@wrongstack/tools 0.236.0 → 0.255.0

package/dist/index.js

@@ -2,28 +2,30 @@ import * as fs4 from 'node:fs/promises';
 import * as path from 'node:path';
 import { resolve, sep, dirname, join } from 'node:path';
 import * as Core from '@wrongstack/core';
-import { atomicWrite, unifiedDiff, detectNewlineStyle, normalizeToLf, toStyle, compileGlob, expectDefined, buildChildEnv, loadPlan, setPlanItemStatus, savePlan, loadTasks, saveTasks, mutatePlan, clearPlan, getPlanTemplate, addPlanItem, deriveTodosFromPlanItem, removePlanItem, emptyTaskFile, formatTaskList, formatPlan, recordPackageAction, detectPackageEcosystem, mutateTasks, emptyPlan, computeTaskItemProgress, resolveWstackPaths } from '@wrongstack/core';
+import { atomicWrite, unifiedDiff, detectNewlineStyle, normalizeToLf, toStyle, compileGlob, expectDefined, buildChildEnv, loadPlan, setPlanItemStatus, savePlan, loadTasks, saveTasks, mutatePlan, clearPlan, getPlanTemplate, addPlanItem, deriveTodosFromPlanItem, removePlanItem, emptyTaskFile, formatTaskList, formatPlan, recordPackageAction, detectPackageEcosystem, mutateTasks, emptyPlan, computeTaskItemProgress, wstackGlobalRoot, resolveWstackPaths, truncate } from '@wrongstack/core';
 import { spawn, execFileSync, spawnSync } from 'node:child_process';
 import * as os from 'node:os';
 import * as fs7 from 'node:fs';
-import { statSync, writeFileSync, mkdirSync } from 'node:fs';
+import { statSync, mkdirSync, createWriteStream, writeFileSync } from 'node:fs';
 import * as dns from 'node:dns/promises';
 import * as net from 'node:net';
 import { Agent } from 'undici';
 import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import { Worker } from 'node:worker_threads';
 import * as ts from 'typescript';
 import { randomUUID } from 'node:crypto';
 
 // src/read.ts
 async function detectPackageManager(cwd) {
-  const { stat: stat10 } = await import('node:fs/promises');
+  const { stat: stat11 } = await import('node:fs/promises');
   try {
-    await stat10(`${cwd}/pnpm-lock.yaml`);
+    await stat11(`${cwd}/pnpm-lock.yaml`);
     return "pnpm";
   } catch {
   }
   try {
-    await stat10(`${cwd}/yarn.lock`);
+    await stat11(`${cwd}/yarn.lock`);
     return "yarn";
   } catch {
   }
@@ -192,9 +194,9 @@ var readTool = {
   async execute(input, ctx) {
     if (!input?.path) throw new Error("read: path is required");
     const absPath = await safeResolveReal(input.path, ctx);
-    let stat10;
+    let stat11;
     try {
-      stat10 = await fs4.stat(absPath);
+      stat11 = await fs4.stat(absPath);
     } catch (err) {
       const code = err.code;
       if (code === "ENOENT") throw new Error(`read: file not found "${input.path}"`);
@@ -202,9 +204,9 @@ var readTool = {
         `read: failed to stat "${input.path}": ${err instanceof Error ? err.message : String(err)}`
       );
     }
-    if (!stat10.isFile()) throw new Error(`read: "${input.path}" is not a regular file`);
-    if (stat10.size > MAX_BYTES) {
-      throw new Error(`read: file too large (${stat10.size} bytes, limit ${MAX_BYTES})`);
+    if (!stat11.isFile()) throw new Error(`read: "${input.path}" is not a regular file`);
+    if (stat11.size > MAX_BYTES) {
+      throw new Error(`read: file too large (${stat11.size} bytes, limit ${MAX_BYTES})`);
     }
     const buf = await fs4.readFile(absPath);
     if (isBinaryBuffer(buf)) {
@@ -216,14 +218,14 @@ var readTool = {
     const offset = Math.max(1, input.offset ?? 1);
     const limit = Math.max(0, Math.min(input.limit ?? 2e3, 5e3));
     if (limit === 0) {
-      ctx.recordRead(absPath, stat10.mtimeMs);
+      ctx.recordRead(absPath, stat11.mtimeMs);
       return { text: "", total_lines: total, encoding: "utf8", truncated: total > 0 };
     }
     const slice = allLines.slice(offset - 1, offset - 1 + limit);
     const truncated = offset - 1 + slice.length < total;
     const width = String(offset + slice.length - 1).length;
     const numbered = slice.map((line, i) => `${String(offset + i).padStart(width, " ")}\u2192${line}`).join("\n");
-    ctx.recordRead(absPath, stat10.mtimeMs);
+    ctx.recordRead(absPath, stat11.mtimeMs);
     return {
       text: numbered,
       total_lines: total,
@@ -262,12 +264,12 @@ var writeTool = {
     let existed = false;
     let prev = "";
     try {
-      const stat11 = await fs4.stat(absPath);
-      existed = stat11.isFile();
+      const stat12 = await fs4.stat(absPath);
+      existed = stat12.isFile();
       if (existed) {
         if (!ctx.hasRead(absPath)) {
           prev = await fs4.readFile(absPath, "utf8");
-          ctx.recordRead(absPath, stat11.mtimeMs);
+          ctx.recordRead(absPath, stat12.mtimeMs);
         } else {
           prev = await fs4.readFile(absPath, "utf8");
         }
@@ -280,8 +282,8 @@ var writeTool = {
     await atomicWrite(absPath, input.content);
     const diff = existed ? unifiedDiff(prev, input.content, { fromFile: input.path, toFile: input.path }) : `+++ ${input.path}
 + (new file, ${input.content.split("\n").length} lines)`;
-    const stat10 = await fs4.stat(absPath);
-    ctx.recordRead(absPath, stat10.mtimeMs);
+    const stat11 = await fs4.stat(absPath);
+    ctx.recordRead(absPath, stat11.mtimeMs);
     ctx.session.recordFileChange({
       path: absPath,
       action: existed ? "modified" : "created",
@@ -321,13 +323,13 @@ var editTool = {
     if (input.new_string === void 0) throw new Error("edit: new_string is required");
     if (input.old_string === "") throw new Error("edit: old_string cannot be empty");
     const absPath = await safeResolveReal(input.path, ctx);
-    const stat10 = await fs4.stat(absPath).catch((err) => {
+    const stat11 = await fs4.stat(absPath).catch((err) => {
       if (err.code === "ENOENT") {
         throw new Error(`edit: file "${input.path}" does not exist. Use \`write\` instead.`);
       }
       throw err;
     });
-    if (!stat10.isFile()) throw new Error(`edit: "${input.path}" is not a regular file`);
+    if (!stat11.isFile()) throw new Error(`edit: "${input.path}" is not a regular file`);
     if (!ctx.hasRead(absPath)) {
       throw new Error(`edit: file "${input.path}" was not read in this session. Read it first.`);
     }
@@ -522,8 +524,8 @@ var replaceTool = {
       }
       const rel = path.relative(realRoot, realPath);
       if (rel.startsWith("..") || path.isAbsolute(rel)) continue;
-      const stat10 = await fs4.stat(realPath).catch(() => null);
-      if (!stat10 || !stat10.isFile()) continue;
+      const stat11 = await fs4.stat(realPath).catch(() => null);
+      if (!stat11 || !stat11.isFile()) continue;
       let content;
       try {
         const buf = await fs4.readFile(realPath);
@@ -548,7 +550,7 @@ var replaceTool = {
       totalReplacements += count;
       if (!dryRun) {
         const newContent = toStyle(newContentLf, style);
-        await atomicWrite(realPath, newContent, { mode: stat10.mode & 511 });
+        await atomicWrite(realPath, newContent, { mode: stat11.mode & 511 });
       }
       const diff = dryRun || matches.length > 0 ? unifiedDiff(content, toStyle(newContentLf, style), {
         fromFile: absPath,
@@ -578,8 +580,8 @@ async function resolveFiles(filesInput, ctx, extraGlob) {
   const resolved = [];
   for (const p of parts) {
     const absPath = safeResolve(p, ctx);
-    const stat10 = await fs4.stat(absPath).catch(() => null);
-    if (stat10?.isFile()) {
+    const stat11 = await fs4.stat(absPath).catch(() => null);
+    if (stat11?.isFile()) {
       resolved.push(absPath);
     }
   }
@@ -599,7 +601,7 @@ async function globFiles(pattern, base, extraGlob) {
 function checkRg() {
   return new Promise((resolve7) => {
     try {
-      const p = spawn("rg", ["--version"], { env: buildChildEnv(), stdio: "ignore" });
+      const p = spawn("rg", ["--version"], { env: buildChildEnv(), stdio: "ignore", windowsHide: true });
       p.on("error", () => resolve7(false));
       p.on("close", (code) => resolve7(code === 0));
     } catch {
@@ -612,7 +614,8 @@ function spawnRgFind(pattern, base) {
   const child = spawn("rg", args, {
     signal: AbortSignal.timeout(3e4),
     env: buildChildEnv(),
-    stdio: ["ignore", "pipe", "pipe"]
+    stdio: ["ignore", "pipe", "pipe"],
+    windowsHide: true
   });
   let buf = "";
   child.stdout?.on("data", (chunk) => {
@@ -641,8 +644,8 @@ async function globNative(pattern, base, extraGlob) {
       if (DEFAULT_IGNORE.includes(e.name)) continue;
       const full = path.join(dir, e.name);
       try {
-        const stat10 = await fs4.lstat(full);
-        if (stat10.isSymbolicLink()) continue;
+        const stat11 = await fs4.lstat(full);
+        if (stat11.isSymbolicLink()) continue;
       } catch {
         continue;
       }
@@ -828,7 +831,7 @@ var grepTool = {
 async function detectRg(signal) {
   return new Promise((resolve7) => {
     try {
-      const p = spawn("rg", ["--version"], { env: buildChildEnv(), stdio: "ignore", signal });
+      const p = spawn("rg", ["--version"], { env: buildChildEnv(), stdio: "ignore", signal, windowsHide: true });
       p.on("error", () => resolve7(false));
       p.on("close", (code) => resolve7(code === 0));
     } catch {
@@ -858,7 +861,7 @@ async function* runRgStream(input, base, mode, limit, signal) {
   const FLUSH_AT = 16;
   const MAX_BUF_BYTES = 1e6;
   let bufOverflow = false;
-  const child = spawn("rg", args, { signal, env: buildChildEnv(), stdio: ["ignore", "pipe", "pipe"] });
+  const child = spawn("rg", args, { signal, env: buildChildEnv(), stdio: ["ignore", "pipe", "pipe"], windowsHide: true });
   const queue = [];
   let waiter;
   const wake = () => {
@@ -993,8 +996,8 @@ async function runNative(input, base, mode, limit, signal) {
         if (globRe && !globRe.test(e.name) && !globRe.test(full)) continue;
         if (globRe) globRe.lastIndex = 0;
         try {
-          const stat10 = await fs4.stat(full);
-          if (stat10.size > 1e6) continue;
+          const stat11 = await fs4.stat(full);
+          if (stat11.size > 1e6) continue;
           const head = await fs4.readFile(full);
           if (isBinaryBuffer(head)) continue;
           const text = head.toString("utf8");
@@ -1034,6 +1037,107 @@ async function runNative(input, base, mode, limit, signal) {
     used: "native"
   };
 }
+var SPOOL_RETENTION_MS = 7 * 24 * 60 * 60 * 1e3;
+var SPOOL_WRITE_HWM_BYTES = 4 * 1024 * 1024;
+var sweepStarted = false;
+function toolOutputDir() {
+  return path.join(wstackGlobalRoot(), "tool-output");
+}
+function sweepOldSpoolFiles(dir) {
+  if (sweepStarted) return;
+  sweepStarted = true;
+  void (async () => {
+    try {
+      const now = Date.now();
+      for (const name of await fs4.readdir(dir)) {
+        if (!name.endsWith(".log")) continue;
+        const p = path.join(dir, name);
+        try {
+          const st = await fs4.stat(p);
+          if (now - st.mtimeMs > SPOOL_RETENTION_MS) await fs4.unlink(p);
+        } catch {
+        }
+      }
+    } catch {
+    }
+  })();
+}
+function spoolNote(info) {
+  const dropped = info.droppedBytes > 0 ? `, ~${info.droppedBytes} bytes dropped under backpressure` : "";
+  return `
+[output truncated \u2014 full ${info.bytes} bytes at ${info.path}${dropped}; read/grep that file selectively instead of re-running with more output]`;
+}
+function createOutputSpool(opts) {
+  const threshold = opts.thresholdBytes ?? 32768;
+  const safeTool = opts.tool.replace(/[^a-zA-Z0-9._-]+/g, "_").slice(0, 40) || "tool";
+  let head = "";
+  let headBytes = 0;
+  let totalBytes = 0;
+  let droppedBytes = 0;
+  let stream = null;
+  let filePath = null;
+  let failed = false;
+  let finalized = false;
+  const open = () => {
+    if (stream || failed) return;
+    try {
+      const dir = toolOutputDir();
+      mkdirSync(dir, { recursive: true });
+      sweepOldSpoolFiles(dir);
+      const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+      const rand = Math.random().toString(36).slice(2, 6);
+      filePath = path.join(dir, `${stamp}-${safeTool}-${rand}.log`);
+      stream = createWriteStream(filePath, { flags: "w", encoding: "utf8" });
+      stream.on("error", () => {
+        failed = true;
+        stream = null;
+        filePath = null;
+      });
+      stream.write(head);
+    } catch {
+      failed = true;
+      stream = null;
+      filePath = null;
+    }
+  };
+  return {
+    write(text) {
+      if (finalized || !text) return;
+      totalBytes += Buffer.byteLength(text, "utf8");
+      if (!stream && !failed) {
+        if (headBytes + text.length <= threshold) {
+          head += text;
+          headBytes += text.length;
+          return;
+        }
+        head += text;
+        open();
+        head = "";
+        return;
+      }
+      if (stream) {
+        if (stream.writableLength > SPOOL_WRITE_HWM_BYTES) {
+          droppedBytes += Buffer.byteLength(text, "utf8");
+          return;
+        }
+        stream.write(text);
+      }
+    },
+    finalize() {
+      if (finalized) {
+        return filePath ? { path: filePath, bytes: totalBytes, droppedBytes } : null;
+      }
+      finalized = true;
+      head = "";
+      if (!stream || !filePath) return null;
+      try {
+        stream.end();
+      } catch {
+      }
+      return { path: filePath, bytes: totalBytes, droppedBytes };
+    }
+  };
+}
 
 // src/circuit-breaker.ts
 var DEFAULT_MAX_CONSECUTIVE_FAILURES = 5;
@@ -1513,7 +1617,7 @@ var bashTool = {
     })();
     const args = isWin ? ["/c", input.command] : ["-c", input.command];
     const env = buildChildEnv(ctx.session?.id);
-    const detached = isWin ? !!input.background : true;
+    const detached = !isWin;
     const startedAt = Date.now();
     if (input.background) {
       let buf2 = "";
@@ -1522,7 +1626,15 @@ var bashTool = {
         cwd: ctx.projectRoot,
         env,
         stdio: ["ignore", "pipe", "pipe"],
-        detached: true,
+        // win32: CreateProcess IGNORES CREATE_NO_WINDOW (windowsHide) when
+        // DETACHED_PROCESS (detached: true) is set, so the console-less
+        // cmd.exe's grandchildren (node, dev servers) each allocate a fresh
+        // VISIBLE console window. detached: false lets CREATE_NO_WINDOW
+        // apply: the child gets a hidden console that grandchildren inherit.
+        // Windows children survive parent exit either way. POSIX keeps
+        // detached for the process-group kill semantics.
+        detached: !isWin,
+        windowsHide: true,
         signal: opts.signal
       });
       const pid2 = child2.pid;
@@ -1537,24 +1649,22 @@ var bashTool = {
         });
         child2.on("close", () => registry.unregister(pid2));
       }
-      child2.stdout?.on("data", (chunk) => {
-        if (!truncated) {
-          const remain = MAX_OUTPUT - buf2.length;
-          if (remain > 0) {
-            buf2 += chunk.toString().slice(0, remain);
-          }
-          if (buf2.length >= MAX_OUTPUT) truncated = true;
+      const onBgData = (chunk) => {
+        if (truncated) return;
+        const remain = MAX_OUTPUT - buf2.length;
+        if (remain > 0) {
+          buf2 += chunk.toString().slice(0, remain);
         }
-      });
-      child2.stderr?.on("data", (chunk) => {
-        if (!truncated) {
-          const remain = MAX_OUTPUT - buf2.length;
-          if (remain > 0) {
-            buf2 += chunk.toString().slice(0, remain);
-          }
-          if (buf2.length >= MAX_OUTPUT) truncated = true;
+        if (buf2.length >= MAX_OUTPUT) {
+          truncated = true;
+          child2.stdout?.off("data", onBgData);
+          child2.stderr?.off("data", onBgData);
         }
-      });
+      };
+      child2.stdout?.on("data", onBgData);
+      child2.stderr?.on("data", onBgData);
+      child2.stdout?.unref?.();
+      child2.stderr?.unref?.();
       child2.on("close", () => {
         registry.afterCall(Date.now() - startedAt, false, bypassBreaker);
       });
@@ -1575,6 +1685,7 @@ var bashTool = {
       env,
       stdio: ["ignore", "pipe", "pipe"],
       detached,
+      windowsHide: true,
       ...isWin ? {} : { signal: opts.signal }
     });
     const pid = child.pid;
@@ -1589,9 +1700,10 @@ var bashTool = {
       });
     }
     let buf = "";
-    let pending = "";
+    let pending2 = "";
     let timedOut = false;
     const timers = [];
+    const spool = createOutputSpool({ tool: "bash", thresholdBytes: MAX_OUTPUT });
     function killWithTimeout(child2, timeoutMs2) {
       if (isWin) {
         if (typeof child2.pid === "number" && child2.exitCode === null && killWin32Tree(child2.pid)) {
@@ -1671,9 +1783,9 @@ var bashTool = {
     });
     let lastFlush = Date.now();
     const flush = () => {
-      if (pending.length === 0) return null;
-      const text = pending;
-      pending = "";
+      if (pending2.length === 0) return null;
+      const text = pending2;
+      pending2 = "";
       lastFlush = Date.now();
       return text;
     };
@@ -1697,7 +1809,8 @@ var bashTool = {
       if (buf.length < MAX_OUTPUT) {
         buf += text.slice(0, MAX_OUTPUT - buf.length);
       }
-      pending += text;
+      spool.write(text);
+      pending2 += text;
       push({ kind: "data", text });
       pauseIfFlooded();
     };
@@ -1724,10 +1837,11 @@ var bashTool = {
           if (remainder !== null) {
             yield { type: "partial_output", text: remainder };
           }
+          const spooled = spool.finalize();
           yield {
             type: "final",
             output: {
-              output: normalizeCommandOutput(buf),
+              output: normalizeCommandOutput(buf) + (spooled ? spoolNote(spooled) : ""),
               exit_code: c.code,
               timed_out: timedOut
             }
@@ -1735,13 +1849,14 @@ var bashTool = {
           return;
         }
         const now = Date.now();
-        if (pending.length >= STREAM_FLUSH_BYTES || now - lastFlush >= STREAM_FLUSH_INTERVAL_MS) {
+        if (pending2.length >= STREAM_FLUSH_BYTES || now - lastFlush >= STREAM_FLUSH_INTERVAL_MS) {
           const text = flush();
           if (text) yield { type: "partial_output", text };
         }
       }
     } finally {
       for (const t of timers) clearTimeout(t);
+      spool.finalize();
       if (isWin) opts.signal.removeEventListener("abort", onAbort);
       child.stdout?.off("data", onData);
       child.stderr?.off("data", onData);
@@ -1982,6 +2097,7 @@ function runCommand(cmd, args, cwd, timeout, signal, sessionId) {
     let stderr = "";
     let killed = false;
     const startedAt = Date.now();
+    const spool = createOutputSpool({ tool: `exec-${cmd}`, thresholdBytes: MAX_OUTPUT2 });
     const resolved = resolveWin32Command(cmd);
     const isWin = process.platform === "win32";
     const needsShell = isWin && (resolved.endsWith(".cmd") || resolved.endsWith(".bat"));
@@ -1989,6 +2105,7 @@ function runCommand(cmd, args, cwd, timeout, signal, sessionId) {
       cwd,
       env: buildChildEnv(sessionId),
       stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true,
       ...isWin ? {} : { signal },
       ...needsShell ? { shell: true, windowsVerbatimArguments: true } : {}
     });
@@ -2013,10 +2130,14 @@ function runCommand(cmd, args, cwd, timeout, signal, sessionId) {
       else signal.addEventListener("abort", onAbort, { once: true });
     }
     child.stdout?.on("data", (chunk) => {
-      if (stdout.length < MAX_OUTPUT2) stdout += chunk.toString();
+      const text = chunk.toString();
+      if (stdout.length < MAX_OUTPUT2) stdout += text;
+      spool.write(text);
     });
     child.stderr?.on("data", (chunk) => {
-      if (stderr.length < MAX_OUTPUT2) stderr += chunk.toString();
+      const text = chunk.toString();
+      if (stderr.length < MAX_OUTPUT2) stderr += text;
+      spool.write(text);
     });
     child.on("close", (code) => {
       clearTimeout(timer);
@@ -2025,10 +2146,11 @@ function runCommand(cmd, args, cwd, timeout, signal, sessionId) {
       const durationMs = Date.now() - startedAt;
       const exitCode = killed ? 124 : code ?? 1;
       registry.afterCall(durationMs, exitCode !== 0);
+      const spooled = spool.finalize();
       resolve7({
         command: cmd,
         args,
-        stdout: normalizeCommandOutput(stdout),
+        stdout: normalizeCommandOutput(stdout) + (spooled ? spoolNote(spooled) : ""),
         stderr: normalizeCommandOutput(stderr),
         exitCode,
         truncated: Buffer.byteLength(stdout, "utf8") > COMMAND_OUTPUT_MAX_BYTES || Buffer.byteLength(stderr, "utf8") > COMMAND_OUTPUT_MAX_BYTES,
@@ -2040,6 +2162,7 @@ function runCommand(cmd, args, cwd, timeout, signal, sessionId) {
       if (isWin) signal.removeEventListener("abort", onAbort);
       if (typeof pid === "number") registry.unregister(pid);
       registry.afterCall(Date.now() - startedAt, true);
+      spool.finalize();
       resolve7({
         command: cmd,
         args,
@@ -3062,8 +3185,8 @@ function findGitDir(cwd, projectRoot) {
   let dir = cwd;
   for (let i = 0; i < 20; i++) {
     try {
-      const stat10 = statSync(`${dir}/.git`);
-      if (stat10.isDirectory() || stat10.isFile()) return dir;
+      const stat11 = statSync(`${dir}/.git`);
+      if (stat11.isDirectory() || stat11.isFile()) return dir;
     } catch {
     }
     if (dir === root) break;
@@ -3151,7 +3274,8 @@ function runGit(args, cwd, signal) {
       cwd,
       signal,
       env: buildChildEnv(),
-      stdio: ["ignore", "pipe", "pipe"]
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true
     });
     child.stdout?.on("data", (chunk) => {
       if (stdout.length < MAX_OUTPUT3) {
@@ -3274,7 +3398,7 @@ function runPatch(args, cwd, signal) {
     let stdout = "";
     let stderr = "";
     const env = { ...buildChildEnv(), LANG: "C", LC_ALL: "C" };
-    const child = spawn("patch", args, { cwd, signal, env, stdio: ["pipe", "pipe", "pipe"] });
+    const child = spawn("patch", args, { cwd, signal, env, stdio: ["pipe", "pipe", "pipe"], windowsHide: true });
     child.stdout?.on("data", (c) => {
       stdout += c.toString();
     });
@@ -3365,8 +3489,8 @@ var jsonTool = {
     };
   }
 };
-function query(data, path20) {
-  const parts = path20.replace(/\[(\d+)\]/g, ".$1").split(".").filter(Boolean);
+function query(data, path21) {
+  const parts = path21.replace(/\[(\d+)\]/g, ".$1").split(".").filter(Boolean);
   let current = data;
   for (const part of parts) {
     if (current === null || current === void 0) return void 0;
@@ -3495,8 +3619,8 @@ function findGitDir2(cwd) {
   let dir = cwd;
   for (let i = 0; i < 20; i++) {
     try {
-      const stat10 = statSync(path.join(dir, ".git"));
-      if (stat10.isDirectory()) return dir;
+      const stat11 = statSync(path.join(dir, ".git"));
+      if (stat11.isDirectory()) return dir;
     } catch {
     }
     const parent = path.dirname(dir);
@@ -3513,7 +3637,8 @@ function runGit2(args, cwd, signal) {
       cwd,
       signal,
       env: buildChildEnv(),
-      stdio: ["ignore", "pipe", "pipe"]
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true
     });
     child.stdout?.on("data", (c) => {
       stdout += c.toString();
@@ -3539,8 +3664,8 @@ async function fileDiff(input, ctx, _signal) {
   const results = [];
   for (const file of files) {
     const absPath = safeResolve(file, ctx);
-    const stat10 = await fs4.stat(absPath).catch(() => null);
-    if (!stat10?.isFile()) continue;
+    const stat11 = await fs4.stat(absPath).catch(() => null);
+    if (!stat11?.isFile()) continue;
     const content = await fs4.readFile(absPath, "utf8");
     const lines = content.split(/\r?\n/);
     results.push(formatWithLineNumbers(file, lines));
@@ -3741,17 +3866,31 @@ async function* spawnStream(opts) {
   const maxQueue = opts.maxQueueSize ?? 500;
   let stdout = "";
   let stderr = "";
-  let pending = "";
+  let pending2 = "";
   let error;
+  const spool = createOutputSpool({ tool: opts.cmd, thresholdBytes: max });
   const cmd = resolveWin32Command(opts.cmd);
-  const needsShell = process.platform === "win32" && (cmd.endsWith(".cmd") || cmd.endsWith(".bat"));
+  const isWin = process.platform === "win32";
+  const needsShell = isWin && (cmd.endsWith(".cmd") || cmd.endsWith(".bat"));
   const child = spawn(cmd, opts.args, {
     cwd: opts.cwd,
-    signal: opts.signal,
     env: buildChildEnv(),
     stdio: ["ignore", "pipe", "pipe"],
+    windowsHide: true,
+    ...isWin ? {} : { signal: opts.signal },
     ...needsShell ? { shell: true, windowsVerbatimArguments: true } : {}
   });
+  const registry = getProcessRegistry();
+  const pid = child.pid;
+  if (typeof pid === "number") {
+    registry.register({
+      pid,
+      name: opts.cmd,
+      command: redactCommand(`${opts.cmd} ${opts.args.join(" ")}`),
+      startedAt: Date.now(),
+      child
+    });
+  }
   const queue = [];
   let waiter;
   let paused = false;
@@ -3769,9 +3908,10 @@ async function* spawnStream(opts) {
       child.stderr?.resume();
     }
   };
-  child.stdout?.on("data", (c) => {
+  const onOut = (c) => {
     const s = c.toString();
     if (stdout.length < max) stdout += s;
+    spool.write(s);
     queue.push({ kind: "out", data: s });
     wake();
     if (!paused && queue.length >= maxQueue) {
@@ -3779,10 +3919,11 @@ async function* spawnStream(opts) {
       child.stdout?.pause();
       child.stderr?.pause();
     }
-  });
-  child.stderr?.on("data", (c) => {
+  };
+  const onErr = (c) => {
     const s = c.toString();
     if (stderr.length < max) stderr += s;
+    spool.write(s);
     queue.push({ kind: "err", data: s });
     wake();
     if (!paused && queue.length >= maxQueue) {
@@ -3790,51 +3931,92 @@ async function* spawnStream(opts) {
       child.stdout?.pause();
       child.stderr?.pause();
     }
-  });
+  };
+  child.stdout?.on("data", onOut);
+  child.stderr?.on("data", onErr);
   child.on("error", (e) => {
     error = e.message;
     queue.push({ kind: "error", data: e.message });
     wake();
   });
   child.on("close", (code) => {
+    if (typeof pid === "number") registry.unregister(pid);
     queue.push({ kind: "close", data: "", code: code ?? 0 });
     wake();
   });
+  const onAbort = () => {
+    if (typeof pid === "number") {
+      registry.kill(pid, { force: true });
+    } else {
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+    }
+    queue.push({ kind: "close", data: "", code: 124 });
+    wake();
+  };
+  if (opts.signal.aborted) onAbort();
+  else opts.signal.addEventListener("abort", onAbort, { once: true });
   let exitCode = 0;
   let spawnFailed = false;
-  for (; ; ) {
-    while (queue.length === 0) {
-      await new Promise((resolve7) => {
-        waiter = resolve7;
-      });
-    }
-    const chunk = queue.shift();
-    resume();
-    if (chunk.kind === "close") {
-      if (!spawnFailed) exitCode = chunk.code ?? 0;
-      break;
+  try {
+    for (; ; ) {
+      while (queue.length === 0) {
+        await new Promise((resolve7) => {
+          waiter = resolve7;
+        });
+      }
+      const chunk = queue.shift();
+      resume();
+      if (chunk.kind === "close") {
+        if (!spawnFailed) exitCode = chunk.code ?? 0;
+        break;
+      }
+      if (chunk.kind === "error") {
+        spawnFailed = true;
+        exitCode = 1;
+        continue;
+      }
+      pending2 += chunk.data;
+      if (pending2.length >= flushAt) {
+        yield { type: "partial_output", text: pending2 };
+        pending2 = "";
+      }
     }
-    if (chunk.kind === "error") {
-      spawnFailed = true;
-      exitCode = 1;
-      continue;
+    if (pending2.length > 0) {
+      yield { type: "partial_output", text: pending2 };
     }
-    pending += chunk.data;
-    if (pending.length >= flushAt) {
-      yield { type: "partial_output", text: pending };
-      pending = "";
+    const spooled = spool.finalize();
+    return {
+      // The marker rides on stdout's tail so every consumer's head+tail
+      // normalization keeps it without per-tool changes.
+      stdout: spooled ? stdout + spoolNote(spooled) : stdout,
+      stderr,
+      exitCode,
+      truncated: stdout.length >= max || stderr.length >= max,
+      error,
+      spoolPath: spooled?.path,
+      spoolBytes: spooled?.bytes
+    };
+  } finally {
+    spool.finalize();
+    opts.signal.removeEventListener("abort", onAbort);
+    child.stdout?.off("data", onOut);
+    child.stderr?.off("data", onErr);
+    child.stdout?.destroy();
+    child.stderr?.destroy();
+    if (child.exitCode === null && !child.killed) {
+      if (typeof pid === "number") {
+        registry.kill(pid, { force: true });
+      } else {
+        try {
+          child.kill("SIGKILL");
+        } catch {
+        }
+      }
     }
   }
-  if (pending.length > 0) {
-    yield { type: "partial_output", text: pending };
-  }
-  return {
-    stdout,
-    stderr,
-    exitCode,
-    truncated: stdout.length >= max || stderr.length >= max,
-    error
-  };
 }
 
 // src/lint.ts
@@ -3917,11 +4099,11 @@ var lintTool = {
   }
 };
 async function detectLinter(cwd) {
-  const { stat: stat10 } = await import('node:fs/promises');
+  const { stat: stat11 } = await import('node:fs/promises');
   const checks = ["biome.json", ".eslintrc.json", "tslint.json", ".eslintrc.js", "tsconfig.json"];
   for (const f of checks) {
     try {
-      await stat10(`${cwd}/${f}`);
+      await stat11(`${cwd}/${f}`);
       if (f.includes("biome")) return "biome";
       if (f.includes("eslint")) return "eslint";
       if (f.includes("tslint")) return "tslint";
@@ -4019,13 +4201,13 @@ var formatTool = {
   }
 };
 async function detectFixer(cwd) {
-  const { stat: stat10 } = await import('node:fs/promises');
+  const { stat: stat11 } = await import('node:fs/promises');
   try {
-    await stat10(`${cwd}/biome.json`);
+    await stat11(`${cwd}/biome.json`);
     return "biome";
   } catch {
     try {
-      await stat10(`${cwd}/.prettierrc`);
+      await stat11(`${cwd}/.prettierrc`);
       return "prettier";
     } catch {
       return "biome";
@@ -4103,11 +4285,11 @@ var typecheckTool = {
   }
 };
 async function findTsConfig(cwd) {
-  const { stat: stat10 } = await import('node:fs/promises');
+  const { stat: stat11 } = await import('node:fs/promises');
   const candidates = ["tsconfig.json", "tsconfig.base.json"];
   for (const f of candidates) {
     try {
-      const s = await stat10(path.join(cwd, f));
+      const s = await stat11(path.join(cwd, f));
       if (s.isFile()) return path.join(cwd, f);
     } catch {
     }
@@ -4138,7 +4320,11 @@ var testTool = {
       coverage: { type: "boolean", description: "Generate coverage report (default: false)" },
       cwd: { type: "string", description: "Working directory (default: cwd)" },
       grep: { type: "string", description: "Filter tests by name pattern (default: none)" },
-      timeout: { type: "integer", description: "Test timeout in ms (default: 30000)" }
+      timeout: { type: "integer", description: "Test timeout in ms (default: 30000)" },
+      verbose: {
+        type: "boolean",
+        description: "Per-test verbose reporter output (default: false \u2014 the summary reporter is used; full output is always saved to a log file referenced in the result)"
+      }
     }
   },
   async execute(input, ctx, opts) {
@@ -4186,11 +4372,11 @@ var testTool = {
   }
 };
 async function detectRunner(cwd) {
-  const { stat: stat10 } = await import('node:fs/promises');
+  const { stat: stat11 } = await import('node:fs/promises');
   const candidates = ["vitest.config.ts", "jest.config.js", ".mocharc.json"];
   for (const f of candidates) {
     try {
-      await stat10(path.join(cwd, f));
+      await stat11(path.join(cwd, f));
       if (f.includes("vitest")) return "vitest";
       if (f.includes("jest")) return "jest";
       if (f.includes("mocha")) return "mocha";
@@ -4204,17 +4390,14 @@ function buildArgs2(runner, input) {
   const timeout = input.timeout ?? 3e4;
   switch (runner) {
     case "vitest":
-      args.push("run", "--reporter=verbose");
-      if (input.watch) {
-        args[1] = "";
-        args.push("watch");
-      }
+      args.push(input.watch ? "watch" : "run");
+      if (input.verbose) args.push("--reporter=verbose");
       if (input.coverage) args.push("--coverage");
       if (input.grep) args.push("--testNamePattern", input.grep);
       args.push("--testTimeout", String(timeout));
       break;
     case "jest":
-      args.push("--verbose");
+      if (input.verbose) args.push("--verbose");
       if (input.watch) args.push("--watch");
       if (input.coverage) args.push("--coverage");
       if (input.grep) args.push("--testPathPattern", input.grep);
@@ -4258,7 +4441,13 @@ function parseResult(runner, result, duration) {
     passed,
     failed,
     duration_ms: duration,
-    output: normalizeCommandOutput(result.stdout || result.error || ""),
+    // A passing run only needs the tail summary in chat history — counts are
+    // already parsed above and the FULL log is on disk (spool marker rides
+    // the stdout tail). Failures keep the standard command-output cap so
+    // the agent sees the failure details inline.
+    output: normalizeCommandOutput(result.stdout || result.error || "", {
+      maxBytes: result.exitCode === 0 ? 4096 : void 0
+    }),
     truncated: result.truncated
   };
 }
@@ -4539,7 +4728,7 @@ function runOutdated(manager, args, cwd, signal) {
     const MAX = 1e5;
     const resolved = resolveWin32Command(manager);
     const needsShell = process.platform === "win32" && (resolved.endsWith(".cmd") || resolved.endsWith(".bat"));
-    const child = spawn(resolved, args, { cwd, signal, env: buildChildEnv(), stdio: ["ignore", "pipe", "pipe"], ...needsShell ? { shell: true, windowsVerbatimArguments: true } : {} });
+    const child = spawn(resolved, args, { cwd, signal, env: buildChildEnv(), stdio: ["ignore", "pipe", "pipe"], windowsHide: true, ...needsShell ? { shell: true, windowsVerbatimArguments: true } : {} });
     child.stdout?.on("data", (c) => {
       if (stdout.length < MAX) stdout += c.toString();
     });
@@ -4693,7 +4882,7 @@ async function dockerLogs(service, lines, filterRe, cwd, signal, since) {
       clearTimeout(timer);
       resolve7(result);
     };
-    const child = spawn("docker", args, { cwd, signal, env: buildChildEnv(), stdio: ["ignore", "pipe", "pipe"] });
+    const child = spawn("docker", args, { cwd, signal, env: buildChildEnv(), stdio: ["ignore", "pipe", "pipe"], windowsHide: true });
     const timer = setTimeout(() => {
       child.kill("SIGTERM");
       finish(empty());
@@ -4724,7 +4913,7 @@ async function dockerLogs(service, lines, filterRe, cwd, signal, since) {
 }
 var DOCKER_LOGS_TIMEOUT_MS = 3e3;
 var MAX_TAIL_LINES = 1e5;
-async function fileLogs(path20, lines, filterRe, stream) {
+async function fileLogs(path21, lines, filterRe, stream) {
   const { createInterface } = await import('node:readline');
   const { createReadStream } = await import('node:fs');
   const entries = [];
@@ -4733,7 +4922,7 @@ async function fileLogs(path20, lines, filterRe, stream) {
   let writeIdx = 0;
   let totalLines = 0;
   const rl = createInterface({
-    input: createReadStream(path20),
+    input: createReadStream(path21),
     crlfDelay: Number.POSITIVE_INFINITY
   });
   for await (const line of rl) {
@@ -4754,7 +4943,7 @@ async function fileLogs(path20, lines, filterRe, stream) {
     if (parsed) entries.push(parsed);
   }
   return {
-    source: path20,
+    source: path21,
     entries,
     total: entries.length,
     truncated: totalLines > effLines,
@@ -4877,8 +5066,8 @@ async function resolveFiles2(filesInput, cwd) {
   for (const f of files) {
     const absPath = f.trim().startsWith("/") ? f.trim() : `${cwd}/${f.trim()}`;
     try {
-      const stat10 = await fs4.stat(absPath);
-      if (stat10.isFile()) resolved.push(absPath);
+      const stat11 = await fs4.stat(absPath);
+      if (stat11.isFile()) resolved.push(absPath);
     } catch {
     }
   }
@@ -5754,8 +5943,91 @@ ${mode.description}`
   };
 }
 
+// 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) {
@@ -5790,6 +6062,94 @@ function lspKindToInternalKind(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(query2, filter) {
+    const qTokens = tokenise(query2);
+    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) {
@@ -5825,15 +6185,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);
     fs7.mkdirSync(this.indexDir, { recursive: true });
     const Database = loadDatabaseSync();
     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");
+    } catch {
+    }
     this.initSchema();
   }
   initSchema() {
@@ -5842,6 +6266,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,
@@ -5882,53 +6321,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(
@@ -5995,15 +6457,103 @@ var IndexStore = class {
       lspKind: filter?.lspKind
     }));
   }
-  getAllIndexable() {
-    return this.db.prepare("SELECT id, text FROM symbols").all().map(
-      ({ id, text }) => ({ id, text })
-    );
-  }
   /**
-   * Largest symbol id currently in the table (0 when empty). New ids must be
-   * allocated from this, NOT from `COUNT(*)`: incremental reindexes delete a
-   * changed file's rows, so the row count drops below the max id and a
+   * 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(query2, filter, limit) {
+    const tokens = tokenise(query2);
+    if (tokens.length === 0 || !this.ftsAvailable) {
+      return this.searchRankedFallback(query2, 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(query2, filter, limit) {
+    const candidates = this.search(query2, filter);
+    if (candidates.length === 0) return { results: [], total: 0 };
+    if (!query2.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(query2, (id) => candidates.some((c) => c.id === id));
+    scored.sort((a, b) => b.score - a.score);
+    const qTokens = tokenise(query2);
+    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 })
+    );
+  }
+  /**
+   * Largest symbol id currently in the table (0 when empty). New ids must be
+   * allocated from this, NOT from `COUNT(*)`: incremental reindexes delete a
+   * changed file's rows, so the row count drops below the max id and a
    * count-based id would collide with a surviving row (UNIQUE constraint on
    * `symbols.id`). Ids may have gaps — that is fine.
    */
@@ -6044,14 +6594,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 ────────────────────────────────────────────────────────────────
   /**
@@ -6059,46 +6614,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?).
@@ -6859,7 +7420,7 @@ function parseSymbols4(opts) {
 }
 function checkNativeParser() {
   try {
-    execFileSync("rustc", ["--version"], { stdio: "pipe" });
+    execFileSync("rustc", ["--version"], { stdio: "pipe", windowsHide: true });
     const toolsDir = path.join(process.cwd(), "tools");
     try {
       execFileSync(
@@ -6872,7 +7433,7 @@ function checkNativeParser() {
           "--manifest-path",
           path.join(toolsDir, "Cargo.toml")
         ],
-        { stdio: "pipe" }
+        { stdio: "pipe", windowsHide: true }
       );
       return true;
     } catch {
@@ -6895,7 +7456,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) {
@@ -7309,10 +7871,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,
@@ -7379,126 +7937,6 @@ 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()
-  };
-}
-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() {
@@ -7636,25 +8074,25 @@ 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);
     }
-    let stat10;
+    let stat11;
     try {
       const statOpts = signal ? { signal } : {};
-      stat10 = await fs4.stat(file, statOpts);
+      stat11 = await fs4.stat(file, statOpts);
     } catch (e) {
       if (isAbortError(e)) throw e;
       store.deleteFile(file);
       continue;
     }
-    if (!stat10.isFile()) continue;
+    if (!stat11.isFile()) continue;
     const lang = detectLang(file);
     if (!lang) continue;
     const meta = existingMeta.get(file);
-    if (!force && meta && meta.mtimeMs === Math.floor(stat10.mtimeMs)) {
+    if (!force && meta && meta.mtimeMs === Math.floor(stat11.mtimeMs)) {
       langStats[lang] = (langStats[lang] ?? 0) + meta.symbolCount;
       symbolsIndexed += meta.symbolCount;
       filesIndexed++;
@@ -7681,7 +8119,7 @@ async function runIndexerWithStore(store, opts) {
       store.upsertFile({
         file,
         lang,
-        mtimeMs: Math.floor(stat10.mtimeMs),
+        mtimeMs: Math.floor(stat11.mtimeMs),
         symbolCount: 0,
         lastIndexed: Date.now()
       });
@@ -7707,7 +8145,7 @@ async function runIndexerWithStore(store, opts) {
     store.upsertFile({
       file,
       lang,
-      mtimeMs: Math.floor(stat10.mtimeMs),
+      mtimeMs: Math.floor(stat11.mtimeMs),
       symbolCount: count,
       lastIndexed: Date.now()
     });
@@ -7731,6 +8169,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:" && fs7.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((resolve7, 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();
+        resolve7(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",
@@ -7766,103 +8563,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(query2, filter) {
-    const qTokens = tokenise(query2);
-    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" : "");
   }
 };
 
@@ -7908,7 +8626,7 @@ var codebaseSearchTool = {
     },
     required: ["query"]
   },
-  async execute(input, ctx) {
+  async execute(input, ctx, execOpts) {
     const state = getIndexState();
     if (!state.ready) {
       return {
@@ -7927,51 +8645,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 };
   }
 };
 
@@ -7990,7 +8687,7 @@ var codebaseStatsTool = {
     properties: {},
     additionalProperties: false
   },
-  async execute(_input, ctx) {
+  async execute(_input, ctx, execOpts) {
     const idxState = getIndexState();
     if (!idxState.ready) {
       return {
@@ -8005,34 +8702,30 @@ 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.`
+      } : {}
+    };
   }
 };
 var setWorkingDirTool = {
@@ -8430,6 +9123,6 @@ var builtinToolsPack = {
   tools: builtinTools
 };
 
-export { CircuitBreaker, _resetProcessRegistry, auditTool, bashTool, batchToolUseTool, builtinTools, builtinToolsPack, cancelPendingReindexes, codebaseIndexTool, codebaseSearchTool, codebaseStatsTool, createModeTool, diffTool, documentTool, editTool, enqueueReindex, execTool, fetchTool, forgetTool, formatTool, getIndexState, getProcessRegistry, gitTool, globTool, grepTool, installTool, isIndexReady, isIndexableFile, isIndexing, jsonTool, lintTool, logsTool, onIndexStateChange, outdatedTool, patchTool, planTool, readTool, relatedMemoryTool, rememberTool, replaceTool, runStartupIndex, scaffoldTool, searchMemoryTool, searchTool, testTool, todoTool, toolHelpTool, toolSearchTool, toolUseTool, treeTool, typecheckTool, writeTool };
+export { CircuitBreaker, CircuitOpenError, IndexCircuitBreaker, IndexTimeoutError, _resetProcessRegistry, auditTool, bashTool, batchToolUseTool, builtinTools, builtinToolsPack, cancelPendingReindexes, codebaseIndexStats, codebaseIndexTool, codebaseSearchTool, codebaseStatsTool, createModeTool, diffTool, documentTool, editTool, enqueueReindex, execTool, fetchTool, forgetTool, formatTool, getIndexState, getProcessRegistry, gitTool, globTool, grepTool, indexCircuitBreaker, installTool, isIndexReady, isIndexableFile, isIndexing, jsonTool, lintTool, logsTool, onIndexStateChange, outdatedTool, patchTool, planTool, readTool, relatedMemoryTool, rememberTool, replaceTool, resetIndexCircuitBreaker, runStartupIndex, scaffoldTool, searchCodebaseIndex, searchMemoryTool, searchTool, shutdownCodebaseIndexHost, testTool, todoTool, toolHelpTool, toolSearchTool, toolUseTool, treeTool, typecheckTool, writeTool };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map