agent.libx.js 0.89.5 → 0.89.7

package/dist/cli.js

@@ -1397,7 +1397,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)));
-            log7.debug("shell spawn error", err2);
+            log8.debug("shell spawn error", err2);
             finish(`[exit 1] ${err2?.message ?? err2}${out ? "\n" + clean(out) : ""}`);
           });
           proc.on("close", (code) => {
@@ -1457,14 +1457,14 @@ ${clean(out) || "(no output yet)"}`;
     }
   ];
 }
-var log7, clean, SECRET_ENV_RE, _spawn, ShellJobRegistry, NO_JOB2;
+var log8, clean, SECRET_ENV_RE, _spawn, ShellJobRegistry, NO_JOB2;
 var init_tools_shell = __esm({
   "src/tools.shell.ts"() {
     "use strict";
     init_tools();
     init_redact();
     init_logging();
-    log7 = forComponent("shell");
+    log8 = forComponent("shell");
     clean = (s) => truncateOutput(redactSecrets(s.replace(/\n+$/, "")));
     SECRET_ENV_RE = /(_API_KEY|_TOKEN|_SECRET|_PASSWORD|_PRIVATE_KEY|^AWS_|^GITHUB_TOKEN$|^OPENAI_|^ANTHROPIC_|^GOOGLE_|^GEMINI_|^GROQ_|^NPM_TOKEN$)/i;
     ShellJobRegistry = class {
@@ -3348,6 +3348,202 @@ function digestRun(messages, maxChars) {
   return out.length > maxChars ? out.slice(0, maxChars) + "\n\u2026 (truncated)" : out;
 }
 
+// src/duplex.ts
+import { MemFilesystem as MemFilesystem2 } from "@livx.cc/wcli/core";
+init_logging();
+var log6 = forComponent("DuplexAgent");
+var DuplexAgentOptions = class {
+  /** Any ai.libx.js AIClient — shared by the voice and worker agents (routed by model). */
+  ai;
+  /** The WORKER's filesystem. If omitted the worker keeps Agent's jailed-disk-at-cwd default. */
+  fs;
+  voiceModel = "anthropic/claude-haiku-4-5";
+  workerModel = "anthropic/claude-sonnet-4-6";
+  /** Escape hatches merged over the derived per-agent options. */
+  voiceOptions;
+  workerOptions;
+  /** Receives the voice text_delta stream + task lifecycle events. */
+  host;
+  /** How many recent transcript messages are rendered into a worker's brief. */
+  excerptTurns = 6;
+  /** Voice register: 'neutral' = clean spoken style; 'conversational' = human-like — fillers,
+   *  backchannels, impulsive first reactions before content (mimics real duplex conversation). */
+  voiceStyle = "neutral";
+  /** Awaited BEFORE a delegated worker spawns — open a per-task checkpoint frame, audit, etc.
+   *  (post-spawn would race the worker's first edits). */
+  onTaskStart;
+};
+var VOICE_SYSTEM_PROMPT = 'You are a spoken voice assistant \u2014 the user HEARS everything you say. Use short sentences. One idea per sentence. No markdown, no bullet lists, no code blocks, no headings, no emoji.\nKeep turns SHORT \u2014 one to three sentences, then stop. Never lecture, enumerate cases, or add caveats unprompted. Conversation is a fast exchange: give the one thing asked, and let the user pull more if they want it.\nYou work in a pair: you talk, and a background worker with FULL access to the user\'s environment (files, shell, web) does the hands-on work. You can find out or do ANYTHING by calling `Delegate` with a clear, self-contained brief \u2014 so NEVER tell the user you can\'t see, access, or do something. Delegate and find out. When the user mentions their project, folder, files, or environment ("this project", "the current folder", "my code"), delegate IMMEDIATELY \u2014 do not ask for paths or details the worker can discover itself. Never pretend to have done the work or invent results \u2014 the worker\'s report is your only source.\nAfter calling Delegate, tell the user you are on it in one short sentence, then end your turn. Do not wait for the result.\nResults arrive later as events like "[task t1 completed] \u2026" or "[task t1 failed] \u2026". When one arrives, summarize it for the ear in one or two short sentences. Never read raw file paths, diffs, or code aloud verbatim.\nDo not fire a second Delegate for work already in flight \u2014 check `TaskStatus` first. Use `CancelTask` when the user asks to stop something.';
+var VOICE_STYLE_CONVERSATIONAL = `Speak like a person in a live conversation, not an assistant reading a script. React first, then deliver: a quick impulsive beat ("oh nice", "hmm, hold on", "ah, got it") before the substance. Use contractions always. Vary sentence length \u2014 some very short. Light fillers and backchannels are fine ("mm-hm", "right", "let's see") but at most one per reply \u2014 never stack them. When you delegate, say it like a human would ("hang on, let me actually dig into that \u2014 gimme a minute") instead of announcing a task. When a result comes back, react to it like you just found out ("okay so \u2014 turns out\u2026"). Match the user's energy: a quick question gets a quick answer \u2014 a few words is a perfectly good turn. Prefer a short answer plus an offer ("want the details?") over covering everything. Never narrate your own mechanics (no "I will now delegate", no task ids out loud).`;
+var DuplexAgent = class {
+  options;
+  voice;
+  tasks = /* @__PURE__ */ new Map();
+  queue = Promise.resolve();
+  seq = 0;
+  pendingEvents = [];
+  flushQueued = false;
+  constructor(options) {
+    this.options = { ...new DuplexAgentOptions(), ...options };
+    const o = this.options;
+    this.voice = new Agent({
+      ai: o.ai,
+      fs: new MemFilesystem2(),
+      // scratch — NOT Agent's jailed-disk default (voice has no fs tools; edge-safe)
+      model: o.voiceModel,
+      stream: true,
+      host: o.host,
+      systemPrompt: VOICE_SYSTEM_PROMPT + (o.voiceStyle === "conversational" ? "\n" + VOICE_STYLE_CONVERSATIONAL : ""),
+      instructionFiles: false,
+      maxSteps: 8,
+      // a voice turn should never loop
+      timeoutMs: 3e4,
+      ...o.voiceOptions,
+      // no defaultTools() — the voice can only Delegate, never touch files itself. Set AFTER the
+      // voiceOptions spread (addTools() would be clobbered by the first prepare()); extra voice
+      // tools come in via voiceOptions.tools and are merged here.
+      tools: [...o.voiceOptions?.tools ?? [], this.delegateTool(), this.taskStatusTool(), this.cancelTaskTool()]
+    });
+  }
+  /** One user turn: the voice agent streams the reply (and may Delegate). Serialized with re-voice turns. */
+  send(content) {
+    return this.enqueue(() => this.voice.send(content));
+  }
+  /** Resolve when all queued voice turns AND all in-flight worker tasks have settled (tests, graceful shutdown). */
+  async idle() {
+    while (true) {
+      const q2 = this.queue;
+      await q2.catch(() => {
+      });
+      await Promise.all([...this.tasks.values()].map((t) => t.promise));
+      if (this.queue === q2 && ![...this.tasks.values()].some((t) => t.status === "running")) return;
+    }
+  }
+  /** Promise-chain mutex: turns run strictly one at a time; a failed turn doesn't poison the chain. */
+  enqueue(fn) {
+    const run = this.queue.then(fn, fn);
+    this.queue = run.then(() => {
+    }, () => {
+    });
+    return run;
+  }
+  notify(kind, message, data) {
+    this.options.host?.notify?.({ kind, message, data });
+  }
+  /** Queue a `[task …]` event for re-voicing. Events arriving while the voice is busy coalesce into ONE turn. */
+  queueRevoice(event) {
+    this.pendingEvents.push(event);
+    if (this.flushQueued) return;
+    this.flushQueued = true;
+    void this.enqueue(async () => {
+      this.flushQueued = false;
+      const events = this.pendingEvents.splice(0);
+      if (!events.length) return;
+      await this.voice.send(events.join("\n"));
+      this.notify("revoice_done", "");
+    });
+  }
+  /** The worker's brief: the Delegate args + a STATIC text snapshot of the recent conversation. */
+  buildBrief(brief) {
+    const recent = this.voice.transcript.filter((m) => (m.role === "user" || m.role === "assistant") && contentText(m.content).trim()).slice(-this.options.excerptTurns).map((m) => `${m.role}: ${contentText(m.content)}`).join("\n");
+    return recent ? `${brief}
+
+## Recent conversation (for context)
+${recent}` : brief;
+  }
+  /** Spawn a detached worker for task `id`; its settlement notifies + enqueues the re-voice turn. */
+  spawnWorker(id, label, briefText) {
+    const o = this.options;
+    const controller = new AbortController();
+    const worker = new Agent({
+      ai: o.ai,
+      fs: o.fs,
+      model: o.workerModel,
+      ...o.workerOptions,
+      // may override ai/fs/model/tools/… —
+      signal: controller.signal
+      // …but never the per-task cancellation signal
+    });
+    const promise = worker.run(briefText).then((res) => this.onWorkerSettled(id, res)).catch((err2) => this.onWorkerFailed(id, err2));
+    this.tasks.set(id, { id, label, status: "running", controller, promise });
+  }
+  onWorkerSettled(id, res) {
+    const rec = this.tasks.get(id);
+    if (res.finishReason === "aborted" || rec.status === "cancelled") {
+      rec.status = "cancelled";
+      this.notify("task_cancelled", `task ${id} (${rec.label}) cancelled`);
+      return;
+    }
+    if (res.finishReason === "error") {
+      const msg = res.error instanceof Error ? res.error.message : String(res.error ?? "unknown error");
+      return this.failTask(rec, msg);
+    }
+    rec.status = "done";
+    log6.verbose(`task ${id} done (${res.steps} steps)`);
+    this.notify("task_done", `task ${id} (${rec.label}) completed`, { id, text: res.text, usage: res.usage, usageEstimated: res.usageEstimated });
+    this.queueRevoice(`[task ${id} completed] ${res.text}`);
+  }
+  onWorkerFailed(id, err2) {
+    this.failTask(this.tasks.get(id), err2 instanceof Error ? err2.message : String(err2));
+  }
+  failTask(rec, msg) {
+    rec.status = "error";
+    log6.warn(`task ${rec.id} failed: ${msg}`);
+    this.notify("task_error", `task ${rec.id} (${rec.label}) failed: ${msg}`);
+    this.queueRevoice(`[task ${rec.id} failed] ${msg}`);
+  }
+  // --- the three voice tools (closures over this instance) ---
+  delegateTool() {
+    return {
+      name: "Delegate",
+      description: 'Escalate real work (reading/editing files, searching, running tasks, deep analysis) to a background worker agent. Returns immediately with a task id; the result arrives later as a "[task <id> completed]" event. Provide a clear, self-contained `brief` (the worker does not hear the live conversation).',
+      parameters: {
+        type: "object",
+        required: ["brief"],
+        properties: {
+          brief: { type: "string", description: "full, self-contained instructions for the worker" },
+          label: { type: "string", description: "a short (2-4 word) label for the task" }
+        }
+      },
+      run: async ({ brief, label }) => {
+        const id = `t${++this.seq}`;
+        const lbl = String(label ?? "task");
+        await this.options.onTaskStart?.(id, lbl);
+        this.spawnWorker(id, lbl, this.buildBrief(String(brief ?? "")));
+        this.notify("task_started", `task ${id} (${lbl}) started`, { id, brief });
+        return `Delegated as task ${id}. Acknowledge briefly; the result will arrive as a [task ${id} completed] event.`;
+      }
+    };
+  }
+  taskStatusTool() {
+    return {
+      name: "TaskStatus",
+      description: "Status of background tasks. Pass `id` for one task, or omit it to list all.",
+      parameters: { type: "object", properties: { id: { type: "string" } } },
+      run: async ({ id }) => {
+        const list = id ? [this.tasks.get(String(id))].filter(Boolean) : [...this.tasks.values()];
+        if (!list.length) return id ? `No task '${id}'.` : "No background tasks.";
+        return list.map((t) => `${t.id} (${t.label}): ${t.status}`).join("\n");
+      }
+    };
+  }
+  cancelTaskTool() {
+    return {
+      name: "CancelTask",
+      description: "Cancel a running background task by id.",
+      parameters: { type: "object", required: ["id"], properties: { id: { type: "string" } } },
+      run: async ({ id }) => {
+        const rec = this.tasks.get(String(id));
+        if (!rec) return `No task '${id}'.`;
+        if (rec.status !== "running") return `Task ${rec.id} is already ${rec.status}.`;
+        rec.status = "cancelled";
+        rec.controller.abort();
+        return `Task ${rec.id} (${rec.label}) cancelled.`;
+      }
+    };
+  }
+};
+
 // src/mcp.ts
 function toText(result) {
   if (result == null) return "";
@@ -3375,12 +3571,12 @@ function mcpToolsToAgentTools(specs, callTool, prefix = "mcp__", filter) {
 
 // src/index.ts
 init_logging();
-import { MemFilesystem as MemFilesystem2, IndexedDbFilesystem, CommandExecutor as CommandExecutor2, registerHeadlessCommands as registerHeadlessCommands2 } from "@livx.cc/wcli/core";
+import { MemFilesystem as MemFilesystem3, IndexedDbFilesystem, CommandExecutor as CommandExecutor2, registerHeadlessCommands as registerHeadlessCommands2 } from "@livx.cc/wcli/core";
 
 // src/mcp.client.ts
 init_logging();
 import { spawn } from "child_process";
-var log6 = forComponent("mcp");
+var log7 = forComponent("mcp");
 var PROTOCOL_VERSION = "2025-06-18";
 var DEFAULT_TIMEOUT_MS = 3e4;
 var StdioTransport = class {
@@ -3399,7 +3595,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) => log6.debug(`[${command}] stderr:`, chunk.trimEnd()));
+    proc.stderr.on("data", (chunk) => log7.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))));
   }
@@ -3413,7 +3609,7 @@ var StdioTransport = class {
       try {
         this.dispatch(JSON.parse(line));
       } catch (e) {
-        log6.debug("dropping non-JSON line from MCP server:", line, e);
+        log7.debug("dropping non-JSON line from MCP server:", line, e);
       }
     }
   }
@@ -3462,7 +3658,7 @@ var StdioTransport = class {
     try {
       this.proc?.stdin?.end();
     } catch (e) {
-      log6.debug("stdin end failed", e);
+      log7.debug("stdin end failed", e);
     }
     this.proc?.kill();
   }
@@ -3531,7 +3727,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) {
-      log6.debug("skipping unparseable SSE data line", e);
+      log7.debug("skipping unparseable SSE data line", e);
     }
   }
   return {};
@@ -3585,16 +3781,16 @@ async function mountMcpServers(servers = {}) {
   for (const [name, cfg] of Object.entries(servers)) {
     if (!cfg || cfg.disabled) continue;
     if (!cfg.command && !cfg.url) {
-      log6.warn(`MCP server "${name}" needs a command (stdio) or url (http) \u2014 skipping`);
+      log7.warn(`MCP server "${name}" needs a command (stdio) or url (http) \u2014 skipping`);
       continue;
     }
     try {
       const m = await mountMcpServer(name, cfg);
       out.push(m);
-      log6.info(`MCP "${name}" mounted \u2014 ${m.tools.length} tool(s)${m.serverInfo?.name ? ` from ${m.serverInfo.name}` : ""}`);
+      log7.info(`MCP "${name}" mounted \u2014 ${m.tools.length} tool(s)${m.serverInfo?.name ? ` from ${m.serverInfo.name}` : ""}`);
     } catch (e) {
-      if (e instanceof McpAuthError) log6.warn(`MCP "${name}" needs-auth: HTTP ${e.status} \u2014 set bearerToken or headers in its config; skipping`);
-      else log6.error(`MCP server "${name}" failed to mount: ${e?.message ?? e}`);
+      if (e instanceof McpAuthError) log7.warn(`MCP "${name}" needs-auth: HTTP ${e.status} \u2014 set bearerToken or headers in its config; skipping`);
+      else log7.error(`MCP server "${name}" failed to mount: ${e?.message ?? e}`);
     }
   }
   return out;
@@ -3827,6 +4023,21 @@ async function hydrate(from, to, dir = "/") {
   }
   return n;
 }
+function toCursorMcp(servers) {
+  if (!servers) return void 0;
+  const out = {};
+  for (const [name, s] of Object.entries(servers)) {
+    if (!s || s.disabled) continue;
+    if (s.command) {
+      out[name] = { type: "stdio", command: s.command, ...s.args ? { args: s.args } : {}, ...s.env ? { env: s.env } : {}, ...s.cwd ? { cwd: s.cwd } : {} };
+    } else if (s.url) {
+      if (s.auth === "oauth" && !s.bearerToken) continue;
+      const headers = { ...s.headers ?? {}, ...s.bearerToken ? { Authorization: `Bearer ${s.bearerToken}` } : {} };
+      out[name] = { url: s.url, ...Object.keys(headers).length ? { headers } : {} };
+    }
+  }
+  return Object.keys(out).length ? { mcpServers: out } : void 0;
+}
 async function buildAgent(o) {
   if (typeof o.sandbox !== "boolean")
     throw new Error(
@@ -3838,9 +4049,14 @@ async function buildAgent(o) {
   const jailedDisk = new JailedFilesystem(disk);
   jailedDisk.setCwd(cwd);
   const virtual = o.sandbox || !!o.boddb;
+  const isCursor = (o.model ?? "").startsWith("cursor/");
+  if (virtual && isCursor)
+    throw new Error(
+      "cursor/* models cannot run in --sandbox/--boddb: the Cursor agent runs its own real-disk tools and bypasses the VFS jail. Use disk mode (default)."
+    );
   let fs = jailedDisk;
   if (o.sandbox) {
-    const mem = new MemFilesystem2();
+    const mem = new MemFilesystem3();
     await mkdirp(mem, cwd);
     await hydrate(jailedDisk, mem, cwd);
     mem.setCwd(cwd);
@@ -3899,6 +4115,11 @@ Reference files in them by their mount path (the left side).`;
     ai: o.ai,
     fs,
     model: o.model ?? "anthropic/claude-sonnet-4-6",
+    // Anchor cursor to the launch dir (its adapter defaults to TMPDIR otherwise) and forward the
+    // host's MCP servers so the delegated cursor agent runs in the same environment. Gated to cursor:
+    // openai/google adapters Object.assign providerOptions into the request body, so a blanket cwd
+    // would corrupt those calls.
+    ...isCursor ? { providerOptions: { cwd, ...toCursorMcp(o.mcpServers) ?? {} } } : {},
     ...(() => {
       const now = /* @__PURE__ */ new Date();
       const platformNames = { darwin: "macOS", linux: "Linux", win32: "Windows" };
@@ -3962,6 +4183,7 @@ function summarizeCall(name, args) {
   if (args.command) return String(args.command);
   if (args.pattern) return `/${args.pattern}/${args.glob ? " in " + args.glob : ""}`;
   if (args.prompt) return trunc(String(args.description ?? args.prompt), 50);
+  if (args.brief) return trunc(String(args.label ? `${args.label}: ${args.brief}` : args.brief), 70);
   return trunc(JSON.stringify(args), 60);
 }
 var trunc = (s, n) => (s == null ? "" : String(s).length > n ? String(s).slice(0, n) + "\u2026" : String(s)).replace(/\n/g, "\u23CE");
@@ -4024,7 +4246,7 @@ async function loadConfig(cwd) {
 
 // cli/hooks-config.ts
 import { spawnSync } from "child_process";
-var log8 = forComponent("hooks");
+var log9 = forComponent("hooks");
 var escapeRegex = (s) => s.replace(/[.+^${}()|[\]\\]/g, "\\$&");
 function ruleMatches(rule, toolName) {
   if (!rule.tool || rule.tool === "*") return true;
@@ -4041,7 +4263,7 @@ function runCmd(rule, env) {
     });
     return { code: r.status ?? 1, out: ((r.stdout ?? "") + (r.stderr ?? "")).trim() };
   } catch (e) {
-    log8.debug(`hook command failed: ${rule.command}`, e);
+    log9.debug(`hook command failed: ${rule.command}`, e);
     return { code: 1, out: String(e?.message ?? e) };
   }
 }
@@ -4147,7 +4369,7 @@ function formatDiff(ops, opts = {}) {
 // cli/session.ts
 import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3, readdirSync, renameSync } from "fs";
 import { join as join5 } from "path";
-var log9 = forComponent("session");
+var log10 = forComponent("session");
 var SessionStore = class {
   dir;
   constructor(cwd) {
@@ -4173,7 +4395,7 @@ var SessionStore = class {
   }
   load(id) {
     if (!this.safeId(id)) {
-      log9.debug(`rejecting unsafe session id: ${id}`);
+      log10.debug(`rejecting unsafe session id: ${id}`);
       return void 0;
     }
     const path = join5(this.dir, `${id}.json`);
@@ -4181,7 +4403,7 @@ var SessionStore = class {
     try {
       return JSON.parse(readFileSync3(path, "utf8"));
     } catch (e) {
-      log9.debug(`unreadable session ${id} \u2014 ignoring`, e);
+      log10.debug(`unreadable session ${id} \u2014 ignoring`, e);
       return void 0;
     }
   }
@@ -4194,7 +4416,7 @@ var SessionStore = class {
       try {
         metas.push(JSON.parse(readFileSync3(join5(this.dir, f), "utf8")).meta);
       } catch (e) {
-        log9.debug(`skipping unreadable session file ${f}`, e);
+        log10.debug(`skipping unreadable session file ${f}`, e);
       }
     }
     return metas.sort((a, b) => b.updated - a.updated);
@@ -4288,7 +4510,7 @@ import { execFile } from "child_process";
 import { promisify } from "util";
 import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync4, existsSync as existsSync5 } from "fs";
 import { join as join6, resolve as resolve2, sep as sep2 } from "path";
-var log10 = forComponent("checkpoints");
+var log11 = forComponent("checkpoints");
 var exec = promisify(execFile);
 var DEFAULT_EXCLUDE = [".agent/", ".git/", "node_modules/", "dist/", "build/", ".next/", "target/", ".venv/", "__pycache__/", "*.log"];
 var ShadowRepo = class {
@@ -4322,7 +4544,7 @@ var ShadowRepo = class {
       writeFileSync4(join6(this.gitDir, "info", "exclude"), this.exclude.join("\n") + "\n");
       this.ready = true;
     } catch (e) {
-      log10.debug(`git checkpoints unavailable for ${this.workTree}`, e);
+      log11.debug(`git checkpoints unavailable for ${this.workTree}`, e);
       this.ready = false;
     }
     return this.ready;
@@ -4385,7 +4607,7 @@ var ShadowRepo = class {
       await this.run("gc", "--auto", "-q").catch(() => {
       });
     } catch (e) {
-      log10.debug("checkpoint prune failed", e);
+      log11.debug("checkpoint prune failed", e);
     }
   }
 };
@@ -4442,7 +4664,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) => log10.debug("re-point failed", e));
+    if (this.started) for (const r of this.repos) void r.point(this.ref()).catch((e) => log11.debug("re-point failed", e));
   }
   async begin(label) {
     if (!await this.start()) return;
@@ -4453,7 +4675,7 @@ var GitCheckpoints = class {
       try {
         await r.commit(msg);
       } catch (e) {
-        log10.debug("checkpoint commit failed", e);
+        log11.debug("checkpoint commit failed", e);
       }
     }
     if (slow) clearTimeout(slow);
@@ -5402,6 +5624,9 @@ function createLineEditor(out) {
     process.on("SIGWINCH", onResize);
     return new Promise((resolve4) => {
       const redraw = () => render(s, opts.prompt, maxVisible, opts.status);
+      const ticker = opts.statusTickMs && opts.status ? setInterval(() => {
+        if (!s.pasting) redraw();
+      }, opts.statusTickMs) : void 0;
       const onKey = (str, key) => {
         if (key?.ctrl && key.name === "l") {
           out.write("\x1B[2J\x1B[3J\x1B[H");
@@ -5419,6 +5644,11 @@ function createLineEditor(out) {
           redraw();
           return;
         }
+        if (key?.ctrl && key.name === "o" && opts.onToggleVerbose) {
+          opts.onToggleVerbose();
+          redraw();
+          return;
+        }
         if (key?.meta && key.name === "p" && opts.onPickModel) {
           process.stdin.off("keypress", onKey);
           void opts.onPickModel().finally(() => {
@@ -5455,6 +5685,7 @@ function createLineEditor(out) {
         render(s, opts.prompt, maxVisible, opts.status);
       };
       const finish = () => {
+        if (ticker) clearInterval(ticker);
         process.stdin.off("keypress", onKey);
         process.removeListener("SIGWINCH", onResize);
         out.write("\x1B[?2004l");
@@ -5767,7 +5998,7 @@ var red = C("31");
 var bold = C("1");
 var yellow = C("33");
 var err = (s) => process.stderr.write(s);
-var log11 = forComponent("cli");
+var log12 = forComponent("cli");
 var VERSION = (() => {
   try {
     return JSON.parse(readFileSync5(new URL("../package.json", import.meta.url), "utf8")).version ?? "?";
@@ -5806,7 +6037,7 @@ function parseReasoning(raw) {
   throw new Error(`invalid --reasoning: ${raw} (use off|low|medium|high or a token budget)`);
 }
 function parseArgs(argv) {
-  const a = { stream: true, plan: false, ask: false, yes: false, vfs: false, shell: void 0, seed: false, subagents: false, help: false, version: false, cont: false, outputFormat: "text" };
+  const a = { stream: true, plan: false, ask: false, yes: false, vfs: false, shell: void 0, seed: false, subagents: false, help: false, version: false, cont: false, outputFormat: "text", duplex: false, voice: false };
   const rest = [];
   const val = (i, flag) => {
     const v = argv[i];
@@ -5838,6 +6069,11 @@ function parseArgs(argv) {
     else if (x === "--shell") a.shell = true;
     else if (x === "--no-shell") a.shell = false;
     else if (x === "--subagents") a.subagents = true;
+    else if (x === "--duplex") a.duplex = true;
+    else if (x === "--conversational" || x === "--convo" || x === "--voice") {
+      a.voice = true;
+      a.duplex = true;
+    } else if (x === "--voice-model") a.voiceModel = val(++i, x);
     else if (x === "--allowedTools" || x === "--allowed-tools") a.allowedTools = val(++i, x).split(",").map((s) => s.trim()).filter(Boolean);
     else if (x === "--disallowedTools" || x === "--disallowed-tools") a.disallowedTools = val(++i, x).split(",").map((s) => s.trim()).filter(Boolean);
     else if (x === "--append-system-prompt") a.appendSystemPrompt = val(++i, x);
@@ -5857,6 +6093,9 @@ function parseArgs(argv) {
   if (!a.task && rest.length) a.task = rest.join(" ");
   if (a.boddb && a.vfs) throw new Error("--boddb and --sandbox are mutually exclusive (both are non-disk filesystems; pick one)");
   if (a.seed && !a.boddb) throw new Error("--seed only applies with --boddb (it seeds the database from cwd on first run)");
+  if (a.duplex && (a.task || a.print)) throw new Error("--duplex is interactive-only (a conversational mode) \u2014 drop the task/-p");
+  if (a.duplex && a.plan) throw new Error("--plan is not supported in --duplex (workers are non-interactive; a plan could never be approved)");
+  if (a.voiceModel && !a.duplex) throw new Error("--voice-model only applies with --duplex");
   return a;
 }
 var HELP = `agentx \u2014 agent.libx.js CLI
@@ -5886,6 +6125,11 @@ Flags:
   --allowedTools <l>   comma-list of tools to allow w/o asking, e.g. "Edit,Shell(git *)"
   --disallowedTools <l> comma-list of tools to deny outright (wins over allow), e.g. "Shell(rm *)"
   --append-system-prompt <t>  extra instructions appended to the system prompt for this run
+  --duplex             duplex mode: a fast voice model replies instantly and delegates real work
+                       to a background worker agent (-m model); results are re-voiced when ready
+  --conversational     duplex with a conversation-native register \u2014 short fast turns, fillers,
+                       impulsive reactions, human pacing (implies --duplex; aliases: --convo, --voice)
+  --voice-model <id>   with --duplex: the fast voice model (default anthropic/claude-haiku-4-5)
   --add-dir <path>     mount another directory into the workspace (repeatable; disk mode only)
   --subagents          allow the Task tool (spawn child agents)
   --reasoning <e>      extended thinking: off|low|medium|high or a token budget (anthropic/openai)
@@ -5918,7 +6162,7 @@ REPL shortcuts: !<cmd> runs a shell command inline \xB7 #<note> saves a memory \
 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 /exit
 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 \u2192 or Tab accepts the dim history ghost-suggestion.
+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.
 REPL editing (emacs/readline): Ctrl-A/E line start/end \xB7 Ctrl-B/F char \xB7 Alt-B/F or Alt/Ctrl-\u2190/\u2192 word \xB7 Ctrl-W kill word \xB7 Ctrl-U/K kill to start/end \xB7 Ctrl-Y yank \xB7 Alt-D kill word fwd \xB7 Ctrl-L clear screen. Set editorMode:'vim' (or /config) for modal vim editing.
 REPL paste: large/multi-line pastes collapse to a [Pasted text +N lines] preview (expands on send); a pasted image/file path attaches as [Image]/[File]; /paste grabs a clipboard image (macOS).`;
 function newestModel() {
@@ -5980,7 +6224,10 @@ function makeHost(format = "text", opts) {
       }
       if (e.kind === "thinking_delta") {
         if (streamJson) process.stdout.write(JSON.stringify({ type: "thinking", text: e.message }) + "\n");
-        else if (!cleanStdout) process.stderr.write(dim(e.message));
+        else if (!cleanStdout) {
+          if (md && md.pending()) process.stdout.write(md.flush() + "\n");
+          process.stderr.write(dim(e.message));
+        }
         return;
       }
       if (md && md.pending()) process.stdout.write(md.flush() + "\n");
@@ -6054,7 +6301,7 @@ function displayHooks(fs) {
         const text = String(result).replace(/\s+$/, "");
         if (text && !/^Edited|^Wrote|^Applied/.test(text)) {
           const lines = text.split("\n");
-          const shown = lines.slice(0, RESULT_PREVIEW_LINES);
+          const shown = lines.slice(0, previewLines());
           for (const ln of shown) err(dim(`    ${ln.length > 200 ? ln.slice(0, 200) + "\u2026" : ln}
 `));
           const more = lines.length - shown.length;
@@ -6182,6 +6429,14 @@ async function appendMemoryNote(fs, dir, text) {
 }
 var ASK_MUTATING = ["bash", "Shell", "Write", "Edit", "MultiEdit", "deleteFile"];
 var RESULT_PREVIEW_LINES = 6;
+var verboseOutput = false;
+var previewLines = () => verboseOutput ? Number.MAX_SAFE_INTEGER : RESULT_PREVIEW_LINES;
+var toggleVerbose = () => {
+  verboseOutput = !verboseOutput;
+  err(dim(`  \u2303O verbose output ${verboseOutput ? "on \u2014 full tool results" : "off \u2014 previews"}
+`));
+  return verboseOutput ? "verbose" : "preview";
+};
 var canPrompt = !!(process.stdin.isTTY && process.stderr.isTTY);
 function resolvePermMode(args, interactiveCapable) {
   if (args.yes) return { gate: "allow" };
@@ -6262,7 +6517,10 @@ function optsFor(args, ai, cfg = {}, extraTools = []) {
     maxToolCalls: cfg.maxToolCalls,
     keepToolOutputs: cfg.keepToolOutputs,
     maxContextTokens: cfg.maxContextTokens,
-    learnFromMistakes: cfg.learnFromMistakes
+    learnFromMistakes: cfg.learnFromMistakes,
+    // Forwarded to cursor/* delegations for environment parity (chat-model providers ignore it).
+    // Raw config (pre-OAuth): unresolved-oauth http servers are skipped by the cursor mapper.
+    mcpServers: cfg.mcpServers
   };
 }
 async function makeAgent(args, ai, cfg, extraTools = []) {
@@ -6306,7 +6564,7 @@ async function mountMcp(cfg, oauth) {
   return mounted;
 }
 async function closeMcp(mounted) {
-  await Promise.all(mounted.map((m) => m.client.close().catch((e) => log11.debug("mcp close failed", e))));
+  await Promise.all(mounted.map((m) => m.client.close().catch((e) => log12.debug("mcp close failed", e))));
 }
 var IMG_EXT = { ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".gif": "image/gif", ".webp": "image/webp" };
 function readImageParts(cwd, line) {
@@ -6386,7 +6644,7 @@ async function readMultiline(readLine) {
     return parts.join("\n");
   }
 }
-async function runTurn(agent, store, session, task, cp, cwd = process.cwd()) {
+async function runTurn(agent, store, session, task, cp, cwd = process.cwd(), sendFn) {
   const t0 = Date.now();
   await cp?.begin(task);
   const { text, loaded, missing } = await expandMentions(agent.options.fs, task);
@@ -6406,9 +6664,9 @@ async function runTurn(agent, store, session, task, cp, cwd = process.cwd()) {
   agent.options.signal = ctrl.signal;
   const content = images.length ? [{ type: "text", text }, ...images] : text;
   let res;
-  spinner.start();
+  spinner.start(sendFn ? "voice\u2026" : void 0);
   try {
-    res = await agent.send(content);
+    res = await (sendFn ? sendFn(content) : agent.send(content));
   } catch (e) {
     spinner.stop();
     err(red(`  error: ${e?.message ?? e}
@@ -6529,25 +6787,127 @@ function persistSetting(cwd, key, value) {
   }
 }
 var persistModel = (cwd, model) => persistSetting(cwd, "model", model);
+var isCancelTeardown = (e) => {
+  if (!e) return false;
+  if (e.code === 20 || e.cause?.code === 20) return true;
+  const blob = `${e.code ?? ""} ${e.name ?? ""} ${e.cause?.name ?? ""} ${e.rawMessage ?? ""} ${e.message ?? ""}`;
+  return /NGHTTP2_FRAME_SIZE_ERROR|ERR_HTTP2_STREAM_ERROR|operation was aborted|\bAbortError\b/i.test(blob);
+};
+function installCancelGuards(mounted) {
+  process.on("unhandledRejection", (e) => {
+    if (isCancelTeardown(e)) {
+      log12.debug("suppressed unhandledRejection (cursor stream cancel)", e);
+      return;
+    }
+    log12.error("unhandledRejection", e);
+  });
+  process.on("uncaughtException", (e) => {
+    if (isCancelTeardown(e)) {
+      log12.debug("suppressed uncaughtException (cursor stream cancel)", e);
+      return;
+    }
+    console.error(e);
+    void closeMcp(mounted);
+    process.exit(1);
+  });
+}
 async function repl(args, ai, cfg, cwd) {
   const oauth = new McpOAuth({ storePath: join8(cwd, ".agent", "mcp-auth.json") });
   const mounted = await mountMcp(cfg, oauth);
   const agent = await makeAgent(args, ai, cfg, mounted.flatMap((m) => m.tools));
+  const duplex = args.duplex;
+  let dx;
+  let workerOptions;
+  let duplexPersist = () => {
+  };
+  let duplexAccount = () => {
+  };
+  const duplexAsk = async (call) => {
+    err(yellow(`  \u2298 worker asked to run ${call.name} \u2014 auto-denied (no interactive approval in duplex; use --yes or --allowedTools)
+`));
+    return { decision: "deny" };
+  };
+  if (duplex) {
+    const { host: _host, stream: _stream, signal: _signal, ...wo } = agent.options;
+    workerOptions = wo;
+    if (workerOptions.permissions)
+      workerOptions.permissions = new PermissionPolicy({ ...workerOptions.permissions.options, host: void 0, ask: duplexAsk });
+    workerOptions.planMode = false;
+    const base = makeHost("text", { stream: true });
+    const host = {
+      ...base,
+      notify(e) {
+        if (e.kind === "revoice_done") {
+          base.flushText();
+          process.stdout.write("\n");
+          duplexPersist();
+          return;
+        }
+        if (e.kind === "task_done" && e.data?.text) {
+          const lines = String(e.data.text).split("\n");
+          const shown = lines.slice(0, previewLines());
+          err("\n" + dim(`  \u29BF ${e.message}
+`) + shown.map((l) => dim(`    ${l}
+`)).join(""));
+          if (lines.length > shown.length) err(dim(`    \u2026 (+${lines.length - shown.length} more lines)
+`));
+          duplexAccount(e.data);
+          return;
+        }
+        base.notify(e);
+      }
+    };
+    const rewindFilesTool = {
+      name: "RewindFiles",
+      description: "Undo file changes made by delegated tasks: roll back the last N task checkpoints (default 1). Use when the user asks to undo/revert what a task changed.",
+      parameters: { type: "object", properties: { steps: { type: "number", description: "how many task checkpoints to undo (default 1)" } } },
+      run: async ({ steps }) => {
+        if (!checkpoints.size) return "No file checkpoints to rewind yet.";
+        if ([...dx?.tasks.values() ?? []].some((t) => t.status === "running"))
+          return "A task is still running \u2014 cancel it first (CancelTask), then rewind.";
+        const n = Math.min(Math.max(1, Number(steps ?? 1)), checkpoints.size);
+        const r = await checkpoints.rewindTo(checkpoints.size - n);
+        return `Rewound ${n} task checkpoint(s): restored ${r.restored} file(s), deleted ${r.deleted}.`;
+      }
+    };
+    dx = new DuplexAgent({
+      ai,
+      fs: agent.options.fs,
+      ...args.voiceModel ? { voiceModel: resolveModelOrNewest(args.voiceModel) } : {},
+      workerModel: agent.options.model,
+      workerOptions,
+      host,
+      ...args.voice ? { voiceStyle: "conversational" } : {},
+      // Per-TASK checkpoint frames (the natural undo unit in duplex = one delegation): opened BEFORE
+      // the worker spawns (post-spawn would race its first edits). `checkpoints` is bound below.
+      onTaskStart: async (_id, label) => {
+        await checkpoints.begin(label);
+      },
+      // The voice runs on the REAL fs (it has no fs tools — harmless) so @mentions, !cmd and #note
+      // resolve against the project; + CC-parity chrome for its own tool calls (⚙ Delegate …).
+      voiceOptions: { fs: agent.options.fs, hooks: displayHooks(agent.options.fs), tools: [rewindFilesTool] }
+    });
+  }
+  const face = dx ? dx.voice : agent;
+  const work = workerOptions ?? agent.options;
+  const sendVia = dx ? (c) => dx.send(c) : void 0;
   const baseRules = () => [
     ...parsePermRules({ deny: args.disallowedTools }),
     ...parsePermRules({ allow: args.allowedTools }),
     ...parsePermRules(mergePerms(loadPersistedRules(cwd), cfg.permissions))
   ];
   const askFor = (tools) => tools.map((t) => ({ tool: t, decision: "ask" }));
-  const POSTURES = ["default", "acceptEdits", "plan"];
-  let posture = args.plan || cfg.permissionMode === "plan" ? "plan" : cfg.permissionMode === "acceptEdits" ? "acceptEdits" : "default";
+  const POSTURES = duplex ? ["default", "acceptEdits"] : ["default", "acceptEdits", "plan"];
+  let posture = !duplex && (args.plan || cfg.permissionMode === "plan") ? "plan" : cfg.permissionMode === "acceptEdits" ? "acceptEdits" : "default";
   const postureLabel = () => posture === "default" ? "ask (default)" : posture === "acceptEdits" ? "accept edits" : "plan mode";
   const applyPosture = (p) => {
     posture = p;
     const ask = p === "acceptEdits" ? askFor(["bash", "Shell"]) : askFor(ASK_MUTATING);
-    agent.options.permissions = new PermissionPolicy({ rules: [...baseRules(), ...ask], default: "allow", host: makeHost(), ask: makeAskResolver(cwd) });
-    agent.options.planMode = p === "plan";
-    agent.reprepare();
+    work.permissions = new PermissionPolicy({ rules: [...baseRules(), ...ask], default: "allow", host: duplex ? void 0 : makeHost(), ask: duplex ? duplexAsk : makeAskResolver(cwd) });
+    if (!duplex) {
+      agent.options.planMode = p === "plan";
+      agent.reprepare();
+    }
   };
   const cyclePosture = () => {
     applyPosture(POSTURES[(POSTURES.indexOf(posture) + 1) % POSTURES.length]);
@@ -6558,13 +6918,27 @@ async function repl(args, ai, cfg, cwd) {
   if (!args.yes) applyPosture(posture);
   const REASONING_CYCLE = ["off", "low", "medium", "high"];
   const toggleReasoning = () => {
-    const cur = String(agent.options.reasoning ?? "off");
+    const cur = String(work.reasoning ?? "off");
     const next = REASONING_CYCLE[(Math.max(0, REASONING_CYCLE.indexOf(cur)) + 1) % REASONING_CYCLE.length];
-    agent.options.reasoning = next;
+    work.reasoning = next;
     err(dim(`  ~ reasoning \u2192 ${next}
 `));
     return next;
   };
+  const setModel = (m) => {
+    work.model = m;
+    if (dx) dx.options.workerModel = m;
+    persistModel(cwd, m);
+    err(dim("  model \u2192 " + m + "\n"));
+  };
+  const addWorkTools = (ts) => {
+    if (duplex) work.tools = [...work.tools ?? [], ...ts];
+    else agent.addTools(ts);
+  };
+  const removeWorkTools = (names) => {
+    if (duplex) work.tools = (work.tools ?? []).filter((t) => !names.includes(t.name));
+    else agent.removeTools(names);
+  };
   const pendingImages = [];
   const grabClipboardAttachment = () => {
     const dir = join8(tmpdir(), "agentx-pasted");
@@ -6583,33 +6957,33 @@ async function repl(args, ai, cfg, cwd) {
     void closeMcp(mounted);
     process.exit(130);
   });
-  const isCancelTeardown = (e) => {
-    if (!e) return false;
-    if (e.code === 20 || e.cause?.code === 20) return true;
-    const blob = `${e.code ?? ""} ${e.name ?? ""} ${e.cause?.name ?? ""} ${e.rawMessage ?? ""} ${e.message ?? ""}`;
-    return /NGHTTP2_FRAME_SIZE_ERROR|ERR_HTTP2_STREAM_ERROR|operation was aborted|\bAbortError\b/i.test(blob);
-  };
-  process.on("unhandledRejection", (e) => {
-    if (isCancelTeardown(e)) {
-      log11.debug("suppressed unhandledRejection (cursor stream cancel)", e);
-      return;
-    }
-    log11.error("unhandledRejection", e);
-  });
-  process.on("uncaughtException", (e) => {
-    if (isCancelTeardown(e)) {
-      log11.debug("suppressed uncaughtException (cursor stream cancel)", e);
-      return;
-    }
-    console.error(e);
-    void closeMcp(mounted);
-    process.exit(1);
-  });
+  installCancelGuards(mounted);
   const store = new SessionStore(cwd);
-  let session = startSession(args, store, agent, cwd);
+  let session = startSession(args, store, face, cwd);
   const checkpoints = args.vfs || args.boddb ? new CheckpointStack(agent.options.fs) : new GitCheckpoints({ workTree: cwd, gitDir: join8(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);
+  if (cpHooks) work.hooks = composeHooks(work.hooks, cpHooks);
+  duplexPersist = () => {
+    session.messages = face.transcript;
+    session.meta.updated = Date.now();
+    if (!session.meta.title) session.meta.title = titleOf(face.transcript);
+    try {
+      store.save(session);
+    } catch (e) {
+      err(dim(`  (session not saved: ${e?.message ?? e})
+`));
+    }
+  };
+  duplexAccount = (data) => {
+    if (!data?.usage?.totalTokens) return;
+    session.meta.tokens = (session.meta.tokens ?? 0) + data.usage.totalTokens;
+    session.meta.costUsd = (session.meta.costUsd ?? 0) + turnCost(work.model, data.usage);
+    if (data.usageEstimated) session.meta.costEstimated = true;
+    try {
+      store.save(session);
+    } catch {
+    }
+  };
   const fs = agent.options.fs;
   const fsBase = fs.getCwd() === "/" ? "" : fs.getCwd();
   const adot = (sub) => `${fsBase}/.agent/${sub}`;
@@ -6623,7 +6997,7 @@ async function repl(args, ai, cfg, cwd) {
       mkdirSync6(join8(cwd, ".agent"), { recursive: true });
       appendFileSync(histPath, line + "\n");
     } catch (e) {
-      log11.debug("history write failed", e);
+      log12.debug("history write failed", e);
     }
   };
   const ago = (t) => {
@@ -6631,7 +7005,7 @@ async function repl(args, ai, cfg, cwd) {
     return s < 60 ? "just now" : s < 3600 ? `${Math.floor(s / 60)}m ago` : s < 86400 ? `${Math.floor(s / 3600)}h ago` : `${Math.floor(s / 86400)}d ago`;
   };
   const resumeInto = (data) => {
-    agent.transcript = data.messages;
+    face.transcript = data.messages;
     session = data;
     checkpoints.use?.(data.meta.id);
     err(dim(`  resumed ${data.meta.id} (${data.meta.turns} turns)${data.meta.title ? " \u2014 " + data.meta.title : ""}
@@ -6639,7 +7013,7 @@ async function repl(args, ai, cfg, cwd) {
     printHistory(data.messages);
   };
   const rewindToMessage = async () => {
-    const users = agent.transcript.map((m, i) => ({ m, i })).filter((x) => x.m.role === "user");
+    const users = face.transcript.map((m, i) => ({ m, i })).filter((x) => x.m.role === "user");
     if (!users.length) {
       err(dim("  (no earlier messages to jump back to)\n"));
       return void 0;
@@ -6655,7 +7029,7 @@ async function repl(args, ai, cfg, cwd) {
     const idx = users[p].i;
     const frame = p - (users.length - checkpoints.size);
     let mode = "convo";
-    if (frame >= 0 && frame < checkpoints.size) {
+    if (!duplex && frame >= 0 && frame < checkpoints.size) {
       const m = await selectMenu(process.stderr, { title: "Restore\u2026", items: [
         { label: "Conversation and code", value: "both" },
         { label: "Conversation only", value: "convo" },
@@ -6664,7 +7038,7 @@ async function repl(args, ai, cfg, cwd) {
       if (m == null) return void 0;
       mode = m;
     }
-    const text = contentText(agent.transcript[idx].content).split("\n\n--- @")[0].trim();
+    const text = contentText(face.transcript[idx].content).split("\n\n--- @")[0].trim();
     if (mode === "code" || mode === "both") {
       try {
         const { restored, deleted } = await checkpoints.rewindTo(frame);
@@ -6676,14 +7050,14 @@ async function repl(args, ai, cfg, cwd) {
       }
     }
     if (mode === "convo" || mode === "both") {
-      agent.transcript = agent.transcript.slice(0, idx);
-      session.messages = agent.transcript;
+      face.transcript = face.transcript.slice(0, idx);
+      session.messages = face.transcript;
       try {
         store.save(session);
       } catch (e) {
-        log11.debug("session save after rewind failed", e);
+        log12.debug("session save after rewind failed", e);
       }
-      err(green("  \u27F2 jumped back") + dim(` \u2014 ${agent.transcript.length} message(s) kept; edit + resend
+      err(green("  \u27F2 jumped back") + dim(` \u2014 ${face.transcript.length} message(s) kept; edit + resend
 `));
       return text;
     }
@@ -6702,19 +7076,20 @@ async function repl(args, ai, cfg, cwd) {
     if (data) resumeInto(data);
     else err(red("  no such session\n"));
   };
+  const turn = (task) => runTurn(face, store, session, task, duplex ? void 0 : checkpoints, cwd, sendVia);
   const runSkill = async (sk, extra = "") => {
     try {
       const body = await fs.readFile(sk.path);
-      await runTurn(agent, store, session, extra ? `${body}
+      await turn(extra ? `${body}
 
-${extra}` : body, checkpoints, cwd);
+${extra}` : body);
     } catch (e) {
       err(red(`  couldn't load skill ${sk.name}: ${e?.message ?? e}
 `));
     }
   };
   const runCommand = async (c, extra = "") => {
-    await runTurn(agent, store, session, await expandCommand(fs, c, extra), checkpoints, cwd);
+    await turn(await expandCommand(fs, c, extra));
   };
   const pickAndRun = async (kind) => {
     const pool = kind === "skill" ? skills : cmds;
@@ -6771,15 +7146,21 @@ ${extra}` : body, checkpoints, cwd);
       desc: "show CLI version + runtime",
       run: () => {
         const rt = process.versions.bun ? `bun ${process.versions.bun}` : `node ${process.versions.node}`;
-        err(`  ${bold("agent.libx.js")} ${cyan("v" + VERSION)}${dim(` \xB7 ${agent.options.model} \xB7 ${rt}`)}
+        err(`  ${bold("agent.libx.js")} ${cyan("v" + VERSION)}${dim(` \xB7 ${duplex ? `voice ${dx.options.voiceModel} \xB7 worker ${work.model}` : work.model} \xB7 ${rt}`)}
 `);
       }
     },
-    tools: { desc: "list available tools", run: () => err(dim("  " + agent.options.tools.map((t) => t.name).join(", ") + "\n")) },
+    tools: {
+      desc: "list available tools",
+      run: () => {
+        if (duplex) err(dim("  voice:  " + face.options.tools.map((t) => t.name).join(", ") + "\n  worker: " + (work.tools ?? []).map((t) => t.name).join(", ") + "\n"));
+        else err(dim("  " + agent.options.tools.map((t) => t.name).join(", ") + "\n"));
+      }
+    },
     permissions: {
       desc: "show the active permission rules + default posture",
       run: () => {
-        const pol = agent.options.permissions;
+        const pol = work.permissions;
         const rules = pol?.options.rules ?? [];
         if (!rules.length) err(dim("  (no rules \u2014 default: " + (pol?.options.default ?? "allow") + ")\n"));
         else {
@@ -6793,19 +7174,22 @@ ${extra}` : body, checkpoints, cwd);
       desc: "session status \u2014 model, dir, fs-mode, permissions, tools, usage",
       run: () => {
         const mode = args.vfs ? "sandbox (VFS \u2014 disk untouched)" : args.boddb ? `boddb (database workspace at ${args.boddb} \u2014 disk untouched)` : args.shell ? "disk + real /bin/sh" : "disk (full real FS, like Claude Code)";
-        const pol = agent.options.permissions;
+        const pol = work.permissions;
         const perm = !pol ? "allow all (unattended)" : `${pol.options.rules.length} rule(s), default ${pol.options.default}`;
-        err(formatStatus({ model: agent.options.model, cwd, mode, tools: agent.options.tools.map((t) => t.name), permissions: perm, turns: session.meta.turns, tokens: session.meta.tokens ?? 0, sessionId: session.meta.id, estimated: session.meta.costEstimated ?? false }));
+        const model = duplex ? `voice ${dx.options.voiceModel} \xB7 worker ${work.model}` : work.model;
+        err(formatStatus({ model, cwd, mode, tools: (duplex ? work.tools ?? [] : agent.options.tools).map((t) => t.name), permissions: perm, turns: session.meta.turns, tokens: session.meta.tokens ?? 0, sessionId: session.meta.id, estimated: session.meta.costEstimated ?? false }));
+        if (duplex && dx.tasks.size) err(dim(`  tasks: ${[...dx.tasks.values()].map((t) => `${t.id}:${t.status}`).join(" ")}
+`));
       }
     },
     cost: {
       desc: "cumulative cost + token usage for this session",
       run: () => {
         const t = session.meta.tokens ?? 0, usd = session.meta.costUsd ?? 0;
-        const priced = getModelInfo(agent.options.model)?.pricing;
+        const priced = getModelInfo(work.model)?.pricing;
         const est = session.meta.costEstimated ?? false;
         const m = est ? "~" : "";
-        const note = priced ? est ? " (estimated \u2014 some turns streamed without usage)" : " (exact \u2014 provider-reported usage)" : ` (no pricing for ${agent.options.model})`;
+        const note = priced ? est ? " (estimated \u2014 some turns streamed without usage)" : " (exact \u2014 provider-reported usage)" : ` (no pricing for ${work.model})`;
         err(dim(`  ${usd > 0 ? m + fmtUsd(usd) + " \xB7 " : ""}${m}${(t / 1e3).toFixed(1)}k tokens across ${session.meta.turns} turn(s)${note}
 `));
       }
@@ -6813,9 +7197,9 @@ ${extra}` : body, checkpoints, cwd);
     context: {
       desc: "context-window usage (messages + estimated tokens)",
       run: () => {
-        const est = estimateTranscriptTokens(agent.transcript);
-        const cap = agent.options.maxTokens || 2e5;
-        err(dim(`  ${agent.transcript.length} message(s) \xB7 ~${(est / 1e3).toFixed(1)}k tokens (~${Math.round(est / cap * 100)}% of ${Math.round(cap / 1e3)}k budget)
+        const est = estimateTranscriptTokens(face.transcript);
+        const cap = face.options.maxTokens || 2e5;
+        err(dim(`  ${face.transcript.length} message(s) \xB7 ~${(est / 1e3).toFixed(1)}k tokens (~${Math.round(est / cap * 100)}% of ${Math.round(cap / 1e3)}k budget)
 `));
       }
     },
@@ -6846,26 +7230,21 @@ ${extra}` : body, checkpoints, cwd);
       }
     },
     model: {
-      desc: "switch model \u2014 /model <id>, or /model alone for an interactive picker",
+      desc: "switch model \u2014 /model <id>, or /model alone for an interactive picker (duplex: the worker model)",
       run: async (a) => {
         if (a[0]) {
-          agent.options.model = a[0];
-          persistModel(cwd, a[0]);
-          err(dim("  model \u2192 " + a[0] + "\n"));
+          setModel(a[0]);
           return;
         }
-        const picked = await pickModel(agent.options.model);
-        if (picked) {
-          agent.options.model = picked;
-          persistModel(cwd, picked);
-          err(dim("  model \u2192 " + picked + "\n"));
-        } else err(dim("  " + agent.options.model + "\n"));
+        const picked = await pickModel(work.model);
+        if (picked) setModel(picked);
+        else err(dim("  " + (duplex ? `voice ${dx.options.voiceModel} \xB7 worker ${work.model}` : work.model) + "\n"));
       }
     },
     reasoning: {
-      desc: "extended thinking \u2014 /reasoning <off|low|medium|high|tokens>, or alone for an interactive picker",
+      desc: "extended thinking \u2014 /reasoning <off|low|medium|high|tokens>, or alone for an interactive picker (duplex: the workers')",
       run: async (a) => {
-        const current = String(agent.options.reasoning ?? "off");
+        const current = String(work.reasoning ?? "off");
         let next;
         if (a[0]) {
           try {
@@ -6888,9 +7267,9 @@ ${extra}` : body, checkpoints, cwd);
           }
           next = picked;
         }
-        agent.options.reasoning = next;
-        if (next !== "off" && getModelInfo(agent.options.model)?.reasoning === false)
-          err(yellow(`  note: ${agent.options.model} has no reasoning capability \u2014 setting may be ignored
+        work.reasoning = next;
+        if (next !== "off" && getModelInfo(work.model)?.reasoning === false)
+          err(yellow(`  note: ${work.model} has no reasoning capability \u2014 setting may be ignored
 `));
         err(dim("  reasoning \u2192 " + next + "\n"));
       }
@@ -6900,23 +7279,21 @@ ${extra}` : body, checkpoints, cwd);
       run: async () => {
         for (; ; ) {
           const items = [
-            { label: "model", value: "model", desc: agent.options.model },
-            { label: "reasoning", value: "reasoning", desc: String(agent.options.reasoning ?? "off") },
+            { label: "model", value: "model", desc: work.model },
+            { label: "reasoning", value: "reasoning", desc: String(work.reasoning ?? "off") },
             { label: "permission posture", value: "posture", desc: postureLabel() + "  (Shift+Tab)" },
-            { label: "streaming", value: "stream", desc: agent.options.stream ? "on" : "off" },
+            // streaming is the voice's lifeblood in duplex (always on) — only a normal-mode knob
+            ...duplex ? [] : [{ label: "streaming", value: "stream", desc: agent.options.stream ? "on" : "off" }],
             { label: "editor mode", value: "editor", desc: cfg.editorMode === "vim" ? "vim" : "normal" }
           ];
           const pick = await selectMenu(process.stderr, { title: "Settings \xB7 \u21B5 change \xB7 esc close", items });
           if (!pick) return;
           if (pick === "model") {
-            const m = await pickModel(agent.options.model);
-            if (m) {
-              agent.options.model = m;
-              persistModel(cwd, m);
-            }
+            const m = await pickModel(work.model);
+            if (m) setModel(m);
           } else if (pick === "reasoning") {
             await builtins.reasoning.run([]);
-            persistSetting(cwd, "reasoning", agent.options.reasoning ?? "off");
+            persistSetting(cwd, "reasoning", work.reasoning ?? "off");
           } else if (pick === "posture") {
             cyclePosture();
             persistSetting(cwd, "permissionMode", posture);
@@ -6951,8 +7328,8 @@ ${extra}` : body, checkpoints, cwd);
     compact: {
       desc: "summarize older context to free up the window",
       run: () => {
-        const n = agent.compactNow();
-        session.messages = agent.transcript;
+        const n = face.compactNow();
+        session.messages = face.transcript;
         try {
           store.save(session);
         } catch {
@@ -6999,8 +7376,8 @@ ${extra}` : body, checkpoints, cwd);
     clear: {
       desc: "start a fresh conversation (and clear the screen)",
       run: () => {
-        agent.transcript = [];
-        session = startSession({ ...args, cont: false, resume: void 0 }, store, agent, cwd);
+        face.transcript = [];
+        session = startSession({ ...args, cont: false, resume: void 0 }, store, face, cwd);
         err("\x1Bc");
       }
     },
@@ -7038,13 +7415,13 @@ ${extra}` : body, checkpoints, cwd);
             err(green(`  \u2713 authorized "${name}"`) + dim(" \u2014 remounting with the new token\n"));
             const idx = mounted.findIndex((m2) => m2.name === name);
             if (idx >= 0) {
-              agent.removeTools(mounted[idx].tools.map((t) => t.name));
+              removeWorkTools(mounted[idx].tools.map((t) => t.name));
               await mounted.splice(idx, 1)[0].client.close().catch(() => {
               });
             }
             const m = await mountMcpServer(name, { ...target, bearerToken: await oauth.tokenFor(target.url) });
             mounted.push(m);
-            agent.addTools(m.tools);
+            addWorkTools(m.tools);
             err(green(`  \u2713 ${m.name}`) + dim(` \u2014 ${m.tools.length} tool(s)
 `));
           } catch (e) {
@@ -7069,7 +7446,7 @@ ${extra}` : body, checkpoints, cwd);
           try {
             const m = await mountMcpServer(name, cfg2);
             mounted.push(m);
-            agent.addTools(m.tools);
+            addWorkTools(m.tools);
             err(green(`  \u2713 ${m.name}`) + dim(` \u2014 ${m.tools.length} tool(s)${m.serverInfo?.name ? ` from ${m.serverInfo.name}` : ""}
 `));
           } catch (e) {
@@ -7091,8 +7468,8 @@ ${extra}` : body, checkpoints, cwd);
             return;
           }
           const m = mounted.splice(idx, 1)[0];
-          agent.removeTools(m.tools.map((t) => t.name));
-          await m.client.close().catch((e) => log11.debug("mcp close failed", e));
+          removeWorkTools(m.tools.map((t) => t.name));
+          await m.client.close().catch((e) => log12.debug("mcp close failed", e));
           err(dim(`  removed "${name}"
 `));
           return;
@@ -7191,7 +7568,7 @@ ${extra}` : body, checkpoints, cwd);
           return;
         }
         const msg = a.join(" ").trim();
-        if (msg) await runTurn(agent, store, session, `${msg} ${att.ref}`, checkpoints, cwd);
+        if (msg) await turn(`${msg} ${att.ref}`);
         else {
           pendingImages.push(att.path);
           err(green(`  \u2713 image attached (#${pendingImages.length})`) + dim(" \u2014 type your message to send it\n"));
@@ -7201,7 +7578,7 @@ ${extra}` : body, checkpoints, cwd);
     export: {
       desc: "save this conversation to Markdown \u2014 /export [path] (default ./.agent/exports/<id>.md)",
       run: (a) => {
-        const shown = agent.transcript.filter((m) => m.role !== "system");
+        const shown = face.transcript.filter((m) => m.role !== "system");
         if (!shown.length) {
           err(dim("  (nothing to export yet)\n"));
           return;
@@ -7224,14 +7601,16 @@ ${extra}` : body, checkpoints, cwd);
     exit: { desc: "quit", run: () => true },
     quit: { desc: "quit", run: () => true }
   };
-  err(bold("agent.libx.js") + cyan(" v" + VERSION) + dim(` \u2014 ${agent.options.model} \xB7 ${cwd}
+  err(bold("agent.libx.js") + cyan(" v" + VERSION) + dim(` \u2014 ${work.model} \xB7 ${cwd}
 `));
   err(dim("Type a task, or /help. Type / or @ for live suggestions (\u2191/\u2193 \u23CE). Esc cancels/clears; double-Esc jumps back; Ctrl-D exits.\n"));
+  if (dx) err(dim(`\u25D1 duplex \u2014 voice: ${dx.options.voiceModel} \xB7 worker: ${work.model} (real work runs in background tasks, re-voiced when done)
+`));
   const listDir = (absDir) => {
     try {
       return readdirSync2(join8(cwd, absDir.replace(/^\/+/, "")), { withFileTypes: true }).map((d) => ({ name: d.name, dir: d.isDirectory() }));
     } catch (e) {
-      log11.debug("completion readdir failed", absDir, e);
+      log12.debug("completion readdir failed", absDir, e);
       return null;
     }
   };
@@ -7247,6 +7626,10 @@ ${extra}` : body, checkpoints, cwd);
   if (process.stdin.isTTY) {
     process.stdin.on("keypress", (_s, key) => {
       if (!activeTurn) return;
+      if (key?.ctrl && key?.name === "o") {
+        toggleVerbose();
+        return;
+      }
       const cancel = key?.name === "escape" || key?.ctrl && key?.name === "c";
       if (!cancel) return;
       if (!aborting) {
@@ -7272,6 +7655,7 @@ ${extra}` : body, checkpoints, cwd);
     process.stdin.pause();
   };
   let prefill;
+  let tick = 0;
   while (true) {
     if (pendingRewind) {
       pendingRewind = false;
@@ -7282,16 +7666,21 @@ ${extra}` : body, checkpoints, cwd);
     err("\n");
     const initial = prefill;
     prefill = void 0;
-    const ctxTok = estimateTranscriptTokens(agent.transcript);
-    const ctxCap = agent.options.maxTokens || 2e5;
+    const ctxTok = estimateTranscriptTokens(face.transcript);
+    const ctxCap = face.options.maxTokens || 2e5;
     const usd = session.meta.costUsd ?? 0;
     const computeFooter = () => {
       const parts = [];
       if (ctxTok > 400) parts.push(`${Math.round(ctxTok / ctxCap * 100)}% ctx (~${(ctxTok / 1e3).toFixed(1)}k/${Math.round(ctxCap / 1e3)}k)`);
       if (usd > 0) parts.push(`${session.meta.costEstimated ? "~" : ""}${fmtUsd(usd)}`);
       if (posture !== "default") parts.push(postureLabel());
-      const r = agent.options.reasoning;
+      const r = work.reasoning;
       if (r && r !== "off") parts.push(`reasoning:${r}`);
+      if (verboseOutput) parts.push("verbose");
+      if (dx?.tasks.size) {
+        const frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+        parts.push(`tasks: ${[...dx.tasks.values()].map((t) => t.status === "running" ? `${frames[tick++ % frames.length]} ${t.id} working\u2026` : `${t.id}:${t.status}`).join(" ")}`);
+      }
       return parts.join(" \xB7 ");
     };
     const result = await readMultiline((cont) => editor.readLine({
@@ -7303,15 +7692,14 @@ ${extra}` : body, checkpoints, cwd);
       initial: cont ? void 0 : initial,
       status: computeFooter,
       vimMode: cfg.editorMode === "vim",
+      statusTickMs: dx ? 1e3 : void 0,
+      // duplex: animate the running-task footer while idle at the prompt
       onCyclePosture: cyclePosture,
       onToggleThinking: toggleReasoning,
+      onToggleVerbose: toggleVerbose,
       onPickModel: async () => {
-        const picked = await pickModel(agent.options.model);
-        if (picked) {
-          agent.options.model = picked;
-          persistModel(cwd, picked);
-          err(dim("  model \u2192 " + picked + "\n"));
-        }
+        const picked = await pickModel(work.model);
+        if (picked) setModel(picked);
         return picked;
       }
     }));
@@ -7369,7 +7757,17 @@ ${extra}` : body, checkpoints, cwd);
     }
     const task = pendingImages.length ? `${line} ${pendingImages.map((p) => "@" + p).join(" ")}` : line;
     pendingImages.length = 0;
-    await runTurn(agent, store, session, task, checkpoints, cwd);
+    await turn(task);
+  }
+  if (dx) {
+    const running = [...dx.tasks.values()].filter((t) => t.status === "running").length;
+    if (running) {
+      err(dim(`  \u2026 waiting for ${running} background task(s) (Ctrl-C to force quit)
+`));
+      await dx.idle();
+      face.options.host?.flushText?.();
+      duplexPersist();
+    }
   }
   releaseStdin();
   await closeMcp(mounted);