Search: span every indexed volume, not just the root drive

Filename search was root-only by construction: it loaded the root drive's index and pinned `SEARCH_VOLUME_ID = "root"`, so searching a scope on a NAS/SMB share or external drive silently returned "No files found" even when that volume's `index-<id>.db` held millions of entries. Search now routes a scope to its owning volume(s) and, unscoped, fans out across every volume with a persisted index, merging the ranked results.

- **Per-volume arenas (`search/volumes.rs`).** Generalized the global `SEARCH_INDEX` singleton into a per-volume registry. `ensure_volume(id)` lazily loads and caches each volume's arena: root from the live `get_read_pool()`, a non-root volume read-only straight from `index-<id>.db` on disk — deliberately NOT via `INDEX_REGISTRY`, so an ejected/unmounted drive's index is still searchable. The mount root comes from the DB's `volume_path` meta (known offline). Dialog-scoped idle/backstop timers drop every arena at once to reclaim RAM; a long root pre-load stays cancelable.
- **Honest coverage signal.** A scope pointing at a volume with no persisted index no longer reads as empty success: `run_blocking` collects those paths into the new typed `SearchResult.uncovered_scopes` (callers branch on emptiness, never string-match), and the UI/MCP render "Cmdr hasn't indexed X yet" instead of "no files found". Partial coverage still returns the covered volumes' hits alongside the note.
- **Mount-relative path spaces.** A non-root index is rooted at its mount, so it stores mount-relative paths. Two mirror transforms bridge the gap: `engine::search_ranked` PREFIXES the mount root onto reconstructed paths (a NAS result reports `/Volumes/naspi/...` and opens in a pane), and `query::resolve_include_path_ids` STRIPS the mount root from scope include paths before `resolve_path`.
- **Cross-volume merge.** The engine returns ranked entries carrying their `RankKey` (match-quality band + importance-boosted recency + id — all volume-independent), so `execute.rs` k-way-merges each volume's already-ranked slice with one global sort, sums per-volume totals, and fills directory sizes per volume from the owning pool.
- **Per-volume importance weights.** Weights load per volume into a `WEIGHTS` map: root stays live via the recompute subscriber, a non-root volume takes a load-time snapshot. A volume with no `importance-<id>.db` degrades to match-quality + recency (the existing contract).
- **Shared runner for dialog + MCP.** `commands/search.rs` and `mcp/executor/search.rs` both route through `execute::run_blocking`; the MCP `search`/`ai_search` handlers surface the uncovered-scope note. Removed the now-redundant per-caller load/postprocess paths.
- **Supporting exposure.** Made `volume_id_for_local_path` `pub(crate)` (re-exported from `indexing`); un-gated `IndexStore::get_meta` (was test-only) so the loader can read `volume_path`.

Tests: cross-volume merge ordering (exact match on one volume beats a prefix match on another), mount-path prefixing, the directory-size post-filter, scope→volume grouping, per-volume load from a persisted DB with mount root from meta, the missing-DB honesty signal, per-volume and missing importance weights, and recompute-notify weight refresh.

`file-length-allowlist.json` is a check-run shrink-wrap: `query.rs` dropped below 800 lines after its dir-size helpers moved to `execute.rs`, so its entry was auto-removed.

Author: vdavid

apps/desktop/src-tauri/src/commands/search.rs

@@ -2,22 +2,15 @@
 //!
 //! Thin wrappers around `search` module functions, exposed to the frontend via Tauri commands.
 
-use std::sync::Arc;
-use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::atomic::Ordering;
 
 use serde::Serialize;
 
 use genai::chat::ChatOptions;
 
 use crate::ai::AiTranslateError;
-use crate::indexing::get_read_pool;
-use crate::search::{
-    self, DIALOG_OPEN, ParsedScope, SEARCH_INDEX, SearchIndexState, SearchQuery, SearchResult, drop_search_index,
-    fill_directory_sizes, start_backstop_timer, start_idle_timer, touch_activity,
-};
-
-use crate::indexing::writer::WRITER_GENERATION;
-use crate::pluralize::pluralize_with;
+use crate::search::{self, ParsedScope, SearchQuery, SearchResult, VolumeLoad};
+
 use crate::search::ai::{self, query_builder as ai_query_builder};
 use crate::search::history::{self, HistoryEntry};
 
@@ -37,103 +30,42 @@ pub struct SearchIndexReadyEvent {
     pub entry_count: u64,
 }
 
-/// Called when the search dialog opens. Starts loading the index in the background.
-/// Returns immediately with `{ ready, entryCount }`.
+/// Called when the search dialog opens. Pre-loads the ROOT index in the background
+/// (the common case; scoped volumes load lazily on their first query). Returns
+/// immediately with `{ ready, entryCount }`; the dialog flips to ready on the
+/// emitted `search-index-ready` event.
 #[tauri::command]
 #[specta::specta]
 pub async fn prepare_search_index(app: tauri::AppHandle) -> Result<PrepareResult, String> {
-    touch_activity();
-    DIALOG_OPEN.store(true, Ordering::Relaxed);
-
-    // Check if already loaded and fresh
-    {
-        let mut guard = SEARCH_INDEX.lock().map_err(|e| format!("{e}"))?;
-        if let Some(ref mut state) = *guard {
-            let current_gen = WRITER_GENERATION.load(Ordering::Relaxed);
-            if state.index.generation == current_gen {
-                // Cancel any pending idle timer
-                if let Some(ref h) = state.idle_timer {
-                    h.abort();
-                }
-                state.idle_timer = None;
-                // Reset backstop timer; the previous session's timer may still
-                // be ticking and could fire while the dialog is open.
-                if let Some(ref h) = state.backstop_timer {
-                    h.abort();
-                }
-                state.backstop_timer = Some(start_backstop_timer());
-                return Ok(PrepareResult {
-                    ready: true,
-                    entry_count: state.index.entries.len() as u64,
-                });
-            }
-            // Stale: drop and reload below
-        }
-    }
-
-    // Drop stale index if any
-    drop_search_index();
-
-    let pool = get_read_pool().ok_or_else(|| "Index not available".to_string())?;
-    let cancel = Arc::new(AtomicBool::new(false));
-    let cancel_clone = cancel.clone();
-
-    // Store a "loading" sentinel with the cancel flag BEFORE spawning the task.
-    // This closes the race window where release_search_index can't cancel the
-    // load between checking the lock and the background task starting.
-    {
-        let mut guard = SEARCH_INDEX.lock().map_err(|e| format!("{e}"))?;
-        if guard.is_some() {
-            return Ok(PrepareResult {
-                ready: false,
-                entry_count: 0,
-            });
-        }
-        *guard = Some(SearchIndexState {
-            index: Arc::new(search::SearchIndex::empty()),
-            idle_timer: None,
-            backstop_timer: None,
-            load_cancel: Some(cancel.clone()),
+    use crate::indexing::ROOT_VOLUME_ID;
+
+    search::touch_activity();
+    search::DIALOG_OPEN.store(true, Ordering::Relaxed);
+    search::cancel_idle_timer();
+
+    // Fast path: root already warm and fresh.
+    if let Some(v) = search::get_loaded(ROOT_VOLUME_ID) {
+        // A prior session's backstop timer may still be ticking; reset it so it
+        // can't fire while the dialog is open.
+        search::reset_backstop_timer();
+        return Ok(PrepareResult {
+            ready: true,
+            entry_count: v.index.entries.len() as u64,
         });
     }
 
-    // Spawn the load in a background task
+    // Load root in the background so the dialog doesn't block on a multi-second scan.
     let app_clone = app.clone();
     tauri::async_runtime::spawn(async move {
-        let result = tokio::task::spawn_blocking(move || search::load_search_index(&pool, &cancel_clone)).await;
-
-        match result {
-            Ok(Ok(index)) => {
-                let entry_count = index.entries.len() as u64;
-                let backstop = start_backstop_timer();
-                let mut guard = match SEARCH_INDEX.lock() {
-                    Ok(g) => g,
-                    Err(e) => e.into_inner(),
-                };
-                *guard = Some(SearchIndexState {
-                    index: Arc::new(index),
-                    idle_timer: None,
-                    backstop_timer: Some(backstop),
-                    load_cancel: Some(cancel),
-                });
-                log::debug!(
-                    "Search index ready: {}",
-                    pluralize_with(entry_count, "entry", "entries")
-                );
-                // Emit event to frontend
+        match tokio::task::spawn_blocking(|| search::ensure_volume(ROOT_VOLUME_ID)).await {
+            Ok(VolumeLoad::Loaded(v)) => {
+                let entry_count = v.index.entries.len() as u64;
                 use tauri_specta::Event;
                 let _ = SearchIndexReadyEvent { entry_count }.emit(&app_clone);
             }
-            Ok(Err(e)) => {
-                if e.contains("cancelled") {
-                    log::debug!("Search index load cancelled");
-                } else {
-                    log::warn!("Search index load failed: {e}");
-                }
-            }
-            Err(e) => {
-                log::warn!("Search index load task panicked: {e}");
-            }
+            Ok(VolumeLoad::NotIndexed) => log::debug!("prepare_search_index: root index not available yet"),
+            Ok(VolumeLoad::Failed(e)) => log::warn!("prepare_search_index: root load failed: {e}"),
+            Err(e) => log::warn!("prepare_search_index: load task panicked: {e}"),
         }
     });
 
@@ -143,106 +75,28 @@ pub async fn prepare_search_index(app: tauri::AppHandle) -> Result<PrepareResult
     })
 }
 
-/// Search the in-memory index. Returns empty if not loaded yet.
+/// Search across the scoped volume(s), or every indexed volume when unscoped.
+/// Returns empty (no coverage gaps) when nothing is indexed yet.
 #[tauri::command]
 #[specta::specta]
-pub async fn search_files(mut query: SearchQuery) -> Result<SearchResult, String> {
-    touch_activity();
-
-    let index = {
-        let guard = SEARCH_INDEX.lock().map_err(|e| format!("{e}"))?;
-        match guard.as_ref() {
-            Some(state) => {
-                // Cancel any idle timer since we're actively searching
-                if let Some(ref h) = state.idle_timer {
-                    h.abort();
-                }
-                state.index.clone()
-            }
-            None => {
-                return Ok(SearchResult {
-                    entries: Vec::new(),
-                    total_count: 0,
-                });
-            }
-        }
-    };
-
-    // Resolve include paths to entry IDs via SQLite (microseconds, not 20s)
-    if query.include_paths.as_ref().is_some_and(|p| !p.is_empty())
-        && let Some(pool) = get_read_pool()
-    {
-        search::resolve_include_paths(&mut query, &pool);
-    }
-
-    // Load the per-volume importance weight map (empty when unavailable, which
-    // degrades ranking to match-quality + recency — today's behavior).
-    let weights = search::importance_weights_snapshot();
+pub async fn search_files(query: SearchQuery) -> Result<SearchResult, String> {
+    search::touch_activity();
+    search::cancel_idle_timer();
 
-    // Run search on a blocking thread (rayon parallel scan)
-    let query_clone = query.clone();
-    let index_clone = index.clone();
-    let mut result = tokio::task::spawn_blocking(move || search::search(&index_clone, &query_clone, &weights))
+    // Route + load + scan + merge on a blocking thread (opens DBs, rayon scan).
+    tokio::task::spawn_blocking(move || search::run_blocking(query))
         .await
-        .map_err(|e| format!("Search task failed: {e}"))??;
-
-    // Fill directory sizes from the DB
-    if result.entries.iter().any(|e| e.is_directory)
-        && let Some(pool) = get_read_pool()
-    {
-        fill_directory_sizes(&mut result, &pool);
-    }
-
-    // Post-filter directories by size (their sizes come from dir_stats, filled
-    // above, so engine::search couldn't apply the size filter to them).
-    search::filter_directories_by_size(&mut result, &query);
-
-    // Truncate to the originally requested limit
-    let limit = query.limit.min(1000) as usize;
-    if result.entries.len() > limit {
-        result.entries.truncate(limit);
-    }
-
-    // Check generation staleness; trigger background reload if needed
-    let current_gen = WRITER_GENERATION.load(Ordering::Relaxed);
-    if index.generation != current_gen {
-        log::debug!(
-            "Search index stale (gen {} vs {}), will reload on next prepare",
-            index.generation,
-            current_gen
-        );
-    }
-
-    Ok(result)
+        .map_err(|e| format!("Search task failed: {e}"))?
 }
 
-/// Called when the search dialog closes. Starts the idle timer and
-/// cancels any in-progress load.
+/// Called when the search dialog closes. Starts the idle timer and cancels any
+/// in-progress index load.
 #[tauri::command]
 #[specta::specta]
 pub async fn release_search_index() -> Result<(), String> {
-    DIALOG_OPEN.store(false, Ordering::Relaxed);
-    let mut guard = SEARCH_INDEX.lock().map_err(|e| format!("{e}"))?;
-
-    // Set cancellation flag on any in-progress load
-    if let Some(ref state) = *guard
-        && let Some(ref cancel) = state.load_cancel
-    {
-        cancel.store(true, Ordering::Relaxed);
-    }
-
-    // Start idle timer
-    if guard.is_some() {
-        let idle_handle = start_idle_timer();
-        if let Some(ref mut state) = *guard {
-            // Cancel previous idle timer if any
-            if let Some(ref h) = state.idle_timer {
-                h.abort();
-            }
-            state.idle_timer = Some(idle_handle);
-        }
-    }
-
+    search::DIALOG_OPEN.store(false, Ordering::Relaxed);
+    search::cancel_active_loads();
+    search::start_idle_timer();
     Ok(())
 }
 

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

@@ -71,9 +71,10 @@ impl ReadPool {
     }
 }
 
-/// The root volume's read pool. The fast handle for local-disk enrichment,
-/// search (D7 keeps search local-only), and IPC dir-stats. The root
-/// `IndexInstance` shares this same `Arc`, so registry and read path can't drift.
+/// The root volume's read pool. The fast handle for local-disk enrichment, root
+/// filename search, and IPC dir-stats. The root `IndexInstance` shares this same
+/// `Arc`, so registry and read path can't drift. (Non-root filename search opens
+/// its own read-only pool from the volume's `index-{id}.db`; see `search/volumes.rs`.)
 ///
 /// Root is special-cased to this global (rather than read from the registry)
 /// for two reasons: search reads it on the hot path, and the indexing tests

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

@@ -85,7 +85,7 @@ pub use queries::{
     get_debug_status, get_dir_stats, get_dir_stats_batch, get_status, get_volume_index_status,
     get_volume_index_status_for_path, list_dir_children,
 };
-pub(crate) use routing::{IndexPathSpace, index_read_path};
+pub(crate) use routing::{IndexPathSpace, index_read_path, volume_id_for_local_path};
 pub(crate) use state::ROOT_VOLUME_ID;
 pub(crate) use state::get_freshness;
 #[cfg(test)]

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

@@ -44,7 +44,7 @@ use super::store::{self, IndexStoreError};
 ///   [`external_mount_volume_id_for_path`].
 /// - **Everything else** (the boot disk, and cloud-drive folders in the home dir
 ///   that `root`'s index owns) → `root`.
-pub(super) fn volume_id_for_local_path(path: &str) -> VolumeId {
+pub(crate) fn volume_id_for_local_path(path: &str) -> VolumeId {
     #[cfg(any(target_os = "macos", target_os = "linux"))]
     if let Some(smb_id) = super::smb_index::smb_volume_id_for_path(path) {
         return smb_id;

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

@@ -19,8 +19,8 @@ impl IndexStore {
         Ok(())
     }
 
-    /// Get a single meta value by key.
-    #[cfg(test)]
+    /// Get a single meta value by key. Read by the search loader to recover a
+    /// volume's `volume_path` (mount root) from its persisted index DB.
     pub fn get_meta(conn: &Connection, key: &str) -> Result<Option<String>, IndexStoreError> {
         Self::read_meta_value(conn, key)
     }