@wrongstack/tools 0.293.0 → 0.295.0

package/dist/codebase-index/index.js

@@ -1,5 +1,5 @@
 // src/codebase-index/writer.ts
-import { expectDefined } from "@wrongstack/core";
+import { expectDefined } from "@wrongstack/core/utils";
 
 // src/codebase-index/circuit-breaker.ts
 var CircuitOpenError = class extends Error {
@@ -89,7 +89,7 @@ import { toErrorMessage } from "@wrongstack/core/utils";
 import { createRequire } from "node:module";
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { resolveWstackPaths } from "@wrongstack/core";
+import { resolveWstackPaths, sqliteCachePragmas } from "@wrongstack/core/utils";
 
 // src/codebase-index/schema.ts
 var SCHEMA_VERSION = 3;
@@ -174,23 +174,13 @@ function buildBm25Index(docs) {
     const tokens = tokenise(d.text);
     return { id: d.id, tokens, raw: d.text, len: tokens.length };
   });
-  const df = {};
-  for (const doc of documents) {
-    const seen = /* @__PURE__ */ new Set();
-    for (const t of doc.tokens) {
-      if (!seen.has(t)) {
-        df[t] = (df[t] ?? 0) + 1;
-        seen.add(t);
-      }
-    }
-  }
   const N = documents.length;
   const totalLen = documents.reduce((sum, d) => sum + d.len, 0);
   const avgLen = N === 0 ? 0 : totalLen / N;
-  return new Bm25Index(documents, df, N, avgLen);
+  return new Bm25Index(documents, N, avgLen);
 }
 var Bm25Index = class {
-  constructor(documents, _df, N, avgLen) {
+  constructor(documents, N, avgLen) {
     this.documents = documents;
     this.N = N;
     this.safeAvgLen = avgLen === 0 ? 1 : avgLen;
@@ -198,9 +188,19 @@ var Bm25Index = class {
   documents;
   N;
   safeAvgLen;
+  /** Lazily-built id→doc index so getDoc is O(1) instead of an O(D) linear find. */
+  _byId;
   score(query, filter) {
     const qTokens = tokenise(query);
     if (qTokens.length === 0) return [];
+    const dfByTerm = /* @__PURE__ */ new Map();
+    for (const qTerm of qTokens) {
+      let dfVal = 0;
+      for (const candidate of this.documents) {
+        if (candidate.tokens.some((t) => t.startsWith(qTerm))) dfVal++;
+      }
+      dfByTerm.set(qTerm, dfVal);
+    }
     const results = [];
     for (const doc of this.documents) {
       if (filter && !filter(doc.id)) continue;
@@ -211,10 +211,7 @@ var Bm25Index = class {
           if (t.startsWith(qTerm)) tf++;
         }
         if (tf === 0) continue;
-        let dfVal = 0;
-        for (const candidate of this.documents) {
-          if (candidate.tokens.some((t) => t.startsWith(qTerm))) dfVal++;
-        }
+        const dfVal = dfByTerm.get(qTerm) ?? 0;
         if (dfVal === 0) continue;
         const idf = Math.log((this.N - dfVal + 0.5) / (dfVal + 0.5) + 1);
         const lenRatio = B * (doc.len / this.safeAvgLen);
@@ -226,7 +223,10 @@ var Bm25Index = class {
     return results;
   }
   getDoc(id) {
-    return this.documents.find((d) => d.id === id);
+    if (!this._byId) {
+      this._byId = new Map(this.documents.map((d) => [d.id, d]));
+    }
+    return this._byId.get(id);
   }
   extractSnippet(docId, queryTokens, radius = 40) {
     const doc = this.getDoc(docId);
@@ -388,6 +388,25 @@ var IndexStore = class _IndexStore {
    * and reuse it. Cleared in {@link close} when the connection is torn down.
    */
   stmtCache = /* @__PURE__ */ new Map();
+  /**
+   * Cached full-corpus BM25 index for the FTS5-unavailable fallback path.
+   * Built lazily on the first `searchRankedFallback` call and invalidated
+   * (via `bm25Dirty`) whenever the `symbols` table is mutated. Computing
+   * IDF over the full corpus is also more correct than the old per-query
+   * candidate-subset IDF.
+   *
+   * Cache-lifecycle invariants (single source of truth lives at the
+   * `invalidateBm25()` helper — see its docblock for the "every mutation
+   * MUST call this" contract):
+   *   - declaration: this field + `bm25Dirty` (here)
+   *   - invalidation: `invalidateBm25()` flips the flag and nulls the cache
+   *   - build: `getOrBuildBm25()` rebuilds against current `symbols` rows
+   *   - teardown: `close()` resets the flag and nulls the cache
+   */
+  bm25Cache = null;
+  // Dirty on open so the first getOrBuildBm25() rebuilds against current rows;
+  // an empty or pre-existing corpus makes a stale IDF table meaningless.
+  bm25Dirty = true;
   /** Prepare-once helper: compile `sql` on first use, reuse thereafter. */
   stmt(sql) {
     let s = this.stmtCache.get(sql);
@@ -435,7 +454,15 @@ var IndexStore = class _IndexStore {
     this.db = new Database(path.join(this.indexDir, DB_FILE));
     try {
       this.db.exec("PRAGMA journal_mode = WAL");
-      this.db.exec("PRAGMA busy_timeout = 5000");
+      this.db.exec("PRAGMA synchronous = NORMAL");
+      this.db.exec("PRAGMA busy_timeout = 15000");
+      this.db.exec("PRAGMA temp_store = MEMORY");
+      const cache = sqliteCachePragmas();
+      this.db.exec(`PRAGMA cache_size = -${cache.cacheSizeKiB}`);
+      this.db.exec(`PRAGMA mmap_size = ${cache.mmapBytes}`);
+      this.db.exec("PRAGMA foreign_keys = ON");
+      this.db.exec("PRAGMA journal_size_limit = 67108864");
+      this.db.exec("PRAGMA wal_autocheckpoint = 1000");
     } catch {
     }
     this.initSchema();
@@ -447,7 +474,7 @@ var IndexStore = class _IndexStore {
         value TEXT NOT NULL
       );
     `);
-    const storedRows = this.db.prepare("SELECT value FROM metadata WHERE key = ?").all("version");
+    const storedRows = this.stmt("SELECT value FROM metadata WHERE key = ?").all("version");
     const storedVersion = storedRows.length ? Number(storedRows[0]?.value) : null;
     if (storedVersion !== null && storedVersion !== SCHEMA_VERSION) {
       this.db.exec(`
@@ -456,9 +483,9 @@ var IndexStore = class _IndexStore {
         DROP TABLE IF EXISTS refs;
       `);
       this.db.exec("DROP TABLE IF EXISTS symbols_fts");
-      this.db.prepare("UPDATE metadata SET value = ? WHERE key = ?").run(String(SCHEMA_VERSION), "version");
+      this.stmt("UPDATE metadata SET value = ? WHERE key = ?").run(String(SCHEMA_VERSION), "version");
     } else if (storedVersion === null) {
-      this.db.prepare("INSERT INTO metadata(key, value) VALUES (?, ?)").run("version", String(SCHEMA_VERSION));
+      this.stmt("INSERT INTO metadata(key, value) VALUES (?, ?)").run("version", String(SCHEMA_VERSION));
     }
     this.db.exec(`
       CREATE TABLE IF NOT EXISTS files (
@@ -489,6 +516,7 @@ var IndexStore = class _IndexStore {
     this.db.exec("CREATE INDEX IF NOT EXISTS idx_s_file ON symbols(file)");
     this.db.exec("CREATE INDEX IF NOT EXISTS idx_s_lang_kind ON symbols(lang, kind)");
     this.db.exec("CREATE INDEX IF NOT EXISTS idx_s_file_fk ON symbols(file_fk)");
+    this.db.exec("CREATE INDEX IF NOT EXISTS idx_s_name_id ON symbols(name, id)");
     this.db.exec(`
       CREATE TABLE IF NOT EXISTS refs (
         id INTEGER PRIMARY KEY,
@@ -509,65 +537,167 @@ var IndexStore = class _IndexStore {
       );
       this.ftsAvailable = true;
       const symbolCount = Number(
-        this.db.prepare("SELECT COUNT(*) AS n FROM symbols").get()?.n ?? 0
+        this.stmt("SELECT COUNT(*) AS n FROM symbols").get()?.n ?? 0
       );
       const ftsCount = Number(
-        this.db.prepare("SELECT COUNT(*) AS n FROM symbols_fts").get()?.n ?? 0
+        this.stmt("SELECT COUNT(*) AS n FROM symbols_fts").get()?.n ?? 0
       );
       if (symbolCount !== ftsCount) {
         this.db.exec("DELETE FROM symbols_fts");
-        const insert = this.db.prepare("INSERT INTO symbols_fts(rowid, text) VALUES (?, ?)");
-        const rows = this.db.prepare("SELECT id, name, signature, doc_comment FROM symbols ORDER BY id").all();
-        for (const row of rows) {
-          insert.run(row.id, buildIndexableText(row.name, row.signature, row.doc_comment));
-        }
+        const rows = this.stmt("SELECT id, name, signature, doc_comment FROM symbols ORDER BY id").all();
+        this.bulkInsertFts(
+          rows.map((row) => ({
+            id: row.id,
+            text: buildIndexableText(row.name, row.signature, row.doc_comment)
+          }))
+        );
+        this.invalidateBm25();
       }
     } catch {
       this.ftsAvailable = false;
     }
+    this.ensureNextSymbolIdSeeded();
+  }
+  // ─── ID allocation & bulk helpers ────────────────────────────────────────────
+  static NEXT_SYMBOL_ID_KEY = "next_symbol_id";
+  /** Stay under typical SQLite SQLITE_MAX_VARIABLE_NUMBER (often 999). */
+  static MAX_SQL_VARS = 900;
+  /**
+   * Ensure `metadata.next_symbol_id` exists. Safe to call outside a write
+   * transaction on open; the first concurrent writer under BEGIN IMMEDIATE
+   * re-reads and advances the counter atomically.
+   */
+  ensureNextSymbolIdSeeded() {
+    const existing = this.stmt("SELECT value FROM metadata WHERE key = ?").get(
+      _IndexStore.NEXT_SYMBOL_ID_KEY
+    );
+    if (existing?.value !== void 0) return;
+    const maxRows = this.stmt("SELECT MAX(id) AS m FROM symbols").all();
+    const next = (maxRows[0]?.m ?? 0) + 1;
+    this.stmt("INSERT OR REPLACE INTO metadata(key, value) VALUES (?, ?)").run(
+      _IndexStore.NEXT_SYMBOL_ID_KEY,
+      String(next)
+    );
+  }
+  /**
+   * Reserve `count` consecutive symbol ids. MUST run inside BEGIN IMMEDIATE
+   * so concurrent indexers cannot hand out overlapping ranges.
+   */
+  allocateSymbolIds(count) {
+    if (count <= 0) return this.getMaxSymbolId() + 1;
+    this.ensureNextSymbolIdSeeded();
+    const row = this.stmt("SELECT value FROM metadata WHERE key = ?").get(
+      _IndexStore.NEXT_SYMBOL_ID_KEY
+    );
+    const start = Math.max(1, Number(row?.value ?? 1) || 1);
+    this.stmt("INSERT OR REPLACE INTO metadata(key, value) VALUES (?, ?)").run(
+      _IndexStore.NEXT_SYMBOL_ID_KEY,
+      String(start + count)
+    );
+    return start;
+  }
+  /** Multi-row INSERT for symbols — amortizes prepare/bind overhead in large batches. */
+  bulkInsertSymbols(rows) {
+    if (rows.length === 0) return;
+    const cols = 12;
+    const chunkSize = Math.max(1, Math.floor(_IndexStore.MAX_SQL_VARS / cols));
+    for (let i = 0; i < rows.length; i += chunkSize) {
+      const chunk = rows.slice(i, i + chunkSize);
+      const placeholders = chunk.map(() => "(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)").join(", ");
+      const stmt = this.stmt(
+        `INSERT INTO symbols(id, lang, kind, name, file, line, col, signature, doc_comment, scope, text, file_fk)
+         VALUES ${placeholders}`
+      );
+      const binds = [];
+      for (const r of chunk) {
+        binds.push(
+          r.id,
+          r.lang,
+          r.kind,
+          r.name,
+          r.file,
+          r.line,
+          r.col,
+          r.signature,
+          r.docComment,
+          r.scope,
+          r.text,
+          r.file
+        );
+      }
+      stmt.run(...binds);
+    }
+  }
+  bulkInsertFts(rows) {
+    if (!this.ftsAvailable || rows.length === 0) return;
+    const cols = 2;
+    const chunkSize = Math.max(1, Math.floor(_IndexStore.MAX_SQL_VARS / cols));
+    for (let i = 0; i < rows.length; i += chunkSize) {
+      const chunk = rows.slice(i, i + chunkSize);
+      const placeholders = chunk.map(() => "(?, ?)").join(", ");
+      const stmt = this.stmt(`INSERT INTO symbols_fts(rowid, text) VALUES ${placeholders}`);
+      const binds = [];
+      for (const r of chunk) binds.push(r.id, r.text);
+      stmt.run(...binds);
+    }
+  }
+  bulkInsertRefs(refs) {
+    if (refs.length === 0) return;
+    const cols = 5;
+    const chunkSize = Math.max(1, Math.floor(_IndexStore.MAX_SQL_VARS / cols));
+    for (let i = 0; i < refs.length; i += chunkSize) {
+      const chunk = refs.slice(i, i + chunkSize);
+      const placeholders = chunk.map(() => "(?, ?, ?, ?, ?)").join(", ");
+      const stmt = this.stmt(
+        `INSERT INTO refs(from_id, to_name, to_id, call_type, line) VALUES ${placeholders}`
+      );
+      const binds = [];
+      for (const ref of chunk) {
+        binds.push(ref.fromId, ref.toName, ref.toId ?? null, ref.callType, ref.line);
+      }
+      stmt.run(...binds);
+    }
   }
   // ─── Symbol CRUD ─────────────────────────────────────────────────────────────
   /**
    * Insert symbols, assigning IDs atomically inside `BEGIN IMMEDIATE` /
-   * `COMMIT`. The ID allocation (`SELECT MAX(id)`) and all `INSERT`s share
-   * the same transaction, preventing UNIQUE constraint violations when two
-   * processes index concurrently (each would see a different `MAX(id)` and
-   * neither can insert with the other's IDs).
+   * `COMMIT`. Id ranges come from the `next_symbol_id` metadata counter
+   * (O(1)); multi-row INSERT amortizes bind overhead for large files.
    *
    * @returns The symbols array with `id` fields populated so the caller can
    *          use them for refs without re-reading from the DB.
    */
   insertSymbols(symbols) {
+    this.invalidateBm25();
     return this.runWithRetry(() => {
       this.db.exec("BEGIN IMMEDIATE");
       try {
-        const maxRows = this.stmt("SELECT MAX(id) AS m FROM symbols").all();
-        let nextId = (maxRows[0]?.m ?? 0) + 1;
-        const stmt = this.db.prepare(
-          `INSERT INTO symbols(id, lang, kind, name, file, line, col, signature, doc_comment, scope, text, file_fk)
-           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
-        );
-        const ftsStmt = this.ftsAvailable ? this.db.prepare("INSERT INTO symbols_fts(rowid, text) VALUES (?, ?)") : null;
+        let nextId = this.allocateSymbolIds(symbols.length);
         const result = [];
+        const bulk = [];
+        const ftsRows = [];
         for (const s of symbols) {
           const id = nextId++;
-          stmt.run(
+          bulk.push({
             id,
-            s.lang,
-            s.kind,
-            s.name,
-            s.file,
-            s.line,
-            s.col,
-            s.signature,
-            s.docComment,
-            s.scope,
-            s.text,
-            s.file
-          );
-          ftsStmt?.run(id, buildIndexableText(s.name, s.signature, s.docComment));
+            lang: s.lang,
+            kind: s.kind,
+            name: s.name,
+            file: s.file,
+            line: s.line,
+            col: s.col,
+            signature: s.signature,
+            docComment: s.docComment,
+            scope: s.scope,
+            text: s.text
+          });
+          if (this.ftsAvailable) {
+            ftsRows.push({ id, text: buildIndexableText(s.name, s.signature, s.docComment) });
+          }
           result.push({ ...s, id });
         }
+        this.bulkInsertSymbols(bulk);
+        this.bulkInsertFts(ftsRows);
         this.db.exec("COMMIT");
         return result;
       } catch (err) {
@@ -577,6 +707,7 @@ var IndexStore = class _IndexStore {
     });
   }
   deleteSymbolsForFile(file) {
+    this.invalidateBm25();
     this.runWithRetry(() => {
       if (this.ftsAvailable) {
         this.stmt(
@@ -592,17 +723,20 @@ var IndexStore = class _IndexStore {
    * dropped the `files` row, leaving its symbols orphaned but still searchable.
    */
   deleteFile(file) {
+    this.invalidateBm25();
     this.runWithRetry(() => {
       this.db.exec("BEGIN IMMEDIATE");
       try {
         if (this.ftsAvailable) {
-          this.db.prepare(
+          this.stmt(
             "DELETE FROM symbols_fts WHERE rowid IN (SELECT id FROM symbols WHERE file_fk = ?)"
           ).run(file);
         }
-        this.db.prepare("DELETE FROM refs WHERE from_id IN (SELECT id FROM symbols WHERE file_fk = ?)").run(file);
-        this.db.prepare("DELETE FROM symbols WHERE file_fk = ?").run(file);
-        this.db.prepare("DELETE FROM files WHERE file = ?").run(file);
+        this.stmt(
+          "DELETE FROM refs WHERE from_id IN (SELECT id FROM symbols WHERE file_fk = ?)"
+        ).run(file);
+        this.stmt("DELETE FROM symbols WHERE file_fk = ?").run(file);
+        this.stmt("DELETE FROM files WHERE file = ?").run(file);
         this.db.exec("COMMIT");
       } catch (err) {
         this.db.exec("ROLLBACK");
@@ -639,7 +773,7 @@ var IndexStore = class _IndexStore {
     };
   }
   getAllFileMetas() {
-    return this.db.prepare("SELECT file, lang, mtime_ms, symbol_count, last_indexed FROM files").all().map((r) => ({
+    return this.stmt("SELECT file, lang, mtime_ms, symbol_count, last_indexed FROM files").all().map((r) => ({
       file: r.file,
       lang: r.lang,
       mtimeMs: r.mtime_ms,
@@ -648,7 +782,32 @@ var IndexStore = class _IndexStore {
     }));
   }
   // ─── Search ──────────────────────────────────────────────────────────────────
-  search(query, filter) {
+  search(query, filter, opts) {
+    const built = this.buildSearchWhere(query, filter);
+    if (built === null) return [];
+    const { where, values } = built;
+    const limit = typeof opts?.limit === "number" && Number.isFinite(opts.limit) ? Math.max(0, Math.trunc(opts.limit)) : void 0;
+    const limitSql = limit !== void 0 ? " LIMIT ?" : "";
+    const sql = `SELECT id, lang, kind, name, file, line, col, signature, doc_comment, text FROM symbols ${where}${limitSql}`;
+    const binds = limit !== void 0 ? [...values, limit] : values;
+    const rows = this.stmt(sql).all(...binds);
+    return rows.map((r) => ({
+      id: r.id,
+      lang: r.lang,
+      kind: r.kind,
+      name: r.name,
+      file: r.file,
+      line: r.line,
+      col: r.col,
+      signature: r.signature,
+      docComment: r.doc_comment,
+      score: 0,
+      snippet: "",
+      lspKind: filter?.lspKind
+    }));
+  }
+  /** Shared WHERE builder for {@link search} / empty-query ranked totals. */
+  buildSearchWhere(query, filter) {
     const conditions = [];
     const values = [];
     let effectiveKind = filter?.kind;
@@ -657,7 +816,7 @@ var IndexStore = class _IndexStore {
       if (mapped !== null) {
         effectiveKind = mapped;
       } else {
-        return [];
+        return null;
       }
     }
     if (effectiveKind) {
@@ -679,23 +838,15 @@ var IndexStore = class _IndexStore {
       for (const t of tokens) values.push(`%${t}%`);
     }
     const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : "";
-    const sql = `SELECT id, lang, kind, name, file, line, col, signature, doc_comment, text FROM symbols ${where}`;
-    const stmt = this.db.prepare(sql);
-    const rows = stmt.all(...values);
-    return rows.map((r) => ({
-      id: r.id,
-      lang: r.lang,
-      kind: r.kind,
-      name: r.name,
-      file: r.file,
-      line: r.line,
-      col: r.col,
-      signature: r.signature,
-      docComment: r.doc_comment,
-      score: 0,
-      snippet: "",
-      lspKind: filter?.lspKind
-    }));
+    return { where, values };
+  }
+  countSearch(query, filter) {
+    const built = this.buildSearchWhere(query, filter);
+    if (built === null) return 0;
+    const row = this.stmt(`SELECT COUNT(*) AS n FROM symbols ${built.where}`).get(
+      ...built.values
+    );
+    return Number(row?.n ?? 0);
   }
   /**
    * Ranked search — the one-stop query the codebase-search tool and plug-lsp
@@ -736,12 +887,12 @@ var IndexStore = class _IndexStore {
       values.push(`%${escapeLike(filter.file.replace(/\\/g, "/"))}%`);
     }
     const where = conditions.join(" AND ");
-    const countRows = this.db.prepare(
+    const countRows = this.stmt(
       `SELECT COUNT(*) AS n FROM symbols_fts JOIN symbols s ON s.id = symbols_fts.rowid WHERE ${where}`
     ).all(...values);
     const total = countRows[0] ? Number(countRows[0].n) : 0;
     if (total === 0) return { results: [], total: 0 };
-    const rows = this.db.prepare(
+    const rows = this.stmt(
       `SELECT s.id, s.lang, s.kind, s.name, s.file, s.line, s.col, s.signature, s.doc_comment,
                 -bm25(symbols_fts) AS score,
                 snippet(symbols_fts, 0, '', '', '\u2026', 12) AS snippet
@@ -774,20 +925,60 @@ var IndexStore = class _IndexStore {
       total
     };
   }
+  /**
+   * Invalidate the cached BM25 index.
+   *
+   * **Contract: every method that mutates `symbols` MUST call this before
+   * returning.** (`refs` mutations do not affect the BM25 fallback because
+   * the corpus is built from `symbols.text` via `getAllIndexable()` and the
+   * BM25 score is filtered by the LIKE-selected candidate set in
+   * `searchRankedFallback`.) Today the call sites are `repairDrift`,
+   * `insertSymbols`, `deleteSymbolsForFile`, `deleteFile`, `clearAll`, and
+   * `commitBatch`. A future mutation that adds a new write path (e.g.
+   * `renameFile`, `updateSignature`) MUST also call this — otherwise the
+   * FTS5-unavailable fallback will serve stale search results. The
+   * `close()` reset at L1820-1821 tears the cache down on store shutdown,
+   * which is the only legitimate place that flips the flag outside this
+   * helper.
+   *
+   * Called *before* `runWithRetry` on purpose: if the write fails all
+   * retries the flag stays set, forcing a rebuild on the next search rather
+   * than trusting a cache that may not reflect the intended mutation.
+   * Do not move this inside the retry closure.
+   */
+  invalidateBm25() {
+    this.bm25Dirty = true;
+    this.bm25Cache = null;
+  }
+  /**
+   * Return the cached full-corpus BM25 index, rebuilding it only when the
+   * symbols table has been mutated since the last build. The full-corpus IDF
+   * is more correct than the old per-query candidate-subset IDF, and the
+   * amortized build cost drops from O(symbols × tokens) per search to once
+   * per write batch.
+   *
+   * Note: the first call after a long idle (or on a freshly opened store)
+   * pays the full corpus rebuild synchronously on the search path. For a
+   * 5 500+ symbol corpus this is a visible one-time latency spike.
+   */
+  getOrBuildBm25() {
+    if (this.bm25Cache && !this.bm25Dirty) return this.bm25Cache;
+    const docs = this.getAllIndexable();
+    this.bm25Cache = buildBm25Index(docs);
+    this.bm25Dirty = false;
+    return this.bm25Cache;
+  }
   /** Legacy ranked path: LIKE candidates + in-process BM25 + JS snippets. */
   searchRankedFallback(query, filter, limit) {
-    const candidates = this.search(query, filter);
-    if (candidates.length === 0) return { results: [], total: 0 };
     if (!query.trim()) {
-      return { results: candidates.slice(0, limit), total: candidates.length };
+      const total = this.countSearch(query, filter);
+      if (total === 0) return { results: [], total: 0 };
+      return { results: this.search(query, filter, { limit }), total };
     }
+    const candidates = this.search(query, filter);
+    if (candidates.length === 0) return { results: [], total: 0 };
     const candidateById = new Map(candidates.map((c) => [c.id, c]));
-    const bm25 = buildBm25Index(
-      candidates.map((c) => ({
-        id: c.id,
-        text: buildIndexableText(c.name, c.signature, c.docComment)
-      }))
-    );
+    const bm25 = this.getOrBuildBm25();
     const scored = bm25.score(query, (id) => candidateById.has(id));
     const q = query.trim().toLowerCase();
     const rank = (id) => {
@@ -829,7 +1020,7 @@ var IndexStore = class _IndexStore {
   // ─── Stats ───────────────────────────────────────────────────────────────────
   getStats() {
     const sizeBytes = this.sizeBytes();
-    const lastRows = this.db.prepare("SELECT value FROM metadata WHERE key = 'last_indexed'").all();
+    const lastRows = this.stmt("SELECT value FROM metadata WHERE key = 'last_indexed'").all();
     const lastIndexed = lastRows.length ? Number(lastRows[0]?.value) : null;
     const totalRows = this.stmt("SELECT COUNT(*) FROM symbols").all();
     const totalSymbols = totalRows[0] ? Number(totalRows[0]["COUNT(*)"]) : 0;
@@ -854,19 +1045,20 @@ var IndexStore = class _IndexStore {
   }
   setLastIndexed(ts2) {
     this.runWithRetry(() => {
-      this.db.prepare("INSERT OR REPLACE INTO metadata(key, value) VALUES('last_indexed', ?)").run(String(ts2));
+      this.stmt("INSERT OR REPLACE INTO metadata(key, value) VALUES('last_indexed', ?)").run(String(ts2));
     });
   }
   getMetadata(key) {
-    const rows = this.db.prepare("SELECT value FROM metadata WHERE key = ?").all(key);
+    const rows = this.stmt("SELECT value FROM metadata WHERE key = ?").all(key);
     return rows[0]?.value;
   }
   setMetadata(key, value) {
     this.runWithRetry(() => {
-      this.db.prepare("INSERT OR REPLACE INTO metadata(key, value) VALUES(?, ?)").run(key, value);
+      this.stmt("INSERT OR REPLACE INTO metadata(key, value) VALUES(?, ?)").run(key, value);
     });
   }
   clearAll() {
+    this.invalidateBm25();
     this.runWithRetry(() => {
       this.db.exec("BEGIN IMMEDIATE");
       try {
@@ -893,13 +1085,7 @@ var IndexStore = class _IndexStore {
     this.runWithRetry(() => {
       this.stmt("DELETE FROM refs WHERE from_id = ?").run(fromId);
       if (refs.length === 0) return;
-      const stmt = this.db.prepare(
-        `INSERT INTO refs(from_id, to_name, to_id, call_type, line)
-         VALUES (?, ?, ?, ?, ?)`
-      );
-      for (const ref of refs) {
-        stmt.run(fromId, ref.toName, ref.toId ?? null, ref.callType, ref.line);
-      }
+      this.bulkInsertRefs(refs.map((ref) => ({ ...ref, fromId })));
     });
   }
   /**
@@ -916,13 +1102,7 @@ var IndexStore = class _IndexStore {
   insertRefsBatch(refs) {
     if (refs.length === 0) return;
     this.runWithRetry(() => {
-      const stmt = this.db.prepare(
-        `INSERT INTO refs(from_id, to_name, to_id, call_type, line)
-         VALUES (?, ?, ?, ?, ?)`
-      );
-      for (const ref of refs) {
-        stmt.run(ref.fromId, ref.toName, ref.toId ?? null, ref.callType, ref.line);
-      }
+      this.bulkInsertRefs(refs);
     });
   }
   /**
@@ -947,65 +1127,61 @@ var IndexStore = class _IndexStore {
     if (entries.length === 0 && (options.deleteForFiles?.length ?? 0) === 0) {
       return [];
     }
+    this.invalidateBm25();
     return this.runWithRetry(() => {
       this.db.exec("BEGIN IMMEDIATE");
       try {
         if (options.deleteForFiles && options.deleteForFiles.length > 0) {
           const placeholders = options.deleteForFiles.map(() => "?").join(",");
           if (this.ftsAvailable) {
-            this.db.prepare(
+            this.stmt(
               `DELETE FROM symbols_fts WHERE rowid IN (SELECT id FROM symbols WHERE file IN (${placeholders}))`
             ).run(...options.deleteForFiles);
           }
-          this.db.prepare(
+          this.stmt(
             `DELETE FROM refs WHERE from_id IN (SELECT id FROM symbols WHERE file IN (${placeholders}))`
           ).run(...options.deleteForFiles);
-          this.db.prepare(`DELETE FROM symbols WHERE file IN (${placeholders})`).run(...options.deleteForFiles);
+          this.stmt(`DELETE FROM symbols WHERE file IN (${placeholders})`).run(...options.deleteForFiles);
         }
-        const maxRows = this.stmt("SELECT MAX(id) AS m FROM symbols").all();
-        let nextId = (maxRows[0]?.m ?? 0) + 1;
-        const symStmt = this.db.prepare(
-          `INSERT INTO symbols(id, lang, kind, name, file, line, col, signature, doc_comment, scope, text, file_fk)
-           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
-        );
-        const ftsStmt = this.ftsAvailable ? this.db.prepare("INSERT INTO symbols_fts(rowid, text) VALUES (?, ?)") : null;
+        const totalSymbols = entries.reduce((n, e) => n + e.symbols.length, 0);
+        let nextId = this.allocateSymbolIds(totalSymbols);
         const allInserted = [];
         const refsToInsert = [];
+        const bulkSyms = [];
+        const ftsRows = [];
         for (const entry of entries) {
           const insertedForEntry = [];
           for (const s of entry.symbols) {
             const id = nextId++;
-            symStmt.run(
+            bulkSyms.push({
               id,
-              s.lang,
-              s.kind,
-              s.name,
-              s.file,
-              s.line,
-              s.col,
-              s.signature,
-              s.docComment,
-              s.scope,
-              s.text,
-              s.file
-            );
-            ftsStmt?.run(id, buildIndexableText(s.name, s.signature, s.docComment));
+              lang: s.lang,
+              kind: s.kind,
+              name: s.name,
+              file: s.file,
+              line: s.line,
+              col: s.col,
+              signature: s.signature,
+              docComment: s.docComment,
+              scope: s.scope,
+              text: s.text
+            });
+            if (this.ftsAvailable) {
+              ftsRows.push({
+                id,
+                text: buildIndexableText(s.name, s.signature, s.docComment)
+              });
+            }
             const inserted = { ...s, id };
             allInserted.push(inserted);
             insertedForEntry.push(inserted);
           }
           refsToInsert.push(...assignRefsToSymbols(entry.refs, insertedForEntry));
         }
-        if (refsToInsert.length > 0) {
-          const refStmt = this.db.prepare(
-            `INSERT INTO refs(from_id, to_name, to_id, call_type, line)
-             VALUES (?, ?, ?, ?, ?)`
-          );
-          for (const ref of refsToInsert) {
-            refStmt.run(ref.fromId, ref.toName, ref.toId ?? null, ref.callType, ref.line);
-          }
-        }
-        const upsertStmt = this.db.prepare(
+        this.bulkInsertSymbols(bulkSyms);
+        this.bulkInsertFts(ftsRows);
+        this.bulkInsertRefs(refsToInsert);
+        const upsertStmt = this.stmt(
           `INSERT INTO files(file, lang, mtime_ms, symbol_count, last_indexed)
            VALUES (?, ?, ?, ?, ?)
            ON CONFLICT(file) DO UPDATE SET
@@ -1032,7 +1208,7 @@ var IndexStore = class _IndexStore {
    */
   deleteRefsForFile(file) {
     this.runWithRetry(() => {
-      this.db.prepare("DELETE FROM refs WHERE from_id IN (SELECT id FROM symbols WHERE file = ?)").run(file);
+      this.stmt("DELETE FROM refs WHERE from_id IN (SELECT id FROM symbols WHERE file = ?)").run(file);
     });
   }
   /**
@@ -1045,20 +1221,75 @@ var IndexStore = class _IndexStore {
    */
   resolveRefs() {
     return this.runWithRetry(() => {
-      const result = this.db.prepare(
-        `UPDATE refs SET to_id = (
-           SELECT id FROM symbols WHERE name = refs.to_name LIMIT 1
-         ) WHERE to_id IS NULL AND to_name IS NOT NULL
-           AND to_name IN (SELECT name FROM symbols)`
-      ).run();
-      return result.changes ?? 0;
+      try {
+        const result = this.stmt(
+          `UPDATE refs
+           SET to_id = s.id
+           FROM (
+             SELECT name, MIN(id) AS id FROM symbols GROUP BY name
+           ) AS s
+           WHERE refs.to_id IS NULL
+             AND refs.to_name IS NOT NULL
+             AND refs.to_name = s.name`
+        ).run();
+        return result.changes ?? 0;
+      } catch {
+        const result = this.stmt(
+          `UPDATE refs SET to_id = (
+             SELECT id FROM symbols WHERE name = refs.to_name LIMIT 1
+           ) WHERE to_id IS NULL AND to_name IS NOT NULL
+             AND to_name IN (SELECT name FROM symbols)`
+        ).run();
+        return result.changes ?? 0;
+      }
+    });
+  }
+  /**
+   * Clear symbols/refs for a file and mark it as indexed with zero symbols.
+   * Used by the indexer for empty-parse results so three writes share one txn.
+   */
+  replaceEmptyFile(meta) {
+    this.invalidateBm25();
+    this.runWithRetry(() => {
+      this.db.exec("BEGIN IMMEDIATE");
+      try {
+        if (this.ftsAvailable) {
+          this.stmt(
+            "DELETE FROM symbols_fts WHERE rowid IN (SELECT id FROM symbols WHERE file_fk = ?)"
+          ).run(meta.file);
+        }
+        this.stmt(
+          "DELETE FROM refs WHERE from_id IN (SELECT id FROM symbols WHERE file_fk = ?)"
+        ).run(meta.file);
+        this.stmt("DELETE FROM symbols WHERE file_fk = ?").run(meta.file);
+        this.stmt(
+          `INSERT INTO files(file, lang, mtime_ms, symbol_count, last_indexed)
+           VALUES (?, ?, ?, ?, ?)
+           ON CONFLICT(file) DO UPDATE SET
+             lang = excluded.lang,
+             mtime_ms = excluded.mtime_ms,
+             symbol_count = excluded.symbol_count,
+             last_indexed = excluded.last_indexed`
+        ).run(meta.file, meta.lang, meta.mtimeMs, meta.symbolCount, meta.lastIndexed);
+        this.db.exec("COMMIT");
+      } catch (err) {
+        this.db.exec("ROLLBACK");
+        throw err;
+      }
     });
   }
+  /** Best-effort query planner refresh after a large reindex. */
+  optimize() {
+    try {
+      this.db.exec("PRAGMA optimize");
+    } catch {
+    }
+  }
   /**
    * Find all references TO a given symbol (who calls / uses this symbol?).
    */
   findRefsTo(symbolId) {
-    return this.db.prepare(
+    return this.stmt(
       "SELECT id, from_id, to_name, to_id, call_type, line FROM refs WHERE to_id = ? OR to_name = (SELECT name FROM symbols WHERE id = ?)"
     ).all(symbolId, symbolId).map((r) => ({
       id: r.id,
@@ -1073,7 +1304,7 @@ var IndexStore = class _IndexStore {
    * Find all references FROM a given symbol (what does this symbol call/use?).
    */
   findRefsFrom(symbolId) {
-    return this.db.prepare("SELECT id, from_id, to_name, to_id, call_type, line FROM refs WHERE from_id = ?").all(symbolId).map((r) => ({
+    return this.stmt("SELECT id, from_id, to_name, to_id, call_type, line FROM refs WHERE from_id = ?").all(symbolId).map((r) => ({
       id: r.id,
       fromId: r.from_id,
       toName: r.to_name,
@@ -1146,45 +1377,57 @@ var IndexStore = class _IndexStore {
    * symbol resolved in package B). Node metadata includes symbol/file counts.
    */
   getPackageGraph() {
-    const symbols = this.db.prepare("SELECT file, id FROM symbols ORDER BY id").all();
+    const fileCounts = this.stmt(
+      "SELECT file, COUNT(*) AS n FROM symbols GROUP BY file"
+    ).all();
     const pkgNodes = /* @__PURE__ */ new Map();
     const fileToPkg = /* @__PURE__ */ new Map();
-    const symbolToPkg = /* @__PURE__ */ new Map();
-    for (const s of symbols) {
-      const pkg = _IndexStore.derivePackage(s.file) ?? "(root)";
-      fileToPkg.set(s.file, pkg);
-      symbolToPkg.set(s.id, pkg);
+    for (const { file, n } of fileCounts) {
+      const pkg = _IndexStore.derivePackage(file) ?? "(root)";
+      fileToPkg.set(file, pkg);
       const node = pkgNodes.get(pkg);
       if (node) {
-        node.symbolCount = (node.symbolCount ?? 0) + 1;
+        node.symbolCount = (node.symbolCount ?? 0) + n;
       } else {
         pkgNodes.set(pkg, {
           id: `pkg:${pkg}`,
           label: pkg,
           kind: "package",
           package: pkg,
-          symbolCount: 1,
+          symbolCount: n,
           fileCount: 0
         });
       }
     }
-    const files = this.db.prepare("SELECT DISTINCT file FROM files").all();
+    const files = this.stmt("SELECT DISTINCT file FROM files").all();
     for (const { file } of files) {
       const pkg = _IndexStore.derivePackage(file) ?? "(root)";
+      fileToPkg.set(file, pkg);
       const node = pkgNodes.get(pkg);
       if (node) node.fileCount = (node.fileCount ?? 0) + 1;
+      else {
+        pkgNodes.set(pkg, {
+          id: `pkg:${pkg}`,
+          label: pkg,
+          kind: "package",
+          package: pkg,
+          symbolCount: 0,
+          fileCount: 1
+        });
+      }
     }
-    const refRows = this.db.prepare(
-      `SELECT r.from_id, r.to_id, r.call_type
+    const refRows = this.stmt(
+      `SELECT r.call_type, sf.file AS from_file, st.file AS to_file
        FROM refs r
-       WHERE r.to_id IS NOT NULL`
+       JOIN symbols sf ON sf.id = r.from_id
+       JOIN symbols st ON st.id = r.to_id
+       WHERE r.to_id IS NOT NULL AND r.call_type != 'import'`
     ).all();
     const edgeMap = /* @__PURE__ */ new Map();
     for (const r of refRows) {
-      if (r.call_type === "import") continue;
-      const fromPkg = symbolToPkg.get(r.from_id);
-      const toPkg = symbolToPkg.get(r.to_id);
-      if (!fromPkg || !toPkg || fromPkg === toPkg) continue;
+      const fromPkg = fileToPkg.get(r.from_file) ?? _IndexStore.derivePackage(r.from_file) ?? "(root)";
+      const toPkg = fileToPkg.get(r.to_file) ?? _IndexStore.derivePackage(r.to_file) ?? "(root)";
+      if (fromPkg === toPkg) continue;
       const key = `${fromPkg}\0${toPkg}`;
       let e = edgeMap.get(key);
       if (!e) {
@@ -1194,13 +1437,14 @@ var IndexStore = class _IndexStore {
       e.weight++;
       e.types.set(r.call_type, (e.types.get(r.call_type) ?? 0) + 1);
     }
-    const importRows = this.db.prepare(
-      `SELECT r.from_id, r.to_name
+    const importRows = this.stmt(
+      `SELECT r.to_name, s.file AS from_file
        FROM refs r
+       JOIN symbols s ON s.id = r.from_id
        WHERE r.call_type = 'import'`
     ).all();
     for (const r of importRows) {
-      const fromPkg = symbolToPkg.get(r.from_id);
+      const fromPkg = fileToPkg.get(r.from_file) ?? _IndexStore.derivePackage(r.from_file) ?? "(root)";
       const toPkg = _IndexStore.packageFromImport(r.to_name);
       if (!fromPkg || !toPkg || fromPkg === toPkg || !pkgNodes.has(toPkg)) continue;
       const key = `${fromPkg}\0${toPkg}`;
@@ -1237,12 +1481,12 @@ var IndexStore = class _IndexStore {
    * derived from cross-file symbol references within the package.
    */
   getFileGraph(packageFilter) {
-    const allFiles = this.db.prepare("SELECT DISTINCT file FROM symbols").all();
+    const allFiles = this.stmt("SELECT DISTINCT file FROM symbols").all();
     const pkgFilePaths = allFiles.filter((f) => (_IndexStore.derivePackage(f.file) ?? "(root)") === packageFilter).map((f) => f.file);
     const localFiles = new Set(pkgFilePaths);
     if (localFiles.size === 0) return { nodes: [], edges: [] };
     const filePlaceholders = [...localFiles].map(() => "?").join(",");
-    const pkgSyms = this.db.prepare(
+    const pkgSyms = this.stmt(
       `SELECT file, id, name, kind, lang, line FROM symbols WHERE file IN (${filePlaceholders}) ORDER BY id`
     ).all(...pkgFilePaths);
     const fileNodes = /* @__PURE__ */ new Map();
@@ -1274,7 +1518,7 @@ var IndexStore = class _IndexStore {
       ensureFileNode(file);
     }
     const indexedFiles = new Set(allFiles.map((f) => f.file));
-    const refRows = this.db.prepare(
+    const refRows = this.stmt(
       `SELECT r.from_id, r.to_id, r.call_type
        FROM refs r
        WHERE (r.from_id IN (SELECT id FROM symbols WHERE file IN (${filePlaceholders}))
@@ -1289,7 +1533,7 @@ var IndexStore = class _IndexStore {
     }
     if (crossRefIds.size > 0) {
       const crossPlaceholders = [...crossRefIds].map(() => "?").join(",");
-      const extras = this.db.prepare(
+      const extras = this.stmt(
         `SELECT id, file FROM symbols WHERE id IN (${crossPlaceholders})`
       ).all(...crossRefIds);
       for (const x of extras) {
@@ -1317,7 +1561,7 @@ var IndexStore = class _IndexStore {
       e.weight++;
       e.types.set(r.call_type, (e.types.get(r.call_type) ?? 0) + 1);
     }
-    const importRows = this.db.prepare(
+    const importRows = this.stmt(
       `SELECT r.from_id, r.to_name
        FROM refs r
        WHERE r.call_type = 'import'
@@ -1364,7 +1608,7 @@ var IndexStore = class _IndexStore {
    * derived from intra-file and cross-file symbol references (who calls whom).
    */
   getSymbolGraph(fileFilter) {
-    const syms = this.db.prepare(
+    const syms = this.stmt(
       "SELECT id, name, kind, lang, file, line, signature, scope FROM symbols WHERE file = ? ORDER BY line, id"
     ).all(fileFilter);
     if (syms.length === 0) return { nodes: [], edges: [] };
@@ -1385,11 +1629,16 @@ var IndexStore = class _IndexStore {
       external: s.file !== fileFilter
     });
     const symIds = new Set(syms.map((s) => s.id));
-    const refRows = this.db.prepare(
+    const refRows = this.stmt(
       `SELECT r.from_id, r.to_id, r.to_name, r.call_type, r.line
        FROM refs r
-       WHERE r.from_id IN (SELECT id FROM symbols WHERE file = ?)
-          OR r.to_id IN (SELECT id FROM symbols WHERE file = ?)`
+       JOIN symbols s ON s.id = r.from_id
+       WHERE s.file = ?
+       UNION
+       SELECT r.from_id, r.to_id, r.to_name, r.call_type, r.line
+       FROM refs r
+       JOIN symbols s ON s.id = r.to_id
+       WHERE s.file = ?`
     ).all(fileFilter, fileFilter);
     const edgeMap = /* @__PURE__ */ new Map();
     for (const r of refRows) {
@@ -1428,7 +1677,7 @@ var IndexStore = class _IndexStore {
     const missingIds = [...relatedIds].filter((id) => !loadedIds.has(id));
     if (missingIds.length > 0) {
       const placeholders = missingIds.map(() => "?").join(",");
-      const extras = this.db.prepare(
+      const extras = this.stmt(
         `SELECT id, name, kind, lang, file, line, signature, scope FROM symbols WHERE id IN (${placeholders})`
       ).all(...missingIds);
       for (const s of extras) symById.set(s.id, s);
@@ -1442,6 +1691,8 @@ var IndexStore = class _IndexStore {
   }
   close() {
     this.stmtCache.clear();
+    this.bm25Dirty = true;
+    this.bm25Cache = null;
     try {
       this.db.close();
     } catch {
@@ -1455,14 +1706,121 @@ import { fileURLToPath } from "node:url";
 import { Worker } from "node:worker_threads";
 
 // src/codebase-index/indexer.ts
-import { expectDefined as expectDefined5 } from "@wrongstack/core";
+import { expectDefined as expectDefined5 } from "@wrongstack/core/utils";
 import * as fs7 from "node:fs/promises";
-import * as path8 from "node:path";
+import * as path9 from "node:path";
 import { availableParallelism } from "node:os";
-import { compileGlob as compileGlob2 } from "@wrongstack/core";
+import { indexParallelBatchSize, isFrugalPerf } from "@wrongstack/core/utils";
 
 // src/codebase-index/ts-parser.ts
 import * as ts from "@typescript/typescript6";
+
+// src/codebase-index/languages.ts
+import * as path2 from "node:path";
+var EXT_TO_LANG = {
+  // TypeScript / JavaScript (first-class TS compiler API)
+  ".ts": "ts",
+  ".mts": "ts",
+  ".cts": "ts",
+  ".tsx": "tsx",
+  ".js": "js",
+  ".mjs": "js",
+  ".cjs": "js",
+  ".jsx": "jsx",
+  // First-class native/spawn parsers (+ regex fallback)
+  ".go": "go",
+  ".py": "py",
+  ".pyi": "py",
+  ".pyw": "py",
+  ".rs": "rs",
+  ".json": "json",
+  ".jsonc": "json",
+  ".yaml": "yaml",
+  ".yml": "yaml",
+  // C family
+  ".c": "c",
+  ".h": "c",
+  ".cc": "cpp",
+  ".cpp": "cpp",
+  ".cxx": "cpp",
+  ".hh": "cpp",
+  ".hpp": "cpp",
+  ".hxx": "cpp",
+  // JVM / .NET
+  ".java": "java",
+  ".cs": "csharp",
+  ".kt": "kotlin",
+  ".kts": "kotlin",
+  ".scala": "scala",
+  ".sc": "scala",
+  // Scripting
+  ".php": "php",
+  ".rb": "ruby",
+  ".swift": "swift",
+  ".dart": "dart",
+  ".lua": "lua",
+  ".r": "r",
+  ".R": "r",
+  ".pl": "other",
+  ".pm": "other",
+  // Systems / functional
+  ".zig": "zig",
+  ".ex": "elixir",
+  ".exs": "elixir",
+  ".hs": "haskell",
+  ".lhs": "haskell",
+  // Shell / data / docs / web
+  ".sh": "shell",
+  ".bash": "shell",
+  ".zsh": "shell",
+  ".ps1": "shell",
+  ".sql": "sql",
+  ".md": "md",
+  ".mdx": "md",
+  ".toml": "toml",
+  ".html": "html",
+  ".htm": "html",
+  ".css": "css",
+  ".scss": "css",
+  ".less": "css",
+  ".vue": "vue",
+  ".svelte": "svelte",
+  ".proto": "proto",
+  ".graphql": "graphql",
+  ".gql": "graphql"
+};
+var INDEXABLE_EXTENSIONS = Object.freeze(
+  [...new Set(Object.keys(EXT_TO_LANG).map((e) => e.toLowerCase()))].sort()
+);
+var SPECIAL_FILENAMES = {
+  makefile: "other",
+  gnumakefile: "other",
+  dockerfile: "other",
+  "docker-compose.yml": "yaml",
+  "docker-compose.yaml": "yaml",
+  "cmakelists.txt": "other",
+  gemfile: "ruby",
+  rakefile: "ruby",
+  procfile: "other",
+  justfile: "other"
+};
+function detectLang(file) {
+  const base = path2.basename(file);
+  const lowerBase = base.toLowerCase();
+  if (lowerBase.endsWith(".d.ts") || lowerBase.endsWith(".d.mts") || lowerBase.endsWith(".d.cts")) {
+    return "ts";
+  }
+  const special = SPECIAL_FILENAMES[lowerBase];
+  if (special) return special;
+  const ext = path2.extname(base).toLowerCase();
+  if (!ext) return null;
+  return EXT_TO_LANG[ext] ?? null;
+}
+function isIndexablePath(file) {
+  return detectLang(file) !== null;
+}
+
+// src/codebase-index/ts-parser.ts
 var KIND_MAP = {
   [ts.SyntaxKind.ClassDeclaration]: "class",
   [ts.SyntaxKind.InterfaceDeclaration]: "interface",
@@ -1489,32 +1847,6 @@ function kindOf(node) {
   if (ts.isModuleDeclaration(node)) return "namespace";
   return KIND_MAP[node.kind] ?? null;
 }
-function extToLang(ext) {
-  switch (ext) {
-    case ".ts":
-      return "ts";
-    case ".tsx":
-      return "tsx";
-    case ".js":
-      return "js";
-    case ".jsx":
-      return "jsx";
-    case ".go":
-      return "go";
-    case ".py":
-      return "py";
-    case ".rs":
-      return "rs";
-    case ".json":
-      return "json";
-    case ".yaml":
-      return "yaml";
-    case ".yml":
-      return "yaml";
-    default:
-      return null;
-  }
-}
 function getSignature(printer, node, sourceFile) {
   const raw = printer.printNode(ts.EmitHint.Unspecified, node, sourceFile);
   return raw.replace(/\s+/g, " ").slice(0, 500);
@@ -1637,30 +1969,25 @@ function deduplicateRefs(refs) {
     return true;
   });
 }
-function detectLang(file) {
-  const idx = file.lastIndexOf(".");
-  if (idx < 0) return null;
-  return extToLang(file.slice(idx));
-}
 
 // src/codebase-index/go-parser.ts
 import { spawn } from "node:child_process";
 import * as os from "node:os";
-import * as path3 from "node:path";
+import * as path4 from "node:path";
 import * as fs3 from "node:fs/promises";
 
 // src/_win32-resolve.ts
 import * as fs2 from "node:fs";
-import * as path2 from "node:path";
+import * as path3 from "node:path";
 function resolveWin32Command(cmd) {
   if (process.platform !== "win32") return cmd;
-  if (cmd.includes("/") || cmd.includes("\\") || path2.extname(cmd.replace(/\//g, "\\"))) {
+  if (cmd.includes("/") || cmd.includes("\\") || path3.extname(cmd.replace(/\//g, "\\"))) {
     return cmd;
   }
   const pathext = (process.env["PATHEXT"] ?? ".COM;.EXE;.BAT;.CMD;.VBS;.JS;.WS;.MSC").toLowerCase().split(";");
-  const pathDirs = (process.env["PATH"] ?? "").split(path2.delimiter);
+  const pathDirs = (process.env["PATH"] ?? "").split(path3.delimiter);
   for (const dir of pathDirs) {
-    const base = path2.join(dir, cmd);
+    const base = path3.join(dir, cmd);
     for (const ext of pathext) {
       const full = `${base}${ext}`;
       try {
@@ -1673,11 +2000,22 @@ function resolveWin32Command(cmd) {
   return cmd;
 }
 
+// src/codebase-index/spawn-gate.ts
+var chain = Promise.resolve();
+function withSpawnGate(fn) {
+  const run = chain.then(fn, fn);
+  chain = run.then(
+    () => void 0,
+    () => void 0
+  );
+  return run;
+}
+
 // src/codebase-index/go-parser.ts
 async function parseSymbols2(opts) {
   const { file, content, lang } = opts;
   try {
-    const parsed = await syncGoParse(file, content, lang);
+    const parsed = await withSpawnGate(() => syncGoParse(file, content, lang));
     if (parsed.symbols.length > 0) {
       return parsed;
     }
@@ -1973,11 +2311,16 @@ func formatType(t ast.Expr) string {
 	}
 }
 `;
+var _cachedGoScriptPath = null;
 async function syncGoParse(filePath, content, lang) {
-  const tmpDir = await fs3.mkdtemp(path3.join(os.tmpdir(), "ws-go-parse-"));
   try {
-    const scriptPath = path3.join(tmpDir, "parse.go");
-    await fs3.writeFile(scriptPath, GO_PARSE_SCRIPT, "utf8");
+    let scriptPath = _cachedGoScriptPath;
+    if (!scriptPath) {
+      const tmpDir = await fs3.mkdtemp(path4.join(os.tmpdir(), "ws-go-parse-"));
+      scriptPath = path4.join(tmpDir, "parse.go");
+      await fs3.writeFile(scriptPath, GO_PARSE_SCRIPT, "utf8");
+      _cachedGoScriptPath = scriptPath;
+    }
     const goBinary = resolveWin32Command("go");
     const goResult = await new Promise(
       (resolve2, reject) => {
@@ -2034,23 +2377,312 @@ async function syncGoParse(filePath, content, lang) {
     return { file: filePath, lang, symbols, mtimeMs: Date.now() };
   } catch {
     return { file: filePath, lang, symbols: [], mtimeMs: Date.now() };
-  } finally {
-    await fs3.rm(tmpDir, { recursive: true, force: true });
   }
 }
 
 // src/codebase-index/py-parser.ts
-import { spawn as spawn2, spawnSync } from "node:child_process";
+import { spawn as spawn2 } from "node:child_process";
 import * as fs4 from "node:fs/promises";
 import * as os2 from "node:os";
-import * as path4 from "node:path";
+import * as path5 from "node:path";
+
+// src/codebase-index/generic-parser.ts
+var C_LIKE = [
+  { re: /\b(?:class|struct|enum|interface|union)\s+([A-Za-z_]\w*)/g, kind: "class" },
+  {
+    re: /\b(?:public|private|protected|static|final|async|override|virtual|inline|export)?\s*(?:[\w:<>\[\]\s\*&]+)\s+([A-Za-z_]\w*)\s*\([^;{]*\)\s*(?:const)?\s*[{;]/g,
+    kind: "function"
+  },
+  { re: /\b(?:namespace)\s+([A-Za-z_]\w*)/g, kind: "namespace" }
+];
+var LANG_PATTERNS = {
+  py: [
+    { re: /^(?:async\s+)?def\s+([A-Za-z_]\w*)/gm, kind: "function" },
+    { re: /^class\s+([A-Za-z_]\w*)/gm, kind: "class" },
+    { re: /^([A-Za-z_]\w*)\s*=/gm, kind: "var" }
+  ],
+  go: [
+    { re: /^func\s+(?:\([^)]*\)\s*)?([A-Za-z_]\w*)\s*\(/gm, kind: "function" },
+    { re: /^type\s+([A-Za-z_]\w*)\b/gm, kind: "type" },
+    { re: /^(?:const|var)\s+([A-Za-z_]\w*)\b/gm, kind: "const" },
+    { re: /^package\s+([A-Za-z_]\w*)/gm, kind: "namespace" }
+  ],
+  rs: [
+    { re: /\bfn\s+([A-Za-z_]\w*)/g, kind: "function" },
+    { re: /\bstruct\s+([A-Za-z_]\w*)/g, kind: "struct" },
+    { re: /\benum\s+([A-Za-z_]\w*)/g, kind: "enum" },
+    { re: /\btrait\s+([A-Za-z_]\w*)/g, kind: "trait" },
+    { re: /\bimpl(?:\s*<[^>]+>)?\s+([A-Za-z_]\w*)/g, kind: "impl" },
+    { re: /\b(?:const|static)\s+([A-Za-z_]\w*)/g, kind: "const" },
+    { re: /\bmod\s+([A-Za-z_]\w*)/g, kind: "mod" }
+  ],
+  c: C_LIKE,
+  cpp: C_LIKE,
+  java: [
+    { re: /\b(?:class|interface|enum|record)\s+([A-Za-z_]\w*)/g, kind: "class" },
+    {
+      re: /\b(?:public|private|protected|static|final|abstract|synchronized|native|default|\s)+\s*[\w.<>,\[\]\s]+\s+([A-Za-z_]\w*)\s*\(/g,
+      kind: "method"
+    }
+  ],
+  csharp: [
+    { re: /\b(?:class|interface|struct|enum|record)\s+([A-Za-z_]\w*)/g, kind: "class" },
+    { re: /\bnamespace\s+([A-Za-z_.\w]+)/g, kind: "namespace" },
+    {
+      re: /\b(?:public|private|protected|internal|static|async|override|virtual|\s)+\s*[\w.<>,\[\]\s]+\s+([A-Za-z_]\w*)\s*\(/g,
+      kind: "method"
+    }
+  ],
+  php: [
+    { re: /\bfunction\s+([A-Za-z_]\w*)/g, kind: "function" },
+    { re: /\bclass\s+([A-Za-z_]\w*)/g, kind: "class" },
+    { re: /\binterface\s+([A-Za-z_]\w*)/g, kind: "interface" },
+    { re: /\bnamespace\s+([A-Za-z_\\]+)/g, kind: "namespace" }
+  ],
+  ruby: [
+    { re: /^\s*def\s+(?:self\.)?([A-Za-z_]\w*[!?]?)/gm, kind: "function" },
+    { re: /^\s*class\s+([A-Za-z_]\w*)/gm, kind: "class" },
+    { re: /^\s*module\s+([A-Za-z_]\w*)/gm, kind: "namespace" }
+  ],
+  swift: [
+    { re: /\b(?:func)\s+([A-Za-z_]\w*)/g, kind: "function" },
+    { re: /\b(?:class|struct|enum|protocol|actor)\s+([A-Za-z_]\w*)/g, kind: "class" }
+  ],
+  kotlin: [
+    { re: /\b(?:fun)\s+([A-Za-z_]\w*)/g, kind: "function" },
+    { re: /\b(?:class|interface|object|enum\s+class|data\s+class)\s+([A-Za-z_]\w*)/g, kind: "class" }
+  ],
+  scala: [
+    { re: /\b(?:def)\s+([A-Za-z_]\w*)/g, kind: "function" },
+    { re: /\b(?:class|object|trait|enum)\s+([A-Za-z_]\w*)/g, kind: "class" }
+  ],
+  shell: [
+    { re: /^(?:function\s+)?([A-Za-z_]\w*)\s*\(\)\s*\{/gm, kind: "function" },
+    { re: /^([A-Za-z_][\w]*)\s*\(\)\s*\{/gm, kind: "function" }
+  ],
+  sql: [
+    { re: /\bCREATE\s+(?:OR\s+REPLACE\s+)?(?:TABLE|VIEW|INDEX|FUNCTION|PROCEDURE|TRIGGER)\s+(?:IF\s+NOT\s+EXISTS\s+)?([A-Za-z_"][\w."]*)/gi, kind: "type" }
+  ],
+  md: [
+    { re: /^(#{1,6})\s+(.+)$/gm, kind: "namespace" }
+  ],
+  toml: [
+    { re: /^\[([^\]]+)\]/gm, kind: "namespace" }
+  ],
+  html: [
+    { re: /\bid\s*=\s*["']([^"']+)["']/gi, kind: "property" },
+    { re: /<(?:script|template|style)\b/gi, kind: "namespace" }
+  ],
+  css: [
+    { re: /^\s*([.#]?[A-Za-z_][\w-]*)\s*\{/gm, kind: "type" },
+    { re: /@(?:keyframes|media|supports)\s+([^{\s]+)/g, kind: "namespace" }
+  ],
+  vue: [
+    { re: /\b(?:function|const|let|var|class|export\s+(?:default\s+)?(?:function|class|const))\s+([A-Za-z_]\w*)/g, kind: "function" },
+    { re: /<(?:script|template|style)\b/gi, kind: "namespace" }
+  ],
+  svelte: [
+    { re: /\b(?:function|const|let|var|class|export\s+(?:default\s+)?(?:function|class|const))\s+([A-Za-z_]\w*)/g, kind: "function" }
+  ],
+  dart: [
+    { re: /\b(?:class|enum|mixin|extension)\s+([A-Za-z_]\w*)/g, kind: "class" },
+    { re: /\b([A-Za-z_]\w*)\s*\([^;]*\)\s*(?:async\s*)?\{/g, kind: "function" }
+  ],
+  lua: [
+    { re: /\bfunction\s+([A-Za-z_.:]\w*)/g, kind: "function" },
+    { re: /\blocal\s+function\s+([A-Za-z_]\w*)/g, kind: "function" }
+  ],
+  r: [
+    { re: /([A-Za-z.]\w*)\s*<-\s*function\s*\(/g, kind: "function" },
+    { re: /([A-Za-z.]\w*)\s*=\s*function\s*\(/g, kind: "function" }
+  ],
+  proto: [
+    { re: /\b(?:message|service|enum)\s+([A-Za-z_]\w*)/g, kind: "type" },
+    { re: /\brpc\s+([A-Za-z_]\w*)/g, kind: "function" }
+  ],
+  graphql: [
+    { re: /\b(?:type|interface|enum|input|union|scalar)\s+([A-Za-z_]\w*)/g, kind: "type" },
+    { re: /\b(?:query|mutation|subscription)\s+([A-Za-z_]\w*)/g, kind: "function" }
+  ],
+  zig: [
+    { re: /\b(?:fn|pub\s+fn)\s+([A-Za-z_]\w*)/g, kind: "function" },
+    { re: /\b(?:const|var)\s+([A-Za-z_]\w*)/g, kind: "const" },
+    { re: /\b(?:struct|enum|union)\s*\{/g, kind: "type" }
+  ],
+  elixir: [
+    { re: /\bdef(?:p|macro|macrop)?\s+([A-Za-z_]\w*[!?]?)/g, kind: "function" },
+    { re: /\bdefmodule\s+([A-Za-z_.]\w*)/g, kind: "namespace" }
+  ],
+  haskell: [
+    { re: /^([A-Za-z_]\w*)\s*::/gm, kind: "function" },
+    { re: /\bdata\s+([A-Za-z_]\w*)/g, kind: "type" },
+    { re: /\btype\s+(?:family\s+)?([A-Za-z_]\w*)/g, kind: "type" },
+    { re: /\bclass\s+([A-Za-z_]\w*)/g, kind: "class" }
+  ],
+  other: [
+    { re: /^(?:export\s+)?(?:async\s+)?function\s+([A-Za-z_]\w*)/gm, kind: "function" },
+    { re: /^(?:export\s+)?class\s+([A-Za-z_]\w*)/gm, kind: "class" },
+    { re: /^(?:export\s+)?(?:const|let|var)\s+([A-Za-z_]\w*)/gm, kind: "const" },
+    { re: /^(?:async\s+)?def\s+([A-Za-z_]\w*)/gm, kind: "function" },
+    { re: /^func\s+(?:\([^)]*\)\s*)?([A-Za-z_]\w*)/gm, kind: "function" },
+    { re: /\bfn\s+([A-Za-z_]\w*)/g, kind: "function" },
+    { re: /^(?:target|PHONY)\s*:/gm, kind: "namespace" }
+  ]
+};
+var KEYWORDS = /* @__PURE__ */ new Set([
+  "if",
+  "else",
+  "for",
+  "while",
+  "switch",
+  "case",
+  "return",
+  "break",
+  "continue",
+  "new",
+  "delete",
+  "typeof",
+  "instanceof",
+  "void",
+  "null",
+  "true",
+  "false",
+  "this",
+  "super",
+  "import",
+  "export",
+  "from",
+  "as",
+  "default",
+  "public",
+  "private",
+  "protected",
+  "static",
+  "final",
+  "class",
+  "struct",
+  "enum",
+  "interface",
+  "function",
+  "def",
+  "fn",
+  "func",
+  "var",
+  "let",
+  "const",
+  "package",
+  "namespace",
+  "module",
+  "using",
+  "include",
+  "require",
+  "select",
+  "from",
+  "where",
+  "and",
+  "or",
+  "not",
+  "in",
+  "is",
+  "try",
+  "catch",
+  "finally",
+  "throw",
+  "async",
+  "await",
+  "yield"
+]);
+function patternsFor(lang) {
+  return LANG_PATTERNS[lang] ?? LANG_PATTERNS.other ?? [];
+}
+function looksBinary(content) {
+  if (content.includes("\0")) return true;
+  const sample = content.slice(0, 2048);
+  if (sample.length === 0) return false;
+  let bad = 0;
+  for (let i = 0; i < sample.length; i++) {
+    const c = sample.charCodeAt(i);
+    if (c === 9 || c === 10 || c === 13) continue;
+    if (c < 32 || c === 127) bad++;
+  }
+  return bad / sample.length > 0.1;
+}
+function lineColAt(content, index) {
+  let line = 1;
+  let lastNl = -1;
+  for (let i = 0; i < index && i < content.length; i++) {
+    if (content.charCodeAt(i) === 10) {
+      line++;
+      lastNl = i;
+    }
+  }
+  return { line, col: index - lastNl };
+}
+var GENERIC_MAX_SYMBOLS_DEFAULT = 500;
+var GENERIC_MAX_FILE_CHARS = 512 * 1024;
+function parseGeneric(opts) {
+  const { file, lang } = opts;
+  const maxSymbols = opts.maxSymbols ?? GENERIC_MAX_SYMBOLS_DEFAULT;
+  const mtimeMs = Date.now();
+  if (!opts.content || looksBinary(opts.content)) {
+    return { file, lang, symbols: [], mtimeMs };
+  }
+  const content = opts.content.length > GENERIC_MAX_FILE_CHARS ? opts.content.slice(0, GENERIC_MAX_FILE_CHARS) : opts.content;
+  const patterns = patternsFor(lang);
+  const symbols = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const pattern of patterns) {
+    const re = new RegExp(pattern.re.source, pattern.re.flags.includes("g") ? pattern.re.flags : `${pattern.re.flags}g`);
+    re.lastIndex = 0;
+    let match;
+    while ((match = re.exec(content)) !== null) {
+      if (symbols.length >= maxSymbols) break;
+      let name = (match[1] ?? match[2] ?? "").trim();
+      if (lang === "md" && match[2]) name = match[2].trim();
+      if (!name || name.length > 200) continue;
+      name = name.replace(/^#+\s*/, "").replace(/["'`]/g, "");
+      if (!name || KEYWORDS.has(name.toLowerCase())) continue;
+      if (!/^[A-Za-z_#.@/\w][\w.\-:/#!?]*$/.test(name) && lang !== "md" && lang !== "toml") {
+        continue;
+      }
+      const { line, col } = lineColAt(content, match.index);
+      const key = `${name}\0${line}\0${pattern.kind}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      const nl = content.indexOf("\n", match.index);
+      const lineText = content.slice(match.index, nl === -1 ? content.length : nl);
+      const signature = (lineText || name).trim().slice(0, 500);
+      symbols.push({
+        id: 0,
+        lang,
+        kind: lang === "md" ? "namespace" : pattern.kind,
+        name: name.slice(0, 200),
+        file,
+        line,
+        col,
+        signature,
+        docComment: "",
+        scope: "",
+        text: `${name} ${signature}`.trim().slice(0, 1e3)
+      });
+    }
+    if (symbols.length >= maxSymbols) break;
+  }
+  return { file, lang, symbols, mtimeMs };
+}
 async function parseSymbols3(opts) {
+  return parseGeneric(opts);
+}
+
+// src/codebase-index/py-parser.ts
+async function parseSymbols4(opts) {
   const { file, content, lang } = opts;
   try {
-    return await syncPyParse(file, content, lang);
+    const native = await withSpawnGate(() => syncPyParse(file, content, lang));
+    if (native !== null) return native;
   } catch {
-    return { file, lang, symbols: [], mtimeMs: Date.now() };
   }
+  return parseGeneric({ file, content, lang: lang === "py" ? "py" : lang });
 }
 var PY_PARSE_SCRIPT = `import ast, json, sys, os
 
@@ -2255,20 +2887,37 @@ visitor.visit(tree)
 
 print(json.dumps([s.to_dict() for s in syms]))
 `;
-function resolvePython() {
+async function resolvePython() {
   const candidates = process.platform === "win32" ? ["python3", "python", "py"] : ["python3", "python"];
   for (const name of candidates) {
     const resolved = resolveWin32Command(name);
-    const result = spawnSync(resolved, ["--version"], {
-      stdio: "pipe",
-      timeout: 5e3
-    });
-    if (result.error) continue;
-    if (result.status !== 0) continue;
+    if (!await commandIsAvailable(resolved)) continue;
     return resolved;
   }
   return null;
 }
+function commandIsAvailable(command) {
+  return new Promise((resolve2) => {
+    let settled = false;
+    const proc = spawn2(command, ["--version"], {
+      stdio: "ignore",
+      windowsHide: true
+    });
+    const finish = (available) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve2(available);
+    };
+    const timer = setTimeout(() => {
+      proc.kill("SIGKILL");
+      finish(false);
+    }, 5e3);
+    timer.unref?.();
+    proc.once("error", () => finish(false));
+    proc.once("close", (code) => finish(code === 0));
+  });
+}
 function spawnPyParser(pyBinary, scriptPath, filePath, content) {
   return new Promise((resolve2, reject) => {
     let settled = false;
@@ -2304,21 +2953,20 @@ function spawnPyParser(pyBinary, scriptPath, filePath, content) {
   });
 }
 var _cachedScriptPath = null;
-var _cachedPyBinary = null;
+var cachedPyBinary;
 async function syncPyParse(filePath, content, lang) {
   try {
     if (!_cachedScriptPath) {
-      const tmpDir = path4.join(os2.tmpdir(), "ws-py-parse");
+      const tmpDir = path5.join(os2.tmpdir(), "ws-py-parse");
       await fs4.mkdir(tmpDir, { recursive: true });
-      _cachedScriptPath = path4.join(tmpDir, "parse.py");
+      _cachedScriptPath = path5.join(tmpDir, "parse.py");
       await fs4.writeFile(_cachedScriptPath, PY_PARSE_SCRIPT, "utf8");
     }
-    if (!_cachedPyBinary) {
-      _cachedPyBinary = resolvePython();
-      if (!_cachedPyBinary) return { file: filePath, lang, symbols: [], mtimeMs: Date.now() };
-    }
+    cachedPyBinary ??= resolvePython();
+    const pyBinary = await cachedPyBinary;
+    if (!pyBinary) return null;
     const { code, stdout } = await spawnPyParser(
-      _cachedPyBinary,
+      pyBinary,
       _cachedScriptPath,
       filePath,
       content
@@ -2342,30 +2990,39 @@ async function syncPyParse(filePath, content, lang) {
     }));
     return { file: filePath, lang, symbols, mtimeMs: Date.now() };
   } catch {
-    return { file: filePath, lang, symbols: [], mtimeMs: Date.now() };
+    return null;
   }
 }
 
 // src/codebase-index/rs-parser.ts
-import { expectDefined as expectDefined2 } from "@wrongstack/core";
-import { execFileSync, spawn as spawn3 } from "node:child_process";
+import { expectDefined as expectDefined2 } from "@wrongstack/core/utils";
+import { execFile, spawn as spawn3 } from "node:child_process";
 import * as fs5 from "node:fs/promises";
-import * as path5 from "node:path";
-async function parseSymbols4(opts) {
+import * as path6 from "node:path";
+async function parseSymbols5(opts) {
   const { file, content, lang } = opts;
-  const nativeAvailable = checkNativeParser();
+  const nativeAvailable = await checkNativeParser();
   if (nativeAvailable) {
-    const result = await tryNativeParse(file, content);
+    const result = await withSpawnGate(() => tryNativeParse(file, content));
     if (result) return result;
   }
   return regexParse({ file, content, lang });
 }
+var nativeParserAvailability;
+function probe(command, args) {
+  return new Promise((resolve2, reject) => {
+    execFile(command, args, { timeout: 1e4, windowsHide: true }, (error) => {
+      if (error) reject(error);
+      else resolve2();
+    });
+  });
+}
 function checkNativeParser() {
-  try {
-    execFileSync("rustc", ["--version"], { stdio: "pipe", windowsHide: true });
-    const toolsDir = path5.join(process.cwd(), "tools");
+  nativeParserAvailability ??= (async () => {
     try {
-      execFileSync(
+      await probe("rustc", ["--version"]);
+      const toolsDir = path6.join(process.cwd(), "tools");
+      await probe(
         "cargo",
         [
           "metadata",
@@ -2373,23 +3030,21 @@ function checkNativeParser() {
           "--format-version",
           "1",
           "--manifest-path",
-          path5.join(toolsDir, "Cargo.toml")
-        ],
-        { stdio: "pipe", windowsHide: true }
+          path6.join(toolsDir, "Cargo.toml")
+        ]
       );
       return true;
     } catch {
       return false;
     }
-  } catch {
-    return false;
-  }
+  })();
+  return nativeParserAvailability;
 }
 async function tryNativeParse(file, content) {
   try {
-    const toolsDir = path5.join(process.cwd(), "tools");
-    const crateDir = path5.join(toolsDir, "syn-parser");
-    const tmpFile = path5.join(crateDir, "src", "input.rs");
+    const toolsDir = path6.join(process.cwd(), "tools");
+    const crateDir = path6.join(toolsDir, "syn-parser");
+    const tmpFile = path6.join(crateDir, "src", "input.rs");
     await fs5.writeFile(tmpFile, content, "utf8");
     const cargoBinary = resolveWin32Command("cargo");
     const result = await new Promise(
@@ -2397,7 +3052,7 @@ async function tryNativeParse(file, content) {
         let settled = false;
         const proc = spawn3(
           cargoBinary,
-          ["run", "--manifest-path", path5.join(toolsDir, "Cargo.toml")],
+          ["run", "--manifest-path", path6.join(toolsDir, "Cargo.toml")],
           {
             cwd: process.cwd(),
             stdio: ["pipe", "pipe", "pipe"],
@@ -2511,9 +3166,9 @@ function regexParse(opts) {
 }
 
 // src/codebase-index/json-parser.ts
-import { expectDefined as expectDefined3 } from "@wrongstack/core";
-import * as path6 from "node:path";
-function parseSymbols5(opts) {
+import { expectDefined as expectDefined3 } from "@wrongstack/core/utils";
+import * as path7 from "node:path";
+function parseSymbols6(opts) {
   const { file, content, lang } = opts;
   try {
     return regexParse2({ file, content, lang });
@@ -2524,9 +3179,9 @@ function parseSymbols5(opts) {
 function regexParse2(opts) {
   const { file, content, lang } = opts;
   const symbols = [];
-  const basename3 = path6.basename(file).toLowerCase();
-  const isPackageJson = basename3 === "package.json";
-  const isTsconfig = basename3 === "tsconfig.json" || basename3 === "tsconfig.build.json";
+  const basename4 = path7.basename(file).toLowerCase();
+  const isPackageJson = basename4 === "package.json";
+  const isTsconfig = basename4 === "tsconfig.json" || basename4 === "tsconfig.build.json";
   const isJsonSchema = content.includes("$schema") || content.includes("$id") || content.includes("$ref");
   const isOpenApi = content.includes("openapi") || content.includes("swagger");
   const lines = content.split("\n");
@@ -2550,11 +3205,11 @@ function regexParse2(opts) {
     const line = lineFromOffset(offset);
     symbols.push(
       makeSymbol({
-        name: path6.basename(file),
+        name: path7.basename(file),
         kind: "object",
         line,
         col: 0,
-        signature: `"${path6.basename(file)}" = { ... }`,
+        signature: `"${path7.basename(file)}" = { ... }`,
         file,
         lang
       })
@@ -2716,8 +3371,8 @@ function makeSymbol(opts) {
 }
 
 // src/codebase-index/yaml-parser.ts
-import { expectDefined as expectDefined4, truncate } from "@wrongstack/core";
-function parseSymbols6(opts) {
+import { expectDefined as expectDefined4, truncate } from "@wrongstack/core/utils";
+function parseSymbols7(opts) {
   const { file, content, lang } = opts;
   try {
     return regexParse3({ file, content, lang });
@@ -2866,8 +3521,8 @@ function makeSymbol2(opts) {
 
 // src/codebase-index/gitignore.ts
 import * as fs6 from "node:fs/promises";
-import * as path7 from "node:path";
-import { compileGlob } from "@wrongstack/core";
+import * as path8 from "node:path";
+import { compileGlob } from "@wrongstack/core/utils";
 function globBody(glob) {
   return compileGlob(glob).source.replace(/^\^/, "").replace(/\$$/, "");
 }
@@ -2912,7 +3567,7 @@ function compileGitignore(lines) {
 async function loadGitignoreMatcher(projectRoot) {
   let lines = [];
   try {
-    const raw = await fs6.readFile(path7.join(projectRoot, ".gitignore"), "utf8");
+    const raw = await fs6.readFile(path8.join(projectRoot, ".gitignore"), "utf8");
     lines = raw.split("\n");
   } catch {
   }
@@ -2921,7 +3576,9 @@ async function loadGitignoreMatcher(projectRoot) {
 
 // src/codebase-index/indexer.ts
 var YIELD_EVERY_N = 50;
-var PARALLEL_BATCH = Math.min(availableParallelism() * 4, 40);
+function resolveParallelBatch() {
+  return indexParallelBatchSize(availableParallelism());
+}
 function yieldEventLoop() {
   return new Promise((resolve2) => setImmediate(resolve2));
 }
@@ -2947,8 +3604,8 @@ var DEFAULT_IGNORE = [
 var DEFAULT_IGNORE_FILES = /* @__PURE__ */ new Set(["package-lock.json", "pnpm-lock.yaml", "pnpm-lock.yml"]);
 var MAX_INDEX_FILE_BYTES = 5 * 1024 * 1024;
 function isWithinProject(projectRoot, file) {
-  const rel = path8.relative(projectRoot, file);
-  return rel !== "" && !rel.startsWith(`..${path8.sep}`) && rel !== ".." && !path8.isAbsolute(rel);
+  const rel = path9.relative(projectRoot, file);
+  return rel !== "" && !rel.startsWith(`..${path9.sep}`) && rel !== ".." && !path9.isAbsolute(rel);
 }
 function isMissingPathError(err) {
   const code = err?.code;
@@ -2959,18 +3616,7 @@ async function findSourceFiles(projectRoot, ignore, isGitIgnored, signal) {
   const errors = [];
   let complete = true;
   const ignoreSet = /* @__PURE__ */ new Set([...DEFAULT_IGNORE, ...ignore]);
-  const globs = [
-    { ext: ".ts", pat: compileGlob2("**/*.ts") },
-    { ext: ".tsx", pat: compileGlob2("**/*.tsx") },
-    { ext: ".js", pat: compileGlob2("**/*.js") },
-    { ext: ".jsx", pat: compileGlob2("**/*.jsx") },
-    { ext: ".go", pat: compileGlob2("**/*.go") },
-    { ext: ".py", pat: compileGlob2("**/*.py") },
-    { ext: ".rs", pat: compileGlob2("**/*.rs") },
-    { ext: ".json", pat: compileGlob2("**/*.json") },
-    { ext: ".yaml", pat: compileGlob2("**/*.yaml") },
-    { ext: ".yml", pat: compileGlob2("**/*.yml") }
-  ];
+  const indexableExts = new Set(INDEXABLE_EXTENSIONS);
   let dirCount = 0;
   const walk = async (dir) => {
     throwIfAborted(signal);
@@ -2989,19 +3635,16 @@ async function findSourceFiles(projectRoot, ignore, isGitIgnored, signal) {
     dirCount++;
     for (const e of entries) {
       if (ignoreSet.has(e.name)) continue;
-      const full = path8.join(dir, e.name);
-      const rel = path8.relative(projectRoot, full).replace(/\\/g, "/");
+      const full = path9.join(dir, e.name);
+      const rel = path9.relative(projectRoot, full).replace(/\\/g, "/");
       if (e.isDirectory()) {
         if (isGitIgnored(rel, true)) continue;
         await walk(full);
       } else if (e.isFile()) {
         if (DEFAULT_IGNORE_FILES.has(e.name) || isGitIgnored(rel, false)) continue;
-        const ext = path8.extname(e.name).toLowerCase();
-        for (const { ext: extName, pat } of globs) {
-          if (ext === extName && (pat.test(rel) || pat.test(e.name))) {
-            results.push(full);
-            break;
-          }
+        const ext = path9.extname(e.name).toLowerCase();
+        if (indexableExts.has(ext) || detectLang(full) !== null) {
+          results.push(full);
         }
       }
     }
@@ -3010,24 +3653,25 @@ async function findSourceFiles(projectRoot, ignore, isGitIgnored, signal) {
   return { files: results, complete, errors };
 }
 async function parseFile(file, content, lang) {
-  switch (lang) {
+  const symbolLang = lang;
+  switch (symbolLang) {
     case "ts":
     case "tsx":
     case "js":
     case "jsx":
-      return parseSymbols({ file, content, lang });
+      return parseSymbols({ file, content, lang: symbolLang });
     case "go":
       return parseSymbols2({ file, content, lang: "go" });
     case "py":
-      return parseSymbols3({ file, content, lang: "py" });
+      return parseSymbols4({ file, content, lang: "py" });
     case "rs":
-      return parseSymbols4({ file, content, lang: "rs" });
+      return parseSymbols5({ file, content, lang: "rs" });
     case "json":
-      return parseSymbols5({ file, content, lang: "json" });
+      return parseSymbols6({ file, content, lang: "json" });
     case "yaml":
-      return parseSymbols6({ file, content, lang: "yaml" });
+      return parseSymbols7({ file, content, lang: "yaml" });
     default:
-      return { file, lang, symbols: [], mtimeMs: Date.now() };
+      return parseSymbols3({ file, content, lang: symbolLang });
   }
 }
 function assignRefsToSymbols2(refs, symbols) {
@@ -3075,10 +3719,10 @@ async function runIndexerWithStore(store, opts) {
   let discoveredFiles = null;
   let discoveryComplete = true;
   if (opts.files && opts.files.length > 0) {
-    files = opts.files.map((f) => path8.resolve(projectRoot, f)).filter((f) => {
+    files = opts.files.map((f) => path9.resolve(projectRoot, f)).filter((f) => {
       if (!isWithinProject(projectRoot, f)) return false;
-      const rel = path8.relative(projectRoot, f).replace(/\\/g, "/");
-      return !rel.split("/").some((seg) => DEFAULT_IGNORE.includes(seg)) && !DEFAULT_IGNORE_FILES.has(path8.basename(f)) && !isGitIgnored(rel, false);
+      const rel = path9.relative(projectRoot, f).replace(/\\/g, "/");
+      return !rel.split("/").some((seg) => DEFAULT_IGNORE.includes(seg)) && !DEFAULT_IGNORE_FILES.has(path9.basename(f)) && !isGitIgnored(rel, false);
     });
   } else {
     const discovery = await findSourceFiles(projectRoot, ignore, isGitIgnored, signal);
@@ -3099,15 +3743,19 @@ async function runIndexerWithStore(store, opts) {
   if (!force) {
     for (const meta of store.getAllFileMetas()) existingMeta.set(meta.file, meta);
   }
+  const parallelBatch = resolveParallelBatch();
   let filesSinceLastYield = 0;
-  for (let batchStart = 0; batchStart < files.length; batchStart += PARALLEL_BATCH) {
-    const batchEnd = Math.min(batchStart + PARALLEL_BATCH, files.length);
+  for (let batchStart = 0; batchStart < files.length; batchStart += parallelBatch) {
+    const batchEnd = Math.min(batchStart + parallelBatch, files.length);
     const batchFiles = files.slice(batchStart, batchEnd);
     opts.onProgress?.(batchEnd, files.length);
     filesSinceLastYield += batchFiles.length;
     if (filesSinceLastYield >= YIELD_EVERY_N) {
       filesSinceLastYield = 0;
       await yieldEventLoop();
+      if (isFrugalPerf()) {
+        await new Promise((r) => setTimeout(r, 8));
+      }
       throwIfAborted(signal);
     }
     const statOpts = signal ? { signal } : {};
@@ -3211,9 +3859,7 @@ async function runIndexerWithStore(store, opts) {
         continue;
       }
       if (parsed.symbols.length === 0) {
-        store.deleteRefsForFile(file);
-        store.deleteSymbolsForFile(file);
-        store.upsertFile({
+        store.replaceEmptyFile({
           file,
           lang,
           mtimeMs: Math.floor(stat2.mtimeMs),
@@ -3282,6 +3928,7 @@ async function runIndexerWithStore(store, opts) {
   }
   store.resolveRefs();
   store.setMetadata("relation_graph_version", relationGraphVersion);
+  store.optimize();
   const durationMs = Date.now() - startMs;
   store.setLastIndexed(Date.now());
   return {
@@ -3572,10 +4219,10 @@ async function callInline(op, args, opts) {
     opts.signal?.removeEventListener("abort", onOuterAbort);
   }
 }
-var chain = Promise.resolve();
+var chain2 = Promise.resolve();
 function withMutex(job) {
-  const run = chain.then(job, job);
-  chain = run.then(
+  const run = chain2.then(job, job);
+  chain2 = run.then(
     () => void 0,
     () => void 0
   );
@@ -3589,11 +4236,62 @@ function circuitOpenError() {
 }
 var DEFAULT_DEBOUNCE_MS = 400;
 var debounceTimers = /* @__PURE__ */ new Map();
-function debounceKey(indexDir, file) {
-  return `${indexDir ?? ""}|${file}`;
+var readyReindexBatches = /* @__PURE__ */ new Map();
+function debounceKey(projectRoot, indexDir, file) {
+  return JSON.stringify([projectRoot, indexDir ?? "", file]);
+}
+function reindexBatchKey(projectRoot, indexDir) {
+  return JSON.stringify([projectRoot, indexDir ?? ""]);
+}
+function flushReadyReindexBatch(key) {
+  const batch = readyReindexBatches.get(key);
+  if (!batch) return;
+  readyReindexBatches.delete(key);
+  if (!indexCircuitBreaker.allowRequest()) {
+    const error = circuitOpenError();
+    for (const onError of batch.onErrors) onError(error);
+    return;
+  }
+  void withMutex(
+    () => callIndexOp(
+      "index",
+      {
+        projectRoot: batch.projectRoot,
+        files: [...batch.files].sort(),
+        indexDir: batch.indexDir
+      },
+      { timeoutMs: batch.timeoutMs }
+    )
+  ).then(
+    () => indexCircuitBreaker.recordSuccess(),
+    (err) => {
+      indexCircuitBreaker.recordFailure(err);
+      for (const onError of batch.onErrors) onError(err);
+    }
+  );
+}
+function addReadyReindex(opts) {
+  const key = reindexBatchKey(opts.projectRoot, opts.indexDir);
+  const existing = readyReindexBatches.get(key);
+  if (existing) {
+    existing.files.add(opts.file);
+    existing.timeoutMs = Math.max(existing.timeoutMs, opts.timeoutMs);
+    if (opts.onError) existing.onErrors.add(opts.onError);
+    return;
+  }
+  const batch = {
+    projectRoot: opts.projectRoot,
+    indexDir: opts.indexDir,
+    files: /* @__PURE__ */ new Set([opts.file]),
+    timeoutMs: opts.timeoutMs,
+    onErrors: new Set(opts.onError ? [opts.onError] : [])
+  };
+  batch.flush = setImmediate(() => flushReadyReindexBatch(key));
+  batch.flush.unref?.();
+  readyReindexBatches.set(key, batch);
 }
 function isIndexableFile(filePath) {
-  return detectLang(filePath) !== null;
+  return isIndexablePath(filePath);
 }
 function isRecoverableConstraintError(err) {
   if (err instanceof Error) {
@@ -3653,28 +4351,18 @@ function enqueueReindex(opts) {
   if (files.length === 0) return;
   const ms = opts.debounceMs ?? DEFAULT_DEBOUNCE_MS;
   for (const file of files) {
-    const key = debounceKey(opts.indexDir, file);
+    const key = debounceKey(opts.projectRoot, opts.indexDir, file);
     const existing = debounceTimers.get(key);
     if (existing) clearTimeout(existing);
     const timer = setTimeout(() => {
       debounceTimers.delete(key);
-      if (!indexCircuitBreaker.allowRequest()) {
-        opts.onError?.(circuitOpenError());
-        return;
-      }
-      void withMutex(
-        () => callIndexOp(
-          "index",
-          { projectRoot: opts.projectRoot, files: [file], indexDir: opts.indexDir },
-          { timeoutMs: opts.timeoutMs ?? DEFAULT_INCREMENTAL_TIMEOUT_MS }
-        )
-      ).then(
-        () => indexCircuitBreaker.recordSuccess(),
-        (err) => {
-          indexCircuitBreaker.recordFailure(err);
-          opts.onError?.(err);
-        }
-      );
+      addReadyReindex({
+        projectRoot: opts.projectRoot,
+        file,
+        indexDir: opts.indexDir,
+        timeoutMs: opts.timeoutMs ?? DEFAULT_INCREMENTAL_TIMEOUT_MS,
+        onError: opts.onError
+      });
     }, ms);
     timer.unref?.();
     debounceTimers.set(key, timer);
@@ -3683,6 +4371,10 @@ function enqueueReindex(opts) {
 function cancelPendingReindexes() {
   for (const t of debounceTimers.values()) clearTimeout(t);
   debounceTimers.clear();
+  for (const batch of readyReindexBatches.values()) {
+    if (batch.flush) clearImmediate(batch.flush);
+  }
+  readyReindexBatches.clear();
 }
 async function searchCodebaseIndex(args, opts = {}) {
   return callIndexOp("search", args, {
@@ -3967,6 +4659,7 @@ var codebaseStatsTool = {
 };
 export {
   CircuitOpenError,
+  INDEXABLE_EXTENSIONS,
   IndexCircuitBreaker,
   IndexStore,
   IndexTimeoutError,
@@ -3979,6 +4672,7 @@ export {
   codebaseIndexTool,
   codebaseSearchTool,
   codebaseStatsTool,
+  detectLang,
   enqueueReindex,
   fileGraphService,
   getIndexState,
@@ -3986,6 +4680,7 @@ export {
   internalKindToLspKind,
   isIndexReady,
   isIndexableFile,
+  isIndexablePath,
   isIndexing,
   lspKindToInternalKind,
   onIndexStateChange,