@wrongstack/tools 0.236.0 → 0.255.0

package/dist/codebase-index/index.js

@@ -1,17 +1,102 @@
-import { resolveWstackPaths, expectDefined, compileGlob } from '@wrongstack/core';
-import * as fs3 from 'node:fs/promises';
-import * as path4 from 'node:path';
+import { resolveWstackPaths, expectDefined, compileGlob, truncate } from '@wrongstack/core';
 import { createRequire } from 'node:module';
 import * as fs from 'node:fs';
 import { writeFileSync, mkdirSync } from 'node:fs';
+import * as path4 from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Worker } from 'node:worker_threads';
+import * as fs3 from 'node:fs/promises';
 import * as ts from 'typescript';
 import { execFileSync, spawnSync } from 'node:child_process';
 import * as os from 'node:os';
 
-// src/codebase-index/indexer.ts
+// src/codebase-index/writer.ts
+
+// src/codebase-index/circuit-breaker.ts
+var CircuitOpenError = class extends Error {
+  name = "CircuitOpenError";
+};
+var IndexTimeoutError = class extends Error {
+  name = "IndexTimeoutError";
+};
+var LockError = class extends Error {
+  name = "LockError";
+};
+var IndexCircuitBreaker = class {
+  failureThreshold;
+  cooldownMs;
+  now;
+  state = "closed";
+  consecutiveFailures = 0;
+  openedAt = 0;
+  lastFailure = null;
+  probeInFlight = false;
+  constructor(opts = {}) {
+    this.failureThreshold = opts.failureThreshold ?? 3;
+    this.cooldownMs = opts.cooldownMs ?? 6e4;
+    this.now = opts.now ?? Date.now;
+  }
+  /**
+   * True when a run may proceed. An open circuit transitions to half-open once
+   * the cooldown has elapsed, admitting exactly one probe; further requests
+   * are rejected until that probe settles via recordSuccess/recordFailure.
+   */
+  allowRequest() {
+    if (this.state === "closed") return true;
+    if (this.state === "open") {
+      if (this.now() - this.openedAt < this.cooldownMs) return false;
+      this.state = "half-open";
+      this.probeInFlight = true;
+      return true;
+    }
+    if (this.probeInFlight) return false;
+    this.probeInFlight = true;
+    return true;
+  }
+  recordSuccess() {
+    this.state = "closed";
+    this.consecutiveFailures = 0;
+    this.lastFailure = null;
+    this.probeInFlight = false;
+  }
+  recordFailure(err) {
+    if (err instanceof LockError) {
+      this.lastFailure = `[transient/lock] ${err.message}`;
+      this.probeInFlight = false;
+      return;
+    }
+    this.lastFailure = err instanceof Error ? err.message : String(err);
+    this.probeInFlight = false;
+    this.consecutiveFailures++;
+    if (this.state === "half-open" || this.consecutiveFailures >= this.failureThreshold) {
+      this.state = "open";
+      this.openedAt = this.now();
+    }
+  }
+  /** Force-close the circuit (manual recovery: `/codebase-reindex`). */
+  reset() {
+    this.state = "closed";
+    this.consecutiveFailures = 0;
+    this.lastFailure = null;
+    this.probeInFlight = false;
+    this.openedAt = 0;
+  }
+  snapshot() {
+    return {
+      state: this.state,
+      consecutiveFailures: this.consecutiveFailures,
+      lastFailure: this.lastFailure,
+      cooldownRemainingMs: this.state === "open" ? Math.max(0, this.cooldownMs - (this.now() - this.openedAt)) : 0
+    };
+  }
+};
+var indexCircuitBreaker = new IndexCircuitBreaker();
+function resetIndexCircuitBreaker() {
+  indexCircuitBreaker.reset();
+}
 
 // src/codebase-index/schema.ts
-var SCHEMA_VERSION = 1;
+var SCHEMA_VERSION = 2;
 
 // src/codebase-index/lsp-kind.ts
 function lspKindToInternalKind(k) {
@@ -75,6 +160,94 @@ function internalKindToLspKind(k) {
   }
 }
 
+// src/codebase-index/bm25.ts
+var K1 = 1.5;
+var B = 0.75;
+function tokenise(text) {
+  const sanitised = text.replace(/[^\p{L}\p{N}$'_]/gu, " ").replace(/_/g, " ");
+  return sanitised.toLowerCase().split(" ").filter(Boolean);
+}
+function splitName(name) {
+  return name.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").trim();
+}
+function buildIndexableText(name, signature, docComment) {
+  return [splitName(name), name, signature, docComment].filter(Boolean).join(" ");
+}
+function buildBm25Index(docs) {
+  const documents = docs.map((d) => {
+    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);
+}
+var Bm25Index = class {
+  constructor(documents, df, N, avgLen) {
+    this.documents = documents;
+    this.df = df;
+    this.N = N;
+    this.safeAvgLen = avgLen === 0 ? 1 : avgLen;
+  }
+  documents;
+  df;
+  N;
+  safeAvgLen;
+  score(query, filter) {
+    const qTokens = tokenise(query);
+    if (qTokens.length === 0) return [];
+    const results = [];
+    for (const doc of this.documents) {
+      if (filter && !filter(doc.id)) continue;
+      let docScore = 0;
+      for (const qTerm of qTokens) {
+        let tf = 0;
+        for (const t of doc.tokens) {
+          if (t === qTerm) tf++;
+        }
+        if (tf === 0) continue;
+        const dfVal = this.df[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);
+        const tfComponent = tf * (K1 + 1) / (tf + K1 * (1 - B + lenRatio));
+        docScore += idf * tfComponent;
+      }
+      if (docScore > 0) results.push({ id: doc.id, score: docScore });
+    }
+    return results;
+  }
+  getDoc(id) {
+    return this.documents.find((d) => d.id === id);
+  }
+  extractSnippet(docId, queryTokens, radius = 40) {
+    const doc = this.getDoc(docId);
+    if (!doc) return "";
+    for (const tok of queryTokens) {
+      const idx = doc.raw.toLowerCase().indexOf(tok);
+      if (idx !== -1) {
+        const start = Math.max(0, idx - radius);
+        const end = Math.min(doc.raw.length, idx + tok.length + radius);
+        const excerpt = doc.raw.slice(start, end);
+        const ellipsis = "\u2026";
+        return (start > 0 ? ellipsis : "") + excerpt + (end < doc.raw.length ? ellipsis : "");
+      }
+    }
+    return doc.raw.slice(0, radius * 2) + (doc.raw.length > radius * 2 ? "\u2026" : "");
+  }
+};
+
 // src/codebase-index/writer.ts
 var DB_FILE = "index.db";
 function resolveIndexDir(projectRoot, override) {
@@ -110,15 +283,79 @@ function loadDatabaseSync() {
   }
   return DatabaseSyncCtor;
 }
+var MAX_LOCK_RETRIES = 3;
+var LOCK_RETRY_BASE_DELAY_MS = 50;
+var LOCK_RETRY_MAX_DELAY_MS = 500;
+function isLockError(err) {
+  if (!(err instanceof Error)) return false;
+  const e = err;
+  const code = e.code ?? e.sqliteCode;
+  if (typeof code === "string" && /SQLITE_(BUSY|LOCKED)/.test(code)) return true;
+  if (typeof code === "number" && (code === 5 || code === 6)) return true;
+  if (/SQLITE_(BUSY|LOCKED)/.test(err.message)) return true;
+  return false;
+}
+function sleepSync(ms) {
+  try {
+    const sab = new SharedArrayBuffer(4);
+    const view = new Int32Array(sab);
+    Atomics.wait(view, 0, 0, ms);
+  } catch {
+  }
+}
 var IndexStore = class {
   db;
   /** Absolute path to this project's index directory. */
   indexDir;
+  /**
+   * True when the SQLite build provides FTS5 (Node's bundled SQLite does).
+   * When false, ranked search falls back to the LIKE + in-process BM25 path.
+   */
+  ftsAvailable = false;
+  /**
+   * Execute a SQLite write operation with automatic retry on lock conflicts.
+   *
+   * When another wstack process is holding the write lock the statement first
+   * waits up to `busy_timeout` ms, then throws SQLITE_BUSY.  This wrapper catches
+   * that error and retries (up to MAX_LOCK_RETRIES) with exponential backoff,
+   * giving the competing writer time to finish and release the lock.
+   *
+   * @param fn  The write operation to execute. Can return a value which is
+   *            returned to the caller on success.
+   * @throws   {@link LockError} when all retries are exhausted on a lock conflict
+   *            (non-lock errors always propagate on the first attempt).
+   */
+  runWithRetry(fn) {
+    let lastError;
+    for (let attempt = 0; attempt <= MAX_LOCK_RETRIES; attempt++) {
+      try {
+        return fn();
+      } catch (err) {
+        lastError = err;
+        if (!isLockError(err)) throw err;
+        if (attempt === MAX_LOCK_RETRIES) {
+          const msg = lastError instanceof Error ? lastError.message : String(lastError);
+          throw new LockError(`SQLite lock conflict after ${MAX_LOCK_RETRIES} retries: ${msg}`);
+        }
+        const delay = Math.min(
+          LOCK_RETRY_BASE_DELAY_MS * Math.pow(2, attempt),
+          LOCK_RETRY_MAX_DELAY_MS
+        );
+        sleepSync(delay);
+      }
+    }
+    throw lastError;
+  }
   constructor(projectRoot, opts = {}) {
     this.indexDir = resolveIndexDir(projectRoot, opts.indexDir);
     fs.mkdirSync(this.indexDir, { recursive: true });
     const Database = loadDatabaseSync();
     this.db = new Database(path4.join(this.indexDir, DB_FILE));
+    try {
+      this.db.exec("PRAGMA journal_mode = WAL");
+      this.db.exec("PRAGMA busy_timeout = 5000");
+    } catch {
+    }
     this.initSchema();
   }
   initSchema() {
@@ -127,6 +364,21 @@ var IndexStore = class {
         key TEXT PRIMARY KEY,
         value TEXT NOT NULL
       );
+    `);
+    const storedRows = this.db.prepare("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(`
+        DROP TABLE IF EXISTS symbols;
+        DROP TABLE IF EXISTS files;
+        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");
+    } else if (storedVersion === null) {
+      this.db.prepare("INSERT INTO metadata(key, value) VALUES (?, ?)").run("version", String(SCHEMA_VERSION));
+    }
+    this.db.exec(`
       CREATE TABLE IF NOT EXISTS files (
         file TEXT PRIMARY KEY,
         lang TEXT NOT NULL,
@@ -167,53 +419,76 @@ var IndexStore = class {
     this.db.exec("CREATE INDEX IF NOT EXISTS idx_r_to_id ON refs(to_id)");
     this.db.exec("CREATE INDEX IF NOT EXISTS idx_r_to_name ON refs(to_name)");
     this.db.exec("CREATE INDEX IF NOT EXISTS idx_r_call_type ON refs(call_type)");
-    const versionRows = this.db.prepare("SELECT value FROM metadata WHERE key = ?").all("version");
-    if (!versionRows.length) {
-      this.db.prepare("INSERT INTO metadata(key, value) VALUES (?, ?)").run("version", String(SCHEMA_VERSION));
+    try {
+      this.db.exec("CREATE VIRTUAL TABLE IF NOT EXISTS symbols_fts USING fts5(text, tokenize = 'unicode61')");
+      this.ftsAvailable = true;
+    } catch {
+      this.ftsAvailable = false;
     }
   }
   // ─── Symbol CRUD ─────────────────────────────────────────────────────────────
   insertSymbols(symbols, nextId) {
-    const stmt = this.db.prepare(
-      `INSERT INTO symbols(id, lang, kind, name, file, line, col, signature, doc_comment, scope, text, file_fk)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
-    );
-    let id = nextId;
-    for (const s of symbols) {
-      stmt.run(
-        id++,
-        s.lang,
-        s.kind,
-        s.name,
-        s.file,
-        s.line,
-        s.col,
-        s.signature,
-        s.docComment,
-        s.scope,
-        s.text,
-        s.file
+    return this.runWithRetry(() => {
+      const stmt = this.db.prepare(
+        `INSERT INTO symbols(id, lang, kind, name, file, line, col, signature, doc_comment, scope, text, file_fk)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
       );
-    }
-    return id;
+      const ftsStmt = this.ftsAvailable ? this.db.prepare("INSERT INTO symbols_fts(rowid, text) VALUES (?, ?)") : null;
+      let id = nextId;
+      for (const s of symbols) {
+        stmt.run(
+          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));
+        id++;
+      }
+      return id;
+    });
   }
   deleteSymbolsForFile(file) {
-    this.db.prepare("DELETE FROM symbols WHERE file_fk = ?").run(file);
+    this.runWithRetry(() => {
+      if (this.ftsAvailable) {
+        this.db.prepare("DELETE FROM symbols_fts WHERE rowid IN (SELECT id FROM symbols WHERE file_fk = ?)").run(file);
+      }
+      this.db.prepare("DELETE FROM symbols WHERE file_fk = ?").run(file);
+    });
   }
+  /**
+   * Remove every trace of a file (refs, symbols, FTS rows, file meta). Used
+   * when a source file disappears between index runs — previously this only
+   * dropped the `files` row, leaving its symbols orphaned but still searchable.
+   */
   deleteFile(file) {
-    this.db.prepare("DELETE FROM files WHERE file = ?").run(file);
+    this.runWithRetry(() => {
+      this.deleteRefsForFile(file);
+      this.deleteSymbolsForFile(file);
+      this.db.prepare("DELETE FROM files WHERE file = ?").run(file);
+    });
   }
   // ─── File metadata ──────────────────────────────────────────────────────────
   upsertFile(meta) {
-    this.db.prepare(
-      `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.runWithRetry(() => {
+      this.db.prepare(
+        `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);
+    });
   }
   getFileMeta(file) {
     const rows = this.db.prepare(
@@ -280,6 +555,94 @@ var IndexStore = class {
       lspKind: filter?.lspKind
     }));
   }
+  /**
+   * Ranked search — the one-stop query the codebase-search tool and plug-lsp
+   * use. With FTS5 this is a single indexed `MATCH` ranked by SQLite's native
+   * `bm25()` with a built-in `snippet()`; without FTS5 it falls back to the
+   * legacy LIKE scan + in-process BM25 (identical semantics, slower).
+   *
+   * Tokens are matched as prefixes (`"tok"*`), mirroring the old
+   * `LIKE '%tok%'` recall for the common symbol-search shapes ("user" finds
+   * "users", camelCase-split text makes "complex" find "complexOperation").
+   */
+  searchRanked(query, filter, limit) {
+    const tokens = tokenise(query);
+    if (tokens.length === 0 || !this.ftsAvailable) {
+      return this.searchRankedFallback(query, filter, limit);
+    }
+    let effectiveKind = filter?.kind;
+    if (filter?.lspKind !== void 0) {
+      const mapped = lspKindToInternalKind(filter.lspKind);
+      if (mapped === null) return { results: [], total: 0 };
+      effectiveKind = mapped;
+    }
+    const match = tokens.map((t) => `"${t.replaceAll('"', "")}"*`).join(" OR ");
+    const conditions = ["symbols_fts MATCH ?"];
+    const values = [match];
+    if (effectiveKind) {
+      conditions.push("s.kind = ?");
+      values.push(effectiveKind);
+    }
+    if (filter?.lang) {
+      conditions.push("s.lang = ?");
+      values.push(filter.lang);
+    }
+    if (filter?.file) {
+      conditions.push("s.file LIKE ?");
+      values.push(`%${filter.file}%`);
+    }
+    const where = conditions.join(" AND ");
+    const countRows = this.db.prepare(`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(
+      `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
+         FROM symbols_fts JOIN symbols s ON s.id = symbols_fts.rowid
+         WHERE ${where}
+         ORDER BY bm25(symbols_fts)
+         LIMIT ?`
+    ).all(...values, limit);
+    return {
+      results: 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,
+        // bm25() is negative-is-better; negate so callers keep "higher is
+        // better" and clamp so a match never reports a zero score.
+        score: Math.max(1e-4, r.score),
+        snippet: r.snippet,
+        lspKind: filter?.lspKind
+      })),
+      total
+    };
+  }
+  /** 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 bm25 = buildBm25Index(
+      candidates.map((c) => ({ id: c.id, text: buildIndexableText(c.name, c.signature, c.docComment) }))
+    );
+    const scored = bm25.score(query, (id) => candidates.some((c) => c.id === id));
+    scored.sort((a, b) => b.score - a.score);
+    const qTokens = tokenise(query);
+    const results = scored.slice(0, limit).map(({ id, score }) => {
+      const c = expectDefined(candidates.find((cand) => cand.id === id));
+      return { ...c, score, snippet: bm25.extractSnippet(id, qTokens) };
+    });
+    return { results, total: candidates.length };
+  }
   getAllIndexable() {
     return this.db.prepare("SELECT id, text FROM symbols").all().map(
       ({ id, text }) => ({ id, text })
@@ -329,14 +692,19 @@ var IndexStore = class {
     };
   }
   setLastIndexed(ts2) {
-    this.db.prepare(
-      "INSERT OR REPLACE INTO metadata(key, value) VALUES('last_indexed', ?)"
-    ).run(String(ts2));
+    this.runWithRetry(() => {
+      this.db.prepare(
+        "INSERT OR REPLACE INTO metadata(key, value) VALUES('last_indexed', ?)"
+      ).run(String(ts2));
+    });
   }
   clearAll() {
-    this.db.exec("DELETE FROM symbols");
-    this.db.exec("DELETE FROM files");
-    this.db.exec("DELETE FROM refs");
+    this.runWithRetry(() => {
+      this.db.exec("DELETE FROM symbols");
+      this.db.exec("DELETE FROM files");
+      this.db.exec("DELETE FROM refs");
+      if (this.ftsAvailable) this.db.exec("DELETE FROM symbols_fts");
+    });
   }
   // ─── Ref CRUD ────────────────────────────────────────────────────────────────
   /**
@@ -344,46 +712,52 @@ var IndexStore = class {
    * Replaces any existing refs from the same source (idempotent on re-index).
    */
   insertRefs(fromId, refs) {
-    this.db.prepare("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.runWithRetry(() => {
+      this.db.prepare("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);
+      }
+    });
   }
   /**
    * Delete all refs whose source symbols are in a given file.
    * Used when re-indexing a file to clear stale refs.
    */
   deleteRefsForFile(file) {
-    const ids = this.db.prepare(
-      "SELECT id FROM symbols WHERE file = ?"
-    ).all(file);
-    if (!ids.length) return;
-    const placeholders = ids.map(() => "?").join(",");
-    this.db.prepare(`DELETE FROM refs WHERE from_id IN (${placeholders})`).run(...ids.map((r) => r.id));
+    this.runWithRetry(() => {
+      const ids = this.db.prepare(
+        "SELECT id FROM symbols WHERE file = ?"
+      ).all(file);
+      if (!ids.length) return;
+      const placeholders = ids.map(() => "?").join(",");
+      this.db.prepare(`DELETE FROM refs WHERE from_id IN (${placeholders})`).run(...ids.map((r) => r.id));
+    });
   }
   /**
    * Resolve `to_name` → `to_id` for all refs that have a name but no id.
    * Call this after all symbols have been inserted to fill in cross-references.
    */
   resolveRefs() {
-    const unresolved = this.db.prepare(
-      "SELECT id, to_name FROM refs WHERE to_id IS NULL AND to_name IS NOT NULL"
-    ).all();
-    let resolved = 0;
-    for (const row of unresolved) {
-      const target = this.db.prepare("SELECT id FROM symbols WHERE name = ? LIMIT 1").all(row.to_name);
-      const first = target[0];
-      if (first) {
-        this.db.prepare("UPDATE refs SET to_id = ? WHERE id = ?").run(first.id, row.id);
-        resolved++;
+    return this.runWithRetry(() => {
+      const unresolved = this.db.prepare(
+        "SELECT id, to_name FROM refs WHERE to_id IS NULL AND to_name IS NOT NULL"
+      ).all();
+      let resolved = 0;
+      for (const row of unresolved) {
+        const target = this.db.prepare("SELECT id FROM symbols WHERE name = ? LIMIT 1").all(row.to_name);
+        const first = target[0];
+        if (first) {
+          this.db.prepare("UPDATE refs SET to_id = ? WHERE id = ?").run(first.id, row.id);
+          resolved++;
+        }
       }
-    }
-    return resolved;
+      return resolved;
+    });
   }
   /**
    * Find all references TO a given symbol (who calls / uses this symbol?).
@@ -1144,7 +1518,7 @@ function parseSymbols4(opts) {
 }
 function checkNativeParser() {
   try {
-    execFileSync("rustc", ["--version"], { stdio: "pipe" });
+    execFileSync("rustc", ["--version"], { stdio: "pipe", windowsHide: true });
     const toolsDir = path4.join(process.cwd(), "tools");
     try {
       execFileSync(
@@ -1157,7 +1531,7 @@ function checkNativeParser() {
           "--manifest-path",
           path4.join(toolsDir, "Cargo.toml")
         ],
-        { stdio: "pipe" }
+        { stdio: "pipe", windowsHide: true }
       );
       return true;
     } catch {
@@ -1180,7 +1554,8 @@ function tryNativeParse(file, content) {
         cwd: process.cwd(),
         encoding: "utf8",
         timeout: 15e3,
-        stdio: ["pipe", "pipe", "pipe"]
+        stdio: ["pipe", "pipe", "pipe"],
+        windowsHide: true
       }
     );
     if (result.status === 0 && result.stdout) {
@@ -1594,10 +1969,6 @@ function isScalar(value) {
   if (/^'[^']*'$/.test(value) || /^"[^"]*"$/.test(value)) return true;
   return false;
 }
-function truncate(s, max) {
-  if (s.length <= max) return s;
-  return s.slice(0, max) + "...";
-}
 function makeSymbol2(opts) {
   return {
     id: 0,
@@ -1664,136 +2035,16 @@ async function loadGitignoreMatcher(projectRoot) {
   return compileGitignore(lines);
 }
 
-// src/codebase-index/background-indexer.ts
-var _ready = false;
-var _indexing = false;
-var _currentFile = 0;
-var _totalFiles = 0;
-var _lastError = null;
-function isIndexReady() {
-  return _ready;
-}
-function setIndexReady() {
-  _ready = true;
-}
-function isIndexing() {
-  return _indexing;
-}
-function getIndexState() {
-  return {
-    ready: _ready,
-    indexing: _indexing,
-    currentFile: _currentFile,
-    totalFiles: _totalFiles,
-    lastError: _lastError
-  };
-}
-var _listeners = [];
-function onIndexStateChange(listener) {
-  _listeners.push(listener);
-  return () => {
-    _listeners = _listeners.filter((l) => l !== listener);
-  };
-}
-function emitState() {
-  const state = getIndexState();
-  for (const l of _listeners) l(state);
-}
-function _setIndexProgress(current, total) {
-  _currentFile = current;
-  _totalFiles = total;
-  emitState();
-}
-function stubCtx(projectRoot) {
-  return {
-    projectRoot,
-    cwd: projectRoot,
-    messages: [],
-    todos: [],
-    readFiles: /* @__PURE__ */ new Set(),
-    fileMtimes: /* @__PURE__ */ new Map()
-  };
+// src/codebase-index/indexer.ts
+var YIELD_EVERY_N = 50;
+function yieldEventLoop() {
+  return new Promise((resolve2) => setImmediate(resolve2));
 }
-var chain = Promise.resolve();
-function withMutex(job) {
-  const run = chain.then(job, job);
-  chain = run.then(
-    () => void 0,
-    () => void 0
-  );
-  return run;
-}
-var DEFAULT_DEBOUNCE_MS = 400;
-var debounceTimers = /* @__PURE__ */ new Map();
-function debounceKey(indexDir, file) {
-  return `${indexDir ?? ""}|${file}`;
-}
-function isIndexableFile(filePath) {
-  return detectLang(filePath) !== null;
-}
-async function runStartupIndex(opts) {
-  _indexing = true;
-  emitState();
-  try {
-    const result = await withMutex(() => {
-      _currentFile = 0;
-      _totalFiles = 0;
-      _lastError = null;
-      return runIndexer(stubCtx(opts.projectRoot), {
-        projectRoot: opts.projectRoot,
-        indexDir: opts.indexDir,
-        force: opts.force,
-        signal: opts.signal
-      });
-    });
-    _ready = true;
-    return result;
-  } catch (err) {
-    _lastError = err instanceof Error ? err.message : String(err);
-    _ready = true;
-    throw err;
-  } finally {
-    _indexing = false;
-    emitState();
-  }
-}
-function enqueueReindex(opts) {
-  const files = opts.files.filter(isIndexableFile);
-  if (files.length === 0) return;
-  const ms = opts.debounceMs ?? DEFAULT_DEBOUNCE_MS;
-  for (const file of files) {
-    const key = debounceKey(opts.indexDir, file);
-    const existing = debounceTimers.get(key);
-    if (existing) clearTimeout(existing);
-    const timer = setTimeout(() => {
-      debounceTimers.delete(key);
-      void withMutex(
-        () => runIndexer(stubCtx(opts.projectRoot), {
-          projectRoot: opts.projectRoot,
-          files: [file],
-          indexDir: opts.indexDir
-        })
-      ).catch((err) => opts.onError?.(err));
-    }, ms);
-    timer.unref?.();
-    debounceTimers.set(key, timer);
-  }
-}
-function cancelPendingReindexes() {
-  for (const t of debounceTimers.values()) clearTimeout(t);
-  debounceTimers.clear();
-}
-
-// src/codebase-index/indexer.ts
-var YIELD_EVERY_N = 50;
-function yieldEventLoop() {
-  return new Promise((resolve2) => setImmediate(resolve2));
-}
-function throwIfAborted(signal) {
-  if (!signal?.aborted) return;
-  if (signal.reason instanceof Error) throw signal.reason;
-  throw new Error(
-    typeof signal.reason === "string" ? signal.reason : "Indexing cancelled"
+function throwIfAborted(signal) {
+  if (!signal?.aborted) return;
+  if (signal.reason instanceof Error) throw signal.reason;
+  throw new Error(
+    typeof signal.reason === "string" ? signal.reason : "Indexing cancelled"
   );
 }
 function isAbortError(err) {
@@ -1921,7 +2172,7 @@ async function runIndexerWithStore(store, opts) {
   }
   for (let fi = 0; fi < files.length; fi++) {
     const file = expectDefined(files[fi]);
-    _setIndexProgress(fi + 1, files.length);
+    opts.onProgress?.(fi + 1, files.length);
     if (fi > 0 && fi % YIELD_EVERY_N === 0) {
       await yieldEventLoop();
       throwIfAborted(signal);
@@ -2016,6 +2267,365 @@ async function runIndexerWithStore(store, opts) {
   };
 }
 
+// src/codebase-index/index-service.ts
+function stubCtx(projectRoot) {
+  return {
+    projectRoot,
+    cwd: projectRoot,
+    messages: [],
+    todos: [],
+    readFiles: /* @__PURE__ */ new Set(),
+    fileMtimes: /* @__PURE__ */ new Map()
+  };
+}
+async function indexService(args, hooks = {}) {
+  return runIndexer(stubCtx(args.projectRoot), {
+    projectRoot: args.projectRoot,
+    indexDir: args.indexDir,
+    files: args.files,
+    force: args.force,
+    langs: args.langs,
+    ignore: args.ignore,
+    signal: hooks.signal,
+    onProgress: hooks.onProgress
+  });
+}
+function searchService(args) {
+  const store = new IndexStore(args.projectRoot, { indexDir: args.indexDir });
+  try {
+    return store.searchRanked(
+      args.query,
+      {
+        kind: args.kind,
+        lang: args.lang,
+        file: args.file,
+        lspKind: args.lspKind
+      },
+      args.limit
+    );
+  } finally {
+    store.close();
+  }
+}
+function statsService(args) {
+  const store = new IndexStore(args.projectRoot, { indexDir: args.indexDir });
+  try {
+    return store.getStats();
+  } finally {
+    store.close();
+  }
+}
+
+// src/codebase-index/background-indexer.ts
+var DEFAULT_FULL_INDEX_TIMEOUT_MS = 12e4;
+var DEFAULT_INCREMENTAL_TIMEOUT_MS = 3e4;
+var DEFAULT_QUERY_TIMEOUT_MS = 8e3;
+var _ready = false;
+var _indexing = false;
+var _currentFile = 0;
+var _totalFiles = 0;
+var _lastError = null;
+function isIndexReady() {
+  return _ready;
+}
+function isIndexing() {
+  return _indexing;
+}
+function getIndexState() {
+  return {
+    ready: _ready,
+    indexing: _indexing,
+    currentFile: _currentFile,
+    totalFiles: _totalFiles,
+    lastError: _lastError,
+    circuit: indexCircuitBreaker.snapshot()
+  };
+}
+var _listeners = [];
+function onIndexStateChange(listener) {
+  _listeners.push(listener);
+  return () => {
+    _listeners = _listeners.filter((l) => l !== listener);
+  };
+}
+function emitState() {
+  const state = getIndexState();
+  for (const l of _listeners) l(state);
+}
+function setIndexProgress(current, total) {
+  _currentFile = current;
+  _totalFiles = total;
+  emitState();
+}
+var worker = null;
+var workerUnavailable = false;
+var nextRpcId = 1;
+var pending = /* @__PURE__ */ new Map();
+function resolveWorkerUrl() {
+  if (process.env["WRONGSTACK_INDEX_INLINE"]) return null;
+  for (const rel of ["./worker.js", "./codebase-index/worker.js"]) {
+    try {
+      const url = new URL(rel, import.meta.url);
+      if (url.protocol === "file:" && fs.existsSync(fileURLToPath(url))) return url;
+    } catch {
+    }
+  }
+  return null;
+}
+function failAllPending(err) {
+  const entries = [...pending.values()];
+  pending.clear();
+  for (const p of entries) p.reject(err);
+}
+function ensureWorker() {
+  if (worker) return worker;
+  if (workerUnavailable) return null;
+  const url = resolveWorkerUrl();
+  if (!url) {
+    workerUnavailable = true;
+    return null;
+  }
+  try {
+    const w = new Worker(url, { name: "wstack-codebase-index" });
+    w.unref();
+    w.on("message", (msg) => {
+      if (msg.type === "progress") {
+        pending.get(msg.id)?.onProgress?.(msg.current, msg.total);
+        return;
+      }
+      const entry = pending.get(msg.id);
+      if (!entry) return;
+      pending.delete(msg.id);
+      if (msg.ok) entry.resolve(msg.result);
+      else entry.reject(new Error(msg.error));
+    });
+    w.on("error", (err) => {
+      worker = null;
+      failAllPending(err);
+    });
+    w.on("exit", () => {
+      if (worker === w) worker = null;
+      failAllPending(new Error("codebase-index worker exited"));
+    });
+    worker = w;
+    return w;
+  } catch {
+    workerUnavailable = true;
+    return null;
+  }
+}
+function terminateWorker(reason) {
+  const w = worker;
+  worker = null;
+  failAllPending(reason);
+  if (w) void w.terminate().catch(() => {
+  });
+}
+function shutdownCodebaseIndexHost() {
+  cancelPendingReindexes();
+  terminateWorker(new Error("codebase-index host shut down"));
+  workerUnavailable = false;
+}
+function callIndexOp(op, args, opts) {
+  const w = ensureWorker();
+  if (!w) return callInline(op, args, opts);
+  return new Promise((resolve2, reject) => {
+    const id = nextRpcId++;
+    const timer = setTimeout(() => {
+      pending.delete(id);
+      const err = new IndexTimeoutError(
+        `Index ${op} exceeded its ${opts.timeoutMs}ms watchdog timeout`
+      );
+      terminateWorker(err);
+      reject(err);
+    }, opts.timeoutMs);
+    timer.unref?.();
+    const onAbort = () => {
+      w.postMessage({ type: "cancel", id });
+    };
+    if (opts.signal?.aborted) onAbort();
+    else opts.signal?.addEventListener("abort", onAbort, { once: true });
+    const cleanup = () => {
+      clearTimeout(timer);
+      opts.signal?.removeEventListener("abort", onAbort);
+    };
+    pending.set(id, {
+      resolve: (v) => {
+        cleanup();
+        resolve2(v);
+      },
+      reject: (e) => {
+        cleanup();
+        reject(e);
+      },
+      onProgress: opts.onProgress
+    });
+    w.postMessage({ type: "request", id, op, args });
+  });
+}
+async function callInline(op, args, opts) {
+  const ac = new AbortController();
+  const onOuterAbort = () => ac.abort(opts.signal?.reason ?? new Error("Indexing cancelled"));
+  if (opts.signal?.aborted) onOuterAbort();
+  else opts.signal?.addEventListener("abort", onOuterAbort, { once: true });
+  let timer;
+  const watchdog = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      const err = new IndexTimeoutError(
+        `Index ${op} exceeded its ${opts.timeoutMs}ms watchdog timeout`
+      );
+      ac.abort(err);
+      reject(err);
+    }, opts.timeoutMs);
+    timer.unref?.();
+  });
+  const job = async () => {
+    switch (op) {
+      case "index":
+        return await indexService(args, {
+          signal: ac.signal,
+          onProgress: opts.onProgress
+        });
+      case "search":
+        return searchService(args);
+      case "stats":
+        return statsService(args);
+      default:
+        throw new Error(`unknown index op: ${String(op)}`);
+    }
+  };
+  try {
+    return await Promise.race([job(), watchdog]);
+  } finally {
+    if (timer) clearTimeout(timer);
+    opts.signal?.removeEventListener("abort", onOuterAbort);
+  }
+}
+var chain = Promise.resolve();
+function withMutex(job) {
+  const run = chain.then(job, job);
+  chain = run.then(
+    () => void 0,
+    () => void 0
+  );
+  return run;
+}
+function circuitOpenError() {
+  const c = indexCircuitBreaker.snapshot();
+  return new CircuitOpenError(
+    "Codebase indexing is temporarily paused after repeated failures" + (c.lastFailure ? ` (last: ${c.lastFailure})` : "") + (c.cooldownRemainingMs > 0 ? `; auto-retry in ${Math.ceil(c.cooldownRemainingMs / 1e3)}s` : "") + ". Use /codebase-reindex to retry now."
+  );
+}
+var DEFAULT_DEBOUNCE_MS = 400;
+var debounceTimers = /* @__PURE__ */ new Map();
+function debounceKey(indexDir, file) {
+  return `${indexDir ?? ""}|${file}`;
+}
+function isIndexableFile(filePath) {
+  return detectLang(filePath) !== null;
+}
+function isUniqueConstraintError(err) {
+  if (err instanceof Error) {
+    const msg = err.message.toLowerCase();
+    return msg.includes("unique constraint") || msg.includes("UNIQUE constraint");
+  }
+  return false;
+}
+async function runStartupIndex(opts) {
+  if (!indexCircuitBreaker.allowRequest()) throw circuitOpenError();
+  _indexing = true;
+  emitState();
+  try {
+    const result = await withMutex(() => {
+      _currentFile = 0;
+      _totalFiles = 0;
+      _lastError = null;
+      return callIndexOp(
+        "index",
+        {
+          projectRoot: opts.projectRoot,
+          indexDir: opts.indexDir,
+          force: opts.force,
+          langs: opts.langs
+        },
+        {
+          timeoutMs: opts.timeoutMs ?? DEFAULT_FULL_INDEX_TIMEOUT_MS,
+          signal: opts.signal,
+          onProgress: setIndexProgress
+        }
+      );
+    });
+    _ready = true;
+    indexCircuitBreaker.recordSuccess();
+    return result;
+  } catch (err) {
+    _lastError = err instanceof Error ? err.message : String(err);
+    if (isUniqueConstraintError(err) && !opts.force) {
+      _lastError = null;
+      const rebuildResult = await runStartupIndex({
+        ...opts,
+        force: true
+      });
+      _ready = true;
+      return rebuildResult;
+    }
+    _ready = true;
+    if (!opts.signal?.aborted) indexCircuitBreaker.recordFailure(err);
+    throw err;
+  } finally {
+    _indexing = false;
+    emitState();
+  }
+}
+function enqueueReindex(opts) {
+  const files = opts.files.filter(isIndexableFile);
+  if (files.length === 0) return;
+  const ms = opts.debounceMs ?? DEFAULT_DEBOUNCE_MS;
+  for (const file of files) {
+    const key = debounceKey(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);
+        }
+      );
+    }, ms);
+    timer.unref?.();
+    debounceTimers.set(key, timer);
+  }
+}
+function cancelPendingReindexes() {
+  for (const t of debounceTimers.values()) clearTimeout(t);
+  debounceTimers.clear();
+}
+async function searchCodebaseIndex(args, opts = {}) {
+  return callIndexOp("search", args, {
+    timeoutMs: opts.timeoutMs ?? DEFAULT_QUERY_TIMEOUT_MS,
+    signal: opts.signal
+  });
+}
+async function codebaseIndexStats(args, opts = {}) {
+  return callIndexOp("stats", args, {
+    timeoutMs: opts.timeoutMs ?? DEFAULT_QUERY_TIMEOUT_MS,
+    signal: opts.signal
+  });
+}
+
 // src/codebase-index/codebase-index-tool.ts
 var codebaseIndexTool = {
   name: "codebase-index",
@@ -2051,103 +2661,24 @@ var codebaseIndexTool = {
         note: "A full index is already in progress. Retry codebase-index after it completes (check codebase-stats)."
       };
     }
-    const result = await runIndexer(ctx, {
+    const circuit = indexCircuitBreaker.snapshot();
+    if (circuit.state === "open" && circuit.cooldownRemainingMs > 0) {
+      return {
+        filesIndexed: 0,
+        symbolsIndexed: 0,
+        langStats: {},
+        durationMs: 0,
+        errors: [],
+        note: `Codebase indexing is paused after repeated failures (last: ${circuit.lastFailure ?? "unknown"}). Auto-retry possible in ${Math.ceil(circuit.cooldownRemainingMs / 1e3)}s; the user can run /codebase-reindex to retry immediately.`
+      };
+    }
+    return await runStartupIndex({
       projectRoot: ctx.projectRoot,
       force: input.force ?? false,
       langs: input.langs,
       indexDir: codebaseIndexDirOverride(ctx),
       signal: execOpts?.signal
     });
-    setIndexReady();
-    return result;
-  }
-};
-
-// src/codebase-index/bm25.ts
-var K1 = 1.5;
-var B = 0.75;
-function tokenise(text) {
-  const sanitised = text.replace(/[^\p{L}\p{N}$'_]/gu, " ").replace(/_/g, " ");
-  return sanitised.toLowerCase().split(" ").filter(Boolean);
-}
-function splitName(name) {
-  return name.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").trim();
-}
-function buildIndexableText(name, signature, docComment) {
-  return [splitName(name), name, signature, docComment].filter(Boolean).join(" ");
-}
-function buildBm25Index(docs) {
-  const documents = docs.map((d) => {
-    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);
-}
-var Bm25Index = class {
-  constructor(documents, df, N, avgLen) {
-    this.documents = documents;
-    this.df = df;
-    this.N = N;
-    this.safeAvgLen = avgLen === 0 ? 1 : avgLen;
-  }
-  documents;
-  df;
-  N;
-  safeAvgLen;
-  score(query, filter) {
-    const qTokens = tokenise(query);
-    if (qTokens.length === 0) return [];
-    const results = [];
-    for (const doc of this.documents) {
-      if (filter && !filter(doc.id)) continue;
-      let docScore = 0;
-      for (const qTerm of qTokens) {
-        let tf = 0;
-        for (const t of doc.tokens) {
-          if (t === qTerm) tf++;
-        }
-        if (tf === 0) continue;
-        const dfVal = this.df[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);
-        const tfComponent = tf * (K1 + 1) / (tf + K1 * (1 - B + lenRatio));
-        docScore += idf * tfComponent;
-      }
-      if (docScore > 0) results.push({ id: doc.id, score: docScore });
-    }
-    return results;
-  }
-  getDoc(id) {
-    return this.documents.find((d) => d.id === id);
-  }
-  extractSnippet(docId, queryTokens, radius = 40) {
-    const doc = this.getDoc(docId);
-    if (!doc) return "";
-    for (const tok of queryTokens) {
-      const idx = doc.raw.toLowerCase().indexOf(tok);
-      if (idx !== -1) {
-        const start = Math.max(0, idx - radius);
-        const end = Math.min(doc.raw.length, idx + tok.length + radius);
-        const excerpt = doc.raw.slice(start, end);
-        const ellipsis = "\u2026";
-        return (start > 0 ? ellipsis : "") + excerpt + (end < doc.raw.length ? ellipsis : "");
-      }
-    }
-    return doc.raw.slice(0, radius * 2) + (doc.raw.length > radius * 2 ? "\u2026" : "");
   }
 };
 
@@ -2193,7 +2724,7 @@ var codebaseSearchTool = {
     },
     required: ["query"]
   },
-  async execute(input, ctx) {
+  async execute(input, ctx, execOpts) {
     const state = getIndexState();
     if (!state.ready) {
       return {
@@ -2212,51 +2743,30 @@ var codebaseSearchTool = {
       };
     }
     if (state.lastError) {
+      const circuit = state.circuit;
+      const retryHint = circuit.state === "open" ? `Indexing is paused (circuit open, retry in ${Math.ceil(circuit.cooldownRemainingMs / 1e3)}s); the user can run /codebase-reindex to retry now.` : "Try /codebase-reindex.";
       return {
         results: [],
         total: 0,
         query: input.query,
-        indexStatus: `Index build failed: ${state.lastError}. Try /codebase-reindex.`
+        indexStatus: `Index build failed: ${state.lastError}. ${retryHint}`
       };
     }
-    const store = new IndexStore(ctx.projectRoot, { indexDir: codebaseIndexDirOverride(ctx) });
-    try {
-      const limit = Math.min(input.limit ?? 20, 100);
-      const candidates = store.search(input.query, {
+    const limit = Math.min(input.limit ?? 20, 100);
+    const { results, total } = await searchCodebaseIndex(
+      {
+        projectRoot: ctx.projectRoot,
+        indexDir: codebaseIndexDirOverride(ctx),
+        query: input.query,
         kind: input.kind,
         lang: input.lang,
         file: input.file,
-        lspKind: input.lspKind
-      });
-      if (candidates.length === 0) {
-        return { results: [], total: 0, query: input.query };
-      }
-      const indexable = candidates.map((c) => ({
-        id: c.id,
-        text: buildIndexableText(c.name, c.signature, c.docComment)
-      }));
-      const bm25 = buildBm25Index(indexable);
-      const scored = bm25.score(input.query, (id) => candidates.some((c) => c.id === id));
-      scored.sort((a, b) => b.score - a.score);
-      const top = scored.slice(0, limit);
-      const qTokens = tokenise(input.query);
-      const results = top.map(({ id, score }) => {
-        const c = expectDefined(candidates.find((c2) => c2.id === id));
-        const snippet = bm25.extractSnippet(id, qTokens);
-        return {
-          ...c,
-          score,
-          snippet
-        };
-      });
-      return {
-        results,
-        total: candidates.length,
-        query: input.query
-      };
-    } finally {
-      store.close();
-    }
+        lspKind: input.lspKind,
+        limit
+      },
+      { signal: execOpts?.signal }
+    );
+    return { results, total, query: input.query };
   }
 };
 
@@ -2275,7 +2785,7 @@ var codebaseStatsTool = {
     properties: {},
     additionalProperties: false
   },
-  async execute(_input, ctx) {
+  async execute(_input, ctx, execOpts) {
     const idxState = getIndexState();
     if (!idxState.ready) {
       return {
@@ -2290,37 +2800,33 @@ var codebaseStatsTool = {
         indexStatus: idxState.indexing ? `Indexing in progress (${idxState.currentFile}/${idxState.totalFiles} files).` : "Index not yet built."
       };
     }
+    const stats = await codebaseIndexStats(
+      { projectRoot: ctx.projectRoot, indexDir: codebaseIndexDirOverride(ctx) },
+      { signal: execOpts?.signal }
+    );
     if (idxState.indexing) {
-      const store2 = new IndexStore(ctx.projectRoot, { indexDir: codebaseIndexDirOverride(ctx) });
-      try {
-        const stats = store2.getStats();
-        return {
-          ...stats,
-          indexStatus: `Index refresh in progress (${idxState.currentFile}/${idxState.totalFiles} files). Stats may be incomplete.`
-        };
-      } finally {
-        store2.close();
-      }
-    }
-    const store = new IndexStore(ctx.projectRoot, { indexDir: codebaseIndexDirOverride(ctx) });
-    try {
-      const stats = store.getStats();
       return {
-        totalSymbols: stats.totalSymbols,
-        totalFiles: stats.totalFiles,
-        byLang: stats.byLang,
-        byKind: stats.byKind,
-        lastIndexed: stats.lastIndexed,
-        sizeBytes: stats.sizeBytes,
-        indexPath: stats.indexPath,
-        version: stats.version
+        ...stats,
+        indexStatus: `Index refresh in progress (${idxState.currentFile}/${idxState.totalFiles} files). Stats may be incomplete.`
       };
-    } finally {
-      store.close();
     }
+    const circuit = idxState.circuit;
+    return {
+      totalSymbols: stats.totalSymbols,
+      totalFiles: stats.totalFiles,
+      byLang: stats.byLang,
+      byKind: stats.byKind,
+      lastIndexed: stats.lastIndexed,
+      sizeBytes: stats.sizeBytes,
+      indexPath: stats.indexPath,
+      version: stats.version,
+      ...circuit.state === "open" ? {
+        indexStatus: `Indexing is paused after repeated failures (last: ${circuit.lastFailure ?? "unknown"}); auto-retry in ${Math.ceil(circuit.cooldownRemainingMs / 1e3)}s, or run /codebase-reindex. Stats reflect the last successful build.`
+      } : {}
+    };
   }
 };
 
-export { IndexStore, SCHEMA_VERSION, buildBm25Index, buildIndexableText, cancelPendingReindexes, codebaseIndexDirOverride, codebaseIndexTool, codebaseSearchTool, codebaseStatsTool, enqueueReindex, getIndexState, internalKindToLspKind, isIndexReady, isIndexableFile, isIndexing, lspKindToInternalKind, onIndexStateChange, resolveIndexDir, runIndexer, runStartupIndex, tokenise };
+export { CircuitOpenError, IndexCircuitBreaker, IndexStore, IndexTimeoutError, SCHEMA_VERSION, buildBm25Index, buildIndexableText, cancelPendingReindexes, codebaseIndexDirOverride, codebaseIndexStats, codebaseIndexTool, codebaseSearchTool, codebaseStatsTool, enqueueReindex, getIndexState, indexCircuitBreaker, internalKindToLspKind, isIndexReady, isIndexableFile, isIndexing, lspKindToInternalKind, onIndexStateChange, resetIndexCircuitBreaker, resolveIndexDir, runIndexer, runStartupIndex, searchCodebaseIndex, shutdownCodebaseIndexHost, tokenise };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map