Indexing: Add reconciler tests, fix dir→file orphan bug

- Add 9 unit tests for `reconciler.rs` and `event_loop.rs` covering FSEvents edge cases: atomic swaps, `MustScanSubDirs` preservation, false directory removal, `merge_fs_events` flag priority, and multi-level `reconcile_subtree`
- Fix latent bug: `reconcile_subtree` now sends `DeleteSubtreeById` before upserting when a directory is replaced by a file, preventing orphaned children
- Replace `thread::sleep`-based sync with `flush_blocking()` in 6 pre-existing tests, remove 9 unnecessary post-shutdown sleeps

Author: vdavid

apps/desktop/src-tauri/src/indexing/CLAUDE.md

@@ -167,6 +167,8 @@ Key test files are alongside each module (test functions within `#[cfg(test)]` b
 
 **ScanContext maps scan root to ROOT_ID**: Both `scan_volume` and `scan_subtree` create a `ScanContext` that maps the scan root directory to `ROOT_ID` (1). This means all top-level entries under any scan root get `parent_id = ROOT_ID` in the DB. For subtree scans, the root is resolved to its existing entry ID (not ROOT_ID), and `DeleteDescendantsById` is sent before the scan starts. The `ScanContext` opens a temporary read connection to the DB to fetch `next_id` via `get_next_id()`.
 
+**Reconciler must delete old subtree on dir-to-file type changes**: When `reconcile_subtree` matches a filesystem entry to a DB entry by name, it must check if `is_directory` changed. If a directory became a file, `DeleteSubtreeById` must be sent before `UpsertEntryV2`. Without this, `INSERT OR REPLACE` keeps the same row ID (same `parent_id + name`), and the old directory's children become logical orphans — entries parented by a file.
+
 **Never use `INSERT OR REPLACE` on entries without deleting descendants first**: `INSERT OR REPLACE` on the `idx_parent_name` unique index silently deletes the old row and inserts a new one with a new ID. This orphans all children (their `parent_id` points to the deleted old ID) and orphans the old `dir_stats` row. The scanner's `insert_entries_v2_batch` still uses `INSERT OR REPLACE` as a safety net, but it's always preceded by `DeleteDescendantsById` for subtree scans, so no conflicts should occur in practice.
 
 **IndexWriter exposes `db_path()`**: The scanner needs the DB path to open a temporary connection for `ScanContext::new()`. This path is stored on the `IndexWriter` handle and accessible via `db_path()`. The temporary connection is short-lived (only used to read `MAX(id)`).

apps/desktop/src-tauri/src/indexing/event_loop.rs

@@ -927,3 +927,114 @@ fn verify_affected_dirs(affected_paths: &HashSet<String>, writer: &IndexWriter)
         new_dir_paths,
     }
 }
+
+// ── Tests ────────────────────────────────────────────────────────────
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn make_event(path: &str, event_id: u64, flags: watcher::FsEventFlags) -> watcher::FsChangeEvent {
+        watcher::FsChangeEvent {
+            path: path.to_string(),
+            event_id,
+            flags,
+        }
+    }
+
+    /// Merging created+removed: `item_removed` wins (priority-based merge),
+    /// dropping `item_created`. The reconciler's stat-before-delete in
+    /// `handle_removal` compensates: if the file still exists on disk, it
+    /// upserts instead of deleting. Regression coverage for f0c225f.
+    #[test]
+    fn merge_created_then_removed_prioritizes_removed() {
+        let created = make_event(
+            "/test/file.txt",
+            100,
+            watcher::FsEventFlags {
+                item_created: true,
+                item_is_file: true,
+                ..Default::default()
+            },
+        );
+        let removed = make_event(
+            "/test/file.txt",
+            200,
+            watcher::FsEventFlags {
+                item_removed: true,
+                item_is_file: true,
+                ..Default::default()
+            },
+        );
+
+        let merged = merge_fs_events(&created, &removed);
+
+        assert!(merged.flags.item_removed, "item_removed should be set");
+        assert!(!merged.flags.item_created, "item_created is dropped — removed wins");
+        assert!(merged.flags.item_is_file, "item_is_file should be preserved");
+        assert_eq!(merged.event_id, 200, "higher event_id should be kept");
+    }
+
+    /// Same as above but with events in reverse order: removed first, then
+    /// created. `item_removed` still wins.
+    #[test]
+    fn merge_removed_then_created_prioritizes_removed() {
+        let removed = make_event(
+            "/test/file.txt",
+            100,
+            watcher::FsEventFlags {
+                item_removed: true,
+                item_is_file: true,
+                ..Default::default()
+            },
+        );
+        let created = make_event(
+            "/test/file.txt",
+            200,
+            watcher::FsEventFlags {
+                item_created: true,
+                item_is_file: true,
+                ..Default::default()
+            },
+        );
+
+        let merged = merge_fs_events(&removed, &created);
+
+        assert!(merged.flags.item_removed, "item_removed should be set");
+        assert!(!merged.flags.item_created, "item_created is dropped — removed wins");
+        assert!(merged.flags.item_is_file, "item_is_file should be preserved");
+        assert_eq!(merged.event_id, 200, "higher event_id should be kept");
+    }
+
+    /// When merging, the higher event_id should always win regardless of
+    /// which event is "existing" vs "incoming".
+    #[test]
+    fn merge_keeps_higher_event_id() {
+        let older = make_event(
+            "/test/file.txt",
+            300,
+            watcher::FsEventFlags {
+                item_modified: true,
+                item_is_file: true,
+                ..Default::default()
+            },
+        );
+        let newer = make_event(
+            "/test/file.txt",
+            100,
+            watcher::FsEventFlags {
+                item_modified: true,
+                item_is_file: true,
+                ..Default::default()
+            },
+        );
+
+        // existing=older (300), incoming=newer (100)
+        let merged = merge_fs_events(&older, &newer);
+        assert_eq!(merged.event_id, 300, "higher event_id should be kept");
+
+        // existing=newer (100), incoming=older (300)
+        let merged = merge_fs_events(&newer, &older);
+        assert_eq!(merged.event_id, 300, "higher event_id should be kept");
+    }
+}