@livx.cc/agentx 0.95.1 → 0.95.3

package/dist/cli.js

@@ -1059,6 +1059,172 @@ var init_tools = __esm({
   }
 });
 
+// src/worktree.ts
+var worktree_exports = {};
+__export(worktree_exports, {
+  cleanupWorktree: () => cleanupWorktree,
+  enterWorktree: () => enterWorktree,
+  exitWorktree: () => exitWorktree,
+  findGitRoot: () => findGitRoot,
+  getOrCreateWorktree: () => getOrCreateWorktree,
+  getWorktreeSession: () => getWorktreeSession,
+  validateWorktreeSlug: () => validateWorktreeSlug,
+  worktreeBranchName: () => worktreeBranchName
+});
+import { spawnSync } from "child_process";
+import { symlinkSync, mkdirSync, statSync as statSync2, readFileSync, rmSync } from "fs";
+import { join as join2 } from "path";
+function validateWorktreeSlug(slug2) {
+  if (!slug2) throw new Error("worktree slug must not be empty");
+  if (slug2.length > MAX_SLUG_LENGTH) throw new Error(`worktree slug must be \u2264${MAX_SLUG_LENGTH} chars (got ${slug2.length})`);
+  for (const seg of slug2.split("/")) {
+    if (seg === "." || seg === "..") throw new Error(`worktree slug must not contain "." or ".." segments`);
+    if (!VALID_SEGMENT.test(seg)) throw new Error(`worktree slug segment "${seg}" contains invalid characters (allowed: a-z A-Z 0-9 . _ -)`);
+  }
+}
+function flattenSlug(slug2) {
+  return slug2.replaceAll("/", "+");
+}
+function worktreeBranchName(slug2) {
+  return `worktree-${flattenSlug(slug2)}`;
+}
+function worktreesDir(repoRoot) {
+  return join2(repoRoot, ".claude", "worktrees");
+}
+function worktreePathFor(repoRoot, slug2) {
+  return join2(worktreesDir(repoRoot), flattenSlug(slug2));
+}
+function git(args, cwd) {
+  const r = spawnSync("git", args, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    env: { ...process.env, ...GIT_NO_PROMPT_ENV }
+  });
+  return { ok: r.status === 0, stdout: (r.stdout ?? "").toString().trim(), stderr: (r.stderr ?? "").toString().trim() };
+}
+function findGitRoot(from) {
+  const r = git(["rev-parse", "--show-toplevel"], from);
+  return r.ok ? r.stdout : null;
+}
+function readWorktreeHead(worktreePath) {
+  try {
+    const gitFile = readFileSync(join2(worktreePath, ".git"), "utf-8").trim();
+    const m = gitFile.match(/^gitdir:\s*(.+)$/);
+    if (!m) return null;
+    const headPath = join2(m[1], "HEAD");
+    const head = readFileSync(headPath, "utf-8").trim();
+    const refMatch = head.match(/^ref:\s*(.+)$/);
+    if (!refMatch) return head.length === 40 ? head : null;
+    const refPath = join2(m[1], "..", refMatch[1]);
+    try {
+      return readFileSync(refPath, "utf-8").trim();
+    } catch {
+    }
+    const r = git(["rev-parse", "HEAD"], worktreePath);
+    return r.ok ? r.stdout : null;
+  } catch {
+    return null;
+  }
+}
+function getOrCreateWorktree(repoRoot, slug2) {
+  validateWorktreeSlug(slug2);
+  const worktreePath = worktreePathFor(repoRoot, slug2);
+  const branch = worktreeBranchName(slug2);
+  const existingHead = readWorktreeHead(worktreePath);
+  if (existingHead) return { worktreePath, branch, headCommit: existingHead, existed: true };
+  mkdirSync(worktreesDir(repoRoot), { recursive: true });
+  const defaultBranch = git(["symbolic-ref", "--short", "refs/remotes/origin/HEAD"], repoRoot);
+  let baseBranch = defaultBranch.ok ? defaultBranch.stdout.replace(/^origin\//, "") : "HEAD";
+  const originRef = `origin/${baseBranch}`;
+  const hasOrigin = git(["rev-parse", "--verify", originRef], repoRoot);
+  if (!hasOrigin.ok) {
+    const fetched = git(["fetch", "origin", baseBranch], repoRoot);
+    if (!fetched.ok) baseBranch = "HEAD";
+  }
+  const base = baseBranch === "HEAD" ? "HEAD" : originRef;
+  const r = git(["worktree", "add", "-B", branch, worktreePath, base], repoRoot);
+  if (!r.ok) throw new Error(`failed to create worktree: ${r.stderr}`);
+  const headSha = git(["rev-parse", "HEAD"], worktreePath);
+  symlinkDirs(repoRoot, worktreePath, ["node_modules", ".bun"]);
+  return { worktreePath, branch, headCommit: headSha.stdout, existed: false, baseBranch };
+}
+function symlinkDirs(repoRoot, worktreePath, dirs) {
+  for (const dir of dirs) {
+    const src = join2(repoRoot, dir);
+    const dst = join2(worktreePath, dir);
+    try {
+      statSync2(src);
+    } catch {
+      continue;
+    }
+    try {
+      symlinkSync(src, dst, "dir");
+    } catch (e) {
+      if (e?.code !== "EEXIST") console.error(`[worktree] symlink ${dir}: ${e?.message ?? e}`);
+    }
+  }
+}
+function cleanupWorktree(repoRoot, slug2, opts) {
+  validateWorktreeSlug(slug2);
+  const worktreePath = worktreePathFor(repoRoot, slug2);
+  const branch = worktreeBranchName(slug2);
+  try {
+    statSync2(worktreePath);
+  } catch {
+    return { removed: false, reason: "not found" };
+  }
+  if (!opts?.force) {
+    const status = git(["status", "--porcelain", "-uno"], worktreePath);
+    if (status.ok && status.stdout) return { removed: false, reason: "uncommitted changes" };
+  }
+  for (const dir of ["node_modules", ".bun"]) {
+    try {
+      rmSync(join2(worktreePath, dir));
+    } catch {
+    }
+  }
+  const rm = git(["worktree", "remove", "--force", worktreePath], repoRoot);
+  if (!rm.ok) return { removed: false, reason: rm.stderr };
+  git(["branch", "-D", branch], repoRoot);
+  return { removed: true };
+}
+function getWorktreeSession() {
+  return _session;
+}
+function enterWorktree(slug2, cwd) {
+  const repoRoot = findGitRoot(cwd);
+  if (!repoRoot) throw new Error("--worktree requires a git repository");
+  const info = getOrCreateWorktree(repoRoot, slug2);
+  process.chdir(info.worktreePath);
+  _session = {
+    originalCwd: cwd,
+    worktreePath: info.worktreePath,
+    slug: slug2,
+    branch: info.branch,
+    headCommit: info.headCommit
+  };
+  return _session;
+}
+function exitWorktree() {
+  if (!_session) return null;
+  const repoRoot = findGitRoot(_session.originalCwd);
+  if (!repoRoot) return null;
+  process.chdir(_session.originalCwd);
+  const result = cleanupWorktree(repoRoot, _session.slug);
+  _session = null;
+  return result;
+}
+var VALID_SEGMENT, MAX_SLUG_LENGTH, GIT_NO_PROMPT_ENV, _session;
+var init_worktree = __esm({
+  "src/worktree.ts"() {
+    "use strict";
+    VALID_SEGMENT = /^[a-zA-Z0-9._-]+$/;
+    MAX_SLUG_LENGTH = 64;
+    GIT_NO_PROMPT_ENV = { GIT_TERMINAL_PROMPT: "0", GIT_ASKPASS: "" };
+    _session = null;
+  }
+});
+
 // src/NodeDiskFilesystem.ts
 var NodeDiskFilesystem_exports = {};
 __export(NodeDiskFilesystem_exports, {
@@ -1420,172 +1586,6 @@ var init_JailedFilesystem = __esm({
   }
 });
 
-// src/worktree.ts
-var worktree_exports = {};
-__export(worktree_exports, {
-  cleanupWorktree: () => cleanupWorktree,
-  enterWorktree: () => enterWorktree,
-  exitWorktree: () => exitWorktree,
-  findGitRoot: () => findGitRoot,
-  getOrCreateWorktree: () => getOrCreateWorktree,
-  getWorktreeSession: () => getWorktreeSession,
-  validateWorktreeSlug: () => validateWorktreeSlug,
-  worktreeBranchName: () => worktreeBranchName
-});
-import { spawnSync } from "child_process";
-import { symlinkSync, mkdirSync, statSync as statSync2, readFileSync, rmSync } from "fs";
-import { join as join3 } from "path";
-function validateWorktreeSlug(slug2) {
-  if (!slug2) throw new Error("worktree slug must not be empty");
-  if (slug2.length > MAX_SLUG_LENGTH) throw new Error(`worktree slug must be \u2264${MAX_SLUG_LENGTH} chars (got ${slug2.length})`);
-  for (const seg of slug2.split("/")) {
-    if (seg === "." || seg === "..") throw new Error(`worktree slug must not contain "." or ".." segments`);
-    if (!VALID_SEGMENT.test(seg)) throw new Error(`worktree slug segment "${seg}" contains invalid characters (allowed: a-z A-Z 0-9 . _ -)`);
-  }
-}
-function flattenSlug(slug2) {
-  return slug2.replaceAll("/", "+");
-}
-function worktreeBranchName(slug2) {
-  return `worktree-${flattenSlug(slug2)}`;
-}
-function worktreesDir(repoRoot) {
-  return join3(repoRoot, ".claude", "worktrees");
-}
-function worktreePathFor(repoRoot, slug2) {
-  return join3(worktreesDir(repoRoot), flattenSlug(slug2));
-}
-function git(args, cwd) {
-  const r = spawnSync("git", args, {
-    cwd,
-    stdio: ["ignore", "pipe", "pipe"],
-    env: { ...process.env, ...GIT_NO_PROMPT_ENV }
-  });
-  return { ok: r.status === 0, stdout: (r.stdout ?? "").toString().trim(), stderr: (r.stderr ?? "").toString().trim() };
-}
-function findGitRoot(from) {
-  const r = git(["rev-parse", "--show-toplevel"], from);
-  return r.ok ? r.stdout : null;
-}
-function readWorktreeHead(worktreePath) {
-  try {
-    const gitFile = readFileSync(join3(worktreePath, ".git"), "utf-8").trim();
-    const m = gitFile.match(/^gitdir:\s*(.+)$/);
-    if (!m) return null;
-    const headPath = join3(m[1], "HEAD");
-    const head = readFileSync(headPath, "utf-8").trim();
-    const refMatch = head.match(/^ref:\s*(.+)$/);
-    if (!refMatch) return head.length === 40 ? head : null;
-    const refPath = join3(m[1], "..", refMatch[1]);
-    try {
-      return readFileSync(refPath, "utf-8").trim();
-    } catch {
-    }
-    const r = git(["rev-parse", "HEAD"], worktreePath);
-    return r.ok ? r.stdout : null;
-  } catch {
-    return null;
-  }
-}
-function getOrCreateWorktree(repoRoot, slug2) {
-  validateWorktreeSlug(slug2);
-  const worktreePath = worktreePathFor(repoRoot, slug2);
-  const branch = worktreeBranchName(slug2);
-  const existingHead = readWorktreeHead(worktreePath);
-  if (existingHead) return { worktreePath, branch, headCommit: existingHead, existed: true };
-  mkdirSync(worktreesDir(repoRoot), { recursive: true });
-  const defaultBranch = git(["symbolic-ref", "--short", "refs/remotes/origin/HEAD"], repoRoot);
-  let baseBranch = defaultBranch.ok ? defaultBranch.stdout.replace(/^origin\//, "") : "HEAD";
-  const originRef = `origin/${baseBranch}`;
-  const hasOrigin = git(["rev-parse", "--verify", originRef], repoRoot);
-  if (!hasOrigin.ok) {
-    const fetched = git(["fetch", "origin", baseBranch], repoRoot);
-    if (!fetched.ok) baseBranch = "HEAD";
-  }
-  const base = baseBranch === "HEAD" ? "HEAD" : originRef;
-  const r = git(["worktree", "add", "-B", branch, worktreePath, base], repoRoot);
-  if (!r.ok) throw new Error(`failed to create worktree: ${r.stderr}`);
-  const headSha = git(["rev-parse", "HEAD"], worktreePath);
-  symlinkDirs(repoRoot, worktreePath, ["node_modules", ".bun"]);
-  return { worktreePath, branch, headCommit: headSha.stdout, existed: false, baseBranch };
-}
-function symlinkDirs(repoRoot, worktreePath, dirs) {
-  for (const dir of dirs) {
-    const src = join3(repoRoot, dir);
-    const dst = join3(worktreePath, dir);
-    try {
-      statSync2(src);
-    } catch {
-      continue;
-    }
-    try {
-      symlinkSync(src, dst, "dir");
-    } catch (e) {
-      if (e?.code !== "EEXIST") console.error(`[worktree] symlink ${dir}: ${e?.message ?? e}`);
-    }
-  }
-}
-function cleanupWorktree(repoRoot, slug2, opts) {
-  validateWorktreeSlug(slug2);
-  const worktreePath = worktreePathFor(repoRoot, slug2);
-  const branch = worktreeBranchName(slug2);
-  try {
-    statSync2(worktreePath);
-  } catch {
-    return { removed: false, reason: "not found" };
-  }
-  if (!opts?.force) {
-    const status = git(["status", "--porcelain", "-uno"], worktreePath);
-    if (status.ok && status.stdout) return { removed: false, reason: "uncommitted changes" };
-  }
-  for (const dir of ["node_modules", ".bun"]) {
-    try {
-      rmSync(join3(worktreePath, dir));
-    } catch {
-    }
-  }
-  const rm = git(["worktree", "remove", "--force", worktreePath], repoRoot);
-  if (!rm.ok) return { removed: false, reason: rm.stderr };
-  git(["branch", "-D", branch], repoRoot);
-  return { removed: true };
-}
-function getWorktreeSession() {
-  return _session;
-}
-function enterWorktree(slug2, cwd) {
-  const repoRoot = findGitRoot(cwd);
-  if (!repoRoot) throw new Error("--worktree requires a git repository");
-  const info = getOrCreateWorktree(repoRoot, slug2);
-  process.chdir(info.worktreePath);
-  _session = {
-    originalCwd: cwd,
-    worktreePath: info.worktreePath,
-    slug: slug2,
-    branch: info.branch,
-    headCommit: info.headCommit
-  };
-  return _session;
-}
-function exitWorktree() {
-  if (!_session) return null;
-  const repoRoot = findGitRoot(_session.originalCwd);
-  if (!repoRoot) return null;
-  process.chdir(_session.originalCwd);
-  const result = cleanupWorktree(repoRoot, _session.slug);
-  _session = null;
-  return result;
-}
-var VALID_SEGMENT, MAX_SLUG_LENGTH, GIT_NO_PROMPT_ENV, _session;
-var init_worktree = __esm({
-  "src/worktree.ts"() {
-    "use strict";
-    VALID_SEGMENT = /^[a-zA-Z0-9._-]+$/;
-    MAX_SLUG_LENGTH = 64;
-    GIT_NO_PROMPT_ENV = { GIT_TERMINAL_PROMPT: "0", GIT_ASKPASS: "" };
-    _session = null;
-  }
-});
-
 // src/shell.sandbox.ts
 function writable(cwd, o, tmpDir) {
   const set = /* @__PURE__ */ new Set([cwd, "/tmp", "/private/tmp", "/private/var/folders", "/dev", ...tmpDir ? [tmpDir] : [], ...o.writePaths]);
@@ -1755,7 +1755,7 @@ function makeRealShellTool(options) {
           proc.stderr?.on("data", collect);
           proc.on("error", (err2) => {
             if (err2?.name === "AbortError" || ctl.signal.aborted) return finish(reasonFor(timedOut, timeoutMs, clean(out)));
-            log12.debug("shell spawn error", err2);
+            log13.debug("shell spawn error", err2);
             finish(`[exit 1] ${err2?.message ?? err2}${out ? "\n" + clean(out) : ""}`);
           });
           proc.on("close", (code) => {
@@ -1817,7 +1817,7 @@ ${clean(out) || "(no output yet)"}`;
     }
   ];
 }
-var log12, clean, DETACHED, SECRET_ENV_RE, _spawn, ShellJobRegistry, NO_JOB2;
+var log13, clean, DETACHED, SECRET_ENV_RE, _spawn, ShellJobRegistry, NO_JOB2;
 var init_tools_shell = __esm({
   "src/tools.shell.ts"() {
     "use strict";
@@ -1825,7 +1825,7 @@ var init_tools_shell = __esm({
     init_redact();
     init_logging();
     init_shell_sandbox();
-    log12 = forComponent("shell");
+    log13 = forComponent("shell");
     clean = (s) => truncateOutput(redactSecrets(s.replace(/\n+$/, "")));
     DETACHED = { stdio: ["ignore", "pipe", "pipe"], detached: true };
     SECRET_ENV_RE = /(_API_KEY|_TOKEN|_SECRET|_PASSWORD|_PRIVATE_KEY|^AWS_|^GITHUB_TOKEN$|^OPENAI_|^ANTHROPIC_|^GOOGLE_|^GEMINI_|^GROQ_|^NPM_TOKEN$)/i;
@@ -1907,7 +1907,7 @@ var init_tools_shell = __esm({
 
 // cli/cli.ts
 import { createInterface } from "readline/promises";
-import { existsSync as existsSync10, readFileSync as readFileSync7, appendFileSync, mkdirSync as mkdirSync10, writeFileSync as writeFileSync8, readdirSync as readdirSync4, statSync as statSync4, unlinkSync as unlinkSync5 } from "fs";
+import { existsSync as existsSync10, readFileSync as readFileSync7, appendFileSync, mkdirSync as mkdirSync11, writeFileSync as writeFileSync9, readdirSync as readdirSync4, statSync as statSync4, unlinkSync as unlinkSync5 } from "fs";
 import { homedir as homedir9, tmpdir as tmpdir3 } from "os";
 
 // cli/clipboard.ts
@@ -1975,7 +1975,7 @@ function copyTextToClipboard(text, platform2 = process.platform) {
 }
 
 // cli/cli.ts
-import { join as join13, resolve as resolve3, basename as basename2, extname, dirname as dirname4 } from "path";
+import { join as join14, resolve as resolve3, basename as basename2, extname, dirname as dirname4 } from "path";
 import { AIClient, listModels, listProviders, getProviderFromModel, getModelInfo, resolveModel, isModelSupported, disposeCursorSessions } from "ai.libx.js";
 
 // src/llm.ts
@@ -2622,7 +2622,13 @@ ${sections.join("\n\n---\n\n")}`;
 
 // src/subagent.ts
 init_tools();
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join4 } from "path";
 init_OverlayFilesystem();
+init_worktree();
+init_NodeDiskFilesystem();
+init_logging();
+var log3 = forComponent("subagent");
 async function boundedPool(items, limit, fn) {
   const out = new Array(items.length);
   let next = 0;
@@ -2635,13 +2641,86 @@ async function boundedPool(items, limit, fn) {
   await Promise.all(Array.from({ length: Math.max(1, Math.min(limit, items.length)) }, worker));
   return out;
 }
+function sanitizeSlug(raw) {
+  return raw.replace(/[^a-zA-Z0-9._-]/g, "-").replace(/-+/g, "-").slice(0, 40);
+}
+function createWorktreeFs(cwd, label, index) {
+  const repoRoot = findGitRoot(cwd);
+  if (!repoRoot) return 'isolation: "worktree" requires a git repository';
+  const slug2 = `sub-${index}-${sanitizeSlug(label)}`;
+  try {
+    const info = getOrCreateWorktree(repoRoot, slug2);
+    return { repoRoot, slug: slug2, worktreePath: info.worktreePath, branch: info.branch };
+  } catch (e) {
+    return `worktree creation failed: ${e instanceof Error ? e.message : String(e)}`;
+  }
+}
+function releaseWorktree(handle) {
+  return cleanupWorktree(handle.repoRoot, handle.slug, { force: true });
+}
+function worktreePromptPrefix(branch) {
+  return `You are running in an isolated git worktree on branch "${branch}". When you finish making changes, commit them with a clear message before replying with your summary. Your worktree will be removed after you finish \u2014 only committed work survives (on the branch).
+
+`;
+}
+var traceSeq = 0;
+function traceFileFor(dir, label, depth) {
+  try {
+    mkdirSync2(dir, { recursive: true });
+    const id = `${Date.now().toString(36)}-${(traceSeq++).toString(36)}`;
+    return join4(dir, `${id}-d${depth}-${sanitizeSlug(label) || "sub"}.json`);
+  } catch (e) {
+    log3.warn(`subagent trace dir unavailable (${dir}) \u2014 running without a trace: ${e instanceof Error ? e.message : String(e)}`);
+    return void 0;
+  }
+}
+function flushTrace(file, meta, messages, status) {
+  try {
+    writeFileSync2(file, JSON.stringify({ ...meta, status, updated: Date.now(), messages }, null, 2));
+  } catch (e) {
+    log3.warn(`subagent trace flush failed (${file}): ${e instanceof Error ? e.message : String(e)}`);
+  }
+}
+function installTrace(child, file, meta) {
+  const prev = child.options.host;
+  child.options.host = {
+    ...prev,
+    notify: (e) => {
+      if (e.kind === "turn_start") flushTrace(file, meta, child.transcript, "running");
+      prev?.notify?.(e);
+    }
+  };
+}
+function abortHint(label, res, file) {
+  const last = (res.text || "").trim().slice(0, 500);
+  const lines = [
+    `[sub-task '${label}' did NOT finish \u2014 ${res.finishReason} after ${res.steps} step(s). Treat its work as INCOMPLETE.]`,
+    last ? `Progress so far: ${last}` : "It produced no summary before stopping."
+  ];
+  if (file) lines.push(`Full transcript (every step it took): ${file} \u2014 Read it to see what was actually done.`);
+  lines.push("Decide: ignore it, re-delegate a fresh Task that continues from the trace, or start over. Do NOT assume the sub-task completed.");
+  return lines.join("\n");
+}
+async function runChildTraced(args) {
+  const { opts, label, agentType, prompt } = args;
+  if (args.signal) args.childOpts.signal = args.signal;
+  const file = opts.traceDir ? traceFileFor(opts.traceDir, label, args.childDepth) : void 0;
+  const meta = { label, agentType, prompt };
+  const child = new Agent(args.childOpts);
+  if (file) installTrace(child, file, meta);
+  const res = await child.run(prompt);
+  if (file) flushTrace(file, meta, child.transcript, res.finishReason);
+  const result = res.finishReason === "stop" ? res.text || `(child '${label}' finished with no summary; finishReason=${res.finishReason})` : abortHint(label, res, file);
+  await opts.hooks?.onSubagentStop?.(result, { label, agentType });
+  return { res, result };
+}
 function childOptionsFor(opts, fs, depth, maxDepth, agentType) {
   let def;
   if (agentType) {
     def = (opts.agents ?? []).find((a) => a.name === agentType);
     if (!def) return `no subagent type '${agentType}'. Available: ${(opts.agents ?? []).map((a) => a.name).join(", ") || "(none defined)"}`;
   }
-  const childOpts = { ai: opts.ai, fs, model: def?.model ?? opts.model, subagents: true, depth: depth + 1, maxDepth };
+  const childOpts = { ai: opts.ai, fs, model: def?.model ?? opts.model, subagents: true, depth: depth + 1, maxDepth, traceDir: opts.traceDir };
   if (opts.maxSteps != null) childOpts.maxSteps = opts.maxSteps;
   if (def?.systemPrompt) childOpts.systemPrompt = def.systemPrompt;
   if (def?.tools?.length) {
@@ -2658,7 +2737,7 @@ function makeTaskTool(opts) {
   const maxDepth = opts.maxDepth ?? 2;
   return {
     name: "Task",
-    description: "Delegate a self-contained sub-task to a child agent over the same filesystem. It runs autonomously with its own step budget and returns a concise summary \u2014 use to isolate context-heavy work (broad search, a scoped refactor). Provide a short `description` and a full `prompt`. Set `background: true` to run it detached (returns a job id to poll with JobOutput while you keep working); its file edits are overlay-isolated and commit when it finishes.",
+    description: 'Delegate a self-contained sub-task to a child agent over the same filesystem. It runs autonomously with its own step budget and returns a concise summary \u2014 use to isolate context-heavy work (broad search, a scoped refactor). Provide a short `description` and a full `prompt`. If it is interrupted or fails, the result is a STATUS HINT with a pointer to its full transcript (Read it to recover what it did, then decide whether to continue or restart) \u2014 do not assume an incomplete sub-task succeeded. Set `background: true` to run it detached (returns a job id to poll with JobOutput while you keep working); its file edits are overlay-isolated and commit when it finishes. Set `isolation: "worktree"` to run in a real git worktree (needed when the child uses real shell commands that must see/modify actual files) \u2014 slower (~200ms setup), auto-cleaned if no changes.',
     parameters: {
       type: "object",
       required: ["description", "prompt"],
@@ -2666,36 +2745,83 @@ function makeTaskTool(opts) {
         description: { type: "string", description: "a short (3-5 word) label for the sub-task" },
         prompt: { type: "string", description: "the full instructions the child agent should carry out" },
         agentType: { type: "string", description: "optional named subagent type (its persona, model, and scoped tools) \u2014 see the catalog" },
-        background: { type: "boolean", description: "run detached (overlay-isolated, commits on finish); returns a job id to poll with JobOutput instead of blocking" }
+        background: { type: "boolean", description: "run detached (overlay-isolated, commits on finish); returns a job id to poll with JobOutput instead of blocking" },
+        isolation: { type: "string", enum: ["overlay", "worktree"], description: 'isolation mode: "overlay" (default, VFS layer) or "worktree" (real git worktree for shell-heavy work)' }
       }
     },
-    async run({ description, prompt, agentType, background }, ctx) {
+    async run({ description, prompt, agentType, background, isolation }, ctx) {
       if (depth >= maxDepth) {
         return `Error: Task depth limit reached (maxDepth ${maxDepth}). Cannot spawn another child agent \u2014 do this work directly instead.`;
       }
       const label = String(description ?? agentType ?? "sub-task");
+      const useWorktree = isolation === "worktree";
       if (background && ctx.jobs) {
         const id = ctx.jobs.start(async ({ signal }) => {
-          const overlay = new OverlayFilesystem(opts.fs);
-          const childOpts2 = childOptionsFor(opts, overlay, depth, maxDepth, agentType);
+          let fs2;
+          let commit;
+          let wtHandle2;
+          if (useWorktree) {
+            const h = createWorktreeFs(process.cwd(), label, 0);
+            if (typeof h === "string") throw new Error(h);
+            wtHandle2 = h;
+            fs2 = new NodeDiskFilesystem(h.worktreePath);
+            commit = async () => {
+            };
+          } else {
+            const overlay = new OverlayFilesystem(opts.fs);
+            fs2 = overlay;
+            commit = () => overlay.commit();
+          }
+          const childOpts2 = childOptionsFor(opts, fs2, depth, maxDepth, agentType);
           if (typeof childOpts2 === "string") throw new Error(childOpts2);
-          childOpts2.signal = signal;
-          const res2 = await new Agent(childOpts2).run(String(prompt ?? ""));
-          if (signal.aborted) return "[killed before commit]";
-          await overlay.commit();
-          const summary2 = res2.text || `(child '${label}' finished with no summary; finishReason=${res2.finishReason})`;
-          await opts.hooks?.onSubagentStop?.(summary2, { label, agentType });
-          return summary2;
+          const childPrompt = wtHandle2 ? worktreePromptPrefix(wtHandle2.branch) + String(prompt ?? "") : String(prompt ?? "");
+          const { res, result } = await runChildTraced({ opts, childOpts: childOpts2, prompt: childPrompt, label, agentType, childDepth: depth + 1, signal });
+          if (res.finishReason === "aborted" || signal.aborted) {
+            wtHandle2 && releaseWorktree(wtHandle2);
+            return result;
+          }
+          await commit();
+          let summary = result;
+          if (wtHandle2) {
+            const r = releaseWorktree(wtHandle2);
+            if (!r.removed) summary += `
+
+[worktree removal failed: ${r.reason}]`;
+          }
+          return summary;
         }, { kind: "agent", label });
         return `Started background sub-task ${id} ('${label}') \u2014 poll with JobOutput({id:"${id}"}).`;
       }
-      const childOpts = childOptionsFor(opts, opts.fs, depth, maxDepth, agentType);
-      if (typeof childOpts === "string") return `Error: ${childOpts}`;
-      const child = new Agent(childOpts);
-      const res = await child.run(String(prompt ?? ""));
-      const summary = res.text || `(child agent finished '${label}' with no summary; finishReason=${res.finishReason})`;
-      await opts.hooks?.onSubagentStop?.(summary, { label, agentType });
-      return summary;
+      let fs;
+      let wtHandle;
+      if (useWorktree) {
+        const h = createWorktreeFs(process.cwd(), label, 0);
+        if (typeof h === "string") return `Error: ${h}`;
+        wtHandle = h;
+        fs = new NodeDiskFilesystem(h.worktreePath);
+      } else {
+        fs = opts.fs;
+      }
+      const childOpts = childOptionsFor(opts, fs, depth, maxDepth, agentType);
+      if (typeof childOpts === "string") {
+        wtHandle && releaseWorktree(wtHandle);
+        return `Error: ${childOpts}`;
+      }
+      try {
+        const childPrompt = wtHandle ? worktreePromptPrefix(wtHandle.branch) + String(prompt ?? "") : String(prompt ?? "");
+        const { result } = await runChildTraced({ opts, childOpts, prompt: childPrompt, label, agentType, childDepth: depth + 1, signal: ctx.signal });
+        let summary = result;
+        if (wtHandle) {
+          const r = releaseWorktree(wtHandle);
+          if (!r.removed) summary += `
+
+[worktree removal failed: ${r.reason}]`;
+        }
+        return summary;
+      } catch (e) {
+        if (wtHandle) releaseWorktree(wtHandle);
+        throw e;
+      }
     }
   };
 }
@@ -2705,7 +2831,7 @@ function makeTaskBatchTool(opts) {
   const maxParallel = opts.maxParallel ?? 4;
   return {
     name: "TaskBatch",
-    description: "Delegate SEVERAL independent sub-tasks to child agents that run concurrently; returns all their summaries. Each child is write-isolated (its file edits are merged back in array order). Use for parallel fan-out (review/search/scoped refactors across files). Provide `tasks: [{ description, prompt, agentType? }]`.",
+    description: 'Delegate SEVERAL independent sub-tasks to child agents that run concurrently; returns all their summaries. Each child is write-isolated (its file edits are merged back in array order). Use for parallel fan-out (review/search/scoped refactors across files). Provide `tasks: [{ description, prompt, agentType? }]`. Set `isolation: "worktree"` to run each child in its own git worktree (needed for real shell commands) \u2014 slower, auto-cleaned if no changes.',
     parameters: {
       type: "object",
       required: ["tasks"],
@@ -2722,30 +2848,53 @@ function makeTaskBatchTool(opts) {
               agentType: { type: "string", description: "optional named subagent type" }
             }
           }
-        }
+        },
+        isolation: { type: "string", enum: ["overlay", "worktree"], description: 'isolation mode for ALL children: "overlay" (default) or "worktree" (real git worktree each)' }
       }
     },
-    async run({ tasks }, _ctx) {
+    async run({ tasks, isolation }, ctx) {
       if (depth >= maxDepth) return `Error: Task depth limit reached (maxDepth ${maxDepth}). Cannot spawn child agents \u2014 do this work directly instead.`;
       const list = Array.isArray(tasks) ? tasks : [];
       if (!list.length) return "Error: TaskBatch needs a non-empty `tasks` array.";
+      const useWorktree = isolation === "worktree";
       const results = await boundedPool(list, maxParallel, async (t, i) => {
         const label = String(t?.description ?? t?.agentType ?? `task ${i + 1}`);
-        const overlay = new OverlayFilesystem(opts.fs);
-        const childOpts = childOptionsFor(opts, overlay, depth, maxDepth, t?.agentType);
+        let fs;
+        let overlay;
+        let wtHandle;
+        if (useWorktree) {
+          const h = createWorktreeFs(process.cwd(), label, i);
+          if (typeof h === "string") return { label, error: h, ok: false };
+          wtHandle = h;
+          fs = new NodeDiskFilesystem(h.worktreePath);
+        } else {
+          overlay = new OverlayFilesystem(opts.fs);
+          fs = overlay;
+        }
+        const childOpts = childOptionsFor(opts, fs, depth, maxDepth, t?.agentType);
         if (typeof childOpts === "string") return { label, error: childOpts, ok: false };
         try {
-          const res = await new Agent(childOpts).run(String(t?.prompt ?? ""));
-          await opts.hooks?.onSubagentStop?.(res.text, { label, agentType: t?.agentType });
-          return { label, text: res.text, overlay, ok: res.finishReason !== "error" };
+          const childPrompt = wtHandle ? worktreePromptPrefix(wtHandle.branch) + String(t?.prompt ?? "") : String(t?.prompt ?? "");
+          const { res, result } = await runChildTraced({ opts, childOpts, prompt: childPrompt, label, agentType: t?.agentType, childDepth: depth + 1, signal: ctx.signal });
+          return { label, text: result, overlay, wtHandle, ok: res.finishReason !== "error" && res.finishReason !== "aborted" };
         } catch (e) {
-          return { label, error: e instanceof Error ? e.message : String(e), ok: false };
+          return { label, error: e instanceof Error ? e.message : String(e), wtHandle, ok: false };
         }
       });
-      for (const r of results) if (r.ok && r.overlay) await r.overlay.commit().catch(() => {
-      });
-      return results.map((r, i) => `### ${i + 1}. ${r.label}
-${r.error ? `ERROR: ${r.error}` : r.text || "(no summary)"}`).join("\n\n");
+      const lines = [];
+      for (const r of results) {
+        if (r.ok && r.overlay) await r.overlay.commit().catch(() => {
+        });
+        let extra = "";
+        if (r.wtHandle) {
+          const wr = releaseWorktree(r.wtHandle);
+          if (!wr.removed) extra = `
+[worktree removal failed: ${wr.reason}]`;
+        }
+        lines.push(`### ${lines.length + 1}. ${r.label}
+${r.error ? `ERROR: ${r.error}` : r.text || "(no summary)"}${extra}`);
+      }
+      return lines.join("\n\n");
     }
   };
 }
@@ -2990,7 +3139,7 @@ function reasoningToChatFragment(model, effort) {
 }
 
 // src/Agent.ts
-var log3 = forComponent("Agent");
+var log4 = forComponent("Agent");
 function isAbortError(err2) {
   const e = err2;
   const blob = `${e?.message ?? ""} ${e?.name ?? ""} ${e?.code ?? ""} ${e?.cause?.name ?? ""}`;
@@ -3066,6 +3215,11 @@ var AgentOptions = class {
   depth = 0;
   /** Hard ceiling on subagent nesting (beyond it the `Task` tool refuses to spawn). */
   maxDepth = 2;
+  /** Real-disk dir where child agents stream their transcript as they run (origin-anchored — survives
+   *  worktree teardown / a child's own cwd). When set, an interrupted/failed child commits a STATUS HINT
+   *  + a pointer to its trace instead of a dangling tool_call, so the parent can read it and decide
+   *  whether to ignore, pick it up, or restart. Unset (library/sandbox default) = no tracing. */
+  traceDir;
   /** Stream tokens from the model. Takes effect only with a `host.notify`; off => current (non-stream) behavior. */
   stream = false;
   /** Fold the dropped middle of an over-long transcript into a synthetic summary (edge-safe, no LLM). Off => drop-oldest. */
@@ -3186,7 +3340,7 @@ var Agent = class _Agent {
       const disk = new NodeDiskFilesystem2(process.cwd());
       await disk.init();
       this.options.fs = new JailedFilesystem2(disk);
-      log3.info(`no fs provided \u2014 defaulting to jailed real disk at ${process.cwd()}`);
+      log4.info(`no fs provided \u2014 defaulting to jailed real disk at ${process.cwd()}`);
     }
     this.buildCtx();
   }
@@ -3240,7 +3394,7 @@ var Agent = class _Agent {
         agents = loaded.agents;
         if (loaded.catalog) systemPrompt += "\n\n" + loaded.catalog;
       }
-      const taskOpts = { ai: o.ai, model: o.model, fs, depth: o.depth, maxDepth: o.maxDepth, agents, hooks: o.hooks };
+      const taskOpts = { ai: o.ai, model: o.model, fs, depth: o.depth, maxDepth: o.maxDepth, agents, hooks: o.hooks, traceDir: o.traceDir };
       tools = [...tools, makeTaskTool(taskOpts), makeTaskBatchTool(taskOpts)];
     }
     if (o.checkpoints) tools = [...tools, ...checkpointTools()];
@@ -3329,7 +3483,7 @@ var Agent = class _Agent {
     let lastFp = "";
     let repeats = 0;
     const kill = (finishReason) => {
-      log3.warn(`kill-switch: ${finishReason} (steps=${steps}, tokens=${usage.totalTokens}, budgetTokens=${Math.round(usage.totalTokens - 0.9 * usage.cacheReadTokens)}, ms=${Date.now() - start - this.parkedMs}${this.parkedMs ? ` +${this.parkedMs} parked` : ""})`);
+      log4.warn(`kill-switch: ${finishReason} (steps=${steps}, tokens=${usage.totalTokens}, budgetTokens=${Math.round(usage.totalTokens - 0.9 * usage.cacheReadTokens)}, ms=${Date.now() - start - this.parkedMs}${this.parkedMs ? ` +${this.parkedMs} parked` : ""})`);
       this.ctx.jobs?.killAll();
       return { text: lastAssistantText(this.transcript), steps, finishReason, messages: this.transcript, usage, usageEstimated };
     };
@@ -3375,7 +3529,7 @@ var Agent = class _Agent {
             const transient = !o.signal?.aborted && !isAbortError(err2) && attempt < 2 && (network || serverSide);
             if (!transient) throw err2;
             const waitMs = 1e3 * (attempt + 1);
-            log3.warn(`network drop mid-step (${err2?.message ?? err2}) \u2014 retrying in ${waitMs}ms`);
+            log4.warn(`network drop mid-step (${err2?.message ?? err2}) \u2014 retrying in ${waitMs}ms`);
             o.host?.notify?.({ kind: "retry", message: `connection dropped \u2014 retrying step (#${attempt + 1})` });
             await new Promise((r) => setTimeout(r, waitMs));
           }
@@ -3391,7 +3545,7 @@ var Agent = class _Agent {
           bodyStr = void 0;
         }
         if (bodyStr && err2 instanceof Error && !err2.message.includes(bodyStr)) err2.detail = bodyStr;
-        log3.error(`chat() failed: ${err2?.message ?? err2}${bodyStr ? ` \u2014 ${bodyStr}` : ""}`, err2);
+        log4.error(`chat() failed: ${err2?.message ?? err2}${bodyStr ? ` \u2014 ${bodyStr}` : ""}`, err2);
         return { text: "", steps, finishReason: "error", messages: this.transcript, usage, usageEstimated, error: err2 };
       }
       if (o.signal?.aborted) return kill("aborted");
@@ -3418,7 +3572,7 @@ var Agent = class _Agent {
         });
       }
       if (toolCalls.length === 0) {
-        log3.verbose(`completed in ${steps} step(s)`);
+        log4.verbose(`completed in ${steps} step(s)`);
         await this.ctx.jobs?.drain();
         await this.activeHooks?.onStop?.(res.content ?? "");
         return { text: res.content ?? "", steps, finishReason: "stop", messages: this.transcript, usage, usageEstimated };
@@ -3484,13 +3638,13 @@ var Agent = class _Agent {
     const decision = await this.park(Promise.resolve(hooks?.preToolUse?.(call, meta)));
     if (decision?.block) {
       const blocked = `Blocked by hook: ${decision.reason ?? "no reason given"}`;
-      log3.debug(`${tc.function.name} -> ${blocked}`);
+      log4.debug(`${tc.function.name} -> ${blocked}`);
       await hooks?.postToolUse?.(call, blocked, meta);
       return blocked;
     }
     this.options.host?.notify?.({ kind: "tool_use", id: tc.id ?? "", name: tc.function.name, input: args });
     if (earlyError) {
-      log3.debug(`${tc.function.name} -> ${earlyError}`);
+      log4.debug(`${tc.function.name} -> ${earlyError}`);
       await hooks?.postToolUse?.(call, earlyError, meta);
       this.options.host?.notify?.({ kind: "tool_result", id: tc.id ?? "", output: earlyError, isError: true });
       return earlyError;
@@ -3499,12 +3653,12 @@ var Agent = class _Agent {
     let images;
     let threw = false;
     try {
-      log3.debug(`${tc.function.name}(${tc.function.arguments})`);
+      log4.debug(`${tc.function.name}(${tc.function.arguments})`);
       this.ctx.emit = hooks?.onToolOutput ? (chunk) => {
         try {
           hooks.onToolOutput(call, chunk, meta);
         } catch (e) {
-          log3.debug(`onToolOutput hook error: ${e}`);
+          log4.debug(`onToolOutput hook error: ${e}`);
         }
       } : void 0;
       const raw = await tool.run(args, this.ctx);
@@ -3516,7 +3670,7 @@ var Agent = class _Agent {
       }
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e);
-      log3.debug(`${tc.function.name} -> error: ${msg}`);
+      log4.debug(`${tc.function.name} -> error: ${msg}`);
       result = `Error: ${msg}`;
       threw = true;
     } finally {
@@ -3642,7 +3796,7 @@ function fitTokenBudget(messages, maxTokens) {
   const ids = callIdSet(messages.slice(from));
   while (from < messages.length && messages[from].role === "tool" && !ids.has(messages[from].tool_call_id ?? "")) total -= per[from++];
   if (total > maxTokens)
-    log3.warn(`context ~${total} tok still over maxContextTokens=${maxTokens} after trimming (system head can't be dropped)`);
+    log4.warn(`context ~${total} tok still over maxContextTokens=${maxTokens} after trimming (system head can't be dropped)`);
   return [...head, ...messages.slice(from)];
 }
 function compact(m, max, focus) {
@@ -4199,7 +4353,7 @@ init_tools_web();
 init_tools();
 init_tools_structured();
 init_logging();
-var log4 = forComponent("scratch");
+var log5 = forComponent("scratch");
 var SCRATCH_DIR = "/scratch";
 function shortArgs(args) {
   try {
@@ -4239,7 +4393,7 @@ var Scratch = class {
           await (this.dirReady ??= mkdirp(this.fs, dir));
           await this.fs.writeFile(path, header + raw);
         } catch (e) {
-          log4.debug("scratch write failed; returning raw", e);
+          log5.debug("scratch write failed; returning raw", e);
           return raw;
         }
         const preview = raw.slice(0, previewChars).replace(/\s+/g, " ").trim();
@@ -4269,7 +4423,7 @@ To pull a specific detail, Grep/Read ${path}, or call Ask({ question: "\u2026",
       await (this.dirReady ??= mkdirp(this.fs, dir));
       await this.fs.writeFile(path, header + full);
     } catch (e) {
-      log4.debug("scratch spill failed; cropping lossy", e);
+      log5.debug("scratch spill failed; cropping lossy", e);
       return full.slice(0, pageBytes) + `
 
 [output cropped to ${pageBytes} of ${full.length} bytes; full output unavailable (scratch write failed) \u2014 refine your query]`;
@@ -4315,7 +4469,7 @@ Question: ${q2}`);
         const answer = (res.text ?? "").trim();
         return answer || "(no answer found in scratch)";
       } catch (e) {
-        log4.debug("Ask peek failed", e);
+        log5.debug("Ask peek failed", e);
         return `Error querying scratch: ${e?.message ?? e}`;
       }
     }
@@ -4324,7 +4478,7 @@ Question: ${q2}`);
 
 // src/lessons.ts
 init_logging();
-var log5 = forComponent("Lessons");
+var log6 = forComponent("Lessons");
 var LessonOptionsDefaults = class {
   minRepeats = 2;
 };
@@ -4349,15 +4503,15 @@ function lessonCapture(options) {
       counts.set(lesson.slug, n);
       if (n < o.minRepeats) return;
       written.add(lesson.slug);
-      await writeFact(o.fs, o.dir, lesson.slug, lesson.body).catch((e) => log5.warn(`could not persist ${lesson.slug}: ${e?.message ?? e}`));
-      log5.debug(`captured lesson ${lesson.slug} (recurred ${n}\xD7)`);
+      await writeFact(o.fs, o.dir, lesson.slug, lesson.body).catch((e) => log6.warn(`could not persist ${lesson.slug}: ${e?.message ?? e}`));
+      log6.debug(`captured lesson ${lesson.slug} (recurred ${n}\xD7)`);
     }
   };
 }
 
 // src/reflect.ts
 init_logging();
-var log6 = forComponent("Reflect");
+var log7 = forComponent("Reflect");
 async function reflectOnRun(o) {
   const digest = digestRun(o.result.messages, o.maxDigestChars ?? 6e3);
   if (!digest.trim()) return null;
@@ -4373,7 +4527,7 @@ If the run was fine or the issue was purely task-specific (not generalizable), r
     const r = await o.ai.chat({ model: o.model, messages: [{ role: "user", content: prompt }], stream: false });
     text = r?.content ?? "";
   } catch (e) {
-    log6.warn(`reflection call failed: ${e?.message ?? e}`);
+    log7.warn(`reflection call failed: ${e?.message ?? e}`);
     return null;
   }
   const m = text.match(/LESSON:\s*(.+)/i);
@@ -4383,10 +4537,10 @@ If the run was fine or the issue was purely task-specific (not generalizable), r
   try {
     await writeFact(o.fs, o.dir, slug2, lesson);
   } catch (e) {
-    log6.warn(`could not persist lesson: ${e?.message ?? e}`);
+    log7.warn(`could not persist lesson: ${e?.message ?? e}`);
     return null;
   }
-  log6.debug(`reflection persisted ${slug2}`);
+  log7.debug(`reflection persisted ${slug2}`);
   return slug2;
 }
 function digestRun(messages, maxChars) {
@@ -4403,7 +4557,7 @@ function digestRun(messages, maxChars) {
 // src/duplex.ts
 import { MemFilesystem as MemFilesystem2 } from "@livx.cc/wcli/core";
 init_logging();
-var log7 = forComponent("DuplexAgent");
+var log8 = forComponent("DuplexAgent");
 function describeCall(call) {
   const v = call.args && Object.values(call.args).find((x) => typeof x === "string" && x.trim());
   const hint = v ? ` (${String(v).replace(/\s+/g, " ").trim().slice(0, 48)})` : "";
@@ -4543,7 +4697,7 @@ Today's date: ${(/* @__PURE__ */ new Date()).toDateString()}.`;
           const m = this.reflexBuf.match(RESERVED_EVENT_MARKER);
           if (m) {
             this.fabricationCut = true;
-            log7.warn(`reflex fabricated a [task \u2026] event in its spoken stream \u2014 cutting it (kept ${m.index} chars)`);
+            log8.warn(`reflex fabricated a [task \u2026] event in its spoken stream \u2014 cutting it (kept ${m.index} chars)`);
             const safe = this.reflexBuf.slice(this.reflexForwarded, m.index);
             if (!safe) return;
             if (safe.trim()) this.spokeThisTurn = true;
@@ -4610,23 +4764,28 @@ Today's date: ${(/* @__PURE__ */ new Date()).toDateString()}.`;
       }
     };
   }
-  /** True when the just-finished turn dispatched a task but voiced nothing — dead air to repair.
+  /** True when the just-finished turn voiced NOTHING — dead air to repair. Two ways this happens:
+   *  (a) a dispatch with no spoken ack, and (b) an INLINE turn whose `final` channel came back empty —
+   *  gpt-oss harmony sometimes puts the whole reply in `analysis` (→ thinking_delta, suppressed in
+   *  voice) and emits an empty `final`, so no text_delta ever streams. Both ship silence; both repair.
    *  Requires a host: without one there's no stream to detect speech on (and no one to speak to). */
-  get silentDispatch() {
-    return !!this.options.host && this.turnDispatched && !this.spokeThisTurn;
+  get silentTurn() {
+    return !!this.options.host && !this.spokeThisTurn;
   }
-  /** A dispatch with no spoken text is dead air. Re-prompt the reflex ONCE so the LLM itself voices a
-   *  short ack (no template). If it STILL says nothing, fall back to a minimal line so silence never ships. */
+  /** A turn that voiced nothing is dead air. Re-prompt the reflex ONCE so the LLM itself voices a short
+   *  line (no template). If it STILL says nothing, fall back to a minimal line so silence never ships.
+   *  Wording adapts to whether work was dispatched (an ack) or the inline reply was simply lost. */
   async ackIfSilent() {
+    const dispatched = this.turnDispatched;
     this.nudging = true;
     try {
-      await this.voice.send("[reminder] You dispatched a task but said nothing to the user. Say ONE short spoken acknowledgement now \u2014 no tools.");
+      await this.voice.send(dispatched ? "[reminder] You dispatched a task but said nothing to the user. Say ONE short spoken acknowledgement now \u2014 no tools." : "[reminder] You said nothing to the user this turn. Give your ONE short spoken reply now \u2014 no tools.");
     } catch (e) {
-      log7.warn(`ack nudge failed: ${e instanceof Error ? e.message : e}`);
+      log8.warn(`ack nudge failed: ${e instanceof Error ? e.message : e}`);
     } finally {
       this.nudging = false;
     }
-    if (!this.spokeThisTurn) this.options.host?.notify?.({ kind: "text_delta", message: "Okay, on it." });
+    if (!this.spokeThisTurn) this.options.host?.notify?.({ kind: "text_delta", message: dispatched ? "Okay, on it." : "Sorry, could you say that again?" });
   }
   /** One user turn: the voice agent streams the reply (and may Act/Think). Serialized with re-voice turns. */
   send(content) {
@@ -4634,7 +4793,7 @@ Today's date: ${(/* @__PURE__ */ new Date()).toDateString()}.`;
       await this.initMemory();
       this.resetTurn();
       const res = await this.voice.send(content);
-      if (this.silentDispatch) await this.ackIfSilent();
+      if (this.silentTurn) await this.ackIfSilent();
       return res;
     });
   }
@@ -4679,7 +4838,7 @@ Today's date: ${(/* @__PURE__ */ new Date()).toDateString()}.`;
       if (!events.length) return;
       this.resetTurn();
       await this.voice.send(events.join("\n"));
-      if (this.silentDispatch) await this.ackIfSilent();
+      if (this.silentTurn) await this.ackIfSilent();
       this.notify("revoice_done", "");
     });
   }
@@ -4770,7 +4929,7 @@ Another agent just implemented the above. Independently check the CURRENT state
     this.notify("task_verify", `task ${id}: verifying`, { id });
     const cres = await new Agent(agentOpts).run(checkBrief);
     if (cres.finishReason !== "stop") {
-      log7.warn(`task ${id}: verify inconclusive (${cres.finishReason})`);
+      log8.warn(`task ${id}: verify inconclusive (${cres.finishReason})`);
       this.notify("task_verify", `task ${id}: verify inconclusive (${cres.finishReason})`, { id, finishReason: cres.finishReason });
     }
     const sum = (a = 0, b = 0) => a + b;
@@ -4873,7 +5032,7 @@ Another agent just implemented the above. Independently check the CURRENT state
     }
     rec.status = "done";
     rec.result = res.text;
-    log7.verbose(`task ${id} done (${res.steps} steps)`);
+    log8.verbose(`task ${id} done (${res.steps} steps)`);
     this.notify("task_done", `task ${id} (${rec.label}) completed`, {
       id,
       text: res.text,
@@ -4891,7 +5050,7 @@ Another agent just implemented the above. Independently check the CURRENT state
     this.dropAsk(rec.id);
     rec.status = "error";
     rec.result = msg;
-    log7.warn(`task ${rec.id} failed: ${msg}`);
+    log8.warn(`task ${rec.id} failed: ${msg}`);
     this.notify("task_error", `task ${rec.id} (${rec.label}) failed: ${msg}`);
     this.queueRevoice(`[task ${rec.id} failed] ${msg}`);
   }
@@ -5193,7 +5352,7 @@ init_logging();
 
 // src/voice/engine.ts
 init_logging();
-var log8 = forComponent("VoiceEngine");
+var log9 = forComponent("VoiceEngine");
 var now = () => performance.now();
 var forSpeech = (t) => t.replace(/[*_`#]+/g, "").replace(/^[ \t]*[-•]\s+/gm, "").replace(/\s*[\u2013\u2014]\s*/g, ", ").replace(/[\u2010\u2011]/g, "-").replace(/\s*\|\s*/g, ", ").replace(/(\d)\s+%/g, "$1%").replace(/\.{3,}/g, ".");
 var VoiceEngineOptions = class {
@@ -5301,7 +5460,7 @@ var VoiceEngine = class _VoiceEngine {
     this.stt.onLevel = (rms) => this.handleLevel(rms);
     await Promise.all([this.tts.connect(), this.stt.start()]);
     this.setState("listening");
-    log8.debug(`voice I/O up (${this.stt.usingAec ? "AEC" : "heuristic echo"} capture)`);
+    log9.debug(`voice I/O up (${this.stt.usingAec ? "AEC" : "heuristic echo"} capture)`);
   }
   get usingAec() {
     return this.stt.usingAec;
@@ -5353,7 +5512,7 @@ var VoiceEngine = class _VoiceEngine {
     this.reply += text;
     for (const w of this.words(this.reply)) this.echoWords.add(w);
     this.tts.speak(forSpeech(text), true);
-    if (!this.spokeDeltas && this.turnStartAt) log8.debug(`ttft: ${Math.round(now() - this.turnStartAt)}ms`);
+    if (!this.spokeDeltas && this.turnStartAt) log9.debug(`ttft: ${Math.round(now() - this.turnStartAt)}ms`);
     this.spokeDeltas = true;
     this.setState("speaking");
   }
@@ -5374,7 +5533,7 @@ var VoiceEngine = class _VoiceEngine {
       }
       this.drainTimer = null;
       this.speaking = false;
-      if (this.turnStartAt) log8.debug(`turn: ${Math.round(now() - this.turnStartAt)}ms (incl. playback)`);
+      if (this.turnStartAt) log9.debug(`turn: ${Math.round(now() - this.turnStartAt)}ms (incl. playback)`);
       this.echoUntil = now() + 2500;
       if (!this.usingAec) this.stt.reset();
       this.setState("listening");
@@ -5515,7 +5674,7 @@ var VoiceEngine = class _VoiceEngine {
     this.pendingUtt = this.pendingUtt ? `${this.pendingUtt} ${text}` : text;
     if (this.pendingTimer) clearTimeout(this.pendingTimer);
     if (this.options.incompleteMergeMs && this.looksIncomplete(this.pendingUtt)) {
-      log8.verbose(`hold: incomplete utterance "${this.pendingUtt.slice(-40)}"`);
+      log9.verbose(`hold: incomplete utterance "${this.pendingUtt.slice(-40)}"`);
       this.options.onHold();
       if (this.options.holdFiller && !this.speaking) {
         this.beginSpeech();
@@ -5613,7 +5772,7 @@ async function resolveAuth(auth) {
 }
 
 // src/voice/soniox.ts
-var log9 = forComponent("SonioxSTT");
+var log10 = forComponent("SonioxSTT");
 var now2 = () => performance.now();
 var SonioxSTTOptions = class {
   auth = "";
@@ -5670,9 +5829,9 @@ var SonioxSTT = class {
     this.ws.onmessage = (ev) => this.handle(JSON.parse(String(ev.data)));
     this.ws.onclose = (ev) => {
       if (this.stopped) return;
-      log9.warn(`soniox ws closed (${ev.code} ${ev.reason || ""}) \u2014 reconnecting`);
+      log10.warn(`soniox ws closed (${ev.code} ${ev.reason || ""}) \u2014 reconnecting`);
       this.reset();
-      this.connectWs().catch((e) => log9.error(`soniox reconnect failed: ${e.message}`));
+      this.connectWs().catch((e) => log10.error(`soniox reconnect failed: ${e.message}`));
     };
   }
   async start() {
@@ -5682,7 +5841,7 @@ var SonioxSTT = class {
     this.endpointTimer = setInterval(() => {
       const combined = (this.finalText + this.partialText).trim();
       if (!combined || now2() - this.lastChangeAt < this.options.silenceEndpointMs) return;
-      if (this.firstTokenAt) log9.debug(`stt: ${Math.round(now2() - this.firstTokenAt)}ms first-token\u2192silence-endpoint, "${combined.slice(0, 60)}"`);
+      if (this.firstTokenAt) log10.debug(`stt: ${Math.round(now2() - this.firstTokenAt)}ms first-token\u2192silence-endpoint, "${combined.slice(0, 60)}"`);
       this.reset();
       this.onUtterance(combined, now2());
     }, 120);
@@ -5699,7 +5858,7 @@ var SonioxSTT = class {
     });
   }
   handle(m) {
-    if (m.error_message) return log9.error(`soniox: ${m.error_message}`);
+    if (m.error_message) return log10.error(`soniox: ${m.error_message}`);
     let endpoint = false;
     for (const t of m.tokens ?? []) {
       if (t.text === "<end>") endpoint = true;
@@ -5715,7 +5874,7 @@ var SonioxSTT = class {
     this.onPartial(combined);
     if (endpoint && this.finalText.trim()) {
       const utterance = this.finalText.trim();
-      if (this.firstTokenAt) log9.debug(`stt: ${Math.round(now2() - this.firstTokenAt)}ms first-token\u2192endpoint, "${utterance.slice(0, 60)}"`);
+      if (this.firstTokenAt) log10.debug(`stt: ${Math.round(now2() - this.firstTokenAt)}ms first-token\u2192endpoint, "${utterance.slice(0, 60)}"`);
       this.reset();
       this.onUtterance(utterance, now2());
     }
@@ -5737,7 +5896,7 @@ var SonioxSTT = class {
 
 // src/voice/cartesia.ts
 init_logging();
-var log10 = forComponent("CartesiaTTS");
+var log11 = forComponent("CartesiaTTS");
 var now3 = () => performance.now();
 var CartesiaTTSOptions = class {
   auth = "";
@@ -5787,9 +5946,9 @@ var CartesiaTTS = class _CartesiaTTS {
       this.ws.onerror = (e) => rej(new Error(`cartesia ws: ${e.message || "connect failed"}`));
     });
     this.ws.onclose = (ev) => {
-      log10.warn(`cartesia ws closed (${ev.code} ${ev.reason || ""})`);
+      log11.warn(`cartesia ws closed (${ev.code} ${ev.reason || ""})`);
       if (!this.closed) {
-        this.connecting = this.doConnect().catch((e) => log10.error(`cartesia reconnect failed: ${e.message}`));
+        this.connecting = this.doConnect().catch((e) => log11.error(`cartesia reconnect failed: ${e.message}`));
       }
     };
     this.ws.onmessage = (ev) => {
@@ -5811,11 +5970,11 @@ var CartesiaTTS = class _CartesiaTTS {
           this.down = true;
           this.downAt = now3();
           this.consecutiveOk = 0;
-          log10.warn(`TTS circuit breaker open \u2014 ${this.consecutiveErrors} consecutive errors, switching to text-only`);
+          log11.warn(`TTS circuit breaker open \u2014 ${this.consecutiveErrors} consecutive errors, switching to text-only`);
           this.onDone();
           this.startProbe();
         } else if (!this.down) {
-          log10.warn(`cartesia: ${JSON.stringify(m)}`);
+          log11.warn(`cartesia: ${JSON.stringify(m)}`);
         }
       }
     };
@@ -5829,7 +5988,7 @@ var CartesiaTTS = class _CartesiaTTS {
     this.consecutiveOk = 0;
     this.stopProbe();
     const downMs = this.downAt ? now3() - this.downAt : 0;
-    (downMs < 2e3 ? log10.debug : log10.info)(`TTS recovered${downMs ? ` (down ${downMs}ms)` : ""}`);
+    (downMs < 2e3 ? log11.debug : log11.info)(`TTS recovered${downMs ? ` (down ${downMs}ms)` : ""}`);
   }
   /** Ensure the WS is open before sending — reconnects if idle-closed. */
   async ensureConnected() {
@@ -5909,7 +6068,7 @@ import { MemFilesystem as MemFilesystem3, IndexedDbFilesystem, CommandExecutor a
 init_logging();
 import { spawn } from "child_process";
 import { createHash } from "crypto";
-var log11 = forComponent("mcp");
+var log12 = forComponent("mcp");
 var PROTOCOL_VERSION = "2025-06-18";
 var DEFAULT_TIMEOUT_MS = 3e4;
 var StdioTransport = class {
@@ -5928,7 +6087,7 @@ var StdioTransport = class {
     proc.stdout.setEncoding("utf8");
     proc.stdout.on("data", (chunk) => this.onData(chunk));
     proc.stderr.setEncoding("utf8");
-    proc.stderr.on("data", (chunk) => log11.debug(`[${command}] stderr:`, chunk.trimEnd()));
+    proc.stderr.on("data", (chunk) => log12.debug(`[${command}] stderr:`, chunk.trimEnd()));
     proc.on("exit", (code) => this.failAll(new Error(`MCP server "${command}" exited (code ${code})`)));
     proc.on("error", (e) => this.failAll(e instanceof Error ? e : new Error(String(e))));
   }
@@ -5942,7 +6101,7 @@ var StdioTransport = class {
       try {
         this.dispatch(JSON.parse(line));
       } catch (e) {
-        log11.debug("dropping non-JSON line from MCP server:", line, e);
+        log12.debug("dropping non-JSON line from MCP server:", line, e);
       }
     }
   }
@@ -5991,7 +6150,7 @@ var StdioTransport = class {
     try {
       this.proc?.stdin?.end();
     } catch (e) {
-      log11.debug("stdin end failed", e);
+      log12.debug("stdin end failed", e);
     }
     this.proc?.kill();
   }
@@ -6060,7 +6219,7 @@ function parseSseResponse(body) {
       const obj = JSON.parse(trimmed.slice(5).trim());
       if (obj && (obj.result !== void 0 || obj.error !== void 0)) return obj;
     } catch (e) {
-      log11.debug("skipping unparseable SSE data line", e);
+      log12.debug("skipping unparseable SSE data line", e);
     }
   }
   return {};
@@ -6128,7 +6287,7 @@ async function mountWithDeadline(name, cfg, mountTimeoutMs) {
       return { name, client, tools, specs, serverInfo: init?.serverInfo, config: cfg };
     })(), mountTimeoutMs, name);
   } catch (e) {
-    await client.close().catch((err2) => log11.debug(`close after failed mount of "${name}": ${err2}`));
+    await client.close().catch((err2) => log12.debug(`close after failed mount of "${name}": ${err2}`));
     throw e;
   }
 }
@@ -6139,15 +6298,15 @@ function validEntries(servers) {
   return Object.entries(servers).filter(([name, cfg]) => {
     if (!cfg || cfg.disabled) return false;
     if (!cfg.command && !cfg.url) {
-      log11.warn(`MCP server "${name}" needs a command (stdio) or url (http) \u2014 skipping`);
+      log12.warn(`MCP server "${name}" needs a command (stdio) or url (http) \u2014 skipping`);
       return false;
     }
     return true;
   });
 }
 function logMountFailure(name, e) {
-  if (e instanceof McpAuthError) log11.warn(`MCP "${name}" needs-auth: HTTP ${e.status} \u2014 set bearerToken or headers in its config; skipping`);
-  else log11.error(`MCP server "${name}" failed to mount: ${e?.message ?? e}`);
+  if (e instanceof McpAuthError) log12.warn(`MCP "${name}" needs-auth: HTTP ${e.status} \u2014 set bearerToken or headers in its config; skipping`);
+  else log12.error(`MCP server "${name}" failed to mount: ${e?.message ?? e}`);
 }
 async function mountMcpServers(servers = {}, opts = {}) {
   const entries = validEntries(servers);
@@ -6157,7 +6316,7 @@ async function mountMcpServers(servers = {}, opts = {}) {
     const name = entries[i][0];
     if (r.status === "fulfilled") {
       out.push(r.value);
-      log11.debug(`MCP "${name}" mounted \u2014 ${r.value.tools.length} tool(s)${r.value.serverInfo?.name ? ` from ${r.value.serverInfo.name}` : ""}`);
+      log12.debug(`MCP "${name}" mounted \u2014 ${r.value.tools.length} tool(s)${r.value.serverInfo?.name ? ` from ${r.value.serverInfo.name}` : ""}`);
     } else logMountFailure(name, r.reason);
   });
   return out;
@@ -6197,7 +6356,7 @@ var McpPool = class {
     const prev = this.warm.get(key);
     if (prev) {
       clearTimeout(prev.timer);
-      if (prev.client !== client) void prev.client.close().catch((err2) => log11.debug(`warm-pool replace close failed: ${err2}`));
+      if (prev.client !== client) void prev.client.close().catch((err2) => log12.debug(`warm-pool replace close failed: ${err2}`));
     }
     const e = { client, timer: void 0 };
     this.warm.set(key, e);
@@ -6214,7 +6373,7 @@ var McpPool = class {
     const e = this.warm.get(key);
     if (!e) return;
     this.warm.delete(key);
-    await e.client.close().catch((err2) => log11.debug(`warm-pool evict close failed: ${err2}`));
+    await e.client.close().catch((err2) => log12.debug(`warm-pool evict close failed: ${err2}`));
   }
   async closeAll() {
     for (const e of this.warm.values()) {
@@ -6231,7 +6390,7 @@ var defaultPool = new McpPool();
 // cli/mcpOAuth.ts
 import { createServer } from "http";
 import { randomBytes, createHash as createHash2 } from "crypto";
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync } from "fs";
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, existsSync } from "fs";
 import { dirname as dirname2 } from "path";
 var McpOAuthOptions = class {
   /** Where to persist tokens. Mode 0600. */
@@ -6265,8 +6424,8 @@ var McpOAuth = class {
     }
   }
   save(store) {
-    mkdirSync2(dirname2(this.options.storePath), { recursive: true });
-    writeFileSync2(this.options.storePath, JSON.stringify(store, null, 2), { mode: 384 });
+    mkdirSync3(dirname2(this.options.storePath), { recursive: true });
+    writeFileSync3(this.options.storePath, JSON.stringify(store, null, 2), { mode: 384 });
   }
   // -- ATTENDED: one-time authorization ----------------------------------------
   /** Run the authorization-code + PKCE flow and persist the resulting tokens for `serverUrl`. */
@@ -6424,15 +6583,15 @@ function defaultOpenBrowser(url) {
 // cli/core.ts
 import { randomUUID } from "crypto";
 import { execFile as execFile2 } from "child_process";
-import { resolve, basename, join as join4 } from "path";
-import { existsSync as existsSync3, mkdirSync as mkdirSync3 } from "fs";
+import { resolve, basename, join as join5 } from "path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync4 } from "fs";
 import { platform, arch, release, userInfo, homedir as homedir2, tmpdir } from "os";
 init_tools_shell();
 
 // src/tools.notify.ts
 init_logging();
 import { execFile } from "child_process";
-var log13 = forComponent("notify");
+var log14 = forComponent("notify");
 function makeNotifyTool(opts = {}) {
   const platform2 = opts.platform ?? process.platform;
   const run = opts.exec ?? execFile;
@@ -6456,7 +6615,7 @@ function makeNotifyTool(opts = {}) {
       return new Promise((resolve4) => {
         run(argv[0], argv[1], { timeout: 5e3 }, (e) => {
           if (e) {
-            log13.debug("notification failed", e);
+            log14.debug("notification failed", e);
             resolve4(`Notification failed: ${e.message}`);
           } else resolve4("Notification shown.");
         });
@@ -6472,7 +6631,7 @@ import { BodDB as BodDB2 } from "@bod.ee/db";
 init_logging();
 import { existsSync as existsSync2, readFileSync as readFileSync3 } from "fs";
 import { homedir } from "os";
-var log14 = forComponent("cli-util");
+var log15 = forComponent("cli-util");
 function dotDirs(base, sub, opts = {}) {
   const home = opts.home ?? homedir();
   const dirs = [`${base}/.agent/${sub}`, `${base}/.claude/${sub}`, `${home}/.agent/${sub}`, `${home}/.claude/${sub}`];
@@ -6489,7 +6648,7 @@ function parseJson(text, fallback, what = "json") {
   try {
     return JSON.parse(text);
   } catch (e) {
-    log14.debug(`parseJson(${what}) failed: ${e.message}`);
+    log15.debug(`parseJson(${what}) failed: ${e.message}`);
     return fallback;
   }
 }
@@ -6499,7 +6658,7 @@ function readJsonFile(path, fallback) {
   try {
     text = readFileSync3(path, "utf8");
   } catch (e) {
-    log14.debug(`readJsonFile(${path}) unreadable: ${e.message}`);
+    log15.debug(`readJsonFile(${path}) unreadable: ${e.message}`);
     return fallback;
   }
   return parseJson(text, fallback, path);
@@ -6583,8 +6742,8 @@ async function buildAgent(o) {
     fs = mem;
   } else if (o.boddb) {
     const root = resolve(o.boddb);
-    mkdirSync3(root, { recursive: true });
-    const db = new BodDB2({ path: join4(root, "meta.db"), sweepInterval: 0, vfs: { storageRoot: join4(root, "files") } });
+    mkdirSync4(root, { recursive: true });
+    const db = new BodDB2({ path: join5(root, "meta.db"), sweepInterval: 0, vfs: { storageRoot: join5(root, "files") } });
     const bod = new BodDbFilesystem(db);
     const firstRun = (await bod.readDir("/").catch(() => [])).length === 0;
     await mkdirp(bod, cwd);
@@ -6711,6 +6870,9 @@ The filesystem root '/' is the real machine root \u2014 you have full filesystem
     ...scratch ? { capToolResult: (full, info) => scratch.spill(full, info) } : {},
     backgroundJobs: o.backgroundJobs ?? virtual,
     // default ON in virtual modes (no real shell there); disk uses ShellJobRegistry
+    // Subagent transcript traces, origin-anchored under .agent/traces (disk mode only — sandbox/db modes
+    // must never write the real disk). Lets an interrupted/failed child leave a readable trail + pointer.
+    ...!virtual ? { traceDir: `${cwd}/.agent/traces` } : {},
     skillsDir: dots("skills"),
     commandsDir: dots("commands"),
     memoryDir,
@@ -6744,11 +6906,11 @@ var trunc = (s, n) => (s == null ? "" : String(s).length > n ? String(s).slice(0
 // cli/voice.ts
 init_logging();
 import { spawn as spawn2, spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync4, mkdirSync as mkdirSync4, statSync as statSync3 } from "fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync5, statSync as statSync3 } from "fs";
 import { homedir as homedir3 } from "os";
-import { dirname as dirname3, join as join5 } from "path";
+import { dirname as dirname3, join as join6 } from "path";
 import { fileURLToPath } from "url";
-var log15 = forComponent("VoiceIO");
+var log16 = forComponent("VoiceIO");
 var now4 = () => performance.now();
 var Player = class {
   proc = null;
@@ -6762,7 +6924,7 @@ var Player = class {
       ["-loglevel", "quiet", "-nodisp", "-fflags", "nobuffer", "-flags", "low_delay", "-probesize", "32", "-f", "s16le", "-ar", String(TTS_SAMPLE_RATE), "-ch_layout", "mono", "-i", "-"],
       { stdio: ["pipe", "ignore", "ignore"] }
     );
-    this.proc.on("error", (e) => log15.warn(`ffplay error: ${e.message}`));
+    this.proc.on("error", (e) => log16.warn(`ffplay error: ${e.message}`));
     this.proc.stdin.on("error", () => {
     });
     this.bytesWritten = 0;
@@ -6789,7 +6951,7 @@ var Player = class {
     this.proc = null;
   }
 };
-var nativeDir = () => join5(dirname3(fileURLToPath(import.meta.url)), "native");
+var nativeDir = () => join6(dirname3(fileURLToPath(import.meta.url)), "native");
 function detectFfmpegMic() {
   if (process.env.MIC_DEVICE) return process.env.MIC_DEVICE;
   const out = spawnSync2("ffmpeg", ["-f", "avfoundation", "-list_devices", "true", "-i", ""], { encoding: "utf8" }).stderr;
@@ -6797,7 +6959,7 @@ function detectFfmpegMic() {
   const devices = [...audio.matchAll(/\[(\d+)\] (.+)/g)].map(([, idx, name]) => ({ idx, name: name.trim() }));
   const mic = devices.find((d) => /microphone|built-in/i.test(d.name) && !/teams|blackhole|loopback/i.test(d.name)) ?? devices[0];
   if (!mic) throw new Error("no audio input device found");
-  log15.debug(`ffmpeg mic: [${mic.idx}] ${mic.name}`);
+  log16.debug(`ffmpeg mic: [${mic.idx}] ${mic.name}`);
   return `:${mic.idx}`;
 }
 function detectedInputDevice() {
@@ -6825,23 +6987,23 @@ function detectedInputDevice() {
 }
 function resolveAecBinary() {
   if (process.env.MIC_AEC === "0" || process.platform !== "darwin") return null;
-  const src = join5(nativeDir(), "mic-aec.swift");
-  const plist = join5(nativeDir(), "Info.plist");
+  const src = join6(nativeDir(), "mic-aec.swift");
+  const plist = join6(nativeDir(), "Info.plist");
   if (!existsSync4(src)) return null;
-  const cacheDir = join5(homedir3(), ".agent", "cache");
-  const bin = join5(cacheDir, "mic-aec");
+  const cacheDir = join6(homedir3(), ".agent", "cache");
+  const bin = join6(cacheDir, "mic-aec");
   if (existsSync4(bin) && statSync3(bin).mtimeMs >= statSync3(src).mtimeMs) return bin;
   if (spawnSync2("which", ["swiftc"]).status !== 0) return null;
-  mkdirSync4(cacheDir, { recursive: true });
-  log15.info("compiling AEC mic helper (first run)\u2026");
+  mkdirSync5(cacheDir, { recursive: true });
+  log16.info("compiling AEC mic helper (first run)\u2026");
   const build = spawnSync2("swiftc", ["-O", "-o", bin, src, "-Xlinker", "-sectcreate", "-Xlinker", "__TEXT", "-Xlinker", "__info_plist", "-Xlinker", plist], { encoding: "utf8" });
   if (build.status !== 0) {
-    log15.warn(`AEC build failed: ${build.stderr?.slice(0, 400)}`);
+    log16.warn(`AEC build failed: ${build.stderr?.slice(0, 400)}`);
     return null;
   }
   const sign = spawnSync2("codesign", ["-fs", "-", bin], { encoding: "utf8" });
   if (sign.status !== 0) {
-    log15.warn(`codesign failed: ${sign.stderr?.slice(0, 200)}`);
+    log16.warn(`codesign failed: ${sign.stderr?.slice(0, 200)}`);
     return null;
   }
   return bin;
@@ -6860,16 +7022,16 @@ var NodeMicSource = class {
       this.proc = spawn2(this.bin, [], { stdio: ["ignore", "pipe", "ignore"] });
     } else {
       if (spawnSync2("which", ["ffmpeg"]).status !== 0) throw new Error("voice I/O unavailable: no AEC helper and no ffmpeg on PATH");
-      log15.info("mic: raw capture (no AEC) \u2014 echo handled heuristically; headphones recommended");
+      log16.info("mic: raw capture (no AEC) \u2014 echo handled heuristically; headphones recommended");
       this.proc = spawn2(
         "ffmpeg",
         ["-loglevel", "error", "-f", "avfoundation", "-i", detectFfmpegMic(), "-ar", String(STT_SAMPLE_RATE), "-ac", "1", "-f", "s16le", "-"],
         { stdio: ["ignore", "pipe", "pipe"] }
       );
-      this.proc.stderr.on("data", (d) => log15.warn(`ffmpeg: ${String(d).trim()}`));
+      this.proc.stderr.on("data", (d) => log16.warn(`ffmpeg: ${String(d).trim()}`));
     }
     this.proc.on("exit", (c) => {
-      if (c && !this.stopped) log15.error(`mic capture exited (${c}) \u2014 check mic permission / MIC_DEVICE / MIC_AEC=0`);
+      if (c && !this.stopped) log16.error(`mic capture exited (${c}) \u2014 check mic permission / MIC_DEVICE / MIC_AEC=0`);
     });
     this.proc.stdout.on("data", (chunk) => onChunk(chunk));
   }
@@ -6903,11 +7065,11 @@ var AecDuplexAudio = class {
     this.proc.stdin.on("error", () => {
     });
     this.proc.on("exit", (c) => {
-      if (c && !this.stopped) log15.error(`aec duplex audio exited (${c}) \u2014 check mic permission / MIC_AEC=0`);
+      if (c && !this.stopped) log16.error(`aec duplex audio exited (${c}) \u2014 check mic permission / MIC_AEC=0`);
     });
     this.proc.stdout.on("data", (chunk) => onChunk(chunk));
     this.proc.stderr.on("data", (d) => {
-      for (const ln of String(d).split("\n")) if (ln.trim()) log15.debug(`mic-aec: ${ln.trim()}`);
+      for (const ln of String(d).split("\n")) if (ln.trim()) log16.debug(`mic-aec: ${ln.trim()}`);
     });
   }
   stop() {
@@ -7029,12 +7191,12 @@ var VoiceIO = class extends VoiceEngine {
 // cli/config.ts
 import { homedir as homedir4 } from "os";
 import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 import { pathToFileURL } from "url";
 var FILES = ["config.ts", "config.js", "config.mjs", "config.json"];
 async function loadFrom(dir) {
   for (const f of FILES) {
-    const p = join6(dir, ".agent", f);
+    const p = join7(dir, ".agent", f);
     if (!existsSync5(p)) continue;
     try {
       const mod = await import(pathToFileURL(p).href, f.endsWith(".json") ? { with: { type: "json" } } : void 0);
@@ -7047,7 +7209,7 @@ async function loadFrom(dir) {
   return {};
 }
 function loadSettings(dir) {
-  const p = join6(dir, ".agent", "settings.json");
+  const p = join7(dir, ".agent", "settings.json");
   if (!existsSync5(p)) return {};
   try {
     const raw = JSON.parse(readFileSync4(p, "utf8"));
@@ -7084,7 +7246,7 @@ async function loadConfig(cwd) {
 
 // cli/hooks-config.ts
 import { spawnSync as spawnSync3 } from "child_process";
-var log16 = forComponent("hooks");
+var log17 = forComponent("hooks");
 var escapeRegex = (s) => s.replace(/[.+^${}()|[\]\\]/g, "\\$&");
 function ruleMatches(rule, toolName) {
   if (!rule.tool || rule.tool === "*") return true;
@@ -7101,7 +7263,7 @@ function runCmd(rule, env) {
     });
     return { code: r.status ?? 1, out: ((r.stdout ?? "") + (r.stderr ?? "")).trim() };
   } catch (e) {
-    log16.debug(`hook command failed: ${rule.command}`, e);
+    log17.debug(`hook command failed: ${rule.command}`, e);
     return { code: 1, out: String(e?.message ?? e) };
   }
 }
@@ -7205,15 +7367,15 @@ function formatDiff(ops, opts = {}) {
 }
 
 // cli/session.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync3, readdirSync, renameSync, symlinkSync as symlinkSync2, unlinkSync, readlinkSync } from "fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync4, readdirSync, renameSync, symlinkSync as symlinkSync2, unlinkSync, readlinkSync } from "fs";
 import { homedir as homedir5 } from "os";
-import { join as join7 } from "path";
-var log17 = forComponent("session");
-var globalDir = () => join7(homedir5(), ".agent", "sessions");
+import { join as join8 } from "path";
+var log18 = forComponent("session");
+var globalDir = () => join8(homedir5(), ".agent", "sessions");
 var SessionStore = class {
   dir;
   constructor(cwd) {
-    this.dir = join7(cwd, ".agent", "sessions");
+    this.dir = join8(cwd, ".agent", "sessions");
   }
   /** Sortable, human-readable id: `YYYYMMDD-HHMMSS-<folder>`. */
   newId(now5 = Date.now(), cwd) {
@@ -7221,10 +7383,10 @@ var SessionStore = class {
     const p = (n, w = 2) => String(n).padStart(w, "0");
     const slug2 = (cwd ?? process.cwd()).split("/").pop()?.replace(/[^A-Za-z0-9_-]/g, "") || "session";
     let id = `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}-${slug2}`;
-    if (existsSync6(this.dir) && existsSync6(join7(this.dir, `${id}.json`))) {
+    if (existsSync6(this.dir) && existsSync6(join8(this.dir, `${id}.json`))) {
       for (let i = 2; i <= 99; i++) {
         const c = `${id}-${i}`;
-        if (!existsSync6(join7(this.dir, `${c}.json`))) {
+        if (!existsSync6(join8(this.dir, `${c}.json`))) {
           id = c;
           break;
         }
@@ -7238,30 +7400,30 @@ var SessionStore = class {
   }
   save(data) {
     if (!this.safeId(data.meta.id)) throw new Error(`unsafe session id: ${data.meta.id}`);
-    if (!existsSync6(this.dir)) mkdirSync5(this.dir, { recursive: true });
-    const path = join7(this.dir, `${data.meta.id}.json`);
+    if (!existsSync6(this.dir)) mkdirSync6(this.dir, { recursive: true });
+    const path = join8(this.dir, `${data.meta.id}.json`);
     const tmp = `${path}.${process.pid}.tmp`;
-    writeFileSync3(tmp, JSON.stringify(data));
+    writeFileSync4(tmp, JSON.stringify(data));
     renameSync(tmp, path);
     try {
       const gd = globalDir();
-      if (!existsSync6(gd)) mkdirSync5(gd, { recursive: true });
-      const link2 = join7(gd, `${data.meta.id}.json`);
+      if (!existsSync6(gd)) mkdirSync6(gd, { recursive: true });
+      const link2 = join8(gd, `${data.meta.id}.json`);
       if (!existsSync6(link2)) symlinkSync2(path, link2);
     } catch {
     }
   }
   load(id) {
     if (!this.safeId(id)) {
-      log17.debug(`rejecting unsafe session id: ${id}`);
+      log18.debug(`rejecting unsafe session id: ${id}`);
       return void 0;
     }
-    const path = join7(this.dir, `${id}.json`);
+    const path = join8(this.dir, `${id}.json`);
     if (!existsSync6(path)) return void 0;
     try {
       return JSON.parse(readFileSync5(path, "utf8"));
     } catch (e) {
-      log17.debug(`unreadable session ${id} \u2014 ignoring`, e);
+      log18.debug(`unreadable session ${id} \u2014 ignoring`, e);
       return void 0;
     }
   }
@@ -7272,9 +7434,9 @@ var SessionStore = class {
     for (const f of readdirSync(this.dir)) {
       if (!f.endsWith(".json")) continue;
       try {
-        metas.push(JSON.parse(readFileSync5(join7(this.dir, f), "utf8")).meta);
+        metas.push(JSON.parse(readFileSync5(join8(this.dir, f), "utf8")).meta);
       } catch (e) {
-        log17.debug(`skipping unreadable session file ${f}`, e);
+        log18.debug(`skipping unreadable session file ${f}`, e);
       }
     }
     return metas.sort((a, b) => b.updated - a.updated);
@@ -7291,7 +7453,7 @@ var SessionStore = class {
 function globalSessionLoad(idOrPrefix) {
   const gd = globalDir();
   if (!existsSync6(gd)) return void 0;
-  const exact = join7(gd, `${idOrPrefix}.json`);
+  const exact = join8(gd, `${idOrPrefix}.json`);
   if (existsSync6(exact)) {
     try {
       const target = readlinkSync(exact);
@@ -7305,7 +7467,7 @@ function globalSessionLoad(idOrPrefix) {
       if (!f.endsWith(".json")) continue;
       const base = f.slice(0, -5);
       if (base.includes(idOrPrefix) || base.endsWith(idOrPrefix)) {
-        const target = readlinkSync(join7(gd, f));
+        const target = readlinkSync(join8(gd, f));
         return JSON.parse(readFileSync5(target, "utf8"));
       }
     }
@@ -7320,10 +7482,10 @@ function globalSessionList() {
   for (const f of readdirSync(gd)) {
     if (!f.endsWith(".json")) continue;
     try {
-      const target = readlinkSync(join7(gd, f));
+      const target = readlinkSync(join8(gd, f));
       if (!existsSync6(target)) {
         try {
-          unlinkSync(join7(gd, f));
+          unlinkSync(join8(gd, f));
         } catch {
         }
         continue;
@@ -7440,9 +7602,9 @@ ${formatDiff(ops)}`);
 // cli/gitCheckpoints.ts
 import { execFile as execFile3 } from "child_process";
 import { promisify } from "util";
-import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync6, existsSync as existsSync7 } from "fs";
-import { join as join8, resolve as resolve2, sep as sep2 } from "path";
-var log18 = forComponent("checkpoints");
+import { writeFileSync as writeFileSync5, mkdirSync as mkdirSync7, existsSync as existsSync7 } from "fs";
+import { join as join9, resolve as resolve2, sep as sep2 } from "path";
+var log19 = forComponent("checkpoints");
 var exec = promisify(execFile3);
 var DEFAULT_EXCLUDE = [".agent/", ".git/", "node_modules/", "dist/", "build/", ".next/", "target/", ".venv/", "__pycache__/", "*.log"];
 var ShadowRepo = class {
@@ -7474,13 +7636,13 @@ var ShadowRepo = class {
     try {
       await exec(this.git, ["--version"]);
       if (!existsSync7(this.gitDir)) {
-        mkdirSync6(this.gitDir, { recursive: true });
+        mkdirSync7(this.gitDir, { recursive: true });
         await this.run("init", "-q");
       }
-      writeFileSync4(join8(this.gitDir, "info", "exclude"), this.exclude.join("\n") + "\n");
+      writeFileSync5(join9(this.gitDir, "info", "exclude"), this.exclude.join("\n") + "\n");
       this.ready = true;
     } catch (e) {
-      log18.debug(`git checkpoints unavailable for ${this.workTree}`, e);
+      log19.debug(`git checkpoints unavailable for ${this.workTree}`, e);
       this.ready = false;
     }
     return this.ready;
@@ -7491,7 +7653,7 @@ var ShadowRepo = class {
   }
   async commit(label, forced = []) {
     await this.run("add", "-A");
-    for (const p of forced) await this.run("add", "-f", "--", p).catch((e) => log18.debug(`force-add failed: ${p}`, e));
+    for (const p of forced) await this.run("add", "-f", "--", p).catch((e) => log19.debug(`force-add failed: ${p}`, e));
     await this.run("commit", "--allow-empty", "-q", "-m", label);
   }
   /** Inject the CURRENT (pre-edit) content of `paths` into the turn-open restore point by amending it.
@@ -7499,8 +7661,8 @@ var ShadowRepo = class {
    *  turn-boundary `add -A` would never have captured it. Amend (vs a new commit) keeps one restore
    *  point per turn, so the REPL's turn↔frame mapping stays intact. */
   async amendForced(paths) {
-    for (const p of paths) await this.run("add", "-f", "--", p).catch((e) => log18.debug(`force-capture failed: ${p}`, e));
-    await this.run("commit", "--amend", "--no-edit", "-q", "--allow-empty").catch((e) => log18.debug("amend failed", e));
+    for (const p of paths) await this.run("add", "-f", "--", p).catch((e) => log19.debug(`force-capture failed: ${p}`, e));
+    await this.run("commit", "--amend", "--no-edit", "-q", "--allow-empty").catch((e) => log19.debug("amend failed", e));
   }
   /** Commits on `ref`, oldest-first (canonical index space). */
   async log(ref) {
@@ -7560,7 +7722,7 @@ var ShadowRepo = class {
       await this.run("gc", "--auto", "-q").catch(() => {
       });
     } catch (e) {
-      log18.debug("checkpoint prune failed", e);
+      log19.debug("checkpoint prune failed", e);
     }
   }
 };
@@ -7592,7 +7754,7 @@ var GitCheckpoints = class {
       const abs = resolve2(d);
       if (abs === cwd || abs.startsWith(cwd + sep2)) continue;
       if (cwd.startsWith(abs + sep2)) continue;
-      out.push({ workTree: abs, gitDir: join8(abs, ".agent", "checkpoints.git") });
+      out.push({ workTree: abs, gitDir: join9(abs, ".agent", "checkpoints.git") });
     }
     return out;
   }
@@ -7619,7 +7781,7 @@ var GitCheckpoints = class {
   use(sessionId) {
     if (sessionId === this.session) return;
     this.session = sessionId;
-    if (this.started) for (const r of this.repos) void r.point(this.ref()).catch((e) => log18.debug("re-point failed", e));
+    if (this.started) for (const r of this.repos) void r.point(this.ref()).catch((e) => log19.debug("re-point failed", e));
   }
   async begin(label) {
     if (!await this.start()) return;
@@ -7631,7 +7793,7 @@ var GitCheckpoints = class {
       try {
         await this.repos[i].commit(msg, forced);
       } catch (e) {
-        log18.debug("checkpoint commit failed", e);
+        log19.debug("checkpoint commit failed", e);
       }
     }
     if (slow) clearTimeout(slow);
@@ -7661,7 +7823,7 @@ var GitCheckpoints = class {
           if (this.forced.has(abs)) continue;
           this.forced.add(abs);
           const i = this.repoIndexFor(abs);
-          if (i >= 0) await this.repos[i].amendForced([abs]).catch((e) => log18.debug("amendForced failed", e));
+          if (i >= 0) await this.repos[i].amendForced([abs]).catch((e) => log19.debug("amendForced failed", e));
         }
       }
     };
@@ -7713,7 +7875,7 @@ var GitCheckpointsOptions = class {
   /** Real working tree to snapshot (the launch cwd). */
   workTree = process.cwd();
   /** Isolated git dir for the cwd shadow repo (kept out of the user's real .git). */
-  gitDir = join8(process.cwd(), ".agent", "checkpoints.git");
+  gitDir = join9(process.cwd(), ".agent", "checkpoints.git");
   /** Extra mounted dirs (`--add-dir`); those outside cwd each get their own shadow repo. */
   addDirs = [];
   /** Conversation id → per-session restore-point ref. */
@@ -7727,9 +7889,9 @@ var GitCheckpointsOptions = class {
 };
 
 // cli/permissions.ts
-import { writeFileSync as writeFileSync5, mkdirSync as mkdirSync7 } from "fs";
+import { writeFileSync as writeFileSync6, mkdirSync as mkdirSync8 } from "fs";
 import { homedir as homedir6 } from "os";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 var RULE_RE = /^(\w+)(?:\((.+)\))?$/;
 function parseOne(raw, decision) {
   const m = RULE_RE.exec(raw.trim());
@@ -7751,13 +7913,13 @@ function parsePermRules(perms) {
 function describeRule(r) {
   return `${r.decision.padEnd(5)} ${r.tool ?? "*"}${r.pathGlob ? `(${r.pathGlob})` : ""}`;
 }
-var PERM_FILE = (cwd) => join9(cwd, ".agent", "permissions.json");
+var PERM_FILE = (cwd) => join10(cwd, ".agent", "permissions.json");
 function loadPersistedRules(cwd) {
   const j = readJsonFile(PERM_FILE(cwd), null);
   return j ? { allow: j.allow ?? [], ask: j.ask ?? [], deny: j.deny ?? [] } : {};
 }
 function loadClaudeSettings(cwd, home = homedir6()) {
-  const files = [join9(home, ".claude", "settings.json"), join9(cwd, ".claude", "settings.json"), join9(cwd, ".claude", "settings.local.json")];
+  const files = [join10(home, ".claude", "settings.json"), join10(cwd, ".claude", "settings.json"), join10(cwd, ".claude", "settings.local.json")];
   let out = {};
   for (const p of files) {
     const perms = readJsonFile(p, null)?.permissions;
@@ -7770,8 +7932,8 @@ function persistRule(cwd, decision, ruleStr) {
   const list = cur[decision] ??= [];
   if (!list.includes(ruleStr)) list.push(ruleStr);
   try {
-    mkdirSync7(join9(cwd, ".agent"), { recursive: true });
-    writeFileSync5(PERM_FILE(cwd), JSON.stringify(cur, null, 2) + "\n");
+    mkdirSync8(join10(cwd, ".agent"), { recursive: true });
+    writeFileSync6(PERM_FILE(cwd), JSON.stringify(cur, null, 2) + "\n");
   } catch {
   }
 }
@@ -7784,7 +7946,7 @@ function mergePerms(a, b) {
   }
   return Object.keys(out).length ? out : void 0;
 }
-var TRUST_FILE = join9(homedir6(), ".agent", "trusted.json");
+var TRUST_FILE = join10(homedir6(), ".agent", "trusted.json");
 function isTrusted(cwd, file = TRUST_FILE) {
   const list = readJsonFile(file, []);
   return Array.isArray(list) && list.includes(cwd);
@@ -7794,8 +7956,8 @@ function trustDir(cwd, file = TRUST_FILE) {
   if (!Array.isArray(list)) list = [];
   if (!list.includes(cwd)) list.push(cwd);
   try {
-    mkdirSync7(join9(file, ".."), { recursive: true });
-    writeFileSync5(file, JSON.stringify(list, null, 2) + "\n");
+    mkdirSync8(join10(file, ".."), { recursive: true });
+    writeFileSync6(file, JSON.stringify(list, null, 2) + "\n");
   } catch {
   }
 }
@@ -7855,9 +8017,9 @@ function completePath(listDir, ref) {
 // cli/lineEditor.ts
 import { emitKeypressEvents } from "readline";
 import { spawnSync as spawnSync4 } from "child_process";
-import { writeFileSync as writeFileSync6, readFileSync as readFileSync6, unlinkSync as unlinkSync2 } from "fs";
+import { writeFileSync as writeFileSync7, readFileSync as readFileSync6, unlinkSync as unlinkSync2 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 
 // cli/bidi.ts
 var RTL_RE = /[\u0590-\u05ff\u0600-\u06ff\u0750-\u077f\u08a0-\u08ff\ufb1d-\ufdff\ufe70-\ufeff]/;
@@ -8934,9 +9096,9 @@ function createLineEditor(out) {
   function externalEdit(s) {
     const spec = process.env.VISUAL || process.env.EDITOR || "vi";
     const [cmd, ...cargs] = spec.split(" ").filter(Boolean);
-    const file = join10(tmpdir2(), `agentx-edit-${process.pid}-${Date.now()}.md`);
+    const file = join11(tmpdir2(), `agentx-edit-${process.pid}-${Date.now()}.md`);
     try {
-      writeFileSync6(file, s.buf);
+      writeFileSync7(file, s.buf);
       process.stdin.setRawMode(false);
       out.write("\x1B[?2004l");
       const r = spawnSync4(cmd, [...cargs, file], { stdio: "inherit" });
@@ -9364,23 +9526,23 @@ function readPlainLine() {
 
 // cli/osScheduler.ts
 import { spawnSync as spawnSync5 } from "child_process";
-import { writeFileSync as writeFileSync7, mkdirSync as mkdirSync8, readdirSync as readdirSync2, unlinkSync as unlinkSync3, chmodSync, existsSync as existsSync8 } from "fs";
+import { writeFileSync as writeFileSync8, mkdirSync as mkdirSync9, readdirSync as readdirSync2, unlinkSync as unlinkSync3, chmodSync, existsSync as existsSync8 } from "fs";
 import { homedir as homedir7 } from "os";
-import { join as join11 } from "path";
-var log19 = forComponent("os-sched");
+import { join as join12 } from "path";
+var log20 = forComponent("os-sched");
 var OsScheduler = class {
   options;
   constructor(options) {
     this.options = { ...new OsSchedulerOptions(), ...options };
   }
   get dir() {
-    return join11(this.options.home, ".agent", "sched");
+    return join12(this.options.home, ".agent", "sched");
   }
   label(id) {
     return `cc.livx.agentx.sched-${id}`;
   }
   plistPath(id) {
-    return join11(this.options.home, "Library", "LaunchAgents", `${this.label(id)}.plist`);
+    return join12(this.options.home, "Library", "LaunchAgents", `${this.label(id)}.plist`);
   }
   run(cmd, args, input) {
     return this.options.exec(cmd, args, input);
@@ -9391,16 +9553,16 @@ var OsScheduler = class {
   /** Register the job with the OS. Returns a human description of the mechanism used. Throws on failure. */
   schedule(spec) {
     if (!this.available()) throw new Error(`no OS scheduler on ${this.options.platform}`);
-    mkdirSync8(this.dir, { recursive: true });
+    mkdirSync9(this.dir, { recursive: true });
     const oneOff = "at" in spec.trigger;
     const script = this.writeScript(spec, oneOff);
     const mechanism = this.options.platform === "darwin" ? this.scheduleDarwin(spec, script) : this.scheduleLinux(spec, script, oneOff);
     const meta = { ...spec, created: Date.now(), mechanism };
-    writeFileSync7(join11(this.dir, `${spec.id}.json`), JSON.stringify(meta, null, 2));
+    writeFileSync8(join12(this.dir, `${spec.id}.json`), JSON.stringify(meta, null, 2));
     return mechanism;
   }
   cancel(id) {
-    const meta = readJsonFile(join11(this.dir, `${id}.json`), null);
+    const meta = readJsonFile(join12(this.dir, `${id}.json`), null);
     if (!meta) return false;
     try {
       if (this.options.platform === "darwin") {
@@ -9429,11 +9591,11 @@ var OsScheduler = class {
         }
       }
     } catch (e) {
-      log19.debug(`cancel ${id}`, e);
+      log20.debug(`cancel ${id}`, e);
     }
     for (const f of [`${id}.json`, `${id}.sh`]) {
       try {
-        unlinkSync3(join11(this.dir, f));
+        unlinkSync3(join12(this.dir, f));
       } catch {
       }
     }
@@ -9441,19 +9603,19 @@ var OsScheduler = class {
   }
   list() {
     if (!existsSync8(this.dir)) return [];
-    return readdirSync2(this.dir).filter((f) => f.endsWith(".json")).map((f) => readJsonFile(join11(this.dir, f), null)).filter(Boolean);
+    return readdirSync2(this.dir).filter((f) => f.endsWith(".json")).map((f) => readJsonFile(join12(this.dir, f), null)).filter(Boolean);
   }
   /** The per-job runner script: cd to the project, headless-resume the session, log, notify. */
   writeScript(spec, oneOff) {
-    const p = join11(this.dir, `${spec.id}.sh`);
+    const p = join12(this.dir, `${spec.id}.sh`);
     const q2 = (s) => `'${s.replace(/'/g, `'\\''`)}'`;
-    const cleanup = oneOff ? this.options.platform === "darwin" ? `launchctl remove ${this.label(spec.id)} 2>/dev/null; rm -f ${q2(this.plistPath(spec.id))} ${q2(join11(this.dir, `${spec.id}.json`))} ${q2(p)}
-` : `rm -f ${q2(join11(this.dir, `${spec.id}.json`))} ${q2(p)}
+    const cleanup = oneOff ? this.options.platform === "darwin" ? `launchctl remove ${this.label(spec.id)} 2>/dev/null; rm -f ${q2(this.plistPath(spec.id))} ${q2(join12(this.dir, `${spec.id}.json`))} ${q2(p)}
+` : `rm -f ${q2(join12(this.dir, `${spec.id}.json`))} ${q2(p)}
 ` : "";
-    writeFileSync7(p, `#!/bin/sh
+    writeFileSync8(p, `#!/bin/sh
 # agentx scheduled job ${spec.id}${spec.label ? ` \u2014 ${spec.label}` : ""}
 cd ${q2(spec.cwd)} || exit 1
-${this.options.agentx} -p ${q2(spec.prompt)} --resume ${q2(spec.sessionId)} --yes >> ${q2(join11(this.dir, `${spec.id}.log`))} 2>&1
+${this.options.agentx} -p ${q2(spec.prompt)} --resume ${q2(spec.sessionId)} --yes >> ${q2(join12(this.dir, `${spec.id}.log`))} 2>&1
 ${cleanup}`);
     chmodSync(p, 493);
     return p;
@@ -9490,8 +9652,8 @@ ${trigger}
 <key>RunAtLoad</key><false/>
 </dict></plist>
 `;
-    mkdirSync8(join11(this.options.home, "Library", "LaunchAgents"), { recursive: true });
-    writeFileSync7(this.plistPath(spec.id), plist);
+    mkdirSync9(join12(this.options.home, "Library", "LaunchAgents"), { recursive: true });
+    writeFileSync8(this.plistPath(spec.id), plist);
     this.run("launchctl", ["load", this.plistPath(spec.id)]);
     return `launchd:${this.label(spec.id)}`;
   }
@@ -9543,12 +9705,12 @@ function routeTrigger(trigger, backendHint, now5 = Date.now()) {
 // cli/remoteTrigger.ts
 import { createServer as createServer2, createConnection } from "net";
 import { spawn as spawn3 } from "child_process";
-import { existsSync as existsSync9, mkdirSync as mkdirSync9, unlinkSync as unlinkSync4, readdirSync as readdirSync3 } from "fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync10, unlinkSync as unlinkSync4, readdirSync as readdirSync3 } from "fs";
 import { homedir as homedir8 } from "os";
-import { join as join12 } from "path";
-var log20 = forComponent("remote-trigger");
-var TRIGGER_DIR = () => join12(homedir8(), ".agent", "triggers");
-var sockPath = (sessionId, dir = TRIGGER_DIR()) => join12(dir, `${sessionId}.sock`);
+import { join as join13 } from "path";
+var log21 = forComponent("remote-trigger");
+var TRIGGER_DIR = () => join13(homedir8(), ".agent", "triggers");
+var sockPath = (sessionId, dir = TRIGGER_DIR()) => join13(dir, `${sessionId}.sock`);
 var TriggerServer = class {
   constructor(onTrigger) {
     this.onTrigger = onTrigger;
@@ -9560,7 +9722,7 @@ var TriggerServer = class {
   start(sessionId, dir = TRIGGER_DIR()) {
     this.stop();
     try {
-      mkdirSync9(dir, { recursive: true, mode: 448 });
+      mkdirSync10(dir, { recursive: true, mode: 448 });
       const p = sockPath(sessionId, dir);
       try {
         unlinkSync4(p);
@@ -9584,13 +9746,13 @@ var TriggerServer = class {
             conn.end(JSON.stringify({ ok: false, error: String(e) }) + "\n");
           }
         });
-        conn.on("error", (e) => log20.debug("trigger conn error", e));
+        conn.on("error", (e) => log21.debug("trigger conn error", e));
       });
-      this.server.on("error", (e) => log20.debug("trigger server error", e));
+      this.server.on("error", (e) => log21.debug("trigger server error", e));
       this.server.listen(p);
       this.path = p;
     } catch (e) {
-      log20.debug("trigger server unavailable", e);
+      log21.debug("trigger server unavailable", e);
     }
   }
   /** Re-bind on /resume (the session id changed). */
@@ -9711,7 +9873,7 @@ var italic = C("3");
 var strike = C("9");
 var link = (text, url) => useColor ? `\x1B]8;;${url}\x1B\\${cyan(text)}\x1B]8;;\x1B\\` : `${text} (${url})`;
 var err = (s) => process.stderr.write(s);
-var log21 = forComponent("cli");
+var log22 = forComponent("cli");
 var VERSION = (() => {
   try {
     return JSON.parse(readFileSync7(new URL("../package.json", import.meta.url), "utf8")).version ?? "?";
@@ -9939,9 +10101,9 @@ function resolveModelOrNewest(model) {
 var ENV_KEY_ALIASES = { google: ["GEMINI_API_KEY"] };
 function loadInstallEnv() {
   let dir = dirname4(import.meta.path);
-  for (let i = 0; i < 5 && !existsSync10(join13(dir, "package.json")); i++) dir = dirname4(dir);
+  for (let i = 0; i < 5 && !existsSync10(join14(dir, "package.json")); i++) dir = dirname4(dir);
   for (const name of [".env", ".env.local"]) {
-    const file = join13(dir, name);
+    const file = join14(dir, name);
     if (!existsSync10(file)) continue;
     for (const line of readFileSync7(file, "utf8").split("\n")) {
       const m = line.match(/^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/);
@@ -10302,7 +10464,7 @@ function costOf(pricing, promptTokens = 0, completionTokens = 0, cacheCreationTo
 function turnCost(model, usage) {
   return costOf(getModelInfo(model)?.pricing, usage?.promptTokens ?? 0, usage?.completionTokens ?? 0, usage?.cacheCreationTokens ?? 0, usage?.cacheReadTokens ?? 0, model);
 }
-async function evaluateGoal(ai, condition, transcript, log22) {
+async function evaluateGoal(ai, condition, transcript, log23) {
   const recent = transcript.filter((m) => m.role === "assistant").slice(-8).map((m) => {
     const text = typeof m.content === "string" ? m.content : m.content.filter((p) => p.type === "text").map((p) => p.text).join(" ");
     return text.slice(0, 600);
@@ -10322,7 +10484,7 @@ ${recent}` }
     const match = r.content.match(/\{[\s\S]*\}/);
     if (match) return JSON.parse(match[0]);
   } catch (e) {
-    log22(dim(`  (goal evaluator error: ${e?.message ?? e})
+    log23(dim(`  (goal evaluator error: ${e?.message ?? e})
 `));
   }
   return { met: false, reason: "evaluation unclear" };
@@ -10529,13 +10691,13 @@ function mcpAgentTools(mounted, opts) {
   return tools;
 }
 async function closeMcp(mounted) {
-  await Promise.all(mounted.map((m) => m.client.close().catch((e) => log21.debug("mcp close failed", e))));
+  await Promise.all(mounted.map((m) => m.client.close().catch((e) => log22.debug("mcp close failed", e))));
 }
 var IMG_EXT = { ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".gif": "image/gif", ".webp": "image/webp" };
 function mentionRefs(line) {
   return [...line.matchAll(/(?:^|\s)@(?:"([^"]+)"|(\S+))/g)].map((m) => m[1] ?? m[2].replace(/[?!.,;:)\]}'">]+$/, "")).filter(Boolean);
 }
-var untilde = (p) => p.startsWith("~/") ? join13(homedir9(), p.slice(2)) : p;
+var untilde = (p) => p.startsWith("~/") ? join14(homedir9(), p.slice(2)) : p;
 function readImageParts(cwd, line) {
   const refs = mentionRefs(line);
   const parts = [];
@@ -10579,7 +10741,7 @@ async function expandMentions(fs, line) {
     if (loaded.includes(ref) || missing.includes(ref)) continue;
     if (ref.includes(":") && mcpMentionResolver) {
       const body = await mcpMentionResolver(ref).catch((e) => {
-        log21.debug("mcp mention resolve failed", e);
+        log22.debug("mcp mention resolve failed", e);
         return null;
       });
       if (body != null) {
@@ -10662,7 +10824,7 @@ async function runTurn(agent, store, session, task, cp, cwd = process.cwd(), sen
       try {
         store.save(session);
       } catch (ex) {
-        log21.debug("mid-turn session flush failed", ex);
+        log22.debug("mid-turn session flush failed", ex);
       }
     }
     return origNotify(e);
@@ -10775,25 +10937,25 @@ var AGENTS_MD_TEMPLATE = `# ${"${name}"}
 `;
 function initInstructions(cwd) {
   for (const f of ["AGENTS.md", "CLAUDE.md"]) {
-    if (existsSync10(join13(cwd, f))) {
+    if (existsSync10(join14(cwd, f))) {
       err(yellow(`  ${f} already exists \u2014 leaving it as-is
 `));
       return;
     }
   }
-  const path = join13(cwd, "AGENTS.md");
-  writeFileSync8(path, AGENTS_MD_TEMPLATE.replace("${name}", basename2(cwd)));
+  const path = join14(cwd, "AGENTS.md");
+  writeFileSync9(path, AGENTS_MD_TEMPLATE.replace("${name}", basename2(cwd)));
   err(green(`  created ${path}
 `) + dim("  edit it, then it auto-loads into every run.\n"));
 }
 function persistSetting(cwd, key, value) {
-  const path = join13(cwd, ".agent", "settings.json");
+  const path = join14(cwd, ".agent", "settings.json");
   try {
     const obj = existsSync10(path) ? JSON.parse(readFileSync7(path, "utf8")) : {};
     if (obj[key] === value) return;
     obj[key] = value;
-    mkdirSync10(dirname4(path), { recursive: true });
-    writeFileSync8(path, JSON.stringify(obj, null, 2) + "\n");
+    mkdirSync11(dirname4(path), { recursive: true });
+    writeFileSync9(path, JSON.stringify(obj, null, 2) + "\n");
   } catch (e) {
     err(yellow(`  \u26A0 couldn't persist ${key} to ${path} \u2014 ${e?.message ?? e}
 `));
@@ -10809,14 +10971,14 @@ var isCancelTeardown = (e) => {
 function installCancelGuards(mounted) {
   process.on("unhandledRejection", (e) => {
     if (isCancelTeardown(e)) {
-      log21.debug("suppressed unhandledRejection (cursor stream cancel)", e);
+      log22.debug("suppressed unhandledRejection (cursor stream cancel)", e);
       return;
     }
-    log21.error("unhandledRejection", e);
+    log22.error("unhandledRejection", e);
   });
   process.on("uncaughtException", (e) => {
     if (isCancelTeardown(e)) {
-      log21.debug("suppressed uncaughtException (cursor stream cancel)", e);
+      log22.debug("suppressed uncaughtException (cursor stream cancel)", e);
       return;
     }
     console.error(e);
@@ -10825,7 +10987,7 @@ function installCancelGuards(mounted) {
   });
 }
 async function repl(args, ai, cfg, cwd) {
-  const oauth = new McpOAuth({ storePath: join13(cwd, ".agent", "mcp-auth.json") });
+  const oauth = new McpOAuth({ storePath: join14(cwd, ".agent", "mcp-auth.json") });
   const mounted = await mountMcp(cfg, oauth);
   let mcpToolNames = [];
   const initialMcpTools = mcpAgentTools(mounted);
@@ -11033,7 +11195,7 @@ async function repl(args, ai, cfg, cwd) {
       quickLook: {
         branch: () => {
           try {
-            const head = readFileSync7(join13(cwd, ".git", "HEAD"), "utf8").trim();
+            const head = readFileSync7(join14(cwd, ".git", "HEAD"), "utf8").trim();
             return head.startsWith("ref: refs/heads/") ? `branch: ${head.slice("ref: refs/heads/".length)}` : `detached HEAD at ${head.slice(0, 12)}`;
           } catch {
             return "not a git repository";
@@ -11162,9 +11324,9 @@ async function repl(args, ai, cfg, cwd) {
   const pendingImages = [];
   const bangContext = [];
   const grabClipboardAttachment = () => {
-    const dir = join13(tmpdir3(), "agentx-pasted");
+    const dir = join14(tmpdir3(), "agentx-pasted");
     try {
-      mkdirSync10(dir, { recursive: true });
+      mkdirSync11(dir, { recursive: true });
     } catch {
     }
     const img = grabClipboardImage(dir, String(Date.now()));
@@ -11215,7 +11377,7 @@ async function repl(args, ai, cfg, cwd) {
     err(dim(`  \u23F0 ${scheduler.size} scheduled job(s) re-armed
 `));
   }
-  const checkpoints = args.vfs || args.boddb ? new CheckpointStack(agent.options.fs) : new GitCheckpoints({ workTree: cwd, gitDir: join13(cwd, ".agent", "checkpoints.git"), addDirs: args.addDirs, sessionId: session.meta.id });
+  const checkpoints = args.vfs || args.boddb ? new CheckpointStack(agent.options.fs) : new GitCheckpoints({ workTree: cwd, gitDir: join14(cwd, ".agent", "checkpoints.git"), addDirs: args.addDirs, sessionId: session.meta.id });
   const cpHooks = checkpoints.hooks?.();
   if (cpHooks) {
     agent.options.hooks = composeHooks(agent.options.hooks, cpHooks);
@@ -11267,14 +11429,14 @@ ${lines.join("\n")}
 Added entries are loadable now via the Skill/SlashCommand tools; removed ones are gone even if still listed in the system prompt.
 </system-reminder>`;
   };
-  const histPath = join13(cwd, ".agent", "history");
+  const histPath = join14(cwd, ".agent", "history");
   const history = existsSync10(histPath) ? readFileSync7(histPath, "utf8").split("\n").filter(Boolean).reverse().slice(0, 500) : [];
   const remember = (line) => {
     try {
-      mkdirSync10(join13(cwd, ".agent"), { recursive: true });
+      mkdirSync11(join14(cwd, ".agent"), { recursive: true });
       appendFileSync(histPath, line + "\n");
     } catch (e) {
-      log21.debug("history write failed", e);
+      log22.debug("history write failed", e);
     }
   };
   const ago = (t) => {
@@ -11345,7 +11507,7 @@ Added entries are loadable now via the Skill/SlashCommand tools; removed ones ar
       try {
         store.save(session);
       } catch (e) {
-        log21.debug("session save after rewind failed", e);
+        log22.debug("session save after rewind failed", e);
       }
       err(green("  \u27F2 jumped back") + dim(` \u2014 ${face.transcript.length} message(s) kept; edit + resend
 `));
@@ -11379,7 +11541,7 @@ ${task}`;
       bangContext.length = 0;
     }
     const delta = await refreshCatalogs().catch((e) => {
-      log21.debug("catalog refresh failed", e);
+      log22.debug("catalog refresh failed", e);
       return "";
     });
     if (delta) {
@@ -11596,8 +11758,8 @@ ${task}`;
         cfgFiles.length ? ok(`config: ${cfgFiles.join(", ")}`) : warn("no .agent/config.* found (project or ~) \u2014 running on defaults");
         try {
           const probe = `${cwd}/.agent/sessions/.doctor-probe`;
-          mkdirSync10(`${cwd}/.agent/sessions`, { recursive: true });
-          writeFileSync8(probe, "ok");
+          mkdirSync11(`${cwd}/.agent/sessions`, { recursive: true });
+          writeFileSync9(probe, "ok");
           unlinkSync5(probe);
           ok(`session store writable (${cwd}/.agent/sessions)`);
         } catch (e) {
@@ -11625,7 +11787,7 @@ ${task}`;
       desc: "rescan skills/commands dirs and rebuild the system prompt (one cache miss) \u2014 picks up entries created mid-session",
       run: async () => {
         await refreshCatalogs().catch((e) => {
-          log21.debug("catalog refresh failed", e);
+          log22.debug("catalog refresh failed", e);
         });
         face.reprepare();
         err(green(`  \u2713 reloaded \u2014 ${skills.length} skill(s), ${cmds.length} command(s); system prompt rebuilds on next message
@@ -12082,7 +12244,7 @@ ${task}`;
           try {
             for (const def of (await loadAgents(fs2, d)).agents) if (!seen.has(def.name)) seen.set(def.name, { def, from: d });
           } catch (e) {
-            log21.debug(`loadAgents(${d}) failed`, e);
+            log22.debug(`loadAgents(${d}) failed`, e);
           }
         }
         if (!seen.size) {
@@ -12170,7 +12332,7 @@ ${task}`;
           }
           if (idx >= 0) {
             const old = mounted.splice(idx, 1)[0];
-            await old.client.close().catch((e) => log21.debug("mcp close failed", e));
+            await old.client.close().catch((e) => log22.debug("mcp close failed", e));
           }
           try {
             const m = await mountMcpServer(name, conf);
@@ -12198,7 +12360,7 @@ ${task}`;
           }
           const m = mounted.splice(idx, 1)[0];
           remountMcpTools();
-          await m.client.close().catch((e) => log21.debug("mcp close failed", e));
+          await m.client.close().catch((e) => log22.debug("mcp close failed", e));
           err(dim(`  removed "${name}"
 `));
           return;
@@ -12330,11 +12492,11 @@ ${task}`;
           return;
         }
         const md = exportMarkdown(session.meta, shown);
-        const name = a[0] ? extname(a[0]) ? a[0] : a[0] + ".md" : join13(".agent", "exports", `${session.meta.id}.md`);
+        const name = a[0] ? extname(a[0]) ? a[0] : a[0] + ".md" : join14(".agent", "exports", `${session.meta.id}.md`);
         const path = resolve3(cwd, name);
         try {
-          mkdirSync10(dirname4(path), { recursive: true });
-          writeFileSync8(path, md);
+          mkdirSync11(dirname4(path), { recursive: true });
+          writeFileSync9(path, md);
           err(green(`  \u2713 exported \u2192 ${path}
 `) + dim(`  ${shown.length} message(s) \xB7 ${md.length} chars
 `));
@@ -12396,9 +12558,9 @@ ${task}`;
   if (dx) banner(dim(`\u25D1 duplex \u2014 reflex: ${dx.options.reflexModel} \xB7 act: ${work.model}${dx.options.thinkModel !== false ? ` \xB7 think: ${dx.options.thinkModel}` : ""} (real work runs in background tasks, re-voiced when done)`));
   const listDir = (absDir) => {
     try {
-      return readdirSync4(join13(cwd, absDir.replace(/^\/+/, "")), { withFileTypes: true }).map((d) => ({ name: d.name, dir: d.isDirectory() }));
+      return readdirSync4(join14(cwd, absDir.replace(/^\/+/, "")), { withFileTypes: true }).map((d) => ({ name: d.name, dir: d.isDirectory() }));
     } catch (e) {
-      log21.debug("completion readdir failed", absDir, e);
+      log22.debug("completion readdir failed", absDir, e);
       return null;
     }
   };
@@ -12525,18 +12687,18 @@ ${out}
         return;
       }
       await refreshCatalogs().catch((e) => {
-        log21.debug("catalog refresh failed", e);
+        log22.debug("catalog refresh failed", e);
       });
-      const c = cmds.find((x) => x.name === name);
-      if (c) {
-        await runCommand(c, a.join(" "));
-        return;
-      }
       const sk = skills.find((x) => x.name === name);
       if (sk) {
         await runSkill(sk, a.join(" "));
         return;
       }
+      const c = cmds.find((x) => x.name === name);
+      if (c) {
+        await runCommand(c, a.join(" "));
+        return;
+      }
       const known = Object.keys(builtins).filter((k) => k !== "quit").map((k) => "/" + k);
       const custom = [...cmds.map((x) => x.name), ...skills.map((x) => x.name)].map((n) => "/" + n);
       err(red(`  unknown command /${name}
@@ -12925,7 +13087,7 @@ async function main() {
     }
   });
   if (args.task) {
-    const mounted = await mountMcp(cfg, new McpOAuth({ storePath: join13(cwd, ".agent", "mcp-auth.json") }));
+    const mounted = await mountMcp(cfg, new McpOAuth({ storePath: join14(cwd, ".agent", "mcp-auth.json") }));
     const agent = await makeAgent(args, ai, cfg, mcpAgentTools(mounted));
     const store = new SessionStore(cwd);
     const session = startSession(args, store, agent, cwd);