@wrongstack/tools 0.155.0 → 0.250.0

package/dist/index.js

@@ -1,8 +1,8 @@
 import * as fs4 from 'node:fs/promises';
 import * as path from 'node:path';
-import { resolve, sep, dirname } 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, emptyPlan, clearPlan, savePlan, getPlanTemplate, addPlanItem, deriveTodosFromPlanItem, removePlanItem, setPlanItemStatus, formatPlan, loadTasks, emptyTaskFile, saveTasks, computeTaskItemProgress, formatTaskList, 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, 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';
@@ -11,7 +11,10 @@ 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) {
@@ -29,7 +32,7 @@ async function detectPackageManager(cwd) {
   return "npm";
 }
 function resolvePath(input, ctx) {
-  return path.isAbsolute(input) ? path.normalize(input) : path.resolve(ctx.cwd, input);
+  return path.isAbsolute(input) ? path.normalize(input) : path.resolve(ctx.workingDir ?? ctx.cwd, input);
 }
 function ensureInsideRoot(absPath, ctx) {
   const root = path.resolve(ctx.projectRoot);
@@ -598,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 {
@@ -611,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) => {
@@ -827,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 {
@@ -857,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 = () => {
@@ -1098,8 +1102,13 @@ var CircuitBreaker = class {
    * Call this BEFORE spawning a bash/exec process.
    * Returns true if the call is allowed; false if the breaker is open.
    * When false, callers MUST NOT spawn a process.
+   *
+   * @param bypass - If true, skip the circuit breaker check entirely.
+   *                  Use for background/fire-and-forget processes that should
+   *                  not affect breaker state.
    */
-  beforeCall() {
+  beforeCall(bypass = false) {
+    if (bypass) return true;
     this._checkStateTransition();
     if (this.state === "open") return false;
     return true;
@@ -1109,8 +1118,12 @@ var CircuitBreaker = class {
    * `durationMs` is the wall-clock time the process ran.
    * `failed` is true when the process returned a non-zero exit code or
    * threw an exception before spawning.
+   *
+   * @param bypass - If true, do not update breaker state.
+   *                  Use for background/fire-and-forget processes.
    */
-  afterCall(durationMs, failed) {
+  afterCall(durationMs, failed, bypass = false) {
+    if (bypass) return;
     const now = Date.now();
     if (this.state === "half-open") {
       if (failed) {
@@ -1209,6 +1222,17 @@ function redactCommand(cmd) {
   return result;
 }
 var DEFAULT_GRACE_MS = 2e3;
+function killWin32Tree(pid) {
+  try {
+    spawn("taskkill", ["/pid", String(pid), "/T", "/F"], {
+      stdio: "ignore",
+      windowsHide: true
+    }).unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
 var ProcessRegistryImpl = class {
   processes = /* @__PURE__ */ new Map();
   breaker;
@@ -1266,16 +1290,20 @@ var ProcessRegistryImpl = class {
   /**
    * Called before spawning a process. Returns true if allowed; false if
    * the circuit breaker is open.
+   *
+   * @param bypass - If true, skip circuit breaker check (for background processes).
    */
-  beforeCall() {
-    return this.breaker.beforeCall();
+  beforeCall(bypass = false) {
+    return this.breaker.beforeCall(bypass);
   }
   /**
    * Called after a process finishes. `durationMs` is wall-clock time;
    * `failed` is true for non-zero exit codes.
+   *
+   * @param bypass - If true, do not update circuit breaker state (for background processes).
    */
-  afterCall(durationMs, failed) {
-    this.breaker.afterCall(durationMs, failed);
+  afterCall(durationMs, failed, bypass = false) {
+    this.breaker.afterCall(durationMs, failed, bypass);
   }
   /** Force-open the circuit breaker (Ctrl+C, /kill force). */
   forceBreakerOpen() {
@@ -1306,9 +1334,22 @@ var ProcessRegistryImpl = class {
     const { force = false, graceMs = DEFAULT_GRACE_MS } = opts;
     const isWin = os.platform() === "win32";
     if (isWin) {
-      try {
-        p.child.kill(force ? "SIGKILL" : "SIGTERM");
-      } catch {
+      const liveRealChild = p.child.exitCode === null && typeof p.child.pid === "number";
+      if (liveRealChild && killWin32Tree(pid)) {
+        const fallback = setTimeout(() => {
+          if (p.child.exitCode === null) {
+            try {
+              p.child.kill("SIGKILL");
+            } catch {
+            }
+          }
+        }, graceMs);
+        fallback.unref?.();
+      } else {
+        try {
+          p.child.kill(force ? "SIGKILL" : "SIGTERM");
+        } catch {
+        }
       }
       p.killed = true;
       return true;
@@ -1387,6 +1428,7 @@ var MAX_OUTPUT = 32768;
 var DEFAULT_TIMEOUT_MS = 3e5;
 var STREAM_FLUSH_INTERVAL_MS = 200;
 var STREAM_FLUSH_BYTES = 4 * 1024;
+var MAX_QUEUE_CHUNKS = 500;
 var bashTool = {
   name: "bash",
   category: "Shell",
@@ -1434,7 +1476,8 @@ var bashTool = {
   async *executeStream(input, ctx, opts) {
     if (!input?.command) throw new Error("bash: command is required");
     const registry = getProcessRegistry();
-    if (!registry.beforeCall()) {
+    const bypassBreaker = !!input.background;
+    if (!registry.beforeCall(bypassBreaker)) {
       yield {
         type: "final",
         output: {
@@ -1447,6 +1490,17 @@ var bashTool = {
       };
       return;
     }
+    const PIPE_TO_SHELL_PATTERN = /\|\s*(sh|bash|ksh|zsh|fish|cmd|powershell|pwsh)/i;
+    if (PIPE_TO_SHELL_PATTERN.test(input.command)) {
+      console.warn(JSON.stringify({
+        level: "warn",
+        event: "bash.pipe_to_shell_detected",
+        message: "Detected pipe-to-shell pattern. Consider reviewing the full command before confirming.",
+        command_prefix: input.command.slice(0, 100),
+        // Log first 100 chars for review
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }));
+    }
     const timeoutMs = Math.max(1, Math.min(input.timeout_ms ?? DEFAULT_TIMEOUT_MS, 6e5));
     const isWin = os.platform() === "win32";
     const shell = (() => {
@@ -1472,6 +1526,10 @@ var bashTool = {
         env,
         stdio: ["ignore", "pipe", "pipe"],
         detached: true,
+        // Detached console children on Windows allocate their own VISIBLE
+        // console window (one per background command — test suites flash
+        // dozens). CREATE_NO_WINDOW suppresses it; no-op elsewhere.
+        windowsHide: true,
         signal: opts.signal
       });
       const pid2 = child2.pid;
@@ -1505,7 +1563,7 @@ var bashTool = {
         }
       });
       child2.on("close", () => {
-        registry.afterCall(Date.now() - startedAt, false);
+        registry.afterCall(Date.now() - startedAt, false, bypassBreaker);
       });
       if (typeof pid2 === "number") child2.unref();
       yield {
@@ -1524,7 +1582,8 @@ var bashTool = {
       env,
       stdio: ["ignore", "pipe", "pipe"],
       detached,
-      signal: opts.signal
+      windowsHide: true,
+      ...isWin ? {} : { signal: opts.signal }
     });
     const pid = child.pid;
     if (typeof pid === "number") {
@@ -1538,14 +1597,27 @@ var bashTool = {
       });
     }
     let buf = "";
-    let pending = "";
+    let pending2 = "";
     let timedOut = false;
     const timers = [];
     function killWithTimeout(child2, timeoutMs2) {
       if (isWin) {
-        try {
-          child2.kill();
-        } catch {
+        if (typeof child2.pid === "number" && child2.exitCode === null && killWin32Tree(child2.pid)) {
+          const fallback = setTimeout(() => {
+            if (child2.exitCode === null) {
+              try {
+                child2.kill();
+              } catch {
+              }
+            }
+          }, 2e3);
+          timers.push(fallback);
+          fallback.unref?.();
+        } else {
+          try {
+            child2.kill();
+          } catch {
+          }
         }
         return;
       }
@@ -1584,6 +1656,11 @@ var bashTool = {
     }, timeoutMs);
     timers.push(timer);
     timer.unref?.();
+    const onAbort = () => killWithTimeout(child, 2e3);
+    if (isWin) {
+      if (opts.signal.aborted) onAbort();
+      else opts.signal.addEventListener("abort", onAbort, { once: true });
+    }
     const queue = [];
     let resolveNext = null;
     const push = (c) => {
@@ -1602,24 +1679,38 @@ 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;
     };
-    child.stdout?.on("data", (chunk) => {
-      const text = chunk.toString();
-      buf += text;
-      pending += text;
-      push({ kind: "data", text });
-    });
-    child.stderr?.on("data", (chunk) => {
+    let paused = false;
+    const pauseIfFlooded = () => {
+      if (!paused && queue.length >= MAX_QUEUE_CHUNKS) {
+        paused = true;
+        child.stdout?.pause();
+        child.stderr?.pause();
+      }
+    };
+    const resumeIfDrained = () => {
+      if (paused && queue.length < MAX_QUEUE_CHUNKS) {
+        paused = false;
+        child.stdout?.resume();
+        child.stderr?.resume();
+      }
+    };
+    const onData = (chunk) => {
       const text = chunk.toString();
-      buf += text;
-      pending += text;
+      if (buf.length < MAX_OUTPUT) {
+        buf += text.slice(0, MAX_OUTPUT - buf.length);
+      }
+      pending2 += text;
       push({ kind: "data", text });
-    });
+      pauseIfFlooded();
+    };
+    child.stdout?.on("data", onData);
+    child.stderr?.on("data", onData);
     child.on("error", (err) => {
       for (const t of timers) clearTimeout(t);
       registry.afterCall(Date.now() - startedAt, true);
@@ -1634,6 +1725,7 @@ var bashTool = {
     try {
       while (true) {
         const c = await next();
+        resumeIfDrained();
         if (c.kind === "error") throw c.err;
         if (c.kind === "end") {
           const remainder = flush();
@@ -1651,13 +1743,22 @@ 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);
+      if (isWin) opts.signal.removeEventListener("abort", onAbort);
+      child.stdout?.off("data", onData);
+      child.stderr?.off("data", onData);
+      child.stdout?.destroy();
+      child.stderr?.destroy();
+      if (child.exitCode === null && !child.killed) {
+        if (typeof pid === "number") registry.kill(pid, { force: true });
+        else killWithTimeout(child, 2e3);
+      }
     }
   }
 };
@@ -1890,12 +1991,14 @@ function runCommand(cmd, args, cwd, timeout, signal, sessionId) {
     let killed = false;
     const startedAt = Date.now();
     const resolved = resolveWin32Command(cmd);
-    const needsShell = process.platform === "win32" && (resolved.endsWith(".cmd") || resolved.endsWith(".bat"));
+    const isWin = process.platform === "win32";
+    const needsShell = isWin && (resolved.endsWith(".cmd") || resolved.endsWith(".bat"));
     const child = spawn(resolved, args, {
       cwd,
-      signal,
       env: buildChildEnv(sessionId),
       stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true,
+      ...isWin ? {} : { signal },
       ...needsShell ? { shell: true, windowsVerbatimArguments: true } : {}
     });
     const registry = getProcessRegistry();
@@ -1909,6 +2012,15 @@ function runCommand(cmd, args, cwd, timeout, signal, sessionId) {
       if (typeof pid === "number") registry.kill(pid);
       else child.kill("SIGTERM");
     }, timeout);
+    const onAbort = () => {
+      killed = true;
+      if (typeof pid === "number") registry.kill(pid, { force: true });
+      else child.kill("SIGTERM");
+    };
+    if (isWin) {
+      if (signal.aborted) onAbort();
+      else signal.addEventListener("abort", onAbort, { once: true });
+    }
     child.stdout?.on("data", (chunk) => {
       if (stdout.length < MAX_OUTPUT2) stdout += chunk.toString();
     });
@@ -1917,6 +2029,7 @@ function runCommand(cmd, args, cwd, timeout, signal, sessionId) {
     });
     child.on("close", (code) => {
       clearTimeout(timer);
+      if (isWin) signal.removeEventListener("abort", onAbort);
       if (typeof pid === "number") registry.unregister(pid);
       const durationMs = Date.now() - startedAt;
       const exitCode = killed ? 124 : code ?? 1;
@@ -1933,6 +2046,7 @@ function runCommand(cmd, args, cwd, timeout, signal, sessionId) {
     });
     child.on("error", (err) => {
       clearTimeout(timer);
+      if (isWin) signal.removeEventListener("abort", onAbort);
       if (typeof pid === "number") registry.unregister(pid);
       registry.afterCall(Date.now() - startedAt, true);
       resolve7({
@@ -2350,13 +2464,24 @@ var searchTool = {
 async function duckduckgoSearch(query2, num, signal) {
   const encoded = encodeURIComponent(query2);
   const url = `https://lite.duckduckgo.com/lite/?q=${encoded}&kd=-1&kl=wt-wt`;
-  const results = await fetchWithTimeout(url, signal, TIMEOUT_MS2).then((r) => r.text()).then((html) => parseDuckDuckGo(html, num)).catch(() => [{ title: "Search unavailable", url: "", snippet: "Could not reach DuckDuckGo" }]);
-  return {
-    query: query2,
-    results,
-    source: "duckduckgo",
-    truncated: results.length >= num
-  };
+  try {
+    const response = await fetchWithTimeout(url, signal, TIMEOUT_MS2);
+    const html = await response.text();
+    const results = parseDuckDuckGo(html, num);
+    return {
+      query: query2,
+      results,
+      source: "duckduckgo",
+      truncated: results.length >= num
+    };
+  } catch {
+    return {
+      query: query2,
+      results: [{ title: "Search unavailable", url: "", snippet: "Could not reach DuckDuckGo" }],
+      source: "duckduckgo",
+      truncated: false
+    };
+  }
 }
 function takeFrom(iter, max) {
   const out = [];
@@ -2475,21 +2600,11 @@ async function fetchWithTimeout(url, signal, timeoutMs) {
   }
 }
 function anySignal(...signals) {
-  const controller = new AbortController();
-  for (const s of signals) {
-    if (s.aborted) {
-      controller.abort();
-      break;
-    }
-    s.addEventListener("abort", () => controller.abort());
-  }
-  return controller.signal;
+  return AbortSignal.any(signals);
 }
 function stripTags2(html) {
   return html.replace(/<[^>]+>/g, "").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").trim();
 }
-
-// src/todo.ts
 var todoTool = {
   name: "todo",
   category: "Session",
@@ -2548,6 +2663,48 @@ var todoTool = {
       }
     }
     ctx.state.replaceTodos(items);
+    const completedPlanIds = /* @__PURE__ */ new Set();
+    const completedTaskIds = /* @__PURE__ */ new Set();
+    const pendingPlanIds = /* @__PURE__ */ new Set();
+    const pendingTaskIds = /* @__PURE__ */ new Set();
+    for (const item of items) {
+      if (item.promotedFromPlan) {
+        (item.status === "completed" ? completedPlanIds : pendingPlanIds).add(item.promotedFromPlan);
+      }
+      if (item.promotedFromTask) {
+        (item.status === "completed" ? completedTaskIds : pendingTaskIds).add(item.promotedFromTask);
+      }
+    }
+    for (const planId of completedPlanIds) {
+      if (pendingPlanIds.has(planId)) continue;
+      const planPath = ctx.meta["plan.path"];
+      if (typeof planPath !== "string" || !planPath) continue;
+      try {
+        const plan = await loadPlan(planPath);
+        if (plan) {
+          const updated = setPlanItemStatus(plan, planId, "done");
+          await savePlan(planPath, updated);
+        }
+      } catch {
+      }
+    }
+    for (const taskId of completedTaskIds) {
+      if (pendingTaskIds.has(taskId)) continue;
+      const taskPath = ctx.meta["task.path"];
+      if (typeof taskPath !== "string" || !taskPath) continue;
+      try {
+        const file = await loadTasks(taskPath);
+        if (file) {
+          const task = file.tasks.find((t) => t.id === taskId);
+          if (task && task.status !== "completed") {
+            task.status = "completed";
+            task.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+            await saveTasks(taskPath, file);
+          }
+        }
+      } catch {
+      }
+    }
     return {
       count: items.length,
       in_progress: items.filter((t) => t.status === "in_progress").length
@@ -2558,7 +2715,7 @@ var planTool = {
   name: "plan",
   category: "Session",
   description: "Manage a persistent strategic plan for the current session. Unlike todos, plans are meant for higher-level, multi-phase approaches and survive across conversation resumptions. Use this to outline big-picture work, then promote concrete items into the todo list when ready to execute.",
-  usageHint: 'RECOMMENDED FOR COMPLEX, MULTI-PHASE WORK:\n\n- Start by creating a high-level plan with `action: "add"` or using templates (`template_use`).\n- Use `promote` to turn a plan item into actionable todos.\n- Keep plans at the "why and what" level, and todos at the "how and next step" level.\n- Common templates: "new-feature", "bug-fix", "refactor", "release", "security-audit".\n\nThis tool is excellent for maintaining long-term direction across many turns or even multiple sessions.',
+  usageHint: 'RECOMMENDED FOR COMPLEX, MULTI-PHASE WORK:\n\n- Start by creating a high-level plan with `action: "add"` or using templates (`template_use`).\n- Use `promote` to turn a plan item into actionable todos.\n- Use `taskify` to convert a plan item into a structured task (with type/priority/deps).\n- Keep plans at the "why and what" level, and todos at the "how and next step" level.\n- Common templates: "new-feature", "bug-fix", "refactor", "release", "security-audit".\n\nThis tool is excellent for maintaining long-term direction across many turns or even multiple sessions.',
   permission: "confirm",
   mutating: true,
   capabilities: ["fs.write"],
@@ -2575,9 +2732,9 @@ var planTool = {
           "done",
           "remove",
           "promote",
-          "derive",
           "template_use",
-          "clear"
+          "clear",
+          "taskify"
         ],
         description: "The operation to perform on the plan board."
       },
@@ -2596,7 +2753,7 @@ var planTool = {
       subtasks: {
         type: "array",
         items: { type: "string" },
-        description: "List of subtask titles. Used with promote or derive to break a plan item into multiple todos."
+        description: "List of subtask titles. Used with promote to break a plan item into multiple todos."
       },
       template: {
         type: "string",
@@ -2617,92 +2774,151 @@ var planTool = {
       };
     }
     const sessionId = ctx.session?.id ?? "unknown";
-    let plan = await loadPlan(planPath) ?? emptyPlan(sessionId);
-    switch (input.action) {
-      case "show":
-        break;
-      case "add": {
-        const title = input.title?.trim();
-        if (!title) {
-          return mkResult(plan, false, "add requires `title`.");
-        }
-        ({ plan } = addPlanItem(plan, title, input.details?.trim() || void 0));
-        await savePlan(planPath, plan);
-        break;
-      }
-      case "start":
-      case "done": {
-        if (!input.target) {
-          return mkResult(plan, false, `${input.action} requires \`target\` (id|index|substring).`);
+    let early = null;
+    const taskifyMeta = { title: "", details: "" };
+    let didTaskify = false;
+    const plan = await mutatePlan(planPath, sessionId, async (p) => {
+      switch (input.action) {
+        case "show":
+          break;
+        case "add": {
+          const title = input.title?.trim();
+          if (!title) {
+            early = mkResult(p, false, "add requires `title`.");
+            return p;
+          }
+          const { plan: updated } = addPlanItem(p, title, input.details?.trim() || void 0);
+          return updated;
         }
-        const next = setPlanItemStatus(
-          plan,
-          input.target,
-          input.action === "start" ? "in_progress" : "done"
-        );
-        if (next === plan) {
-          return mkResult(plan, false, `No plan item matched "${input.target}".`);
+        case "start":
+        case "done": {
+          if (!input.target) {
+            early = mkResult(p, false, `${input.action} requires \`target\` (id|index|substring).`);
+            return p;
+          }
+          const next = setPlanItemStatus(
+            p,
+            input.target,
+            input.action === "start" ? "in_progress" : "done"
+          );
+          if (next === p) {
+            early = mkResult(p, false, `No plan item matched "${input.target}".`);
+            return p;
+          }
+          return next;
         }
-        plan = next;
-        await savePlan(planPath, plan);
-        break;
-      }
-      case "remove": {
-        if (!input.target) {
-          return mkResult(plan, false, "remove requires `target` (id|index|substring).");
+        case "remove": {
+          if (!input.target) {
+            early = mkResult(p, false, "remove requires `target` (id|index|substring).");
+            return p;
+          }
+          const next = removePlanItem(p, input.target);
+          if (next === p) {
+            early = mkResult(p, false, `No plan item matched "${input.target}".`);
+            return p;
+          }
+          return next;
         }
-        const next = removePlanItem(plan, input.target);
-        if (next === plan) {
-          return mkResult(plan, false, `No plan item matched "${input.target}".`);
+        case "promote": {
+          if (!input.target) {
+            early = mkResult(p, false, `${input.action} requires \`target\` (id|index|substring).`);
+            return p;
+          }
+          const derived = deriveTodosFromPlanItem(p, input.target, input.subtasks);
+          if (!derived) {
+            early = mkResult(p, false, `No plan item matched "${input.target}".`);
+            return p;
+          }
+          ctx.state.replaceTodos(derived.todos);
+          early = mkResult(
+            derived.plan,
+            true,
+            `${input.action} ok \u2014 ${derived.todos.length} todo(s) created.`,
+            derived.todos
+          );
+          return derived.plan;
         }
-        plan = next;
-        await savePlan(planPath, plan);
-        break;
-      }
-      case "promote":
-      case "derive": {
-        if (!input.target) {
-          return mkResult(plan, false, `${input.action} requires \`target\` (id|index|substring).`);
+        case "template_use": {
+          const templateName = input.template?.trim();
+          if (!templateName) {
+            early = mkResult(p, false, "template_use requires `template` name.");
+            return p;
+          }
+          const template = getPlanTemplate(templateName);
+          if (!template) {
+            early = mkResult(p, false, `Unknown template "${templateName}".`);
+            return p;
+          }
+          let updated = p;
+          for (const item of template.items) {
+            ({ plan: updated } = addPlanItem(updated, item.title, item.details));
+          }
+          early = mkResult(
+            updated,
+            true,
+            `Applied template "${template.name}" \u2014 ${template.items.length} items added.`
+          );
+          return updated;
         }
-        const derived = deriveTodosFromPlanItem(plan, input.target, input.subtasks);
-        if (!derived) {
-          return mkResult(plan, false, `No plan item matched "${input.target}".`);
+        case "clear":
+          return clearPlan(p);
+        case "taskify": {
+          if (!input.target) {
+            early = mkResult(p, false, "taskify requires `target` (plan item id|index|substring).");
+            return p;
+          }
+          let itemIdx = -1;
+          const asNum = Number.parseInt(input.target, 10);
+          if (!Number.isNaN(asNum) && asNum >= 1 && asNum <= p.items.length) {
+            itemIdx = asNum - 1;
+          } else {
+            itemIdx = p.items.findIndex((it) => it.id === input.target);
+            if (itemIdx === -1) {
+              const lower = input.target.toLowerCase();
+              itemIdx = p.items.findIndex((it) => it.title.toLowerCase().includes(lower));
+            }
+          }
+          if (itemIdx === -1 || !p.items[itemIdx]) {
+            early = mkResult(p, false, `No plan item matched "${input.target}".`);
+            return p;
+          }
+          const item = p.items[itemIdx];
+          taskifyMeta.title = item.title;
+          taskifyMeta.details = item.details ?? "";
+          didTaskify = true;
+          break;
         }
-        plan = derived.plan;
-        await savePlan(planPath, plan);
-        ctx.state.replaceTodos(derived.todos);
-        return mkResult(
-          plan,
-          true,
-          `${input.action} ok \u2014 ${derived.todos.length} todo(s) created.`,
-          derived.todos
-        );
+        default:
+          early = mkResult(p, false, `Unknown action "${input.action}".`);
+          return p;
       }
-      case "template_use": {
-        const templateName = input.template?.trim();
-        if (!templateName) {
-          return mkResult(plan, false, "template_use requires `template` name.");
-        }
-        const template = getPlanTemplate(templateName);
-        if (!template) {
-          return mkResult(plan, false, `Unknown template "${templateName}".`);
-        }
-        for (const item of template.items) {
-          ({ plan } = addPlanItem(plan, item.title, item.details));
-        }
-        await savePlan(planPath, plan);
-        return mkResult(
-          plan,
-          true,
-          `Applied template "${template.name}" \u2014 ${template.items.length} items added.`
-        );
+      return p;
+    });
+    if (early) return early;
+    if (didTaskify) {
+      const taskPath = ctx.meta["task.path"];
+      if (typeof taskPath !== "string" || !taskPath) {
+        return mkResult(plan, false, "Task storage path not configured \u2014 cannot taskify.");
       }
-      case "clear":
-        plan = clearPlan(plan);
-        await savePlan(planPath, plan);
-        break;
-      default:
-        return mkResult(plan, false, `Unknown action "${input.action}".`);
+      const taskFile = await loadTasks(taskPath) ?? emptyTaskFile(sessionId);
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      taskFile.tasks.push({
+        id: `task_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+        title: taskifyMeta.title,
+        description: taskifyMeta.details || void 0,
+        type: "feature",
+        priority: "medium",
+        status: "pending",
+        createdAt: now,
+        updatedAt: now
+      });
+      await saveTasks(taskPath, taskFile);
+      return mkResult(
+        plan,
+        true,
+        `taskify ok \u2014 added "${taskifyMeta.title}" to tasks.
+${formatTaskList(taskFile.tasks)}`
+      );
     }
     return mkResult(plan, true, `Plan ${input.action} ok.`);
   }
@@ -2944,7 +3160,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) {
@@ -3067,7 +3284,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();
     });
@@ -3306,7 +3523,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();
@@ -3531,9 +3749,10 @@ async function walkDir(dir, depth, opts) {
 async function* spawnStream(opts) {
   const max = opts.maxBytes ?? 2e5;
   const flushAt = opts.flushBytes ?? 4 * 1024;
+  const maxQueue = opts.maxQueueSize ?? 500;
   let stdout = "";
   let stderr = "";
-  let pending = "";
+  let pending2 = "";
   let error;
   const cmd = resolveWin32Command(opts.cmd);
   const needsShell = process.platform === "win32" && (cmd.endsWith(".cmd") || cmd.endsWith(".bat"));
@@ -3542,10 +3761,12 @@ async function* spawnStream(opts) {
     signal: opts.signal,
     env: buildChildEnv(),
     stdio: ["ignore", "pipe", "pipe"],
+    windowsHide: true,
     ...needsShell ? { shell: true, windowsVerbatimArguments: true } : {}
   });
   const queue = [];
   let waiter;
+  let paused = false;
   const wake = () => {
     if (waiter) {
       const w = waiter;
@@ -3553,17 +3774,34 @@ async function* spawnStream(opts) {
       w();
     }
   };
+  const resume = () => {
+    if (paused && queue.length < maxQueue) {
+      paused = false;
+      child.stdout?.resume();
+      child.stderr?.resume();
+    }
+  };
   child.stdout?.on("data", (c) => {
     const s = c.toString();
     if (stdout.length < max) stdout += s;
     queue.push({ kind: "out", data: s });
     wake();
+    if (!paused && queue.length >= maxQueue) {
+      paused = true;
+      child.stdout?.pause();
+      child.stderr?.pause();
+    }
   });
   child.stderr?.on("data", (c) => {
     const s = c.toString();
     if (stderr.length < max) stderr += s;
     queue.push({ kind: "err", data: s });
     wake();
+    if (!paused && queue.length >= maxQueue) {
+      paused = true;
+      child.stdout?.pause();
+      child.stderr?.pause();
+    }
   });
   child.on("error", (e) => {
     error = e.message;
@@ -3583,6 +3821,7 @@ async function* spawnStream(opts) {
       });
     }
     const chunk = queue.shift();
+    resume();
     if (chunk.kind === "close") {
       if (!spawnFailed) exitCode = chunk.code ?? 0;
       break;
@@ -3592,14 +3831,14 @@ async function* spawnStream(opts) {
       exitCode = 1;
       continue;
     }
-    pending += chunk.data;
-    if (pending.length >= flushAt) {
-      yield { type: "partial_output", text: pending };
-      pending = "";
+    pending2 += chunk.data;
+    if (pending2.length >= flushAt) {
+      yield { type: "partial_output", text: pending2 };
+      pending2 = "";
     }
   }
-  if (pending.length > 0) {
-    yield { type: "partial_output", text: pending };
+  if (pending2.length > 0) {
+    yield { type: "partial_output", text: pending2 };
   }
   return {
     stdout,
@@ -4035,8 +4274,6 @@ function parseResult(runner, result, duration) {
     truncated: result.truncated
   };
 }
-
-// src/install.ts
 var installTool = {
   name: "install",
   category: "Package Management",
@@ -4131,18 +4368,48 @@ var installTool = {
       signal: opts.signal,
       maxBytes: 1e5
     });
-    yield {
-      type: "final",
-      output: {
-        packages: pkgList,
-        exit_code: result.exitCode,
-        output: normalizeCommandOutput(result.stdout || result.stderr || result.error || ""),
-        dry_run: args.includes("--dry-run"),
-        truncated: result.truncated
-      }
+    const output = {
+      packages: pkgList,
+      exit_code: result.exitCode,
+      output: normalizeCommandOutput(result.stdout || result.stderr || result.error || ""),
+      dry_run: args.includes("--dry-run"),
+      truncated: result.truncated
     };
+    const isSuccess = result.exitCode === 0 && !output.dry_run && !input.global;
+    if (isSuccess && pkgList.length > 0) {
+      const trackerOpts = ctx.meta?.["packageTrackerOpts"];
+      if (trackerOpts) {
+        const manifestPath = resolveManifestPath(cwd, pkgManager);
+        for (const pkg of pkgList) {
+          try {
+            await recordPackageAction(trackerOpts, {
+              manifestPath,
+              packageName: pkg,
+              versionSpec: "latest",
+              // exact version resolved by package manager at install time
+              ecosystem: detectPackageEcosystem(manifestPath),
+              agentId: ctx.agentId,
+              agentName: ctx.agentName,
+              sessionId: ctx.session.id
+            });
+          } catch {
+          }
+        }
+      }
+    }
+    yield { type: "final", output };
   }
 };
+function resolveManifestPath(cwd, pkgManager) {
+  switch (pkgManager) {
+    case "pnpm":
+    case "yarn":
+    case "npm":
+      return join(cwd, "package.json");
+    default:
+      return join(cwd, "package.json");
+  }
+}
 
 // src/audit.ts
 var auditTool = {
@@ -4284,7 +4551,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();
     });
@@ -4438,7 +4705,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());
@@ -5499,8 +5766,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) {
@@ -5535,50 +5885,202 @@ function lspKindToInternalKind(k) {
   }
 }
 
-// src/codebase-index/writer.ts
-var DB_FILE = "index.db";
-function resolveIndexDir(projectRoot, override) {
-  return override ?? resolveWstackPaths({ projectRoot }).projectCodebaseIndex;
+// 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 codebaseIndexDirOverride(ctx) {
-  const v = ctx.meta?.["codebaseIndexDir"];
-  return typeof v === "string" ? v : void 0;
+function splitName(name) {
+  return name.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").trim();
 }
-var warningSilenced = false;
-function silenceSqliteExperimentalWarning() {
-  if (warningSilenced) return;
-  warningSilenced = true;
-  const original = process.emitWarning.bind(process);
-  process.emitWarning = ((warning, ...rest) => {
-    const msg = typeof warning === "string" ? warning : warning?.message ?? "";
-    const name = typeof warning === "string" ? String(rest[0] ?? "") : warning?.name ?? "";
-    if (/sqlite/i.test(msg) && /experimental/i.test(`${name} ${msg}`)) return;
-    original(warning, ...rest);
-  });
+function buildIndexableText(name, signature, docComment) {
+  return [splitName(name), name, signature, docComment].filter(Boolean).join(" ");
 }
-var DatabaseSyncCtor;
-function loadDatabaseSync() {
-  if (DatabaseSyncCtor) return DatabaseSyncCtor;
-  silenceSqliteExperimentalWarning();
-  try {
-    const req = createRequire(import.meta.url);
-    DatabaseSyncCtor = req("node:sqlite").DatabaseSync;
-  } catch (err) {
-    throw new Error(
-      `The codebase index needs Node's built-in SQLite (node:sqlite), available since Node 22.5. This runtime doesn't provide it: ${err instanceof Error ? err.message : String(err)}`
-    );
+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);
+      }
+    }
   }
-  return DatabaseSyncCtor;
+  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 IndexStore = class {
-  db;
-  /** Absolute path to this project's index directory. */
-  indexDir;
-  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));
+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) {
+  return override ?? resolveWstackPaths({ projectRoot }).projectCodebaseIndex;
+}
+function codebaseIndexDirOverride(ctx) {
+  const v = ctx.meta?.["codebaseIndexDir"];
+  return typeof v === "string" ? v : void 0;
+}
+var warningSilenced = false;
+function silenceSqliteExperimentalWarning() {
+  if (warningSilenced) return;
+  warningSilenced = true;
+  const original = process.emitWarning.bind(process);
+  process.emitWarning = ((warning, ...rest) => {
+    const msg = typeof warning === "string" ? warning : warning?.message ?? "";
+    const name = typeof warning === "string" ? String(rest[0] ?? "") : warning?.name ?? "";
+    if (/sqlite/i.test(msg) && /experimental/i.test(`${name} ${msg}`)) return;
+    original(warning, ...rest);
+  });
+}
+var DatabaseSyncCtor;
+function loadDatabaseSync() {
+  if (DatabaseSyncCtor) return DatabaseSyncCtor;
+  silenceSqliteExperimentalWarning();
+  try {
+    const req = createRequire(import.meta.url);
+    DatabaseSyncCtor = req("node:sqlite").DatabaseSync;
+  } catch (err) {
+    throw new Error(
+      `The codebase index needs Node's built-in SQLite (node:sqlite), available since Node 22.5. This runtime doesn't provide it: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  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() {
@@ -5587,6 +6089,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,
@@ -5627,53 +6144,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(
@@ -5740,6 +6280,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(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 })
@@ -5789,14 +6417,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 ────────────────────────────────────────────────────────────────
   /**
@@ -5804,46 +6437,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?).
@@ -6604,7 +7243,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(
@@ -6617,7 +7256,7 @@ function checkNativeParser() {
           "--manifest-path",
           path.join(toolsDir, "Cargo.toml")
         ],
-        { stdio: "pipe" }
+        { stdio: "pipe", windowsHide: true }
       );
       return true;
     } catch {
@@ -6640,7 +7279,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) {
@@ -7054,10 +7694,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,
@@ -7124,140 +7760,20 @@ 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((resolve7) => setImmediate(resolve7));
 }
-var chain = Promise.resolve();
-function withMutex(job) {
-  const run = chain.then(job, job);
-  chain = run.then(
-    () => void 0,
-    () => void 0
+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"
   );
-  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;
-  _currentFile = 0;
-  _totalFiles = 0;
-  _lastError = null;
-  emitState();
-  try {
-    const result = await withMutex(
-      () => 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((resolve7) => setImmediate(resolve7));
-}
-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) {
-  return err instanceof DOMException && err.name === "AbortError";
+function isAbortError(err) {
+  return err instanceof DOMException && err.name === "AbortError";
 }
 var DEFAULT_IGNORE5 = [
   "node_modules",
@@ -7343,8 +7859,18 @@ async function parseFile(file, content, lang) {
   }
 }
 async function runIndexer(_ctx, opts) {
-  const { projectRoot, force = false, langs, ignore = [], indexDir, signal } = opts;
-  const store = new IndexStore(projectRoot, { indexDir });
+  const store = new IndexStore(opts.projectRoot, { indexDir: opts.indexDir });
+  try {
+    return await runIndexerWithStore(store, opts);
+  } finally {
+    try {
+      store.close();
+    } catch {
+    }
+  }
+}
+async function runIndexerWithStore(store, opts) {
+  const { projectRoot, force = false, langs, ignore = [], signal } = opts;
   const startMs = Date.now();
   const errors = [];
   const langStats = {};
@@ -7371,7 +7897,7 @@ async function runIndexer(_ctx, 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);
@@ -7457,7 +7983,6 @@ async function runIndexer(_ctx, opts) {
   }
   const durationMs = Date.now() - startMs;
   store.setLastIndexed(Date.now());
-  store.close();
   return {
     filesIndexed,
     symbolsIndexed,
@@ -7467,6 +7992,349 @@ async function runIndexer(_ctx, 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;
+}
+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);
+    _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",
@@ -7502,103 +8370,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" : "");
   }
 };
 
@@ -7644,7 +8433,7 @@ var codebaseSearchTool = {
     },
     required: ["query"]
   },
-  async execute(input, ctx) {
+  async execute(input, ctx, execOpts) {
     const state = getIndexState();
     if (!state.ready) {
       return {
@@ -7663,51 +8452,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 };
   }
 };
 
@@ -7726,7 +8494,7 @@ var codebaseStatsTool = {
     properties: {},
     additionalProperties: false
   },
-  async execute(_input, ctx) {
+  async execute(_input, ctx, execOpts) {
     const idxState = getIndexState();
     if (!idxState.ready) {
       return {
@@ -7741,51 +8509,113 @@ 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();
+      return {
+        ...stats,
+        indexStatus: `Index refresh in progress (${idxState.currentFile}/${idxState.totalFiles} files). Stats may be incomplete.`
+      };
+    }
+    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 = {
+  name: "set_working_dir",
+  category: "Context",
+  description: "Change the current working directory for all subsequent file operations. The new directory must be inside the project root. Use this to navigate between subdirectories when working on files in different parts of the project.",
+  usageHint: "Change the working directory so relative paths in subsequent tool calls resolve from a different directory. Pass `path` to set a new directory, or omit to query the current one. The directory must exist and be inside the project root.",
+  permission: "confirm",
+  mutating: true,
+  capabilities: ["fs.read"],
+  timeoutMs: 5e3,
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "Directory to navigate to. Can be relative (to projectRoot) or absolute. If omitted, returns the current working directory without changing it."
       }
     }
-    const store = new IndexStore(ctx.projectRoot, { indexDir: codebaseIndexDirOverride(ctx) });
+  },
+  async execute(input, ctx, _opts) {
+    if (!input.path) {
+      return {
+        current: ctx.workingDir,
+        message: `Current working directory is ${ctx.workingDir}`
+      };
+    }
+    const previous = ctx.workingDir;
+    let resolved;
     try {
-      const stats = store.getStats();
+      resolved = ctx.setWorkingDir(input.path);
+    } catch (err) {
       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
+        current: ctx.workingDir,
+        error: err instanceof Error ? err.message : String(err)
       };
-    } finally {
-      store.close();
     }
+    try {
+      await fs4.access(resolved);
+    } catch {
+      try {
+        ctx.setWorkingDir(previous);
+      } catch {
+      }
+      return {
+        current: ctx.workingDir,
+        error: `Directory does not exist: ${resolved}`
+      };
+    }
+    return {
+      current: resolved,
+      previous,
+      message: `Working directory changed to ${resolved}`
+    };
   }
 };
+function findTaskIndex(tasks, query2) {
+  const asNum = Number.parseInt(query2, 10);
+  if (!Number.isNaN(asNum)) {
+    const idx = asNum - 1;
+    if (tasks[idx]) return idx;
+  }
+  const byId = tasks.findIndex((t) => t.id === query2);
+  if (byId >= 0) return byId;
+  const lower = query2.toLowerCase();
+  return tasks.findIndex((t) => t.title.toLowerCase().includes(lower));
+}
 var taskTool = {
   name: "task",
   category: "Session",
   description: "Manage structured work items with dependencies, types, and priorities. Use this for complex, multi-step work where tasks have ordering constraints. Unlike `todo` (flat, tactical), `task` supports typed work (feature/bugfix/refactor/etc.), dependencies between items, priority ranking, and agent assignment. The task list persists across session resumes.",
-  usageHint: 'USE FOR STRUCTURED WORK:\n- `action: "replace"` \u2014 set the complete task list (tasks ordered by priority)\n- `action: "add"` \u2014 append a single task\n- `action: "status"` \u2014 update a task\'s status (e.g. pending\u2192in_progress, in_progress\u2192completed)\n- `action: "show"` \u2014 view current tasks without changing them\n\nTask fields:\n- `dependsOn`: list of task IDs this one waits for\n- `type`: "feature" | "bugfix" | "refactor" | "docs" | "test" | "chore"\n- `priority`: "critical" | "high" | "medium" | "low"\n- `assignee`: agent/subagent name (e.g. "bug-hunter", "refactor-planner")\n- `estimateHours`: rough time estimate',
-  permission: "auto",
-  mutating: false,
+  usageHint: 'USE FOR STRUCTURED WORK:\n- `action: "replace"` \u2014 set the complete task list (tasks ordered by priority)\n- `action: "add"` \u2014 append a single task\n- `action: "status"` \u2014 update a task\'s status (e.g. pending\u2192in_progress, in_progress\u2192completed)\n- `action: "show"` \u2014 view current tasks without changing them\n- `action: "promote"` \u2014 convert a task into actionable todo items via `target` (id|index|substring)\n- `action: "planify"` \u2014 promote a task to a plan item (strategic level) via `target` (id|index|substring)\n\nTask fields:\n- `dependsOn`: list of task IDs this one waits for\n- `type`: "feature" | "bugfix" | "refactor" | "docs" | "test" | "chore"\n- `priority`: "critical" | "high" | "medium" | "low"\n- `assignee`: agent/subagent name (e.g. "bug-hunter", "refactor-planner")\n- `estimateHours`: rough time estimate',
+  permission: "confirm",
+  mutating: true,
+  capabilities: ["fs.write"],
   timeoutMs: 2e3,
   inputSchema: {
     type: "object",
     properties: {
       action: {
         type: "string",
-        enum: ["replace", "add", "status", "show"],
-        description: "replace = set full list, add = append, status = update task status, show = view only."
+        enum: ["replace", "add", "status", "show", "promote", "planify"],
+        description: "replace = set full list, add = append, status = update task status, show = view only, promote = convert task to todos, planify = convert task to plan item."
       },
       tasks: {
         type: "array",
@@ -7829,11 +8659,20 @@ var taskTool = {
         required: ["title", "type", "priority"],
         description: "Single task to append (id/createdAt/updatedAt auto-generated)."
       },
-      id: { type: "string", description: "Task id for action=status." },
+      id: { type: "string", description: "Task id for action=status or target for action=promote." },
       status: {
         type: "string",
         enum: ["pending", "in_progress", "blocked", "failed", "review", "completed"],
         description: "New status for action=status."
+      },
+      target: {
+        type: "string",
+        description: "Target task identifier (id, 1-based index, or title substring) for action=promote."
+      },
+      subtasks: {
+        type: "array",
+        items: { type: "string" },
+        description: "Optional subtask titles for action=promote. Each becomes a pending todo."
       }
     },
     required: ["action"]
@@ -7844,65 +8683,196 @@ var taskTool = {
       return { ok: false, message: "Task storage path not configured.", count: 0, completed: 0, inProgress: 0 };
     }
     const sessionId = ctx.session?.id ?? "unknown";
-    const file = await loadTasks(taskPath) ?? emptyTaskFile(sessionId);
-    switch (input.action) {
-      case "show":
-        break;
-      case "replace": {
-        if (!Array.isArray(input.tasks)) {
-          return { ok: false, message: "action=replace requires `tasks` array.", count: 0, completed: 0, inProgress: 0 };
+    let early = null;
+    const promoteMeta = { count: 0, title: "" };
+    const planifyMeta = { title: "", details: "" };
+    let didPlanify = false;
+    const file = await mutateTasks(taskPath, sessionId, async (f) => {
+      switch (input.action) {
+        case "show":
+          break;
+        case "replace": {
+          if (!Array.isArray(input.tasks)) {
+            early = { ok: false, message: "action=replace requires `tasks` array.", count: 0, completed: 0, inProgress: 0 };
+            return f;
+          }
+          const newIds = new Set(input.tasks.map((t) => t.id));
+          for (const t of input.tasks) {
+            if (t.dependsOn && t.dependsOn.length > 0) {
+              const missing = t.dependsOn.filter((d) => !newIds.has(d));
+              if (missing.length > 0) {
+                early = {
+                  ok: false,
+                  message: `dependsOn validation failed: task "${t.id}" references unknown IDs: ${missing.join(", ")}`,
+                  count: 0,
+                  completed: 0,
+                  inProgress: 0
+                };
+                return f;
+              }
+            }
+          }
+          const now = (/* @__PURE__ */ new Date()).toISOString();
+          f.tasks = input.tasks.map((t) => ({
+            ...t,
+            createdAt: t.createdAt || now,
+            updatedAt: now
+          }));
+          break;
         }
-        const now = (/* @__PURE__ */ new Date()).toISOString();
-        file.tasks = input.tasks.map((t) => ({
-          ...t,
-          createdAt: t.createdAt || now,
-          updatedAt: now
-        }));
-        await saveTasks(taskPath, file);
-        break;
-      }
-      case "add": {
-        const t = input.task;
-        if (!t || !t.title) {
-          return { ok: false, message: "action=add requires `task` with at least `title`.", count: 0, completed: 0, inProgress: 0 };
+        case "add": {
+          const t = input.task;
+          if (!t || !t.title) {
+            early = { ok: false, message: "action=add requires `task` with at least `title`.", count: 0, completed: 0, inProgress: 0 };
+            return f;
+          }
+          if (t.dependsOn && t.dependsOn.length > 0) {
+            const existingIds = new Set(f.tasks.map((e) => e.id));
+            const missing = t.dependsOn.filter((d) => !existingIds.has(d));
+            if (missing.length > 0) {
+              early = {
+                ok: false,
+                message: `dependsOn validation failed: unknown task IDs: ${missing.join(", ")}`,
+                count: 0,
+                completed: 0,
+                inProgress: 0
+              };
+              return f;
+            }
+          }
+          const now = (/* @__PURE__ */ new Date()).toISOString();
+          const newTask = {
+            id: `task_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+            title: t.title,
+            description: t.description,
+            type: t.type || "feature",
+            priority: t.priority || "medium",
+            status: t.status || "pending",
+            dependsOn: t.dependsOn,
+            assignee: t.assignee,
+            estimateHours: t.estimateHours,
+            tags: t.tags,
+            createdAt: now,
+            updatedAt: now
+          };
+          f.tasks.push(newTask);
+          break;
         }
-        const now = (/* @__PURE__ */ new Date()).toISOString();
-        const newTask = {
-          id: `task_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
-          title: t.title,
-          description: t.description,
-          type: t.type || "feature",
-          priority: t.priority || "medium",
-          status: t.status || "pending",
-          dependsOn: t.dependsOn,
-          assignee: t.assignee,
-          estimateHours: t.estimateHours,
-          tags: t.tags,
-          createdAt: now,
-          updatedAt: now
-        };
-        file.tasks.push(newTask);
-        await saveTasks(taskPath, file);
-        break;
-      }
-      case "status": {
-        if (!input.id || !input.status) {
-          return { ok: false, message: "action=status requires `id` and `status`.", count: 0, completed: 0, inProgress: 0 };
+        case "status": {
+          if (!input.id || !input.status) {
+            early = { ok: false, message: "action=status requires `id` and `status`.", count: 0, completed: 0, inProgress: 0 };
+            return f;
+          }
+          const task = f.tasks.find((t) => t.id === input.id);
+          if (!task) {
+            early = { ok: false, message: `Task "${input.id}" not found.`, count: 0, completed: 0, inProgress: 0 };
+            return f;
+          }
+          task.status = input.status;
+          task.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+          break;
+        }
+        case "promote": {
+          const target = input.target?.trim();
+          if (!target) {
+            early = { ok: false, message: "action=promote requires `target` (task id, index, or title substring).", count: 0, completed: 0, inProgress: 0 };
+            return f;
+          }
+          const idx = findTaskIndex(f.tasks, target);
+          if (idx === -1) {
+            early = { ok: false, message: `No task matched "${target}".`, count: 0, completed: 0, inProgress: 0 };
+            return f;
+          }
+          const match = f.tasks[idx];
+          if (!match) {
+            early = { ok: false, message: `No task matched "${target}".`, count: 0, completed: 0, inProgress: 0 };
+            return f;
+          }
+          if (match.status !== "completed" && match.status !== "failed") {
+            match.status = "in_progress";
+            match.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+          }
+          const todos = [];
+          const ts2 = Date.now();
+          todos.push({
+            id: `todo_${ts2}_task`,
+            content: match.title,
+            status: "in_progress",
+            activeForm: match.title,
+            promotedFromTask: match.id
+          });
+          if (match.description) {
+            todos.push({
+              id: `todo_${ts2}_${randomUUID().slice(0, 6)}`,
+              content: match.description.slice(0, 200),
+              status: "pending",
+              promotedFromTask: match.id
+            });
+          }
+          if (input.subtasks && input.subtasks.length > 0) {
+            for (const st of input.subtasks) {
+              todos.push({
+                id: `todo_${ts2}_${randomUUID().slice(0, 6)}`,
+                content: st,
+                status: "pending",
+                promotedFromTask: match.id
+              });
+            }
+          }
+          ctx.state.replaceTodos(todos);
+          promoteMeta.count = todos.length;
+          promoteMeta.title = match.title;
+          break;
         }
-        const task = file.tasks.find((t) => t.id === input.id);
-        if (!task) {
-          return { ok: false, message: `Task "${input.id}" not found.`, count: 0, completed: 0, inProgress: 0 };
+        case "planify": {
+          const target = input.target?.trim();
+          if (!target) {
+            early = { ok: false, message: "action=planify requires `target` (task id, index, or title substring).", count: 0, completed: 0, inProgress: 0 };
+            return f;
+          }
+          const idx = findTaskIndex(f.tasks, target);
+          if (idx === -1) {
+            early = { ok: false, message: `No task matched "${target}".`, count: 0, completed: 0, inProgress: 0 };
+            return f;
+          }
+          const match = f.tasks[idx];
+          if (!match) {
+            early = { ok: false, message: `No task matched "${target}".`, count: 0, completed: 0, inProgress: 0 };
+            return f;
+          }
+          planifyMeta.title = match.title;
+          planifyMeta.details = match.description ?? "";
+          didPlanify = true;
+          break;
         }
-        task.status = input.status;
-        task.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-        await saveTasks(taskPath, file);
-        break;
+        default:
+          early = { ok: false, message: `Unknown action "${input.action}". Use replace | add | status | show | promote | planify.`, count: 0, completed: 0, inProgress: 0 };
+          return f;
       }
-      default:
-        return { ok: false, message: `Unknown action "${input.action}". Use replace | add | status | show.`, count: 0, completed: 0, inProgress: 0 };
+      return f;
+    });
+    if (early) return early;
+    if (didPlanify) {
+      const { title, details } = planifyMeta;
+      const planPath = ctx.meta["plan.path"];
+      if (typeof planPath === "string" && planPath) {
+        const planCfg = await loadPlan(planPath) ?? emptyPlan(sessionId);
+        const { plan: updated } = addPlanItem(planCfg, title, details || void 0);
+        await savePlan(planPath, updated);
+        return {
+          ok: true,
+          message: `planify ok \u2014 added "${title}" to plan.
+${formatPlan(updated)}`,
+          count: file.tasks.length,
+          completed: computeTaskItemProgress(file.tasks).completed,
+          inProgress: computeTaskItemProgress(file.tasks).inProgress
+        };
+      }
+      return { ok: false, message: "Plan storage path not configured \u2014 cannot planify.", count: 0, completed: 0, inProgress: 0 };
     }
     const p = computeTaskItemProgress(file.tasks);
-    const summary = file.tasks.length > 0 ? formatTaskList(file.tasks) : "No tasks.";
+    const summary = promoteMeta.count > 0 ? `promote ok \u2014 ${promoteMeta.count} todo(s) created from "${promoteMeta.title}".
+${formatTaskList(file.tasks)}` : file.tasks.length > 0 ? formatTaskList(file.tasks) : "No tasks.";
     return {
       ok: true,
       message: summary,
@@ -7949,7 +8919,8 @@ var builtinTools = [
   toolHelpTool,
   codebaseIndexTool,
   codebaseSearchTool,
-  codebaseStatsTool
+  codebaseStatsTool,
+  setWorkingDirTool
 ];
 
 // src/pack.ts
@@ -7959,6 +8930,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