fix(native): skip unsupported-extension files in detect_removed_files (#1070)

The Rust file_collector only collects files whose extension is recognized
by `LanguageKind::from_extension` or listed in `SUPPORTED_EXTENSIONS`.
The JS LANGUAGE_REGISTRY is broader — Clojure, Gleam, Julia, F# files
exist in `file_hashes` because the JS-side WASM backfill writes them
(#1068), but Rust's narrower collector never sees them.

Before this fix, `detect_removed_files` flagged every such file as
"removed" on every incremental rebuild because they were absent from
`current` (the just-collected file list). The orchestrator's purge step
then deleted their `nodes` and `file_hashes` rows, and the JS-side
`backfillNativeDroppedFiles` (now running on every pass per #1069)
re-parsed them with WASM and re-inserted the rows — the ~2s 1-file
rebuild floor reported in #1066.

Add `is_supported_extension` to `file_collector` (exposing the same
predicate used by `collect_files`) and apply it as a pre-filter in
`detect_removed_files`. Files outside Rust's capability are now left
alone: their absence from `current` is a capability boundary, not a
deletion. Rows owned by the JS layer persist across incremental
rebuilds and the backfill's missing-file early-return at
`pipeline.ts:811` finally fires.

Refs #1066

Impact: 3 functions changed, 4 affected

Author: carlos-alm

crates/codegraph-core/src/change_detection.rs

@@ -10,6 +10,7 @@
 //! when switching between JS and native engines, so hash format compatibility is
 //! not required.
 
+use crate::file_collector::is_supported_extension;
 use crate::journal;
 use rusqlite::Connection;
 use sha2::{Digest, Sha256};
@@ -129,6 +130,14 @@ fn load_file_hashes(conn: &Connection) -> Option<HashMap<String, FileHashRow>> {
 /// When `scoped_rel_paths` is provided (scoped rebuild), only files within that
 /// scope are considered candidates for removal. Without it, all DB files not
 /// found on disk are treated as removed.
+///
+/// Files whose extension is outside the Rust file_collector's supported set
+/// (e.g. `.clj`, `.gleam`, `.jl`, `.fs` — WASM-only languages) are skipped:
+/// the orchestrator's narrower collector never sees them, so absence from
+/// `current` is a capability boundary, not a deletion. Their `nodes` and
+/// `file_hashes` rows are owned by the JS-side WASM backfill (#967, #1068)
+/// and must be left alone, otherwise every incremental rebuild purges and
+/// re-creates them — the ~2s floor reported in #1066.
 fn detect_removed_files(
     existing: &HashMap<String, FileHashRow>,
     all_files: &[String],
@@ -143,6 +152,9 @@ fn detect_removed_files(
     existing
         .keys()
         .filter(|f| {
+            if !is_supported_extension(f) {
+                return false;
+            }
             // When scope is set, only consider files within scope as candidates.
             if let Some(scope) = scoped_rel_paths {
                 scope.contains(*f) && !current.contains(*f)
@@ -759,4 +771,45 @@ mod tests {
         let removed = detect_removed_files(&existing, &all_files, "/project", None);
         assert_eq!(removed, vec!["src/b.ts"]);
     }
+
+    #[test]
+    fn detect_removed_skips_unsupported_extensions() {
+        // Files in WASM-only languages (Clojure, Gleam, Julia, F#) live in
+        // `file_hashes` because the JS-side WASM backfill writes them, but
+        // Rust's narrower file_collector never collects them. Without this
+        // skip, every incremental rebuild would flag them as removed and
+        // purge their rows — the #1066 ~2s floor.
+        let mut existing = HashMap::new();
+        for path in [
+            "tests/fixtures/clojure/main.clj",
+            "tests/fixtures/gleam/main.gleam",
+            "tests/fixtures/julia/main.jl",
+            "tests/fixtures/fsharp/Main.fs",
+        ] {
+            existing.insert(
+                path.to_string(),
+                FileHashRow {
+                    file: path.to_string(),
+                    hash: "h".to_string(),
+                    mtime: 0,
+                    size: 0,
+                },
+            );
+        }
+        // Also include a supported file that IS missing from disk — should
+        // still be flagged as removed.
+        existing.insert(
+            "src/deleted.ts".to_string(),
+            FileHashRow {
+                file: "src/deleted.ts".to_string(),
+                hash: "h".to_string(),
+                mtime: 0,
+                size: 0,
+            },
+        );
+
+        let all_files: Vec<String> = Vec::new();
+        let removed = detect_removed_files(&existing, &all_files, "/project", None);
+        assert_eq!(removed, vec!["src/deleted.ts"]);
+    }
 }

crates/codegraph-core/src/file_collector.rs

@@ -38,6 +38,25 @@ const SUPPORTED_EXTENSIONS: &[&str] = &[
     "kts", "swift", "scala", "sh", "bash", "ex", "exs", "lua", "dart", "zig", "hs", "ml", "mli",
 ];
 
+/// Returns whether `path` has an extension the Rust file_collector would accept.
+///
+/// Mirrors the predicate at the heart of `collect_files`: a file is collected
+/// if `LanguageKind::from_extension` recognizes it OR its raw extension is in
+/// `SUPPORTED_EXTENSIONS`. Exposed for `change_detection::detect_removed_files`
+/// so that files outside Rust's capability (e.g. WASM-only `.clj`, `.gleam`,
+/// `.jl`) are not flagged as "removed" merely because the orchestrator's
+/// narrower collector never sees them.
+pub fn is_supported_extension(path: &str) -> bool {
+    if LanguageKind::from_extension(path).is_some() {
+        return true;
+    }
+    let ext = Path::new(path)
+        .extension()
+        .and_then(|e| e.to_str())
+        .unwrap_or("");
+    SUPPORTED_EXTENSIONS.contains(&ext)
+}
+
 /// Result of file collection.
 pub struct CollectResult {
     /// Absolute paths of all collected source files.