From 65e40833b719fa3cd4737dd5c56c7b896e377170 Mon Sep 17 00:00:00 2001
From: Mohamad Yahia <xyzt70@gmail.com>
Date: Sun, 22 Feb 2026 23:56:30 +0400
Subject: [PATCH 01/16] feat: Implement .gitignore-style ignore patterns for
 Preferences

- Added support for .gitignore-style matching semantics in ignore paths.
- Introduced a new IgnoreMatcher to handle ignore patterns and their evaluation.
- Updated the useIgnorePaths hook to include a comprehensive set of default ignore paths.
- Enhanced validation and error messages for ignore paths in the UI.
- Implemented tests to verify the behavior of ignore patterns, including negation and directory pruning.
- Documented ignore pattern semantics and requirements in new markdown files.
---
 Cargo.lock                                    |  68 ++++++++
 cardinal/src-tauri/Cargo.lock                 |  40 +++++
 cardinal/src-tauri/src/commands.rs            | 114 ++++++++++--
 cardinal/src-tauri/src/lib.rs                 |   2 +-
 cardinal/src/App.css                          |  33 ++++
 .../src/components/PreferencesOverlay.tsx     |  22 ++-
 .../__tests__/PreferencesOverlay.test.tsx     |  64 +++++++
 .../hooks/__tests__/useIgnorePaths.test.ts    |  29 +++-
 cardinal/src/hooks/useIgnorePaths.ts          |  74 +++++++-
 cardinal/src/i18n/resources/ar-SA.json        |   2 +-
 cardinal/src/i18n/resources/en-US.json        |   4 +-
 .../src/utils/__tests__/watchRoot.test.ts     |  23 ++-
 cardinal/src/utils/watchRoot.ts               |   4 +
 doc/inner/SUMMARY.md                          |   2 +
 doc/inner/ignore-patterns.md                  | 162 ++++++++++++++++++
 doc/inner/ignore-requirements-implemented.md  |  89 ++++++++++
 fswalk/Cargo.toml                             |   1 +
 fswalk/src/lib.rs                             | 113 ++++++++++--
 fswalk/tests/deep_walk.rs                     | 162 +++++++++++++++++-
 search-cache/src/cache.rs                     | 159 +++++++++++++++--
 .../tests/fsevent_incremental_tests.rs        | 147 +++++++++++++++-
 21 files changed, 1237 insertions(+), 77 deletions(-)
 create mode 100644 doc/inner/ignore-patterns.md
 create mode 100644 doc/inner/ignore-requirements-implemented.md

diff --git a/Cargo.lock b/Cargo.lock
index 6af61aba..60815471 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -118,6 +118,16 @@ dependencies = [
  "objc2",
 ]
 
+[[package]]
+name = "bstr"
+version = "1.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63044e1ae8e69f3b5a92c736ca6269b8d12fa7efe39bf34ddb06d102cf0e2cab"
+dependencies = [
+ "memchr",
+ "serde",
+]
+
 [[package]]
 name = "bumpalo"
 version = "3.19.0"
@@ -414,6 +424,7 @@ name = "fswalk"
 version = "0.1.0"
 dependencies = [
  "enumn",
+ "ignore",
  "memchr",
  "rayon",
  "serde",
@@ -439,6 +450,19 @@ dependencies = [
  "wasip2",
 ]
 
+[[package]]
+name = "globset"
+version = "0.4.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52dfc19153a48bde0cbd630453615c8151bce3a5adfac7a0aebfbf0a1e1f57e3"
+dependencies = [
+ "aho-corasick",
+ "bstr",
+ "log",
+ "regex-automata",
+ "regex-syntax",
+]
+
 [[package]]
 name = "hash32"
 version = "0.2.1"
@@ -505,6 +529,22 @@ dependencies = [
  "cc",
 ]
 
+[[package]]
+name = "ignore"
+version = "0.4.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3d782a365a015e0f5c04902246139249abf769125006fbe7649e2ee88169b4a"
+dependencies = [
+ "crossbeam-deque",
+ "globset",
+ "log",
+ "memchr",
+ "regex-automata",
+ "same-file",
+ "walkdir",
+ "winapi-util",
+]
+
 [[package]]
 name = "indexmap"
 version = "2.12.1"
@@ -1195,6 +1235,15 @@ version = "1.0.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f"
 
+[[package]]
+name = "same-file"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+dependencies = [
+ "winapi-util",
+]
+
 [[package]]
 name = "scopeguard"
 version = "1.2.0"
@@ -1562,6 +1611,16 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65"
 
+[[package]]
+name = "walkdir"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
+dependencies = [
+ "same-file",
+ "winapi-util",
+]
+
 [[package]]
 name = "was"
 version = "0.1.0"
@@ -1642,6 +1701,15 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
 
+[[package]]
+name = "winapi-util"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
+dependencies = [
+ "windows-sys",
+]
+
 [[package]]
 name = "winapi-x86_64-pc-windows-gnu"
 version = "0.4.0"
diff --git a/cardinal/src-tauri/Cargo.lock b/cardinal/src-tauri/Cargo.lock
index 99a28a31..e1494eec 100644
--- a/cardinal/src-tauri/Cargo.lock
+++ b/cardinal/src-tauri/Cargo.lock
@@ -322,6 +322,16 @@ dependencies = [
  "alloc-stdlib",
 ]
 
+[[package]]
+name = "bstr"
+version = "1.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63044e1ae8e69f3b5a92c736ca6269b8d12fa7efe39bf34ddb06d102cf0e2cab"
+dependencies = [
+ "memchr",
+ "serde",
+]
+
 [[package]]
 name = "bumpalo"
 version = "3.19.0"
@@ -1195,6 +1205,7 @@ name = "fswalk"
 version = "0.1.0"
 dependencies = [
  "enumn",
+ "ignore",
  "memchr",
  "rayon",
  "serde",
@@ -1561,6 +1572,19 @@ dependencies = [
  "xkeysym",
 ]
 
+[[package]]
+name = "globset"
+version = "0.4.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52dfc19153a48bde0cbd630453615c8151bce3a5adfac7a0aebfbf0a1e1f57e3"
+dependencies = [
+ "aho-corasick",
+ "bstr",
+ "log",
+ "regex-automata",
+ "regex-syntax",
+]
+
 [[package]]
 name = "gobject-sys"
 version = "0.18.0"
@@ -1928,6 +1952,22 @@ dependencies = [
  "icu_properties",
 ]
 
+[[package]]
+name = "ignore"
+version = "0.4.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3d782a365a015e0f5c04902246139249abf769125006fbe7649e2ee88169b4a"
+dependencies = [
+ "crossbeam-deque",
+ "globset",
+ "log",
+ "memchr",
+ "regex-automata",
+ "same-file",
+ "walkdir",
+ "winapi-util",
+]
+
 [[package]]
 name = "indexmap"
 version = "1.9.3"
diff --git a/cardinal/src-tauri/src/commands.rs b/cardinal/src-tauri/src/commands.rs
index 92878e85..164a9fa4 100644
--- a/cardinal/src-tauri/src/commands.rs
+++ b/cardinal/src-tauri/src/commands.rs
@@ -142,12 +142,7 @@ impl SearchState {
     }
 }
 
-/// Normalizes user-provided path input into an absolute path string.
-///
-/// Expands a leading `~` component using the current `HOME` directory and rejects
-/// non-absolute paths (including relative paths and unsupported `~user` forms).
-/// Returns `Some` absolute path string when valid, otherwise `None`.
-fn normalize_path_input(raw: &str) -> Option<String> {
+fn expand_path_input(raw: &str) -> Option<String> {
     let trimmed = raw.trim();
     if trimmed.is_empty() {
         return None;
@@ -167,12 +162,25 @@ fn normalize_path_input(raw: &str) -> Option<String> {
         }
     }
 
-    let resolved = expanded.into_string();
-    if resolved.starts_with('/') {
-        Some(resolved)
-    } else {
-        None
-    }
+    Some(expanded.into_string())
+}
+
+/// Normalizes user-provided path input into an absolute path string.
+///
+/// Expands a leading `~` component using the current `HOME` directory and rejects
+/// non-absolute paths (including relative paths and unsupported `~user` forms).
+/// Returns `Some` absolute path string when valid, otherwise `None`.
+fn normalize_path_input(raw: &str) -> Option<String> {
+    let resolved = expand_path_input(raw)?;
+    resolved.starts_with('/').then_some(resolved)
+}
+
+/// Normalizes ignore entries.
+///
+/// Keeps raw entries so matching follows gitignore semantics exactly,
+/// including empty lines and comments.
+fn normalize_ignore_path_input(raw: &str) -> String {
+    raw.to_string()
 }
 
 pub(crate) fn normalize_watch_config(
@@ -184,13 +192,7 @@ pub(crate) fn normalize_watch_config(
         .or_else(|| fallback_watch_root.and_then(normalize_path_input))?;
     let mut ignore_paths = ignore_paths
         .into_iter()
-        .filter_map(|path| {
-            let normalized = normalize_path_input(&path);
-            if normalized.is_none() {
-                warn!("Ignoring invalid ignore path: {path:?}");
-            }
-            normalized
-        })
+        .map(|path| normalize_ignore_path_input(&path))
         .collect::<Vec<_>>();
     if !ignore_paths
         .iter()
@@ -540,4 +542,78 @@ mod tests {
         assert_eq!(normalize_path_input("~someone"), None);
         assert_eq!(normalize_path_input("~someone/Documents"), None);
     }
+
+    #[test]
+    fn normalize_ignore_accepts_absolute_paths_and_globs() {
+        assert_eq!(
+            normalize_ignore_path_input("/tmp/cache"),
+            "/tmp/cache".to_string()
+        );
+        assert_eq!(
+            normalize_ignore_path_input("**/node_modules/**"),
+            "**/node_modules/**".to_string()
+        );
+        assert_eq!(
+            normalize_ignore_path_input("build/*.tmp"),
+            "build/*.tmp".to_string()
+        );
+        assert_eq!(normalize_ignore_path_input(".cache"), ".cache".to_string());
+        assert_eq!(
+            normalize_ignore_path_input("Library/Biome/"),
+            "Library/Biome/".to_string()
+        );
+    }
+
+    #[test]
+    fn normalize_ignore_keeps_gitignore_syntax_verbatim() {
+        assert_eq!(
+            normalize_ignore_path_input("!/important.pyc"),
+            "!/important.pyc".to_string()
+        );
+        assert_eq!(
+            normalize_ignore_path_input("# comment"),
+            "# comment".to_string()
+        );
+        assert_eq!(
+            normalize_ignore_path_input("relative/path"),
+            "relative/path".to_string()
+        );
+        assert_eq!(
+            normalize_ignore_path_input("~someone/**"),
+            "~someone/**".to_string()
+        );
+        assert_eq!(
+            normalize_ignore_path_input("../relative/path"),
+            "../relative/path".to_string()
+        );
+    }
+
+    #[test]
+    fn normalize_ignore_keeps_empty_and_whitespace_entries() {
+        assert_eq!(normalize_ignore_path_input(""), String::new());
+        assert_eq!(normalize_ignore_path_input("   "), "   ".to_string());
+    }
+
+    #[test]
+    fn normalize_watch_config_keeps_globs_and_adds_default_ignore_path() {
+        let Some((watch_root, ignore_paths)) = normalize_watch_config(
+            "/",
+            vec![
+                "**/node_modules/**".to_string(),
+                String::new(),
+                "relative/path".to_string(),
+                "/tmp/cache".to_string(),
+            ],
+            None,
+        ) else {
+            panic!("watch config should be valid");
+        };
+
+        assert_eq!(watch_root, "/");
+        assert!(ignore_paths.contains(&"**/node_modules/**".to_string()));
+        assert!(ignore_paths.contains(&String::new()));
+        assert!(ignore_paths.contains(&"relative/path".to_string()));
+        assert!(ignore_paths.contains(&"/tmp/cache".to_string()));
+        assert!(ignore_paths.contains(&DEFAULT_SYSTEM_IGNORE_PATH.to_string()));
+    }
 }
diff --git a/cardinal/src-tauri/src/lib.rs b/cardinal/src-tauri/src/lib.rs
index dc362094..01079e5c 100644
--- a/cardinal/src-tauri/src/lib.rs
+++ b/cardinal/src-tauri/src/lib.rs
@@ -37,7 +37,7 @@ use window_controls::{activate_window, hide_window};
 
 static DB_PATH: OnceCell<PathBuf> = OnceCell::new();
 pub(crate) static LOGIC_START: OnceCell<Sender<LogicStartConfig>> = OnceCell::new();
-pub(crate) const DEFAULT_SYSTEM_IGNORE_PATH: &str = "/System/Volumes/Data";
+pub(crate) const DEFAULT_SYSTEM_IGNORE_PATH: &str = "/System/Volumes/";
 const FSE_LATENCY_SECS: f64 = 0.1;
 
 #[derive(Debug, Clone)]
diff --git a/cardinal/src/App.css b/cardinal/src/App.css
index cbde9aa9..e753836f 100644
--- a/cardinal/src/App.css
+++ b/cardinal/src/App.css
@@ -1675,6 +1675,13 @@ button:active:not(:disabled) {
   text-align: right;
 }
 
+.preferences-control--stack {
+  display: flex;
+  flex-direction: column;
+  align-items: flex-start;
+  text-align: left;
+}
+
 .preferences-field {
   border: 1px solid var(--color-elevated-border, var(--color-border));
   border-radius: 8px;
@@ -1712,6 +1719,32 @@ button:active:not(:disabled) {
   margin-bottom: 0;
 }
 
+.preferences-ignore-reset {
+  margin-top: 8px;
+  border: 1px solid var(--color-elevated-border, var(--color-border));
+  background: transparent;
+  color: var(--color-text-secondary);
+  border-radius: 8px;
+  padding: 6px 10px;
+  font-size: 0.82rem;
+  cursor: pointer;
+  transition:
+    border-color 0.2s ease,
+    color 0.2s ease,
+    background-color 0.2s ease;
+}
+
+.preferences-ignore-reset:hover {
+  border-color: var(--color-accent);
+  color: var(--color-text);
+  background: rgba(var(--color-accent-rgb), 0.08);
+}
+
+.preferences-ignore-reset:focus-visible {
+  outline: 2px solid rgba(var(--color-accent-rgb), 0.35);
+  outline-offset: 2px;
+}
+
 .preferences-field:focus {
   outline: 2px solid rgba(var(--color-accent-rgb), 0.35);
   border-color: var(--color-accent);
diff --git a/cardinal/src/components/PreferencesOverlay.tsx b/cardinal/src/components/PreferencesOverlay.tsx
index 99bd3fed..6bf208f9 100644
--- a/cardinal/src/components/PreferencesOverlay.tsx
+++ b/cardinal/src/components/PreferencesOverlay.tsx
@@ -1,6 +1,6 @@
 import React, { useCallback, useEffect, useState } from 'react';
 import { useTranslation } from 'react-i18next';
-import { getWatchRootValidation, isPathInputValid } from '../utils/watchRoot';
+import { getWatchRootValidation, isIgnorePathInputValid } from '../utils/watchRoot';
 import ThemeSwitcher from './ThemeSwitcher';
 import LanguageSwitcher from './LanguageSwitcher';
 
@@ -105,12 +105,9 @@ export function PreferencesOverlay({
     }
   };
 
-  const parsedIgnorePaths = ignorePathsInput
-    .split(/\r?\n/)
-    .map((line) => line.trim())
-    .filter((line) => line.length > 0);
+  const parsedIgnorePaths = ignorePathsInput.split(/\r?\n/);
   const ignorePathsErrorMessage = (() => {
-    const invalid = parsedIgnorePaths.find((line) => !isPathInputValid(line));
+    const invalid = parsedIgnorePaths.find((line) => !isIgnorePathInputValid(line));
     return invalid ? t('ignorePaths.errors.absolute') : null;
   })();
 
@@ -120,6 +117,10 @@ export function PreferencesOverlay({
     }
   };
 
+  const handleResetIgnorePaths = (): void => {
+    setIgnorePathsInput(defaultIgnorePaths.join('\n'));
+  };
+
   const handleSave = (): void => {
     if (watchRootErrorMessage || ignorePathsErrorMessage) {
       return;
@@ -235,7 +236,7 @@ export function PreferencesOverlay({
                 {t('ignorePaths.label')}
               </p>
             </div>
-            <div className="preferences-control">
+            <div className="preferences-control preferences-control--stack">
               <textarea
                 className="preferences-field preferences-textarea"
                 value={ignorePathsInput}
@@ -254,6 +255,13 @@ export function PreferencesOverlay({
                   {ignorePathsErrorMessage}
                 </p>
               ) : null}
+              <button
+                className="preferences-ignore-reset"
+                type="button"
+                onClick={handleResetIgnorePaths}
+              >
+                Reset ignores list
+              </button>
             </div>
           </div>
         </div>
diff --git a/cardinal/src/components/__tests__/PreferencesOverlay.test.tsx b/cardinal/src/components/__tests__/PreferencesOverlay.test.tsx
index 5331cb89..0153055e 100644
--- a/cardinal/src/components/__tests__/PreferencesOverlay.test.tsx
+++ b/cardinal/src/components/__tests__/PreferencesOverlay.test.tsx
@@ -66,6 +66,70 @@ describe('PreferencesOverlay', () => {
     });
   });
 
+  it('accepts glob ignore path updates via onWatchConfigChange', () => {
+    const onWatchConfigChange = vi.fn();
+    render(<PreferencesOverlay {...baseProps} onWatchConfigChange={onWatchConfigChange} />);
+
+    const ignorePathsInput = screen.getByLabelText('ignorePaths.label');
+    fireEvent.change(ignorePathsInput, { target: { value: '**/node_modules/**' } });
+
+    fireEvent.click(screen.getByText('preferences.save'));
+
+    expect(onWatchConfigChange).toHaveBeenCalledWith({
+      watchRoot: baseProps.watchRoot,
+      ignorePaths: ['**/node_modules/**'],
+    });
+  });
+
+  it('accepts relative literal ignore path updates via onWatchConfigChange', () => {
+    const onWatchConfigChange = vi.fn();
+    render(<PreferencesOverlay {...baseProps} onWatchConfigChange={onWatchConfigChange} />);
+
+    const ignorePathsInput = screen.getByLabelText('ignorePaths.label');
+    fireEvent.change(ignorePathsInput, { target: { value: '.cache\n__pycache__' } });
+
+    fireEvent.click(screen.getByText('preferences.save'));
+
+    expect(onWatchConfigChange).toHaveBeenCalledWith({
+      watchRoot: baseProps.watchRoot,
+      ignorePaths: ['.cache', '__pycache__'],
+    });
+  });
+
+  it('preserves blank and whitespace-only ignore lines on save', () => {
+    const onWatchConfigChange = vi.fn();
+    render(<PreferencesOverlay {...baseProps} onWatchConfigChange={onWatchConfigChange} />);
+
+    const ignorePathsInput = screen.getByLabelText('ignorePaths.label');
+    fireEvent.change(ignorePathsInput, { target: { value: '/tmp/one\n\n   \n# comment' } });
+
+    fireEvent.click(screen.getByText('preferences.save'));
+
+    expect(onWatchConfigChange).toHaveBeenCalledWith({
+      watchRoot: baseProps.watchRoot,
+      ignorePaths: ['/tmp/one', '', '   ', '# comment'],
+    });
+  });
+
+  it('resets only the ignore textarea to default list', () => {
+    const onWatchConfigChange = vi.fn();
+    render(
+      <PreferencesOverlay
+        {...baseProps}
+        onWatchConfigChange={onWatchConfigChange}
+        defaultIgnorePaths={['# group', '/default/one', '', '/default/two']}
+      />,
+    );
+
+    const ignorePathsInput = screen.getByLabelText('ignorePaths.label');
+    fireEvent.change(ignorePathsInput, { target: { value: '/tmp/one\n/tmp/two' } });
+
+    fireEvent.click(screen.getByText('Reset ignores list'));
+
+    expect(ignorePathsInput).toHaveValue('# group\n/default/one\n\n/default/two');
+    expect(onWatchConfigChange).not.toHaveBeenCalled();
+  });
+
   it('resets inputs to defaults before invoking onReset', () => {
     const onReset = vi.fn();
     const onWatchConfigChange = vi.fn();
diff --git a/cardinal/src/hooks/__tests__/useIgnorePaths.test.ts b/cardinal/src/hooks/__tests__/useIgnorePaths.test.ts
index faaa213b..af0e20a6 100644
--- a/cardinal/src/hooks/__tests__/useIgnorePaths.test.ts
+++ b/cardinal/src/hooks/__tests__/useIgnorePaths.test.ts
@@ -18,13 +18,13 @@ describe('useIgnorePaths', () => {
     vi.restoreAllMocks();
   });
 
-  it('hydrates from stored values and filters invalid entries', async () => {
+  it('hydrates from stored values and preserves blank entries', async () => {
     window.localStorage.setItem(STORAGE_KEY, JSON.stringify([' /tmp ', '', 42, '   ', '/var']));
     const setItemSpy = vi.spyOn(Storage.prototype, 'setItem');
 
     const { result } = renderHook(() => useIgnorePaths());
 
-    expect(result.current.ignorePaths).toEqual(['/tmp', '/var']);
+    expect(result.current.ignorePaths).toEqual([' /tmp ', '', '   ', '/var']);
 
     await flushEffects();
 
@@ -46,20 +46,32 @@ describe('useIgnorePaths', () => {
     );
   });
 
-  it('keeps an empty stored array without writing defaults', async () => {
+  it('ships grouped defaults with comments and blank separators', () => {
+    const { result } = renderHook(() => useIgnorePaths());
+    const defaults = result.current.defaultIgnorePaths;
+
+    expect(defaults[0]).toBe('# Root-anchored system paths');
+    expect(defaults).toContain('');
+    expect(defaults).toContain('# Common project/build caches');
+    expect(defaults).toContain('# Application-specific heavy caches');
+    expect(defaults).toContain('# Basename folders to ignore anywhere');
+    expect(defaults).toContain('# File patterns');
+  });
+
+  it('keeps a whitespace-only stored array without writing defaults', async () => {
     window.localStorage.setItem(STORAGE_KEY, JSON.stringify(['', '   ']));
     const setItemSpy = vi.spyOn(Storage.prototype, 'setItem');
 
     const { result } = renderHook(() => useIgnorePaths());
 
-    expect(result.current.ignorePaths).toEqual([]);
+    expect(result.current.ignorePaths).toEqual(['', '   ']);
 
     await flushEffects();
 
     expect(setItemSpy).not.toHaveBeenCalled();
   });
 
-  it('cleans and persists updates', async () => {
+  it('preserves pattern text including blank entries and persists updates', async () => {
     window.localStorage.setItem(STORAGE_KEY, JSON.stringify([]));
     const setItemSpy = vi.spyOn(Storage.prototype, 'setItem');
 
@@ -71,8 +83,11 @@ describe('useIgnorePaths', () => {
       result.current.setIgnorePaths([' /tmp ', '', '/var', '   ']);
     });
 
-    expect(result.current.ignorePaths).toEqual(['/tmp', '/var']);
-    expect(setItemSpy).toHaveBeenCalledWith(STORAGE_KEY, JSON.stringify(['/tmp', '/var']));
+    expect(result.current.ignorePaths).toEqual([' /tmp ', '', '/var', '   ']);
+    expect(setItemSpy).toHaveBeenCalledWith(
+      STORAGE_KEY,
+      JSON.stringify([' /tmp ', '', '/var', '   ']),
+    );
   });
 
   it('falls back to defaults when stored JSON is invalid', async () => {
diff --git a/cardinal/src/hooks/useIgnorePaths.ts b/cardinal/src/hooks/useIgnorePaths.ts
index 6109854d..74412893 100644
--- a/cardinal/src/hooks/useIgnorePaths.ts
+++ b/cardinal/src/hooks/useIgnorePaths.ts
@@ -2,10 +2,73 @@ import { useCallback } from 'react';
 import { useStoredState } from './useStoredState';
 
 const STORAGE_KEY = 'cardinal.ignorePaths';
-const DEFAULT_IGNORE_PATHS = ['/Volumes'];
+const DEFAULT_IGNORE_PATHS = [
+  '# Root-anchored system paths',
+  '/Volumes/',
+  '/cores/',
+  '/dev/',
+  '/private/',
+  '/System/Applications/**/Contents/Resources/',
+  '/System/Volumes/',
+  '/usr/share/',
+  '/xarts/',
 
-const cleanPaths = (next: string[]): string[] =>
-  next.map((item) => item.trim()).filter((item) => item.length > 0);
+  '',
+  '# Common project/build caches',
+  'node_modules/',
+  '.next/',
+  '.bun/',
+  '.pnpm/',
+  '**/.local/fsindex*',
+
+  '',
+  '# Application-specific heavy caches',
+  '**/com.docker.docker/Data/',
+  '**/Firefox/Profiles/**/sessionstore-backups/',
+  '**/Firefox/Profiles/**/storage/default/',
+  '**/Firefox/Profiles/**/storage/permanent/',
+  '**/Google/Chrome*/Cache/',
+  '**/Google/Chrome*/leveldb/',
+  '**/IconJar*/Backups/',
+  '**/Sublime Text */Index/',
+  '**/var/postgres/base/',
+  '**/var/postgres/pg_stat_tmp/',
+  '**/var/postgres/pg_wal/',
+  '**/Spotify/Users/*/pending-messages*',
+
+  '',
+  '# Root user-library indexing data',
+  '/Library/Biome/',
+  '/Library/DuetExpertCenter/',
+
+  '',
+  '# Basename folders to ignore anywhere',
+  '.cache/',
+  '.cocoapods/',
+  '.git/',
+  '.opam/',
+  '__pycache__/',
+  'Cache/',
+  'Caches/',
+  'doc/',
+  'Xcode.app/',
+  'wharf/',
+  'Index.noindex/',
+  'TextIndex/',
+  'io.tailscale.ipn.macos/',
+  '.stversions/',
+
+  '',
+  '# File patterns',
+  '*.com.google.Chrome',
+  '*.pyc',
+  '.dat.nosync*',
+  'webappsstore.sqlite-wal',
+  '.DS_Store',
+];
+
+const keepStringEntries = (next: unknown[]): string[] =>
+  next.filter((item): item is string => typeof item === 'string');
 
 export function useIgnorePaths() {
   const [ignorePaths, setIgnorePathsState] = useStoredState<string[]>({
@@ -14,7 +77,7 @@ export function useIgnorePaths() {
     read: (raw) => {
       const parsed = JSON.parse(raw);
       if (!Array.isArray(parsed)) return null;
-      return cleanPaths(parsed.filter((item): item is string => typeof item === 'string'));
+      return keepStringEntries(parsed);
     },
     write: (value) => JSON.stringify(value),
     readErrorMessage: 'Unable to read saved ignore paths',
@@ -23,8 +86,7 @@ export function useIgnorePaths() {
 
   const setIgnorePaths = useCallback(
     (next: string[]) => {
-      const cleaned = cleanPaths(next);
-      setIgnorePathsState(cleaned);
+      setIgnorePathsState(next);
     },
     [setIgnorePathsState],
   );
diff --git a/cardinal/src/i18n/resources/ar-SA.json b/cardinal/src/i18n/resources/ar-SA.json
index 756e2235..e56b560f 100644
--- a/cardinal/src/i18n/resources/ar-SA.json
+++ b/cardinal/src/i18n/resources/ar-SA.json
@@ -164,7 +164,7 @@
     "label": "مسارات متجاهلة",
     "help": "مسار واحد في كل سطر؛ المسارات المتجاهلة يتم تخطيها أثناء الفهرسة.",
     "errors": {
-      "absolute": "يجب أن يبدأ كل مسار بـ '/' أو '~'."
+      "absolute": "يرجى إدخال نمط مسار glob غير فارغ."
     }
   }
 }
diff --git a/cardinal/src/i18n/resources/en-US.json b/cardinal/src/i18n/resources/en-US.json
index 4259994c..cdaf9e26 100644
--- a/cardinal/src/i18n/resources/en-US.json
+++ b/cardinal/src/i18n/resources/en-US.json
@@ -162,9 +162,9 @@
   },
   "ignorePaths": {
     "label": "Ignore paths",
-    "help": "One path per line; ignored paths are skipped during indexing.",
+    "help": "One glob style pattern per line (Use .gitignore patterns like node_modules, **/node_modules/**, !keep.txt).",
     "errors": {
-      "absolute": "Each path must start with '/' or '~'."
+      "absolute": "Please enter a non-empty glob path pattern."
     }
   }
 }
diff --git a/cardinal/src/utils/__tests__/watchRoot.test.ts b/cardinal/src/utils/__tests__/watchRoot.test.ts
index af1af536..cde54bf6 100644
--- a/cardinal/src/utils/__tests__/watchRoot.test.ts
+++ b/cardinal/src/utils/__tests__/watchRoot.test.ts
@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest';
 
-import { getWatchRootValidation, isPathInputValid } from '../watchRoot';
+import { getWatchRootValidation, isIgnorePathInputValid, isPathInputValid } from '../watchRoot';
 
 describe('isPathInputValid', () => {
   it('rejects empty or whitespace-only inputs', () => {
@@ -71,3 +71,24 @@ describe('getWatchRootValidation', () => {
     });
   });
 });
+
+describe('isIgnorePathInputValid', () => {
+  it('accepts gitignore-style entries', () => {
+    expect(isIgnorePathInputValid('/tmp/cache')).toBe(true);
+    expect(isIgnorePathInputValid('~/Library/Caches')).toBe(true);
+    expect(isIgnorePathInputValid('**/node_modules/**')).toBe(true);
+    expect(isIgnorePathInputValid('build/*.tmp')).toBe(true);
+    expect(isIgnorePathInputValid('.cache')).toBe(true);
+    expect(isIgnorePathInputValid('__pycache__')).toBe(true);
+    expect(isIgnorePathInputValid('relative/path')).toBe(true);
+    expect(isIgnorePathInputValid('./relative/path')).toBe(true);
+    expect(isIgnorePathInputValid('Library/Biome/')).toBe(true);
+    expect(isIgnorePathInputValid('!/keep.me')).toBe(true);
+    expect(isIgnorePathInputValid('# comment')).toBe(true);
+  });
+
+  it('accepts empty and whitespace-only entries for formatting', () => {
+    expect(isIgnorePathInputValid('')).toBe(true);
+    expect(isIgnorePathInputValid('   ')).toBe(true);
+  });
+});
diff --git a/cardinal/src/utils/watchRoot.ts b/cardinal/src/utils/watchRoot.ts
index 1734b37a..032f7977 100644
--- a/cardinal/src/utils/watchRoot.ts
+++ b/cardinal/src/utils/watchRoot.ts
@@ -5,6 +5,10 @@ export const isPathInputValid = (input: string): boolean => {
   return trimmed === '~' || trimmed.startsWith('~/');
 };
 
+export const isIgnorePathInputValid = (_input: string): boolean => {
+  return true;
+};
+
 type WatchRootValidation = {
   isValid: boolean;
   errorKey: 'watchRoot.errors.required' | 'watchRoot.errors.absolute' | null;
diff --git a/doc/inner/SUMMARY.md b/doc/inner/SUMMARY.md
index 9b0e34d4..5a396139 100644
--- a/doc/inner/SUMMARY.md
+++ b/doc/inner/SUMMARY.md
@@ -9,6 +9,8 @@
 - [UI Dataflow](ui-dataflow.md)
 - [FS Events SDK](fs-events-sdk.md)
 - [FSWalk](fswalk.md)
+- [Ignore Patterns](ignore-patterns.md)
+- [Ignore Requirements Implemented](ignore-requirements-implemented.md)
 - [FS Icon](fs-icon.md)
 - [Search Cancellation](search-cancellation.md)
 - [NamePool](name-pool.md)
diff --git a/doc/inner/ignore-patterns.md b/doc/inner/ignore-patterns.md
new file mode 100644
index 00000000..957c9115
--- /dev/null
+++ b/doc/inner/ignore-patterns.md
@@ -0,0 +1,162 @@
+# Ignore Patterns (`.gitignore` Semantics)
+
+This document describes how Cardinal interprets ignore patterns from Preferences.
+
+The behavior is intended to follow `.gitignore` pattern semantics for matching rules.
+
+---
+
+## Root Definition
+
+Ignore patterns are evaluated relative to the configured **Monitor root path** (`watchRoot`).
+
+Think of it as:
+- One virtual `.gitignore` file located at the watch root.
+- All preferences ignore lines are entries in that one file.
+
+Examples:
+- If watch root is `/`, pattern `/Volumes` matches `/Volumes`.
+- If watch root is `/Users/madda`, pattern `/Library` matches `/Users/madda/Library` (not system `/Library`).
+
+---
+
+## Input Source
+
+Ignore rules come from the Preferences textarea, one line per rule.
+
+Current behavior:
+- Empty/whitespace-only lines are ignored.
+- Non-empty lines are preserved and interpreted using `.gitignore` rule syntax.
+
+---
+
+## Matching Rules
+
+The following semantics apply:
+
+1. Order matters: last matching rule wins.
+2. `#` starts a comment.
+3. `!` negates (unignores) a previous ignore match.
+4. Leading `/` anchors to the watch root.
+5. Trailing `/` means directory-only match.
+6. No `/` in a pattern means basename-style match anywhere under the watch root.
+7. `*`, `?`, `[abc]`, and `**` behave like `.gitignore`.
+
+Important example:
+- `**/Xcode.app/**` ignores descendants of `Xcode.app`, but not `Xcode.app` itself.
+- `/Xcode.app/` ignores `Xcode.app` and everything inside it (when anchored at root).
+- `Xcode.app` (no slash) matches `Xcode.app` directories/files by basename anywhere.
+
+---
+
+## Common Pattern Examples
+
+1. Ignore any `node_modules` directory and its contents:
+`node_modules`
+
+2. Ignore descendants inside any `Xcode.app` bundle, but keep the bundle directory node:
+`**/Xcode.app/**`
+
+3. Ignore only root-level `build` under watch root:
+`/build/`
+
+4. Ignore all `.pyc` files:
+`*.pyc`
+
+5. Ignore all `.DS_Store` files:
+`.DS_Store`
+
+6. Ignore everything in `.cache`, then re-include one file:
+`.cache/`
+`!.cache/keep.me`
+
+---
+
+## Notes on Scope
+
+Cardinal currently uses a single global ruleset (from Preferences) rooted at `watchRoot`.
+
+This means:
+- Pattern syntax matches `.gitignore` semantics.
+- Cardinal does **not** recursively read `.gitignore` files from each directory in the filesystem tree.
+
+---
+
+## Built-in Default Rules
+
+Cardinal ships with the following default ignore entries:
+
+```gitignore
+# Root-anchored system paths
+/Volumes/
+/cores/
+/dev/
+/private/
+/System/Applications/**/Contents/Resources/
+/System/Volumes/
+/usr/share/
+/xarts/
+
+# Common project/build caches
+node_modules/
+.next/
+.bun/
+.pnpm/
+**/.local/fsindex*
+
+# Application-specific heavy caches
+**/com.docker.docker/Data/
+**/Firefox/Profiles/**/sessionstore-backups/
+**/Firefox/Profiles/**/storage/default/
+**/Firefox/Profiles/**/storage/permanent/
+**/Google/Chrome*/Cache/
+**/Google/Chrome*/leveldb/
+**/IconJar*/Backups/
+**/Sublime Text */Index/
+**/var/postgres/base/
+**/var/postgres/pg_stat_tmp/
+**/var/postgres/pg_wal/
+**/Spotify/Users/*/pending-messages*
+
+# Root user-library indexing data
+/Library/Biome/
+/Library/DuetExpertCenter/
+
+# Basename folders to ignore anywhere
+.cache/
+.cocoapods/
+.git/
+.opam/
+__pycache__/
+Cache/
+Caches/
+doc/
+Xcode.app/
+wharf/
+Index.noindex/
+TextIndex/
+io.tailscale.ipn.macos/
+.stversions/
+
+# File patterns
+*.com.google.Chrome
+*.pyc
+.dat.nosync*
+webappsstore.sqlite-wal
+.DS_Store
+```
+
+These defaults are used for first run and reset behavior.
+
+---
+
+## Practical Guidance
+
+1. Prefer basename rules for common folders:
+`node_modules`, `.git`, `__pycache__`, `.cache`
+
+2. Use `/...` when you want strict root anchoring.
+
+3. Use `**/.../**` when you specifically want descendants but not the parent directory node.
+
+4. Use negation (`!`) carefully: if a parent directory is excluded, you may need to unignore parent paths as well, same as `.gitignore`.
diff --git a/doc/inner/ignore-requirements-implemented.md b/doc/inner/ignore-requirements-implemented.md
new file mode 100644
index 00000000..3104cdad
--- /dev/null
+++ b/doc/inner/ignore-requirements-implemented.md
@@ -0,0 +1,89 @@
+# Ignore Requirements Implemented
+
+This document summarizes the final ignore-pattern requirements implemented in this branch and reflected in current git changes.
+
+## High-Level Requirements
+
+1. `.gitignore`-style matching semantics were implemented for Preferences ignore rules.
+2. Negation (`!`) is supported with the same practical limitation as `.gitignore`:
+   - A file cannot be re-included if an ancestor directory was ignored and pruned.
+3. Ignore matching is rooted to the configured `watchRoot` and remains consistent across:
+   - Initial full indexing
+   - Full rescans
+   - Incremental (FSEvents-driven) rescans
+4. Ignore evaluation is performance-oriented:
+   - Ignored directories are pruned early (no subtree walk/read_dir for descendants).
+   - Compiled ignore matcher state is reused instead of rebuilt on each incremental rescan.
+
+## Technical Implementation Details
+
+### Matching Engine and Semantics
+
+- Switched ignore evaluation to `ignore::gitignore` rules and matching behavior.
+- Rules are matched against paths relative to watch root.
+- Matching checks both the path and its parents.
+
+Relevant files:
+- `fswalk/src/lib.rs`
+- `fswalk/Cargo.toml`
+
+### Negation Behavior and Pruned-Parent Limitation
+
+- Negation rules (`!`) are supported.
+- Incremental rescans now enforce the same pruned-parent behavior as full scans:
+  - If an ancestor directory is ignored, descendant paths are not indexed even if a child rule negates them.
+
+Relevant files:
+- `search-cache/src/cache.rs`
+- `fswalk/tests/deep_walk.rs`
+- `search-cache/tests/fsevent_incremental_tests.rs`
+
+### Compile Once, Reuse Always
+
+- Added reusable compiled matcher plumbing via `Arc<IgnoreMatcher>`.
+- `SearchCache` stores a compiled matcher and reuses it for:
+  - Incremental subtree scans
+  - Full rescans with reused `WalkData`
+
+Relevant files:
+- `fswalk/src/lib.rs`
+- `search-cache/src/cache.rs`
+
+### Early Directory Pruning
+
+- The walker checks ignore status with directory/file context and prunes ignored directories before traversal.
+- This avoids unnecessary `read_dir` and descendant work for ignored subtrees.
+
+Relevant files:
+- `fswalk/src/lib.rs`
+
+### Root-Consistent Matching in Incremental Flow
+
+- Incremental rescans use matcher state rooted at watch root.
+- Added protection to skip incremental scan paths outside watch root.
+
+Relevant files:
+- `search-cache/src/cache.rs`
+
+### UI/Input Pipeline Alignment
+
+- Ignore lines are preserved as raw `.gitignore`-style lines (non-empty), not auto-expanded into custom glob wrappers.
+- Validation/help text now aligns with `.gitignore` expectations.
+
+Relevant files:
+- `cardinal/src-tauri/src/commands.rs`
+- `cardinal/src/utils/watchRoot.ts`
+- `cardinal/src/components/PreferencesOverlay.tsx`
+- `cardinal/src/hooks/useIgnorePaths.ts`
+- `cardinal/src/i18n/resources/en-US.json`
+
+### Verification in Current Git Changes
+
+The current branch includes tests that lock in the implemented requirements:
+
+- `.gitignore` semantics and glob behavior:
+  - `fswalk/tests/deep_walk.rs`
+- Incremental rescan behavior with ignores/negation:
+  - `search-cache/tests/fsevent_incremental_tests.rs`
+
+The implementation and tests are present in modified tracked files visible in `git status`.
diff --git a/fswalk/Cargo.toml b/fswalk/Cargo.toml
index 9d90bc3f..4b3e99a4 100644
--- a/fswalk/Cargo.toml
+++ b/fswalk/Cargo.toml
@@ -9,6 +9,7 @@ serde_repr = "0.1.0"
 rayon = "1"
 memchr = "2.7.4"
 enumn = "0.1.14"
+ignore = "0.4"
 
 [dev-dependencies]
 tempdir = "0.3"
diff --git a/fswalk/src/lib.rs b/fswalk/src/lib.rs
index aaca64a1..b248f6f2 100644
--- a/fswalk/src/lib.rs
+++ b/fswalk/src/lib.rs
@@ -1,3 +1,4 @@
+use ignore::gitignore::{Gitignore, GitignoreBuilder};
 use rayon::{iter::ParallelBridge, prelude::ParallelIterator};
 use serde::{Deserialize, Serialize};
 use serde_repr::{Deserialize_repr, Serialize_repr};
@@ -7,7 +8,10 @@ use std::{
     num::NonZeroU64,
     os::unix::fs::MetadataExt,
     path::{Path, PathBuf},
-    sync::atomic::{AtomicBool, AtomicUsize, Ordering},
+    sync::{
+        Arc,
+        atomic::{AtomicBool, AtomicUsize, Ordering},
+    },
     time::UNIX_EPOCH,
 };
 
@@ -80,6 +84,49 @@ impl From<fs::FileType> for NodeFileType {
     }
 }
 
+#[derive(Debug, Default)]
+pub struct IgnoreMatcher {
+    root_path: PathBuf,
+    gitignore: Option<Gitignore>,
+}
+
+impl IgnoreMatcher {
+    pub fn new(root_path: &Path, ignore_directories: &[PathBuf]) -> Self {
+        if ignore_directories.is_empty() {
+            return Self {
+                root_path: root_path.to_path_buf(),
+                gitignore: None,
+            };
+        }
+
+        let mut builder = GitignoreBuilder::new(root_path);
+        for ignore in ignore_directories {
+            let pattern = ignore.to_string_lossy();
+            let _ = builder.add_line(None, &pattern);
+        }
+
+        let gitignore = builder.build().ok();
+        Self {
+            root_path: root_path.to_path_buf(),
+            gitignore,
+        }
+    }
+
+    pub fn is_ignored(&self, path: &Path, is_dir: bool) -> bool {
+        let Ok(candidate) = path.strip_prefix(&self.root_path) else {
+            return false;
+        };
+        self.gitignore
+            .as_ref()
+            .map(|gitignore| {
+                gitignore
+                    .matched_path_or_any_parents(candidate, is_dir)
+                    .is_ignore()
+            })
+            .unwrap_or(false)
+    }
+}
+
 #[derive(Debug)]
 pub struct WalkData<'w> {
     pub num_files: AtomicUsize,
@@ -88,18 +135,20 @@ pub struct WalkData<'w> {
     cancel: Option<&'w AtomicBool>,
     pub root_path: &'w Path,
     pub ignore_directories: &'w [PathBuf],
+    ignore_matcher: Arc<IgnoreMatcher>,
     /// If set, metadata will be collected for each file node(folder node will get free metadata).
     need_metadata: bool,
 }
 
 impl<'w> WalkData<'w> {
-    pub const fn simple(root_path: &'w Path, need_metadata: bool) -> Self {
+    pub fn simple(root_path: &'w Path, need_metadata: bool) -> Self {
         Self {
             num_files: AtomicUsize::new(0),
             num_dirs: AtomicUsize::new(0),
             cancel: None,
             root_path,
             ignore_directories: &[],
+            ignore_matcher: Arc::new(IgnoreMatcher::default()),
             need_metadata,
         }
     }
@@ -109,6 +158,38 @@ impl<'w> WalkData<'w> {
         ignore_directories: &'w [PathBuf],
         need_metadata: bool,
         cancel: Option<&'w AtomicBool>,
+    ) -> Self {
+        Self::new_with_ignore_root(
+            root_path,
+            root_path,
+            ignore_directories,
+            need_metadata,
+            cancel,
+        )
+    }
+
+    pub fn new_with_ignore_root(
+        root_path: &'w Path,
+        ignore_root_path: &'w Path,
+        ignore_directories: &'w [PathBuf],
+        need_metadata: bool,
+        cancel: Option<&'w AtomicBool>,
+    ) -> Self {
+        Self::new_with_ignore_matcher(
+            root_path,
+            ignore_directories,
+            Arc::new(IgnoreMatcher::new(ignore_root_path, ignore_directories)),
+            need_metadata,
+            cancel,
+        )
+    }
+
+    pub fn new_with_ignore_matcher(
+        root_path: &'w Path,
+        ignore_directories: &'w [PathBuf],
+        ignore_matcher: Arc<IgnoreMatcher>,
+        need_metadata: bool,
+        cancel: Option<&'w AtomicBool>,
     ) -> Self {
         Self {
             num_files: AtomicUsize::new(0),
@@ -116,12 +197,17 @@ impl<'w> WalkData<'w> {
             cancel,
             root_path,
             ignore_directories,
+            ignore_matcher,
             need_metadata,
         }
     }
 
-    fn should_ignore(&self, path: &Path) -> bool {
-        self.ignore_directories.iter().any(|ignore| ignore == path)
+    pub fn ignore_matcher(&self) -> Arc<IgnoreMatcher> {
+        Arc::clone(&self.ignore_matcher)
+    }
+
+    fn should_ignore(&self, path: &Path, is_dir: bool) -> bool {
+        self.ignore_matcher.is_ignored(path, is_dir)
     }
 }
 
@@ -165,11 +251,12 @@ pub fn walk_it(walk_data: &WalkData) -> Option<Node> {
 }
 
 fn walk(path: &Path, walk_data: &WalkData) -> Option<Node> {
-    if walk_data.should_ignore(path) {
+    let metadata = metadata_of_path(path);
+    let is_dir = metadata.as_ref().map(|x| x.is_dir()).unwrap_or_default();
+    if walk_data.should_ignore(path, is_dir) {
         return None;
     }
-    let metadata = metadata_of_path(path);
-    let children = if metadata.as_ref().map(|x| x.is_dir()).unwrap_or_default() {
+    let children = if is_dir {
         walk_data.num_dirs.fetch_add(1, Ordering::Relaxed);
         let read_dir = fs::read_dir(path);
         match read_dir {
@@ -186,13 +273,15 @@ fn walk(path: &Path, walk_data: &WalkData) -> Option<Node> {
                             {
                                 return None;
                             }
-                            if walk_data.should_ignore(path) {
-                                return None;
-                            }
+                            let entry_path = entry.path();
                             // doesn't traverse symlink
                             if let Ok(data) = entry.file_type() {
-                                if data.is_dir() {
-                                    return walk(&entry.path(), walk_data);
+                                let is_dir = data.is_dir();
+                                if walk_data.should_ignore(&entry_path, is_dir) {
+                                    return None;
+                                }
+                                if is_dir {
+                                    return walk(&entry_path, walk_data);
                                 } else {
                                     walk_data.num_files.fetch_add(1, Ordering::Relaxed);
                                     let name = entry
diff --git a/fswalk/tests/deep_walk.rs b/fswalk/tests/deep_walk.rs
index 8036cb5e..f64c5468 100644
--- a/fswalk/tests/deep_walk.rs
+++ b/fswalk/tests/deep_walk.rs
@@ -49,7 +49,7 @@ fn node_for_path<'a>(node: &'a fswalk::Node, path: &Path) -> &'a fswalk::Node {
 fn ignores_directories_and_collects_metadata() {
     let tmp = TempDir::new("fswalk_deep").unwrap();
     build_deep_fixture(tmp.path());
-    let ignore = vec![tmp.path().join("skip_dir")];
+    let ignore = vec![std::path::PathBuf::from("/skip_dir")];
     let walk_data = WalkData::new(tmp.path(), &ignore, true, None);
     let tree = walk_it(&walk_data).expect("root node");
     let tree = node_for_path(&tree, tmp.path());
@@ -102,3 +102,163 @@ fn cancellation_stops_traversal_early() {
         "expected immediate cancellation to abort traversal"
     );
 }
+
+#[test]
+fn glob_patterns_ignore_nested_directories() {
+    let tmp = TempDir::new("fswalk_glob_ignore").unwrap();
+    let root = tmp.path();
+
+    fs::create_dir_all(root.join("packages/app/node_modules/pkg")).unwrap();
+    fs::create_dir_all(root.join("src/components")).unwrap();
+    fs::write(
+        root.join("packages/app/node_modules/pkg/ignored.js"),
+        b"console.log('ignored');",
+    )
+    .unwrap();
+    fs::write(
+        root.join("src/components/kept.tsx"),
+        b"export const kept = true;",
+    )
+    .unwrap();
+
+    let ignore = vec![std::path::PathBuf::from("**/node_modules/**")];
+    let walk_data = WalkData::new(root, &ignore, true, None);
+    let tree = walk_it(&walk_data).expect("root node");
+    let tree = node_for_path(&tree, root);
+
+    let packages = tree
+        .children
+        .iter()
+        .find(|child| &*child.name == "packages")
+        .expect("packages directory");
+    let app = packages
+        .children
+        .iter()
+        .find(|child| &*child.name == "app")
+        .expect("app directory");
+    let node_modules = app
+        .children
+        .iter()
+        .find(|child| &*child.name == "node_modules")
+        .expect("node_modules directory should still exist");
+    assert!(
+        node_modules.children.is_empty(),
+        "glob ignore should remove descendants under node_modules"
+    );
+
+    let src = tree
+        .children
+        .iter()
+        .find(|child| &*child.name == "src")
+        .expect("src directory");
+    let components = src
+        .children
+        .iter()
+        .find(|child| &*child.name == "components")
+        .expect("components directory");
+    assert!(
+        components
+            .children
+            .iter()
+            .any(|child| &*child.name == "kept.tsx"),
+        "non-matching files should remain indexed"
+    );
+}
+
+#[test]
+fn globstar_descendant_pattern_does_not_ignore_parent_directory() {
+    let tmp = TempDir::new("fswalk_globstar_parent_semantics").unwrap();
+    let root = tmp.path();
+
+    fs::create_dir_all(root.join("Xcode.app/Contents")).unwrap();
+    fs::write(root.join("Xcode.app/Contents/data.bin"), b"data").unwrap();
+
+    let ignore = vec![std::path::PathBuf::from("**/Xcode.app/**")];
+    let walk_data = WalkData::new(root, &ignore, true, None);
+    let tree = walk_it(&walk_data).expect("root node");
+    let tree = node_for_path(&tree, root);
+
+    let xcode_app = tree
+        .children
+        .iter()
+        .find(|child| &*child.name == "Xcode.app")
+        .expect("Xcode.app should not be ignored by **/Xcode.app/** itself");
+    assert!(
+        xcode_app.children.is_empty(),
+        "descendants under Xcode.app should be ignored by **/Xcode.app/**"
+    );
+}
+
+#[test]
+fn gitignore_negation_reincludes_file_when_parent_is_not_pruned() {
+    let tmp = TempDir::new("fswalk_gitignore_negation_reinclude").unwrap();
+    let root = tmp.path();
+
+    fs::create_dir_all(root.join("workspace/node_modules")).unwrap();
+    fs::write(root.join("workspace/node_modules/included.js"), b"ok").unwrap();
+    fs::write(root.join("workspace/node_modules/ignored.js"), b"no").unwrap();
+
+    let ignore = vec![
+        std::path::PathBuf::from("**/node_modules/**"),
+        std::path::PathBuf::from("!**/node_modules/**/included.js"),
+    ];
+    let walk_data = WalkData::new(root, &ignore, true, None);
+    let tree = walk_it(&walk_data).expect("root node");
+    let tree = node_for_path(&tree, root);
+
+    let workspace = tree
+        .children
+        .iter()
+        .find(|child| &*child.name == "workspace")
+        .expect("workspace directory");
+    let node_modules = workspace
+        .children
+        .iter()
+        .find(|child| &*child.name == "node_modules")
+        .expect("node_modules directory");
+
+    assert!(
+        node_modules
+            .children
+            .iter()
+            .any(|child| &*child.name == "included.js"),
+        "negation should re-include explicit file when parent directory is not pruned"
+    );
+    assert!(
+        node_modules
+            .children
+            .iter()
+            .all(|child| &*child.name != "ignored.js"),
+        "non-negated files should remain ignored"
+    );
+}
+
+#[test]
+fn gitignore_negation_cannot_reinclude_when_parent_directory_is_pruned() {
+    let tmp = TempDir::new("fswalk_gitignore_negation_pruned_parent").unwrap();
+    let root = tmp.path();
+
+    fs::create_dir_all(root.join("workspace/node_modules")).unwrap();
+    fs::write(root.join("workspace/node_modules/included.js"), b"ok").unwrap();
+
+    let ignore = vec![
+        std::path::PathBuf::from("**/node_modules/"),
+        std::path::PathBuf::from("!**/node_modules/**/included.js"),
+    ];
+    let walk_data = WalkData::new(root, &ignore, true, None);
+    let tree = walk_it(&walk_data).expect("root node");
+    let tree = node_for_path(&tree, root);
+
+    let workspace = tree
+        .children
+        .iter()
+        .find(|child| &*child.name == "workspace")
+        .expect("workspace directory");
+    assert!(
+        workspace
+            .children
+            .iter()
+            .all(|child| &*child.name != "node_modules"),
+        "when a parent directory is ignored, its subtree is pruned and negation cannot re-include descendants"
+    );
+}
diff --git a/search-cache/src/cache.rs b/search-cache/src/cache.rs
index 189dcdda..bfac3dfb 100644
--- a/search-cache/src/cache.rs
+++ b/search-cache/src/cache.rs
@@ -8,7 +8,7 @@ use crate::{
 use anyhow::{Context, Result, anyhow};
 use cardinal_sdk::{EventFlag, FsEvent, ScanType, current_event_id};
 use cardinal_syntax::{optimize_query, parse_query};
-use fswalk::{Node, NodeMetadata, WalkData, walk_it, walk_it_without_root_chain};
+use fswalk::{IgnoreMatcher, Node, NodeMetadata, WalkData, walk_it, walk_it_without_root_chain};
 use hashbrown::HashSet;
 use namepool::NamePool;
 use search_cancel::CancellationToken;
@@ -16,7 +16,7 @@ use std::{
     ffi::OsStr,
     io::ErrorKind,
     path::{Path, PathBuf},
-    sync::{LazyLock, atomic::AtomicBool},
+    sync::{Arc, LazyLock, atomic::AtomicBool},
     time::Instant,
 };
 use thin_vec::ThinVec;
@@ -28,6 +28,7 @@ pub struct SearchCache {
     last_event_id: u64,
     rescan_count: u64,
     pub(crate) name_index: NameIndex,
+    ignore_matcher: Arc<IgnoreMatcher>,
     stop: Option<&'static AtomicBool>,
 }
 
@@ -180,7 +181,14 @@ impl SearchCache {
             slab_root,
         );
         // metadata cache inits later
-        Some(Self::new(slab, last_event_id, 0, name_index, cancel))
+        Some(Self::new_with_ignore_matcher(
+            slab,
+            last_event_id,
+            0,
+            name_index,
+            walk_data.ignore_matcher(),
+            cancel,
+        ))
     }
 
     fn new(
@@ -189,12 +197,32 @@ impl SearchCache {
         rescan_count: u64,
         name_index: NameIndex,
         cancel: Option<&'static AtomicBool>,
+    ) -> Self {
+        let ignore_matcher = Arc::new(IgnoreMatcher::new(slab.path(), slab.ignore_paths()));
+        Self::new_with_ignore_matcher(
+            slab,
+            last_event_id,
+            rescan_count,
+            name_index,
+            ignore_matcher,
+            cancel,
+        )
+    }
+
+    fn new_with_ignore_matcher(
+        slab: FileNodes,
+        last_event_id: u64,
+        rescan_count: u64,
+        name_index: NameIndex,
+        ignore_matcher: Arc<IgnoreMatcher>,
+        cancel: Option<&'static AtomicBool>,
     ) -> Self {
         Self {
             file_nodes: slab,
             last_event_id,
             rescan_count,
             name_index,
+            ignore_matcher,
             stop: cancel,
         }
     }
@@ -347,15 +375,55 @@ impl SearchCache {
         current
     }
 
+    fn has_ignored_ancestor_directory(&self, path: &Path) -> bool {
+        let watch_root = self.file_nodes.path();
+        let mut ancestor = path.parent();
+        while let Some(dir) = ancestor {
+            if dir == watch_root {
+                break;
+            }
+            if !dir.starts_with(watch_root) {
+                break;
+            }
+            if self.ignore_matcher.is_ignored(dir, true) {
+                return true;
+            }
+            ancestor = dir.parent();
+        }
+        false
+    }
+
     // `Self::scan_path_recursive`function returns index of the constructed node(with metadata provided).
     // - If path is not under the watch root, None is returned.
     // - Procedure contains metadata fetching, if metadata fetching failed, None is returned.
     fn scan_path_recursive(&mut self, path: &Path) -> Option<SlabIndex> {
+        if !path.starts_with(self.file_nodes.path()) {
+            warn!("skip incremental scan outside watch root: {:?}", path);
+            return None;
+        }
+        if self.has_ignored_ancestor_directory(path) {
+            self.remove_node_path(path);
+            return None;
+        }
         // Ensure path is under the watch root
         if path.symlink_metadata().err().map(|e| e.kind()) == Some(ErrorKind::NotFound) {
             self.remove_node_path(path);
             return None;
         };
+        let walk_data = WalkData::new_with_ignore_matcher(
+            path,
+            self.file_nodes.ignore_paths(),
+            Arc::clone(&self.ignore_matcher),
+            true,
+            self.stop,
+        );
+        let node = match walk_it_without_root_chain(&walk_data) {
+            Some(node) => node,
+            None => {
+                self.remove_node_path(path);
+                return None;
+            }
+        };
         let parent = path.parent().expect(
             "scan_path_recursive doesn't expected to scan root(should be filtered outside)",
         );
@@ -369,14 +437,10 @@ impl SearchCache {
         {
             self.remove_node(old_node);
         }
-        // For incremental data, we need metadata
-        let walk_data = WalkData::new(path, self.file_nodes.ignore_paths(), true, self.stop);
-        walk_it_without_root_chain(&walk_data).map(|node| {
-            let node = self.create_node_slab_update_name_index_and_name_pool(Some(parent), &node);
-            // Push the newly created node to the parent's children
-            self.file_nodes[parent].add_children(node);
-            node
-        })
+        let node = self.create_node_slab_update_name_index_and_name_pool(Some(parent), &node);
+        // Push the newly created node to the parent's children
+        self.file_nodes[parent].add_children(node);
+        Some(node)
     }
 
     // `Self::scan_path_nonrecursive`function returns index of the constructed node.
@@ -399,7 +463,13 @@ impl SearchCache {
     ) -> WalkData<'p> {
         *phantom1 = self.file_nodes.path().to_path_buf();
         *phantom2 = self.file_nodes.ignore_paths().clone();
-        WalkData::new(phantom1, phantom2, false, self.stop)
+        WalkData::new_with_ignore_matcher(
+            phantom1,
+            phantom2,
+            Arc::clone(&self.ignore_matcher),
+            false,
+            self.stop,
+        )
     }
 
     pub fn rescan_with_walk_data(&mut self, walk_data: &WalkData) -> Option<()> {
@@ -414,9 +484,10 @@ impl SearchCache {
     pub fn rescan(&mut self) {
         // Remove all memory consuming cache early for memory consumption in Self::walk_fs_new.
         let Some(new_cache) = Self::walk_fs_with_walk_data(
-            &WalkData::new(
+            &WalkData::new_with_ignore_matcher(
                 self.file_nodes.path(),
                 self.file_nodes.ignore_paths(),
+                Arc::clone(&self.ignore_matcher),
                 false,
                 self.stop,
             ),
@@ -478,6 +549,7 @@ impl SearchCache {
             last_event_id,
             rescan_count,
             name_index,
+            ignore_matcher: _,
             stop: _,
         } = self;
         let (path, ignore_paths, slab_root, slab) = file_nodes.into_parts();
@@ -596,7 +668,7 @@ impl SearchCache {
             self.rescan_count = self.rescan_count.saturating_add(1);
             return Err(HandleFSEError::Rescan);
         }
-        for scan_path in scan_paths(events) {
+        for scan_path in scan_paths_under_root(events, self.file_nodes.path()) {
             info!("Scanning path: {scan_path:?}");
             let folder = self.scan_path_recursive(&scan_path);
             if folder.is_some() {
@@ -682,6 +754,15 @@ fn scan_paths(events: Vec<FsEvent>) -> Vec<PathBuf> {
     selected
 }
 
+fn scan_paths_under_root(events: Vec<FsEvent>, watch_root: &Path) -> Vec<PathBuf> {
+    scan_paths(
+        events
+            .into_iter()
+            .filter(|event| event.path.starts_with(watch_root))
+            .collect(),
+    )
+}
+
 fn path_depth(path: &Path) -> usize {
     path.components().count()
 }
@@ -1530,6 +1611,36 @@ mod tests {
         assert_eq!(cache.search("new_file.txt").unwrap().len(), 1);
     }
 
+    #[test]
+    fn test_handle_fs_event_out_of_root_ancestor_does_not_mask_in_root_path() {
+        let temp_dir = TempDir::new("test_events").expect("Failed to create temp directory");
+        let temp_path = temp_dir.path();
+        let mut cache = SearchCache::walk_fs(temp_path);
+
+        let in_root_file = temp_path.join("new_file.txt");
+        fs::File::create(&in_root_file).expect("Failed to create file");
+
+        let out_of_root_ancestor = temp_path
+            .parent()
+            .expect("temp dir should always have a parent")
+            .to_path_buf();
+        let mock_events = vec![
+            FsEvent {
+                path: out_of_root_ancestor,
+                id: cache.last_event_id + 1,
+                flag: EventFlag::ItemModified | EventFlag::ItemIsDir,
+            },
+            FsEvent {
+                path: in_root_file,
+                id: cache.last_event_id + 2,
+                flag: EventFlag::ItemCreated | EventFlag::ItemIsFile,
+            },
+        ];
+
+        cache.handle_fs_events(mock_events).unwrap();
+        assert_eq!(cache.search("new_file.txt").unwrap().len(), 1);
+    }
+
     // Processing outdated fs event is required to avoid bouncing.
     #[test]
     fn test_handle_outdated_fs_event() {
@@ -3045,4 +3156,24 @@ mod tests {
         let out = scan_paths(events);
         assert_eq!(out, vec![PathBuf::from("/long")]);
     }
+
+    #[test]
+    fn test_scan_paths_under_root_filters_masking_out_of_root_ancestor() {
+        let watch_root = Path::new("/tmp/watch");
+        let events = vec![
+            FsEvent {
+                path: PathBuf::from("/tmp"),
+                id: 1,
+                flag: EventFlag::ItemModified | EventFlag::ItemIsDir,
+            },
+            FsEvent {
+                path: PathBuf::from("/tmp/watch/new.txt"),
+                id: 2,
+                flag: EventFlag::ItemCreated | EventFlag::ItemIsFile,
+            },
+        ];
+
+        let out = scan_paths_under_root(events, watch_root);
+        assert_eq!(out, vec![PathBuf::from("/tmp/watch/new.txt")]);
+    }
 }
diff --git a/search-cache/tests/fsevent_incremental_tests.rs b/search-cache/tests/fsevent_incremental_tests.rs
index 3e5bc431..f74c65fa 100644
--- a/search-cache/tests/fsevent_incremental_tests.rs
+++ b/search-cache/tests/fsevent_incremental_tests.rs
@@ -455,7 +455,7 @@ fn test_events_for_ignored_paths() {
     let ignored_dir = root_path.join("ignored");
     std::fs::create_dir(&ignored_dir).unwrap();
 
-    let ignore_paths = vec![ignored_dir.clone()];
+    let ignore_paths = vec![PathBuf::from("/ignored")];
     let mut cache = SearchCache::walk_fs_with_ignore(&root_path, &ignore_paths);
 
     // Create file in ignored directory
@@ -470,14 +470,149 @@ fn test_events_for_ignored_paths() {
 
     cache.handle_fs_events(vec![event]).unwrap();
 
-    // File in ignored path may or may not be indexed depending on implementation
-    // Just verify it doesn't panic
     let search_result = cache
         .query_files("should_not_index".to_string(), CancellationToken::noop())
         .unwrap();
-    assert!(
-        search_result.is_some(),
-        "Search should not panic for ignored paths"
+    assert!(search_result.is_some());
+    assert_eq!(
+        search_result.unwrap().len(),
+        0,
+        "Files under ignored absolute paths should stay excluded"
+    );
+}
+
+#[test]
+fn test_events_for_glob_ignored_paths() {
+    let temp_dir = TempDir::new("glob_ignored_paths_test").unwrap();
+    let root_path = temp_dir.path().to_path_buf();
+    std::mem::forget(temp_dir);
+
+    std::fs::create_dir_all(root_path.join("workspace/node_modules/pkg")).unwrap();
+    std::fs::File::create(root_path.join("workspace/included.txt")).unwrap();
+
+    let ignore_paths = vec![PathBuf::from("**/node_modules/**")];
+    let mut cache = SearchCache::walk_fs_with_ignore(&root_path, &ignore_paths);
+
+    let ignored_file = root_path.join("workspace/node_modules/pkg/new_ignored.txt");
+    std::fs::File::create(&ignored_file).unwrap();
+
+    cache
+        .handle_fs_events(vec![FsEvent {
+            path: ignored_file,
+            flag: EventFlag::ItemCreated,
+            id: 301,
+        }])
+        .unwrap();
+
+    let ignored_result = cache
+        .query_files("new_ignored".to_string(), CancellationToken::noop())
+        .unwrap();
+    assert!(ignored_result.is_some());
+    assert_eq!(
+        ignored_result.unwrap().len(),
+        0,
+        "Files matching glob ignored paths should stay excluded"
+    );
+
+    let included_result = cache
+        .query_files("included".to_string(), CancellationToken::noop())
+        .unwrap();
+    assert!(included_result.is_some());
+    assert_eq!(
+        included_result.unwrap().len(),
+        1,
+        "Non-matching files should remain searchable"
+    );
+}
+
+#[test]
+fn test_events_for_negated_glob_paths() {
+    let temp_dir = TempDir::new("negated_glob_paths_test").unwrap();
+    let root_path = temp_dir.path().to_path_buf();
+    std::mem::forget(temp_dir);
+
+    std::fs::create_dir_all(root_path.join("workspace/node_modules")).unwrap();
+
+    let ignore_paths = vec![
+        PathBuf::from("**/node_modules/**"),
+        PathBuf::from("!**/node_modules/**/included.txt"),
+    ];
+    let mut cache = SearchCache::walk_fs_with_ignore(&root_path, &ignore_paths);
+
+    let included_file = root_path.join("workspace/node_modules/included.txt");
+    std::fs::write(&included_file, b"included").unwrap();
+    let ignored_file = root_path.join("workspace/node_modules/ignored.txt");
+    std::fs::write(&ignored_file, b"ignored").unwrap();
+
+    cache
+        .handle_fs_events(vec![
+            FsEvent {
+                path: included_file,
+                flag: EventFlag::ItemCreated,
+                id: 302,
+            },
+            FsEvent {
+                path: ignored_file,
+                flag: EventFlag::ItemCreated,
+                id: 303,
+            },
+        ])
+        .unwrap();
+
+    let included_result = cache
+        .query_files("included".to_string(), CancellationToken::noop())
+        .unwrap();
+    assert!(included_result.is_some());
+    assert_eq!(
+        included_result.unwrap().len(),
+        1,
+        "Negated patterns should re-include explicit files when parent directories are not ignored"
+    );
+
+    let ignored_result = cache
+        .query_files("ignored".to_string(), CancellationToken::noop())
+        .unwrap();
+    assert!(ignored_result.is_some());
+    assert_eq!(
+        ignored_result.unwrap().len(),
+        0,
+        "Non-negated files should remain ignored"
+    );
+}
+
+#[test]
+fn test_events_for_negation_under_pruned_parent_directory() {
+    let temp_dir = TempDir::new("negated_glob_pruned_parent_test").unwrap();
+    let root_path = temp_dir.path().to_path_buf();
+    std::mem::forget(temp_dir);
+
+    std::fs::create_dir_all(root_path.join("workspace/node_modules")).unwrap();
+
+    let ignore_paths = vec![
+        PathBuf::from("**/node_modules/"),
+        PathBuf::from("!**/node_modules/**/included.txt"),
+    ];
+    let mut cache = SearchCache::walk_fs_with_ignore(&root_path, &ignore_paths);
+
+    let included_file = root_path.join("workspace/node_modules/included.txt");
+    std::fs::write(&included_file, b"included").unwrap();
+
+    cache
+        .handle_fs_events(vec![FsEvent {
+            path: included_file,
+            flag: EventFlag::ItemCreated,
+            id: 304,
+        }])
+        .unwrap();
+
+    let included_result = cache
+        .query_files("included".to_string(), CancellationToken::noop())
+        .unwrap();
+    assert!(included_result.is_some());
+    assert_eq!(
+        included_result.unwrap().len(),
+        0,
+        "Files cannot be re-included when an ancestor directory was ignored and pruned"
     );
 }
 

From 59712e22e9b0a2b89e04b39d0512f3ccfa6e2723 Mon Sep 17 00:00:00 2001
From: Mohamad Yahia <xyzt70@gmail.com>
Date: Wed, 25 Feb 2026 07:05:16 +0400
Subject: [PATCH 02/16] feat(export): add menu-driven current files list export

---
 .gitignore                                    |   3 +-
 cardinal/src-tauri/Cargo.lock                 | 192 ++++++++++++++++++
 cardinal/src-tauri/Cargo.toml                 |   1 +
 cardinal/src-tauri/src/commands.rs            |  96 ++++++++-
 cardinal/src-tauri/src/lib.rs                 |  13 +-
 cardinal/src/App.css                          |   2 +-
 cardinal/src/App.tsx                          |  83 ++++++++
 .../src/__tests__/App.contextMenu.test.tsx    | 124 ++++++++++-
 cardinal/src/components/StatusBar.tsx         |   4 +-
 cardinal/src/constants/appEvents.ts           |   1 +
 cardinal/src/menu.ts                          |  11 +
 .../__tests__/exportListedFilesTsv.test.ts    |  85 ++++++++
 cardinal/src/utils/exportListedFilesTsv.ts    |  83 ++++++++
 13 files changed, 687 insertions(+), 11 deletions(-)
 create mode 100644 cardinal/src/utils/__tests__/exportListedFilesTsv.test.ts
 create mode 100644 cardinal/src/utils/exportListedFilesTsv.ts

diff --git a/.gitignore b/.gitignore
index fd531785..c8084351 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,4 @@
 target
 .DS_Store
-.vscode
\ No newline at end of file
+.vscode
+/ignored/
diff --git a/cardinal/src-tauri/Cargo.lock b/cardinal/src-tauri/Cargo.lock
index e1494eec..f271b8e1 100644
--- a/cardinal/src-tauri/Cargo.lock
+++ b/cardinal/src-tauri/Cargo.lock
@@ -53,6 +53,28 @@ version = "1.0.100"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a23eb6b1614318a8071c9b2521f36b424b2c83db5eb3a0fead4a6c0809af6e61"
 
+[[package]]
+name = "ashpd"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2f3f79755c74fd155000314eb349864caa787c6592eace6c6882dad873d9c39"
+dependencies = [
+ "async-fs",
+ "async-net",
+ "enumflags2",
+ "futures-channel",
+ "futures-util",
+ "rand 0.9.2",
+ "raw-window-handle",
+ "serde",
+ "serde_repr",
+ "url",
+ "wayland-backend",
+ "wayland-client",
+ "wayland-protocols",
+ "zbus",
+]
+
 [[package]]
 name = "async-broadcast"
 version = "0.7.2"
@@ -91,6 +113,17 @@ dependencies = [
  "slab",
 ]
 
+[[package]]
+name = "async-fs"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8034a681df4aed8b8edbd7fbe472401ecf009251c8b40556b304567052e294c5"
+dependencies = [
+ "async-lock",
+ "blocking",
+ "futures-lite",
+]
+
 [[package]]
 name = "async-io"
 version = "2.6.0"
@@ -120,6 +153,17 @@ dependencies = [
  "pin-project-lite",
 ]
 
+[[package]]
+name = "async-net"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b948000fad4873c1c9339d60f2623323a0cfd3816e5181033c6a5cb68b2accf7"
+dependencies = [
+ "async-io",
+ "blocking",
+ "futures-lite",
+]
+
 [[package]]
 name = "async-process"
 version = "2.5.0"
@@ -411,6 +455,7 @@ dependencies = [
  "once_cell",
  "parking_lot",
  "rayon",
+ "rfd",
  "search-cache",
  "search-cancel",
  "serde",
@@ -885,6 +930,15 @@ dependencies = [
  "syn 2.0.111",
 ]
 
+[[package]]
+name = "dlib"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "330c60081dcc4c72131f8eb70510f1ac07223e5d4163db481a04a0befcffa412"
+dependencies = [
+ "libloading",
+]
+
 [[package]]
 name = "dlopen2"
 version = "0.8.2"
@@ -908,6 +962,12 @@ dependencies = [
  "syn 2.0.111",
 ]
 
+[[package]]
+name = "downcast-rs"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75b325c5dbd37f80359721ad39aca5a29fb04c89279657cffdda8736d0c0b9d2"
+
 [[package]]
 name = "dpi"
 version = "0.1.2"
@@ -3191,6 +3251,12 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "pollster"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2f3a9f18d041e6d0e102a0a46750538147e5e8992d3b4873aaafee2520b00ce3"
+
 [[package]]
 name = "portable-atomic"
 version = "1.11.1"
@@ -3370,6 +3436,16 @@ dependencies = [
  "rand_core 0.6.4",
 ]
 
+[[package]]
+name = "rand"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
+dependencies = [
+ "rand_chacha 0.9.0",
+ "rand_core 0.9.5",
+]
+
 [[package]]
 name = "rand_chacha"
 version = "0.2.2"
@@ -3390,6 +3466,16 @@ dependencies = [
  "rand_core 0.6.4",
 ]
 
+[[package]]
+name = "rand_chacha"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.9.5",
+]
+
 [[package]]
 name = "rand_core"
 version = "0.5.1"
@@ -3408,6 +3494,15 @@ dependencies = [
  "getrandom 0.2.16",
 ]
 
+[[package]]
+name = "rand_core"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c"
+dependencies = [
+ "getrandom 0.3.4",
+]
+
 [[package]]
 name = "rand_hc"
 version = "0.2.0"
@@ -3556,6 +3651,30 @@ dependencies = [
  "web-sys",
 ]
 
+[[package]]
+name = "rfd"
+version = "0.15.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef2bee61e6cffa4635c72d7d81a84294e28f0930db0ddcb0f66d10244674ebed"
+dependencies = [
+ "ashpd",
+ "block2 0.6.2",
+ "dispatch2",
+ "js-sys",
+ "log",
+ "objc2 0.6.3",
+ "objc2-app-kit",
+ "objc2-core-foundation",
+ "objc2-foundation 0.3.2",
+ "pollster",
+ "raw-window-handle",
+ "urlencoding",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+ "windows-sys 0.59.0",
+]
+
 [[package]]
 name = "rustc-hash"
 version = "2.1.1"
@@ -3656,6 +3775,12 @@ dependencies = [
  "syn 2.0.111",
 ]
 
+[[package]]
+name = "scoped-tls"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294"
+
 [[package]]
 name = "scopeguard"
 version = "1.2.0"
@@ -5026,6 +5151,12 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "urlencoding"
+version = "2.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "daf8dba3b7eb870caf1ddeed7bc9d2a049f3cfdfae7cb521b087cc33ae4c49da"
+
 [[package]]
 name = "urlpattern"
 version = "0.3.0"
@@ -5211,6 +5342,66 @@ dependencies = [
  "web-sys",
 ]
 
+[[package]]
+name = "wayland-backend"
+version = "0.3.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fee64194ccd96bf648f42a65a7e589547096dfa702f7cadef84347b66ad164f9"
+dependencies = [
+ "cc",
+ "downcast-rs",
+ "rustix",
+ "scoped-tls",
+ "smallvec",
+ "wayland-sys",
+]
+
+[[package]]
+name = "wayland-client"
+version = "0.31.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8e6faa537fbb6c186cb9f1d41f2f811a4120d1b57ec61f50da451a0c5122bec"
+dependencies = [
+ "bitflags 2.10.0",
+ "rustix",
+ "wayland-backend",
+ "wayland-scanner",
+]
+
+[[package]]
+name = "wayland-protocols"
+version = "0.32.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baeda9ffbcfc8cd6ddaade385eaf2393bd2115a69523c735f12242353c3df4f3"
+dependencies = [
+ "bitflags 2.10.0",
+ "wayland-backend",
+ "wayland-client",
+ "wayland-scanner",
+]
+
+[[package]]
+name = "wayland-scanner"
+version = "0.31.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5423e94b6a63e68e439803a3e153a9252d5ead12fd853334e2ad33997e3889e3"
+dependencies = [
+ "proc-macro2",
+ "quick-xml",
+ "quote",
+]
+
+[[package]]
+name = "wayland-sys"
+version = "0.31.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e6dbfc3ac5ef974c92a2235805cc0114033018ae1290a72e474aa8b28cbbdfd"
+dependencies = [
+ "dlib",
+ "log",
+ "pkg-config",
+]
+
 [[package]]
 name = "web-sys"
 version = "0.3.83"
@@ -6157,6 +6348,7 @@ dependencies = [
  "endi",
  "enumflags2",
  "serde",
+ "url",
  "winnow 0.7.14",
  "zvariant_derive",
  "zvariant_utils",
diff --git a/cardinal/src-tauri/Cargo.toml b/cardinal/src-tauri/Cargo.toml
index 9c5dbfc4..92a757eb 100644
--- a/cardinal/src-tauri/Cargo.toml
+++ b/cardinal/src-tauri/Cargo.toml
@@ -39,6 +39,7 @@ tauri-plugin-prevent-default = "4"
 tauri-plugin-macos-permissions = "2.3.0"
 tauri-plugin-window-state = "2"
 once_cell = { version = "1.20", features = ["parking_lot"] }
+rfd = "0.15"
 
 cardinal-sdk.path = "../../cardinal-sdk"
 search-cache.path = "../../search-cache"
diff --git a/cardinal/src-tauri/src/commands.rs b/cardinal/src-tauri/src/commands.rs
index 164a9fa4..c3bcd1f1 100644
--- a/cardinal/src-tauri/src/commands.rs
+++ b/cardinal/src-tauri/src/commands.rs
@@ -22,7 +22,12 @@ use parking_lot::Mutex;
 use search_cache::{SearchOptions, SearchOutcome, SearchResultNode, SlabIndex, SlabNodeMetadata};
 use search_cancel::CancellationToken;
 use serde::{Deserialize, Serialize};
-use std::{cell::LazyCell, process::Command};
+use std::{
+    cell::LazyCell,
+    fs::OpenOptions,
+    io::Write,
+    process::Command,
+};
 use tauri::{ActivationPolicy, AppHandle, State};
 use tracing::{error, info, warn};
 
@@ -420,6 +425,95 @@ pub async fn open_path(path: String) {
     }
 }
 
+#[tauri::command]
+pub async fn prompt_save_listed_files_tsv(
+    app: AppHandle,
+    default_filename: String,
+) -> Result<Option<String>, String> {
+    let (response_tx, response_rx) = bounded::<Result<Option<String>, String>>(1);
+
+    app.run_on_main_thread(move || {
+        let result = prompt_save_listed_files_tsv_impl(default_filename);
+        if response_tx.send(result).is_err() {
+            error!("Failed to send prompt_save_listed_files_tsv response");
+        }
+    })
+    .map_err(|e| format!("Failed to dispatch prompt save dialog on main thread: {e:?}"))?;
+
+    response_rx
+        .recv()
+        .map_err(|e| format!("Failed to receive prompt_save_listed_files_tsv response: {e:?}"))?
+}
+
+fn normalize_export_default_filename(default_filename: String) -> String {
+    let fallback_filename = "cardinal-word-list.tsv".to_string();
+    let trimmed = default_filename.trim();
+    if trimmed.is_empty() {
+        fallback_filename
+    } else {
+        trimmed.to_string()
+    }
+}
+
+fn prompt_save_listed_files_tsv_impl(default_filename: String) -> Result<Option<String>, String> {
+    let default_filename = normalize_export_default_filename(default_filename);
+
+    info!(
+        "Opening listed-files TSV save dialog with default filename: {}",
+        default_filename
+    );
+
+    let dialog = rfd::FileDialog::new()
+        .add_filter("Tab-separated values", &["tsv"])
+        .set_file_name(&default_filename);
+    let Some(mut path) = dialog.save_file() else {
+        info!("Listed-files TSV save dialog canceled by user");
+        return Ok(None);
+    };
+
+    if path.extension().is_none() {
+        path.set_extension("tsv");
+    }
+
+    let path = path.to_string_lossy().into_owned();
+    Ok(Some(path))
+}
+
+#[tauri::command]
+pub async fn write_listed_files_tsv(path: String, content: String) -> Result<(), String> {
+    let mut file = OpenOptions::new()
+        .create(true)
+        .truncate(true)
+        .write(true)
+        .open(&path)
+        .map_err(|e| format!("Failed to open TSV file for writing {}: {e}", path))?;
+    file.write_all(content.as_bytes())
+        .map_err(|e| format!("Failed to write TSV file to {}: {e}", path))?;
+    info!("Saved listed-files TSV to {}", path);
+    Ok(())
+}
+
+#[tauri::command]
+pub async fn append_listed_files_tsv_chunk(path: String, content: String) -> Result<(), String> {
+    let mut file = OpenOptions::new()
+        .create(true)
+        .append(true)
+        .open(&path)
+        .map_err(|e| format!("Failed to open TSV file for appending {}: {e}", path))?;
+    file.write_all(content.as_bytes())
+        .map_err(|e| format!("Failed appending TSV chunk to {}: {e}", path))?;
+    Ok(())
+}
+
+#[tauri::command]
+pub async fn remove_listed_files_tsv(path: String) -> Result<(), String> {
+    match std::fs::remove_file(&path) {
+        Ok(()) => Ok(()),
+        Err(err) if err.kind() == std::io::ErrorKind::NotFound => Ok(()),
+        Err(err) => Err(format!("Failed to remove TSV file {}: {err}", path)),
+    }
+}
+
 #[tauri::command]
 pub async fn start_logic(watch_root: String, ignore_paths: Vec<String>) {
     if let Some(sender) = LOGIC_START.get() {
diff --git a/cardinal/src-tauri/src/lib.rs b/cardinal/src-tauri/src/lib.rs
index 01079e5c..7ffeba95 100644
--- a/cardinal/src-tauri/src/lib.rs
+++ b/cardinal/src-tauri/src/lib.rs
@@ -14,10 +14,11 @@ use background::{
 use cardinal_sdk::EventWatcher;
 use commands::{
     NodeInfoRequest, SearchJob, SearchState, WatchConfigUpdate, activate_main_window,
-    close_quicklook, copy_files_to_clipboard, get_app_status, get_nodes_info, get_sorted_view,
-    hide_main_window, normalize_watch_config, open_in_finder, open_path, search,
-    set_tray_activation_policy, set_watch_config, start_logic, toggle_main_window,
-    toggle_quicklook, trigger_rescan, update_icon_viewport, update_quicklook,
+    append_listed_files_tsv_chunk, close_quicklook, copy_files_to_clipboard, get_app_status,
+    get_nodes_info, get_sorted_view, hide_main_window, normalize_watch_config, open_in_finder,
+    open_path, prompt_save_listed_files_tsv, remove_listed_files_tsv, search,
+    set_tray_activation_policy, set_watch_config, start_logic, toggle_main_window, toggle_quicklook,
+    trigger_rescan, update_icon_viewport, update_quicklook, write_listed_files_tsv,
 };
 use crossbeam_channel::{Receiver, RecvTimeoutError, Sender, bounded, unbounded};
 use lifecycle::{
@@ -131,6 +132,10 @@ pub fn run() -> Result<()> {
             set_watch_config,
             open_in_finder,
             open_path,
+            prompt_save_listed_files_tsv,
+            write_listed_files_tsv,
+            append_listed_files_tsv_chunk,
+            remove_listed_files_tsv,
             toggle_quicklook,
             close_quicklook,
             update_quicklook,
diff --git a/cardinal/src/App.css b/cardinal/src/App.css
index e753836f..3713f386 100644
--- a/cardinal/src/App.css
+++ b/cardinal/src/App.css
@@ -1528,7 +1528,7 @@ button:active:not(:disabled) {
 
 .preferences-card {
   width: 100%;
-  max-width: 480px;
+  max-width: 680px;
   max-height: calc(100vh - 96px);
   background: var(--color-elevated-bg, var(--color-bg));
   color: var(--color-text);
diff --git a/cardinal/src/App.tsx b/cardinal/src/App.tsx
index f98ccbe2..3973efe7 100644
--- a/cardinal/src/App.tsx
+++ b/cardinal/src/App.tsx
@@ -1,6 +1,7 @@
 import { useRef, useCallback, useEffect, useMemo } from 'react';
 import type { ChangeEvent, CSSProperties, MouseEvent as ReactMouseEvent } from 'react';
 import './App.css';
+import { invoke } from '@tauri-apps/api/core';
 import { FileRow } from './components/FileRow';
 import { SearchBar } from './components/SearchBar';
 import { FilesTabContent } from './components/FilesTabContent';
@@ -30,6 +31,15 @@ import { useAppPreferences } from './hooks/useAppPreferences';
 import { useAppWindowListeners } from './hooks/useAppWindowListeners';
 import { useFilesTabEffects } from './hooks/useFilesTabEffects';
 import { useFilesTabState } from './hooks/useFilesTabState';
+import {
+  buildListedFilesTsvHeader,
+  buildListedFilesTsvRows,
+  createListedFilesTsvFilename,
+} from './utils/exportListedFilesTsv';
+import { REQUEST_EXPORT_CURRENT_FILES_LIST_EVENT } from './constants/appEvents';
+import type { NodeInfoResponse } from './types/search';
+
+const EXPORT_BATCH_SIZE = 1000;
 
 function App() {
   const {
@@ -246,6 +256,79 @@ function App() {
     [showEventsContextMenu],
   );
 
+  const handleExportListedFilesTsv = useCallback(async () => {
+    if (activeTab !== 'files' || displayedResults.length === 0) {
+      return;
+    }
+
+    let savePath: string | null = null;
+    try {
+      savePath = await invoke<string | null>('prompt_save_listed_files_tsv', {
+        defaultFilename: createListedFilesTsvFilename(currentQuery),
+      });
+      if (!savePath) {
+        return;
+      }
+
+      const labels = {
+        filename: t('columns.filename'),
+        path: t('columns.path'),
+        size: t('columns.size'),
+        modified: t('columns.modified'),
+        created: t('columns.created'),
+      } as const;
+
+      const header = buildListedFilesTsvHeader(labels);
+      await invoke('write_listed_files_tsv', {
+        path: savePath,
+        content: `${header}\n`,
+      });
+
+      for (let start = 0; start < displayedResults.length; start += EXPORT_BATCH_SIZE) {
+        const batch = displayedResults.slice(start, start + EXPORT_BATCH_SIZE);
+        const fetched = await invoke<NodeInfoResponse[]>('get_nodes_info', {
+          results: batch,
+          includeIcons: false,
+        });
+        const rowsChunk = buildListedFilesTsvRows(fetched);
+        if (!rowsChunk) {
+          continue;
+        }
+        const isLastBatch = start + EXPORT_BATCH_SIZE >= displayedResults.length;
+        const chunkContent = isLastBatch ? rowsChunk : `${rowsChunk}\n`;
+        await invoke('append_listed_files_tsv_chunk', {
+          path: savePath,
+          content: chunkContent,
+        });
+      }
+    } catch (error) {
+      console.error('Failed to export listed files as TSV', error);
+      if (savePath) {
+        try {
+          await invoke('remove_listed_files_tsv', { path: savePath });
+        } catch (cleanupError) {
+          console.error('Failed to clean up partial TSV export', cleanupError);
+        }
+      }
+      if (typeof window !== 'undefined') {
+        window.alert('Failed to export current files list. Please try again.');
+      }
+    }
+  }, [activeTab, currentQuery, displayedResults, t]);
+
+  useEffect(() => {
+    if (typeof window === 'undefined') {
+      return;
+    }
+    const onRequestExport = () => {
+      void handleExportListedFilesTsv();
+    };
+    window.addEventListener(REQUEST_EXPORT_CURRENT_FILES_LIST_EVENT, onRequestExport);
+    return () => {
+      window.removeEventListener(REQUEST_EXPORT_CURRENT_FILES_LIST_EVENT, onRequestExport);
+    };
+  }, [handleExportListedFilesTsv]);
+
   const renderRow = useCallback(
     (rowIndex: number, item: SearchResultItem | undefined, rowStyle: CSSProperties) => {
       if (!item) {
diff --git a/cardinal/src/__tests__/App.contextMenu.test.tsx b/cardinal/src/__tests__/App.contextMenu.test.tsx
index c19e2b01..3a4b3b7b 100644
--- a/cardinal/src/__tests__/App.contextMenu.test.tsx
+++ b/cardinal/src/__tests__/App.contextMenu.test.tsx
@@ -1,14 +1,20 @@
-import { fireEvent, render, screen } from '@testing-library/react';
+import { fireEvent, render, screen, waitFor } from '@testing-library/react';
 import { forwardRef } from 'react';
 import type { CSSProperties } from 'react';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import App from '../App';
+import { REQUEST_EXPORT_CURRENT_FILES_LIST_EVENT } from '../constants/appEvents';
 
 const mocks = vi.hoisted(() => ({
   showFilesContextMenu: vi.fn(),
   showEventsContextMenu: vi.fn(),
   selectSingleRow: vi.fn(),
   useContextMenuMock: vi.fn(),
+  invoke: vi.fn(),
+  buildListedFilesTsvHeader: vi.fn(),
+  buildListedFilesTsvRows: vi.fn(),
+  createListedFilesTsvFilename: vi.fn(),
+  alert: vi.fn(),
 }));
 
 const testState = vi.hoisted(() => ({
@@ -27,6 +33,10 @@ vi.mock('react-i18next', () => ({
   }),
 }));
 
+vi.mock('@tauri-apps/api/core', () => ({
+  invoke: (...args: unknown[]) => mocks.invoke(...args),
+}));
+
 vi.mock('../components/SearchBar', () => ({
   SearchBar: ({ inputRef }: { inputRef: React.Ref<HTMLInputElement> }) => (
     <input data-testid="search-input" ref={inputRef} />
@@ -266,12 +276,22 @@ vi.mock('../hooks/useStableEvent', () => ({
   useStableEvent: <T extends (...args: any[]) => any>(handler: T): T => handler,
 }));
 
+vi.mock('../utils/exportListedFilesTsv', () => ({
+  buildListedFilesTsvHeader: (...args: unknown[]) => mocks.buildListedFilesTsvHeader(...args),
+  buildListedFilesTsvRows: (...args: unknown[]) => mocks.buildListedFilesTsvRows(...args),
+  createListedFilesTsvFilename: (...args: unknown[]) => mocks.createListedFilesTsvFilename(...args),
+}));
+
 describe('App context menu regression', () => {
   beforeEach(() => {
     vi.clearAllMocks();
+    vi.spyOn(window, 'alert').mockImplementation(mocks.alert);
     testState.activeTab = 'files';
     testState.selectedIndices = [0];
     testState.selectedPaths = ['/stale-a', '/stale-b'];
+    mocks.buildListedFilesTsvHeader.mockReturnValue('header-cols');
+    mocks.buildListedFilesTsvRows.mockReturnValue('row1\nrow2');
+    mocks.createListedFilesTsvFilename.mockReturnValue('cardinal-word-list-test-2026-02-22.tsv');
 
     mocks.useContextMenuMock
       .mockReturnValueOnce({
@@ -284,6 +304,10 @@ describe('App context menu regression', () => {
       });
   });
 
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
   it('uses clicked row path for context menu when row is not already selected', () => {
     render(<App />);
 
@@ -330,4 +354,100 @@ describe('App context menu regression', () => {
     expect(mocks.showEventsContextMenu).toHaveBeenCalledTimes(1);
     expect(mocks.showEventsContextMenu.mock.calls[0][1]).toEqual(['/event-path']);
   });
+
+  it('exports listed files as TSV using displayed result order', async () => {
+    const fetchedNodes = [
+      {
+        path: '/tmp/alpha.txt',
+        metadata: { type: 0, size: 10, mtime: 1, ctime: 2 },
+      },
+      {
+        path: '/tmp/folder',
+        metadata: { type: 1, size: 0, mtime: 3, ctime: 4 },
+      },
+    ];
+    mocks.invoke
+      .mockResolvedValueOnce('/tmp/cardinal-word-list-test-2026-02-22.tsv')
+      .mockResolvedValueOnce(undefined)
+      .mockResolvedValueOnce(fetchedNodes)
+      .mockResolvedValueOnce(undefined);
+
+    render(<App />);
+    window.dispatchEvent(new Event(REQUEST_EXPORT_CURRENT_FILES_LIST_EVENT));
+
+    await waitFor(() => {
+      expect(mocks.invoke).toHaveBeenCalledWith('write_listed_files_tsv', {
+        path: '/tmp/cardinal-word-list-test-2026-02-22.tsv',
+        content: 'header-cols\n',
+      });
+    });
+
+    expect(mocks.invoke).toHaveBeenNthCalledWith(1, 'prompt_save_listed_files_tsv', {
+      defaultFilename: 'cardinal-word-list-test-2026-02-22.tsv',
+    });
+    expect(mocks.invoke).toHaveBeenNthCalledWith(2, 'write_listed_files_tsv', {
+      path: '/tmp/cardinal-word-list-test-2026-02-22.tsv',
+      content: 'header-cols\n',
+    });
+    expect(mocks.invoke).toHaveBeenNthCalledWith(3, 'get_nodes_info', {
+      results: [101, 202],
+      includeIcons: false,
+    });
+    expect(mocks.invoke).toHaveBeenNthCalledWith(4, 'append_listed_files_tsv_chunk', {
+      path: '/tmp/cardinal-word-list-test-2026-02-22.tsv',
+      content: 'row1\nrow2',
+    });
+
+    expect(mocks.invoke).toHaveBeenCalledWith('get_nodes_info', {
+      results: [101, 202],
+      includeIcons: false,
+    });
+    expect(mocks.buildListedFilesTsvHeader).toHaveBeenCalledWith({
+      filename: 'columns.filename',
+      path: 'columns.path',
+      size: 'columns.size',
+      modified: 'columns.modified',
+      created: 'columns.created',
+    });
+    expect(mocks.buildListedFilesTsvRows).toHaveBeenCalledWith(fetchedNodes);
+    expect(mocks.createListedFilesTsvFilename).toHaveBeenCalledWith('');
+  });
+
+  it('does not fetch or write when save dialog is canceled', async () => {
+    mocks.invoke.mockResolvedValueOnce(null);
+
+    render(<App />);
+    window.dispatchEvent(new Event(REQUEST_EXPORT_CURRENT_FILES_LIST_EVENT));
+
+    await waitFor(() => {
+      expect(mocks.invoke).toHaveBeenCalledWith('prompt_save_listed_files_tsv', {
+        defaultFilename: 'cardinal-word-list-test-2026-02-22.tsv',
+      });
+    });
+
+    expect(mocks.invoke).toHaveBeenCalledTimes(1);
+    expect(mocks.buildListedFilesTsvHeader).not.toHaveBeenCalled();
+    expect(mocks.buildListedFilesTsvRows).not.toHaveBeenCalled();
+  });
+
+  it('cleans up partial export and shows an alert when writing fails', async () => {
+    vi.spyOn(console, 'error').mockImplementation(() => {});
+    mocks.invoke
+      .mockResolvedValueOnce('/tmp/cardinal-word-list-test-2026-02-22.tsv')
+      .mockRejectedValueOnce(new Error('write failed'))
+      .mockResolvedValueOnce(undefined);
+
+    render(<App />);
+    window.dispatchEvent(new Event(REQUEST_EXPORT_CURRENT_FILES_LIST_EVENT));
+
+    await waitFor(() => {
+      expect(mocks.invoke).toHaveBeenCalledWith('remove_listed_files_tsv', {
+        path: '/tmp/cardinal-word-list-test-2026-02-22.tsv',
+      });
+    });
+
+    expect(mocks.alert).toHaveBeenCalledWith(
+      'Failed to export current files list. Please try again.',
+    );
+  });
 });
diff --git a/cardinal/src/components/StatusBar.tsx b/cardinal/src/components/StatusBar.tsx
index fc39dd6b..619e0974 100644
--- a/cardinal/src/components/StatusBar.tsx
+++ b/cardinal/src/components/StatusBar.tsx
@@ -1,4 +1,4 @@
-import React, { useCallback, useRef, useLayoutEffect, useState } from 'react';
+import React, { useCallback, useLayoutEffect, useRef } from 'react';
 import type { CSSProperties } from 'react';
 import type { AppLifecycleStatus } from '../types/ipc';
 import { useTranslation } from 'react-i18next';
@@ -41,7 +41,7 @@ const StatusBar = ({
   const tabsRef = useRef<HTMLDivElement | null>(null);
   const filesTabRef = useRef<HTMLButtonElement | null>(null);
   const eventsTabRef = useRef<HTMLButtonElement | null>(null);
-  const [sliderStyle, setSliderStyle] = useState<CSSProperties>({});
+  const [sliderStyle, setSliderStyle] = React.useState<CSSProperties>({});
 
   useLayoutEffect(() => {
     // Keep the active-tab underline aligned even when labels resize or counters update.
diff --git a/cardinal/src/constants/appEvents.ts b/cardinal/src/constants/appEvents.ts
index 91a1096b..2c96d0df 100644
--- a/cardinal/src/constants/appEvents.ts
+++ b/cardinal/src/constants/appEvents.ts
@@ -1 +1,2 @@
 export const OPEN_PREFERENCES_EVENT = 'cardinal:open-preferences';
+export const REQUEST_EXPORT_CURRENT_FILES_LIST_EVENT = 'cardinal:request-export-current-files-list';
diff --git a/cardinal/src/menu.ts b/cardinal/src/menu.ts
index 5046f658..73e51a11 100644
--- a/cardinal/src/menu.ts
+++ b/cardinal/src/menu.ts
@@ -3,6 +3,7 @@ import { invoke } from '@tauri-apps/api/core';
 import { Menu, MenuItem, PredefinedMenuItem, Submenu } from '@tauri-apps/api/menu';
 import { openUrl } from '@tauri-apps/plugin-opener';
 import i18n from './i18n/config';
+import { REQUEST_EXPORT_CURRENT_FILES_LIST_EVENT } from './constants/appEvents';
 import { openPreferences } from './utils/openPreferences';
 
 const HELP_UPDATES_URL = 'https://github.com/cardisoft/cardinal/releases';
@@ -31,6 +32,15 @@ async function buildAppMenu(): Promise<void> {
       openPreferences();
     },
   });
+  const exportCurrentFilesListItem = await MenuItem.new({
+    id: 'menu.export_current_files_list',
+    text: 'Export current files list',
+    action: () => {
+      if (typeof window !== 'undefined') {
+        window.dispatchEvent(new Event(REQUEST_EXPORT_CURRENT_FILES_LIST_EVENT));
+      }
+    },
+  });
   const hideItem = await MenuItem.new({
     id: 'menu.hide',
     text: i18n.t('menu.hide'),
@@ -46,6 +56,7 @@ async function buildAppMenu(): Promise<void> {
       aboutItem,
       await PredefinedMenuItem.new({ item: 'Separator' }),
       preferencesItem,
+      exportCurrentFilesListItem,
       hideItem,
       await PredefinedMenuItem.new({ item: 'Separator' }),
       await PredefinedMenuItem.new({
diff --git a/cardinal/src/utils/__tests__/exportListedFilesTsv.test.ts b/cardinal/src/utils/__tests__/exportListedFilesTsv.test.ts
new file mode 100644
index 00000000..ae719b70
--- /dev/null
+++ b/cardinal/src/utils/__tests__/exportListedFilesTsv.test.ts
@@ -0,0 +1,85 @@
+import { describe, expect, it } from 'vitest';
+import {
+  buildListedFilesTsv,
+  createListedFilesTsvFilename,
+  type TsvColumnLabels,
+} from '../exportListedFilesTsv';
+import type { NodeInfoResponse } from '../../types/search';
+import { formatKB, formatTimestamp } from '../format';
+
+const labels: TsvColumnLabels = {
+  filename: 'Filename',
+  path: 'Path',
+  size: 'Size',
+  modified: 'Modified',
+  created: 'Created',
+};
+
+describe('buildListedFilesTsv', () => {
+  it('keeps row order and formats cells like file rows', () => {
+    const nodes: NodeInfoResponse[] = [
+      {
+        path: '/Users/me/project/file.txt',
+        metadata: {
+          type: 0,
+          size: 2048,
+          mtime: 1704067200,
+          ctime: 1704067100,
+        },
+      },
+      {
+        path: '/Users/me/project/folder',
+        metadata: {
+          type: 1,
+          size: 0,
+          mtime: 1704067300,
+          ctime: 1704067000,
+        },
+      },
+    ];
+
+    const tsv = buildListedFilesTsv(nodes, labels);
+    const lines = tsv.split('\n');
+
+    expect(lines[0]).toBe('Filename\tPath\tSize\tModified\tCreated');
+    expect(lines[1]).toBe(
+      `file.txt\t/Users/me/project\t${formatKB(2048)}\t${formatTimestamp(1704067200)}\t${formatTimestamp(1704067100)}`,
+    );
+    expect(lines[2]).toBe(
+      `folder\t/Users/me/project\t—\t${formatTimestamp(1704067300)}\t${formatTimestamp(1704067000)}`,
+    );
+  });
+
+  it('sanitizes tabs and new lines in fields', () => {
+    const nodes: NodeInfoResponse[] = [
+      {
+        path: '/Users/me/line\nbreak\tname.txt',
+        metadata: {
+          type: 0,
+          size: 1024,
+          mtime: 0,
+          ctime: 0,
+        },
+      },
+    ];
+
+    const tsv = buildListedFilesTsv(nodes, labels);
+    expect(tsv).not.toContain('\tname.txt\t/Users/me/line');
+    expect(tsv).toContain('line break name.txt');
+  });
+});
+
+describe('createListedFilesTsvFilename', () => {
+  it('uses a stable date-based fallback filename for empty queries', () => {
+    const filename = createListedFilesTsvFilename('', new Date('2026-02-22T15:04:05.678Z'));
+    expect(filename).toBe('cardinal-word-list-all-files-2026-02-22.tsv');
+  });
+
+  it('includes normalized query text and current date', () => {
+    const filename = createListedFilesTsvFilename(
+      '  Foo/bar: baz + qux  ',
+      new Date('2026-02-22T15:04:05.678Z'),
+    );
+    expect(filename).toBe('cardinal-word-list-foo-bar-baz-qux-2026-02-22.tsv');
+  });
+});
diff --git a/cardinal/src/utils/exportListedFilesTsv.ts b/cardinal/src/utils/exportListedFilesTsv.ts
new file mode 100644
index 00000000..6953ab86
--- /dev/null
+++ b/cardinal/src/utils/exportListedFilesTsv.ts
@@ -0,0 +1,83 @@
+import { formatKB, formatTimestamp } from './format';
+import { splitPath } from './path';
+import type { NodeInfoResponse } from '../types/search';
+
+export type TsvColumnLabels = Readonly<{
+  filename: string;
+  path: string;
+  size: string;
+  modified: string;
+  created: string;
+}>;
+
+const sanitizeField = (value: string): string => value.replace(/[\t\r\n]+/g, ' ');
+const MAX_FILENAME_TERM_LENGTH = 48;
+
+const toDisplayFields = (node: NodeInfoResponse): [string, string, string, string, string] => {
+  const path = node.path ?? '';
+  const pathParts = splitPath(path);
+  const filename = path === '/' ? '' : pathParts.name;
+  const directoryPath = pathParts.directory;
+
+  const sizeBytes = node.metadata?.size ?? node.size;
+  const mtimeSec = node.metadata?.mtime ?? node.mtime;
+  const ctimeSec = node.metadata?.ctime ?? node.ctime;
+  const isDirectory = (node.metadata?.type ?? -1) === 1;
+
+  const sizeText = !isDirectory ? formatKB(sizeBytes) : null;
+  const mtimeText = formatTimestamp(mtimeSec);
+  const ctimeText = formatTimestamp(ctimeSec);
+
+  return [
+    sanitizeField(filename),
+    sanitizeField(directoryPath),
+    sanitizeField(sizeText ?? '—'),
+    sanitizeField(mtimeText ?? '—'),
+    sanitizeField(ctimeText ?? '—'),
+  ];
+};
+
+export const buildListedFilesTsvHeader = (labels: TsvColumnLabels): string => {
+  return [
+    sanitizeField(labels.filename),
+    sanitizeField(labels.path),
+    sanitizeField(labels.size),
+    sanitizeField(labels.modified),
+    sanitizeField(labels.created),
+  ].join('\t');
+};
+
+export const buildListedFilesTsvRows = (nodes: readonly NodeInfoResponse[]): string => {
+  return nodes.map((node) => toDisplayFields(node).join('\t')).join('\n');
+};
+
+export const buildListedFilesTsv = (
+  nodes: readonly NodeInfoResponse[],
+  labels: TsvColumnLabels,
+): string => {
+  const header = buildListedFilesTsvHeader(labels);
+  const body = buildListedFilesTsvRows(nodes);
+  if (!body) {
+    return header;
+  }
+  return `${header}\n${body}`;
+};
+
+const toFilenameTerm = (query: string): string => {
+  const normalized = query
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/-{2,}/g, '-')
+    .replace(/^-+|-+$/g, '');
+  if (!normalized) {
+    return 'all-files';
+  }
+  return normalized.slice(0, MAX_FILENAME_TERM_LENGTH);
+};
+
+export const createListedFilesTsvFilename = (query: string, now: Date = new Date()): string => {
+  const dateStamp = now.toISOString().slice(0, 10);
+  const term = toFilenameTerm(query);
+  return `cardinal-word-list-${term}-${dateStamp}.tsv`;
+};

From 669c2ff871e0cbaa07b89acc61d98a912230e2f7 Mon Sep 17 00:00:00 2001
From: Mohamad Yahia <xyzt70@gmail.com>
Date: Wed, 25 Feb 2026 07:06:00 +0400
Subject: [PATCH 03/16] feat(ignore-paths): add baseline glob-style default
 excludes

---
 .../hooks/__tests__/useIgnorePaths.test.ts    |  30 +++-
 cardinal/src/hooks/useIgnorePaths.ts          | 133 +++++++++++++-----
 2 files changed, 120 insertions(+), 43 deletions(-)

diff --git a/cardinal/src/hooks/__tests__/useIgnorePaths.test.ts b/cardinal/src/hooks/__tests__/useIgnorePaths.test.ts
index af0e20a6..10947be4 100644
--- a/cardinal/src/hooks/__tests__/useIgnorePaths.test.ts
+++ b/cardinal/src/hooks/__tests__/useIgnorePaths.test.ts
@@ -46,16 +46,34 @@ describe('useIgnorePaths', () => {
     );
   });
 
-  it('ships grouped defaults with comments and blank separators', () => {
+  it('ships data-driven defaults with per-pattern comments and blank separators', () => {
     const { result } = renderHook(() => useIgnorePaths());
     const defaults = result.current.defaultIgnorePaths;
 
-    expect(defaults[0]).toBe('# Root-anchored system paths');
+    expect(defaults[0]).toContain('0 files in the 2026-02-24 sample');
     expect(defaults).toContain('');
-    expect(defaults).toContain('# Common project/build caches');
-    expect(defaults).toContain('# Application-specific heavy caches');
-    expect(defaults).toContain('# Basename folders to ignore anywhere');
-    expect(defaults).toContain('# File patterns');
+    expect(defaults).toContain('**/node_modules/');
+    expect(defaults).toContain('**/.pnpm/');
+    expect(defaults).toContain('**/.bun/install/cache/');
+    expect(defaults).toContain('**/Library/Caches/');
+    expect(defaults).toContain('**/.cache/');
+    expect(defaults).toContain('**/Library/Application Support/*/Partitions/*/Cache/');
+    expect(defaults).toContain('**/Library/Application Support/*/Cache/');
+    expect(defaults).toContain('**/Library/pnpm/store/');
+    expect(defaults).toContain('**/target/');
+    expect(defaults).toContain('**/Code Cache/');
+    expect(defaults).toContain('**/Service Worker/CacheStorage/');
+    expect(defaults).toContain('**/IndexedDB/');
+    expect(defaults).toContain('**/WebStorage/');
+    expect(defaults).toContain('**/.next/');
+    expect(defaults).toContain('**/.git/');
+    expect(defaults).toContain('**/__pycache__/');
+    expect(defaults).toContain('**/.cocoapods/');
+    expect(defaults).toContain('**/.opam/');
+    expect(defaults).toContain('**/*.pyc');
+    expect(defaults).toContain('**/.DS_Store');
+    expect(defaults).toContain('**/Google/Chrome*/Cache/');
+    expect(defaults).toContain('/System/Volumes/');
   });
 
   it('keeps a whitespace-only stored array without writing defaults', async () => {
diff --git a/cardinal/src/hooks/useIgnorePaths.ts b/cardinal/src/hooks/useIgnorePaths.ts
index 74412893..b2f6af10 100644
--- a/cardinal/src/hooks/useIgnorePaths.ts
+++ b/cardinal/src/hooks/useIgnorePaths.ts
@@ -3,26 +3,112 @@ import { useStoredState } from './useStoredState';
 
 const STORAGE_KEY = 'cardinal.ignorePaths';
 const DEFAULT_IGNORE_PATHS = [
-  '# Root-anchored system paths',
+  '# 0 files in the 2026-02-24 sample. Keep external volumes excluded to avoid indexing large mounted disks/network shares.',
   '/Volumes/',
+  '',
+  '# 2,384,029 files across 414 roots. Node dependency trees dominate index volume and are regenerated.',
+  '**/node_modules/',
+  '',
+  '# 1,178,011 files across 1 root. iOS simulator runtime volumes are huge generated SDK trees.',
+  '/Library/Developer/CoreSimulator/Volumes/',
+  '',
+  '# 807,360 files across 103 roots. Library cache trees are high-churn generated app/system cache data.',
+  '**/Library/Caches/',
+  '',
+  '# 575,477 files across 81 roots. pnpm per-project stores are dependency artifacts, not user-authored files.',
+  '**/.pnpm/',
+  '',
+  '# 777,084 files across 1 root. Bun package cache is high-volume dependency artifact storage.',
+  '**/.bun/install/cache/',
+  '',
+  '# 449,342 files across 29 roots. App partition cache directories are browser/electron app cache payloads.',
+  '**/Library/Application Support/*/Partitions/*/Cache/',
+  '',
+  '# 403,015 files across 1 root. App bundles contain large binary/resource trees with low filename-search value.',
+  '/Applications/',
+  '',
+  '# 326,312 files across 1 root. macOS system frameworks/resources are large and mostly static.',
+  '/System/Library/',
+  '',
+  '# 275,101 files across 1 root. Global pnpm content-addressed store is rebuildable cache data.',
+  '**/Library/pnpm/store/',
+  '',
+  '# 209,526 files across 1 root. Command-line tools/SDK payloads are generated development artifacts.',
+  '/Library/Developer/CommandLineTools/',
+  '',
+  '# 178,753 files across 22 roots. Dot-cache directories are tool-managed caches and usually disposable.',
+  '**/.cache/',
+  '',
+  '# 157,087 files across 155 roots. Browser/Electron code caches are transient compiled cache blobs.',
+  '**/Code Cache/',
+  '',
+  '# 142,017 files across 39 roots. App Support Cache directories hold large runtime cache data.',
+  '**/Library/Application Support/*/Cache/',
+  '',
+  '# 125,968 files across 1 root. Homebrew Cellar contains large versioned dependency trees.',
+  '/opt/homebrew/Cellar/',
+  '',
+  '# 122,893 files across 44 roots. Service worker cache stores are high-churn browser app data.',
+  '**/Service Worker/CacheStorage/',
+  '',
+  '# 91,948 files across 1 root. Xcode DerivedData is disposable build/index output.',
+  '**/Library/Developer/Xcode/DerivedData/',
+  '',
+  '# 83,513 files across 2 roots. Local shared tool data is mostly generated cache/storage.',
+  '**/.local/share/',
+  '',
+  '# 70,040 files across 1 root. npm content cache is package artifact storage.',
+  '**/.npm/_cacache/',
+  '',
+  '# 48,386 files across 39 roots. target directories are compiler/build outputs and should not be indexed.',
+  '**/target/',
+  '',
+  '# 31,886 files across 1 root. Gradle caches are dependency/build artifacts and can be rebuilt.',
+  '**/.gradle/caches/',
+  '',
+  '# 28,765 files across 1 root. Cargo registry is Rust dependency cache.',
+  '**/.cargo/registry/',
+  '',
+  '# 25,015 files across 1 root. Homebrew shared docs/assets add large low-signal trees.',
+  '/opt/homebrew/share/',
+  '',
+  '# 16,390 files across 462 roots. IndexedDB contains app/browser internals with many small files.',
+  '**/IndexedDB/',
+  '',
+  '# 8,739 files across 91 roots. WebStorage is browser state data with low filename-search value.',
+  '**/WebStorage/',
+  '',
+  '# 6,122 files across 10 roots. Next.js build output is generated and frequently replaced.',
+  '**/.next/',
+  '',
+  '# Baseline exclusions re-added from previous defaults to avoid common dev/system noise.',
   '/cores/',
   '/dev/',
   '/private/',
-  '/System/Applications/**/Contents/Resources/',
   '/System/Volumes/',
   '/usr/share/',
   '/xarts/',
-
+  '/System/Applications/**/Contents/Resources/',
   '',
-  '# Common project/build caches',
-  'node_modules/',
-  '.next/',
-  '.bun/',
-  '.pnpm/',
+  '**/.git/',
+  '**/__pycache__/',
+  '**/.cocoapods/',
+  '**/.opam/',
+  '**/Cache/',
+  '**/Caches/',
+  '**/Index.noindex/',
+  '**/TextIndex/',
+  '**/io.tailscale.ipn.macos/',
+  '**/.stversions/',
+  '**/wharf/',
+  '**/Xcode.app/',
   '**/.local/fsindex*',
-
+  '**/*.com.google.Chrome',
+  '**/*.pyc',
+  '**/.dat.nosync*',
+  '**/webappsstore.sqlite-wal',
+  '**/.DS_Store',
   '',
-  '# Application-specific heavy caches',
   '**/com.docker.docker/Data/',
   '**/Firefox/Profiles/**/sessionstore-backups/',
   '**/Firefox/Profiles/**/storage/default/',
@@ -35,36 +121,9 @@ const DEFAULT_IGNORE_PATHS = [
   '**/var/postgres/pg_stat_tmp/',
   '**/var/postgres/pg_wal/',
   '**/Spotify/Users/*/pending-messages*',
-
   '',
-  '# Root user-library indexing data',
   '/Library/Biome/',
   '/Library/DuetExpertCenter/',
-
-  '',
-  '# Basename folders to ignore anywhere',
-  '.cache/',
-  '.cocoapods/',
-  '.git/',
-  '.opam/',
-  '__pycache__/',
-  'Cache/',
-  'Caches/',
-  'doc/',
-  'Xcode.app/',
-  'wharf/',
-  'Index.noindex/',
-  'TextIndex/',
-  'io.tailscale.ipn.macos/',
-  '.stversions/',
-
-  '',
-  '# File patterns',
-  '*.com.google.Chrome',
-  '*.pyc',
-  '.dat.nosync*',
-  'webappsstore.sqlite-wal',
-  '.DS_Store',
 ];
 
 const keepStringEntries = (next: unknown[]): string[] =>

From 85f5a113d37dbcc295017be5504d2bc67c0bcacd Mon Sep 17 00:00:00 2001
From: Mohamad Yahia <xyzt70@gmail.com>
Date: Tue, 3 Mar 2026 03:18:59 +0400
Subject: [PATCH 04/16] feat: add 'ignored/' folder to .gitignore

---
 .gitignore | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/.gitignore b/.gitignore
index fd531785..5d75306e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,4 @@
 target
 .DS_Store
-.vscode
\ No newline at end of file
+.vscode
+ignored/
\ No newline at end of file

From 1044e41afcfc93073ce196d3a109831abed93730 Mon Sep 17 00:00:00 2001
From: Mohamad Yahia <xyzt70@gmail.com>
Date: Tue, 3 Mar 2026 04:20:13 +0400
Subject: [PATCH 05/16] ui: move the export button to the bottom bar

---
 cardinal/src/App.css                          | 25 +++++++++++++------
 cardinal/src/App.tsx                          | 16 ++----------
 .../src/__tests__/App.contextMenu.test.tsx    | 19 ++++++++++----
 .../src/components/PreferencesOverlay.tsx     | 21 +++++++++-------
 cardinal/src/components/StatusBar.tsx         | 21 ++++++++++++++++
 .../__tests__/PreferencesOverlay.test.tsx     |  2 +-
 cardinal/src/constants/appEvents.ts           |  1 -
 cardinal/src/i18n/resources/en-US.json        |  2 +-
 cardinal/src/menu.ts                          | 11 --------
 9 files changed, 69 insertions(+), 49 deletions(-)

diff --git a/cardinal/src/App.css b/cardinal/src/App.css
index 3713f386..e745a6d5 100644
--- a/cardinal/src/App.css
+++ b/cardinal/src/App.css
@@ -1528,7 +1528,7 @@ button:active:not(:disabled) {
 
 .preferences-card {
   width: 100%;
-  max-width: 680px;
+  max-width: 480px;
   max-height: calc(100vh - 96px);
   background: var(--color-elevated-bg, var(--color-bg));
   color: var(--color-text);
@@ -1555,11 +1555,13 @@ button:active:not(:disabled) {
   display: flex;
   flex-direction: column;
   flex: 1;
-  overflow-y: scroll;
+  width: 100%;
+  box-sizing: border-box;
+  overflow-y: auto;
   overflow-x: hidden;
-  padding-right: 6px;
+  padding-right: 0px;
   min-height: 0;
-  scrollbar-gutter: stable;
+  scrollbar-gutter: auto;
   scrollbar-width: auto;
 }
 
@@ -1656,7 +1658,7 @@ button:active:not(:disabled) {
 .preferences-row {
   display: grid;
   grid-template-columns: minmax(0, 1fr) auto;
-  align-items: center;
+  align-items: start;
   gap: 16px;
   padding: 5px 0;
 }
@@ -1667,6 +1669,15 @@ button:active:not(:disabled) {
   white-space: nowrap;
 }
 
+.preferences-help-text {
+  margin-top: 4px;
+  max-width: 220px;
+  color: var(--color-text-secondary);
+  font-size: 0.8rem;
+  line-height: 1.35;
+  white-space: normal;
+}
+
 .preferences-row__details {
   min-width: 0;
 }
@@ -1720,12 +1731,12 @@ button:active:not(:disabled) {
 }
 
 .preferences-ignore-reset {
-  margin-top: 8px;
+  margin-left: 8px;
   border: 1px solid var(--color-elevated-border, var(--color-border));
   background: transparent;
   color: var(--color-text-secondary);
   border-radius: 8px;
-  padding: 6px 10px;
+  padding: 4px 6px;
   font-size: 0.82rem;
   cursor: pointer;
   transition:
diff --git a/cardinal/src/App.tsx b/cardinal/src/App.tsx
index 3973efe7..3655e142 100644
--- a/cardinal/src/App.tsx
+++ b/cardinal/src/App.tsx
@@ -36,7 +36,6 @@ import {
   buildListedFilesTsvRows,
   createListedFilesTsvFilename,
 } from './utils/exportListedFilesTsv';
-import { REQUEST_EXPORT_CURRENT_FILES_LIST_EVENT } from './constants/appEvents';
 import type { NodeInfoResponse } from './types/search';
 
 const EXPORT_BATCH_SIZE = 1000;
@@ -316,19 +315,6 @@ function App() {
     }
   }, [activeTab, currentQuery, displayedResults, t]);
 
-  useEffect(() => {
-    if (typeof window === 'undefined') {
-      return;
-    }
-    const onRequestExport = () => {
-      void handleExportListedFilesTsv();
-    };
-    window.addEventListener(REQUEST_EXPORT_CURRENT_FILES_LIST_EVENT, onRequestExport);
-    return () => {
-      window.removeEventListener(REQUEST_EXPORT_CURRENT_FILES_LIST_EVENT, onRequestExport);
-    };
-  }, [handleExportListedFilesTsv]);
-
   const renderRow = useCallback(
     (rowIndex: number, item: SearchResultItem | undefined, rowStyle: CSSProperties) => {
       if (!item) {
@@ -474,6 +460,8 @@ function App() {
           onTabChange={onTabChange}
           onRequestRescan={requestRescan}
           rescanErrorCount={rescanErrors}
+          canExportListedFiles={activeTab === 'files' && displayedResults.length > 0}
+          onRequestExportListedFilesTsv={handleExportListedFilesTsv}
         />
       </main>
       <PreferencesOverlay
diff --git a/cardinal/src/__tests__/App.contextMenu.test.tsx b/cardinal/src/__tests__/App.contextMenu.test.tsx
index 3a4b3b7b..1f2bdd58 100644
--- a/cardinal/src/__tests__/App.contextMenu.test.tsx
+++ b/cardinal/src/__tests__/App.contextMenu.test.tsx
@@ -3,7 +3,6 @@ import { forwardRef } from 'react';
 import type { CSSProperties } from 'react';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import App from '../App';
-import { REQUEST_EXPORT_CURRENT_FILES_LIST_EVENT } from '../constants/appEvents';
 
 const mocks = vi.hoisted(() => ({
   showFilesContextMenu: vi.fn(),
@@ -89,7 +88,17 @@ vi.mock('../components/PreferencesOverlay', () => ({
 }));
 
 vi.mock('../components/StatusBar', () => ({
-  default: () => null,
+  default: ({
+    onRequestExportListedFilesTsv,
+  }: {
+    onRequestExportListedFilesTsv?: () => Promise<void> | void;
+  }) => (
+    <button
+      type="button"
+      data-testid="status-export-trigger"
+      onClick={() => void onRequestExportListedFilesTsv?.()}
+    />
+  ),
 }));
 
 vi.mock('../components/FSEventsPanel', () => ({
@@ -373,7 +382,7 @@ describe('App context menu regression', () => {
       .mockResolvedValueOnce(undefined);
 
     render(<App />);
-    window.dispatchEvent(new Event(REQUEST_EXPORT_CURRENT_FILES_LIST_EVENT));
+    fireEvent.click(screen.getByTestId('status-export-trigger'));
 
     await waitFor(() => {
       expect(mocks.invoke).toHaveBeenCalledWith('write_listed_files_tsv', {
@@ -417,7 +426,7 @@ describe('App context menu regression', () => {
     mocks.invoke.mockResolvedValueOnce(null);
 
     render(<App />);
-    window.dispatchEvent(new Event(REQUEST_EXPORT_CURRENT_FILES_LIST_EVENT));
+    fireEvent.click(screen.getByTestId('status-export-trigger'));
 
     await waitFor(() => {
       expect(mocks.invoke).toHaveBeenCalledWith('prompt_save_listed_files_tsv', {
@@ -438,7 +447,7 @@ describe('App context menu regression', () => {
       .mockResolvedValueOnce(undefined);
 
     render(<App />);
-    window.dispatchEvent(new Event(REQUEST_EXPORT_CURRENT_FILES_LIST_EVENT));
+    fireEvent.click(screen.getByTestId('status-export-trigger'));
 
     await waitFor(() => {
       expect(mocks.invoke).toHaveBeenCalledWith('remove_listed_files_tsv', {
diff --git a/cardinal/src/components/PreferencesOverlay.tsx b/cardinal/src/components/PreferencesOverlay.tsx
index 6bf208f9..b82ede96 100644
--- a/cardinal/src/components/PreferencesOverlay.tsx
+++ b/cardinal/src/components/PreferencesOverlay.tsx
@@ -149,6 +149,7 @@ export function PreferencesOverlay({
       onClose();
     }
   };
+  const resetIgnorePathsLabel = `${t('preferences.reset')} ${t('ignorePaths.label')}`;
 
   return (
     <div
@@ -232,8 +233,17 @@ export function PreferencesOverlay({
           </div>
           <div className="preferences-row">
             <div className="preferences-row__details">
-              <p className="preferences-label" title={t('ignorePaths.help')}>
-                {t('ignorePaths.label')}
+              <p className="preferences-label">
+                <span title={t('ignorePaths.help')}>{t('ignorePaths.label')}</span>
+                <button
+                  className="preferences-ignore-reset"
+                  type="button"
+                  aria-label={resetIgnorePathsLabel}
+                  title={resetIgnorePathsLabel}
+                  onClick={handleResetIgnorePaths}
+                >
+                  <span aria-hidden="true">↺</span>
+                </button>
               </p>
             </div>
             <div className="preferences-control preferences-control--stack">
@@ -255,13 +265,6 @@ export function PreferencesOverlay({
                   {ignorePathsErrorMessage}
                 </p>
               ) : null}
-              <button
-                className="preferences-ignore-reset"
-                type="button"
-                onClick={handleResetIgnorePaths}
-              >
-                Reset ignores list
-              </button>
             </div>
           </div>
         </div>
diff --git a/cardinal/src/components/StatusBar.tsx b/cardinal/src/components/StatusBar.tsx
index 619e0974..11f40fe7 100644
--- a/cardinal/src/components/StatusBar.tsx
+++ b/cardinal/src/components/StatusBar.tsx
@@ -16,6 +16,8 @@ type StatusBarProps = {
   onTabChange: (tab: StatusTabKey) => void;
   onRequestRescan: () => void;
   rescanErrorCount: number;
+  canExportListedFiles?: boolean;
+  onRequestExportListedFilesTsv?: () => Promise<void> | void;
 };
 
 const TABS: StatusTabKey[] = ['files', 'events'];
@@ -25,6 +27,7 @@ const LIFECYCLE_META: Record<AppLifecycleStatus, { icon: string; tone: string }>
   Updating: { icon: '◑', tone: 'updating' },
   Ready: { icon: '●', tone: 'ready' },
 };
+const EXPORT_BUTTON_LABEL = 'Export current files list';
 
 const StatusBar = ({
   scannedFiles,
@@ -36,6 +39,8 @@ const StatusBar = ({
   onTabChange,
   onRequestRescan,
   rescanErrorCount,
+  canExportListedFiles = false,
+  onRequestExportListedFilesTsv,
 }: StatusBarProps): React.JSX.Element => {
   const { t } = useTranslation();
   const tabsRef = useRef<HTMLDivElement | null>(null);
@@ -104,6 +109,9 @@ const StatusBar = ({
   const handleOpenPreferences = useCallback(() => {
     openPreferences();
   }, []);
+  const handleRequestExport = useCallback(() => {
+    void onRequestExportListedFilesTsv?.();
+  }, [onRequestExportListedFilesTsv]);
 
   return (
     <div className="status-bar">
@@ -162,6 +170,19 @@ const StatusBar = ({
             </span>
             <span className="sr-only">{t('statusBar.aria.rescan')}</span>
           </button>
+          <button
+            type="button"
+            className="status-icon-button status-export-button"
+            onClick={handleRequestExport}
+            disabled={!canExportListedFiles}
+            title={EXPORT_BUTTON_LABEL}
+            aria-label={EXPORT_BUTTON_LABEL}
+          >
+            <span className="status-rescan-icon" aria-hidden="true">
+              ↓
+            </span>
+            <span className="sr-only">{EXPORT_BUTTON_LABEL}</span>
+          </button>
           <button
             type="button"
             className="status-icon-button status-settings-button"
diff --git a/cardinal/src/components/__tests__/PreferencesOverlay.test.tsx b/cardinal/src/components/__tests__/PreferencesOverlay.test.tsx
index 0153055e..aa543e2f 100644
--- a/cardinal/src/components/__tests__/PreferencesOverlay.test.tsx
+++ b/cardinal/src/components/__tests__/PreferencesOverlay.test.tsx
@@ -124,7 +124,7 @@ describe('PreferencesOverlay', () => {
     const ignorePathsInput = screen.getByLabelText('ignorePaths.label');
     fireEvent.change(ignorePathsInput, { target: { value: '/tmp/one\n/tmp/two' } });
 
-    fireEvent.click(screen.getByText('Reset ignores list'));
+    fireEvent.click(screen.getByRole('button', { name: 'preferences.reset ignorePaths.label' }));
 
     expect(ignorePathsInput).toHaveValue('# group\n/default/one\n\n/default/two');
     expect(onWatchConfigChange).not.toHaveBeenCalled();
diff --git a/cardinal/src/constants/appEvents.ts b/cardinal/src/constants/appEvents.ts
index 2c96d0df..91a1096b 100644
--- a/cardinal/src/constants/appEvents.ts
+++ b/cardinal/src/constants/appEvents.ts
@@ -1,2 +1 @@
 export const OPEN_PREFERENCES_EVENT = 'cardinal:open-preferences';
-export const REQUEST_EXPORT_CURRENT_FILES_LIST_EVENT = 'cardinal:request-export-current-files-list';
diff --git a/cardinal/src/i18n/resources/en-US.json b/cardinal/src/i18n/resources/en-US.json
index cdaf9e26..1413fec3 100644
--- a/cardinal/src/i18n/resources/en-US.json
+++ b/cardinal/src/i18n/resources/en-US.json
@@ -162,7 +162,7 @@
   },
   "ignorePaths": {
     "label": "Ignore paths",
-    "help": "One glob style pattern per line (Use .gitignore patterns like node_modules, **/node_modules/**, !keep.txt).",
+    "help": "One glob style pattern per line (Just like .gitignore)",
     "errors": {
       "absolute": "Please enter a non-empty glob path pattern."
     }
diff --git a/cardinal/src/menu.ts b/cardinal/src/menu.ts
index 73e51a11..5046f658 100644
--- a/cardinal/src/menu.ts
+++ b/cardinal/src/menu.ts
@@ -3,7 +3,6 @@ import { invoke } from '@tauri-apps/api/core';
 import { Menu, MenuItem, PredefinedMenuItem, Submenu } from '@tauri-apps/api/menu';
 import { openUrl } from '@tauri-apps/plugin-opener';
 import i18n from './i18n/config';
-import { REQUEST_EXPORT_CURRENT_FILES_LIST_EVENT } from './constants/appEvents';
 import { openPreferences } from './utils/openPreferences';
 
 const HELP_UPDATES_URL = 'https://github.com/cardisoft/cardinal/releases';
@@ -32,15 +31,6 @@ async function buildAppMenu(): Promise<void> {
       openPreferences();
     },
   });
-  const exportCurrentFilesListItem = await MenuItem.new({
-    id: 'menu.export_current_files_list',
-    text: 'Export current files list',
-    action: () => {
-      if (typeof window !== 'undefined') {
-        window.dispatchEvent(new Event(REQUEST_EXPORT_CURRENT_FILES_LIST_EVENT));
-      }
-    },
-  });
   const hideItem = await MenuItem.new({
     id: 'menu.hide',
     text: i18n.t('menu.hide'),
@@ -56,7 +46,6 @@ async function buildAppMenu(): Promise<void> {
       aboutItem,
       await PredefinedMenuItem.new({ item: 'Separator' }),
       preferencesItem,
-      exportCurrentFilesListItem,
       hideItem,
       await PredefinedMenuItem.new({ item: 'Separator' }),
       await PredefinedMenuItem.new({

From 4d4d2cddc20873ead997f526776b21793596964f Mon Sep 17 00:00:00 2001
From: Mohamad Yahia <xyzt70@gmail.com>
Date: Tue, 3 Mar 2026 05:48:46 +0400
Subject: [PATCH 06/16] feat(ignore-paths): expand home-relative paths

---
 cardinal/src-tauri/src/commands.rs | 22 +++++++++++++++++++++-
 1 file changed, 21 insertions(+), 1 deletion(-)

diff --git a/cardinal/src-tauri/src/commands.rs b/cardinal/src-tauri/src/commands.rs
index c3bcd1f1..232ad49e 100644
--- a/cardinal/src-tauri/src/commands.rs
+++ b/cardinal/src-tauri/src/commands.rs
@@ -183,8 +183,15 @@ fn normalize_path_input(raw: &str) -> Option<String> {
 /// Normalizes ignore entries.
 ///
 /// Keeps raw entries so matching follows gitignore semantics exactly,
-/// including empty lines and comments.
+/// including empty lines and comments. A leading `~` is expanded so
+/// existing home-relative ignore entries keep matching.
 fn normalize_ignore_path_input(raw: &str) -> String {
+    if raw == "~" || raw.starts_with("~/") {
+        if let Some(expanded) = expand_path_input(raw) {
+            return expanded;
+        }
+    }
+
     raw.to_string()
 }
 
@@ -658,6 +665,19 @@ mod tests {
         );
     }
 
+    #[test]
+    fn normalize_ignore_expands_home_prefixed_paths() {
+        let Ok(home) = std::env::var("HOME") else {
+            return;
+        };
+
+        assert_eq!(normalize_ignore_path_input("~"), home.clone());
+        assert_eq!(
+            normalize_ignore_path_input("~/Library/Caches"),
+            format!("{home}/Library/Caches")
+        );
+    }
+
     #[test]
     fn normalize_ignore_keeps_gitignore_syntax_verbatim() {
         assert_eq!(

From c386e82a6239e7acc542660fef05cf607a4b0288 Mon Sep 17 00:00:00 2001
From: Donough Liu <ldm2993593805@163.com>
Date: Sat, 21 Feb 2026 16:10:05 +0800
Subject: [PATCH 07/16] perf: dedupe path ignore check in fswalk; remove
 incorrect interrupt handling (#146)

---
 fswalk/src/lib.rs | 23 +++++++----------------
 1 file changed, 7 insertions(+), 16 deletions(-)

diff --git a/fswalk/src/lib.rs b/fswalk/src/lib.rs
index b248f6f2..33040990 100644
--- a/fswalk/src/lib.rs
+++ b/fswalk/src/lib.rs
@@ -289,7 +289,7 @@ fn walk(path: &Path, walk_data: &WalkData) -> Option<Node> {
                                         .to_string_lossy()
                                         .into_owned()
                                         .into_boxed_str();
-                                    return Some(Node {
+                                    Some(Node {
                                         children: vec![],
                                         name,
                                         metadata: walk_data
@@ -299,30 +299,21 @@ fn walk(path: &Path, walk_data: &WalkData) -> Option<Node> {
                                                 // doesn't traverse symlink
                                                 entry.metadata().ok().map(NodeMetadata::from)
                                             }),
-                                    });
+                                    })
                                 }
+                            } else {
+                                None
                             }
                         }
-                        Err(failed) => {
-                            if handle_error_and_retry(failed) {
-                                return walk(path, walk_data);
-                            }
-                        }
+                        Err(_) => None,
                     }
-                    None
                 })
                 .collect(),
-            Err(failed) => {
-                if handle_error_and_retry(&failed) {
-                    return walk(path, walk_data);
-                } else {
-                    vec![]
-                }
-            }
+            Err(_) => Vec::new(),
         }
     } else {
         walk_data.num_files.fetch_add(1, Ordering::Relaxed);
-        vec![]
+        Vec::new()
     };
     if walk_data
         .cancel

From 4e64288d88f55629ef72f392abc8dc20e4e30ec5 Mon Sep 17 00:00:00 2001
From: Donough Liu <ldm2993593805@163.com>
Date: Tue, 24 Feb 2026 04:17:00 +0800
Subject: [PATCH 08/16] feat: make scanning process cancellable (#149)

* refactor: replace AtomicBool with generic function for cancellation in WalkData

* feat: add new_scan method for active scanning process version management

* feat: make scanning process cancellable

Currently there are tree paths that full file system scanning could happen:
1. first boot with no cache on disk
2. pressing rescan button
3. watch config updated(root path or ignore paths)

This commit make the scanning process cancellable. People can interrupt scanning process by clicking rescan button or changing watch config in settings panel.

* fix: make noop EventWatcher.recv never return

* Remove unnecessary filter of handle_watch_config_update

When last update was cancelled, the watch root tracked in search cache will not be updated. If the next update uses the old(non updated) watch root, currently it will be filtered, which the make status bar stuck.

* test: add tests for CancellationToken behavior and scan token management

* feat: optimize watch config handling to prevent unnecessary updates

* refactor: add TODO to replace watch_root with cache's path in run_logic_thread

* feat: add noop method to SearchCache for handling cancellation scenarios

* refactor: remove existing cache even if current fswalk is cancelled

* fix: make initial search cache respect watch config change

* fix: Don't cerate event watcher when initial search cache building is cancelled

* test: add tests for noop watchers and watch config updates

* fix: simplify is_noop method by using is_empty for collections

* fix: update event watcher handling to use noop for no-op caches

* test: add tests for noop cache properties and walk_data propagation

* fix: update app state to 'Updating' when using noop event watcher
---
 cardinal-sdk/src/event_stream.rs              |  43 +-
 cardinal/src-tauri/src/background.rs          | 102 +++--
 cardinal/src-tauri/src/commands.rs            |   8 +-
 cardinal/src-tauri/src/lib.rs                 |  45 ++-
 .../hooks/__tests__/useAppPreferences.test.ts | 155 ++++++++
 cardinal/src/hooks/useAppPreferences.ts       |  17 +-
 lsf/src/main.rs                               |   9 +-
 .../tests/edge_cases_comprehensive.rs         |   2 +-
 search-cache/tests/scan_cancellation.rs       | 368 ++++++++++++++++++
 search-cancel/src/lib.rs                      |  70 ++++
 search-cancel/tests/more.rs                   | 133 ++++++-
 11 files changed, 887 insertions(+), 65 deletions(-)
 create mode 100644 search-cache/tests/scan_cancellation.rs

diff --git a/cardinal-sdk/src/event_stream.rs b/cardinal-sdk/src/event_stream.rs
index 25c53423..1c8905fd 100644
--- a/cardinal-sdk/src/event_stream.rs
+++ b/cardinal-sdk/src/event_stream.rs
@@ -15,6 +15,7 @@ use std::{
     ops::{Deref, DerefMut},
     ptr::NonNull,
     slice,
+    sync::LazyLock,
 };
 
 type EventsCallback = Box<dyn FnMut(Vec<FsEvent>) + Send>;
@@ -153,9 +154,13 @@ impl DerefMut for EventWatcher {
 
 impl EventWatcher {
     pub fn noop() -> Self {
+        #[allow(clippy::type_complexity)]
+        static BLACK_HOLE1: LazyLock<(Sender<Vec<FsEvent>>, Receiver<Vec<FsEvent>>)> =
+            LazyLock::new(unbounded);
+        static BLACK_HOLE2: LazyLock<(Sender<()>, Receiver<()>)> = LazyLock::new(|| bounded(1));
         Self {
-            receiver: unbounded().1,
-            _cancellation_token: bounded::<()>(1).0,
+            receiver: BLACK_HOLE1.1.clone(),
+            _cancellation_token: BLACK_HOLE2.0.clone(),
         }
     }
 
@@ -200,6 +205,40 @@ mod tests {
     use std::time::{Duration, Instant};
     use tempfile::tempdir;
 
+    #[test]
+    fn noop_event_watcher_recv_timeout_never_disconnects() {
+        let watcher = EventWatcher::noop();
+        let result = watcher.recv_timeout(Duration::from_millis(50));
+        assert!(
+            matches!(result, Err(RecvTimeoutError::Timeout)),
+            "noop watcher should block waiting for events instead of disconnecting"
+        );
+    }
+
+    /// Before the LazyLock fix each `noop()` call created a fresh channel pair
+    /// and immediately dropped its sender, causing `Disconnected` on the very
+    /// first `recv_timeout`. This test locks in the correct shared-channel behaviour:
+    /// multiple concurrent noop watchers must all time out, never disconnect.
+    #[test]
+    fn multiple_noop_watchers_all_timeout_not_disconnected() {
+        let watchers: Vec<_> = (0..4).map(|_| EventWatcher::noop()).collect();
+        for (i, w) in watchers.iter().enumerate() {
+            let result = w.recv_timeout(Duration::from_millis(30));
+            assert!(
+                matches!(result, Err(RecvTimeoutError::Timeout)),
+                "noop watcher #{i} disconnected — shared BLACK_HOLE channel not working"
+            );
+        }
+        // Dropping them should not affect the shared channel used by others.
+        drop(watchers);
+        let late = EventWatcher::noop();
+        let result = late.recv_timeout(Duration::from_millis(30));
+        assert!(
+            matches!(result, Err(RecvTimeoutError::Timeout)),
+            "noop watcher created after previous ones dropped must still timeout"
+        );
+    }
+
     #[test]
     fn event_watcher_on_non_existent_path() {
         let (_dev, watcher) = EventWatcher::spawn("/e mm".to_string(), current_event_id(), 0.05);
diff --git a/cardinal/src-tauri/src/background.rs b/cardinal/src-tauri/src/background.rs
index bf558ad3..d8d90031 100644
--- a/cardinal/src-tauri/src/background.rs
+++ b/cardinal/src-tauri/src/background.rs
@@ -1,6 +1,6 @@
 use crate::{
     commands::{NodeInfoRequest, SearchJob, WatchConfigUpdate},
-    lifecycle::{AppLifecycleState, load_app_state, update_app_state},
+    lifecycle::{APP_QUIT, AppLifecycleState, load_app_state, update_app_state},
     search_activity,
     window_controls::is_main_window_foreground,
 };
@@ -15,6 +15,7 @@ use search_cache::{
     HandleFSEError, SearchCache, SearchOptions, SearchOutcome, SearchResultNode, SlabIndex,
     WalkData,
 };
+use search_cancel::CancellationToken;
 use serde::Serialize;
 use std::{
     path::{Path, PathBuf},
@@ -46,7 +47,7 @@ pub struct BackgroundLoopChannels {
     pub result_tx: Sender<Result<SearchOutcome>>,
     pub node_info_rx: Receiver<NodeInfoRequest>,
     pub icon_viewport_rx: Receiver<(u64, Vec<SlabIndex>)>,
-    pub rescan_rx: Receiver<()>,
+    pub rescan_rx: Receiver<CancellationToken>,
     pub watch_config_rx: Receiver<WatchConfigUpdate>,
     pub icon_update_tx: Sender<IconPayload>,
 }
@@ -104,45 +105,63 @@ fn handle_watch_config_update(
     processed_events: &mut usize,
 ) {
     info!("Received watch config update: {:?}", update);
-    let trimmed_watch_root = update.watch_root.trim();
-    let next_watch_root = if trimmed_watch_root.is_empty() {
-        watch_root.as_str()
-    } else {
-        trimmed_watch_root
-    };
+    let WatchConfigUpdate {
+        watch_root: next_watch_root,
+        ignore_paths,
+        scan_cancellation_token,
+    } = update;
 
-    let next_ignore_paths = update
-        .ignore_paths
+    let next_ignore_paths = ignore_paths
         .into_iter()
         .map(PathBuf::from)
         .collect::<Vec<_>>();
 
-    if next_watch_root == watch_root && &next_ignore_paths == cache.ignore_paths() {
-        return;
-    }
-
     *event_watcher = EventWatcher::noop();
     update_app_state(app_handle, AppLifecycleState::Initializing);
     reset_status_bar(app_handle);
     *history_ready = false;
     *processed_events = 0;
 
-    let Some(next_cache) = build_search_cache(app_handle, next_watch_root, &next_ignore_paths)
-    else {
-        info!("Watch config change cancelled, keeping existing state");
-        return;
+    let next_cache = match build_search_cache(
+        app_handle,
+        &next_watch_root,
+        &next_ignore_paths,
+        scan_cancellation_token,
+    ) {
+        Some(cache) => {
+            info!(
+                "Search cache built. New root: {}, ignore paths: {:?}",
+                next_watch_root, next_ignore_paths
+            );
+            emit_status_bar_update(app_handle, cache.get_total_files(), 0, 0);
+            cache
+        }
+        None => {
+            // if cache build is cancelled, we cannot reuse the old cache since
+            // it's tied to the old watch root and ignore paths; create a noop
+            // cache instead
+            info!("Watch config change cancelled, use noop state");
+            SearchCache::noop(
+                PathBuf::from(&next_watch_root),
+                next_ignore_paths,
+                &APP_QUIT,
+            )
+        }
     };
 
-    emit_status_bar_update(app_handle, next_cache.get_total_files(), 0, 0);
     *cache = next_cache;
     *watch_root = next_watch_root.to_string();
-    *event_watcher = EventWatcher::spawn(
-        watch_root.to_string(),
-        cache.last_event_id(),
-        fse_latency_secs,
-    )
-    .1;
-    update_app_state(app_handle, AppLifecycleState::Updating);
+    *event_watcher = if cache.is_noop() {
+        EventWatcher::noop()
+    } else {
+        update_app_state(app_handle, AppLifecycleState::Updating);
+        EventWatcher::spawn(
+            watch_root.to_string(),
+            cache.last_event_id(),
+            fse_latency_secs,
+        )
+        .1
+    };
 }
 
 struct EventSnapshot {
@@ -308,7 +327,8 @@ pub fn run_background_event_loop(
         crossbeam_channel::select! {
             recv(finish_rx) -> tx => {
                 let tx = tx.expect("Finish channel closed");
-                tx.send(Some(cache)).expect("Failed to send cache");
+                // Only save cache if it's not a noop (i.e. the initial walk wasn't cancelled), otherwise send None to avoid writing an empty cache file
+                tx.send((!cache.is_noop()).then_some(cache)).expect("Failed to send cache");
                 return;
             }
             recv(update_window_state_rx) -> _ => {
@@ -353,7 +373,7 @@ pub fn run_background_event_loop(
                 handle_icon_viewport_update(&mut cache, update, &icon_update_tx);
             }
             recv(rescan_rx) -> request => {
-                request.expect("Rescan channel closed");
+                let scan_cancellation_token = request.expect("Rescan channel closed");
                 info!("Manual rescan requested");
                 perform_rescan(
                     app_handle,
@@ -363,6 +383,7 @@ pub fn run_background_event_loop(
                     fse_latency_secs,
                     &mut history_ready,
                     &mut processed_events,
+                    scan_cancellation_token,
                 );
             }
             recv(watch_config_rx) -> update => {
@@ -396,14 +417,12 @@ pub(crate) fn build_search_cache(
     app_handle: &AppHandle,
     watch_root: &str,
     ignore_paths: &[PathBuf],
+    scan_cancellation_token: CancellationToken,
 ) -> Option<SearchCache> {
-    let path = PathBuf::from(watch_root);
-    let walk_data = WalkData::new(
-        &path,
-        ignore_paths,
-        false,
-        Some(&crate::lifecycle::APP_QUIT),
-    );
+    let path = Path::new(watch_root);
+    let walk_data = WalkData::new(path, ignore_paths, false, move || {
+        APP_QUIT.load(Ordering::Relaxed) || scan_cancellation_token.is_cancelled().is_none()
+    });
     let walking_done = AtomicBool::new(false);
 
     std::thread::scope(|s| {
@@ -416,8 +435,7 @@ pub(crate) fn build_search_cache(
                 std::thread::sleep(Duration::from_millis(100));
             }
         });
-        let cache =
-            SearchCache::walk_fs_with_walk_data(&walk_data, Some(&crate::lifecycle::APP_QUIT));
+        let cache = SearchCache::walk_fs_with_walk_data(&walk_data, Some(&APP_QUIT));
         walking_done.store(true, Ordering::Relaxed);
         cache
     })
@@ -432,7 +450,13 @@ fn perform_rescan(
     fse_latency_secs: f64,
     history_ready: &mut bool,
     processed_events: &mut usize,
+    scan_cancellation_token: CancellationToken,
 ) {
+    if scan_cancellation_token.is_cancelled().is_none() {
+        info!("Skipping stale rescan request");
+        return;
+    }
+
     *event_watcher = EventWatcher::noop();
     update_app_state(app_handle, AppLifecycleState::Initializing);
     *history_ready = false;
@@ -441,7 +465,7 @@ fn perform_rescan(
 
     let mut phantom1 = PathBuf::new();
     let mut phantom2 = Vec::new();
-    let walk_data = cache.walk_data(&mut phantom1, &mut phantom2);
+    let walk_data = cache.walk_data(&mut phantom1, &mut phantom2, scan_cancellation_token);
     let walking_done = AtomicBool::new(false);
     let stopped = std::thread::scope(|s| {
         s.spawn(|| {
@@ -462,6 +486,7 @@ fn perform_rescan(
     *event_watcher = if stopped {
         EventWatcher::noop()
     } else {
+        update_app_state(app_handle, AppLifecycleState::Updating);
         EventWatcher::spawn(
             watch_root.to_string(),
             cache.last_event_id(),
@@ -469,7 +494,6 @@ fn perform_rescan(
         )
         .1
     };
-    update_app_state(app_handle, AppLifecycleState::Updating);
 }
 
 fn unix_timestamp_now() -> i64 {
diff --git a/cardinal/src-tauri/src/commands.rs b/cardinal/src-tauri/src/commands.rs
index 232ad49e..cdd31a30 100644
--- a/cardinal/src-tauri/src/commands.rs
+++ b/cardinal/src-tauri/src/commands.rs
@@ -35,6 +35,7 @@ use tracing::{error, info, warn};
 pub struct WatchConfigUpdate {
     pub watch_root: String,
     pub ignore_paths: Vec<String>,
+    pub scan_cancellation_token: CancellationToken,
 }
 
 #[derive(Debug, Clone, Copy, Deserialize, Default)]
@@ -76,7 +77,7 @@ pub struct SearchState {
     node_info_tx: Sender<NodeInfoRequest>,
 
     icon_viewport_tx: Sender<(u64, Vec<SlabIndex>)>,
-    rescan_tx: Sender<()>,
+    rescan_tx: Sender<CancellationToken>,
     watch_config_tx: Sender<WatchConfigUpdate>,
     sorted_view_cache: Mutex<Option<SortedViewCache>>,
     pub(crate) update_window_state_tx: Sender<()>,
@@ -88,7 +89,7 @@ impl SearchState {
         result_rx: Receiver<Result<SearchOutcome>>,
         node_info_tx: Sender<NodeInfoRequest>,
         icon_viewport_tx: Sender<(u64, Vec<SlabIndex>)>,
-        rescan_tx: Sender<()>,
+        rescan_tx: Sender<CancellationToken>,
         watch_config_tx: Sender<WatchConfigUpdate>,
         update_window_state_tx: Sender<()>,
     ) -> Self {
@@ -393,7 +394,7 @@ pub async fn get_app_status() -> String {
 
 #[tauri::command(async)]
 pub fn trigger_rescan(state: State<'_, SearchState>) {
-    if let Err(e) = state.rescan_tx.send(()) {
+    if let Err(e) = state.rescan_tx.send(CancellationToken::new_scan()) {
         error!("Failed to request rescan: {e:?}");
     }
 }
@@ -413,6 +414,7 @@ pub fn set_watch_config(
     if let Err(e) = state.watch_config_tx.send(WatchConfigUpdate {
         watch_root,
         ignore_paths,
+        scan_cancellation_token: CancellationToken::new_scan(),
     }) {
         error!("Failed to request watch config change: {e:?}");
     }
diff --git a/cardinal/src-tauri/src/lib.rs b/cardinal/src-tauri/src/lib.rs
index 7ffeba95..2247d801 100644
--- a/cardinal/src-tauri/src/lib.rs
+++ b/cardinal/src-tauri/src/lib.rs
@@ -26,6 +26,7 @@ use lifecycle::{
 };
 use once_cell::sync::OnceCell;
 use search_cache::{SearchCache, SearchOutcome, SlabIndex};
+use search_cancel::CancellationToken;
 use std::{
     path::{Path, PathBuf},
     sync::{Once, atomic::Ordering},
@@ -61,7 +62,7 @@ pub fn run() -> Result<()> {
     let (result_tx, result_rx) = unbounded::<Result<SearchOutcome>>();
     let (node_info_tx, node_info_rx) = unbounded::<NodeInfoRequest>();
     let (icon_viewport_tx, icon_viewport_rx) = unbounded::<(u64, Vec<SlabIndex>)>();
-    let (rescan_tx, rescan_rx) = unbounded::<()>();
+    let (rescan_tx, rescan_rx) = unbounded::<CancellationToken>();
     let (watch_config_tx, watch_config_rx) = unbounded::<WatchConfigUpdate>();
     let (icon_update_tx, icon_update_rx) = unbounded::<IconPayload>();
     let (update_window_state_tx, update_window_state_rx) = bounded::<()>(1);
@@ -255,7 +256,15 @@ fn run_logic_thread(
         }
         Err(e) => {
             info!("Walking filesystem: {:?}", e);
-            let Some(cache) = build_search_cache(app_handle, &watch_root, &ignore_paths) else {
+            if let Some(cache) = build_search_cache(
+                app_handle,
+                &watch_root,
+                &ignore_paths,
+                CancellationToken::new_scan(),
+            ) {
+                emit_status_bar_update(app_handle, cache.get_total_files(), 0, 0);
+                cache
+            } else if APP_QUIT.load(Ordering::Relaxed) {
                 info!("Walk filesystem cancelled, app quitting");
                 channels
                     .finish_rx
@@ -264,24 +273,28 @@ fn run_logic_thread(
                     .send(None)
                     .expect("Failed to send None cache");
                 return;
-            };
-
-            emit_status_bar_update(app_handle, cache.get_total_files(), 0, 0);
-
-            cache
+            } else {
+                info!("Initial scan cancelled by newer request, use noop cache");
+                SearchCache::noop(path.clone(), ignore_paths.clone(), &APP_QUIT)
+            }
         }
     };
 
-    let event_watcher = EventWatcher::spawn(
-        watch_root.to_string(),
-        cache.last_event_id(),
-        FSE_LATENCY_SECS,
-    )
-    .1;
-    if load_app_state() != AppLifecycleState::Ready {
+    let event_watcher = if cache.is_noop() {
+        info!("Using noop event watcher due to cancelled initial scan");
+        EventWatcher::noop()
+    } else {
         update_app_state(app_handle, AppLifecycleState::Updating);
-    }
+        EventWatcher::spawn(
+            watch_root.to_string(),
+            cache.last_event_id(),
+            FSE_LATENCY_SECS,
+        )
+        .1
+    };
+
     info!("Started background processing thread");
+    // TODO(ldm0): remove this watch_root, use cache's path instead
     run_background_event_loop(
         app_handle,
         cache,
@@ -315,7 +328,7 @@ fn flush_cache_to_file_once(finish_tx: &Sender<Sender<Option<SearchCache>>>, db_
 
             info!("Cache flushed successfully to {:?}", db_path);
         } else {
-            info!("Cancelled during data construction, no cache to flush");
+            info!("Cancelled before data constructed, no cache to flush");
         }
     });
 }
diff --git a/cardinal/src/hooks/__tests__/useAppPreferences.test.ts b/cardinal/src/hooks/__tests__/useAppPreferences.test.ts
index 0b80759c..10ea75e1 100644
--- a/cardinal/src/hooks/__tests__/useAppPreferences.test.ts
+++ b/cardinal/src/hooks/__tests__/useAppPreferences.test.ts
@@ -145,6 +145,161 @@ describe('useAppPreferences', () => {
     expect(refreshSearchResults).toHaveBeenCalledTimes(1);
   });
 
+  it('skips setWatchConfig when watch config is unchanged', async () => {
+    const { result } = renderHook(() =>
+      useAppPreferences({
+        fullDiskAccessStatus: 'granted',
+        isCheckingFullDiskAccess: false,
+        refreshSearchResults,
+        i18n: { changeLanguage },
+      }),
+    );
+
+    await waitFor(() => {
+      expect(mockedInvoke).toHaveBeenCalledWith('start_logic', {
+        watchRoot: '/workspace',
+        ignorePaths: ['/Volumes'],
+      });
+    });
+
+    mockedSetWatchConfig.mockClear();
+    refreshSearchResults.mockClear();
+    setWatchRoot.mockClear();
+    setIgnorePaths.mockClear();
+
+    act(() => {
+      result.current.handleWatchConfigChange({
+        watchRoot: '/workspace',
+        ignorePaths: ['/Volumes'],
+      });
+    });
+
+    expect(setWatchRoot).not.toHaveBeenCalled();
+    expect(setIgnorePaths).not.toHaveBeenCalled();
+    expect(mockedSetWatchConfig).not.toHaveBeenCalled();
+    expect(refreshSearchResults).not.toHaveBeenCalled();
+  });
+
+  it('updates watch config when only watchRoot changes', async () => {
+    const { result } = renderHook(() =>
+      useAppPreferences({
+        fullDiskAccessStatus: 'granted',
+        isCheckingFullDiskAccess: false,
+        refreshSearchResults,
+        i18n: { changeLanguage },
+      }),
+    );
+
+    await waitFor(() => {
+      expect(mockedInvoke).toHaveBeenCalledWith('start_logic', {
+        watchRoot: '/workspace',
+        ignorePaths: ['/Volumes'],
+      });
+    });
+
+    mockedSetWatchConfig.mockClear();
+    refreshSearchResults.mockClear();
+    setWatchRoot.mockClear();
+    setIgnorePaths.mockClear();
+
+    act(() => {
+      result.current.handleWatchConfigChange({
+        watchRoot: '/new-root',
+        ignorePaths: ['/Volumes'], // same as before
+      });
+    });
+
+    expect(setWatchRoot).toHaveBeenCalledWith('/new-root');
+    expect(setIgnorePaths).toHaveBeenCalledWith(['/Volumes']);
+    expect(mockedSetWatchConfig).toHaveBeenCalledWith({
+      watchRoot: '/new-root',
+      ignorePaths: ['/Volumes'],
+    });
+    expect(refreshSearchResults).toHaveBeenCalledTimes(1);
+  });
+
+  it('updates watch config when only ignorePaths changes', async () => {
+    const { result } = renderHook(() =>
+      useAppPreferences({
+        fullDiskAccessStatus: 'granted',
+        isCheckingFullDiskAccess: false,
+        refreshSearchResults,
+        i18n: { changeLanguage },
+      }),
+    );
+
+    await waitFor(() => {
+      expect(mockedInvoke).toHaveBeenCalledWith('start_logic', {
+        watchRoot: '/workspace',
+        ignorePaths: ['/Volumes'],
+      });
+    });
+
+    mockedSetWatchConfig.mockClear();
+    refreshSearchResults.mockClear();
+    setWatchRoot.mockClear();
+    setIgnorePaths.mockClear();
+
+    act(() => {
+      result.current.handleWatchConfigChange({
+        watchRoot: '/workspace', // same as before
+        ignorePaths: ['/tmp/ignore'], // different
+      });
+    });
+
+    expect(setWatchRoot).toHaveBeenCalledWith('/workspace');
+    expect(setIgnorePaths).toHaveBeenCalledWith(['/tmp/ignore']);
+    expect(mockedSetWatchConfig).toHaveBeenCalledWith({
+      watchRoot: '/workspace',
+      ignorePaths: ['/tmp/ignore'],
+    });
+    expect(refreshSearchResults).toHaveBeenCalledTimes(1);
+  });
+
+  it('treats reordered ignorePaths as a change', async () => {
+    // areStringArraysEqual is index-sensitive: same strings in different order
+    // must NOT be treated as equal, so the update must fire.
+    mockedUseIgnorePaths.mockReturnValue({
+      ignorePaths: ['/Volumes', '/System'],
+      setIgnorePaths,
+      defaultIgnorePaths: ['/Volumes', '/System'],
+    });
+
+    const { result } = renderHook(() =>
+      useAppPreferences({
+        fullDiskAccessStatus: 'granted',
+        isCheckingFullDiskAccess: false,
+        refreshSearchResults,
+        i18n: { changeLanguage },
+      }),
+    );
+
+    await waitFor(() => {
+      expect(mockedInvoke).toHaveBeenCalledWith('start_logic', {
+        watchRoot: '/workspace',
+        ignorePaths: ['/Volumes', '/System'],
+      });
+    });
+
+    mockedSetWatchConfig.mockClear();
+    refreshSearchResults.mockClear();
+    setWatchRoot.mockClear();
+    setIgnorePaths.mockClear();
+
+    act(() => {
+      result.current.handleWatchConfigChange({
+        watchRoot: '/workspace',
+        ignorePaths: ['/System', '/Volumes'], // same items, different order
+      });
+    });
+
+    expect(mockedSetWatchConfig).toHaveBeenCalledWith({
+      watchRoot: '/workspace',
+      ignorePaths: ['/System', '/Volumes'],
+    });
+    expect(refreshSearchResults).toHaveBeenCalledTimes(1);
+  });
+
   it('opens and closes preferences, and resets user preferences', async () => {
     const { result } = renderHook(() =>
       useAppPreferences({
diff --git a/cardinal/src/hooks/useAppPreferences.ts b/cardinal/src/hooks/useAppPreferences.ts
index 0e04c5ce..87ac57be 100644
--- a/cardinal/src/hooks/useAppPreferences.ts
+++ b/cardinal/src/hooks/useAppPreferences.ts
@@ -37,6 +37,9 @@ type UseAppPreferencesResult = {
   handleResetPreferences: () => void;
 };
 
+const areStringArraysEqual = (left: string[], right: string[]): boolean =>
+  left.length === right.length && left.every((value, index) => value === right[index]);
+
 /**
  * Manages app preferences including watch config, tray, theme, language, and overlay state.
  * Provides actions for updating watch settings and resetting preferences to defaults.
@@ -89,14 +92,24 @@ export function useAppPreferences({
 
   const applyWatchConfig = useCallback(
     (nextWatchRoot: string, nextIgnorePaths: string[]) => {
+      const watchConfigChanged =
+        nextWatchRoot !== watchRoot || !areStringArraysEqual(nextIgnorePaths, ignorePaths);
+
+      if (!watchConfigChanged) {
+        return;
+      }
+
       setWatchRoot(nextWatchRoot);
       setIgnorePaths(nextIgnorePaths);
       if (logicStartedRef.current && nextWatchRoot) {
-        void setWatchConfig({ watchRoot: nextWatchRoot, ignorePaths: nextIgnorePaths });
+        void setWatchConfig({
+          watchRoot: nextWatchRoot,
+          ignorePaths: nextIgnorePaths,
+        });
       }
       refreshSearchResults();
     },
-    [refreshSearchResults, setIgnorePaths, setWatchRoot],
+    [ignorePaths, refreshSearchResults, setIgnorePaths, setWatchRoot, watchRoot],
   );
 
   const handleWatchConfigChange = useCallback(
diff --git a/lsf/src/main.rs b/lsf/src/main.rs
index 1ec919f7..6caa5b2e 100644
--- a/lsf/src/main.rs
+++ b/lsf/src/main.rs
@@ -72,7 +72,14 @@ fn main() -> Result<()> {
                         {
                             event_watcher = EventWatcher::noop();
                         }
-                        cache.rescan();
+                        let mut scan_root = PathBuf::new();
+                        let mut scan_ignore_paths = Vec::new();
+                        let walk_data = cache.walk_data(
+                            &mut scan_root,
+                            &mut scan_ignore_paths,
+                            CancellationToken::new_scan(),
+                        );
+                        let _ = cache.rescan_with_walk_data(&walk_data);
                         event_watcher = EventWatcher::spawn("/".to_string(), cache.last_event_id(), 0.1).1;
                     }
                 }
diff --git a/search-cache/tests/edge_cases_comprehensive.rs b/search-cache/tests/edge_cases_comprehensive.rs
index c0cc8773..d615bad2 100644
--- a/search-cache/tests/edge_cases_comprehensive.rs
+++ b/search-cache/tests/edge_cases_comprehensive.rs
@@ -85,7 +85,7 @@ fn test_cancellation_with_stop_flag() {
     }
 
     let stop = Box::leak(Box::new(AtomicBool::new(false)));
-    let walk_data = fswalk::WalkData::new(&root_path, &[], false, Some(stop));
+    let walk_data = fswalk::WalkData::new(&root_path, &[], false, || stop.load(Ordering::Relaxed));
     let mut cache = SearchCache::walk_fs_with_walk_data(&walk_data, Some(stop)).unwrap();
 
     // Set stop flag during search, then create new token to cancel previous
diff --git a/search-cache/tests/scan_cancellation.rs b/search-cache/tests/scan_cancellation.rs
new file mode 100644
index 00000000..6eb9d4f1
--- /dev/null
+++ b/search-cache/tests/scan_cancellation.rs
@@ -0,0 +1,368 @@
+use search_cache::SearchCache;
+use search_cancel::CancellationToken;
+use std::{
+    fs,
+    path::PathBuf,
+    sync::{LazyLock, Mutex, atomic::AtomicBool},
+};
+use tempdir::TempDir;
+
+static SCAN_TOKEN_LOCK: LazyLock<Mutex<()>> = LazyLock::new(|| Mutex::new(()));
+
+/// A stop flag that is always set — simulates a shutdown-in-progress scenario.
+static ALWAYS_STOPPED: AtomicBool = AtomicBool::new(true);
+
+/// A stop flag that is never set — stand-in for a running application.
+static NEVER_STOPPED: AtomicBool = AtomicBool::new(false);
+
+fn build_cache() -> (TempDir, SearchCache) {
+    let temp_dir = TempDir::new("scan_cancellation").expect("failed to create tempdir");
+    let root = temp_dir.path();
+
+    fs::create_dir_all(root.join("src")).expect("failed to create src");
+    fs::write(root.join("src/main.rs"), "fn main() {}").expect("failed to create fixture file");
+
+    let cache = SearchCache::walk_fs(root);
+    (temp_dir, cache)
+}
+
+// ── SearchCache::noop() ──────────────────────────────────────────────────────
+
+#[test]
+fn noop_cache_is_noop_returns_true() {
+    let cache = SearchCache::noop(PathBuf::from("/some/path"), vec![], &NEVER_STOPPED);
+    assert!(
+        cache.is_noop(),
+        "noop() constructor must produce a cache that reports is_noop() == true"
+    );
+    assert_eq!(
+        cache.get_total_files(),
+        0,
+        "noop cache should contain zero file nodes"
+    );
+}
+
+#[test]
+fn noop_cache_preserves_ignore_paths() {
+    let ignore = vec![
+        PathBuf::from("/some/path/node_modules"),
+        PathBuf::from("/some/path/.git"),
+    ];
+    let cache = SearchCache::noop(PathBuf::from("/some/path"), ignore.clone(), &NEVER_STOPPED);
+    assert_eq!(
+        cache.ignore_paths(),
+        &ignore,
+        "noop() should store the supplied ignore paths unchanged"
+    );
+}
+
+#[test]
+fn noop_cache_empty_ignore_paths_is_preserved() {
+    let cache = SearchCache::noop(PathBuf::from("/x"), vec![], &NEVER_STOPPED);
+    assert!(
+        cache.ignore_paths().is_empty(),
+        "noop() with empty ignore_paths should store an empty vec"
+    );
+}
+
+// ── SearchCache::is_noop() ───────────────────────────────────────────────────
+
+#[test]
+fn populated_cache_is_not_noop() {
+    let (_tmp, cache) = build_cache();
+    assert!(
+        !cache.is_noop(),
+        "a cache built by walk_fs must NOT report is_noop() == true"
+    );
+    assert!(
+        cache.get_total_files() > 0,
+        "walk_fs cache should contain at least one node"
+    );
+}
+
+// ── walk_data cancel closure — stale token ───────────────────────────────────
+
+#[test]
+fn stale_scan_token_cancels_rescan_walk_data() {
+    let _guard = SCAN_TOKEN_LOCK
+        .lock()
+        .expect("scan token lock should not be poisoned");
+
+    let (_temp_dir, mut cache) = build_cache();
+    let before = cache.get_total_files();
+
+    let stale = CancellationToken::new_scan();
+    let _latest = CancellationToken::new_scan();
+
+    let mut scan_root = PathBuf::new();
+    let mut scan_ignore_paths = Vec::new();
+    let walk_data = cache.walk_data(&mut scan_root, &mut scan_ignore_paths, stale);
+
+    let rescan_result = cache.rescan_with_walk_data(&walk_data);
+    assert!(
+        rescan_result.is_none(),
+        "stale scan token should cancel this rescan request"
+    );
+    assert_eq!(
+        cache.get_total_files(),
+        before,
+        "cancelled rescan should keep cache unchanged"
+    );
+}
+
+#[test]
+fn stale_token_on_noop_cache_stays_noop() {
+    let _guard = SCAN_TOKEN_LOCK
+        .lock()
+        .expect("scan token lock should not be poisoned");
+
+    let tmp = TempDir::new("stale_on_noop").expect("failed to create tempdir");
+    fs::write(tmp.path().join("file.txt"), "data").expect("failed to create fixture");
+
+    let mut cache = SearchCache::noop(tmp.path().to_path_buf(), vec![], &NEVER_STOPPED);
+
+    let stale = CancellationToken::new_scan();
+    let _newer = CancellationToken::new_scan();
+
+    let mut p1 = PathBuf::new();
+    let mut p2 = Vec::new();
+    let walk_data = cache.walk_data(&mut p1, &mut p2, stale);
+    let result = cache.rescan_with_walk_data(&walk_data);
+
+    assert!(
+        result.is_none(),
+        "stale token should cancel the rescan even on a noop starting cache"
+    );
+    assert!(
+        cache.is_noop(),
+        "noop cache should remain noop after a cancelled rescan"
+    );
+}
+
+// ── walk_data cancel closure — active token ──────────────────────────────────
+
+#[test]
+fn active_scan_token_allows_rescan_to_complete() {
+    let _guard = SCAN_TOKEN_LOCK
+        .lock()
+        .expect("scan token lock should not be poisoned");
+
+    let (tmp, mut cache) = build_cache();
+
+    // Add a new file so we can observe the rescan picking it up.
+    fs::write(tmp.path().join("extra.txt"), "new").expect("failed to create extra file");
+
+    let active = CancellationToken::new_scan();
+
+    let mut scan_root = PathBuf::new();
+    let mut scan_ignore_paths = Vec::new();
+    let walk_data = cache.walk_data(&mut scan_root, &mut scan_ignore_paths, active);
+
+    let result = cache.rescan_with_walk_data(&walk_data);
+    assert!(
+        result.is_some(),
+        "active scan token must allow rescan to complete"
+    );
+    assert!(
+        !cache.is_noop(),
+        "cache must not be noop after a successful rescan"
+    );
+    assert!(
+        cache.get_total_files() > 0,
+        "cache should contain files after a successful rescan"
+    );
+}
+
+#[test]
+fn is_noop_false_after_rescan_of_noop_cache() {
+    let _guard = SCAN_TOKEN_LOCK
+        .lock()
+        .expect("scan token lock should not be poisoned");
+
+    let tmp = TempDir::new("noop_rescan").expect("failed to create tempdir");
+    fs::create_dir_all(tmp.path().join("sub")).expect("failed to create sub");
+    fs::write(tmp.path().join("sub/a.rs"), "fn f() {}").expect("failed to create file");
+
+    let mut cache = SearchCache::noop(tmp.path().to_path_buf(), vec![], &NEVER_STOPPED);
+    assert!(cache.is_noop(), "precondition: starts as noop");
+
+    let active = CancellationToken::new_scan();
+    let mut p1 = PathBuf::new();
+    let mut p2 = Vec::new();
+    let walk_data = cache.walk_data(&mut p1, &mut p2, active);
+    let result = cache.rescan_with_walk_data(&walk_data);
+
+    assert!(result.is_some(), "rescan with active token should succeed");
+    assert!(
+        !cache.is_noop(),
+        "after a successful rescan a previously-noop cache must no longer be noop"
+    );
+    assert!(
+        cache.get_total_files() > 0,
+        "rescan should have discovered the fixture files"
+    );
+}
+
+// ── stop flag (AtomicBool) cancellation ──────────────────────────────────────
+
+#[test]
+fn stop_flag_cancels_rescan_independently_of_scan_token() {
+    let _guard = SCAN_TOKEN_LOCK
+        .lock()
+        .expect("scan token lock should not be poisoned");
+
+    let tmp = TempDir::new("stop_flag").expect("failed to create tempdir");
+    fs::write(tmp.path().join("b.txt"), "hi").expect("failed to create fixture");
+
+    // noop cache tied to ALWAYS_STOPPED — its stop flag is already true.
+    let mut cache = SearchCache::noop(tmp.path().to_path_buf(), vec![], &ALWAYS_STOPPED);
+
+    // Use an *active* scan token so that only the stop flag drives cancellation.
+    let active = CancellationToken::new_scan();
+    let mut p1 = PathBuf::new();
+    let mut p2 = Vec::new();
+    let walk_data = cache.walk_data(&mut p1, &mut p2, active);
+    let result = cache.rescan_with_walk_data(&walk_data);
+
+    assert!(
+        result.is_none(),
+        "a raised stop flag should cancel the rescan even when the scan token is active"
+    );
+    assert!(
+        cache.is_noop(),
+        "cache must remain noop when rescan is aborted by the stop flag"
+    );
+}
+
+// ── is_noop drives cache persistence decision ────────────────────────────────
+
+#[test]
+fn noop_cache_signals_do_not_persist() {
+    // Mirrors the logic in background.rs:
+    //   tx.send((!cache.is_noop()).then(|| cache))
+    // A noop cache should produce None (skip write); a real cache should produce Some.
+    let noop = SearchCache::noop(PathBuf::from("/p"), vec![], &NEVER_STOPPED);
+    let persist_noop: Option<()> = (!noop.is_noop()).then_some(());
+    assert!(
+        persist_noop.is_none(),
+        "noop cache must produce None for the persistence gate"
+    );
+
+    let (_tmp, real) = build_cache();
+    let persist_real: Option<()> = (!real.is_noop()).then_some(());
+    assert!(
+        persist_real.is_some(),
+        "populated cache must produce Some for the persistence gate"
+    );
+}
+
+// ── noop cache property tests (last_event_id, rescan_count, search) ──────────
+
+#[test]
+fn noop_cache_last_event_id_is_zero() {
+    let mut cache = SearchCache::noop(PathBuf::from("/w"), vec![], &NEVER_STOPPED);
+    assert_eq!(
+        cache.last_event_id(),
+        0,
+        "noop cache must have last_event_id == 0 (used to spawn EventWatcher)"
+    );
+}
+
+#[test]
+fn noop_cache_rescan_count_is_zero() {
+    let cache = SearchCache::noop(PathBuf::from("/w"), vec![], &NEVER_STOPPED);
+    assert_eq!(
+        cache.rescan_count(),
+        0,
+        "freshly created noop cache must have rescan_count == 0"
+    );
+}
+
+#[test]
+fn noop_cache_search_returns_empty_results() {
+    use search_cache::SearchOptions;
+    let mut cache = SearchCache::noop(PathBuf::from("/w"), vec![], &NEVER_STOPPED);
+    let outcome = cache
+        .search_with_options(
+            "anything",
+            SearchOptions::default(),
+            CancellationToken::noop(),
+        )
+        .expect("search on noop should not error");
+    let nodes = outcome.nodes.unwrap_or_default();
+    assert!(
+        nodes.is_empty(),
+        "searching a noop cache must return an empty result set"
+    );
+}
+
+#[test]
+fn noop_cache_search_empty_returns_empty_vec() {
+    let cache = SearchCache::noop(PathBuf::from("/w"), vec![], &NEVER_STOPPED);
+    let result = cache
+        .search_empty(CancellationToken::noop())
+        .expect("search_empty on noop should not be cancelled");
+    assert!(
+        result.is_empty(),
+        "search_empty on noop cache must return an empty vec"
+    );
+}
+
+// ── noop cache walk_data propagation ─────────────────────────────────────────
+
+#[test]
+fn noop_cache_walk_data_propagates_path_and_ignore() {
+    let _guard = SCAN_TOKEN_LOCK
+        .lock()
+        .expect("scan token lock should not be poisoned");
+
+    let path = PathBuf::from("/my/root");
+    let ignore = vec![PathBuf::from("/my/root/.git")];
+    let cache = SearchCache::noop(path.clone(), ignore.clone(), &NEVER_STOPPED);
+
+    let mut p1 = PathBuf::new();
+    let mut p2 = Vec::new();
+    let token = CancellationToken::new_scan();
+    let wd = cache.walk_data(&mut p1, &mut p2, token);
+
+    assert_eq!(
+        wd.root_path, &path,
+        "walk_data from noop must propagate root path"
+    );
+    assert_eq!(
+        wd.ignore_directories, &ignore,
+        "walk_data from noop must propagate ignore paths"
+    );
+}
+
+// ── handle_fs_events on noop cache ───────────────────────────────────────────
+
+#[test]
+fn noop_cache_handle_fs_events_with_empty_events_is_ok() {
+    let mut cache = SearchCache::noop(PathBuf::from("/w"), vec![], &NEVER_STOPPED);
+    let result = cache.handle_fs_events(vec![]);
+    assert!(
+        result.is_ok(),
+        "handle_fs_events with empty events on noop cache should succeed"
+    );
+}
+
+#[test]
+fn noop_cache_handle_fs_events_with_create_event_panics_on_invalid_slab() {
+    use cardinal_sdk::{EventFlag, FsEvent};
+    let mut cache = SearchCache::noop(PathBuf::from("/w"), vec![], &NEVER_STOPPED);
+    let event = FsEvent {
+        path: PathBuf::from("/w/new_file.txt"),
+        id: 42,
+        flag: EventFlag::ItemCreated | EventFlag::ItemIsFile,
+    };
+    // The noop cache has an empty slab; attempting to scan a path triggers an
+    // "invalid slab index" panic because the root node doesn't exist.
+    let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+        cache.handle_fs_events(vec![event])
+    }));
+    assert!(
+        result.is_err(),
+        "handle_fs_events on noop cache with a real event should panic (invalid slab)"
+    );
+}
diff --git a/search-cancel/src/lib.rs b/search-cancel/src/lib.rs
index 54730b3a..cd4d71f4 100644
--- a/search-cancel/src/lib.rs
+++ b/search-cancel/src/lib.rs
@@ -6,6 +6,9 @@ pub const CANCEL_CHECK_INTERVAL: usize = 0x10000;
 /// A global atomic identifies the active search version of Cardinal.
 pub static ACTIVE_SEARCH_VERSION: AtomicU64 = AtomicU64::new(0);
 
+/// A global atomic identifies the active scanning process version of Cardinal.
+pub static ACTIVE_SCAN_VERSION: AtomicU64 = AtomicU64::new(0);
+
 #[derive(Clone, Copy, Debug)]
 pub struct CancellationToken {
     active_version: &'static AtomicU64,
@@ -29,6 +32,14 @@ impl CancellationToken {
         }
     }
 
+    pub fn new_scan() -> Self {
+        let version = self::ACTIVE_SCAN_VERSION.fetch_add(1, Ordering::SeqCst) + 1;
+        Self {
+            version,
+            active_version: &ACTIVE_SCAN_VERSION,
+        }
+    }
+
     pub fn is_cancelled(&self) -> Option<()> {
         if self.version != self.active_version.load(Ordering::Relaxed) {
             None
@@ -49,9 +60,25 @@ impl CancellationToken {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use std::sync::{Mutex, MutexGuard};
+
+    static TEST_GUARD: Mutex<()> = Mutex::new(());
+
+    fn lock_versions() -> MutexGuard<'static, ()> {
+        TEST_GUARD
+            .lock()
+            .expect("version lock should not be poisoned")
+    }
+
+    fn reset_versions() {
+        ACTIVE_SEARCH_VERSION.store(0, Ordering::SeqCst);
+        ACTIVE_SCAN_VERSION.store(0, Ordering::SeqCst);
+    }
 
     #[test]
     fn noop_token_is_never_cancelled() {
+        let _guard = lock_versions();
+        reset_versions();
         let token = CancellationToken::noop();
         assert!(
             token.is_cancelled().is_some(),
@@ -61,6 +88,8 @@ mod tests {
 
     #[test]
     fn cancelled_after_version_change() {
+        let _guard = lock_versions();
+        reset_versions();
         let token_v1 = CancellationToken::new(1);
         assert!(
             token_v1.is_cancelled().is_some(),
@@ -71,4 +100,45 @@ mod tests {
         let _token_v2 = CancellationToken::new(2);
         assert!(token_v1.is_cancelled().is_none());
     }
+
+    #[test]
+    fn scan_token_cancelled_after_new_scan_version() {
+        let _guard = lock_versions();
+        reset_versions();
+
+        let scan_v1 = CancellationToken::new_scan();
+        assert!(
+            scan_v1.is_cancelled().is_some(),
+            "latest scan token should start active"
+        );
+
+        let scan_v2 = CancellationToken::new_scan();
+        assert!(
+            scan_v2.is_cancelled().is_some(),
+            "new scan token should be active"
+        );
+        assert!(
+            scan_v1.is_cancelled().is_none(),
+            "older scan token should be cancelled by newer scan"
+        );
+    }
+
+    #[test]
+    fn scan_versions_do_not_cancel_search_tokens() {
+        let _guard = lock_versions();
+        reset_versions();
+
+        let search_v1 = CancellationToken::new(1);
+        let _scan_v1 = CancellationToken::new_scan();
+        assert!(
+            search_v1.is_cancelled().is_some(),
+            "scan token updates should not affect search version"
+        );
+
+        let _search_v2 = CancellationToken::new(2);
+        assert!(
+            search_v1.is_cancelled().is_none(),
+            "search token should still be governed by search version updates"
+        );
+    }
 }
diff --git a/search-cancel/tests/more.rs b/search-cancel/tests/more.rs
index a71c727c..31f6fef6 100644
--- a/search-cancel/tests/more.rs
+++ b/search-cancel/tests/more.rs
@@ -1,7 +1,23 @@
-use search_cancel::CancellationToken;
+use search_cancel::{
+    ACTIVE_SCAN_VERSION, ACTIVE_SEARCH_VERSION, CANCEL_CHECK_INTERVAL, CancellationToken,
+};
+use std::sync::{LazyLock, Mutex, MutexGuard, atomic::Ordering};
+
+static TEST_GUARD: LazyLock<Mutex<()>> = LazyLock::new(|| Mutex::new(()));
+
+fn lock_and_reset_versions() -> MutexGuard<'static, ()> {
+    let guard = TEST_GUARD
+        .lock()
+        .expect("token test lock should not be poisoned");
+    ACTIVE_SEARCH_VERSION.store(0, Ordering::SeqCst);
+    ACTIVE_SCAN_VERSION.store(0, Ordering::SeqCst);
+    guard
+}
 
 #[test]
 fn multiple_tokens_cancelled_independently() {
+    let _guard = lock_and_reset_versions();
+
     let t1 = CancellationToken::new(1);
     assert!(t1.is_cancelled().is_some());
     let t2 = CancellationToken::new(2);
@@ -11,3 +27,118 @@ fn multiple_tokens_cancelled_independently() {
     assert!(t2.is_cancelled().is_none());
     assert!(t3.is_cancelled().is_some());
 }
+
+#[test]
+fn multiple_scan_tokens_cancelled_independently() {
+    let _guard = lock_and_reset_versions();
+
+    let s1 = CancellationToken::new_scan();
+    assert!(s1.is_cancelled().is_some());
+
+    let s2 = CancellationToken::new_scan();
+    assert!(s1.is_cancelled().is_none());
+    assert!(s2.is_cancelled().is_some());
+
+    let s3 = CancellationToken::new_scan();
+    assert!(s2.is_cancelled().is_none());
+    assert!(s3.is_cancelled().is_some());
+}
+
+#[test]
+fn search_version_changes_do_not_cancel_scan_token() {
+    let _guard = lock_and_reset_versions();
+
+    let scan = CancellationToken::new_scan();
+    let _search_v1 = CancellationToken::new(1);
+    let _search_v2 = CancellationToken::new(2);
+    assert!(
+        scan.is_cancelled().is_some(),
+        "scan token should not be affected by search version updates"
+    );
+}
+
+#[test]
+fn scan_sparse_checks_only_cancel_at_interval_boundaries() {
+    let _guard = lock_and_reset_versions();
+
+    let stale = CancellationToken::new_scan();
+    let _latest = CancellationToken::new_scan();
+
+    assert!(
+        stale
+            .is_cancelled_sparse(CANCEL_CHECK_INTERVAL.saturating_sub(1))
+            .is_some(),
+        "non-interval checks should skip cancellation check"
+    );
+    assert!(
+        stale.is_cancelled_sparse(CANCEL_CHECK_INTERVAL).is_none(),
+        "interval checks should observe stale scan token cancellation"
+    );
+}
+
+#[test]
+fn active_scan_token_sparse_check_always_passes() {
+    let _guard = lock_and_reset_versions();
+
+    let active = CancellationToken::new_scan();
+
+    // Non-interval counter: skips check, returns Some.
+    assert!(
+        active
+            .is_cancelled_sparse(CANCEL_CHECK_INTERVAL.saturating_sub(1))
+            .is_some(),
+        "non-interval sparse check on active token should pass"
+    );
+    // Interval boundary: actually checks — still Some because token is latest.
+    assert!(
+        active.is_cancelled_sparse(CANCEL_CHECK_INTERVAL).is_some(),
+        "interval sparse check on active token should still pass"
+    );
+}
+
+#[test]
+fn noop_unaffected_by_scan_versions() {
+    let _guard = lock_and_reset_versions();
+
+    let noop = CancellationToken::noop();
+    let _s1 = CancellationToken::new_scan();
+    let _s2 = CancellationToken::new_scan();
+    assert!(
+        noop.is_cancelled().is_some(),
+        "noop token must remain active regardless of scan version bumps"
+    );
+}
+
+#[test]
+fn active_scan_token_survives_many_search_bumps() {
+    let _guard = lock_and_reset_versions();
+
+    let scan = CancellationToken::new_scan();
+    for v in 1..=10_u64 {
+        let _search = CancellationToken::new(v);
+    }
+    assert!(
+        scan.is_cancelled().is_some(),
+        "scan token must remain active after many search version changes"
+    );
+}
+
+#[test]
+fn new_scan_cancels_all_previous_scan_tokens() {
+    let _guard = lock_and_reset_versions();
+
+    let tokens: Vec<_> = (0..5).map(|_| CancellationToken::new_scan()).collect();
+    let latest = tokens.last().unwrap();
+
+    // Only the last token should be active.
+    for t in &tokens[..tokens.len() - 1] {
+        assert!(
+            t.is_cancelled().is_none(),
+            "every prior scan token should be cancelled when a newer one is created"
+        );
+    }
+    assert!(
+        latest.is_cancelled().is_some(),
+        "the most recently created scan token must be active"
+    );
+}

From e93fb17765b48afe2be6b9617ff64c984a754533 Mon Sep 17 00:00:00 2001
From: Mohamad Yahia <xyzt70@gmail.com>
Date: Wed, 4 Mar 2026 02:48:35 +0400
Subject: [PATCH 09/16] fix(merge): preserve both branch and upstream conflict
 resolutions

---
 .../hooks/__tests__/useIgnorePaths.test.ts    |   1 +
 cardinal/src/hooks/useIgnorePaths.ts          |   2 +
 fswalk/src/lib.rs                             | 387 +++++++++++++++---
 fswalk/tests/deep_walk.rs                     |  12 +-
 search-cache/src/cache.rs                     | 157 +++----
 5 files changed, 402 insertions(+), 157 deletions(-)

diff --git a/cardinal/src/hooks/__tests__/useIgnorePaths.test.ts b/cardinal/src/hooks/__tests__/useIgnorePaths.test.ts
index 10947be4..cb7cc4ef 100644
--- a/cardinal/src/hooks/__tests__/useIgnorePaths.test.ts
+++ b/cardinal/src/hooks/__tests__/useIgnorePaths.test.ts
@@ -74,6 +74,7 @@ describe('useIgnorePaths', () => {
     expect(defaults).toContain('**/.DS_Store');
     expect(defaults).toContain('**/Google/Chrome*/Cache/');
     expect(defaults).toContain('/System/Volumes/');
+    expect(defaults).toContain('~/Library/CloudStorage');
   });
 
   it('keeps a whitespace-only stored array without writing defaults', async () => {
diff --git a/cardinal/src/hooks/useIgnorePaths.ts b/cardinal/src/hooks/useIgnorePaths.ts
index b2f6af10..8fef08ec 100644
--- a/cardinal/src/hooks/useIgnorePaths.ts
+++ b/cardinal/src/hooks/useIgnorePaths.ts
@@ -5,6 +5,8 @@ const STORAGE_KEY = 'cardinal.ignorePaths';
 const DEFAULT_IGNORE_PATHS = [
   '# 0 files in the 2026-02-24 sample. Keep external volumes excluded to avoid indexing large mounted disks/network shares.',
   '/Volumes/',
+  '# Cloud provider stubs under CloudStorage may issue network I/O on first traversal (e.g. OneDrive).',
+  '~/Library/CloudStorage',
   '',
   '# 2,384,029 files across 414 roots. Node dependency trees dominate index volume and are regenerated.',
   '**/node_modules/',
diff --git a/fswalk/src/lib.rs b/fswalk/src/lib.rs
index 33040990..f23911ef 100644
--- a/fswalk/src/lib.rs
+++ b/fswalk/src/lib.rs
@@ -127,12 +127,17 @@ impl IgnoreMatcher {
     }
 }
 
-#[derive(Debug)]
-pub struct WalkData<'w> {
+pub fn should_ignore_path(path: &Path, ignore_directories: &[PathBuf]) -> bool {
+    ignore_directories
+        .iter()
+        .any(|ignore| path.starts_with(ignore))
+}
+
+pub struct WalkData<'w, F: Fn() -> bool> {
     pub num_files: AtomicUsize,
     pub num_dirs: AtomicUsize,
     /// Cancellation will be checked periodically.
-    cancel: Option<&'w AtomicBool>,
+    cancel: F,
     pub root_path: &'w Path,
     pub ignore_directories: &'w [PathBuf],
     ignore_matcher: Arc<IgnoreMatcher>,
@@ -140,24 +145,46 @@ pub struct WalkData<'w> {
     need_metadata: bool,
 }
 
-impl<'w> WalkData<'w> {
+impl<F> std::fmt::Debug for WalkData<'_, F>
+where
+    F: Fn() -> bool,
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("WalkData")
+            .field("num_files", &self.num_files.load(Ordering::Relaxed))
+            .field("num_dirs", &self.num_dirs.load(Ordering::Relaxed))
+            .field("cancel", &((self.cancel)()))
+            .field("root_path", &self.root_path)
+            .field("ignore_directories", &self.ignore_directories)
+            .field("need_metadata", &self.need_metadata)
+            .finish()
+    }
+}
+
+impl<'w> WalkData<'w, fn() -> bool> {
     pub fn simple(root_path: &'w Path, need_metadata: bool) -> Self {
+        fn never_cancel() -> bool {
+            false
+        }
+
         Self {
             num_files: AtomicUsize::new(0),
             num_dirs: AtomicUsize::new(0),
-            cancel: None,
+            cancel: never_cancel,
             root_path,
             ignore_directories: &[],
             ignore_matcher: Arc::new(IgnoreMatcher::default()),
             need_metadata,
         }
     }
+}
 
+impl<'w, F: Fn() -> bool> WalkData<'w, F> {
     pub fn new(
         root_path: &'w Path,
         ignore_directories: &'w [PathBuf],
         need_metadata: bool,
-        cancel: Option<&'w AtomicBool>,
+        cancel: F,
     ) -> Self {
         Self::new_with_ignore_root(
             root_path,
@@ -173,7 +200,7 @@ impl<'w> WalkData<'w> {
         ignore_root_path: &'w Path,
         ignore_directories: &'w [PathBuf],
         need_metadata: bool,
-        cancel: Option<&'w AtomicBool>,
+        cancel: F,
     ) -> Self {
         Self::new_with_ignore_matcher(
             root_path,
@@ -189,7 +216,7 @@ impl<'w> WalkData<'w> {
         ignore_directories: &'w [PathBuf],
         ignore_matcher: Arc<IgnoreMatcher>,
         need_metadata: bool,
-        cancel: Option<&'w AtomicBool>,
+        cancel: F,
     ) -> Self {
         Self {
             num_files: AtomicUsize::new(0),
@@ -209,13 +236,29 @@ impl<'w> WalkData<'w> {
     fn should_ignore(&self, path: &Path, is_dir: bool) -> bool {
         self.ignore_matcher.is_ignored(path, is_dir)
     }
+
+    fn is_cancelled(&self) -> bool {
+        (self.cancel)()
+    }
 }
 
-pub fn walk_it_without_root_chain(walk_data: &WalkData) -> Option<Node> {
+/// return `Some(Node)` if walk is successful.
+/// return `None` if walk is cancelled.
+///
+/// Note: if the root path is missing or inaccessible, it will still return
+/// `Some(Node)` with empty children and None metadata.
+pub fn walk_it_without_root_chain<F: Fn() -> bool + Send + Sync>(
+    walk_data: &WalkData<'_, F>,
+) -> Option<Node> {
     walk(walk_data.root_path, walk_data)
 }
 
-pub fn walk_it(walk_data: &WalkData) -> Option<Node> {
+/// return `Some(Node)` if walk is successful.
+/// return `None` if walk is cancelled.
+///
+/// Note: if the root path is missing or inaccessible, it will still return
+/// `Some(Node)` with empty children and None metadata.
+pub fn walk_it<F: Fn() -> bool + Send + Sync>(walk_data: &WalkData<'_, F>) -> Option<Node> {
     walk(walk_data.root_path, walk_data).map(|node_tree| {
         if let Some(parent) = walk_data.root_path.parent() {
             let mut path = PathBuf::from(parent);
@@ -250,7 +293,9 @@ pub fn walk_it(walk_data: &WalkData) -> Option<Node> {
     })
 }
 
-fn walk(path: &Path, walk_data: &WalkData) -> Option<Node> {
+/// Note: this function will create a Node for the given path even if it's
+/// missing or inaccessible, but the metadata will be None in that case.
+fn walk<F: Fn() -> bool + Send + Sync>(path: &Path, walk_data: &WalkData<'_, F>) -> Option<Node> {
     let metadata = metadata_of_path(path);
     let is_dir = metadata.as_ref().map(|x| x.is_dir()).unwrap_or_default();
     if walk_data.should_ignore(path, is_dir) {
@@ -260,66 +305,66 @@ fn walk(path: &Path, walk_data: &WalkData) -> Option<Node> {
         walk_data.num_dirs.fetch_add(1, Ordering::Relaxed);
         let read_dir = fs::read_dir(path);
         match read_dir {
-            Ok(entries) => entries
-                .into_iter()
-                .par_bridge()
-                .filter_map(|entry| {
-                    match &entry {
-                        Ok(entry) => {
-                            if walk_data
-                                .cancel
-                                .map(|x| x.load(Ordering::Relaxed))
-                                .unwrap_or_default()
-                            {
-                                return None;
-                            }
-                            let entry_path = entry.path();
-                            // doesn't traverse symlink
-                            if let Ok(data) = entry.file_type() {
-                                let is_dir = data.is_dir();
-                                if walk_data.should_ignore(&entry_path, is_dir) {
+            Ok(entries) => {
+                let cancelled = AtomicBool::new(false);
+                let results: Vec<_> = entries
+                    .into_iter()
+                    .par_bridge()
+                    .map(|entry| {
+                        match &entry {
+                            Ok(entry) => {
+                                if walk_data.is_cancelled() {
+                                    cancelled.store(true, Ordering::Relaxed);
                                     return None;
                                 }
-                                if is_dir {
-                                    return walk(&entry_path, walk_data);
+                                let path = entry.path();
+                                // doesn't traverse symlink
+                                if let Ok(data) = entry.file_type() {
+                                    let is_dir = data.is_dir();
+                                    if walk_data.should_ignore(&path, is_dir) {
+                                        return None;
+                                    }
+                                    if is_dir {
+                                        walk(&path, walk_data)
+                                    } else {
+                                        walk_data.num_files.fetch_add(1, Ordering::Relaxed);
+                                        let name = entry
+                                            .file_name()
+                                            .to_string_lossy()
+                                            .into_owned()
+                                            .into_boxed_str();
+                                        Some(Node {
+                                            children: vec![],
+                                            name,
+                                            metadata: walk_data
+                                                .need_metadata
+                                                .then_some(entry)
+                                                .and_then(|entry| {
+                                                    // doesn't traverse symlink
+                                                    entry.metadata().ok().map(NodeMetadata::from)
+                                                }),
+                                        })
+                                    }
                                 } else {
-                                    walk_data.num_files.fetch_add(1, Ordering::Relaxed);
-                                    let name = entry
-                                        .file_name()
-                                        .to_string_lossy()
-                                        .into_owned()
-                                        .into_boxed_str();
-                                    Some(Node {
-                                        children: vec![],
-                                        name,
-                                        metadata: walk_data
-                                            .need_metadata
-                                            .then_some(entry)
-                                            .and_then(|entry| {
-                                                // doesn't traverse symlink
-                                                entry.metadata().ok().map(NodeMetadata::from)
-                                            }),
-                                    })
+                                    None
                                 }
-                            } else {
-                                None
                             }
+                            Err(_) => None,
                         }
-                        Err(_) => None,
-                    }
-                })
-                .collect(),
+                    })
+                    .collect();
+                if cancelled.load(Ordering::Acquire) {
+                    return None;
+                }
+                results.into_iter().flatten().collect()
+            }
             Err(_) => Vec::new(),
         }
     } else {
         walk_data.num_files.fetch_add(1, Ordering::Relaxed);
         Vec::new()
     };
-    if walk_data
-        .cancel
-        .map(|x| x.load(Ordering::Relaxed))
-        .unwrap_or_default()
-    {
+    if walk_data.is_cancelled() {
         return None;
     }
     let name = path
@@ -364,6 +409,7 @@ mod tests {
         fs,
         io::Write,
         path::{Component, Path, PathBuf},
+        sync::atomic::AtomicBool,
         time::{Duration, Instant},
     };
     use tempdir::TempDir;
@@ -536,6 +582,132 @@ mod tests {
         );
     }
 
+    // ── should_ignore tests (prefix-based matching) ──────────────────────
+
+    #[test]
+    fn should_ignore_exact_match() {
+        let ignore = vec![PathBuf::from("/a/b/c")];
+        let wd = WalkData::new(Path::new("/"), &ignore, false, || false);
+        assert!(wd.should_ignore(Path::new("/a/b/c"), true));
+    }
+
+    #[test]
+    fn should_ignore_child_of_ignored_dir() {
+        let ignore = vec![PathBuf::from("/a/b")];
+        let wd = WalkData::new(Path::new("/"), &ignore, false, || false);
+        // direct child
+        assert!(wd.should_ignore(Path::new("/a/b/c"), true));
+        // deeply nested
+        assert!(wd.should_ignore(Path::new("/a/b/c/d/e"), true));
+    }
+
+    #[test]
+    fn should_ignore_does_not_match_sibling_with_shared_prefix_string() {
+        // "/tmp/abc" is NOT a child of "/tmp/ab" — Path::starts_with is
+        // component-aware, not string-prefix.
+        let ignore = vec![PathBuf::from("/tmp/ab")];
+        let wd = WalkData::new(Path::new("/"), &ignore, false, || false);
+        assert!(!wd.should_ignore(Path::new("/tmp/abc"), true));
+        assert!(!wd.should_ignore(Path::new("/tmp/abc/d"), true));
+    }
+
+    #[test]
+    fn should_ignore_unrelated_path() {
+        let ignore = vec![PathBuf::from("/a/b")];
+        let wd = WalkData::new(Path::new("/"), &ignore, false, || false);
+        assert!(!wd.should_ignore(Path::new("/x/y"), true));
+        assert!(!wd.should_ignore(Path::new("/a"), true));
+    }
+
+    #[test]
+    fn should_ignore_empty_ignore_list() {
+        let ignore: Vec<PathBuf> = vec![];
+        let wd = WalkData::new(Path::new("/"), &ignore, false, || false);
+        assert!(!wd.should_ignore(Path::new("/anything"), true));
+    }
+
+    #[test]
+    fn should_ignore_multiple_ignore_dirs() {
+        let ignore = vec![PathBuf::from("/a"), PathBuf::from("/x/y")];
+        let wd = WalkData::new(Path::new("/"), &ignore, false, || false);
+        assert!(wd.should_ignore(Path::new("/a"), true));
+        assert!(wd.should_ignore(Path::new("/a/b/c"), true));
+        assert!(wd.should_ignore(Path::new("/x/y"), true));
+        assert!(wd.should_ignore(Path::new("/x/y/z"), true));
+        assert!(!wd.should_ignore(Path::new("/x"), true));
+        assert!(!wd.should_ignore(Path::new("/b"), true));
+    }
+
+    #[test]
+    fn should_ignore_parent_of_ignored_dir_is_not_ignored() {
+        let ignore = vec![PathBuf::from("/a/b/c")];
+        let wd = WalkData::new(Path::new("/"), &ignore, false, || false);
+        assert!(!wd.should_ignore(Path::new("/a"), true));
+        assert!(!wd.should_ignore(Path::new("/a/b"), true));
+    }
+
+    // ── other unit tests ─────────────────────────────────────────────────
+
+    #[test]
+    fn walk_data_debug_shows_cancel_state() {
+        let ignore = vec![PathBuf::from("/a")];
+        let wd = WalkData::new(Path::new("/root"), &ignore, true, || false);
+        let dbg = format!("{wd:?}");
+        assert!(
+            dbg.contains("cancel: false"),
+            "Debug output should show cancel closure result: {dbg}"
+        );
+        assert!(
+            dbg.contains("root_path"),
+            "Debug output should include root_path: {dbg}"
+        );
+        assert!(
+            dbg.contains("need_metadata: true"),
+            "Debug output should include need_metadata: {dbg}"
+        );
+
+        let wd_cancelled = WalkData::new(Path::new("/root"), &ignore, false, || true);
+        let dbg2 = format!("{wd_cancelled:?}");
+        assert!(
+            dbg2.contains("cancel: true"),
+            "Debug output should reflect cancel=true: {dbg2}"
+        );
+    }
+
+    #[test]
+    fn walk_data_closure_cancellation_is_dynamic() {
+        let flag = AtomicBool::new(false);
+        let ignore: Vec<PathBuf> = vec![];
+        let wd = WalkData::new(Path::new("/"), &ignore, false, || {
+            flag.load(Ordering::Relaxed)
+        });
+        assert!(
+            !wd.is_cancelled(),
+            "should not be cancelled when flag is false"
+        );
+
+        flag.store(true, Ordering::Relaxed);
+        assert!(
+            wd.is_cancelled(),
+            "should be cancelled after flag flipped to true"
+        );
+
+        flag.store(false, Ordering::Relaxed);
+        assert!(
+            !wd.is_cancelled(),
+            "should reflect dynamic state of the closure"
+        );
+    }
+
+    #[test]
+    fn walk_data_simple_never_cancels() {
+        let wd = WalkData::simple(Path::new("/tmp"), false);
+        assert!(
+            !wd.is_cancelled(),
+            "simple WalkData should never report cancelled"
+        );
+    }
+
     #[test]
     fn test_handle_error_and_retry_only_interrupted() {
         let interrupted = Error::from(ErrorKind::Interrupted);
@@ -563,12 +735,101 @@ mod tests {
         );
     }
 
+    #[test]
+    fn regression_missing_root_path_currently_returns_some_node() {
+        let tmp = TempDir::new("fswalk_missing_root").unwrap();
+        let root = tmp.path().to_path_buf();
+        drop(tmp);
+
+        let ignore: Vec<PathBuf> = vec![];
+        let walk_data = WalkData::new(&root, &ignore, false, || false);
+        let node = match walk_it_without_root_chain(&walk_data) {
+            Some(node) => node,
+            None => panic!("current behavior regression: expected Some, got None"),
+        };
+
+        assert!(
+            node.children.is_empty(),
+            "missing root currently produces a leaf node"
+        );
+        assert!(
+            node.metadata.is_none(),
+            "missing root currently has no metadata"
+        );
+        assert_eq!(
+            walk_data.num_files.load(Ordering::Relaxed),
+            1,
+            "missing root currently increments file counter"
+        );
+    }
+
+    #[test]
+    fn missing_root_via_walk_it_returns_some_with_none_metadata() {
+        let tmp = TempDir::new("fswalk_missing_walk_it").unwrap();
+        let root = tmp.path().to_path_buf();
+        drop(tmp); // remove the directory
+
+        let ignore: Vec<PathBuf> = vec![];
+        let walk_data = WalkData::new(&root, &ignore, true, || false);
+        let node = walk_it(&walk_data).expect("walk_it should return Some even for missing root");
+
+        // Navigate to the leaf that represents the (now-missing) root.
+        let root_node = node_for_path(&node, &root);
+        assert!(
+            root_node.children.is_empty(),
+            "missing root should have no children"
+        );
+        assert!(
+            root_node.metadata.is_none(),
+            "missing root should have None metadata even when need_metadata is true"
+        );
+    }
+
+    #[test]
+    fn missing_root_metadata_is_none_regardless_of_need_metadata_flag() {
+        let tmp = TempDir::new("fswalk_missing_meta_flag").unwrap();
+        let root = tmp.path().to_path_buf();
+        drop(tmp);
+
+        for need_metadata in [false, true] {
+            let ignore: Vec<PathBuf> = vec![];
+            let walk_data = WalkData::new(&root, &ignore, need_metadata, || false);
+            let node = walk_it_without_root_chain(&walk_data)
+                .expect("walk should return Some for missing path");
+            assert!(
+                node.metadata.is_none(),
+                "missing path metadata should be None (need_metadata={need_metadata})"
+            );
+            assert!(
+                node.children.is_empty(),
+                "missing path should have no children (need_metadata={need_metadata})"
+            );
+        }
+    }
+
+    #[test]
+    fn missing_root_name_is_preserved() {
+        let tmp = TempDir::new("fswalk_missing_name").unwrap();
+        let root = tmp.path().to_path_buf();
+        let expected_name = root.file_name().unwrap().to_string_lossy().into_owned();
+        drop(tmp);
+
+        let ignore: Vec<PathBuf> = vec![];
+        let walk_data = WalkData::new(&root, &ignore, false, || false);
+        let node = walk_it_without_root_chain(&walk_data)
+            .expect("walk should return Some for missing path");
+        assert_eq!(
+            &*node.name, expected_name,
+            "missing root node should preserve the directory name"
+        );
+    }
+
     #[test]
     #[ignore]
     fn test_search_root() {
         let done = AtomicBool::new(false);
         let path = [PathBuf::from("/System/Volumes/Data")];
-        let walk_data = WalkData::new(Path::new("/"), &path, false, None);
+        let walk_data = WalkData::new(Path::new("/"), &path, false, || false);
         std::thread::scope(|s| {
             s.spawn(|| {
                 let node = walk_it(&walk_data).unwrap();
@@ -595,7 +856,7 @@ mod tests {
             Path::new("/Library/Developer/CoreSimulator/Volumes/iOS_23A343"),
             &ignore,
             true,
-            None,
+            || false,
         );
         std::thread::scope(|s| {
             s.spawn(|| {
@@ -619,7 +880,9 @@ mod tests {
         let cancel = AtomicBool::new(false);
         let done = AtomicBool::new(false);
         let ignore = vec![PathBuf::from("/System/Volumes/Data")];
-        let walk_data = WalkData::new(Path::new("/"), &ignore, false, Some(&cancel));
+        let walk_data = WalkData::new(Path::new("/"), &ignore, false, || {
+            cancel.load(Ordering::Relaxed)
+        });
         std::thread::scope(|s| {
             s.spawn(|| {
                 let node = walk_it(&walk_data);
diff --git a/fswalk/tests/deep_walk.rs b/fswalk/tests/deep_walk.rs
index f64c5468..296ba65a 100644
--- a/fswalk/tests/deep_walk.rs
+++ b/fswalk/tests/deep_walk.rs
@@ -50,7 +50,7 @@ fn ignores_directories_and_collects_metadata() {
     let tmp = TempDir::new("fswalk_deep").unwrap();
     build_deep_fixture(tmp.path());
     let ignore = vec![std::path::PathBuf::from("/skip_dir")];
-    let walk_data = WalkData::new(tmp.path(), &ignore, true, None);
+    let walk_data = WalkData::new(tmp.path(), &ignore, true, || false);
     let tree = walk_it(&walk_data).expect("root node");
     let tree = node_for_path(&tree, tmp.path());
 
@@ -94,7 +94,7 @@ fn cancellation_stops_traversal_early() {
         fs::create_dir(tmp.path().join(format!("dir_{i}"))).unwrap();
     }
     let cancel = AtomicBool::new(false);
-    let walk_data = WalkData::new(tmp.path(), &[], false, Some(&cancel));
+    let walk_data = WalkData::new(tmp.path(), &[], false, || cancel.load(Ordering::Relaxed));
     cancel.store(true, Ordering::Relaxed); // cancel immediately
     let node = walk_it(&walk_data);
     assert!(
@@ -122,7 +122,7 @@ fn glob_patterns_ignore_nested_directories() {
     .unwrap();
 
     let ignore = vec![std::path::PathBuf::from("**/node_modules/**")];
-    let walk_data = WalkData::new(root, &ignore, true, None);
+    let walk_data = WalkData::new(root, &ignore, true, || false);
     let tree = walk_it(&walk_data).expect("root node");
     let tree = node_for_path(&tree, root);
 
@@ -174,7 +174,7 @@ fn globstar_descendant_pattern_does_not_ignore_parent_directory() {
     fs::write(root.join("Xcode.app/Contents/data.bin"), b"data").unwrap();
 
     let ignore = vec![std::path::PathBuf::from("**/Xcode.app/**")];
-    let walk_data = WalkData::new(root, &ignore, true, None);
+    let walk_data = WalkData::new(root, &ignore, true, || false);
     let tree = walk_it(&walk_data).expect("root node");
     let tree = node_for_path(&tree, root);
 
@@ -202,7 +202,7 @@ fn gitignore_negation_reincludes_file_when_parent_is_not_pruned() {
         std::path::PathBuf::from("**/node_modules/**"),
         std::path::PathBuf::from("!**/node_modules/**/included.js"),
     ];
-    let walk_data = WalkData::new(root, &ignore, true, None);
+    let walk_data = WalkData::new(root, &ignore, true, || false);
     let tree = walk_it(&walk_data).expect("root node");
     let tree = node_for_path(&tree, root);
 
@@ -245,7 +245,7 @@ fn gitignore_negation_cannot_reinclude_when_parent_directory_is_pruned() {
         std::path::PathBuf::from("**/node_modules/"),
         std::path::PathBuf::from("!**/node_modules/**/included.js"),
     ];
-    let walk_data = WalkData::new(root, &ignore, true, None);
+    let walk_data = WalkData::new(root, &ignore, true, || false);
     let tree = walk_it(&walk_data).expect("root node");
     let tree = node_for_path(&tree, root);
 
diff --git a/search-cache/src/cache.rs b/search-cache/src/cache.rs
index bfac3dfb..aa46fea7 100644
--- a/search-cache/src/cache.rs
+++ b/search-cache/src/cache.rs
@@ -16,7 +16,10 @@ use std::{
     ffi::OsStr,
     io::ErrorKind,
     path::{Path, PathBuf},
-    sync::{Arc, LazyLock, atomic::AtomicBool},
+    sync::{
+        Arc, LazyLock,
+        atomic::{AtomicBool, Ordering},
+    },
     time::Instant,
 };
 use thin_vec::ThinVec;
@@ -119,38 +122,37 @@ impl SearchCache {
     }
 
     pub fn walk_fs_with_ignore(path: &Path, ignore_paths: &[PathBuf]) -> Self {
-        Self::walk_fs_with_walk_data(&WalkData::new(path, ignore_paths, false, None), None).unwrap()
+        Self::walk_fs_with_walk_data(&WalkData::new(path, ignore_paths, false, || false), None)
+            .unwrap()
     }
 
     pub fn walk_fs(path: &Path) -> Self {
-        Self::walk_fs_with_walk_data(&WalkData::new(path, &[], false, None), None).unwrap()
+        Self::walk_fs_with_walk_data(&WalkData::new(path, &[], false, || false), None).unwrap()
     }
 
     /// This function is expected to be called with WalkData which metadata is not fetched.
     /// If cancelled during walking, None is returned.
-    pub fn walk_fs_with_walk_data(
-        walk_data: &WalkData,
+    pub fn walk_fs_with_walk_data<F>(
+        walk_data: &WalkData<'_, F>,
         cancel: Option<&'static AtomicBool>,
-    ) -> Option<Self> {
+    ) -> Option<Self>
+    where
+        F: Fn() -> bool + Send + Sync,
+    {
         // Return None if cancelled
-        fn walkfs_to_slab(
-            walk_data: &WalkData,
-        ) -> Option<(SlabIndex, ThinSlab<SlabNode>, NameIndex)> {
+        fn walkfs_to_slab<F>(
+            walk_data: &WalkData<'_, F>,
+        ) -> Option<(SlabIndex, ThinSlab<SlabNode>, NameIndex)>
+        where
+            F: Fn() -> bool + Send + Sync,
+        {
             // Build the tree of file names in parallel first (we cannot construct the slab directly
             // because slab nodes reference each other and we prefer to avoid locking).
             let visit_time = Instant::now();
-            let node = walk_it(walk_data).unwrap_or_else(|| {
-                warn!("failed to walk path: {:?}", walk_data.root_path);
-                Node {
-                    children: Vec::new(),
-                    name: walk_data
-                        .root_path
-                        .to_string_lossy()
-                        .into_owned()
-                        .into_boxed_str(),
-                    metadata: None,
-                }
-            });
+            let Some(node) = walk_it(walk_data) else {
+                info!("walk filesystem cancelled during walk_it.");
+                return None;
+            };
             info!(
                 "Walk data: {:?}, time: {:?}",
                 walk_data,
@@ -227,6 +229,23 @@ impl SearchCache {
         }
     }
 
+    /// Create a simple SearchCache which doesn't contain any file node and is
+    /// expected to be used when walk_fs is cancelled.
+    pub fn noop(path: PathBuf, ignore_paths: Vec<PathBuf>, cancel: &'static AtomicBool) -> Self {
+        Self {
+            file_nodes: FileNodes::new(path, ignore_paths, ThinSlab::new(), SlabIndex::new(0)),
+            last_event_id: 0,
+            rescan_count: 0,
+            name_index: NameIndex::default(),
+            ignore_matcher: Arc::new(IgnoreMatcher::default()),
+            stop: Some(cancel),
+        }
+    }
+
+    pub fn is_noop(&self) -> bool {
+        self.file_nodes.is_empty() && self.name_index.is_empty()
+    }
+
     pub fn search_empty(&self, cancellation_token: CancellationToken) -> Option<Vec<SlabIndex>> {
         self.name_index.all_indices(cancellation_token)
     }
@@ -410,20 +429,6 @@ impl SearchCache {
             self.remove_node_path(path);
             return None;
         };
-        let walk_data = WalkData::new_with_ignore_matcher(
-            path,
-            self.file_nodes.ignore_paths(),
-            Arc::clone(&self.ignore_matcher),
-            true,
-            self.stop,
-        );
-        let node = match walk_it_without_root_chain(&walk_data) {
-            Some(node) => node,
-            None => {
-                self.remove_node_path(path);
-                return None;
-            }
-        };
         let parent = path.parent().expect(
             "scan_path_recursive doesn't expected to scan root(should be filtered outside)",
         );
@@ -437,6 +442,21 @@ impl SearchCache {
         {
             self.remove_node(old_node);
         }
+        let stop = self.stop;
+        let walk_data = WalkData::new_with_ignore_matcher(
+            path,
+            self.file_nodes.ignore_paths(),
+            Arc::clone(&self.ignore_matcher),
+            true,
+            move || stop.map(|x| x.load(Ordering::Relaxed)).unwrap_or_default(),
+        );
+        let node = match walk_it_without_root_chain(&walk_data) {
+            Some(node) => node,
+            None => {
+                self.remove_node_path(path);
+                return None;
+            }
+        };
         let node = self.create_node_slab_update_name_index_and_name_pool(Some(parent), &node);
         // Push the newly created node to the parent's children
         self.file_nodes[parent].add_children(node);
@@ -460,19 +480,27 @@ impl SearchCache {
         &self,
         phantom1: &'p mut PathBuf,
         phantom2: &'p mut Vec<PathBuf>,
-    ) -> WalkData<'p> {
+        scan_cancellation_token: CancellationToken,
+    ) -> WalkData<'p, impl Fn() -> bool + Send + Sync + Copy + 'static> {
         *phantom1 = self.file_nodes.path().to_path_buf();
         *phantom2 = self.file_nodes.ignore_paths().clone();
+        let stop = self.stop;
         WalkData::new_with_ignore_matcher(
             phantom1,
             phantom2,
             Arc::clone(&self.ignore_matcher),
             false,
-            self.stop,
+            move || {
+                stop.map(|x| x.load(Ordering::Relaxed)).unwrap_or_default()
+                    || scan_cancellation_token.is_cancelled().is_none()
+            },
         )
     }
 
-    pub fn rescan_with_walk_data(&mut self, walk_data: &WalkData) -> Option<()> {
+    pub fn rescan_with_walk_data<F>(&mut self, walk_data: &WalkData<'_, F>) -> Option<()>
+    where
+        F: Fn() -> bool + Send + Sync,
+    {
         let Some(new_cache) = Self::walk_fs_with_walk_data(walk_data, self.stop) else {
             info!("Rescan cancelled.");
             return None;
@@ -483,13 +511,14 @@ impl SearchCache {
 
     pub fn rescan(&mut self) {
         // Remove all memory consuming cache early for memory consumption in Self::walk_fs_new.
+        let stop = self.stop;
         let Some(new_cache) = Self::walk_fs_with_walk_data(
             &WalkData::new_with_ignore_matcher(
                 self.file_nodes.path(),
                 self.file_nodes.ignore_paths(),
                 Arc::clone(&self.ignore_matcher),
                 false,
-                self.stop,
+                move || stop.map(|x| x.load(Ordering::Relaxed)).unwrap_or_default(),
             ),
             self.stop,
         ) else {
@@ -1611,36 +1640,6 @@ mod tests {
         assert_eq!(cache.search("new_file.txt").unwrap().len(), 1);
     }
 
-    #[test]
-    fn test_handle_fs_event_out_of_root_ancestor_does_not_mask_in_root_path() {
-        let temp_dir = TempDir::new("test_events").expect("Failed to create temp directory");
-        let temp_path = temp_dir.path();
-        let mut cache = SearchCache::walk_fs(temp_path);
-
-        let in_root_file = temp_path.join("new_file.txt");
-        fs::File::create(&in_root_file).expect("Failed to create file");
-
-        let out_of_root_ancestor = temp_path
-            .parent()
-            .expect("temp dir should always have a parent")
-            .to_path_buf();
-        let mock_events = vec![
-            FsEvent {
-                path: out_of_root_ancestor,
-                id: cache.last_event_id + 1,
-                flag: EventFlag::ItemModified | EventFlag::ItemIsDir,
-            },
-            FsEvent {
-                path: in_root_file,
-                id: cache.last_event_id + 2,
-                flag: EventFlag::ItemCreated | EventFlag::ItemIsFile,
-            },
-        ];
-
-        cache.handle_fs_events(mock_events).unwrap();
-        assert_eq!(cache.search("new_file.txt").unwrap().len(), 1);
-    }
-
     // Processing outdated fs event is required to avoid bouncing.
     #[test]
     fn test_handle_outdated_fs_event() {
@@ -3156,24 +3155,4 @@ mod tests {
         let out = scan_paths(events);
         assert_eq!(out, vec![PathBuf::from("/long")]);
     }
-
-    #[test]
-    fn test_scan_paths_under_root_filters_masking_out_of_root_ancestor() {
-        let watch_root = Path::new("/tmp/watch");
-        let events = vec![
-            FsEvent {
-                path: PathBuf::from("/tmp"),
-                id: 1,
-                flag: EventFlag::ItemModified | EventFlag::ItemIsDir,
-            },
-            FsEvent {
-                path: PathBuf::from("/tmp/watch/new.txt"),
-                id: 2,
-                flag: EventFlag::ItemCreated | EventFlag::ItemIsFile,
-            },
-        ];
-
-        let out = scan_paths_under_root(events, watch_root);
-        assert_eq!(out, vec![PathBuf::from("/tmp/watch/new.txt")]);
-    }
 }

From b0bdb9154127d9ed829ed9de4496c62d53f930dc Mon Sep 17 00:00:00 2001
From: Mohamad Yahia <xyzt70@gmail.com>
Date: Wed, 4 Mar 2026 03:15:03 +0400
Subject: [PATCH 10/16] fix: resolve rust and tauri CI failures

---
 cardinal/src-tauri/src/commands.rs      | 25 ++++++++++---------------
 cardinal/src-tauri/src/lib.rs           |  5 +++--
 search-cache/src/tests/date_volume.rs   |  5 +++--
 search-cache/src/tests/query_logic.rs   | 18 +++++++++---------
 search-cache/src/tests/wildcard_star.rs |  5 ++---
 5 files changed, 27 insertions(+), 31 deletions(-)

diff --git a/cardinal/src-tauri/src/commands.rs b/cardinal/src-tauri/src/commands.rs
index cdd31a30..c3db7c46 100644
--- a/cardinal/src-tauri/src/commands.rs
+++ b/cardinal/src-tauri/src/commands.rs
@@ -22,12 +22,7 @@ use parking_lot::Mutex;
 use search_cache::{SearchOptions, SearchOutcome, SearchResultNode, SlabIndex, SlabNodeMetadata};
 use search_cancel::CancellationToken;
 use serde::{Deserialize, Serialize};
-use std::{
-    cell::LazyCell,
-    fs::OpenOptions,
-    io::Write,
-    process::Command,
-};
+use std::{cell::LazyCell, fs::OpenOptions, io::Write, process::Command};
 use tauri::{ActivationPolicy, AppHandle, State};
 use tracing::{error, info, warn};
 
@@ -187,10 +182,10 @@ fn normalize_path_input(raw: &str) -> Option<String> {
 /// including empty lines and comments. A leading `~` is expanded so
 /// existing home-relative ignore entries keep matching.
 fn normalize_ignore_path_input(raw: &str) -> String {
-    if raw == "~" || raw.starts_with("~/") {
-        if let Some(expanded) = expand_path_input(raw) {
-            return expanded;
-        }
+    if (raw == "~" || raw.starts_with("~/"))
+        && let Some(expanded) = expand_path_input(raw)
+    {
+        return expanded;
     }
 
     raw.to_string()
@@ -495,9 +490,9 @@ pub async fn write_listed_files_tsv(path: String, content: String) -> Result<(),
         .truncate(true)
         .write(true)
         .open(&path)
-        .map_err(|e| format!("Failed to open TSV file for writing {}: {e}", path))?;
+        .map_err(|e| format!("Failed to open TSV file for writing {path}: {e}"))?;
     file.write_all(content.as_bytes())
-        .map_err(|e| format!("Failed to write TSV file to {}: {e}", path))?;
+        .map_err(|e| format!("Failed to write TSV file to {path}: {e}"))?;
     info!("Saved listed-files TSV to {}", path);
     Ok(())
 }
@@ -508,9 +503,9 @@ pub async fn append_listed_files_tsv_chunk(path: String, content: String) -> Res
         .create(true)
         .append(true)
         .open(&path)
-        .map_err(|e| format!("Failed to open TSV file for appending {}: {e}", path))?;
+        .map_err(|e| format!("Failed to open TSV file for appending {path}: {e}"))?;
     file.write_all(content.as_bytes())
-        .map_err(|e| format!("Failed appending TSV chunk to {}: {e}", path))?;
+        .map_err(|e| format!("Failed appending TSV chunk to {path}: {e}"))?;
     Ok(())
 }
 
@@ -519,7 +514,7 @@ pub async fn remove_listed_files_tsv(path: String) -> Result<(), String> {
     match std::fs::remove_file(&path) {
         Ok(()) => Ok(()),
         Err(err) if err.kind() == std::io::ErrorKind::NotFound => Ok(()),
-        Err(err) => Err(format!("Failed to remove TSV file {}: {err}", path)),
+        Err(err) => Err(format!("Failed to remove TSV file {path}: {err}")),
     }
 }
 
diff --git a/cardinal/src-tauri/src/lib.rs b/cardinal/src-tauri/src/lib.rs
index 2247d801..0384ecb4 100644
--- a/cardinal/src-tauri/src/lib.rs
+++ b/cardinal/src-tauri/src/lib.rs
@@ -17,8 +17,9 @@ use commands::{
     append_listed_files_tsv_chunk, close_quicklook, copy_files_to_clipboard, get_app_status,
     get_nodes_info, get_sorted_view, hide_main_window, normalize_watch_config, open_in_finder,
     open_path, prompt_save_listed_files_tsv, remove_listed_files_tsv, search,
-    set_tray_activation_policy, set_watch_config, start_logic, toggle_main_window, toggle_quicklook,
-    trigger_rescan, update_icon_viewport, update_quicklook, write_listed_files_tsv,
+    set_tray_activation_policy, set_watch_config, start_logic, toggle_main_window,
+    toggle_quicklook, trigger_rescan, update_icon_viewport, update_quicklook,
+    write_listed_files_tsv,
 };
 use crossbeam_channel::{Receiver, RecvTimeoutError, Sender, bounded, unbounded};
 use lifecycle::{
diff --git a/search-cache/src/tests/date_volume.rs b/search-cache/src/tests/date_volume.rs
index eb8e3c16..4e617c76 100644
--- a/search-cache/src/tests/date_volume.rs
+++ b/search-cache/src/tests/date_volume.rs
@@ -276,8 +276,9 @@ fn segment_2_month_year_keywords() {
     set_file_times(&mut cache, last_year_idx, last_year_ts, last_year_ts);
     let thismonth_hits = cache.search("dm:thismonth").unwrap();
     assert!(list_names(&cache, &thismonth_hits).contains(&"jan_file.txt".to_string()));
-    let lastmonth_hits = cache.search("dm:lastmonth").unwrap(); // may or may not include depending on date; just ensure no panic
-    assert!(lastmonth_hits.len() <= 1);
+    let lastmonth_hits = cache.search("dm:lastmonth").unwrap(); // ensure query is stable and excludes clearly out-of-range fixtures
+    let lastmonth_names = list_names(&cache, &lastmonth_hits);
+    assert!(!lastmonth_names.contains(&"last_year_file.txt".to_string()));
     let thisyear_hits = cache.search("dm:thisyear").unwrap();
     assert!(list_names(&cache, &thisyear_hits).contains(&"jan_file.txt".to_string()));
     let lastyear_hits = cache.search("dm:lastyear").unwrap();
diff --git a/search-cache/src/tests/query_logic.rs b/search-cache/src/tests/query_logic.rs
index 5d2d1955..aeeabea6 100644
--- a/search-cache/src/tests/query_logic.rs
+++ b/search-cache/src/tests/query_logic.rs
@@ -88,10 +88,11 @@ fn test_globstar_dedup_nested_bar_paths() {
 #[test]
 fn test_globstar_dedup_trailing_expansion() {
     let tmp = TempDir::new("query_globstar_trailing").unwrap();
-    fs::create_dir_all(tmp.path().join("a/a")).unwrap();
-    fs::write(tmp.path().join("a/file.txt"), b"x").unwrap();
-    fs::write(tmp.path().join("a/a/file.txt"), b"x").unwrap();
-    let mut cache = SearchCache::walk_fs(tmp.path());
+    let search_root = tmp.path().join("root");
+    fs::create_dir_all(search_root.join("a/a")).unwrap();
+    fs::write(search_root.join("a/file.txt"), b"x").unwrap();
+    fs::write(search_root.join("a/a/file.txt"), b"x").unwrap();
+    let mut cache = SearchCache::walk_fs(&search_root);
 
     let hits = cache.search("a/**").unwrap();
     let mut rel_paths = hits
@@ -100,7 +101,7 @@ fn test_globstar_dedup_trailing_expansion() {
             cache
                 .node_path(*i)
                 .unwrap()
-                .strip_prefix(tmp.path())
+                .strip_prefix(&search_root)
                 .unwrap()
                 .to_path_buf()
         })
@@ -646,12 +647,12 @@ fn test_trailing_globstar_performance_many_files() {
 
     // Create many nested files
     for i in 0..50 {
-        fs::write(tmp.path().join(format!("large/file{:03}.txt", i)), b"x").unwrap();
+        fs::write(tmp.path().join(format!("large/file{i:03}.txt")), b"x").unwrap();
     }
     fs::create_dir_all(tmp.path().join("large/subdir")).unwrap();
     for i in 0..50 {
         fs::write(
-            tmp.path().join(format!("large/subdir/file{:03}.txt", i)),
+            tmp.path().join(format!("large/subdir/file{i:03}.txt")),
             b"x",
         )
         .unwrap();
@@ -666,8 +667,7 @@ fn test_trailing_globstar_performance_many_files() {
     assert!(hits.len() >= 101, "should find all descendants");
     assert!(
         duration.as_millis() < 100,
-        "should complete quickly: {:?}",
-        duration
+        "should complete quickly: {duration:?}"
     );
 }
 
diff --git a/search-cache/src/tests/wildcard_star.rs b/search-cache/src/tests/wildcard_star.rs
index eeea36ef..c9a65682 100644
--- a/search-cache/src/tests/wildcard_star.rs
+++ b/search-cache/src/tests/wildcard_star.rs
@@ -474,7 +474,7 @@ fn star_performance_many_siblings() {
     fs::create_dir_all(tmp.path().join("large")).unwrap();
 
     for i in 0..100 {
-        fs::write(tmp.path().join(format!("large/file{:03}.txt", i)), b"x").unwrap();
+        fs::write(tmp.path().join(format!("large/file{i:03}.txt")), b"x").unwrap();
     }
 
     let mut cache = SearchCache::walk_fs(tmp.path());
@@ -486,8 +486,7 @@ fn star_performance_many_siblings() {
     // Should complete in reasonable time (< 100ms for 100 files)
     assert!(
         duration.as_millis() < 100,
-        "star search took too long: {:?}",
-        duration
+        "star search took too long: {duration:?}"
     );
 }
 

From 348d847740ad4ba8a976cb840c7bc9032cbdeca8 Mon Sep 17 00:00:00 2001
From: Mohamad Yahia <xyzt70@gmail.com>
Date: Fri, 6 Mar 2026 07:58:11 +0400
Subject: [PATCH 11/16] chore: Addressed copilot comments

---
 Cargo.lock                                    |   1 +
 cardinal/src-tauri/Cargo.lock                 |   1 +
 cardinal/src-tauri/src/commands.rs            |  82 +++++++++
 cardinal/src/App.css                          |  20 ++-
 cardinal/src/App.tsx                          |   2 +-
 .../src/__tests__/App.contextMenu.test.tsx    |   4 +-
 .../src/components/PreferencesOverlay.tsx     |  25 +--
 cardinal/src/components/StatusBar.tsx         |   8 +-
 .../hooks/__tests__/useIgnorePaths.test.ts    |  35 +++-
 cardinal/src/hooks/useIgnorePaths.ts          | 167 ++++++++----------
 cardinal/src/i18n/resources/ar-SA.json        |   9 +-
 cardinal/src/i18n/resources/en-US.json        |   9 +-
 .../src/utils/__tests__/watchRoot.test.ts     |  23 +--
 cardinal/src/utils/watchRoot.ts               |   4 -
 fswalk/Cargo.toml                             |   1 +
 fswalk/src/lib.rs                             |  22 ++-
 replies.md                                    |  25 +++
 17 files changed, 278 insertions(+), 160 deletions(-)
 create mode 100644 replies.md

diff --git a/Cargo.lock b/Cargo.lock
index 60815471..ff10bb9b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -430,6 +430,7 @@ dependencies = [
  "serde",
  "serde_repr",
  "tempdir",
+ "tracing",
 ]
 
 [[package]]
diff --git a/cardinal/src-tauri/Cargo.lock b/cardinal/src-tauri/Cargo.lock
index f271b8e1..4661bd43 100644
--- a/cardinal/src-tauri/Cargo.lock
+++ b/cardinal/src-tauri/Cargo.lock
@@ -1270,6 +1270,7 @@ dependencies = [
  "rayon",
  "serde",
  "serde_repr",
+ "tracing",
 ]
 
 [[package]]
diff --git a/cardinal/src-tauri/src/commands.rs b/cardinal/src-tauri/src/commands.rs
index c3db7c46..f9992324 100644
--- a/cardinal/src-tauri/src/commands.rs
+++ b/cardinal/src-tauri/src/commands.rs
@@ -191,6 +191,38 @@ fn normalize_ignore_path_input(raw: &str) -> String {
     raw.to_string()
 }
 
+/// Re-anchor legacy absolute ignore entries beneath the watch root so they keep
+/// matching after ignore evaluation switched to watch-root-relative gitignore semantics.
+fn rewrite_ignore_path_for_watch_root(raw: &str, watch_root: &str) -> String {
+    if watch_root == "/" {
+        return raw.to_string();
+    }
+
+    let (prefix, pattern) = if let Some(pattern) = raw.strip_prefix('!') {
+        ("!", pattern)
+    } else {
+        ("", raw)
+    };
+
+    if !pattern.starts_with('/') {
+        return raw.to_string();
+    }
+
+    let rewritten = if pattern == watch_root || pattern == format!("{watch_root}/") {
+        "/*".to_string()
+    } else if let Some(stripped) = pattern.strip_prefix(watch_root) {
+        if stripped.starts_with('/') {
+            stripped.to_string()
+        } else {
+            return raw.to_string();
+        }
+    } else {
+        return raw.to_string();
+    };
+
+    format!("{prefix}{rewritten}")
+}
+
 pub(crate) fn normalize_watch_config(
     watch_root: &str,
     ignore_paths: Vec<String>,
@@ -208,6 +240,9 @@ pub(crate) fn normalize_watch_config(
     {
         ignore_paths.push(DEFAULT_SYSTEM_IGNORE_PATH.to_string());
     }
+    for path in &mut ignore_paths {
+        *path = rewrite_ignore_path_for_watch_root(path, &watch_root);
+    }
     Some((watch_root, ignore_paths))
 }
 
@@ -727,4 +762,51 @@ mod tests {
         assert!(ignore_paths.contains(&"/tmp/cache".to_string()));
         assert!(ignore_paths.contains(&DEFAULT_SYSTEM_IGNORE_PATH.to_string()));
     }
+
+    #[test]
+    fn normalize_watch_config_rewrites_absolute_ignore_entries_under_non_root_watch_root() {
+        let Some((watch_root, ignore_paths)) = normalize_watch_config(
+            "/Users/me",
+            vec![
+                "/Users/me/Library/Caches/".to_string(),
+                "!/Users/me/project/keep.txt".to_string(),
+                "/Users/other/cache/".to_string(),
+            ],
+            None,
+        ) else {
+            panic!("watch config should be valid");
+        };
+
+        assert_eq!(watch_root, "/Users/me");
+        assert!(ignore_paths.contains(&"/Library/Caches/".to_string()));
+        assert!(ignore_paths.contains(&"!/project/keep.txt".to_string()));
+        assert!(ignore_paths.contains(&"/Users/other/cache/".to_string()));
+        assert!(ignore_paths.contains(&DEFAULT_SYSTEM_IGNORE_PATH.to_string()));
+    }
+
+    #[test]
+    fn normalize_watch_config_rewrites_watch_root_self_ignore_to_root_contents() {
+        let Some((watch_root, ignore_paths)) = normalize_watch_config(
+            "/Users/me",
+            vec!["/Users/me/".to_string()],
+            None,
+        ) else {
+            panic!("watch config should be valid");
+        };
+
+        assert_eq!(watch_root, "/Users/me");
+        assert!(ignore_paths.contains(&"/*".to_string()));
+    }
+
+    #[test]
+    fn normalize_watch_config_rewrites_default_ignore_under_non_root_watch_root() {
+        let Some((watch_root, ignore_paths)) = normalize_watch_config("/System", vec![], None)
+        else {
+            panic!("watch config should be valid");
+        };
+
+        assert_eq!(watch_root, "/System");
+        assert!(ignore_paths.contains(&"/Volumes/".to_string()));
+        assert!(!ignore_paths.contains(&DEFAULT_SYSTEM_IGNORE_PATH.to_string()));
+    }
 }
diff --git a/cardinal/src/App.css b/cardinal/src/App.css
index e745a6d5..3e9fe832 100644
--- a/cardinal/src/App.css
+++ b/cardinal/src/App.css
@@ -1528,7 +1528,7 @@ button:active:not(:disabled) {
 
 .preferences-card {
   width: 100%;
-  max-width: 480px;
+  max-width: 580px;
   max-height: calc(100vh - 96px);
   background: var(--color-elevated-bg, var(--color-bg));
   color: var(--color-text);
@@ -1682,10 +1682,24 @@ button:active:not(:disabled) {
   min-width: 0;
 }
 
+.preferences-row--stacked {
+  grid-template-columns: minmax(0, 1fr);
+}
+
+.preferences-row__details--inline {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+
 .preferences-control {
   text-align: right;
 }
 
+.preferences-control--full-width {
+  width: 100%;
+}
+
 .preferences-control--stack {
   display: flex;
   flex-direction: column;
@@ -1718,8 +1732,8 @@ button:active:not(:disabled) {
 }
 
 .preferences-textarea {
-  width: 240px;
-  min-height: 88px;
+  width: 100%;
+  min-height: 230px;
   padding: 8px 10px;
   font-size: 0.9rem;
   line-height: 1.4;
diff --git a/cardinal/src/App.tsx b/cardinal/src/App.tsx
index 3655e142..584f7701 100644
--- a/cardinal/src/App.tsx
+++ b/cardinal/src/App.tsx
@@ -310,7 +310,7 @@ function App() {
         }
       }
       if (typeof window !== 'undefined') {
-        window.alert('Failed to export current files list. Please try again.');
+        window.alert(t('exportListedFiles.failed'));
       }
     }
   }, [activeTab, currentQuery, displayedResults, t]);
diff --git a/cardinal/src/__tests__/App.contextMenu.test.tsx b/cardinal/src/__tests__/App.contextMenu.test.tsx
index 1f2bdd58..76f3a55b 100644
--- a/cardinal/src/__tests__/App.contextMenu.test.tsx
+++ b/cardinal/src/__tests__/App.contextMenu.test.tsx
@@ -455,8 +455,6 @@ describe('App context menu regression', () => {
       });
     });
 
-    expect(mocks.alert).toHaveBeenCalledWith(
-      'Failed to export current files list. Please try again.',
-    );
+    expect(mocks.alert).toHaveBeenCalledWith('exportListedFiles.failed');
   });
 });
diff --git a/cardinal/src/components/PreferencesOverlay.tsx b/cardinal/src/components/PreferencesOverlay.tsx
index b82ede96..f1f9bf04 100644
--- a/cardinal/src/components/PreferencesOverlay.tsx
+++ b/cardinal/src/components/PreferencesOverlay.tsx
@@ -1,6 +1,6 @@
 import React, { useCallback, useEffect, useState } from 'react';
 import { useTranslation } from 'react-i18next';
-import { getWatchRootValidation, isIgnorePathInputValid } from '../utils/watchRoot';
+import { getWatchRootValidation } from '../utils/watchRoot';
 import ThemeSwitcher from './ThemeSwitcher';
 import LanguageSwitcher from './LanguageSwitcher';
 
@@ -106,10 +106,6 @@ export function PreferencesOverlay({
   };
 
   const parsedIgnorePaths = ignorePathsInput.split(/\r?\n/);
-  const ignorePathsErrorMessage = (() => {
-    const invalid = parsedIgnorePaths.find((line) => !isIgnorePathInputValid(line));
-    return invalid ? t('ignorePaths.errors.absolute') : null;
-  })();
 
   const handleIgnorePathsKeyDown = (event: React.KeyboardEvent<HTMLTextAreaElement>): void => {
     if (event.key === 'Escape') {
@@ -122,7 +118,7 @@ export function PreferencesOverlay({
   };
 
   const handleSave = (): void => {
-    if (watchRootErrorMessage || ignorePathsErrorMessage) {
+    if (watchRootErrorMessage) {
       return;
     }
     commitThreshold();
@@ -231,8 +227,8 @@ export function PreferencesOverlay({
               ) : null}
             </div>
           </div>
-          <div className="preferences-row">
-            <div className="preferences-row__details">
+          <div className="preferences-row preferences-row--stacked">
+            <div className="preferences-row__details preferences-row__details--inline">
               <p className="preferences-label">
                 <span title={t('ignorePaths.help')}>{t('ignorePaths.label')}</span>
                 <button
@@ -246,7 +242,7 @@ export function PreferencesOverlay({
                 </button>
               </p>
             </div>
-            <div className="preferences-control preferences-control--stack">
+            <div className="preferences-control preferences-control--stack preferences-control--full-width">
               <textarea
                 className="preferences-field preferences-textarea"
                 value={ignorePathsInput}
@@ -256,15 +252,6 @@ export function PreferencesOverlay({
                 autoComplete="off"
                 spellCheck={false}
               />
-              {ignorePathsErrorMessage ? (
-                <p
-                  className="permission-status permission-status--error preferences-field-error"
-                  role="status"
-                  aria-live="polite"
-                >
-                  {ignorePathsErrorMessage}
-                </p>
-              ) : null}
             </div>
           </div>
         </div>
@@ -273,7 +260,7 @@ export function PreferencesOverlay({
             className="preferences-save"
             type="button"
             onClick={handleSave}
-            disabled={Boolean(watchRootErrorMessage || ignorePathsErrorMessage)}
+            disabled={Boolean(watchRootErrorMessage)}
           >
             {t('preferences.save')}
           </button>
diff --git a/cardinal/src/components/StatusBar.tsx b/cardinal/src/components/StatusBar.tsx
index 11f40fe7..3476858f 100644
--- a/cardinal/src/components/StatusBar.tsx
+++ b/cardinal/src/components/StatusBar.tsx
@@ -27,7 +27,6 @@ const LIFECYCLE_META: Record<AppLifecycleStatus, { icon: string; tone: string }>
   Updating: { icon: '◑', tone: 'updating' },
   Ready: { icon: '●', tone: 'ready' },
 };
-const EXPORT_BUTTON_LABEL = 'Export current files list';
 
 const StatusBar = ({
   scannedFiles,
@@ -105,6 +104,7 @@ const StatusBar = ({
         })}`
       : rescanTitle;
   const indicatorLabel = t('statusBar.aria.status', { status: lifecycleLabel });
+  const exportButtonLabel = t('statusBar.aria.exportListedFiles');
 
   const handleOpenPreferences = useCallback(() => {
     openPreferences();
@@ -175,13 +175,13 @@ const StatusBar = ({
             className="status-icon-button status-export-button"
             onClick={handleRequestExport}
             disabled={!canExportListedFiles}
-            title={EXPORT_BUTTON_LABEL}
-            aria-label={EXPORT_BUTTON_LABEL}
+            title={exportButtonLabel}
+            aria-label={exportButtonLabel}
           >
             <span className="status-rescan-icon" aria-hidden="true">
               ↓
             </span>
-            <span className="sr-only">{EXPORT_BUTTON_LABEL}</span>
+            <span className="sr-only">{exportButtonLabel}</span>
           </button>
           <button
             type="button"
diff --git a/cardinal/src/hooks/__tests__/useIgnorePaths.test.ts b/cardinal/src/hooks/__tests__/useIgnorePaths.test.ts
index cb7cc4ef..1905add6 100644
--- a/cardinal/src/hooks/__tests__/useIgnorePaths.test.ts
+++ b/cardinal/src/hooks/__tests__/useIgnorePaths.test.ts
@@ -46,12 +46,18 @@ describe('useIgnorePaths', () => {
     );
   });
 
-  it('ships data-driven defaults with per-pattern comments and blank separators', () => {
+  it('ships grouped defaults with section comments and blank separators', () => {
     const { result } = renderHook(() => useIgnorePaths());
     const defaults = result.current.defaultIgnorePaths;
 
-    expect(defaults[0]).toContain('0 files in the 2026-02-24 sample');
+    expect(defaults[0]).toBe('# System volumes and large bundled trees.');
     expect(defaults).toContain('');
+    expect(defaults).toContain('# Developer tools and generated build outputs.');
+    expect(defaults).toContain('# Dependencies and package manager stores.');
+    expect(defaults).toContain('# Caches and runtime storage.');
+    expect(defaults).toContain('# App-specific local data.');
+    expect(defaults).toContain('# Common metadata and disposable directories.');
+    expect(defaults).toContain('# Database internals.');
     expect(defaults).toContain('**/node_modules/');
     expect(defaults).toContain('**/.pnpm/');
     expect(defaults).toContain('**/.bun/install/cache/');
@@ -59,6 +65,9 @@ describe('useIgnorePaths', () => {
     expect(defaults).toContain('**/.cache/');
     expect(defaults).toContain('**/Library/Application Support/*/Partitions/*/Cache/');
     expect(defaults).toContain('**/Library/Application Support/*/Cache/');
+    expect(defaults).toContain('~/Library/Application Support/Cursor/User/History/');
+    expect(defaults).toContain('~/Library/Application Support/Code*/User/History/');
+    expect(defaults).toContain('~/Library/pnpm/store');
     expect(defaults).toContain('**/Library/pnpm/store/');
     expect(defaults).toContain('**/target/');
     expect(defaults).toContain('**/Code Cache/');
@@ -67,14 +76,34 @@ describe('useIgnorePaths', () => {
     expect(defaults).toContain('**/WebStorage/');
     expect(defaults).toContain('**/.next/');
     expect(defaults).toContain('**/.git/');
+    expect(defaults).toContain('**/.gitignore');
+    expect(defaults).toContain('**/.lock');
+    expect(defaults).toContain('**/.bower.json');
+    expect(defaults).toContain('**/.github');
     expect(defaults).toContain('**/__pycache__/');
     expect(defaults).toContain('**/.cocoapods/');
     expect(defaults).toContain('**/.opam/');
     expect(defaults).toContain('**/*.pyc');
+    expect(defaults).toContain('**/*.db-shm');
     expect(defaults).toContain('**/.DS_Store');
-    expect(defaults).toContain('**/Google/Chrome*/Cache/');
+    expect(defaults).toContain('**/bower_components/');
+    expect(defaults).toContain('~/.rustup/toolchains/');
+    expect(defaults).toContain('~/.cursor/extensions/');
+    expect(defaults).toContain('~/.nuget/packages/');
+    expect(defaults).toContain('**/Google/Chrome*/**/GPUCache/');
+    expect(defaults).toContain('**/Vivaldi*/**/GPUCache/');
+    expect(defaults).toContain('**/Google/Chrome*/**/Local Storage/leveldb/');
+    expect(defaults).toContain('**/Vivaldi*/**/Local Storage/leveldb/');
     expect(defaults).toContain('/System/Volumes/');
+    expect(defaults).toContain('/System/iOSSupport/System/Library/');
+    expect(defaults).toContain('/Library/Apple/System/Library/PrivateFrameworks/');
+    expect(defaults).toContain('/Library/Application Support/Apple/BezelServices/');
     expect(defaults).toContain('~/Library/CloudStorage');
+    expect(defaults).toContain('~/Library/Containers/');
+    expect(defaults).toContain('~/Library/Group Containers/');
+    expect(defaults).toContain('~/.codex-profiles/*/tmp/');
+    expect(defaults).toContain('~/Library/Biome');
+    expect(defaults).toContain('~/Library/DuetExpertCenter');
   });
 
   it('keeps a whitespace-only stored array without writing defaults', async () => {
diff --git a/cardinal/src/hooks/useIgnorePaths.ts b/cardinal/src/hooks/useIgnorePaths.ts
index 8fef08ec..0570a50e 100644
--- a/cardinal/src/hooks/useIgnorePaths.ts
+++ b/cardinal/src/hooks/useIgnorePaths.ts
@@ -3,96 +3,96 @@ import { useStoredState } from './useStoredState';
 
 const STORAGE_KEY = 'cardinal.ignorePaths';
 const DEFAULT_IGNORE_PATHS = [
-  '# 0 files in the 2026-02-24 sample. Keep external volumes excluded to avoid indexing large mounted disks/network shares.',
+  '# System volumes and large bundled trees.',
   '/Volumes/',
-  '# Cloud provider stubs under CloudStorage may issue network I/O on first traversal (e.g. OneDrive).',
-  '~/Library/CloudStorage',
-  '',
-  '# 2,384,029 files across 414 roots. Node dependency trees dominate index volume and are regenerated.',
-  '**/node_modules/',
-  '',
-  '# 1,178,011 files across 1 root. iOS simulator runtime volumes are huge generated SDK trees.',
-  '/Library/Developer/CoreSimulator/Volumes/',
-  '',
-  '# 807,360 files across 103 roots. Library cache trees are high-churn generated app/system cache data.',
-  '**/Library/Caches/',
-  '',
-  '# 575,477 files across 81 roots. pnpm per-project stores are dependency artifacts, not user-authored files.',
-  '**/.pnpm/',
-  '',
-  '# 777,084 files across 1 root. Bun package cache is high-volume dependency artifact storage.',
-  '**/.bun/install/cache/',
-  '',
-  '# 449,342 files across 29 roots. App partition cache directories are browser/electron app cache payloads.',
-  '**/Library/Application Support/*/Partitions/*/Cache/',
-  '',
-  '# 403,015 files across 1 root. App bundles contain large binary/resource trees with low filename-search value.',
   '/Applications/',
-  '',
-  '# 326,312 files across 1 root. macOS system frameworks/resources are large and mostly static.',
+  '/cores/',
+  '/dev/',
+  '/private/',
+  '/System/iOSSupport/System/Library/',
   '/System/Library/',
+  '/System/Volumes/',
+  '/usr/share/',
+  '/xarts/',
+  '/Library/Apple/System/Library/PrivateFrameworks/',
+  '/Library/Application Support/Apple/BezelServices/',
+  '/System/Applications/**/Contents/Resources/',
   '',
-  '# 275,101 files across 1 root. Global pnpm content-addressed store is rebuildable cache data.',
-  '**/Library/pnpm/store/',
-  '',
-  '# 209,526 files across 1 root. Command-line tools/SDK payloads are generated development artifacts.',
+  '# Developer tools and generated build outputs.',
+  '/Library/Developer/CoreSimulator/Volumes/',
   '/Library/Developer/CommandLineTools/',
-  '',
-  '# 178,753 files across 22 roots. Dot-cache directories are tool-managed caches and usually disposable.',
-  '**/.cache/',
-  '',
-  '# 157,087 files across 155 roots. Browser/Electron code caches are transient compiled cache blobs.',
-  '**/Code Cache/',
-  '',
-  '# 142,017 files across 39 roots. App Support Cache directories hold large runtime cache data.',
-  '**/Library/Application Support/*/Cache/',
-  '',
-  '# 125,968 files across 1 root. Homebrew Cellar contains large versioned dependency trees.',
   '/opt/homebrew/Cellar/',
-  '',
-  '# 122,893 files across 44 roots. Service worker cache stores are high-churn browser app data.',
-  '**/Service Worker/CacheStorage/',
-  '',
-  '# 91,948 files across 1 root. Xcode DerivedData is disposable build/index output.',
+  '/opt/homebrew/share/',
+  '~/Library/Developer/CoreSimulator/Devices/',
+  '~/.rustup/toolchains/',
+  '~/.cursor/extensions/',
+  '~/.nuget/packages/',
   '**/Library/Developer/Xcode/DerivedData/',
-  '',
-  '# 83,513 files across 2 roots. Local shared tool data is mostly generated cache/storage.',
-  '**/.local/share/',
-  '',
-  '# 70,040 files across 1 root. npm content cache is package artifact storage.',
-  '**/.npm/_cacache/',
-  '',
-  '# 48,386 files across 39 roots. target directories are compiler/build outputs and should not be indexed.',
   '**/target/',
+  '**/.next/',
+  '**/Xcode.app/',
   '',
-  '# 31,886 files across 1 root. Gradle caches are dependency/build artifacts and can be rebuilt.',
+  '# Dependencies and package manager stores.',
+  '**/node_modules/',
+  '**/.pnpm/',
+  '~/Library/pnpm/store',
+  '**/Library/pnpm/store/',
+  '**/.bun/install/cache/',
+  '**/.npm/_cacache/',
   '**/.gradle/caches/',
-  '',
-  '# 28,765 files across 1 root. Cargo registry is Rust dependency cache.',
   '**/.cargo/registry/',
   '',
-  '# 25,015 files across 1 root. Homebrew shared docs/assets add large low-signal trees.',
-  '/opt/homebrew/share/',
-  '',
-  '# 16,390 files across 462 roots. IndexedDB contains app/browser internals with many small files.',
+  '# Caches and runtime storage.',
+  '**/Library/Caches/',
+  '**/Library/Application Support/*/Partitions/*/Cache/',
+  '**/Library/Application Support/*/Cache/',
+  '**/Code Cache/',
+  '**/Service Worker/CacheStorage/',
   '**/IndexedDB/',
-  '',
-  '# 8,739 files across 91 roots. WebStorage is browser state data with low filename-search value.',
   '**/WebStorage/',
+  '~/Library/Application Support/Cursor/User/History/',
+  '~/Library/Application Support/Code*/User/History/',
+  '**/Chromium/**/GPUCache/',
+  '**/Google/Chrome*/**/GPUCache/',
+  '**/BraveSoftware/Brave-Browser*/**/GPUCache/',
+  '**/Microsoft Edge*/**/GPUCache/',
+  '**/Arc/**/GPUCache/',
+  '**/Vivaldi*/**/GPUCache/',
+  '**/Chromium/**/Local Storage/leveldb/',
+  '**/Google/Chrome*/**/Local Storage/leveldb/',
+  '**/BraveSoftware/Brave-Browser*/**/Local Storage/leveldb/',
+  '**/Microsoft Edge*/**/Local Storage/leveldb/',
+  '**/Arc/**/Local Storage/leveldb/',
+  '**/Vivaldi*/**/Local Storage/leveldb/',
+  '**/Firefox/Profiles/**/sessionstore-backups/',
+  '**/Firefox/Profiles/**/storage/default/',
+  '**/Firefox/Profiles/**/storage/permanent/',
+  '**/Spotify/Users/*/pending-messages*',
+  '**/*.com.google.Chrome',
+  '**/webappsstore.sqlite-wal',
   '',
-  '# 6,122 files across 10 roots. Next.js build output is generated and frequently replaced.',
-  '**/.next/',
-  '',
-  '# Baseline exclusions re-added from previous defaults to avoid common dev/system noise.',
-  '/cores/',
-  '/dev/',
-  '/private/',
-  '/System/Volumes/',
-  '/usr/share/',
-  '/xarts/',
-  '/System/Applications/**/Contents/Resources/',
+  '# App-specific local data.',
+  '~/Library/CloudStorage',
+  '~/Library/Containers/',
+  '~/Library/Group Containers/',
+  '~/.codex-profiles/*/tmp/',
+  '**/.local/share/',
+  '**/.local/fsindex*',
+  '**/com.docker.docker/Data/',
+  '**/IconJar*/Backups/',
+  '**/Sublime Text */Index/',
+  '**/io.tailscale.ipn.macos/',
+  '**/wharf/',
+  '~/Library/Biome',
+  '~/Library/DuetExpertCenter',
   '',
+  '# Common metadata and disposable directories.',
+  '**/.cache/',
   '**/.git/',
+  '**/.gitignore',
+  '**/.lock',
+  '**/.bower.json',
+  '**/.github',
   '**/__pycache__/',
   '**/.cocoapods/',
   '**/.opam/',
@@ -100,32 +100,17 @@ const DEFAULT_IGNORE_PATHS = [
   '**/Caches/',
   '**/Index.noindex/',
   '**/TextIndex/',
-  '**/io.tailscale.ipn.macos/',
   '**/.stversions/',
-  '**/wharf/',
-  '**/Xcode.app/',
-  '**/.local/fsindex*',
-  '**/*.com.google.Chrome',
+  '**/*.db-shm',
   '**/*.pyc',
   '**/.dat.nosync*',
-  '**/webappsstore.sqlite-wal',
   '**/.DS_Store',
+  '**/bower_components/',
   '',
-  '**/com.docker.docker/Data/',
-  '**/Firefox/Profiles/**/sessionstore-backups/',
-  '**/Firefox/Profiles/**/storage/default/',
-  '**/Firefox/Profiles/**/storage/permanent/',
-  '**/Google/Chrome*/Cache/',
-  '**/Google/Chrome*/leveldb/',
-  '**/IconJar*/Backups/',
-  '**/Sublime Text */Index/',
+  '# Database internals.',
   '**/var/postgres/base/',
   '**/var/postgres/pg_stat_tmp/',
   '**/var/postgres/pg_wal/',
-  '**/Spotify/Users/*/pending-messages*',
-  '',
-  '/Library/Biome/',
-  '/Library/DuetExpertCenter/',
 ];
 
 const keepStringEntries = (next: unknown[]): string[] =>
diff --git a/cardinal/src/i18n/resources/ar-SA.json b/cardinal/src/i18n/resources/ar-SA.json
index e56b560f..0f6df1ed 100644
--- a/cardinal/src/i18n/resources/ar-SA.json
+++ b/cardinal/src/i18n/resources/ar-SA.json
@@ -62,6 +62,7 @@
       "status": "حالة التطبيق: {{status}}",
       "tablist": "عرض حالة البحث",
       "rescan": "بدء إعادة فحص نظام الملفات",
+      "exportListedFiles": "تصدير قائمة الملفات الحالية",
       "settings": "فتح التفضيلات"
     },
     "rescan": {
@@ -162,9 +163,9 @@
   },
   "ignorePaths": {
     "label": "مسارات متجاهلة",
-    "help": "مسار واحد في كل سطر؛ المسارات المتجاهلة يتم تخطيها أثناء الفهرسة.",
-    "errors": {
-      "absolute": "يرجى إدخال نمط مسار glob غير فارغ."
-    }
+    "help": "نمط واحد بأسلوب .gitignore في كل سطر. الأسطر الفارغة والأسطر التي تبدأ بـ '#' مسموح بها."
+  },
+  "exportListedFiles": {
+    "failed": "تعذر تصدير قائمة الملفات الحالية. يرجى المحاولة مرة أخرى."
   }
 }
diff --git a/cardinal/src/i18n/resources/en-US.json b/cardinal/src/i18n/resources/en-US.json
index 1413fec3..cb39e6d4 100644
--- a/cardinal/src/i18n/resources/en-US.json
+++ b/cardinal/src/i18n/resources/en-US.json
@@ -62,6 +62,7 @@
       "status": "Application status: {{status}}",
       "tablist": "Search status view",
       "rescan": "Trigger filesystem rescan",
+      "exportListedFiles": "Export current files list",
       "settings": "Open preferences"
     },
     "rescan": {
@@ -162,9 +163,9 @@
   },
   "ignorePaths": {
     "label": "Ignore paths",
-    "help": "One glob style pattern per line (Just like .gitignore)",
-    "errors": {
-      "absolute": "Please enter a non-empty glob path pattern."
-    }
+    "help": "One .gitignore-style pattern per line. Blank lines and lines starting with '#' are allowed."
+  },
+  "exportListedFiles": {
+    "failed": "Failed to export current files list. Please try again."
   }
 }
diff --git a/cardinal/src/utils/__tests__/watchRoot.test.ts b/cardinal/src/utils/__tests__/watchRoot.test.ts
index cde54bf6..af1af536 100644
--- a/cardinal/src/utils/__tests__/watchRoot.test.ts
+++ b/cardinal/src/utils/__tests__/watchRoot.test.ts
@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest';
 
-import { getWatchRootValidation, isIgnorePathInputValid, isPathInputValid } from '../watchRoot';
+import { getWatchRootValidation, isPathInputValid } from '../watchRoot';
 
 describe('isPathInputValid', () => {
   it('rejects empty or whitespace-only inputs', () => {
@@ -71,24 +71,3 @@ describe('getWatchRootValidation', () => {
     });
   });
 });
-
-describe('isIgnorePathInputValid', () => {
-  it('accepts gitignore-style entries', () => {
-    expect(isIgnorePathInputValid('/tmp/cache')).toBe(true);
-    expect(isIgnorePathInputValid('~/Library/Caches')).toBe(true);
-    expect(isIgnorePathInputValid('**/node_modules/**')).toBe(true);
-    expect(isIgnorePathInputValid('build/*.tmp')).toBe(true);
-    expect(isIgnorePathInputValid('.cache')).toBe(true);
-    expect(isIgnorePathInputValid('__pycache__')).toBe(true);
-    expect(isIgnorePathInputValid('relative/path')).toBe(true);
-    expect(isIgnorePathInputValid('./relative/path')).toBe(true);
-    expect(isIgnorePathInputValid('Library/Biome/')).toBe(true);
-    expect(isIgnorePathInputValid('!/keep.me')).toBe(true);
-    expect(isIgnorePathInputValid('# comment')).toBe(true);
-  });
-
-  it('accepts empty and whitespace-only entries for formatting', () => {
-    expect(isIgnorePathInputValid('')).toBe(true);
-    expect(isIgnorePathInputValid('   ')).toBe(true);
-  });
-});
diff --git a/cardinal/src/utils/watchRoot.ts b/cardinal/src/utils/watchRoot.ts
index 032f7977..1734b37a 100644
--- a/cardinal/src/utils/watchRoot.ts
+++ b/cardinal/src/utils/watchRoot.ts
@@ -5,10 +5,6 @@ export const isPathInputValid = (input: string): boolean => {
   return trimmed === '~' || trimmed.startsWith('~/');
 };
 
-export const isIgnorePathInputValid = (_input: string): boolean => {
-  return true;
-};
-
 type WatchRootValidation = {
   isValid: boolean;
   errorKey: 'watchRoot.errors.required' | 'watchRoot.errors.absolute' | null;
diff --git a/fswalk/Cargo.toml b/fswalk/Cargo.toml
index 4b3e99a4..8053680a 100644
--- a/fswalk/Cargo.toml
+++ b/fswalk/Cargo.toml
@@ -10,6 +10,7 @@ rayon = "1"
 memchr = "2.7.4"
 enumn = "0.1.14"
 ignore = "0.4"
+tracing = "0.1"
 
 [dev-dependencies]
 tempdir = "0.3"
diff --git a/fswalk/src/lib.rs b/fswalk/src/lib.rs
index f23911ef..878e6f78 100644
--- a/fswalk/src/lib.rs
+++ b/fswalk/src/lib.rs
@@ -14,6 +14,7 @@ use std::{
     },
     time::UNIX_EPOCH,
 };
+use tracing::warn;
 
 #[derive(Serialize, Debug)]
 pub struct Node {
@@ -102,10 +103,27 @@ impl IgnoreMatcher {
         let mut builder = GitignoreBuilder::new(root_path);
         for ignore in ignore_directories {
             let pattern = ignore.to_string_lossy();
-            let _ = builder.add_line(None, &pattern);
+            if let Err(error) = builder.add_line(None, &pattern) {
+                warn!(
+                    root_path = %root_path.display(),
+                    pattern = %pattern,
+                    %error,
+                    "failed to add ignore pattern"
+                );
+            }
         }
 
-        let gitignore = builder.build().ok();
+        let gitignore = match builder.build() {
+            Ok(gitignore) => Some(gitignore),
+            Err(error) => {
+                warn!(
+                    root_path = %root_path.display(),
+                    %error,
+                    "failed to build ignore matcher; ignore patterns are disabled for this root"
+                );
+                None
+            }
+        };
         Self {
             root_path: root_path.to_path_buf(),
             gitignore,
diff --git a/replies.md b/replies.md
new file mode 100644
index 00000000..9c89bfc1
--- /dev/null
+++ b/replies.md
@@ -0,0 +1,25 @@
+# PR 152 Reviewer Replies
+
+## `discussion_r2881615380` - `fswalk/src/lib.rs`
+
+Thanks. I addressed this in the latest changes. `IgnoreMatcher::new` now logs each `GitignoreBuilder::add_line` failure with the offending pattern and root, and it also logs plus safely falls back when `build()` fails so invalid patterns no longer fail silently.
+
+## `discussion_r2881615414` - `cardinal/src/utils/watchRoot.ts`
+
+I handled this by removing the frontend ignore-pattern validation path instead of trying to duplicate `.gitignore` parsing in TypeScript. The UI now preserves raw lines verbatim, including blank lines and comments, and the Rust matcher build is the single source of truth. Invalid patterns are now surfaced through backend logging when the matcher is constructed.
+
+## `discussion_r2881615425` - `cardinal/src/components/StatusBar.tsx`
+
+Fixed. The export button label is now localized through `t('statusBar.aria.exportListedFiles')` for `title`, `aria-label`, and the screen-reader text.
+
+## `discussion_r2881615437` - `cardinal/src/App.tsx`
+
+Fixed. The export failure alert now uses a localized `t('exportListedFiles.failed')` string. There is not a shared toast or notification surface in this flow yet, so I kept the existing alert behavior but removed the hard-coded English copy.
+
+## `discussion_r2881615448` - `cardinal/src/i18n/resources/en-US.json`
+
+Adjusted. The ignore help text now says `.gitignore-style` and explicitly notes that blank lines and `#` comments are allowed. Since I removed the frontend ignore validation path, the stale "non-empty glob path" error copy is gone as well.
+
+## `discussion_r2881615455` - `cardinal/src-tauri/src/commands.rs`
+
+Fixed. `normalize_watch_config` now rewrites legacy absolute ignore entries that live under a non-`/` watch root into watch-root-relative patterns before they reach the matcher, including negated entries and the built-in default system ignore when it falls under the watch root. I also added unit coverage for user-supplied absolute entries, whole-watch-root ignores, and the `/System` default rewrite case.

From 587c6fa56ac2b2b8b9bbb75536a2ef6ea7f2a665 Mon Sep 17 00:00:00 2001
From: Mohamad Yahia <xyzt70@gmail.com>
Date: Fri, 6 Mar 2026 08:07:03 +0400
Subject: [PATCH 12/16] feat: Added multi line comments support and
 instructions for ignore paths

---
 cardinal/src-tauri/src/commands.rs            | 80 ++++++++++++++++++-
 cardinal/src/App.css                          | 53 +++++++++++-
 .../src/components/PreferencesOverlay.tsx     | 43 +++++++++-
 .../__tests__/PreferencesOverlay.test.tsx     | 15 ++++
 cardinal/src/i18n/resources/en-US.json        | 10 ++-
 5 files changed, 194 insertions(+), 7 deletions(-)

diff --git a/cardinal/src-tauri/src/commands.rs b/cardinal/src-tauri/src/commands.rs
index f9992324..824df89f 100644
--- a/cardinal/src-tauri/src/commands.rs
+++ b/cardinal/src-tauri/src/commands.rs
@@ -191,6 +191,31 @@ fn normalize_ignore_path_input(raw: &str) -> String {
     raw.to_string()
 }
 
+fn strip_multiline_ignore_comments(ignore_paths: Vec<String>) -> Vec<String> {
+    let mut normalized = Vec::with_capacity(ignore_paths.len());
+    let mut in_block_comment = false;
+
+    for path in ignore_paths {
+        let trimmed = path.trim();
+
+        if in_block_comment {
+            if trimmed == "*/" {
+                in_block_comment = false;
+            }
+            continue;
+        }
+
+        if trimmed == "/*" {
+            in_block_comment = true;
+            continue;
+        }
+
+        normalized.push(path);
+    }
+
+    normalized
+}
+
 /// Re-anchor legacy absolute ignore entries beneath the watch root so they keep
 /// matching after ignore evaluation switched to watch-root-relative gitignore semantics.
 fn rewrite_ignore_path_for_watch_root(raw: &str, watch_root: &str) -> String {
@@ -230,7 +255,7 @@ pub(crate) fn normalize_watch_config(
 ) -> Option<(String, Vec<String>)> {
     let watch_root = normalize_path_input(watch_root)
         .or_else(|| fallback_watch_root.and_then(normalize_path_input))?;
-    let mut ignore_paths = ignore_paths
+    let mut ignore_paths = strip_multiline_ignore_comments(ignore_paths)
         .into_iter()
         .map(|path| normalize_ignore_path_input(&path))
         .collect::<Vec<_>>();
@@ -740,6 +765,33 @@ mod tests {
         assert_eq!(normalize_ignore_path_input("   "), "   ".to_string());
     }
 
+    #[test]
+    fn strip_multiline_ignore_comments_skips_wrapped_lines_and_markers() {
+        assert_eq!(
+            strip_multiline_ignore_comments(vec![
+                "/tmp/keep".to_string(),
+                "/*".to_string(),
+                "/tmp/commented".to_string(),
+                "# still commented".to_string(),
+                "*/".to_string(),
+                "/tmp/after".to_string(),
+            ]),
+            vec!["/tmp/keep".to_string(), "/tmp/after".to_string()]
+        );
+    }
+
+    #[test]
+    fn strip_multiline_ignore_comments_comments_until_end_when_unclosed() {
+        assert_eq!(
+            strip_multiline_ignore_comments(vec![
+                "/tmp/keep".to_string(),
+                " /* ".to_string(),
+                "/tmp/commented".to_string(),
+            ]),
+            vec!["/tmp/keep".to_string()]
+        );
+    }
+
     #[test]
     fn normalize_watch_config_keeps_globs_and_adds_default_ignore_path() {
         let Some((watch_root, ignore_paths)) = normalize_watch_config(
@@ -763,6 +815,32 @@ mod tests {
         assert!(ignore_paths.contains(&DEFAULT_SYSTEM_IGNORE_PATH.to_string()));
     }
 
+    #[test]
+    fn normalize_watch_config_drops_multiline_commented_ignore_entries() {
+        let Some((watch_root, ignore_paths)) = normalize_watch_config(
+            "/",
+            vec![
+                "/tmp/keep".to_string(),
+                "/*".to_string(),
+                "/tmp/commented".to_string(),
+                "/tmp/also-commented".to_string(),
+                "*/".to_string(),
+                "/tmp/after".to_string(),
+            ],
+            None,
+        ) else {
+            panic!("watch config should be valid");
+        };
+
+        assert_eq!(watch_root, "/");
+        assert!(ignore_paths.contains(&"/tmp/keep".to_string()));
+        assert!(ignore_paths.contains(&"/tmp/after".to_string()));
+        assert!(!ignore_paths.contains(&"/*".to_string()));
+        assert!(!ignore_paths.contains(&"*/".to_string()));
+        assert!(!ignore_paths.contains(&"/tmp/commented".to_string()));
+        assert!(!ignore_paths.contains(&"/tmp/also-commented".to_string()));
+    }
+
     #[test]
     fn normalize_watch_config_rewrites_absolute_ignore_entries_under_non_root_watch_root() {
         let Some((watch_root, ignore_paths)) = normalize_watch_config(
diff --git a/cardinal/src/App.css b/cardinal/src/App.css
index 3e9fe832..9a28ce57 100644
--- a/cardinal/src/App.css
+++ b/cardinal/src/App.css
@@ -1671,13 +1671,31 @@ button:active:not(:disabled) {
 
 .preferences-help-text {
   margin-top: 4px;
-  max-width: 220px;
+  width: 100%;
   color: var(--color-text-secondary);
   font-size: 0.8rem;
   line-height: 1.35;
   white-space: normal;
 }
 
+.preferences-help-panel {
+  width: 100%;
+  margin-top: 8px;
+  padding: 10px 12px;
+  border: 1px solid var(--color-elevated-border, var(--color-border));
+  border-radius: 10px;
+  background: rgba(255, 255, 255, 0.02);
+}
+
+.preferences-help-list {
+  margin: 8px 0 0;
+  padding-left: 18px;
+}
+
+.preferences-help-list .preferences-help-text {
+  margin-top: 6px;
+}
+
 .preferences-row__details {
   min-width: 0;
 }
@@ -1692,6 +1710,10 @@ button:active:not(:disabled) {
   gap: 8px;
 }
 
+.preferences-row__details--inline .preferences-label {
+  margin: 0;
+}
+
 .preferences-control {
   text-align: right;
 }
@@ -1770,6 +1792,35 @@ button:active:not(:disabled) {
   outline-offset: 2px;
 }
 
+.preferences-ignore-info {
+  border: 1px solid var(--color-elevated-border, var(--color-border));
+  background: transparent;
+  color: var(--color-text-secondary);
+  border-radius: 999px;
+  width: 24px;
+  height: 24px;
+  padding: 0;
+  font-size: 0.82rem;
+  font-weight: 600;
+  line-height: 1;
+  cursor: pointer;
+  transition:
+    border-color 0.2s ease,
+    color 0.2s ease,
+    background-color 0.2s ease;
+}
+
+.preferences-ignore-info:hover {
+  border-color: var(--color-accent);
+  color: var(--color-text);
+  background: rgba(var(--color-accent-rgb), 0.08);
+}
+
+.preferences-ignore-info:focus-visible {
+  outline: 2px solid rgba(var(--color-accent-rgb), 0.35);
+  outline-offset: 2px;
+}
+
 .preferences-field:focus {
   outline: 2px solid rgba(var(--color-accent-rgb), 0.35);
   border-color: var(--color-accent);
diff --git a/cardinal/src/components/PreferencesOverlay.tsx b/cardinal/src/components/PreferencesOverlay.tsx
index f1f9bf04..6007b988 100644
--- a/cardinal/src/components/PreferencesOverlay.tsx
+++ b/cardinal/src/components/PreferencesOverlay.tsx
@@ -41,6 +41,7 @@ export function PreferencesOverlay({
   const [thresholdInput, setThresholdInput] = useState<string>(() => sortThreshold.toString());
   const [watchRootInput, setWatchRootInput] = useState<string>(() => watchRoot);
   const [ignorePathsInput, setIgnorePathsInput] = useState<string>(() => ignorePaths.join('\n'));
+  const [isIgnorePathsHelpOpen, setIsIgnorePathsHelpOpen] = useState(false);
 
   useEffect(() => {
     if (!open) {
@@ -146,6 +147,10 @@ export function PreferencesOverlay({
     }
   };
   const resetIgnorePathsLabel = `${t('preferences.reset')} ${t('ignorePaths.label')}`;
+  const ignorePathsHelpPanelId = 'preferences-ignore-paths-help';
+  const ignorePathsHelpToggleLabel = isIgnorePathsHelpOpen
+    ? t('ignorePaths.hideInfo')
+    : t('ignorePaths.showInfo');
 
   return (
     <div
@@ -228,9 +233,22 @@ export function PreferencesOverlay({
             </div>
           </div>
           <div className="preferences-row preferences-row--stacked">
-            <div className="preferences-row__details preferences-row__details--inline">
-              <p className="preferences-label">
-                <span title={t('ignorePaths.help')}>{t('ignorePaths.label')}</span>
+            <div className="preferences-row__details">
+              <div className="preferences-row__details--inline">
+                <p className="preferences-label">
+                  <span>{t('ignorePaths.label')}</span>
+                </p>
+                <button
+                  className="preferences-ignore-info"
+                  type="button"
+                  aria-label={ignorePathsHelpToggleLabel}
+                  aria-expanded={isIgnorePathsHelpOpen}
+                  aria-controls={ignorePathsHelpPanelId}
+                  title={ignorePathsHelpToggleLabel}
+                  onClick={() => setIsIgnorePathsHelpOpen((openState) => !openState)}
+                >
+                  i
+                </button>
                 <button
                   className="preferences-ignore-reset"
                   type="button"
@@ -240,7 +258,24 @@ export function PreferencesOverlay({
                 >
                   <span aria-hidden="true">↺</span>
                 </button>
-              </p>
+              </div>
+              {isIgnorePathsHelpOpen ? (
+                <div
+                  id={ignorePathsHelpPanelId}
+                  className="preferences-help-panel"
+                  role="note"
+                  aria-label={t('ignorePaths.infoTitle')}
+                >
+                  <p className="preferences-help-text">{t('ignorePaths.helpIntro')}</p>
+                  <ul className="preferences-help-list">
+                    <li className="preferences-help-text">{t('ignorePaths.helpComment')}</li>
+                    <li className="preferences-help-text">{t('ignorePaths.helpSingleStar')}</li>
+                    <li className="preferences-help-text">{t('ignorePaths.helpDoubleStar')}</li>
+                    <li className="preferences-help-text">{t('ignorePaths.helpAnchoring')}</li>
+                    <li className="preferences-help-text">{t('ignorePaths.helpNegation')}</li>
+                  </ul>
+                </div>
+              ) : null}
             </div>
             <div className="preferences-control preferences-control--stack preferences-control--full-width">
               <textarea
diff --git a/cardinal/src/components/__tests__/PreferencesOverlay.test.tsx b/cardinal/src/components/__tests__/PreferencesOverlay.test.tsx
index aa543e2f..2c65f4be 100644
--- a/cardinal/src/components/__tests__/PreferencesOverlay.test.tsx
+++ b/cardinal/src/components/__tests__/PreferencesOverlay.test.tsx
@@ -156,4 +156,19 @@ describe('PreferencesOverlay', () => {
     expect(onSortThresholdChange).not.toHaveBeenCalled();
     expect(onWatchConfigChange).not.toHaveBeenCalled();
   });
+
+  it('hides ignore path syntax help until the info button is clicked', () => {
+    render(<PreferencesOverlay {...baseProps} onWatchConfigChange={vi.fn()} />);
+
+    expect(screen.queryByText('ignorePaths.helpIntro')).not.toBeInTheDocument();
+
+    fireEvent.click(screen.getByRole('button', { name: 'ignorePaths.showInfo' }));
+
+    expect(screen.getByText('ignorePaths.helpIntro')).toBeInTheDocument();
+    expect(screen.getByText('ignorePaths.helpComment')).toBeInTheDocument();
+    expect(screen.getByText('ignorePaths.helpSingleStar')).toBeInTheDocument();
+    expect(screen.getByText('ignorePaths.helpDoubleStar')).toBeInTheDocument();
+    expect(screen.getByText('ignorePaths.helpAnchoring')).toBeInTheDocument();
+    expect(screen.getByText('ignorePaths.helpNegation')).toBeInTheDocument();
+  });
 });
diff --git a/cardinal/src/i18n/resources/en-US.json b/cardinal/src/i18n/resources/en-US.json
index cb39e6d4..5a1a6e7b 100644
--- a/cardinal/src/i18n/resources/en-US.json
+++ b/cardinal/src/i18n/resources/en-US.json
@@ -163,7 +163,15 @@
   },
   "ignorePaths": {
     "label": "Ignore paths",
-    "help": "One .gitignore-style pattern per line. Blank lines and lines starting with '#' are allowed."
+    "showInfo": "Show info",
+    "hideInfo": "Hide info",
+    "infoTitle": "Ignore path syntax help",
+    "helpIntro": "One .gitignore-style pattern per line.",
+    "helpComment": "Use '#' for a single-line comment, or place '/*' and '*/' on their own lines to comment out a block while testing patterns.",
+    "helpSingleStar": "Use '*' inside one path segment to match characters except '/': '*.log' matches log files in the current folder.",
+    "helpDoubleStar": "Use '**' to match across directories: '**/node_modules/' matches that folder anywhere below the monitored root.",
+    "helpAnchoring": "Use a leading '/' to anchor a pattern to the monitored root. Without it, the pattern can match anywhere.",
+    "helpNegation": "Use '!' to re-include a path after a broader ignore rule when needed."
   },
   "exportListedFiles": {
     "failed": "Failed to export current files list. Please try again."

From dc3f8e30749d40bb9027876e838f6147da211885 Mon Sep 17 00:00:00 2001
From: Mohamad Yahia <xyzt70@gmail.com>
Date: Fri, 6 Mar 2026 08:25:06 +0400
Subject: [PATCH 13/16] feat: Added instructions for ignore patterns setting

---
 cardinal/src-tauri/src/commands.rs             | 8 +++-----
 cardinal/src/App.css                           | 3 +--
 cardinal/src/components/PreferencesOverlay.tsx | 1 -
 cardinal/src/hooks/useIgnorePaths.ts           | 2 +-
 cardinal/src/i18n/resources/en-US.json         | 7 +++----
 5 files changed, 8 insertions(+), 13 deletions(-)

diff --git a/cardinal/src-tauri/src/commands.rs b/cardinal/src-tauri/src/commands.rs
index 824df89f..1e383a8d 100644
--- a/cardinal/src-tauri/src/commands.rs
+++ b/cardinal/src-tauri/src/commands.rs
@@ -864,11 +864,9 @@ mod tests {
 
     #[test]
     fn normalize_watch_config_rewrites_watch_root_self_ignore_to_root_contents() {
-        let Some((watch_root, ignore_paths)) = normalize_watch_config(
-            "/Users/me",
-            vec!["/Users/me/".to_string()],
-            None,
-        ) else {
+        let Some((watch_root, ignore_paths)) =
+            normalize_watch_config("/Users/me", vec!["/Users/me/".to_string()], None)
+        else {
             panic!("watch config should be valid");
         };
 
diff --git a/cardinal/src/App.css b/cardinal/src/App.css
index 9a28ce57..0b83fa6b 100644
--- a/cardinal/src/App.css
+++ b/cardinal/src/App.css
@@ -1767,11 +1767,10 @@ button:active:not(:disabled) {
 }
 
 .preferences-ignore-reset {
-  margin-left: 8px;
   border: 1px solid var(--color-elevated-border, var(--color-border));
   background: transparent;
   color: var(--color-text-secondary);
-  border-radius: 8px;
+  border-radius: 999px;
   padding: 4px 6px;
   font-size: 0.82rem;
   cursor: pointer;
diff --git a/cardinal/src/components/PreferencesOverlay.tsx b/cardinal/src/components/PreferencesOverlay.tsx
index 6007b988..c7f91080 100644
--- a/cardinal/src/components/PreferencesOverlay.tsx
+++ b/cardinal/src/components/PreferencesOverlay.tsx
@@ -272,7 +272,6 @@ export function PreferencesOverlay({
                     <li className="preferences-help-text">{t('ignorePaths.helpSingleStar')}</li>
                     <li className="preferences-help-text">{t('ignorePaths.helpDoubleStar')}</li>
                     <li className="preferences-help-text">{t('ignorePaths.helpAnchoring')}</li>
-                    <li className="preferences-help-text">{t('ignorePaths.helpNegation')}</li>
                   </ul>
                 </div>
               ) : null}
diff --git a/cardinal/src/hooks/useIgnorePaths.ts b/cardinal/src/hooks/useIgnorePaths.ts
index 0570a50e..5b367fa9 100644
--- a/cardinal/src/hooks/useIgnorePaths.ts
+++ b/cardinal/src/hooks/useIgnorePaths.ts
@@ -67,7 +67,7 @@ const DEFAULT_IGNORE_PATHS = [
   '**/Firefox/Profiles/**/sessionstore-backups/',
   '**/Firefox/Profiles/**/storage/default/',
   '**/Firefox/Profiles/**/storage/permanent/',
-  '**/Spotify/Users/*/pending-messages*',
+  '**/Spotify/Users/',
   '**/*.com.google.Chrome',
   '**/webappsstore.sqlite-wal',
   '',
diff --git a/cardinal/src/i18n/resources/en-US.json b/cardinal/src/i18n/resources/en-US.json
index 5a1a6e7b..51384a45 100644
--- a/cardinal/src/i18n/resources/en-US.json
+++ b/cardinal/src/i18n/resources/en-US.json
@@ -168,10 +168,9 @@
     "infoTitle": "Ignore path syntax help",
     "helpIntro": "One .gitignore-style pattern per line.",
     "helpComment": "Use '#' for a single-line comment, or place '/*' and '*/' on their own lines to comment out a block while testing patterns.",
-    "helpSingleStar": "Use '*' inside one path segment to match characters except '/': '*.log' matches log files in the current folder.",
-    "helpDoubleStar": "Use '**' to match across directories: '**/node_modules/' matches that folder anywhere below the monitored root.",
-    "helpAnchoring": "Use a leading '/' to anchor a pattern to the monitored root. Without it, the pattern can match anywhere.",
-    "helpNegation": "Use '!' to re-include a path after a broader ignore rule when needed."
+    "helpSingleStar": "Use '*' inside one path segment to match characters except '/': '*.log' matches log files in the current folder. [good performance]",
+    "helpDoubleStar": "Use '**' to match across directories: '**/node_modules/' matches that folder anywhere below the monitored root. [broader match]",
+    "helpAnchoring": "Use a leading '/' to anchor a pattern to the monitored root. Without it, the pattern can match anywhere. [best performance]"
   },
   "exportListedFiles": {
     "failed": "Failed to export current files list. Please try again."

From e6995b7aa19af0dbe01aadae2402799e533f3ed4 Mon Sep 17 00:00:00 2001
From: Mohamad Yahia <xyzt70@gmail.com>
Date: Fri, 6 Mar 2026 08:40:22 +0400
Subject: [PATCH 14/16] feat: fixed font sizes and allowed zooming

---
 cardinal/src-tauri/capabilities/default.json                  | 1 +
 cardinal/src-tauri/tauri.conf.json                            | 3 ++-
 cardinal/src/App.css                                          | 4 ++--
 cardinal/src/components/__tests__/PreferencesOverlay.test.tsx | 2 +-
 4 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/cardinal/src-tauri/capabilities/default.json b/cardinal/src-tauri/capabilities/default.json
index ce8f857a..948467f8 100644
--- a/cardinal/src-tauri/capabilities/default.json
+++ b/cardinal/src-tauri/capabilities/default.json
@@ -7,6 +7,7 @@
     "core:default",
     "core:app:allow-default-window-icon",
     "core:window:allow-set-focus",
+    "core:webview:allow-set-webview-zoom",
     "opener:default",
     "macos-permissions:default",
     "drag:default",
diff --git a/cardinal/src-tauri/tauri.conf.json b/cardinal/src-tauri/tauri.conf.json
index b3f61591..d4bd52d5 100644
--- a/cardinal/src-tauri/tauri.conf.json
+++ b/cardinal/src-tauri/tauri.conf.json
@@ -14,7 +14,8 @@
       {
         "title": "Cardinal",
         "width": 1200,
-        "height": 800
+        "height": 800,
+        "zoomHotkeysEnabled": true
       }
     ],
     "security": {
diff --git a/cardinal/src/App.css b/cardinal/src/App.css
index 0b83fa6b..1aa6070a 100644
--- a/cardinal/src/App.css
+++ b/cardinal/src/App.css
@@ -1673,7 +1673,7 @@ button:active:not(:disabled) {
   margin-top: 4px;
   width: 100%;
   color: var(--color-text-secondary);
-  font-size: 0.8rem;
+  font-size: 1rem;
   line-height: 1.35;
   white-space: normal;
 }
@@ -1757,7 +1757,7 @@ button:active:not(:disabled) {
   width: 100%;
   min-height: 230px;
   padding: 8px 10px;
-  font-size: 0.9rem;
+  font-size: 1rem;
   line-height: 1.4;
   resize: vertical;
 }
diff --git a/cardinal/src/components/__tests__/PreferencesOverlay.test.tsx b/cardinal/src/components/__tests__/PreferencesOverlay.test.tsx
index 2c65f4be..338c089e 100644
--- a/cardinal/src/components/__tests__/PreferencesOverlay.test.tsx
+++ b/cardinal/src/components/__tests__/PreferencesOverlay.test.tsx
@@ -164,11 +164,11 @@ describe('PreferencesOverlay', () => {
 
     fireEvent.click(screen.getByRole('button', { name: 'ignorePaths.showInfo' }));
 
+    expect(screen.getByRole('button', { name: 'ignorePaths.hideInfo' })).toBeInTheDocument();
     expect(screen.getByText('ignorePaths.helpIntro')).toBeInTheDocument();
     expect(screen.getByText('ignorePaths.helpComment')).toBeInTheDocument();
     expect(screen.getByText('ignorePaths.helpSingleStar')).toBeInTheDocument();
     expect(screen.getByText('ignorePaths.helpDoubleStar')).toBeInTheDocument();
     expect(screen.getByText('ignorePaths.helpAnchoring')).toBeInTheDocument();
-    expect(screen.getByText('ignorePaths.helpNegation')).toBeInTheDocument();
   });
 });

From 781edb8118cbef0b45fa007ff63cd6e9379aaa30 Mon Sep 17 00:00:00 2001
From: Mohamad Yahia <xyzt70@gmail.com>
Date: Thu, 19 Mar 2026 06:47:32 +0400
Subject: [PATCH 15/16] fix(events): use ignore matcher for runtime feed

---
 cardinal-sdk/src/event.rs            |  2 +-
 cardinal-sdk/src/event_stream.rs     |  4 +-
 cardinal/src-tauri/src/background.rs |  8 ++--
 search-cache/src/cache.rs            | 65 ++++++++++++++++++++++++++++
 4 files changed, 74 insertions(+), 5 deletions(-)

diff --git a/cardinal-sdk/src/event.rs b/cardinal-sdk/src/event.rs
index e17f5a6f..df68e1f5 100644
--- a/cardinal-sdk/src/event.rs
+++ b/cardinal-sdk/src/event.rs
@@ -5,7 +5,7 @@ use std::{
     path::{Path, PathBuf},
 };
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct FsEvent {
     /// The path of this event.
     pub path: PathBuf,
diff --git a/cardinal-sdk/src/event_stream.rs b/cardinal-sdk/src/event_stream.rs
index 1c8905fd..c5f4f5aa 100644
--- a/cardinal-sdk/src/event_stream.rs
+++ b/cardinal-sdk/src/event_stream.rs
@@ -176,7 +176,9 @@ impl EventWatcher {
             since_event_id,
             latency,
             Box::new(move |events| {
-                let _ = sender.send(events);
+                if !events.is_empty() {
+                    let _ = sender.send(events);
+                }
             }),
         );
         let dev = stream.dev();
diff --git a/cardinal/src-tauri/src/background.rs b/cardinal/src-tauri/src/background.rs
index d8d90031..ec7d2a09 100644
--- a/cardinal/src-tauri/src/background.rs
+++ b/cardinal/src-tauri/src/background.rs
@@ -208,7 +208,9 @@ fn handle_event_watcher_events(
     history_ready: &mut bool,
     processed_events: &mut usize,
 ) {
-    *processed_events += events.len();
+    let visible_events = cache.filter_runtime_events(&events);
+
+    *processed_events += visible_events.len();
 
     emit_status_bar_update(
         app_handle,
@@ -217,8 +219,8 @@ fn handle_event_watcher_events(
         cache.rescan_count() as usize,
     );
 
-    let mut snapshots = Vec::with_capacity(events.len());
-    for event in events.iter() {
+    let mut snapshots = Vec::with_capacity(visible_events.len());
+    for event in visible_events.iter() {
         if event.flag == EventFlag::HistoryDone {
             *history_ready = true;
             update_app_state(app_handle, AppLifecycleState::Ready);
diff --git a/search-cache/src/cache.rs b/search-cache/src/cache.rs
index aa46fea7..f98da7b8 100644
--- a/search-cache/src/cache.rs
+++ b/search-cache/src/cache.rs
@@ -65,6 +65,22 @@ impl SearchCache {
         self.file_nodes.ignore_paths()
     }
 
+    pub fn filter_runtime_events(&self, events: &[FsEvent]) -> Vec<FsEvent> {
+        events
+            .iter()
+            .filter(|event| self.should_forward_runtime_event(event))
+            .cloned()
+            .collect()
+    }
+
+    fn should_forward_runtime_event(&self, event: &FsEvent) -> bool {
+        match event.flag.scan_type() {
+            ScanType::Nop | ScanType::ReScan => true,
+            ScanType::Folder => !self.ignore_matcher.is_ignored(&event.path, true),
+            ScanType::SingleNode => !self.ignore_matcher.is_ignored(&event.path, false),
+        }
+    }
+
     /// The `path` is the root path of the constructed cache and fsevent watch path.
     pub fn try_read_persistent_cache(
         path: &Path,
@@ -3008,6 +3024,55 @@ mod tests {
         assert_eq!(out, vec![PathBuf::from("/t/a")]);
     }
 
+    #[test]
+    fn test_filter_runtime_events_uses_ignore_matcher_semantics() {
+        let temp_dir = TempDir::new("runtime_event_filter").unwrap();
+        let root = temp_dir.path().canonicalize().unwrap();
+        fs::create_dir_all(root.join("node_modules/pkg")).unwrap();
+
+        let ignore_paths = vec![
+            PathBuf::from(""),
+            PathBuf::from("# section"),
+            PathBuf::from("**/node_modules/**"),
+        ];
+        let cache = SearchCache::walk_fs_with_ignore(&root, &ignore_paths);
+
+        let visible_path = root.join("src/main.rs");
+        let ignored_path = root.join("node_modules/pkg/index.js");
+        let filtered = cache.filter_runtime_events(&[
+            FsEvent {
+                path: visible_path.clone(),
+                id: 1,
+                flag: EventFlag::ItemCreated | EventFlag::ItemIsFile,
+            },
+            FsEvent {
+                path: ignored_path.clone(),
+                id: 2,
+                flag: EventFlag::ItemCreated | EventFlag::ItemIsFile,
+            },
+            FsEvent {
+                path: root.clone(),
+                id: 3,
+                flag: EventFlag::HistoryDone,
+            },
+        ]);
+
+        assert!(
+            filtered.iter().any(|event| event.path == visible_path),
+            "blank/comment ignore entries must not drop visible events"
+        );
+        assert!(
+            filtered.iter().all(|event| event.path != ignored_path),
+            "glob ignore entries should still suppress ignored subtrees"
+        );
+        assert!(
+            filtered
+                .iter()
+                .any(|event| event.flag.contains(EventFlag::HistoryDone)),
+            "control events should still be forwarded"
+        );
+    }
+
     #[test]
     fn test_scan_paths_siblings_all_retained() {
         let events = vec![

From 39c32a29fe77d6cbeceb08096dd3bdc2dbdf824f Mon Sep 17 00:00:00 2001
From: Mohamad Yahia <xyzt70@gmail.com>
Date: Sun, 22 Mar 2026 08:57:47 +0400
Subject: [PATCH 16/16] feat: update default ignore paths to include additional
 system and application directories to reduce spam in events

---
 cardinal/src/hooks/__tests__/useIgnorePaths.test.ts | 10 ++++++++--
 cardinal/src/hooks/useIgnorePaths.ts                | 10 ++++++++--
 2 files changed, 16 insertions(+), 4 deletions(-)

diff --git a/cardinal/src/hooks/__tests__/useIgnorePaths.test.ts b/cardinal/src/hooks/__tests__/useIgnorePaths.test.ts
index 1905add6..60f2bb5c 100644
--- a/cardinal/src/hooks/__tests__/useIgnorePaths.test.ts
+++ b/cardinal/src/hooks/__tests__/useIgnorePaths.test.ts
@@ -67,6 +67,13 @@ describe('useIgnorePaths', () => {
     expect(defaults).toContain('**/Library/Application Support/*/Cache/');
     expect(defaults).toContain('~/Library/Application Support/Cursor/User/History/');
     expect(defaults).toContain('~/Library/Application Support/Code*/User/History/');
+    expect(defaults).toContain('~/.claude/plugins/cache/');
+    expect(defaults).toContain('**/Library/Logs/DiagnosticReports/');
+    expect(defaults).toContain('**/Library/Application Support/CrashReporter/');
+    expect(defaults).toContain('**/Library/Application Support/Code/User/globalStorage/');
+    expect(defaults).toContain('**/Library/Application Support/Google/Chrome*/');
+    expect(defaults).toContain('**/Library/Application Support/Google/GoogleUpdater/');
+    expect(defaults).toContain('**/Library/Preferences/');
     expect(defaults).toContain('~/Library/pnpm/store');
     expect(defaults).toContain('**/Library/pnpm/store/');
     expect(defaults).toContain('**/target/');
@@ -74,6 +81,7 @@ describe('useIgnorePaths', () => {
     expect(defaults).toContain('**/Service Worker/CacheStorage/');
     expect(defaults).toContain('**/IndexedDB/');
     expect(defaults).toContain('**/WebStorage/');
+    expect(defaults).toContain('**/Library/WebKit/**/WebsiteDataStore/');
     expect(defaults).toContain('**/.next/');
     expect(defaults).toContain('**/.git/');
     expect(defaults).toContain('**/.gitignore');
@@ -90,9 +98,7 @@ describe('useIgnorePaths', () => {
     expect(defaults).toContain('~/.rustup/toolchains/');
     expect(defaults).toContain('~/.cursor/extensions/');
     expect(defaults).toContain('~/.nuget/packages/');
-    expect(defaults).toContain('**/Google/Chrome*/**/GPUCache/');
     expect(defaults).toContain('**/Vivaldi*/**/GPUCache/');
-    expect(defaults).toContain('**/Google/Chrome*/**/Local Storage/leveldb/');
     expect(defaults).toContain('**/Vivaldi*/**/Local Storage/leveldb/');
     expect(defaults).toContain('/System/Volumes/');
     expect(defaults).toContain('/System/iOSSupport/System/Library/');
diff --git a/cardinal/src/hooks/useIgnorePaths.ts b/cardinal/src/hooks/useIgnorePaths.ts
index 5b367fa9..653aa01a 100644
--- a/cardinal/src/hooks/useIgnorePaths.ts
+++ b/cardinal/src/hooks/useIgnorePaths.ts
@@ -50,16 +50,22 @@ const DEFAULT_IGNORE_PATHS = [
   '**/Service Worker/CacheStorage/',
   '**/IndexedDB/',
   '**/WebStorage/',
+  '**/Library/WebKit/**/WebsiteDataStore/',
   '~/Library/Application Support/Cursor/User/History/',
   '~/Library/Application Support/Code*/User/History/',
+  '~/.claude/plugins/cache/',
+  '**/Library/Logs/DiagnosticReports/',
+  '**/Library/Application Support/CrashReporter/',
+  '**/Library/Application Support/Code/User/globalStorage/',
+  '**/Library/Application Support/Google/Chrome*/',
+  '**/Library/Application Support/Google/GoogleUpdater/',
+  '**/Library/Preferences/',
   '**/Chromium/**/GPUCache/',
-  '**/Google/Chrome*/**/GPUCache/',
   '**/BraveSoftware/Brave-Browser*/**/GPUCache/',
   '**/Microsoft Edge*/**/GPUCache/',
   '**/Arc/**/GPUCache/',
   '**/Vivaldi*/**/GPUCache/',
   '**/Chromium/**/Local Storage/leveldb/',
-  '**/Google/Chrome*/**/Local Storage/leveldb/',
   '**/BraveSoftware/Brave-Browser*/**/Local Storage/leveldb/',
   '**/Microsoft Edge*/**/Local Storage/leveldb/',
   '**/Arc/**/Local Storage/leveldb/',