@wrongstack/tools 0.155.0 → 0.236.0

package/dist/pack.js

@@ -1,10 +1,10 @@
 import { spawn, execFileSync, spawnSync } from 'node:child_process';
 import * as Core from '@wrongstack/core';
-import { buildChildEnv, expectDefined, detectNewlineStyle, normalizeToLf, toStyle, atomicWrite, unifiedDiff, compileGlob, loadPlan, emptyPlan, clearPlan, savePlan, getPlanTemplate, addPlanItem, deriveTodosFromPlanItem, removePlanItem, setPlanItemStatus, formatPlan, loadTasks, emptyTaskFile, saveTasks, computeTaskItemProgress, formatTaskList, resolveWstackPaths } from '@wrongstack/core';
+import { buildChildEnv, expectDefined, detectNewlineStyle, normalizeToLf, toStyle, atomicWrite, unifiedDiff, compileGlob, recordPackageAction, detectPackageEcosystem, mutatePlan, clearPlan, getPlanTemplate, addPlanItem, deriveTodosFromPlanItem, removePlanItem, setPlanItemStatus, loadTasks, emptyTaskFile, saveTasks, formatTaskList, formatPlan, mutateTasks, loadPlan, emptyPlan, savePlan, computeTaskItemProgress, resolveWstackPaths } from '@wrongstack/core';
 import * as fs from 'node:fs';
 import { statSync, writeFileSync, mkdirSync } from 'node:fs';
 import * as path2 from 'node:path';
-import { resolve, sep, dirname } from 'node:path';
+import { resolve, sep, dirname, join } from 'node:path';
 import * as fs13 from 'node:fs/promises';
 import * as os from 'node:os';
 import { createRequire } from 'node:module';
@@ -12,6 +12,7 @@ import * as ts from 'typescript';
 import * as dns from 'node:dns/promises';
 import * as net from 'node:net';
 import { Agent } from 'undici';
+import { randomUUID } from 'node:crypto';
 
 // src/_spawn-stream.ts
 function resolveWin32Command(cmd) {
@@ -39,6 +40,7 @@ function resolveWin32Command(cmd) {
 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 = "";
@@ -54,6 +56,7 @@ async function* spawnStream(opts) {
   });
   const queue = [];
   let waiter;
+  let paused = false;
   const wake = () => {
     if (waiter) {
       const w = waiter;
@@ -61,17 +64,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;
@@ -91,6 +111,7 @@ async function* spawnStream(opts) {
       });
     }
     const chunk = queue.shift();
+    resume();
     if (chunk.kind === "close") {
       if (!spawnFailed) exitCode = chunk.code ?? 0;
       break;
@@ -132,7 +153,7 @@ async function detectPackageManager(cwd) {
   return "npm";
 }
 function resolvePath(input, ctx) {
-  return path2.isAbsolute(input) ? path2.normalize(input) : path2.resolve(ctx.cwd, input);
+  return path2.isAbsolute(input) ? path2.normalize(input) : path2.resolve(ctx.workingDir ?? ctx.cwd, input);
 }
 function ensureInsideRoot(absPath, ctx) {
   const root = path2.resolve(ctx.projectRoot);
@@ -423,8 +444,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;
@@ -434,8 +460,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) {
@@ -534,6 +564,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;
@@ -591,16 +632,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() {
@@ -631,9 +676,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;
@@ -709,6 +767,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",
@@ -756,7 +815,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: {
@@ -769,6 +829,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 = (() => {
@@ -827,7 +898,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 {
@@ -846,7 +917,7 @@ var bashTool = {
       env,
       stdio: ["ignore", "pipe", "pipe"],
       detached,
-      signal: opts.signal
+      ...isWin ? {} : { signal: opts.signal }
     });
     const pid = child.pid;
     if (typeof pid === "number") {
@@ -865,9 +936,22 @@ var bashTool = {
     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;
       }
@@ -906,6 +990,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) => {
@@ -930,18 +1019,32 @@ var bashTool = {
       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;
+      if (buf.length < MAX_OUTPUT) {
+        buf += text.slice(0, MAX_OUTPUT - buf.length);
+      }
       pending += 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);
@@ -956,6 +1059,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();
@@ -980,6 +1084,15 @@ var bashTool = {
       }
     } 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);
+      }
     }
   }
 };
@@ -2842,8 +2955,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 = {};
@@ -2956,7 +3079,6 @@ async function runIndexer(_ctx, opts) {
   }
   const durationMs = Date.now() - startMs;
   store.setLastIndexed(Date.now());
-  store.close();
   return {
     filesIndexed,
     symbolsIndexed,
@@ -3878,12 +4000,13 @@ 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"],
+      ...isWin ? {} : { signal },
       ...needsShell ? { shell: true, windowsVerbatimArguments: true } : {}
     });
     const registry = getProcessRegistry();
@@ -3897,6 +4020,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();
     });
@@ -3905,6 +4037,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;
@@ -3921,6 +4054,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({
@@ -5042,8 +5176,6 @@ async function runNative(input, base, mode, limit, signal) {
     used: "native"
   };
 }
-
-// src/install.ts
 var installTool = {
   name: "install",
   category: "Package Management",
@@ -5138,18 +5270,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");
+  }
+}
 var jsonTool = {
   name: "json",
   category: "Data",
@@ -5779,7 +5941,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"],
@@ -5796,9 +5958,9 @@ var planTool = {
           "done",
           "remove",
           "promote",
-          "derive",
           "template_use",
-          "clear"
+          "clear",
+          "taskify"
         ],
         description: "The operation to perform on the plan board."
       },
@@ -5817,7 +5979,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",
@@ -5838,92 +6000,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.`);
   }
@@ -6469,13 +6690,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_MS3).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_MS3);
+    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 = [];
@@ -6594,34 +6826,92 @@ 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();
 }
+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."
+      }
+    }
+  },
+  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 {
+      resolved = ctx.setWorkingDir(input.path);
+    } catch (err) {
+      return {
+        current: ctx.workingDir,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+    try {
+      await fs13.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",
@@ -6665,11 +6955,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"]
@@ -6680,65 +6979,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;
         }
-        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 "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;
         }
-        task.status = input.status;
-        task.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-        await saveTasks(taskPath, file);
-        break;
+        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;
+        }
+        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,
@@ -6896,8 +7326,6 @@ function parseResult(runner, result, duration) {
     truncated: result.truncated
   };
 }
-
-// src/todo.ts
 var todoTool = {
   name: "todo",
   category: "Session",
@@ -6956,6 +7384,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
@@ -7591,7 +8061,8 @@ var builtinTools = [
   toolHelpTool,
   codebaseIndexTool,
   codebaseSearchTool,
-  codebaseStatsTool
+  codebaseStatsTool,
+  setWorkingDirTool
 ];
 
 // src/pack.ts