Drive indexing: fix bg scan_subtree failures

Two bugs in `run_background_verification` caused `scan_subtree` to fail for every newly discovered directory:

1. `verify_affected_dirs` sends `UpsertEntryV2` for new dirs, but thosewrites were still queued when `scan_subtree` tried to resolve the path. Fix: flush the writer before starting subtree scans.
2. `ScanContext::new` called `ensure_root_sentinel` (a write) on a connection that contended with the writer thread's write lock, causing "database is locked" after a 5s timeout. Fix: skip the sentinel for subtree scans (it already exists) and use a read-only connection.

Also adds `IndexStore::open_read_connection` for WAL-mode read-only access.

Author: vdavid

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

@@ -1210,6 +1210,13 @@ async fn run_background_verification(
     // Scan newly discovered directories (inserts children + computes subtree aggregates).
     // Skip excluded paths (system dirs like /System, /dev) that aren't in the index.
     if !verify_result.new_dir_paths.is_empty() {
+        // Flush first: verify_affected_dirs sent UpsertEntryV2 for each new dir, but those
+        // writes are still queued. scan_subtree opens a read connection to resolve the dir's
+        // path → entry_id, which fails if the entry isn't committed yet.
+        if let Err(e) = writer.flush().await {
+            log::warn!("Background verification pre-scan flush failed: {e}");
+        }
+
         let cancelled = AtomicBool::new(false);
         for dir_path in &verify_result.new_dir_paths {
             if scanner::should_exclude(dir_path) {

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

@@ -259,11 +259,16 @@ fn run_scan(
     let mut total_dirs: u64 = 0;
 
     // Initialize the scan context: seed root mapping and get next_id from DB.
-    // We need a temporary read connection to fetch next_id. The writer thread
-    // owns the write connection, but we only need a read here.
+    // Volume-root scans need a write connection (to create the root sentinel).
+    // Subtree scans only read (next_id + resolve_path), so use a read connection
+    // to avoid contending with the writer thread's write lock.
     let mut scan_ctx = {
         let db_path = writer.db_path();
-        let conn = IndexStore::open_write_connection(&db_path).map_err(|e| ScanError::WriterSend(e.to_string()))?;
+        let conn = if is_volume_root {
+            IndexStore::open_write_connection(&db_path).map_err(|e| ScanError::WriterSend(e.to_string()))?
+        } else {
+            IndexStore::open_read_connection(&db_path).map_err(|e| ScanError::WriterSend(e.to_string()))?
+        };
         conn.busy_timeout(std::time::Duration::from_secs(5))
             .map_err(|e| ScanError::WriterSend(e.to_string()))?;
         ScanContext::new(&conn, root, is_volume_root).map_err(|e| ScanError::WriterSend(e.to_string()))?

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

@@ -86,8 +86,12 @@ impl ScanContext {
     /// Returns an error if the root isn't indexed yet (for example, a micro-scan
     /// racing with an ongoing full scan — the full scan will cover it).
     pub fn new(conn: &Connection, root: &Path, is_volume_root: bool) -> Result<Self, IndexStoreError> {
-        // Ensure the root sentinel exists
-        ensure_root_sentinel(conn)?;
+        // Only volume-root scans need to create the sentinel — subtree scans
+        // run after the full scan has already inserted it, and their connection
+        // may be read-only or contending with the writer thread's write lock.
+        if is_volume_root {
+            ensure_root_sentinel(conn)?;
+        }
 
         let next_id = IndexStore::get_next_id(conn)?;
 
@@ -436,6 +440,16 @@ impl IndexStore {
         Ok(conn)
     }
 
+    /// Open a read-only connection with WAL pragmas and `platform_case` collation.
+    ///
+    /// Never contends with the writer thread's write lock.
+    pub fn open_read_connection(db_path: &Path) -> Result<Connection, IndexStoreError> {
+        let conn = Connection::open_with_flags(db_path, rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY)?;
+        register_platform_case_collation(&conn)?;
+        apply_pragmas(&conn)?;
+        Ok(conn)
+    }
+
     /// Read all meta keys and return the index status.
     pub fn get_index_status(&self) -> Result<IndexStatus, IndexStoreError> {
         Ok(IndexStatus {