fix(cache): Fix edits not persisting to cache in filtered view mode

Root cause: In handle_commit_result(), the `edits` parameter was the same
list object as `self.data_manager.pending_edits`. When we called
`pending_edits.clear()` BEFORE the cache update, it emptied the `edits`
list (Python passes lists by reference), so the cache update applied
zero edits.

The fix moves `pending_edits.clear()` to AFTER the cache update completes.

Also improved handling when cache tiers can't be loaded in filtered view:
- Previously: silently skipped cache update entirely
- Now: updates whichever tier(s) can be loaded, with detailed logging

Added tests:
- 5 new cache persistence tests in test_cache.py
- 2 new partial cache update tests in test_app_controller.py

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: wesm

moneyflow/app_controller.py

@@ -1651,11 +1651,10 @@ def handle_commit_result(
                     bulk_merchant_renames,
                 )
 
-            # Clear pending edits on success
-            self.data_manager.pending_edits.clear()
-            logger.info("Cleared pending edits")
-
             # Update cache with edited data (if caching is enabled)
+            # NOTE: Must happen BEFORE clearing pending_edits because `edits` parameter
+            # is the same list object (passed by reference), so clearing pending_edits
+            # would empty the edits list before we can use it for cache updates!
             if self.cache_manager and cache_filters:
                 try:
                     if is_filtered_view:
@@ -1664,10 +1663,54 @@ def handle_commit_result(
                         hot_df = self.cache_manager.load_hot_cache()
                         cold_df = self.cache_manager.load_cold_cache()
                         if hot_df is None or cold_df is None:
+                            # This can happen if cache files don't exist, are corrupted,
+                            # or encryption mode changed since they were created.
+                            # We'll try to recover by applying edits to whichever tier
+                            # loaded successfully, and preserve the other.
                             logger.warning(
-                                "Filtered view detected but cache tiers are unavailable; "
-                                "skipping cache update to avoid corruption"
+                                "Filtered view: cache tier(s) unavailable (hot=%s, cold=%s). "
+                                "Attempting partial update to preserve edits.",
+                                hot_df is not None,
+                                cold_df is not None,
                             )
+                            if hot_df is not None:
+                                updated_hot = CommitOrchestrator.apply_edits_to_dataframe(
+                                    hot_df,
+                                    edits,
+                                    self.data_manager.categories,
+                                    self.data_manager.apply_category_groups,
+                                    bulk_merchant_renames,
+                                )
+                                self.cache_manager.save_hot_cache(
+                                    hot_df=updated_hot,
+                                    categories=self.data_manager.categories,
+                                    category_groups=self.data_manager.category_groups,
+                                )
+                                logger.info("Updated hot cache with edits (cold unavailable)")
+                            if cold_df is not None:
+                                updated_cold = CommitOrchestrator.apply_edits_to_dataframe(
+                                    cold_df,
+                                    edits,
+                                    self.data_manager.categories,
+                                    self.data_manager.apply_category_groups,
+                                    bulk_merchant_renames,
+                                )
+                                self.cache_manager.save_cold_cache(cold_df=updated_cold)
+                                logger.info("Updated cold cache with edits (hot unavailable)")
+                            if hot_df is None and cold_df is None:
+                                # Neither tier available - cache is likely corrupted or missing
+                                # Save current view data as last resort
+                                logger.error(
+                                    "Neither cache tier could be loaded! "
+                                    "Saving current view data - historical transactions may be lost."
+                                )
+                                self.cache_manager.save_cache(
+                                    transactions_df=self.data_manager.df,
+                                    categories=self.data_manager.categories,
+                                    category_groups=self.data_manager.category_groups,
+                                    year=cache_filters.get("year"),
+                                    since=cache_filters.get("since"),
+                                )
                         else:
                             logger.info("Filtered view detected - updating cached tiers with edits")
                             updated_hot = CommitOrchestrator.apply_edits_to_dataframe(
@@ -1704,6 +1747,10 @@ def handle_commit_result(
                     # Cache update failed - not critical, just log
                     logger.warning(f"Cache update failed: {e}", exc_info=True)
 
+            # Clear pending edits on success (after cache update to preserve edits list)
+            self.data_manager.pending_edits.clear()
+            logger.info("Cleared pending edits")
+
             # Refresh to show updated data (smooth update)
             # Note: View already restored in app.py before commit started
             logger.debug(

tests/test_app_controller.py

@@ -647,6 +647,123 @@ def save_cache(
         updated_merchant = stub_cache.saved_hot.filter(pl.col("id") == edit_id)["merchant"][0]
         assert updated_merchant == "Edited"
 
+    async def test_filtered_view_partial_cache_update_when_cold_unavailable(self, controller):
+        """When cold cache is unavailable, hot should still be updated."""
+        from moneyflow.state import TransactionEdit
+
+        class StubCacheManager:
+            def __init__(self, hot_df):
+                self._hot_df = hot_df
+                self.saved_hot = None
+                self.saved_cold = None
+                self.saved_full = None
+
+            def load_hot_cache(self):
+                return self._hot_df.clone() if self._hot_df is not None else None
+
+            def load_cold_cache(self):
+                return None  # Simulate cold cache unavailable
+
+            def save_hot_cache(self, hot_df, categories, category_groups):
+                self.saved_hot = hot_df
+
+            def save_cold_cache(self, cold_df):
+                self.saved_cold = cold_df
+
+            def save_cache(
+                self, transactions_df, categories, category_groups, year=None, since=None
+            ):
+                self.saved_full = transactions_df
+
+        full_df = controller.data_manager.df
+        hot_df = full_df.head(3)
+
+        edit_id = hot_df["id"][0]
+        old_merchant = hot_df["merchant"][0]
+        edits = [TransactionEdit(edit_id, "merchant", old_merchant, "Edited", datetime.now())]
+        controller.data_manager.pending_edits = edits.copy()
+        controller.data_manager.df = hot_df.head(1).clone()
+
+        stub_cache = StubCacheManager(hot_df)
+        controller.cache_manager = stub_cache
+
+        saved_state = controller.state.save_view_state()
+        controller.handle_commit_result(
+            success_count=1,
+            failure_count=0,
+            edits=edits,
+            saved_state=saved_state,
+            cache_filters={"year": None, "since": None},
+            is_filtered_view=True,
+        )
+
+        # Hot should be saved with edits, cold should not be touched
+        assert stub_cache.saved_hot is not None, "Hot cache should be updated"
+        assert stub_cache.saved_cold is None, "Cold cache should not be updated (was unavailable)"
+        assert stub_cache.saved_full is None, "Full cache should not be called"
+
+        updated_merchant = stub_cache.saved_hot.filter(pl.col("id") == edit_id)["merchant"][0]
+        assert updated_merchant == "Edited"
+
+    async def test_filtered_view_partial_cache_update_when_hot_unavailable(self, controller):
+        """When hot cache is unavailable, cold should still be updated."""
+        from moneyflow.state import TransactionEdit
+
+        class StubCacheManager:
+            def __init__(self, cold_df):
+                self._cold_df = cold_df
+                self.saved_hot = None
+                self.saved_cold = None
+                self.saved_full = None
+
+            def load_hot_cache(self):
+                return None  # Simulate hot cache unavailable
+
+            def load_cold_cache(self):
+                return self._cold_df.clone() if self._cold_df is not None else None
+
+            def save_hot_cache(self, hot_df, categories, category_groups):
+                self.saved_hot = hot_df
+
+            def save_cold_cache(self, cold_df):
+                self.saved_cold = cold_df
+
+            def save_cache(
+                self, transactions_df, categories, category_groups, year=None, since=None
+            ):
+                self.saved_full = transactions_df
+
+        full_df = controller.data_manager.df
+        cold_df = full_df.tail(3)
+
+        # Edit a transaction that's in cold cache
+        edit_id = cold_df["id"][0]
+        old_merchant = cold_df["merchant"][0]
+        edits = [TransactionEdit(edit_id, "merchant", old_merchant, "ColdEdited", datetime.now())]
+        controller.data_manager.pending_edits = edits.copy()
+        controller.data_manager.df = cold_df.head(1).clone()
+
+        stub_cache = StubCacheManager(cold_df)
+        controller.cache_manager = stub_cache
+
+        saved_state = controller.state.save_view_state()
+        controller.handle_commit_result(
+            success_count=1,
+            failure_count=0,
+            edits=edits,
+            saved_state=saved_state,
+            cache_filters={"year": None, "since": None},
+            is_filtered_view=True,
+        )
+
+        # Cold should be saved with edits, hot should not be touched
+        assert stub_cache.saved_cold is not None, "Cold cache should be updated"
+        assert stub_cache.saved_hot is None, "Hot cache should not be updated (was unavailable)"
+        assert stub_cache.saved_full is None, "Full cache should not be called"
+
+        updated_merchant = stub_cache.saved_cold.filter(pl.col("id") == edit_id)["merchant"][0]
+        assert updated_merchant == "ColdEdited"
+
 
 class TestEditQueueing:
     """

tests/test_cache.py

@@ -1570,3 +1570,146 @@ def test_filter_mtd_scenario(self):
 
         assert len(filtered) == 2
         assert all(d.month == 12 for d in filtered["date"].to_list())
+
+
+class TestCachePersistenceAfterEdits:
+    """
+    Test that edits are actually persisted to cache files.
+
+    This addresses the bug where changes committed to the backend
+    were not persisted to the local cache.
+    """
+
+    def test_save_cache_persists_edits(self, cache_manager, sample_categories, sample_category_groups):
+        """Test that changes to transactions are persisted after save_cache."""
+        # Create initial data
+        df = create_mixed_transactions_df()
+        original_merchant = df.filter(pl.col("id") == df["id"][0])["merchant"][0]
+        cache_manager.save_cache(df, sample_categories, sample_category_groups)
+
+        # Simulate an edit (like what happens after a commit)
+        edited_df = df.with_columns(
+            pl.when(pl.col("id") == df["id"][0])
+            .then(pl.lit("EDITED_MERCHANT"))
+            .otherwise(pl.col("merchant"))
+            .alias("merchant")
+        )
+
+        # Save the edited data
+        cache_manager.save_cache(edited_df, sample_categories, sample_category_groups)
+
+        # Load and verify the edit was persisted
+        result = cache_manager.load_cache()
+        assert result is not None
+        loaded_df, _, _, _ = result
+
+        edited_row = loaded_df.filter(pl.col("id") == df["id"][0])
+        assert len(edited_row) == 1
+        assert edited_row["merchant"][0] == "EDITED_MERCHANT"
+        assert edited_row["merchant"][0] != original_merchant
+
+    def test_save_hot_cache_persists_edits(
+        self, cache_manager, sample_categories, sample_category_groups
+    ):
+        """Test that edits to hot cache are persisted."""
+        # Create initial data with both tiers
+        df = create_mixed_transactions_df()
+        cache_manager.save_cache(df, sample_categories, sample_category_groups)
+
+        # Load the hot cache
+        hot_df = cache_manager.load_hot_cache()
+        assert hot_df is not None
+        assert len(hot_df) > 0
+
+        # Edit a hot transaction
+        hot_id = hot_df["id"][0]
+        edited_hot = hot_df.with_columns(
+            pl.when(pl.col("id") == hot_id)
+            .then(pl.lit("HOT_EDITED"))
+            .otherwise(pl.col("merchant"))
+            .alias("merchant")
+        )
+
+        # Save hot cache only
+        cache_manager.save_hot_cache(edited_hot, sample_categories, sample_category_groups)
+
+        # Load and verify
+        reloaded_hot = cache_manager.load_hot_cache()
+        edited_row = reloaded_hot.filter(pl.col("id") == hot_id)
+        assert edited_row["merchant"][0] == "HOT_EDITED"
+
+        # Verify cold cache is unchanged
+        reloaded_cold = cache_manager.load_cold_cache()
+        assert reloaded_cold is not None
+
+    def test_save_cold_cache_persists_edits(
+        self, cache_manager, sample_categories, sample_category_groups
+    ):
+        """Test that edits to cold cache are persisted."""
+        # Create initial data with both tiers
+        df = create_mixed_transactions_df()
+        cache_manager.save_cache(df, sample_categories, sample_category_groups)
+
+        # Load the cold cache
+        cold_df = cache_manager.load_cold_cache()
+        assert cold_df is not None
+        assert len(cold_df) > 0
+
+        # Edit a cold transaction
+        cold_id = cold_df["id"][0]
+        edited_cold = cold_df.with_columns(
+            pl.when(pl.col("id") == cold_id)
+            .then(pl.lit("COLD_EDITED"))
+            .otherwise(pl.col("merchant"))
+            .alias("merchant")
+        )
+
+        # Save cold cache only
+        cache_manager.save_cold_cache(edited_cold)
+
+        # Load and verify
+        reloaded_cold = cache_manager.load_cold_cache()
+        edited_row = reloaded_cold.filter(pl.col("id") == cold_id)
+        assert edited_row["merchant"][0] == "COLD_EDITED"
+
+        # Verify hot cache is unchanged
+        reloaded_hot = cache_manager.load_hot_cache()
+        assert reloaded_hot is not None
+
+    def test_atomic_write_creates_no_temp_files_on_success(
+        self, cache_manager, sample_categories, sample_category_groups
+    ):
+        """Verify no temp files are left behind after successful saves."""
+        df = create_mixed_transactions_df()
+        cache_manager.save_cache(df, sample_categories, sample_category_groups)
+
+        # Check for leftover temp files
+        cache_dir = cache_manager.cache_dir
+        temp_files = list(cache_dir.glob(".tmp_*"))
+        assert len(temp_files) == 0, f"Temp files left behind: {temp_files}"
+
+    def test_multiple_sequential_saves_persist_correctly(
+        self, cache_manager, sample_categories, sample_category_groups
+    ):
+        """Test that multiple sequential saves all persist correctly."""
+        df = create_mixed_transactions_df()
+        cache_manager.save_cache(df, sample_categories, sample_category_groups)
+
+        # Perform multiple edits and saves
+        for i in range(5):
+            hot_df = cache_manager.load_hot_cache()
+            if hot_df is not None and len(hot_df) > 0:
+                edited_hot = hot_df.with_columns(
+                    pl.when(pl.col("id") == hot_df["id"][0])
+                    .then(pl.lit(f"EDIT_{i}"))
+                    .otherwise(pl.col("merchant"))
+                    .alias("merchant")
+                )
+                cache_manager.save_hot_cache(edited_hot, sample_categories, sample_category_groups)
+
+        # Verify final state
+        final_hot = cache_manager.load_hot_cache()
+        final_row = final_hot.filter(pl.col("id") == df["id"][0])
+        # The merchant should be the last edit
+        if len(final_row) > 0:
+            assert "EDIT_" in final_row["merchant"][0]