agent.libx.js 0.93.29 → 0.93.31

package/dist/cli.js

@@ -26,7 +26,10 @@ var init_redact = __esm({
 });
 
 // src/tools.structured.ts
-async function walkFiles(fs, dir, out = []) {
+function ckAbort(signal) {
+  if (signal?.aborted) throw new Error("aborted");
+}
+async function walkFiles(fs, dir, signal, out = []) {
   let entries;
   try {
     entries = await fs.readDir(dir);
@@ -34,8 +37,9 @@ async function walkFiles(fs, dir, out = []) {
     return out;
   }
   for (const name of entries.sort()) {
+    ckAbort(signal);
     const p = dir === "/" ? `/${name}` : `${dir}/${name}`;
-    if (await fs.isDirectory(p)) await walkFiles(fs, p, out);
+    if (await fs.isDirectory(p)) await walkFiles(fs, p, signal, out);
     else out.push(p);
   }
   return out;
@@ -92,13 +96,14 @@ function signaturesOf(content, cap = 40) {
   }
   return out;
 }
-async function repoIndex(fs, glob, mode = "code") {
+async function repoIndex(fs, glob, mode = "code", signal) {
   const scope = glob ? anchoredGlob(fs, String(glob)) : null;
   const filter = mode === "code" ? isCode : mode === "docs" ? isDoc : (p) => isCode(p) || isDoc(p);
-  const files = (await walkFiles(fs, fsCwd(fs))).filter((p) => scope ? scope.test(p) : filter(p));
+  const files = (await walkFiles(fs, fsCwd(fs), signal)).filter((p) => scope ? scope.test(p) : filter(p));
   const blocks = [];
   let shown = 0;
   for (const path of files) {
+    ckAbort(signal);
     let content;
     try {
       content = await fs.readFile(path);
@@ -218,7 +223,7 @@ var init_tools_structured = __esm({
         const include = pats.filter((p) => !p.startsWith("!")).map((p) => anchoredGlob(ctx.fs, p));
         const exclude = pats.filter((p) => p.startsWith("!")).map((p) => anchoredGlob(ctx.fs, p.slice(1)));
         const includes = include.length ? include : [anchoredGlob(ctx.fs, "**")];
-        const hits = (await walkFiles(ctx.fs, fsCwd(ctx.fs))).filter(
+        const hits = (await walkFiles(ctx.fs, fsCwd(ctx.fs), ctx.signal)).filter(
           (p) => includes.some((re) => re.test(p)) && !exclude.some((re) => re.test(p))
         );
         return hits.length ? hits.join("\n") : "(no matches)";
@@ -245,11 +250,12 @@ var init_tools_structured = __esm({
           throw new Error(`invalid regex: ${String(e)}`);
         }
         const scope = glob ? anchoredGlob(ctx.fs, String(glob)) : null;
-        const files = (await walkFiles(ctx.fs, fsCwd(ctx.fs))).filter((p) => !scope || scope.test(p));
+        const files = (await walkFiles(ctx.fs, fsCwd(ctx.fs), ctx.signal)).filter((p) => !scope || scope.test(p));
         const ctxN = Math.max(0, Number(context ?? 0));
         const out = [];
         const matched = [];
         for (const path of files) {
+          ckAbort(ctx.signal);
           let content;
           try {
             content = await ctx.fs.readFile(path);
@@ -285,7 +291,7 @@ var init_tools_structured = __esm({
           scope: { type: "string", enum: ["code", "docs", "all"], description: 'what to map: "code" (default), "docs", or "all"' }
         }
       },
-      run: ({ glob, scope }, ctx) => repoIndex(ctx.fs, glob, scope || "code")
+      run: ({ glob, scope }, ctx) => repoIndex(ctx.fs, glob, scope || "code", ctx.signal)
     };
     writeTool = {
       name: "Write",
@@ -1671,7 +1677,7 @@ close access f`;
 
 // cli/cli.ts
 import { join as join9, resolve as resolve3, basename as basename2, extname, dirname as dirname4 } from "path";
-import { AIClient, listModels, listProviders, getProviderFromModel, getModelInfo, resolveModel, isModelSupported } from "ai.libx.js";
+import { AIClient, listModels, listProviders, getProviderFromModel, getModelInfo, resolveModel, isModelSupported, disposeCursorSessions } from "ai.libx.js";
 
 // src/llm.ts
 function contentText(content) {
@@ -2002,9 +2008,9 @@ async function loadCommands(fs, dir, opts = {}) {
       properties: { name: { type: "string" }, args: { type: "string", description: "arguments to fill the template" } }
     },
     async run({ name, args }, ctx) {
-      const slug = String(name ?? "").replace(/^\//, "");
-      const c = commands.find((x) => x.name === slug);
-      if (!c) return `Error: no command named '${slug}'. Available: ${commands.map((x) => x.name).join(", ")}`;
+      const slug2 = String(name ?? "").replace(/^\//, "");
+      const c = commands.find((x) => x.name === slug2);
+      if (!c) return `Error: no command named '${slug2}'. Available: ${commands.map((x) => x.name).join(", ")}`;
       return expandCommand(ctx.fs, c, String(args ?? ""));
     }
   };
@@ -2039,9 +2045,9 @@ async function loadMemory(fs, dir, opts = {}) {
     const lines = md.split("\n");
     if (!header) header = lines.filter((l) => !/^\s*-\s*\[.+\]\(.+\.md\)/.test(l)).join("\n").trim();
     for (const l of lines.filter((l2) => /^\s*-\s*\[.+\]\(.+\.md\)/.test(l2))) {
-      const slug = l.match(/\]\(([^)]+)\.md\)/)?.[1];
-      if (slug && !seenSlugs.has(slug)) {
-        seenSlugs.add(slug);
+      const slug2 = l.match(/\]\(([^)]+)\.md\)/)?.[1];
+      if (slug2 && !seenSlugs.has(slug2)) {
+        seenSlugs.add(slug2);
         allPointers.push(l);
       }
     }
@@ -2057,20 +2063,20 @@ function slugify(s, fallback = "note") {
   const base = String(s ?? "").trim().toLowerCase().replace(/\.md$/i, "").replace(/[^\w\s-]/g, "").replace(/[\s_]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 48);
   return base || fallback;
 }
-async function writeFact(fs, dir, slug, body, opts) {
+async function writeFact(fs, dir, slug2, body, opts) {
   await mkdirp(fs, dir);
   const content = opts?.type ? `---
 type: ${opts.type}
 ---
 
 ${body}` : body;
-  await fs.writeFile(`${dir}/${slug}.md`, content.endsWith("\n") ? content : content + "\n");
+  await fs.writeFile(`${dir}/${slug2}.md`, content.endsWith("\n") ? content : content + "\n");
   const indexPath = `${dir}/MEMORY.md`;
   const idx = await fs.exists(indexPath) ? await fs.readFile(indexPath) : "# Memory Index\n";
   const summary = opts?.description || body.split("\n")[0].slice(0, 80);
-  const line = `- [${slug}](${slug}.md) \u2014 ${summary}`;
+  const line = `- [${slug2}](${slug2}.md) \u2014 ${summary}`;
   const lines = idx.split("\n");
-  const at = lines.findIndex((l) => l.includes(`(${slug}.md)`));
+  const at = lines.findIndex((l) => l.includes(`(${slug2}.md)`));
   if (at >= 0) {
     if (lines[at] !== line) {
       lines[at] = line;
@@ -2121,8 +2127,8 @@ async function listSlugs(fs, dir, prefix = "") {
   }
   return out;
 }
-async function loadFact(fs, dir, slug) {
-  const path = `${dir}/${slug}.md`;
+async function loadFact(fs, dir, slug2) {
+  const path = `${dir}/${slug2}.md`;
   try {
     const raw = await fs.readFile(path);
     const { body } = splitFrontmatter(raw);
@@ -2131,9 +2137,9 @@ async function loadFact(fs, dir, slug) {
     return null;
   }
 }
-async function loadFactMulti(fs, dirs, slug) {
+async function loadFactMulti(fs, dirs, slug2) {
   for (const d of dirs) {
-    const r = await loadFact(fs, d, slug);
+    const r = await loadFact(fs, d, slug2);
     if (r != null) return r;
   }
   return null;
@@ -2159,9 +2165,9 @@ function recallTool(fs, dirs) {
         pattern: { type: "string", description: 'glob pattern to match against slugs (e.g. "auth*", "*database*")' }
       }
     },
-    async run({ slug, slugs, pattern }, ctx) {
+    async run({ slug: slug2, slugs, pattern }, ctx) {
       let targets = [];
-      if (slug) targets = [cleanSlug(slug)];
+      if (slug2) targets = [cleanSlug(slug2)];
       else if (Array.isArray(slugs)) targets = slugs.map(cleanSlug).filter(Boolean);
       else if (pattern) {
         const escaped = String(pattern).replace(/[.+^${}()|[\]\\]/g, "\\$&");
@@ -2212,19 +2218,19 @@ function memorySearchTool(fs, dirs) {
         matcher = (l) => l.toLowerCase().includes(lower);
       }
       const loaded = [];
-      for (const slug of slugs) {
-        const body = await loadFactMulti(fs, dirs, slug);
-        if (body) loaded.push({ slug, body });
+      for (const slug2 of slugs) {
+        const body = await loadFactMulti(fs, dirs, slug2);
+        if (body) loaded.push({ slug: slug2, body });
       }
       const idf = idfWeights(loaded.map((l) => l.body));
       const qTokens = tokenize(q2);
       const hits = [];
-      for (const { slug, body } of loaded) {
+      for (const { slug: slug2, body } of loaded) {
         const lines = body.split("\n");
         const matchLine = lines.find(matcher);
         if (!matchLine && !relevanceScore(body, qTokens, idf)) continue;
         const snippet = matchLine?.trim().slice(0, 120) || lines.find((l) => l.trim())?.trim().slice(0, 120) || "";
-        hits.push({ slug, snippet, score: relevanceScore(body, qTokens, idf) });
+        hits.push({ slug: slug2, snippet, score: relevanceScore(body, qTokens, idf) });
       }
       if (!hits.length) return "(no matches)";
       hits.sort((a, b) => b.score - a.score);
@@ -2248,11 +2254,11 @@ function rememberTool(fs, dir, memOpts = {}) {
         description: { type: "string", description: "one-line summary for the memory index (\u226480 chars)" }
       }
     },
-    async run({ fact, slug, type, description }, ctx) {
+    async run({ fact, slug: slug2, type, description }, ctx) {
       const body = String(fact ?? "").trim();
       if (!body) return `Error: nothing to remember (empty fact).`;
       if (++writes > maxWrites) return `Rate limit: too many memories this session (${maxWrites}). Only persist genuinely durable facts.`;
-      const name = slugify(slug || body.split("\n")[0]);
+      const name = slugify(slug2 || body.split("\n")[0]);
       const isGlobal = (type === "user" || type === "feedback") && memOpts.userDir;
       const targetDir = isGlobal ? memOpts.userDir : dir;
       await writeFact(fs, targetDir, name, body, { type, description });
@@ -2686,6 +2692,14 @@ var AgentOptions = class {
   /** Token-aware backstop (~4 chars/token estimate). After note-taking, drop oldest messages from the
    *  sent context until the estimate is under this ceiling (pairing-safe). 0 = off. */
   maxContextTokens = 0;
+  /** Pagination ceiling for a SINGLE tool result (bytes). A result over this is cropped to page 1 with
+   *  a marker telling the model it was cropped (refine the query, or page further). Guards against one
+   *  Grep/Read/MCP call blowing the whole context window. 0 = off. Default 60k (~15k tokens). */
+  maxToolResultBytes = 6e4;
+  /** Hook to handle an oversized tool result instead of the default lossy crop: receives the FULL output
+   *  and returns the (cropped) string to put in context — e.g. spill to scratch and return a recoverable,
+   *  paginated stub. Called only when a result exceeds `maxToolResultBytes`. */
+  capToolResult;
   /** VFS dir(s) of skills (`<dir>/<id>/SKILL.md`). If set: inject a catalog + add the `Skill` tool. Multiple dirs are merged (first wins on name collisions). */
   skillsDir;
   /** VFS dir(s) of slash-command templates (`<dir>/<name>.md`). If set: inject a catalog + add the `SlashCommand` tool. Multiple dirs are merged (first wins). */
@@ -3008,6 +3022,7 @@ var Agent = class _Agent {
       toolCallsTotal += toolCalls.length;
       if (o.maxToolCalls && toolCallsTotal > o.maxToolCalls) return kill("max_tool_calls");
       for (const tc of toolCalls) {
+        if (o.signal?.aborted) return kill("aborted");
         const raw = await this.dispatch(tc);
         let content;
         if (typeof raw === "string") {
@@ -3100,6 +3115,11 @@ var Agent = class _Agent {
       this.ctx.emit = void 0;
     }
     if (!threw) result = await this.maybeAutoTest(tc.function.name, result);
+    const cap = this.options.maxToolResultBytes ?? 0;
+    if (!threw && cap > 0 && result.length > cap) {
+      const info = { tool: tc.function.name, args };
+      result = this.options.capToolResult ? await this.options.capToolResult(result, info) : cropResult(result, cap);
+    }
     await hooks?.postToolUse?.(call, result, meta);
     this.options.host?.notify?.({ kind: "tool_result", id: tc.id ?? "", output: result, isError: threw });
     if (images?.length) {
@@ -3153,6 +3173,15 @@ function estimateTokens(m) {
   for (const x of m) chars += contentText(x.content).length + (x.tool_calls ? JSON.stringify(x.tool_calls).length : 0);
   return Math.ceil(chars / 4);
 }
+function cropResult(result, cap) {
+  const head = result.slice(0, cap);
+  const nl = head.lastIndexOf("\n");
+  const page = nl > cap * 0.5 ? head.slice(0, nl) : head;
+  const omitted = result.length - page.length;
+  return `${page}
+
+[output cropped \u2014 showing ${page.length} of ${result.length} bytes; ${omitted} omitted. This is page 1. Refine your query/command to narrow it, or call the tool again with a tighter scope to see more.]`;
+}
 function stubOldToolResults(messages, keep) {
   const meta = /* @__PURE__ */ new Map();
   for (const msg of messages)
@@ -3473,6 +3502,127 @@ init_tools();
 init_tools_structured();
 init_logging();
 var log4 = forComponent("scratch");
+var SCRATCH_DIR = "/scratch";
+function shortArgs(args) {
+  try {
+    const s = JSON.stringify(args ?? {});
+    return s.length > 50 ? s.slice(0, 47) + "\u2026" : s;
+  } catch {
+    return "";
+  }
+}
+var slug = (s) => s.replace(/[^a-z0-9]+/gi, "-").replace(/^-+|-+$/g, "").toLowerCase().slice(0, 32) || "out";
+var Scratch = class {
+  constructor(fs, options = {}) {
+    this.fs = fs;
+    this.options = { threshold: 1500, dir: SCRATCH_DIR, previewChars: 320, ...options };
+  }
+  fs;
+  options;
+  seq = 0;
+  dirReady;
+  /** Number of captures so far. */
+  get count() {
+    return this.seq;
+  }
+  /** Wrap a tool: oversized STRING results spill to a scratch file; everything else passes through. */
+  capture(tool) {
+    const { threshold, dir, previewChars } = this.options;
+    return {
+      ...tool,
+      run: async (args, ctx) => {
+        const raw = await tool.run(args, ctx);
+        if (typeof raw !== "string" || raw.length <= threshold) return raw;
+        const id = "a" + ++this.seq;
+        const path = `${dir}/${id}-${slug(tool.name)}.txt`;
+        const header = `# ${tool.name}(${shortArgs(args)}) \u2014 ${raw.length} bytes
+`;
+        try {
+          await (this.dirReady ??= mkdirp(this.fs, dir));
+          await this.fs.writeFile(path, header + raw);
+        } catch (e) {
+          log4.debug("scratch write failed; returning raw", e);
+          return raw;
+        }
+        const preview = raw.slice(0, previewChars).replace(/\s+/g, " ").trim();
+        return `[scratch ${path} \xB7 ${tool.name} \xB7 ${raw.length} bytes \u2014 full output saved out of context to keep it clean]
+preview: ${preview}\u2026
+To pull a specific detail, Grep/Read ${path}, or call Ask({ question: "\u2026", over: "${path}" }). Do NOT guess at what the preview cuts off.`;
+      }
+    };
+  }
+  /** Wrap many tools at once. */
+  captureAll(tools) {
+    return tools.map((t) => this.capture(t));
+  }
+  /**
+   * Spill an oversized tool result to a scratch file and return PAGE 1 + a recoverable, paginated stub.
+   * Drop-in for `Agent.capToolResult`: the agent sees usable content immediately and knows how to get
+   * the rest (refine the query, Read the file in pages with offset/limit, or Ask to extract specifics).
+   * Lossless — unlike a plain crop, the full output stays available on the scratch FS.
+   */
+  async spill(full, info, pageBytes = 8e3) {
+    const { dir } = this.options;
+    const id = "a" + ++this.seq;
+    const path = `${dir}/${id}-${slug(info.tool)}.txt`;
+    const header = `# ${info.tool}(${shortArgs(info.args)}) \u2014 ${full.length} bytes
+`;
+    try {
+      await (this.dirReady ??= mkdirp(this.fs, dir));
+      await this.fs.writeFile(path, header + full);
+    } catch (e) {
+      log4.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]`;
+    }
+    const head = full.slice(0, pageBytes);
+    const nl = head.lastIndexOf("\n");
+    const page = nl > pageBytes * 0.5 ? head.slice(0, nl) : head;
+    return `${page}
+
+[output cropped \u2014 page 1 (${page.length} of ${full.length} bytes). Full output saved to ${path}. To see more: refine your query/command to narrow it, or Read ${path} with offset/limit to page through it, or Ask({ question: "\u2026", over: "${path}" }) to extract specifics.]`;
+  }
+};
+var ASK_PROMPT = "You are a retrieval-extraction step with Read, Grep and Glob over a scratch filesystem holding raw outputs from earlier tools. Find the information that answers the question and return it concisely, quoting values/facts verbatim. Do NOT add analysis or anything not grounded in the files. If the answer is not present, say so plainly.";
+function makeAskTool(o) {
+  const dir = o.dir ?? SCRATCH_DIR;
+  return {
+    name: "Ask",
+    description: "Answer a question by peeking into the scratch files \u2014 large earlier outputs (web search, big reads, subagent reports) kept out of your context. Pass `over` with a scratch path for a targeted lookup, or omit it to search the scratch dir. Returns only the extracted answer; the full data never enters your context.",
+    parameters: {
+      type: "object",
+      required: ["question"],
+      properties: {
+        question: { type: "string", description: "what you need from the scratch files" },
+        over: { type: "string", description: 'scratch path to read, e.g. "/scratch/a3-websearch.txt"; omit to search' }
+      }
+    },
+    async run({ question, over }) {
+      const q2 = String(question ?? "").trim();
+      if (!q2) return "Error: empty question";
+      const child = new Agent({
+        ai: o.ai,
+        model: o.model,
+        fs: o.fs,
+        tools: toolsByName(["Read", "Grep", "Glob"]),
+        maxSteps: o.maxSteps ?? 6,
+        systemPrompt: ASK_PROMPT
+      });
+      const hint = over ? `Start by reading: ${over}.` : `Grep/Glob ${dir} to find the relevant file(s) first.`;
+      try {
+        const res = await child.run(`${hint}
+
+Question: ${q2}`);
+        const answer = (res.text ?? "").trim();
+        return answer || "(no answer found in scratch)";
+      } catch (e) {
+        log4.debug("Ask peek failed", e);
+        return `Error querying scratch: ${e?.message ?? e}`;
+      }
+    }
+  };
+}
 
 // src/lessons.ts
 init_logging();
@@ -3531,15 +3681,15 @@ If the run was fine or the issue was purely task-specific (not generalizable), r
   const m = text.match(/LESSON:\s*(.+)/i);
   const lesson = m?.[1]?.trim().slice(0, 200) ?? "";
   if (!lesson || /^none\b/i.test(lesson)) return null;
-  const slug = ("lesson-" + slugify(lesson)).slice(0, 56);
+  const slug2 = ("lesson-" + slugify(lesson)).slice(0, 56);
   try {
-    await writeFact(o.fs, o.dir, slug, lesson);
+    await writeFact(o.fs, o.dir, slug2, lesson);
   } catch (e) {
     log6.warn(`could not persist lesson: ${e?.message ?? e}`);
     return null;
   }
-  log6.debug(`reflection persisted ${slug}`);
-  return slug;
+  log6.debug(`reflection persisted ${slug2}`);
+  return slug2;
 }
 function digestRun(messages, maxChars) {
   const lines = [];
@@ -3566,10 +3716,18 @@ var DuplexAgentOptions = class {
   ai;
   /** The WORKER's filesystem (act + think). If omitted the worker keeps Agent's jailed-disk-at-cwd default. */
   fs;
-  reflexModel = "groq/openai/gpt-oss-20b";
+  // The reflex IS the voice. 120b (not 20b) for channel discipline + instruction-following: the 20b
+  // mislabels gpt-oss harmony channels under load, leaking raw analysis into the spoken `final` channel
+  // (and misfiring Hold). 120b is the same price tier (~$0.15/$0.60) — the quality/cost trade is free.
+  reflexModel = "groq/openai/gpt-oss-120b";
   actModel = "anthropic/claude-sonnet-4-6";
   /** Premium reasoning model. Set to `false` to disable the Think tier entirely. */
   thinkModel = "anthropic/claude-opus-4-8";
+  /** Per-worker providerOptions, derived from the worker's actual model at spawn time (IoC — keeps duplex
+   *  provider-agnostic). Workers override the reflex/main model, so provider-specific options (e.g. cursor's
+   *  cwd/cursorSession) must be recomputed for the worker's model, never inherited from the main template —
+   *  leaking cursor options to an anthropic worker is a hard 400. Returns undefined → no providerOptions. */
+  providerOptionsFor;
   /** Escape hatches merged over the derived per-agent options. */
   reflexOptions;
   actOptions;
@@ -3648,7 +3806,12 @@ var DuplexAgent = class {
     const canSearch = workerToolNames.some((n) => /WebSearch/i.test(n));
     const canFetch = workerToolNames.some((n) => /WebFetch/i.test(n));
     const workerWeb = canSearch ? `, and it CAN search the web and read web pages \u2014 so when the user gives you something specific to look up ("search for X", "find me\u2026", "what's the latest on\u2026"), route it to Act. But a bare capability QUESTION like "can you search the web?" just gets a short spoken "yes, I can" \u2014 do NOT dispatch and NEVER invent a query the user did not give you` : canFetch ? ", and it can fetch a specific web page URL (but cannot search the web)" : "";
-    const prompt = VOICE_SYSTEM_PROMPT.replace("{{MEMORY_SLOT}}", memSlot).replace("{{THINK_SLOT}}", thinkSlot).replace("{{WORKER_WEB}}", workerWeb) + (o.voiceStyle === "conversational" ? "\n" + VOICE_STYLE_CONVERSATIONAL : "") + `
+    const mcpNames = [
+      ...Object.keys(o.actOptions?.providerOptions?.mcpServers ?? {}),
+      ...new Set(workerToolNames.filter((n) => n.startsWith("mcp__")).map((n) => n.slice(5).split("__")[0]))
+    ];
+    const workerMcp = mcpNames.length ? `, and it can use these MCP servers: ${[...new Set(mcpNames)].join(", ")}` + (mcpNames.some((n) => /browser/i.test(n)) ? ' \u2014 including driving a REAL browser (open tabs, navigate, click, screenshot), so answer "yes" if asked whether you can control/drive a browser and route an actual browse to Act' : "") : "";
+    const prompt = VOICE_SYSTEM_PROMPT.replace("{{MEMORY_SLOT}}", memSlot).replace("{{THINK_SLOT}}", thinkSlot).replace("{{WORKER_WEB}}", workerWeb + workerMcp) + (o.voiceStyle === "conversational" ? "\n" + VOICE_STYLE_CONVERSATIONAL : "") + `
 Today's date: ${(/* @__PURE__ */ new Date()).toDateString()}.`;
     const tools = [
       ...o.reflexOptions?.tools ?? [],
@@ -3832,6 +3995,9 @@ ${recent}` : brief) + verify;
       model: tierModel,
       ...tier === "think" ? { reasoning: tierOpts?.reasoning ?? "high" } : {},
       ...tierOpts,
+      // Recompute providerOptions for THIS worker's model (after tierOpts so it wins over any inherited
+      // main-template value) — prevents cursor-only cwd/cursorSession leaking onto an anthropic worker.
+      providerOptions: o.providerOptionsFor?.(tierModel),
       ...workerHost ? { host: workerHost } : {},
       ...hooks ? { hooks } : {},
       signal: controller.signal
@@ -4080,8 +4246,10 @@ Another agent just implemented the above. Independently check the CURRENT state
             case "capabilities": {
               const actTools = this.options.actOptions?.tools ?? [];
               const names = actTools.map((t) => t.name);
+              const mcpServers = Object.keys(this.options.actOptions?.providerOptions?.mcpServers ?? {});
+              const mcpNote = mcpServers.length ? ` Plus MCP servers your worker can use: ${mcpServers.join(", ")} (e.g. browser-bridge \u2192 drive a real browser: open tabs, navigate, click, screenshot).` : "";
               if (!names.length)
-                return "Your worker uses Act's default local toolset (reading/editing files, running shell commands). No extra tools (e.g. web/internet) are configured; if a request is not a basic file or shell operation, assume you can't do it and say so.";
+                return "Your worker uses Act's default local toolset (reading/editing files, running shell commands). No extra tools (e.g. web/internet) are configured; if a request is not a basic file or shell operation, assume you can't do it and say so." + mcpNote;
               const hasFetch = names.some((n) => /WebFetch/i.test(n));
               const hasBrowser = names.some((n) => /browser.*(navigate|click|page|type)/i.test(n));
               const hasSearch = names.some((n) => /(^|_)WebSearch$|search/i.test(n) && !/WebFetch|browser/i.test(n));
@@ -4090,7 +4258,7 @@ Another agent just implemented the above. Independently check the CURRENT state
               if (hasBrowser) notes.push("The browser tools drive a real browser: you CAN open a site and, if needed, navigate to a search engine and search there \u2014 but it is manual and takes a moment, not an instant lookup.");
               else if (!hasSearch && hasFetch) notes.push('You have no general web-search tool, so for an instant "search the web" you can only fetch a URL they provide.');
               const webNote = notes.length ? " NOTE: " + notes.join(" ") : "";
-              return `Tools your background worker (Act) can actually use: ${names.join(", ")}. Read each name literally and match the request to a SPECIFIC tool; if none fits, you do NOT have that ability \u2014 say so honestly.` + webNote;
+              return `Tools your background worker (Act) can actually use: ${names.join(", ")}. Read each name literally and match the request to a SPECIFIC tool; if none fits, you do NOT have that ability \u2014 say so honestly.` + webNote + mcpNote;
             }
             case "time":
               return (/* @__PURE__ */ new Date()).toString();
@@ -5475,6 +5643,10 @@ function toCursorMcp(servers) {
   }
   return Object.keys(out).length ? { mcpServers: out } : void 0;
 }
+function cursorProviderOptions(model, cwd, mcpServers) {
+  if (!(model ?? "").startsWith("cursor/")) return void 0;
+  return { cwd, ...toCursorMcp(mcpServers) ?? {}, ...process.env.CURSOR_WARM === "0" ? {} : { cursorSession: randomUUID() } };
+}
 async function buildAgent(o) {
   if (typeof o.sandbox !== "boolean")
     throw new Error(
@@ -5566,6 +5738,8 @@ Reference files in them by their mount path (the left side).`;
     const jobs = new ShellJobRegistry({ cwd, killOnExit: true });
     realShell = [makeRealShellTool({ cwd, registry: jobs }), ...makeShellJobTools(jobs)];
   }
+  const scratchDir = o.scratch ? o.scratchDir ?? `${cwd}/.agent/scratch` : void 0;
+  const scratch = scratchDir ? new Scratch(fs, { dir: scratchDir }) : void 0;
   return new Agent({
     ai: o.ai,
     fs,
@@ -5576,7 +5750,10 @@ Reference files in them by their mount path (the left side).`;
     // would corrupt those calls.
     // Warm cursor session (default on; CURSOR_WARM=0 to disable): one long-lived agent reused across
     // turns, amortising the ~2s Agent.create + h2 handshake. Keyed per agentx launch.
-    ...isCursor ? { providerOptions: { cwd, ...toCursorMcp(o.mcpServers) ?? {}, ...process.env.CURSOR_WARM === "0" ? {} : { cursorSession: randomUUID() } } } : {},
+    ...(() => {
+      const po = cursorProviderOptions(o.model, cwd, o.mcpServers);
+      return po ? { providerOptions: po } : {};
+    })(),
     ...(() => {
       const now5 = /* @__PURE__ */ new Date();
       const platformNames = { darwin: "macOS", linux: "Linux", win32: "Windows" };
@@ -5590,7 +5767,13 @@ SANDBOX: you operate on an in-memory COPY of this directory \u2014 the real disk
 The filesystem root '/' is the real machine root \u2014 you have full filesystem access, like a normal shell. Use paths relative to the working directory, or absolute paths. Secret files (.env, .ssh, keys, .git) are hidden for safety.`;
       const shellNote = useRealShell && !virtual ? "The `Shell` tool runs /bin/sh \u2014 you can run any installed binary (git, bun, node, curl, etc). Use `Shell` for all shell commands." : void 0;
       const toneNote = "Be concise. Do not use emojis unless the user asks. Do not explain what you are about to do \u2014 just do it.";
-      const extra = [o.appendSystemPrompt, envNote, cwdNote, shellNote, toneNote, mountNote].filter(Boolean).join("\n\n");
+      const mcpNote = (() => {
+        const names = new Set(Object.keys(o.mcpServers ?? {}));
+        for (const t of o.extraTools ?? []) if (t.name.startsWith("mcp__")) names.add(t.name.slice(5).split("__")[0]);
+        const list = [...names];
+        return `You are agentx (the agent.libx.js runtime) \u2014 NOT Claude Code or Claude Desktop, which are separate agents with their own config. Your MCP servers are configured in .agent/settings.json or .agent/config.* (this project's .agent/ or ~/.agent/), and their tools are already in your tool list as \`mcp__<server>__<tool>\`.${list.length ? ` Configured MCP servers: ${list.join(", ")}.` : " No MCP servers are currently configured."} When asked which MCPs/tools you have, answer from your own tool list \u2014 never read Claude Code/Desktop config (e.g. ~/.claude.json, claude_desktop_config.json) to answer; those belong to a different agent.`;
+      })();
+      const extra = [o.appendSystemPrompt, envNote, cwdNote, shellNote, toneNote, mountNote, mcpNote].filter(Boolean).join("\n\n");
       const basePrompt = (() => {
         let p = new AgentOptions().systemPrompt;
         if (!virtual) p = p.replace("operating on a virtual filesystem", "operating on the host filesystem");
@@ -5601,9 +5784,11 @@ The filesystem root '/' is the real machine root \u2014 you have full filesystem
     })(),
     tools: (() => {
       const base = toolsByName([...o.tools ?? DEFAULT_TOOLS, ...autoWebTools()]);
-      if (!realShell.length) return [...base, ...o.extraTools ?? []];
+      const tail = [...o.extraTools ?? []];
+      if (scratch) tail.push(makeAskTool({ fs, ai: o.ai, model: o.scratchAskModel ?? o.model ?? "anthropic/claude-sonnet-4-6", dir: scratchDir }));
+      if (!realShell.length) return [...base, ...tail];
       const filtered = base.filter((t) => t.name !== "bash");
-      return [...filtered, ...realShell, ...o.extraTools ?? []];
+      return [...filtered, ...realShell, ...tail];
     })(),
     maxSteps: o.maxSteps ?? 30,
     ...o.reasoning != null ? { reasoning: o.reasoning } : {},
@@ -5613,6 +5798,9 @@ The filesystem root '/' is the real machine root \u2014 you have full filesystem
     planMode: o.planMode ?? false,
     permissions: o.permissions,
     subagents: o.subagents ?? false,
+    // When scratch is on, an oversized tool result spills to a scratch file + recoverable paginated stub
+    // (lossless). Without scratch, the Agent's default crop (lossy) still guards the context window.
+    ...scratch ? { capToolResult: (full, info) => scratch.spill(full, info) } : {},
     backgroundJobs: o.backgroundJobs ?? virtual,
     // default ON in virtual modes (no real shell there); disk uses ShellJobRegistry
     skillsDir: dots("skills"),
@@ -7837,6 +8025,7 @@ function parseArgs(argv) {
     else if (x === "--ask") a.ask = true;
     else if (x === "--yes" || x === "-y") a.yes = true;
     else if (x === "--vfs" || x === "--sandbox") a.vfs = true;
+    else if (x === "--scratch") a.scratch = true;
     else if (x === "--boddb") a.boddb = val(++i, x);
     else if (x === "--seed") a.seed = true;
     else if (x === "--shell") a.shell = true;
@@ -7890,6 +8079,7 @@ Flags:
   --no-stream          disable token streaming
                        (default: disk mode \u2014 full real filesystem access, like Claude Code)
   --vfs, --sandbox     sandbox mode: work over an in-memory copy of cwd \u2014 real disk is NEVER modified
+  --scratch            spill big web outputs to scratch files (kept out of context; peek via Grep/Ask)
   --boddb <dir>        database-backed workspace: files live in a persistent bod-db store at <dir>,
                        surviving across runs \u2014 real disk is NEVER modified (DB-native; add --seed below)
   --seed               with --boddb: hydrate the store from cwd on the first run (empty DB) only
@@ -7907,7 +8097,7 @@ Flags:
                        impulsive reactions, human pacing (implies --duplex; aliases: --convo, --voice)
                        with SONIOX_API_KEY + CARTESIA_API_KEY(+VOICE_ID) set: real voice I/O \u2014 mic in,
                        spoken replies out (echo-cancelled; speak over it to interrupt)
-  --voice-model <id>   with --duplex: the fast voice model (default groq/openai/gpt-oss-20b)
+  --voice-model <id>   with --duplex: the fast voice model (default groq/openai/gpt-oss-120b)
   --think-model <id>   with --duplex: the premium deep-reasoning model (default anthropic/claude-opus-4-6)
   --no-think           with --duplex: disable the Think tier (Act handles everything)
   --add-dir <path>     mount another directory into the workspace (repeatable; disk mode only)
@@ -7939,7 +8129,7 @@ Project instructions: ./AGENTS.md or ./CLAUDE.md are auto-loaded (scaffold with
 Auto-loaded from ./.agent/: commands/, skills/, memory/, agents/.
 
 REPL shortcuts: !<cmd> runs a shell command inline \xB7 #<note> saves a memory \xB7 @path inlines a file
-REPL slash commands: /help /version /tools /permissions /status /cost /context /cwd /model /reasoning /config /rename /compact /rewind /undo /clear /sessions /resume /commands /skills /mcp /init /export /paste /goal /exit (duplex: /act /think /voice-model /think-model)
+REPL slash commands: /help /version /tools /permissions /status /cost /context /cwd /model /reasoning /config /rename /compact /rewind /undo /clear /sessions /resume /commands /skills /mcp /init /export /paste /goal /exit (duplex: /act /think /voice /voice-model /think-model)
 REPL completion: type / (commands+skills) or @ (files) for a LIVE menu \u2014 \u2191/\u2193 select, \u23CE/Tab accept, Esc dismiss.
 REPL multi-line: Option/Alt+Enter inserts a newline, or end a line with \\ to continue. Esc cancels a running turn / clears the input line; double-Esc jumps back to edit a previous message.
 REPL shortcuts: Shift+Tab cycles permission posture (ask \u2192 accept-edits \u2192 plan) \xB7 Alt+T toggles reasoning \xB7 Alt+P switches model \xB7 Ctrl+O toggles verbose tool output \xB7 \u2192 or Tab accepts the dim history ghost-suggestion \xB7 Alt+S/Ctrl+S stash/unstash.
@@ -8356,6 +8546,7 @@ function optsFor(args, ai, cfg = {}, extraTools = []) {
     seed: args.seed,
     realShell: args.shell,
     // undefined → core.ts defaults (on for disk, off for sandbox/boddb)
+    scratch: args.scratch,
     appendSystemPrompt: args.appendSystemPrompt,
     addDirs: args.addDirs,
     stream: args.stream,
@@ -8676,6 +8867,7 @@ async function repl(args, ai, cfg, cwd) {
   const duplex = args.duplex;
   let dx;
   let voiceIO;
+  let toggleVoice;
   let editorRef;
   let repaintStash = () => {
   };
@@ -8719,7 +8911,7 @@ async function repl(args, ai, cfg, cwd) {
     return { decision: "deny" };
   };
   if (duplex) {
-    const { host: _host, stream: _stream, signal: _signal, ...wo } = agent.options;
+    const { host: _host, stream: _stream, signal: _signal, providerOptions: _po, ...wo } = agent.options;
     workerOptions = wo;
     if (workerOptions.permissions)
       workerOptions.permissions = new PermissionPolicy({ ...workerOptions.permissions.options, host: void 0, ask: duplexAsk });
@@ -8799,6 +8991,7 @@ async function repl(args, ai, cfg, cwd) {
       ...args.voiceModel ?? cfg.reflexModel ? { reflexModel: resolveModelOrNewest(args.voiceModel ?? cfg.reflexModel) } : {},
       actModel: agent.options.model,
       actOptions: workerOptions,
+      providerOptionsFor: (m) => cursorProviderOptions(m, cwd, cfg.mcpServers),
       ...(args.thinkModel ?? cfg.thinkModel) !== void 0 ? { thinkModel: (args.thinkModel ?? cfg.thinkModel) === false ? false : resolveModelOrNewest(String(args.thinkModel ?? cfg.thinkModel)) } : {},
       host,
       ...args.voice ? { voiceStyle: "conversational", progressUpdates: true, askRelay: true } : {},
@@ -8901,15 +9094,30 @@ async function repl(args, ai, cfg, cwd) {
     const img = grabClipboardImage(dir, String(Date.now()));
     return img ? { display: "Image", ref: "@" + img.path, path: img.path } : null;
   };
+  const forceQuit = (code = 130) => {
+    try {
+      voiceIO?.stop();
+    } catch {
+    }
+    try {
+      disposeCursorSessions();
+    } catch {
+    }
+    void closeMcp(mounted);
+    process.exit(code);
+  };
   process.on("SIGINT", () => {
     if (activeTurn) {
+      if (aborting) {
+        err(red("\n  \u23FB force-quit\n"));
+        forceQuit();
+        return;
+      }
       activeTurn.abort();
       voiceIO?.interrupt();
       return;
     }
-    voiceIO?.stop();
-    void closeMcp(mounted);
-    process.exit(130);
+    forceQuit();
   });
   installCancelGuards(mounted);
   const store = new SessionStore(cwd);
@@ -9267,6 +9475,15 @@ ${extra}` : body);
         err(dim(`  worker chrome: ${workerChrome} (use /workers full|minimal)
 `));
       }
+    }, voice: {
+      desc: "toggle live voice I/O on/off mid-session (needs SONIOX/CARTESIA keys + a TTY)",
+      run: async () => {
+        if (!toggleVoice) {
+          err(dim("  (voice needs --duplex on a TTY)\n"));
+          return;
+        }
+        await toggleVoice();
+      }
     }, "voice-model": {
       desc: "switch the reflex (voice) model \u2014 /voice-model <id>, or alone for a picker",
       run: async (a) => {
@@ -9492,7 +9709,7 @@ ${extra}` : body);
     commands: { desc: "pick a custom slash command to run (./.agent/commands)", run: () => pickAndRun("command") },
     skills: { desc: "pick a skill to run (./.agent/skills)", run: () => pickAndRun("skill") },
     mcp: {
-      desc: "manage MCP servers \u2014 /mcp [add <name> <cmd|url>] [login <name>] [remove <name>] [resources [name]]",
+      desc: "manage MCP servers \u2014 /mcp [add <name> <cmd|url>] [login <name>] [remove <name>] [tools [name]] [resources [name]]",
       run: async (a) => {
         const sub = a[0]?.toLowerCase();
         if (sub === "login") {
@@ -9568,6 +9785,22 @@ ${extra}` : body);
 `));
           return;
         }
+        if (sub === "tools") {
+          const filter = a[1];
+          const targets = filter ? mounted.filter((m) => m.name === filter) : mounted;
+          if (!targets.length) {
+            err(dim(`  (no ${filter ? `MCP server "${filter}"` : "MCP servers"} found)
+`));
+            return;
+          }
+          for (const m of targets) {
+            err(`  ${cyan(m.name)} ${dim(`(${m.tools.length} tools)`)}
+`);
+            for (const t of m.tools) err(dim(`     - ${t.name.replace(`mcp__${m.name}__`, "")}${t.description ? " \u2014 " + t.description.split("\n")[0] : ""}
+`));
+          }
+          return;
+        }
         if (sub === "resources") {
           const filter = a[1];
           const targets = filter ? mounted.filter((m) => m.name === filter) : mounted;
@@ -9602,16 +9835,16 @@ ${extra}` : body);
           }
           for (const m of mounted) {
             const ver = m.serverInfo?.name ? dim(` \xB7 ${m.serverInfo.name}${m.serverInfo.version ? " v" + m.serverInfo.version : ""}`) : "";
-            err(`  ${cyan(m.name)}${ver} ${dim(`(${m.tools.length} tools)`)}
+            err(`  ${green("\u2713")} ${cyan(m.name)}${ver} ${dim(`(${m.tools.length} tools)`)}
 `);
-            for (const t of m.tools) err(dim(`     - ${t.name.replace(`mcp__${m.name}__`, "")}${t.description ? " \u2014 " + t.description.split("\n")[0] : ""}
-`));
           }
+          err(dim("  /mcp tools [name] to list tools \xB7 /mcp resources [name] for resources\n"));
         };
         const items = [
           { label: "list", value: "list", desc: `show mounted servers (${mounted.length})` },
           { label: "add", value: "add", desc: "mount a new MCP server" },
           ...mounted.length ? [
+            { label: "tools", value: "tools", desc: "list a server's tools" },
             { label: "remove", value: "remove", desc: "unmount an MCP server" },
             { label: "resources", value: "resources", desc: "list server resources" }
           ] : []
@@ -9640,13 +9873,13 @@ ${extra}` : body);
           const rv = await selectMenu(process.stderr, { title: "remove server", items: mounted.map((m) => ({ label: m.name, value: m.name })) });
           if (!rv) return;
           a = ["remove", rv];
-        } else if (picked === "resources") {
+        } else if (picked === "tools" || picked === "resources") {
           if (mounted.length === 1) {
-            a = ["resources", mounted[0].name];
+            a = [picked, mounted[0].name];
           } else {
-            const rv = await selectMenu(process.stderr, { title: "server resources", items: [{ label: "(all)", value: "" }, ...mounted.map((m) => ({ label: m.name, value: m.name }))] });
+            const rv = await selectMenu(process.stderr, { title: `server ${picked}`, items: [{ label: "(all)", value: "" }, ...mounted.map((m) => ({ label: m.name, value: m.name }))] });
             if (rv === null) return;
-            a = rv ? ["resources", rv] : ["resources"];
+            a = rv ? [picked, rv] : [picked];
           }
         }
         return builtins.mcp.run(a);
@@ -9786,7 +10019,13 @@ ${extra}` : body);
           aborting = true;
           activeTurn.abort();
           voiceIO?.interrupt();
-          err(yellow("\n  \u238B cancelling\u2026\n"));
+          err(yellow("\n  \u238B cancelling\u2026") + dim(" (Ctrl-C again to force-quit)\n"));
+          setTimeout(() => {
+            if (activeTurn) err(red("  \u26A0 still cancelling \u2014 press Ctrl-C to force-quit\n"));
+          }, 4e3).unref?.();
+        } else if (key?.ctrl && k === "c") {
+          err(red("\n  \u23FB force-quit\n"));
+          forceQuit();
         } else if (k === "escape" && !pendingRewind) {
           pendingRewind = true;
           err(dim("  \u238B\u238B jumping back to edit\u2026\n"));
@@ -9889,67 +10128,91 @@ ${extra}` : body);
   };
   let voicePartial = "";
   let partialRedraw = null;
-  if (args.voice && duplex && process.stdin.isTTY) {
+  const startVoice = async (greet) => {
+    if (voiceIO) return true;
+    if (!duplex || !process.stdin.isTTY) {
+      err(dim("  (voice needs --duplex on a TTY)\n"));
+      return false;
+    }
     if (!VoiceIO.available()) {
       err(dim("  (voice I/O off \u2014 set SONIOX_API_KEY, CARTESIA_API_KEY, CARTESIA_VOICE_ID to talk)\n"));
-    } else {
-      voiceIO = new VoiceIO({
-        // No ack phrase by default: a fixed "Mm-hm," every turn reads robotic, Haiku's TTFT doesn't
-        // need masking (~0.7-1.2s full turns), and the conversational register already opens with a
-        // natural reaction. The mechanism (+ echo-leak guard) stays for slower voice models.
-        onState: () => editorRef?.redrawNow(),
-        // Throttled: each redraw clears the screen below the prompt — a partial-per-token storm
-        // (fast speech, or echo bleed if AEC degrades) would continuously erase streamed text.
-        onPartial: (text) => {
-          if (text === voicePartial) return;
-          voicePartial = text;
-          if (!partialRedraw) partialRedraw = setTimeout(() => {
-            partialRedraw = null;
-            editorRef?.redrawNow();
-          }, 250);
-        },
-        onBargeIn: (phase) => {
-          activeTurn?.abort();
-          if (phase === "speaking") err(yellow("\n  \u270B interrupted\n"));
-        },
-        onUtterance: (text) => {
-          voicePartial = "";
-          if (!text.trim()) return;
-          const cut = voiceIO.takeInterruptedReply();
-          const note = cut && cut.full.length - cut.heard.length > 40 ? `
+      return false;
+    }
+    voiceIO = new VoiceIO({
+      // No ack phrase by default: a fixed "Mm-hm," every turn reads robotic, Haiku's TTFT doesn't
+      // need masking (~0.7-1.2s full turns), and the conversational register already opens with a
+      // natural reaction. The mechanism (+ echo-leak guard) stays for slower voice models.
+      onState: () => editorRef?.redrawNow(),
+      // Throttled: each redraw clears the screen below the prompt — a partial-per-token storm
+      // (fast speech, or echo bleed if AEC degrades) would continuously erase streamed text.
+      onPartial: (text) => {
+        if (text === voicePartial) return;
+        voicePartial = text;
+        if (!partialRedraw) partialRedraw = setTimeout(() => {
+          partialRedraw = null;
+          editorRef?.redrawNow();
+        }, 250);
+      },
+      onBargeIn: (phase) => {
+        activeTurn?.abort();
+        if (phase === "speaking") err(yellow("\n  \u270B interrupted\n"));
+      },
+      onUtterance: (text) => {
+        voicePartial = "";
+        if (!text.trim()) return;
+        const cut = voiceIO.takeInterruptedReply();
+        const note = cut && cut.full.length - cut.heard.length > 40 ? `
 [the user interrupted you mid-speech \u2014 they only heard up to: "\u2026${cut.heard.slice(-80)}". Work any unheard essentials into your reply naturally, only if still relevant.]` : "";
-          if (!/^[!#/]/.test(text.trim())) voiceIO.beginSpeech(true);
-          err(`\r\x1B[K  ${bold(cyan("\u{1F3A4} \u203A"))} ${text}
+        if (!/^[!#/]/.test(text.trim())) voiceIO.beginSpeech(true);
+        err(`\r\x1B[K  ${bold(cyan("\u{1F3A4} \u203A"))} ${text}
 `);
-          void dispatchLine(text + note).then(async (r) => {
-            if (r === "quit") {
-              await voiceIO?.awaitIdle();
-              editorRef?.abort();
-            }
-          }).finally(() => editorRef?.redrawNow());
-        }
-      });
-      try {
-        await voiceIO.start();
-        process.on("exit", () => voiceIO?.stop());
-        for (const sig of ["SIGHUP", "SIGTERM"]) process.on(sig, () => {
-          voiceIO?.stop();
-          process.exit(0);
-        });
-        err(dim(`  \u{1F3A4} voice on (${voiceIO.usingAec ? "echo-cancelled" : "heuristic echo \u2014 headphones recommended"}) \u2014 just talk; speak over it to interrupt
+        void dispatchLine(text + note).then(async (r) => {
+          if (r === "quit") {
+            await voiceIO?.awaitIdle();
+            editorRef?.abort();
+          }
+        }).finally(() => editorRef?.redrawNow());
+      }
+    });
+    try {
+      await voiceIO.start();
+      err(dim(`  \u{1F3A4} voice on (${voiceIO.usingAec ? "echo-cancelled" : "heuristic echo \u2014 headphones recommended"}) \u2014 just talk; speak over it to interrupt
 `));
+      if (greet) {
         const where = cwd.split("/").pop();
         const resumed = session.messages.length > 0;
         void turn(
           `[session started] First call QuickLook with what:"memory" \u2014 if it knows the user's name or preferences, use them. Then greet the user warmly in one or two short sentences, as the opener of a live voice conversation. Context: working directory "${where}"${resumed ? "; this resumes an earlier conversation \u2014 glance at it and pick up naturally" : ""}. Personalize from whatever you learned (memory, prior conversation). Then ask what they'd like to do.`
         ).finally(() => editorRef?.redrawNow());
-      } catch (e) {
-        err(yellow(`  \u26A0 voice I/O failed to start: ${e?.message ?? e} \u2014 continuing text-only
-`));
-        voiceIO = void 0;
       }
+      return true;
+    } catch (e) {
+      err(yellow(`  \u26A0 voice I/O failed to start: ${e?.message ?? e} \u2014 continuing text-only
+`));
+      voiceIO = void 0;
+      return false;
     }
+  };
+  if (duplex && process.stdin.isTTY) {
+    process.on("exit", () => voiceIO?.stop());
+    for (const sig of ["SIGHUP", "SIGTERM"]) process.on(sig, () => {
+      voiceIO?.stop();
+      process.exit(0);
+    });
   }
+  if (duplex && process.stdin.isTTY) toggleVoice = async () => {
+    if (voiceIO) {
+      voiceIO.stop();
+      voiceIO = void 0;
+      voicePartial = "";
+      err(dim("  \u{1F507} voice off\n"));
+      editorRef?.redrawNow();
+      return;
+    }
+    await startVoice(false);
+    editorRef?.redrawNow();
+  };
+  if (args.voice && duplex && process.stdin.isTTY) await startVoice(true);
   while (true) {
     if (pendingRewind) {
       pendingRewind = false;
@@ -10084,6 +10347,7 @@ ${extra}` : body);
       if (forced) {
         voiceIO?.stop();
         releaseStdin();
+        disposeCursorSessions();
         await closeMcp(mounted);
         process.exit(130);
       }
@@ -10092,6 +10356,7 @@ ${extra}` : body);
     }
   }
   releaseStdin();
+  disposeCursorSessions();
   await closeMcp(mounted);
 }
 function readAllStdin() {
@@ -10168,8 +10433,8 @@ async function main() {
     const { ok, res } = await runTurn(agent, store, session, args.task, void 0, cwd);
     if (cfg.reflectOnFailure && !ok && res && agent.options.memoryDir) {
       const _fsBase = agent.options.fs.getCwd() === "/" ? "" : agent.options.fs.getCwd();
-      const slug = await reflectOnRun({ ai, model: agent.options.model, fs: agent.options.fs, dir: primaryMemDir(agent.options.memoryDir, `${_fsBase}/.agent/memory`), result: res });
-      if (slug) err(dim(`  \u270E learned a lesson \u2192 ${slug}
+      const slug2 = await reflectOnRun({ ai, model: agent.options.model, fs: agent.options.fs, dir: primaryMemDir(agent.options.memoryDir, `${_fsBase}/.agent/memory`), result: res });
+      if (slug2) err(dim(`  \u270E learned a lesson \u2192 ${slug2}
 `));
     }
     await closeMcp(mounted);