Bugfix: Fix stale dir sizes on rename

vdavid · vdavid · commit 10213d8450c2 · 2026-03-20T12:33:13.000+01:00
Renames produced two writer messages (`DeleteEntryById` + `UpsertEntryV2`) but `emit_dir_updated` fired immediately after enqueuing them, before the writer committed both. The UI read intermediate `dir_stats` (delete applied, insert not yet), showing wrong sizes.

- Add `WriteMessage::EmitDirUpdated(Vec&lt;String&gt;)` — the writer emits the notification after processing all prior messages in the batch, guaranteeing the UI only sees the final committed state
- Replace direct `reconciler::emit_dir_updated()` calls in `run_live_event_loop` with `writer.send(EmitDirUpdated(...))` (both the flush-tick and channel-closed paths)
- No flush roundtrip, no event loop blocking — just FIFO message ordering
diff --git a/apps/desktop/src-tauri/src/indexing/CLAUDE.md b/apps/desktop/src-tauri/src/indexing/CLAUDE.md
@@ -52,7 +52,7 @@ Live mode:
   |-- macOS: FSEvents -> reconciler (resolve_path -> entry IDs) -> UpsertEntryV2/DeleteEntryById/DeleteSubtreeById -> writer -> SQLite
   |-- Linux: inotify (via notify crate) -> same pipeline
   |-- Reconciler and event loops hold a read connection for integer-keyed path resolution
-  |-- Events deduplicated by normalized path in HashMap, flushed every 1s via index-dir-updated event
+  |-- Events deduplicated by normalized path in HashMap, flushed every 1s, writer flush before emit ensures atomic dir_stats
   |
 Enrichment (every get_file_range call):
   |-- enrich_entries_with_index() -> resolve parent dir → id (one tree walk)
@@ -153,6 +153,8 @@ Key test files are alongside each module (test functions within `#[cfg(test)]` b
 
 **INSERT OR REPLACE on a populated DB is catastrophically slow**: The `platform_case` collation (NFD + case fold on macOS) runs for every B-tree comparison during unique index lookups. On an empty DB a full scan takes ~2.5 min; on a populated DB with 5.5M entries the same scan takes ~30 min because each `INSERT OR REPLACE` triggers ~20 collation calls to traverse the B-tree. `start_scan()` truncates `entries` and `dir_stats` via `TruncateData` + `flush_blocking()` before every scan to avoid this. Additionally, without truncation, old rows accumulate as orphaned subtrees (3-4x DB bloat per scan cycle) because `INSERT OR REPLACE` only deduplicates at the root level.
 
+**Live event notifications are enqueued as writer messages**: `emit_dir_updated` is sent via `WriteMessage::EmitDirUpdated(paths)` instead of being called directly from the event loop. Since the writer processes messages in order, the notification fires only after all prior writes (deletes, upserts, deltas) from the same batch are committed. Without this, multi-message operations (e.g. rename = `DeleteEntryById` + `UpsertEntryV2`) show intermediate `dir_stats` to the UI (e.g. parent dir size drops by the renamed file's size). The replay path uses a different approach (explicit flush + batched emit) because it accumulates paths over thousands of events.
+
 **Cold-start replay enters live mode immediately after flush**: `run_replay_event_loop` (in `event_loop.rs`) doesn't emit `index-dir-updated` during Phase 1 (replay). It collects affected paths, flushes the writer (ensuring all writes are committed), emits a single batched notification, and enters live mode right away (~100ms from startup). Post-replay verification (`verify_affected_dirs`) runs in a background task (`run_background_verification`) concurrently with live events. This is safe because the writer serializes all writes. Any corrections found by verification are emitted as a separate `index-dir-updated` batch.
 
 **FSEvents `item_removed` must be verified against disk**: macOS FSEvents can deliver `item_removed` for paths that still exist (atomic file swaps by editors/git, coalesced events with OR'd flags, `merge_fs_events` discarding `item_created` when `item_removed` is present). `handle_removal()` stats the path before deleting: if the file exists, it delegates to `handle_creation_or_modification()` (upsert) instead. Without this, false removals progressively delete live entries from the DB — especially damaging for directories since `DeleteSubtreeById` is recursive. `handle_creation_or_modification()` already has the inverse pattern: if stat fails, it deletes.
diff --git a/apps/desktop/src-tauri/src/indexing/event_loop.rs b/apps/desktop/src-tauri/src/indexing/event_loop.rs
@@ -188,7 +188,9 @@ pub(super) async fn run_live_event_loop(
                             &writer, &mut pending_paths,
                         );
                         if !pending_paths.is_empty() {
-                            reconciler::emit_dir_updated(&app, pending_paths.drain().collect());
+                            let _ = writer.send(WriteMessage::EmitDirUpdated(
+                                pending_paths.drain().collect(),
+                            ));
                         }
                         break;
                     }
@@ -221,7 +223,13 @@ pub(super) async fn run_live_event_loop(
                     &writer, &mut pending_paths,
                 );
                 if !pending_paths.is_empty() {
-                    reconciler::emit_dir_updated(&app, pending_paths.drain().collect());
+                    // Enqueue the notification as a writer message so it fires
+                    // after all prior writes (deletes, upserts, deltas) commit.
+                    // Without this, multi-message operations (e.g. rename =
+                    // delete + insert) show intermediate dir_stats to the UI.
+                    let _ = writer.send(WriteMessage::EmitDirUpdated(
+                        pending_paths.drain().collect(),
+                    ));
                 }
             }
         }
diff --git a/apps/desktop/src-tauri/src/indexing/writer.rs b/apps/desktop/src-tauri/src/indexing/writer.rs
@@ -115,6 +115,10 @@ pub enum WriteMessage {
     /// Periodic housekeeping: reclaim free pages from deletes/rescans.
     /// Sent by a background timer, not counted in WriterStats.
     IncrementalVacuum,
+    /// Emit `index-dir-updated` for the given paths. Enqueued after a batch
+    /// of writes so the UI notification fires only after all prior messages
+    /// (deletes, upserts, deltas) are committed.
+    EmitDirUpdated(Vec<String>),
     /// Shut down the writer thread.
     Shutdown,
 }
@@ -782,6 +786,11 @@ fn process_message(
                 Err(e) => log::warn!("Writer: freelist_count query failed: {e}"),
             }
         }
+        WriteMessage::EmitDirUpdated(paths) => {
+            if let Some(app) = app_handle {
+                crate::indexing::reconciler::emit_dir_updated(app, paths);
+            }
+        }
         WriteMessage::Shutdown => return true,
     }
     false

Original file line number	Diff line number	Diff line change
`@@ -188,7 +188,9 @@ pub(super) async fn run_live_event_loop(`
`188`	`188`	`&writer, &mut pending_paths,`
`189`	`189`	`);`
`190`	`190`	`if !pending_paths.is_empty() {`
`191`		`- reconciler::emit_dir_updated(&app, pending_paths.drain().collect());`
	`191`	`+ let _ = writer.send(WriteMessage::EmitDirUpdated(`
	`192`	`+ pending_paths.drain().collect(),`
	`193`	`+ ));`
`192`	`194`	`}`
`193`	`195`	`break;`
`194`	`196`	`}`
`@@ -221,7 +223,13 @@ pub(super) async fn run_live_event_loop(`
`221`	`223`	`&writer, &mut pending_paths,`
`222`	`224`	`);`
`223`	`225`	`if !pending_paths.is_empty() {`
`224`		`- reconciler::emit_dir_updated(&app, pending_paths.drain().collect());`
	`226`	`+ // Enqueue the notification as a writer message so it fires`
	`227`	`+ // after all prior writes (deletes, upserts, deltas) commit.`
	`228`	`+ // Without this, multi-message operations (e.g. rename =`
	`229`	`+ // delete + insert) show intermediate dir_stats to the UI.`
	`230`	`+ let _ = writer.send(WriteMessage::EmitDirUpdated(`
	`231`	`+ pending_paths.drain().collect(),`
	`232`	`+ ));`
`225`	`233`	`}`
`226`	`234`	`}`
`227`	`235`	`}`
Original file line number	Diff line number	Diff line change
`@@ -115,6 +115,10 @@ pub enum WriteMessage {`
`115`	`115`	`/// Periodic housekeeping: reclaim free pages from deletes/rescans.`
`116`	`116`	`/// Sent by a background timer, not counted in WriterStats.`
`117`	`117`	`IncrementalVacuum,`
	`118`	+ /// Emit `index-dir-updated` for the given paths. Enqueued after a batch
	`119`	`+ /// of writes so the UI notification fires only after all prior messages`
	`120`	`+ /// (deletes, upserts, deltas) are committed.`
	`121`	`+ EmitDirUpdated(Vec<String>),`
`118`	`122`	`/// Shut down the writer thread.`
`119`	`123`	`Shutdown,`
`120`	`124`	`}`
`@@ -782,6 +786,11 @@ fn process_message(`
`782`	`786`	`Err(e) => log::warn!("Writer: freelist_count query failed: {e}"),`
`783`	`787`	`}`
`784`	`788`	`}`
	`789`	`+ WriteMessage::EmitDirUpdated(paths) => {`
	`790`	`+ if let Some(app) = app_handle {`
	`791`	`+ crate::indexing::reconciler::emit_dir_updated(app, paths);`
	`792`	`+ }`
	`793`	`+ }`
`785`	`794`	`WriteMessage::Shutdown => return true,`
`786`	`795`	`}`
`787`	`796`	`false`