agent.libx.js 0.89.9 → 0.92.2

package/dist/cli.js

@@ -852,6 +852,17 @@ ${out}`.trim() : out || "(command succeeded, no output)";
   );
   return `Started background job ${id} \u2014 poll with JobOutput({id:"${id}"}) / JobStatus, stop with JobKill.`;
 }
+function exitSessionTool(onExit) {
+  return {
+    name: "ExitSession",
+    description: `End the current session and exit the CLI. Call this when the user says goodbye, asks to quit, or clearly indicates they want to stop the conversation (e.g. "ok bye", "that's all", "exit", "goodnight").`,
+    parameters: { type: "object", properties: {} },
+    async run() {
+      onExit();
+      return "Session ending. Goodbye!";
+    }
+  };
+}
 function defaultTools() {
   return [bashTool, readTool, editTool];
 }
@@ -1363,7 +1374,7 @@ function makeRealShellTool(options) {
         const id = await options.registry.start(cmd);
         return `Started background job ${id}. Poll output with ShellOutput({id:"${id}"}), check ShellStatus({id:"${id}"}), stop with ShellKill({id:"${id}"}).`;
       }
-      const spawn2 = options.spawn ?? await nodeSpawn();
+      const spawn3 = options.spawn ?? await nodeSpawn();
       const ctl = new AbortController();
       const onAbort = () => ctl.abort();
       if (ctx.signal) {
@@ -1386,7 +1397,7 @@ function makeRealShellTool(options) {
           };
           let proc;
           try {
-            proc = spawn2("/bin/sh", ["-c", cmd], { cwd: options.cwd, env: childEnv(options), signal: ctl.signal });
+            proc = spawn3("/bin/sh", ["-c", cmd], { cwd: options.cwd, env: childEnv(options), signal: ctl.signal });
           } catch (e) {
             return finish(`[exit 1] failed to spawn shell: ${e?.message ?? e}`);
           }
@@ -1397,7 +1408,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)));
-            log8.debug("shell spawn error", err2);
+            log11.debug("shell spawn error", err2);
             finish(`[exit 1] ${err2?.message ?? err2}${out ? "\n" + clean(out) : ""}`);
           });
           proc.on("close", (code) => {
@@ -1457,14 +1468,14 @@ ${clean(out) || "(no output yet)"}`;
     }
   ];
 }
-var log8, clean, SECRET_ENV_RE, _spawn, ShellJobRegistry, NO_JOB2;
+var log11, 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();
-    log8 = forComponent("shell");
+    log11 = 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 {
@@ -1484,8 +1495,8 @@ var init_tools_shell = __esm({
           job.buf = (job.buf + s).slice(-max);
         };
         try {
-          const spawn2 = this.cfg.spawn ?? await nodeSpawn();
-          const proc = spawn2("/bin/sh", ["-c", command], { cwd: this.cfg.cwd, env: childEnv(this.cfg) });
+          const spawn3 = this.cfg.spawn ?? await nodeSpawn();
+          const proc = spawn3("/bin/sh", ["-c", command], { cwd: this.cfg.cwd, env: childEnv(this.cfg) });
           job.proc = proc;
           proc.stdout?.on("data", append);
           proc.stderr?.on("data", append);
@@ -1542,8 +1553,8 @@ var init_tools_shell = __esm({
 
 // cli/cli.ts
 import { createInterface } from "readline/promises";
-import { existsSync as existsSync7, readFileSync as readFileSync5, appendFileSync, mkdirSync as mkdirSync6, writeFileSync as writeFileSync6, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
-import { homedir as homedir4, tmpdir } from "os";
+import { existsSync as existsSync8, readFileSync as readFileSync5, appendFileSync, mkdirSync as mkdirSync7, writeFileSync as writeFileSync6, readdirSync as readdirSync2, statSync as statSync3 } from "fs";
+import { homedir as homedir5, tmpdir } from "os";
 
 // cli/clipboard.ts
 import { execFileSync } from "child_process";
@@ -1599,7 +1610,7 @@ close access f`;
 }
 
 // cli/cli.ts
-import { join as join8, resolve as resolve3, basename as basename2, extname, dirname as dirname3 } from "path";
+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";
 
 // src/llm.ts
@@ -2839,7 +2850,15 @@ var Agent = class _Agent {
       toolCallsTotal += toolCalls.length;
       if (o.maxToolCalls && toolCallsTotal > o.maxToolCalls) return kill("max_tool_calls");
       for (const tc of toolCalls) {
-        const content = await this.dispatch(tc);
+        const raw = await this.dispatch(tc);
+        let content;
+        if (typeof raw === "string") {
+          content = raw;
+        } else {
+          const parts = [{ type: "text", text: raw.text }];
+          for (const img of raw.images ?? []) parts.push(imagePart(`data:${img.mimeType};base64,${img.data}`));
+          content = parts;
+        }
         this.transcript.push({ role: "tool", tool_call_id: tc.id, name: tc.function.name, content });
       }
     }
@@ -2896,10 +2915,17 @@ var Agent = class _Agent {
       return earlyError;
     }
     let result;
+    let images;
     let threw = false;
     try {
       log3.debug(`${tc.function.name}(${tc.function.arguments})`);
-      result = await tool.run(args, this.ctx);
+      const raw = await tool.run(args, this.ctx);
+      if (typeof raw === "string") {
+        result = raw;
+      } else {
+        result = raw.text;
+        images = raw.images;
+      }
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e);
       log3.debug(`${tc.function.name} -> error: ${msg}`);
@@ -2909,7 +2935,12 @@ var Agent = class _Agent {
     if (!threw) result = await this.maybeAutoTest(tc.function.name, result);
     await hooks?.postToolUse?.(call, result, meta);
     this.options.host?.notify?.({ kind: "tool_result", id: tc.id ?? "", output: result, isError: threw });
-    return result;
+    if (images?.length) {
+      for (const img of images) {
+        this.options.host?.notify?.({ kind: "tool_result_image", id: tc.id ?? "", dataUrl: `data:${img.mimeType};base64,${img.data}` });
+      }
+    }
+    return images?.length ? { text: result, images } : result;
   }
   static WRITE_CLASS = ["Write", "Edit", "MultiEdit", "ApplyEdits"];
   /** Append an autoTest failure section to a write-class tool result, if configured. */
@@ -3352,6 +3383,11 @@ function digestRun(messages, maxChars) {
 import { MemFilesystem as MemFilesystem2 } from "@livx.cc/wcli/core";
 init_logging();
 var log6 = forComponent("DuplexAgent");
+function describeCall(call) {
+  const v = call.args && Object.values(call.args).find((x) => typeof x === "string" && x.trim());
+  const hint = v ? ` (${String(v).replace(/\s+/g, " ").trim().slice(0, 48)})` : "";
+  return `${call.name}${hint}`;
+}
 var DuplexAgentOptions = class {
   /** Any ai.libx.js AIClient — shared by the voice and worker agents (routed by model). */
   ai;
@@ -3372,8 +3408,16 @@ var DuplexAgentOptions = class {
   /** Awaited BEFORE a delegated worker spawns — open a per-task checkpoint frame, audit, etc.
    *  (post-spawn would race the worker's first edits). */
   onTaskStart;
+  /** Re-voice throttled worker progress asides ('[task t1 progress] …') so long tasks aren't dead
+   *  air. Off by default — each update costs a voice turn (LLM call + speech). */
+  progressUpdates = false;
+  /** Min ms between progress re-voices per task. */
+  progressIntervalMs = 25e3;
+  /** Host overrides for QuickLook lookups (keyed by `what`). The engine's defaults go through the
+   *  (possibly jailed) fs — e.g. `.git/**` is deny-listed, so the CLI supplies 'branch' itself. */
+  quickLook;
 };
-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_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. "[task t1 progress] \u2026" events are interim status, NOT results \u2014 give at most a half-sentence aside ("still on it \u2014 running tests now") and end your turn. Never present progress as a finished result.\nNever 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.\nPRIORITY: when the user says goodbye or wants to end/finish/wrap up the session ("ok bye", "that\'s all", "let\'s finish", "let\'s end", "goodnight", "exit", "wrap up"), call `ExitSession` IMMEDIATELY \u2014 do not delegate, do not check status, just exit.\nFor TRIVIAL instant lookups only \u2014 current time, git branch, listing a folder, peeking at a small file \u2014 use `QuickLook` (instant, no task). Anything requiring searching, reasoning, running commands, or editing still goes through `Delegate`.\nNEVER claim to have stored, saved, or remembered something durably \u2014 you cannot. Anything the user wants persisted (their name, preferences, notes) must be Delegated so a worker writes it to memory.\nUser messages may arrive via speech-to-text and can carry transcription artifacts \u2014 odd words, cut-offs, homophones ("for you" vs "folder"). Read for INTENT, not surface text. If a message seems garbled or surprising, briefly confirm what they meant ("did you mean\u2026?") instead of answering the literal words.';
 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;
@@ -3393,7 +3437,10 @@ var DuplexAgent = class {
       model: o.voiceModel,
       stream: true,
       host: o.host,
-      systemPrompt: VOICE_SYSTEM_PROMPT + (o.voiceStyle === "conversational" ? "\n" + VOICE_STYLE_CONVERSATIONAL : ""),
+      // Runtime context line: without it the voice confidently invents "facts" like today's date
+      // (its training cutoff) instead of delegating or admitting it doesn't know.
+      systemPrompt: VOICE_SYSTEM_PROMPT + (o.voiceStyle === "conversational" ? "\n" + VOICE_STYLE_CONVERSATIONAL : "") + `
+Today's date: ${(/* @__PURE__ */ new Date()).toDateString()}.`,
       instructionFiles: false,
       maxSteps: 8,
       // a voice turn should never loop
@@ -3402,7 +3449,7 @@ var DuplexAgent = class {
       // 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()]
+      tools: [...o.voiceOptions?.tools ?? [], this.delegateTool(), this.taskStatusTool(), this.cancelTaskTool(), this.quickLookTool()]
     });
   }
   /** One user turn: the voice agent streams the reply (and may Delegate). Serialized with re-voice turns. */
@@ -3455,18 +3502,69 @@ ${recent}` : brief;
   spawnWorker(id, label, briefText) {
     const o = this.options;
     const controller = new AbortController();
+    const base = o.workerOptions?.hooks;
+    const report = o.progressUpdates ? this.progressReporter(id) : void 0;
+    const hooks = report ? {
+      ...base,
+      preToolUse: async (call, meta) => {
+        const d = await base?.preToolUse?.(call, meta);
+        report.pre(call);
+        return d;
+      },
+      postToolUse: async (call, result, meta) => {
+        await base?.postToolUse?.(call, result, meta);
+        report.post(call);
+      }
+    } : base;
     const worker = new Agent({
       ai: o.ai,
       fs: o.fs,
       model: o.workerModel,
       ...o.workerOptions,
       // may override ai/fs/model/tools/… —
+      ...hooks ? { hooks } : {},
       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 });
   }
+  /** Throttled per-task progress: worker tool calls → at most one progress re-voice per interval.
+   *  Two sources, one throttle: completed steps (post) and a heartbeat for a SINGLE long tool call
+   *  (pre records the in-flight call; a self-cleaning timer narrates "still inside Bash — 70s").
+   *  Completion supersedes: nothing is emitted once the task has settled. */
+  progressReporter(id) {
+    let lastAt = Date.now();
+    let steps = 0;
+    let inflight = null;
+    const due = () => {
+      const rec = this.tasks.get(id);
+      return rec && rec.status === "running" && Date.now() - lastAt >= this.options.progressIntervalMs ? rec : void 0;
+    };
+    const emit = (rec, line, call) => {
+      lastAt = Date.now();
+      this.notify("task_progress", `task ${id} (${rec.label}): ${line}`, { id, steps, call: call.name });
+      this.queueRevoice(`[task ${id} progress] ${line}`);
+    };
+    const timer = setInterval(() => {
+      const rec = this.tasks.get(id);
+      if (!rec || rec.status !== "running") return clearInterval(timer);
+      if (!inflight || !due()) return;
+      emit(rec, `still inside ${describeCall(inflight.call)} \u2014 ${Math.round((Date.now() - inflight.at) / 1e3)}s on this step`, inflight.call);
+    }, Math.max(this.options.progressIntervalMs, 250));
+    timer.unref?.();
+    return {
+      pre: (call) => {
+        inflight = { call, at: Date.now() };
+      },
+      post: (call) => {
+        steps++;
+        inflight = null;
+        const rec = due();
+        if (rec) emit(rec, `still running \u2014 ${steps} steps so far, now: ${describeCall(call)}`, call);
+      }
+    };
+  }
   onWorkerSettled(id, res) {
     const rec = this.tasks.get(id);
     if (res.finishReason === "aborted" || rec.status === "cancelled") {
@@ -3527,6 +3625,58 @@ ${recent}` : brief;
       }
     };
   }
+  /** Sub-100ms read-only lookups the voice may do itself — everything else stays Delegate-only.
+   *  fs-only (no shell; the engine is VFS-abstracted): time, git branch (.git/HEAD read), ls, file
+   *  head. Output is hard-capped so a lookup can never bloat the skinny voice context. */
+  quickLookTool() {
+    const CAP2 = 2e3;
+    const kinds = [.../* @__PURE__ */ new Set(["time", "branch", "ls", "file", ...Object.keys(this.options.quickLook ?? {})])];
+    return {
+      name: "QuickLook",
+      description: `Instant read-only lookup \u2014 one of: ${kinds.join(", ")}. For trivial facts only; anything needing search, commands, or reasoning goes through Delegate.`,
+      parameters: {
+        type: "object",
+        required: ["what"],
+        properties: {
+          what: { type: "string", enum: kinds, description: "what to look up" },
+          path: { type: "string", description: "for ls/file: the path to look at" }
+        }
+      },
+      run: async ({ what, path }) => {
+        const fs = this.options.fs;
+        try {
+          const over = this.options.quickLook?.[String(what)];
+          if (over) return await over(path ? String(path) : void 0);
+          switch (String(what)) {
+            case "time":
+              return (/* @__PURE__ */ new Date()).toString();
+            case "branch": {
+              if (!fs) return "unavailable (no filesystem)";
+              const head = (await fs.readFile(".git/HEAD")).trim();
+              return head.startsWith("ref: refs/heads/") ? `branch: ${head.slice("ref: refs/heads/".length)}` : `detached HEAD at ${head.slice(0, 12)}`;
+            }
+            case "ls": {
+              if (!fs) return "unavailable (no filesystem)";
+              const names = await fs.readDir(String(path ?? "."));
+              return names.slice(0, 50).join("\n") + (names.length > 50 ? `
+\u2026 (+${names.length - 50} more)` : "");
+            }
+            case "file": {
+              if (!fs) return "unavailable (no filesystem)";
+              if (!path) return "file lookup needs a path";
+              const text = await fs.readFile(String(path));
+              return text.length > CAP2 ? text.slice(0, CAP2) + `
+\u2026 (truncated \u2014 ${text.length} chars total; Delegate for the full file)` : text;
+            }
+            default:
+              return `unknown lookup '${what}'`;
+          }
+        } catch (e) {
+          return `lookup failed: ${e?.message ?? e}`;
+        }
+      }
+    };
+  }
   cancelTaskTool() {
     return {
       name: "CancelTask",
@@ -3545,15 +3695,26 @@ ${recent}` : brief;
 };
 
 // src/mcp.ts
-function toText(result) {
-  if (result == null) return "";
-  if (typeof result === "string") return result;
+function toResult(result) {
+  if (result == null) return { text: "" };
+  if (typeof result === "string") return { text: result };
   const content = result.content;
   if (Array.isArray(content)) {
-    const text = content.map((c) => typeof c?.text === "string" ? c.text : JSON.stringify(c)).join("\n");
-    if (text) return text;
+    const texts = [];
+    const images = [];
+    for (const c of content) {
+      if (c?.type === "image" && typeof c.data === "string" && c.mimeType) {
+        images.push({ mimeType: c.mimeType, data: c.data });
+      } else if (typeof c?.text === "string") {
+        texts.push(c.text);
+      } else {
+        texts.push(JSON.stringify(c));
+      }
+    }
+    const text = texts.join("\n");
+    if (text || images.length) return { text, ...images.length ? { images } : {} };
   }
-  return JSON.stringify(result);
+  return { text: JSON.stringify(result) };
 }
 function mcpToolToAgentTool(spec, callTool, prefix = "mcp__") {
   return {
@@ -3561,7 +3722,8 @@ function mcpToolToAgentTool(spec, callTool, prefix = "mcp__") {
     description: spec.description ?? `MCP tool ${spec.name}`,
     parameters: spec.inputSchema ?? { type: "object", properties: {} },
     async run(args, _ctx) {
-      return toText(await callTool(spec.name, args ?? {}));
+      const r = toResult(await callTool(spec.name, args ?? {}));
+      return r.images?.length ? r : r.text;
     }
   };
 }
@@ -3571,12 +3733,470 @@ function mcpToolsToAgentTools(specs, callTool, prefix = "mcp__", filter) {
 
 // src/index.ts
 init_logging();
+
+// src/voice/engine.ts
+init_logging();
+var log7 = forComponent("VoiceEngine");
+var now = () => performance.now();
+var VoiceEngineOptions = class {
+  stt;
+  tts;
+  player;
+  /** a final utterance arrived (endpoint) — host dispatches it as a turn */
+  onUtterance = () => {
+  };
+  /** live partial transcript while listening (host renders the 🎤 line) */
+  onPartial = () => {
+  };
+  onState = () => {
+  };
+  /** user spoke/acted over playback — host aborts the in-flight turn (called AFTER audio is killed).
+   *  phase: 'speaking' = cut mid-speech (real interruption); 'drain' = in the final audio tail
+   *  (normal turn-taking — hosts shouldn't alarm). */
+  onBargeIn = () => {
+  };
+  /** spoken micro-ack on utterance endpoint (masks LLM TTFT); '' disables */
+  ackPhrase = "";
+  /** Endpoint merge window (ms): hold an endpointed utterance briefly — if speech resumes (spelled
+   *  letters, mid-thought pauses), the next utterance MERGES instead of dispatching a truncated one
+   *  ("E-L-Y." / "A."). Costs this much latency per turn; 0 disables. */
+  utteranceMergeMs = 350;
+  /** heuristic (non-AEC) energy barge-in tuning */
+  bargeRmsMult = 2;
+  bargeRmsFloor = 500;
+};
+var VoiceEngine = class {
+  options;
+  state = "idle";
+  stt;
+  tts;
+  player;
+  speaking = false;
+  // audible (deltas flowing OR audio draining)
+  ctxOpen = false;
+  // the current TTS context still accepts deltas (false once end-frame sent)
+  interrupted = false;
+  // barge-in latch: drop in-flight deltas until the next legitimate turn
+  spokeDeltas = false;
+  // a TTS context is open for the current spoken turn
+  drainTimer = null;
+  // heuristic tier state (inert under AEC) — frozen as validated in the experiment
+  echoWords = /* @__PURE__ */ new Set();
+  prevReply = "";
+  reply = "";
+  echoUntil = 0;
+  baseline = 0;
+  hot = 0;
+  suspectUntil = 0;
+  ackAt = 0;
+  // when the micro-ack was spoken — its echo can leak before the AEC filter converges
+  pendingUtt = "";
+  // endpointed text held for the merge window
+  pendingTimer = null;
+  lastInterrupted = null;
+  constructor(options) {
+    this.options = { ...new VoiceEngineOptions(), ...options };
+    const o = this.options;
+    if (!o.stt || !o.tts || !o.player) throw new Error("VoiceEngine needs stt, tts and player (see cli/voice.ts VoiceIO for platform defaults)");
+    this.stt = o.stt;
+    this.tts = o.tts;
+    this.player = o.player;
+  }
+  async start() {
+    this.tts.onAudio = (c) => {
+      if (this.speaking) this.player.write(c);
+    };
+    this.stt.onPartial = (text) => this.handlePartial(text);
+    this.stt.onUtterance = (text) => this.handleUtterance(text);
+    this.stt.onLevel = (rms) => this.handleLevel(rms);
+    await Promise.all([this.tts.connect(), this.stt.start()]);
+    this.setState("listening");
+    log7.info(`voice I/O up (${this.stt.usingAec ? "AEC" : "heuristic echo"} capture)`);
+  }
+  get usingAec() {
+    return this.stt.usingAec;
+  }
+  idleWaiters = [];
+  setState(s) {
+    if (this.state === s) return;
+    this.state = s;
+    this.options.onState(s);
+    if (s !== "speaking" && s !== "thinking") {
+      for (const r of this.idleWaiters.splice(0)) r();
+    }
+  }
+  /** Resolve when the engine is no longer speaking (immediate if already idle). */
+  awaitIdle() {
+    if (this.state !== "speaking" && this.state !== "thinking") return Promise.resolve();
+    return new Promise((r) => this.idleWaiters.push(r));
+  }
+  // --- speaking side (host-driven) ---
+  /** open a spoken turn (idempotent — safe from both onUtterance and first-delta paths).
+   *  `ack` speaks the configured micro-ack as the context opener (utterance path only —
+   *  masks LLM TTFT; re-voice turns begun by their first delta skip it). */
+  beginSpeech(ack = false) {
+    if (this.speaking && this.ctxOpen) return;
+    if (this.drainTimer) {
+      clearTimeout(this.drainTimer);
+      this.drainTimer = null;
+    }
+    this.interrupted = false;
+    if (!this.speaking) this.player.markTurn();
+    this.speaking = true;
+    this.ctxOpen = true;
+    this.spokeDeltas = false;
+    this.reply = "";
+    this.echoWords = new Set(this.words(this.prevReply));
+    this.tts.newContext();
+    if (ack && this.options.ackPhrase) {
+      this.tts.speak(this.options.ackPhrase + " ", true);
+      this.spokeDeltas = true;
+      this.ackAt = now();
+    }
+    this.setState("thinking");
+  }
+  speakDelta(text) {
+    if (this.interrupted) return;
+    if (!this.speaking || !this.ctxOpen) this.beginSpeech();
+    this.reply += text;
+    for (const w of this.words(this.reply)) this.echoWords.add(w);
+    this.tts.speak(text, true);
+    this.spokeDeltas = true;
+    this.setState("speaking");
+  }
+  /** close the spoken turn (idempotent); stays audible until ALL audio arrived AND playback drains */
+  endSpeech() {
+    this.interrupted = false;
+    if (!this.speaking) return;
+    this.ctxOpen = false;
+    if (this.reply) this.prevReply = this.reply;
+    const settle = () => {
+      if (this.ctxOpen) {
+        this.drainTimer = null;
+        return;
+      }
+      this.drainTimer = null;
+      this.speaking = false;
+      this.echoUntil = now() + 2500;
+      if (!this.usingAec) this.stt.reset();
+      this.setState("listening");
+    };
+    const drainThenSettle = () => {
+      if (this.drainTimer) clearTimeout(this.drainTimer);
+      this.drainTimer = setTimeout(settle, this.player.drainMs() + 300);
+    };
+    if (this.spokeDeltas) {
+      this.tts.onDone = drainThenSettle;
+      this.tts.end();
+      if (this.drainTimer) clearTimeout(this.drainTimer);
+      this.drainTimer = setTimeout(drainThenSettle, 15e3);
+    } else drainThenSettle();
+  }
+  /** text of the reply cut by the last barge-in — consumed by the host to tell the model what
+   *  the user did NOT hear. Cleared on read. */
+  takeInterruptedReply() {
+    const r = this.lastInterrupted;
+    this.lastInterrupted = null;
+    return r;
+  }
+  /** barge-in: stop audio NOW, cancel generation, reset for the user's utterance */
+  interrupt() {
+    if (!this.speaking && !this.drainTimer) return;
+    if (this.drainTimer) {
+      clearTimeout(this.drainTimer);
+      this.drainTimer = null;
+    }
+    const heardChars = Math.round(Math.max(0, this.player.playedMs()) / 1e3 * 15);
+    if (this.reply) this.lastInterrupted = { full: this.reply, heard: this.reply.slice(0, heardChars) };
+    this.speaking = false;
+    this.ctxOpen = false;
+    this.interrupted = true;
+    this.suspectUntil = 0;
+    this.echoUntil = now() + 2500;
+    this.tts.cancel();
+    this.player.kill();
+    if (!this.usingAec) this.stt.reset();
+    if (this.reply) this.prevReply = this.reply;
+    this.setState("listening");
+  }
+  stop() {
+    if (this.pendingTimer) clearTimeout(this.pendingTimer);
+    if (this.drainTimer) clearTimeout(this.drainTimer);
+    this.stt.stop();
+    this.player.kill();
+    this.tts.close();
+    this.setState("idle");
+  }
+  // --- listening side (STT-driven) ---
+  words(s) {
+    return s.toLowerCase().replace(/[^a-z0-9\s]/g, "").split(/\s+/).filter((w) => w.length >= 2);
+  }
+  novelWords(text) {
+    return this.words(text).filter((w) => !this.echoWords.has(w));
+  }
+  echoActive() {
+    return this.speaking || now() < this.echoUntil;
+  }
+  handlePartial(text) {
+    if (this.speaking) {
+      const barge = this.novelWords(text).length >= (this.usingAec ? 1 : this.suspectUntil ? 1 : 2);
+      if (barge) {
+        const phase = this.ctxOpen ? "speaking" : "drain";
+        this.interrupt();
+        this.options.onBargeIn(phase);
+      }
+      return;
+    }
+    if (this.pendingUtt && text.trim()) {
+      if (this.pendingTimer) {
+        clearTimeout(this.pendingTimer);
+        this.pendingTimer = null;
+      }
+    }
+    if (!this.echoActive() || this.novelWords(text).length >= 1) this.options.onPartial(text);
+  }
+  handleUtterance(text) {
+    if (this.echoActive() && this.novelWords(text).length < (this.usingAec ? 1 : 2)) {
+      this.stt.reset();
+      return;
+    }
+    const squash = (t) => t.toLowerCase().replace(/[^a-z]/g, "").replace(/(.)\1+/g, "$1");
+    if (this.ackAt && now() - this.ackAt < 6e3 && squash(text) === squash(this.options.ackPhrase)) {
+      this.ackAt = 0;
+      return;
+    }
+    this.pendingUtt = this.pendingUtt ? `${this.pendingUtt} ${text}` : text;
+    if (this.pendingTimer) clearTimeout(this.pendingTimer);
+    if (!this.options.utteranceMergeMs) return this.flushUtterance();
+    this.pendingTimer = setTimeout(() => this.flushUtterance(), this.options.utteranceMergeMs);
+  }
+  flushUtterance() {
+    if (this.pendingTimer) {
+      clearTimeout(this.pendingTimer);
+      this.pendingTimer = null;
+    }
+    const text = this.pendingUtt;
+    this.pendingUtt = "";
+    if (text) this.options.onUtterance(text);
+  }
+  /** energy two-stage barge-in (heuristic tier only): spike over echo baseline → pause + confirm via STT */
+  handleLevel(rms) {
+    if (this.usingAec) return;
+    if (!this.speaking) {
+      this.baseline = 0;
+      this.hot = 0;
+      return;
+    }
+    if (!this.baseline) {
+      this.baseline = rms;
+      return;
+    }
+    this.baseline = this.baseline * 0.9 + rms * 0.1;
+    if (rms > Math.max(this.baseline * this.options.bargeRmsMult, this.options.bargeRmsFloor)) this.hot++;
+    else this.hot = 0;
+    if (this.hot >= 2 && !this.suspectUntil) {
+      this.suspectUntil = now() + 1300;
+      setTimeout(() => {
+        this.suspectUntil = 0;
+      }, 1350);
+    }
+  }
+};
+
+// src/voice/soniox.ts
+init_logging();
+
+// src/voice/types.ts
+var STT_SAMPLE_RATE = 16e3;
+var TTS_SAMPLE_RATE = 44100;
+async function resolveAuth(auth) {
+  return typeof auth === "function" ? await auth() : auth;
+}
+
+// src/voice/soniox.ts
+var log8 = forComponent("SonioxSTT");
+var now2 = () => performance.now();
+var SonioxSTTOptions = class {
+  auth = "";
+  source;
+  model = "stt-rt-preview";
+  languageHints = ["en"];
+};
+var SonioxSTT = class {
+  options;
+  ws;
+  stopped = false;
+  sourceStarted = false;
+  onPartial = () => {
+  };
+  onUtterance = () => {
+  };
+  /** mic energy (RMS) per chunk — drives the energy-based heuristic barge-in tier */
+  onLevel = () => {
+  };
+  finalText = "";
+  partialText = "";
+  constructor(options) {
+    this.options = { ...new SonioxSTTOptions(), ...options };
+  }
+  get usingAec() {
+    return this.options.source?.aec ?? false;
+  }
+  async connectWs() {
+    const apiKey = await resolveAuth(this.options.auth);
+    this.ws = new WebSocket("wss://stt-rt.soniox.com/transcribe-websocket");
+    await new Promise((res, rej) => {
+      this.ws.onopen = () => res();
+      this.ws.onerror = (e) => rej(new Error(`soniox ws: ${e.message || "connect failed"}`));
+    });
+    this.ws.send(
+      JSON.stringify({
+        api_key: apiKey,
+        model: this.options.model,
+        audio_format: "pcm_s16le",
+        sample_rate: STT_SAMPLE_RATE,
+        num_channels: 1,
+        language_hints: this.options.languageHints,
+        enable_endpoint_detection: true
+      })
+    );
+    this.ws.onmessage = (ev) => this.handle(JSON.parse(String(ev.data)));
+    this.ws.onclose = (ev) => {
+      if (this.stopped) return;
+      log8.warn(`soniox ws closed (${ev.code} ${ev.reason || ""}) \u2014 reconnecting`);
+      this.reset();
+      this.connectWs().catch((e) => log8.error(`soniox reconnect failed: ${e.message}`));
+    };
+  }
+  async start() {
+    await this.connectWs();
+    if (this.sourceStarted) return;
+    this.sourceStarted = true;
+    await this.options.source.start((chunk) => {
+      let sum = 0;
+      const view = new DataView(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+      for (let i = 0; i + 1 < chunk.byteLength; i += 2) {
+        const v = view.getInt16(i, true);
+        sum += v * v;
+      }
+      this.onLevel(Math.sqrt(sum / (chunk.byteLength / 2)));
+      if (this.ws.readyState === WebSocket.OPEN) this.ws.send(chunk);
+    });
+  }
+  handle(m) {
+    if (m.error_message) return log8.error(`soniox: ${m.error_message}`);
+    let endpoint = false;
+    for (const t of m.tokens ?? []) {
+      if (t.text === "<end>") endpoint = true;
+      else if (t.is_final) this.finalText += t.text;
+    }
+    this.partialText = (m.tokens ?? []).filter((t) => !t.is_final && t.text !== "<end>").map((t) => t.text).join("");
+    this.onPartial(this.finalText + this.partialText);
+    if (endpoint && this.finalText.trim()) {
+      const utterance = this.finalText.trim();
+      this.reset();
+      this.onUtterance(utterance, now2());
+    }
+  }
+  reset() {
+    this.finalText = "";
+    this.partialText = "";
+  }
+  stop() {
+    this.stopped = true;
+    this.options.source?.stop();
+    if (this.ws) this.ws.onclose = null;
+    this.ws?.close();
+  }
+};
+
+// src/voice/cartesia.ts
+init_logging();
+var log9 = forComponent("CartesiaTTS");
+var now3 = () => performance.now();
+var CartesiaTTSOptions = class {
+  auth = "";
+  voiceId = "";
+  model = "sonic-3.5";
+  /** 'apiKey' (server/CLI) → `api_key=` URL param; 'token' (browser, BE-minted) → `access_token=`. */
+  authMode = "apiKey";
+};
+var CartesiaTTS = class {
+  options;
+  ws;
+  ctxSeq = 0;
+  ctxId = "";
+  onAudio = () => {
+  };
+  onDone = () => {
+  };
+  firstAudioAt = 0;
+  constructor(options) {
+    this.options = { ...new CartesiaTTSOptions(), ...options };
+  }
+  async connect() {
+    const key = await resolveAuth(this.options.auth);
+    const param = this.options.authMode === "token" ? "access_token" : "api_key";
+    this.ws = new WebSocket(`wss://api.cartesia.ai/tts/websocket?cartesia_version=2026-03-01&${param}=${key}`);
+    await new Promise((res, rej) => {
+      this.ws.onopen = () => res();
+      this.ws.onerror = (e) => rej(new Error(`cartesia ws: ${e.message || "connect failed"}`));
+    });
+    this.ws.onclose = (ev) => log9.warn(`cartesia ws closed (${ev.code} ${ev.reason || ""})`);
+    this.ws.onmessage = (ev) => {
+      const m = JSON.parse(String(ev.data));
+      if (m.context_id && m.context_id !== this.ctxId) return;
+      if (m.type === "chunk" && m.data) {
+        if (!this.firstAudioAt) this.firstAudioAt = now3();
+        this.onAudio(base64ToBytes(m.data));
+      } else if (m.type === "done") this.onDone();
+      else if (m.type === "error" && !/already been cancelled|does not exist/.test(m.message || "")) log9.warn(`cartesia: ${JSON.stringify(m)}`);
+    };
+  }
+  newContext() {
+    this.ctxId = `ctx-${++this.ctxSeq}`;
+    this.firstAudioAt = 0;
+    return this.ctxId;
+  }
+  frame(transcript, cont) {
+    return JSON.stringify({
+      model_id: this.options.model,
+      transcript,
+      voice: { mode: "id", id: this.options.voiceId },
+      output_format: { container: "raw", encoding: "pcm_s16le", sample_rate: TTS_SAMPLE_RATE },
+      context_id: this.ctxId,
+      continue: cont
+    });
+  }
+  speak(text, cont) {
+    if (this.ws?.readyState === WebSocket.OPEN) this.ws.send(this.frame(text, cont));
+  }
+  end() {
+    if (this.ws?.readyState === WebSocket.OPEN) this.ws.send(this.frame("", false));
+  }
+  cancel() {
+    if (this.ws?.readyState === WebSocket.OPEN) this.ws.send(JSON.stringify({ context_id: this.ctxId, cancel: true }));
+  }
+  close() {
+    if (this.ws) this.ws.onclose = null;
+    this.ws?.close();
+  }
+};
+function base64ToBytes(b64) {
+  if (typeof Buffer !== "undefined") return Buffer.from(b64, "base64");
+  const bin = atob(b64);
+  const out = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
+  return out;
+}
+
+// src/index.ts
 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 log7 = forComponent("mcp");
+var log10 = forComponent("mcp");
 var PROTOCOL_VERSION = "2025-06-18";
 var DEFAULT_TIMEOUT_MS = 3e4;
 var StdioTransport = class {
@@ -3595,7 +4215,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) => log7.debug(`[${command}] stderr:`, chunk.trimEnd()));
+    proc.stderr.on("data", (chunk) => log10.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))));
   }
@@ -3609,7 +4229,7 @@ var StdioTransport = class {
       try {
         this.dispatch(JSON.parse(line));
       } catch (e) {
-        log7.debug("dropping non-JSON line from MCP server:", line, e);
+        log10.debug("dropping non-JSON line from MCP server:", line, e);
       }
     }
   }
@@ -3658,7 +4278,7 @@ var StdioTransport = class {
     try {
       this.proc?.stdin?.end();
     } catch (e) {
-      log7.debug("stdin end failed", e);
+      log10.debug("stdin end failed", e);
     }
     this.proc?.kill();
   }
@@ -3727,7 +4347,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) {
-      log7.debug("skipping unparseable SSE data line", e);
+      log10.debug("skipping unparseable SSE data line", e);
     }
   }
   return {};
@@ -3781,16 +4401,16 @@ async function mountMcpServers(servers = {}) {
   for (const [name, cfg] of Object.entries(servers)) {
     if (!cfg || cfg.disabled) continue;
     if (!cfg.command && !cfg.url) {
-      log7.warn(`MCP server "${name}" needs a command (stdio) or url (http) \u2014 skipping`);
+      log10.warn(`MCP server "${name}" needs a command (stdio) or url (http) \u2014 skipping`);
       continue;
     }
     try {
       const m = await mountMcpServer(name, cfg);
       out.push(m);
-      log7.info(`MCP "${name}" mounted \u2014 ${m.tools.length} tool(s)${m.serverInfo?.name ? ` from ${m.serverInfo.name}` : ""}`);
+      log10.info(`MCP "${name}" mounted \u2014 ${m.tools.length} tool(s)${m.serverInfo?.name ? ` from ${m.serverInfo.name}` : ""}`);
     } catch (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}`);
+      if (e instanceof McpAuthError) log10.warn(`MCP "${name}" needs-auth: HTTP ${e.status} \u2014 set bearerToken or headers in its config; skipping`);
+      else log10.error(`MCP server "${name}" failed to mount: ${e?.message ?? e}`);
     }
   }
   return out;
@@ -3986,7 +4606,7 @@ function b64url(buf) {
 function defaultOpenBrowser(url) {
   const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
   const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
-  import("child_process").then(({ spawn: spawn2 }) => spawn2(cmd, args, { stdio: "ignore", detached: true }).unref());
+  import("child_process").then(({ spawn: spawn3 }) => spawn3(cmd, args, { stdio: "ignore", detached: true }).unref());
 }
 
 // cli/core.ts
@@ -4121,9 +4741,9 @@ Reference files in them by their mount path (the left side).`;
     // would corrupt those calls.
     ...isCursor ? { providerOptions: { cwd, ...toCursorMcp(o.mcpServers) ?? {} } } : {},
     ...(() => {
-      const now = /* @__PURE__ */ new Date();
+      const now5 = /* @__PURE__ */ new Date();
       const platformNames = { darwin: "macOS", linux: "Linux", win32: "Windows" };
-      const envNote = `Current date: ${now.toLocaleDateString("en-CA")} ${now.toLocaleTimeString("en-GB", { hour: "2-digit", minute: "2-digit" })} (${Intl.DateTimeFormat().resolvedOptions().timeZone})
+      const envNote = `Current date: ${now5.toLocaleDateString("en-CA")} ${now5.toLocaleTimeString("en-GB", { hour: "2-digit", minute: "2-digit" })} (${Intl.DateTimeFormat().resolvedOptions().timeZone})
 Platform: ${platformNames[platform()] ?? platform()} ${arch()} (${release()})
 User: ${userInfo().username}
 Shell: ${process.env.SHELL ?? "unknown"}`;
@@ -4188,16 +4808,162 @@ function summarizeCall(name, args) {
 }
 var trunc = (s, n) => (s == null ? "" : String(s).length > n ? String(s).slice(0, n) + "\u2026" : String(s)).replace(/\n/g, "\u23CE");
 
-// cli/config.ts
+// cli/voice.ts
+init_logging();
+import { spawn as spawn2, spawnSync } from "child_process";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, statSync as statSync2 } from "fs";
 import { homedir as homedir2 } from "os";
-import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
-import { join as join4 } from "path";
+import { dirname as dirname3, join as join4 } from "path";
+import { fileURLToPath } from "url";
+var log12 = forComponent("VoiceIO");
+var now4 = () => performance.now();
+var Player = class {
+  proc = null;
+  bytesWritten = 0;
+  startedAt = 0;
+  /** start a new spoken turn: kill any previous player, spawn a fresh one */
+  markTurn() {
+    this.kill();
+    this.proc = spawn2(
+      "ffplay",
+      ["-loglevel", "quiet", "-nodisp", "-fflags", "nobuffer", "-flags", "low_delay", "-probesize", "32", "-f", "s16le", "-ar", String(TTS_SAMPLE_RATE), "-ch_layout", "mono", "-i", "-"],
+      { stdio: ["pipe", "ignore", "ignore"] }
+    );
+    this.proc.on("error", (e) => log12.warn(`ffplay error: ${e.message}`));
+    this.proc.stdin.on("error", () => {
+    });
+    this.bytesWritten = 0;
+    this.startedAt = 0;
+  }
+  write(chunk) {
+    if (!this.proc) this.markTurn();
+    if (!this.startedAt) this.startedAt = now4();
+    this.bytesWritten += chunk.length;
+    this.proc.stdin.write(chunk);
+  }
+  /** ms of audio actually played so far this turn */
+  playedMs() {
+    return this.startedAt ? now4() - this.startedAt : 0;
+  }
+  /** estimated ms until queued audio finishes playing */
+  drainMs() {
+    if (!this.startedAt) return 0;
+    const queuedMs = this.bytesWritten / (TTS_SAMPLE_RATE * 2) * 1e3;
+    return Math.max(0, queuedMs - (now4() - this.startedAt));
+  }
+  kill() {
+    this.proc?.kill("SIGKILL");
+    this.proc = null;
+  }
+};
+var nativeDir = () => join4(dirname3(fileURLToPath(import.meta.url)), "native");
+function detectFfmpegMic() {
+  if (process.env.MIC_DEVICE) return process.env.MIC_DEVICE;
+  const out = spawnSync("ffmpeg", ["-f", "avfoundation", "-list_devices", "true", "-i", ""], { encoding: "utf8" }).stderr;
+  const audio = out.slice(out.indexOf("audio devices"));
+  const devices = [...audio.matchAll(/\[(\d+)\] (.+)/g)].map(([, idx, name]) => ({ idx, name: name.trim() }));
+  const mic = devices.find((d) => /microphone|built-in/i.test(d.name) && !/teams|blackhole|loopback/i.test(d.name)) ?? devices[0];
+  if (!mic) throw new Error("no audio input device found");
+  log12.debug(`ffmpeg mic: [${mic.idx}] ${mic.name}`);
+  return `:${mic.idx}`;
+}
+function resolveAecBinary() {
+  if (process.env.MIC_AEC === "0" || process.platform !== "darwin") return null;
+  const src = join4(nativeDir(), "mic-aec.swift");
+  const plist = join4(nativeDir(), "Info.plist");
+  if (!existsSync3(src)) return null;
+  const cacheDir = join4(homedir2(), ".agent", "cache");
+  const bin = join4(cacheDir, "mic-aec");
+  if (existsSync3(bin) && statSync2(bin).mtimeMs >= statSync2(src).mtimeMs) return bin;
+  if (spawnSync("which", ["swiftc"]).status !== 0) return null;
+  mkdirSync3(cacheDir, { recursive: true });
+  log12.info("compiling AEC mic helper (first run)\u2026");
+  const build = spawnSync("swiftc", ["-O", "-o", bin, src, "-Xlinker", "-sectcreate", "-Xlinker", "__TEXT", "-Xlinker", "__info_plist", "-Xlinker", plist], { encoding: "utf8" });
+  if (build.status !== 0) {
+    log12.warn(`AEC build failed: ${build.stderr?.slice(0, 400)}`);
+    return null;
+  }
+  const sign = spawnSync("codesign", ["-fs", "-", bin], { encoding: "utf8" });
+  if (sign.status !== 0) {
+    log12.warn(`codesign failed: ${sign.stderr?.slice(0, 200)}`);
+    return null;
+  }
+  return bin;
+}
+var NodeMicSource = class {
+  aec;
+  bin;
+  proc = null;
+  stopped = false;
+  constructor() {
+    this.bin = resolveAecBinary();
+    this.aec = !!this.bin;
+  }
+  start(onChunk) {
+    if (this.bin) {
+      this.proc = spawn2(this.bin, [], { stdio: ["ignore", "pipe", "ignore"] });
+    } else {
+      if (spawnSync("which", ["ffmpeg"]).status !== 0) throw new Error("voice I/O unavailable: no AEC helper and no ffmpeg on PATH");
+      log12.info("mic: raw capture (no AEC) \u2014 echo handled heuristically; headphones recommended");
+      this.proc = spawn2(
+        "ffmpeg",
+        ["-loglevel", "error", "-f", "avfoundation", "-i", detectFfmpegMic(), "-ar", String(STT_SAMPLE_RATE), "-ac", "1", "-f", "s16le", "-"],
+        { stdio: ["ignore", "pipe", "pipe"] }
+      );
+      this.proc.stderr.on("data", (d) => log12.warn(`ffmpeg: ${String(d).trim()}`));
+    }
+    this.proc.on("exit", (c) => {
+      if (c && !this.stopped) log12.error(`mic capture exited (${c}) \u2014 check mic permission / MIC_DEVICE / MIC_AEC=0`);
+    });
+    this.proc.stdout.on("data", (chunk) => onChunk(chunk));
+  }
+  stop() {
+    this.stopped = true;
+    const p = this.proc;
+    this.proc = null;
+    if (!p) return;
+    p.kill("SIGTERM");
+    setTimeout(() => {
+      try {
+        p.kill("SIGKILL");
+      } catch {
+      }
+    }, 500).unref?.();
+  }
+};
+var VoiceIOOptions = class extends VoiceEngineOptions {
+  sonioxApiKey = process.env.SONIOX_API_KEY ?? "";
+  cartesiaApiKey = process.env.CARTESIA_API_KEY ?? "";
+  cartesiaVoiceId = process.env.CARTESIA_VOICE_ID ?? "";
+};
+var VoiceIO = class extends VoiceEngine {
+  constructor(options) {
+    const o = { ...new VoiceIOOptions(), ...options };
+    super({
+      ...o,
+      stt: o.stt ?? new SonioxSTT({ auth: o.sonioxApiKey, source: new NodeMicSource() }),
+      tts: o.tts ?? new CartesiaTTS({ auth: o.cartesiaApiKey, voiceId: o.cartesiaVoiceId }),
+      player: o.player ?? new Player(),
+      bargeRmsMult: Number(process.env.BARGE_RMS_MULT || o.bargeRmsMult),
+      bargeRmsFloor: Number(process.env.BARGE_RMS_FLOOR || o.bargeRmsFloor)
+    });
+  }
+  /** ready = keys present (AEC vs heuristic is decided at start()) */
+  static available(env = process.env) {
+    return !!(env.SONIOX_API_KEY && env.CARTESIA_API_KEY && env.CARTESIA_VOICE_ID);
+  }
+};
+
+// cli/config.ts
+import { homedir as homedir3 } from "os";
+import { existsSync as existsSync4, readFileSync as readFileSync2 } from "fs";
+import { join as join5 } from "path";
 import { pathToFileURL } from "url";
 var FILES = ["config.ts", "config.js", "config.mjs", "config.json"];
 async function loadFrom(dir) {
   for (const f of FILES) {
-    const p = join4(dir, ".agent", f);
-    if (!existsSync3(p)) continue;
+    const p = join5(dir, ".agent", f);
+    if (!existsSync4(p)) continue;
     try {
       const mod = await import(pathToFileURL(p).href, f.endsWith(".json") ? { with: { type: "json" } } : void 0);
       return mod.default ?? mod.config ?? mod;
@@ -4209,8 +4975,8 @@ async function loadFrom(dir) {
   return {};
 }
 function loadSettings(dir) {
-  const p = join4(dir, ".agent", "settings.json");
-  if (!existsSync3(p)) return {};
+  const p = join5(dir, ".agent", "settings.json");
+  if (!existsSync4(p)) return {};
   try {
     const raw = JSON.parse(readFileSync2(p, "utf8"));
     const cfg = {};
@@ -4233,8 +4999,8 @@ function loadSettings(dir) {
   }
 }
 async function loadConfig(cwd) {
-  const userSettings = loadSettings(homedir2());
-  const user = await loadFrom(homedir2());
+  const userSettings = loadSettings(homedir3());
+  const user = await loadFrom(homedir3());
   const projectSettings = loadSettings(cwd);
   const project = await loadFrom(cwd);
   const merged = { ...userSettings, ...user, ...projectSettings, ...project };
@@ -4245,8 +5011,8 @@ async function loadConfig(cwd) {
 }
 
 // cli/hooks-config.ts
-import { spawnSync } from "child_process";
-var log9 = forComponent("hooks");
+import { spawnSync as spawnSync2 } from "child_process";
+var log13 = forComponent("hooks");
 var escapeRegex = (s) => s.replace(/[.+^${}()|[\]\\]/g, "\\$&");
 function ruleMatches(rule, toolName) {
   if (!rule.tool || rule.tool === "*") return true;
@@ -4255,7 +5021,7 @@ function ruleMatches(rule, toolName) {
 }
 function runCmd(rule, env) {
   try {
-    const r = spawnSync(rule.command, {
+    const r = spawnSync2(rule.command, {
       shell: true,
       encoding: "utf8",
       timeout: rule.timeoutMs ?? 1e4,
@@ -4263,7 +5029,7 @@ function runCmd(rule, env) {
     });
     return { code: r.status ?? 1, out: ((r.stdout ?? "") + (r.stderr ?? "")).trim() };
   } catch (e) {
-    log9.debug(`hook command failed: ${rule.command}`, e);
+    log13.debug(`hook command failed: ${rule.command}`, e);
     return { code: 1, out: String(e?.message ?? e) };
   }
 }
@@ -4367,17 +5133,17 @@ 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 log10 = forComponent("session");
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync3, readdirSync, renameSync } from "fs";
+import { join as join6 } from "path";
+var log14 = forComponent("session");
 var SessionStore = class {
   dir;
   constructor(cwd) {
-    this.dir = join5(cwd, ".agent", "sessions");
+    this.dir = join6(cwd, ".agent", "sessions");
   }
   /** Sortable, human-readable id: `YYYYMMDD-HHMMSS-mmm`. */
-  newId(now = Date.now()) {
-    const d = new Date(now);
+  newId(now5 = Date.now()) {
+    const d = new Date(now5);
     const p = (n, w = 2) => String(n).padStart(w, "0");
     return `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}-${p(d.getMilliseconds(), 3)}`;
   }
@@ -4387,36 +5153,36 @@ var SessionStore = class {
   }
   save(data) {
     if (!this.safeId(data.meta.id)) throw new Error(`unsafe session id: ${data.meta.id}`);
-    if (!existsSync4(this.dir)) mkdirSync3(this.dir, { recursive: true });
-    const path = join5(this.dir, `${data.meta.id}.json`);
+    if (!existsSync5(this.dir)) mkdirSync4(this.dir, { recursive: true });
+    const path = join6(this.dir, `${data.meta.id}.json`);
     const tmp = `${path}.${process.pid}.tmp`;
     writeFileSync3(tmp, JSON.stringify(data));
     renameSync(tmp, path);
   }
   load(id) {
     if (!this.safeId(id)) {
-      log10.debug(`rejecting unsafe session id: ${id}`);
+      log14.debug(`rejecting unsafe session id: ${id}`);
       return void 0;
     }
-    const path = join5(this.dir, `${id}.json`);
-    if (!existsSync4(path)) return void 0;
+    const path = join6(this.dir, `${id}.json`);
+    if (!existsSync5(path)) return void 0;
     try {
       return JSON.parse(readFileSync3(path, "utf8"));
     } catch (e) {
-      log10.debug(`unreadable session ${id} \u2014 ignoring`, e);
+      log14.debug(`unreadable session ${id} \u2014 ignoring`, e);
       return void 0;
     }
   }
   /** All sessions' metadata, most-recently-updated first. */
   list() {
-    if (!existsSync4(this.dir)) return [];
+    if (!existsSync5(this.dir)) return [];
     const metas = [];
     for (const f of readdirSync(this.dir)) {
       if (!f.endsWith(".json")) continue;
       try {
-        metas.push(JSON.parse(readFileSync3(join5(this.dir, f), "utf8")).meta);
+        metas.push(JSON.parse(readFileSync3(join6(this.dir, f), "utf8")).meta);
       } catch (e) {
-        log10.debug(`skipping unreadable session file ${f}`, e);
+        log14.debug(`skipping unreadable session file ${f}`, e);
       }
     }
     return metas.sort((a, b) => b.updated - a.updated);
@@ -4508,9 +5274,9 @@ var CheckpointStack = class {
 // cli/gitCheckpoints.ts
 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 log11 = forComponent("checkpoints");
+import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync5, existsSync as existsSync6 } from "fs";
+import { join as join7, resolve as resolve2, sep as sep2 } from "path";
+var log15 = forComponent("checkpoints");
 var exec = promisify(execFile);
 var DEFAULT_EXCLUDE = [".agent/", ".git/", "node_modules/", "dist/", "build/", ".next/", "target/", ".venv/", "__pycache__/", "*.log"];
 var ShadowRepo = class {
@@ -4537,14 +5303,14 @@ var ShadowRepo = class {
     if (this.ready !== void 0) return this.ready;
     try {
       await exec(this.git, ["--version"]);
-      if (!existsSync5(this.gitDir)) {
-        mkdirSync4(this.gitDir, { recursive: true });
+      if (!existsSync6(this.gitDir)) {
+        mkdirSync5(this.gitDir, { recursive: true });
         await this.run("init", "-q");
       }
-      writeFileSync4(join6(this.gitDir, "info", "exclude"), this.exclude.join("\n") + "\n");
+      writeFileSync4(join7(this.gitDir, "info", "exclude"), this.exclude.join("\n") + "\n");
       this.ready = true;
     } catch (e) {
-      log11.debug(`git checkpoints unavailable for ${this.workTree}`, e);
+      log15.debug(`git checkpoints unavailable for ${this.workTree}`, e);
       this.ready = false;
     }
     return this.ready;
@@ -4607,7 +5373,7 @@ var ShadowRepo = class {
       await this.run("gc", "--auto", "-q").catch(() => {
       });
     } catch (e) {
-      log11.debug("checkpoint prune failed", e);
+      log15.debug("checkpoint prune failed", e);
     }
   }
 };
@@ -4637,7 +5403,7 @@ var GitCheckpoints = class {
       const abs = resolve2(d);
       if (abs === cwd || abs.startsWith(cwd + sep2)) continue;
       if (cwd.startsWith(abs + sep2)) continue;
-      out.push({ workTree: abs, gitDir: join6(abs, ".agent", "checkpoints.git") });
+      out.push({ workTree: abs, gitDir: join7(abs, ".agent", "checkpoints.git") });
     }
     return out;
   }
@@ -4664,7 +5430,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) => log11.debug("re-point failed", e));
+    if (this.started) for (const r of this.repos) void r.point(this.ref()).catch((e) => log15.debug("re-point failed", e));
   }
   async begin(label) {
     if (!await this.start()) return;
@@ -4675,7 +5441,7 @@ var GitCheckpoints = class {
       try {
         await r.commit(msg);
       } catch (e) {
-        log11.debug("checkpoint commit failed", e);
+        log15.debug("checkpoint commit failed", e);
       }
     }
     if (slow) clearTimeout(slow);
@@ -4718,7 +5484,7 @@ var GitCheckpointsOptions = class {
   /** Real working tree to snapshot (the launch cwd). */
   workTree = process.cwd();
   /** Isolated git dir for the cwd shadow repo (kept out of the user's real .git). */
-  gitDir = join6(process.cwd(), ".agent", "checkpoints.git");
+  gitDir = join7(process.cwd(), ".agent", "checkpoints.git");
   /** Extra mounted dirs (`--add-dir`); those outside cwd each get their own shadow repo. */
   addDirs = [];
   /** Conversation id → per-session restore-point ref. */
@@ -4732,9 +5498,9 @@ var GitCheckpointsOptions = class {
 };
 
 // cli/permissions.ts
-import { existsSync as existsSync6, readFileSync as readFileSync4, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5 } from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join7 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync4, writeFileSync as writeFileSync5, mkdirSync as mkdirSync6 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join8 } from "path";
 var RULE_RE = /^(\w+)(?:\((.+)\))?$/;
 function parseOne(raw, decision) {
   const m = RULE_RE.exec(raw.trim());
@@ -4756,10 +5522,10 @@ function parsePermRules(perms) {
 function describeRule(r) {
   return `${r.decision.padEnd(5)} ${r.tool ?? "*"}${r.pathGlob ? `(${r.pathGlob})` : ""}`;
 }
-var PERM_FILE = (cwd) => join7(cwd, ".agent", "permissions.json");
+var PERM_FILE = (cwd) => join8(cwd, ".agent", "permissions.json");
 function loadPersistedRules(cwd) {
   const p = PERM_FILE(cwd);
-  if (!existsSync6(p)) return {};
+  if (!existsSync7(p)) return {};
   try {
     const j = JSON.parse(readFileSync4(p, "utf8"));
     return { allow: j.allow ?? [], ask: j.ask ?? [], deny: j.deny ?? [] };
@@ -4767,11 +5533,11 @@ function loadPersistedRules(cwd) {
     return {};
   }
 }
-function loadClaudeSettings(cwd, home = homedir3()) {
-  const files = [join7(home, ".claude", "settings.json"), join7(cwd, ".claude", "settings.json"), join7(cwd, ".claude", "settings.local.json")];
+function loadClaudeSettings(cwd, home = homedir4()) {
+  const files = [join8(home, ".claude", "settings.json"), join8(cwd, ".claude", "settings.json"), join8(cwd, ".claude", "settings.local.json")];
   let out = {};
   for (const p of files) {
-    if (!existsSync6(p)) continue;
+    if (!existsSync7(p)) continue;
     try {
       const perms = JSON.parse(readFileSync4(p, "utf8"))?.permissions;
       if (perms) out = mergePerms(out, { allow: perms.allow, ask: perms.ask, deny: perms.deny }) ?? out;
@@ -4785,7 +5551,7 @@ function persistRule(cwd, decision, ruleStr) {
   const list = cur[decision] ??= [];
   if (!list.includes(ruleStr)) list.push(ruleStr);
   try {
-    mkdirSync5(join7(cwd, ".agent"), { recursive: true });
+    mkdirSync6(join8(cwd, ".agent"), { recursive: true });
     writeFileSync5(PERM_FILE(cwd), JSON.stringify(cur, null, 2) + "\n");
   } catch {
   }
@@ -4799,10 +5565,10 @@ function mergePerms(a, b) {
   }
   return Object.keys(out).length ? out : void 0;
 }
-var TRUST_FILE = join7(homedir3(), ".agent", "trusted.json");
+var TRUST_FILE = join8(homedir4(), ".agent", "trusted.json");
 function isTrusted(cwd, file = TRUST_FILE) {
   try {
-    return existsSync6(file) && JSON.parse(readFileSync4(file, "utf8")).includes(cwd);
+    return existsSync7(file) && JSON.parse(readFileSync4(file, "utf8")).includes(cwd);
   } catch {
     return false;
   }
@@ -4810,12 +5576,12 @@ function isTrusted(cwd, file = TRUST_FILE) {
 function trustDir(cwd, file = TRUST_FILE) {
   let list = [];
   try {
-    if (existsSync6(file)) list = JSON.parse(readFileSync4(file, "utf8"));
+    if (existsSync7(file)) list = JSON.parse(readFileSync4(file, "utf8"));
   } catch {
   }
   if (!list.includes(cwd)) list.push(cwd);
   try {
-    mkdirSync5(join7(file, ".."), { recursive: true });
+    mkdirSync6(join8(file, ".."), { recursive: true });
     writeFileSync5(file, JSON.stringify(list, null, 2) + "\n");
   } catch {
   }
@@ -5564,8 +6330,11 @@ function createLineEditor(out) {
     // cyan
   };
   let curRow = 0;
+  let suspended = false;
   let activeRedraw;
+  let activeAbort;
   function render(s, promptArg, maxVisible, status) {
+    if (suspended) return;
     const cols = out.columns ?? 80;
     const mode = !s.searching ? inputMode(s.buf) : void 0;
     const vimTag = s.vim === "normal" && !s.searching && !mode ? inverse(" N ") + " " : "";
@@ -5630,9 +6399,18 @@ function createLineEditor(out) {
     };
     process.on("SIGWINCH", onResize);
     return new Promise((resolve4) => {
+      activeAbort = () => {
+        finish();
+        resolve4(null);
+      };
       const redraw = () => render(s, opts.prompt, maxVisible, opts.status);
+      let lastStatus = opts.status?.() ?? "";
       const ticker = opts.statusTickMs && opts.status ? setInterval(() => {
-        if (!s.pasting) redraw();
+        if (s.pasting) return;
+        const cur = opts.status();
+        if (cur === lastStatus) return;
+        lastStatus = cur;
+        redraw();
       }, opts.statusTickMs) : void 0;
       const onKey = (str, key) => {
         if (key?.ctrl && key.name === "l") {
@@ -5656,6 +6434,21 @@ function createLineEditor(out) {
           redraw();
           return;
         }
+        if (key?.ctrl && key.name === "s" || key?.meta && key.name === "s") {
+          if (s.buf.trim() && opts.onStash) {
+            opts.onStash(s.expand());
+            s.reset();
+            s.refresh();
+            redraw();
+          } else if (!s.buf.length && opts.onUnstash) {
+            const text = opts.onUnstash();
+            if (text) {
+              s.insert(text);
+              redraw();
+            }
+          }
+          return;
+        }
         if (key?.meta && key.name === "p" && opts.onPickModel) {
           process.stdin.off("keypress", onKey);
           void opts.onPickModel().finally(() => {
@@ -5693,6 +6486,7 @@ function createLineEditor(out) {
       };
       const finish = () => {
         activeRedraw = void 0;
+        activeAbort = void 0;
         if (ticker) clearInterval(ticker);
         process.stdin.off("keypress", onKey);
         process.removeListener("SIGWINCH", onResize);
@@ -5705,7 +6499,24 @@ function createLineEditor(out) {
       process.stdin.on("keypress", onKey);
     });
   }
-  return { readLine, redrawNow: () => activeRedraw?.() };
+  return {
+    readLine,
+    redrawNow: () => activeRedraw?.(),
+    suspend: () => {
+      if (suspended) return;
+      suspended = true;
+      if (curRow > 0) out.write(`\x1B[${curRow}A`);
+      out.write("\r\x1B[J");
+      curRow = 0;
+    },
+    resume: () => {
+      if (!suspended) return;
+      suspended = false;
+      curRow = 0;
+      activeRedraw?.();
+    },
+    abort: () => activeAbort?.()
+  };
 }
 function selectMenu(out, opts) {
   if (!out.isTTY || !process.stdin.isTTY || !opts.items.length) return Promise.resolve(null);
@@ -6006,7 +6817,7 @@ var red = C("31");
 var bold = C("1");
 var yellow = C("33");
 var err = (s) => process.stderr.write(s);
-var log12 = forComponent("cli");
+var log16 = forComponent("cli");
 var VERSION = (() => {
   try {
     return JSON.parse(readFileSync5(new URL("../package.json", import.meta.url), "utf8")).version ?? "?";
@@ -6033,6 +6844,9 @@ var spinner = /* @__PURE__ */ (() => {
   };
 })();
 var activeTurn = null;
+var exitRequested = false;
+var inputStash = [];
+var stashBuf = "";
 function numFlag(raw, flag) {
   const n = Number(raw);
   if (!Number.isFinite(n) || n < 0) throw new Error(`invalid ${flag}: ${raw ?? "(missing value)"}`);
@@ -6137,6 +6951,8 @@ Flags:
                        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)
+                       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 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)
@@ -6170,7 +6986,8 @@ 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 Ctrl+O toggles verbose tool output \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 \xB7 Alt+S/Ctrl+S stash/unstash.
+REPL stash: type while a turn is running \u2192 Enter queues it (auto-submits when the turn finishes). Alt+S (or Ctrl+S) with text stashes it; on an empty prompt pops the next entry for editing.
 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() {
@@ -6188,11 +7005,11 @@ function resolveModelOrNewest(model) {
 }
 var ENV_KEY_ALIASES = { google: ["GEMINI_API_KEY"] };
 function loadInstallEnv() {
-  let dir = dirname3(import.meta.path);
-  for (let i = 0; i < 5 && !existsSync7(join8(dir, "package.json")); i++) dir = dirname3(dir);
+  let dir = dirname4(import.meta.path);
+  for (let i = 0; i < 5 && !existsSync8(join9(dir, "package.json")); i++) dir = dirname4(dir);
   for (const name of [".env", ".env.local"]) {
-    const file = join8(dir, name);
-    if (!existsSync7(file)) continue;
+    const file = join9(dir, name);
+    if (!existsSync8(file)) continue;
     for (const line of readFileSync5(file, "utf8").split("\n")) {
       const m = line.match(/^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/);
       if (!m || m[1] in process.env) continue;
@@ -6572,7 +7389,7 @@ async function mountMcp(cfg, oauth) {
   return mounted;
 }
 async function closeMcp(mounted) {
-  await Promise.all(mounted.map((m) => m.client.close().catch((e) => log12.debug("mcp close failed", e))));
+  await Promise.all(mounted.map((m) => m.client.close().catch((e) => log16.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) {
@@ -6595,9 +7412,9 @@ function pastePathClassifier(cwd) {
     t = t.replace(/\\ /g, " ").replace(/^['"]|['"]$/g, "");
     if (/\s/.test(t)) return null;
     if (!/^(\/|~\/|\.\/|\.\.\/)/.test(t)) return null;
-    const abs = t.startsWith("~/") ? join8(homedir4(), t.slice(2)) : resolve3(cwd, t);
+    const abs = t.startsWith("~/") ? join9(homedir5(), t.slice(2)) : resolve3(cwd, t);
     try {
-      if (!statSync2(abs).isFile()) return null;
+      if (!statSync3(abs).isFile()) return null;
     } catch {
       return null;
     }
@@ -6700,7 +7517,7 @@ async function runTurn(agent, store, session, task, cp, cwd = process.cwd(), sen
   const tools = res.messages.slice(lastUser).filter((m2) => m2.role === "tool").length;
   const ok = res.finishReason === "stop";
   const shortId = session.meta.id.slice(-10);
-  err("\n" + (ok ? green("  \u2713 done") : red(`  \u2717 ${res.finishReason}`)) + dim(` \xB7 ${res.steps} steps \xB7 ${tools} tools \xB7 ${tok}${secs}s \xB7 ${shortId}
+  err("\n" + (process.stderr.isTTY ? "\r\x1B[0J" : "") + (ok ? green("  \u2713 done") : red(`  \u2717 ${res.finishReason}`)) + dim(` \xB7 ${res.steps} steps \xB7 ${tools} tools \xB7 ${tok}${secs}s \xB7 ${shortId}
 `));
   if (res.finishReason === "error" && res.error) {
     const e = res.error;
@@ -6731,8 +7548,8 @@ function startSession(args, store, agent, cwd) {
     if (data) {
       agent.transcript = data.messages;
       if (args.fork) {
-        const now2 = Date.now();
-        const forked = { meta: { ...data.meta, id: args.sessionId ?? store.newId(now2), created: now2, updated: now2, turns: data.meta.turns }, messages: data.messages };
+        const now6 = Date.now();
+        const forked = { meta: { ...data.meta, id: args.sessionId ?? store.newId(now6), created: now6, updated: now6, turns: data.meta.turns }, messages: data.messages };
         err(dim(`  forked ${data.meta.id} \u2192 ${forked.meta.id} (${data.meta.turns} turns)
 `));
         if (!args.task) printHistory(data.messages);
@@ -6746,11 +7563,11 @@ function startSession(args, store, agent, cwd) {
     err(yellow(`  no session to resume \u2014 starting fresh
 `));
   }
-  const now = Date.now();
-  const id = args.sessionId ?? store.newId(now);
+  const now5 = Date.now();
+  const id = args.sessionId ?? store.newId(now5);
   if (!args.task) err(dim(`  session ${id}
 `));
-  return { meta: { id, created: now, updated: now, cwd, model: agent.options.model, turns: 0, title: "" }, messages: [] };
+  return { meta: { id, created: now5, updated: now5, cwd, model: agent.options.model, turns: 0, title: "" }, messages: [] };
 }
 var AGENTS_MD_TEMPLATE = `# ${"${name}"}
 
@@ -6770,24 +7587,24 @@ var AGENTS_MD_TEMPLATE = `# ${"${name}"}
 `;
 function initInstructions(cwd) {
   for (const f of ["AGENTS.md", "CLAUDE.md"]) {
-    if (existsSync7(join8(cwd, f))) {
+    if (existsSync8(join9(cwd, f))) {
       err(yellow(`  ${f} already exists \u2014 leaving it as-is
 `));
       return;
     }
   }
-  const path = join8(cwd, "AGENTS.md");
+  const path = join9(cwd, "AGENTS.md");
   writeFileSync6(path, AGENTS_MD_TEMPLATE.replace("${name}", basename2(cwd)));
   err(green(`  created ${path}
 `) + dim("  edit it, then it auto-loads into every run.\n"));
 }
 function persistSetting(cwd, key, value) {
-  const path = join8(cwd, ".agent", "settings.json");
+  const path = join9(cwd, ".agent", "settings.json");
   try {
-    const obj = existsSync7(path) ? JSON.parse(readFileSync5(path, "utf8")) : {};
+    const obj = existsSync8(path) ? JSON.parse(readFileSync5(path, "utf8")) : {};
     if (obj[key] === value) return;
     obj[key] = value;
-    mkdirSync6(dirname3(path), { recursive: true });
+    mkdirSync7(dirname4(path), { recursive: true });
     writeFileSync6(path, JSON.stringify(obj, null, 2) + "\n");
   } catch (e) {
     err(yellow(`  \u26A0 couldn't persist ${key} to ${path} \u2014 ${e?.message ?? e}
@@ -6804,14 +7621,14 @@ var isCancelTeardown = (e) => {
 function installCancelGuards(mounted) {
   process.on("unhandledRejection", (e) => {
     if (isCancelTeardown(e)) {
-      log12.debug("suppressed unhandledRejection (cursor stream cancel)", e);
+      log16.debug("suppressed unhandledRejection (cursor stream cancel)", e);
       return;
     }
-    log12.error("unhandledRejection", e);
+    log16.error("unhandledRejection", e);
   });
   process.on("uncaughtException", (e) => {
     if (isCancelTeardown(e)) {
-      log12.debug("suppressed uncaughtException (cursor stream cancel)", e);
+      log16.debug("suppressed uncaughtException (cursor stream cancel)", e);
       return;
     }
     console.error(e);
@@ -6820,11 +7637,15 @@ function installCancelGuards(mounted) {
   });
 }
 async function repl(args, ai, cfg, cwd) {
-  const oauth = new McpOAuth({ storePath: join8(cwd, ".agent", "mcp-auth.json") });
+  const oauth = new McpOAuth({ storePath: join9(cwd, ".agent", "mcp-auth.json") });
   const mounted = await mountMcp(cfg, oauth);
   const agent = await makeAgent(args, ai, cfg, mounted.flatMap((m) => m.tools));
+  if (args.voice && !args.duplex) agent.options.tools = [...agent.options.tools ?? [], exitSessionTool(() => {
+    exitRequested = true;
+  })];
   const duplex = args.duplex;
   let dx;
+  let voiceIO;
   let editorRef;
   let workerOptions;
   let duplexPersist = () => {
@@ -6846,17 +7667,23 @@ async function repl(args, ai, cfg, cwd) {
     const host = {
       ...base,
       notify(e) {
+        if (e.kind === "text_delta" && voiceIO) {
+          voiceIO.speakDelta(e.message);
+          editorRef?.suspend();
+        }
         if (e.kind === "revoice_done") {
           base.flushText();
           process.stdout.write("\n");
+          voiceIO?.endSpeech();
           duplexPersist();
+          editorRef?.resume();
           editorRef?.redrawNow();
           return;
         }
         if (e.kind === "task_done" && e.data?.text) {
           const lines = String(e.data.text).split("\n");
           const shown = lines.slice(0, previewLines());
-          err("\r\x1B[2K\n" + dim(`  \u29BF ${e.message}
+          err("\r\x1B[0J\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)
@@ -6884,19 +7711,45 @@ async function repl(args, ai, cfg, cwd) {
     dx = new DuplexAgent({
       ai,
       fs: agent.options.fs,
-      ...args.voiceModel ? { voiceModel: resolveModelOrNewest(args.voiceModel) } : {},
+      ...args.voiceModel ?? cfg.voiceModel ? { voiceModel: resolveModelOrNewest(args.voiceModel ?? cfg.voiceModel) } : {},
       workerModel: agent.options.model,
       workerOptions,
       host,
-      ...args.voice ? { voiceStyle: "conversational" } : {},
+      ...args.voice ? { voiceStyle: "conversational", progressUpdates: true } : {},
+      // voice: narrate throttled worker progress (dead air is worse than a short aside)
       // 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 jail deny-lists .git/** (VCS internals can carry credentials), so the engine's fs-based
+      // 'branch' lookup can't see it — supply it host-side (one safe read-only file).
+      quickLook: {
+        branch: () => {
+          try {
+            const head = readFileSync5(join9(cwd, ".git", "HEAD"), "utf8").trim();
+            return head.startsWith("ref: refs/heads/") ? `branch: ${head.slice("ref: refs/heads/".length)}` : `detached HEAD at ${head.slice(0, 12)}`;
+          } catch {
+            return "not a git repository";
+          }
+        },
+        // Memory READS are QuickLook material (instant, capped); memory WRITES stay delegated —
+        // a worker creates/updates the files under .agent/memory/.
+        memory: async () => {
+          const dir = agent.options.memoryDir || adot("memory");
+          try {
+            const idx = await fs.readFile(`${dir}/MEMORY.md`);
+            return idx.slice(0, 2e3) || "(memory index is empty)";
+          } catch {
+            return "no memory yet \u2014 to save something, Delegate it (a worker writes .agent/memory/)";
+          }
+        }
+      },
       // 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] }
+      voiceOptions: { fs: agent.options.fs, hooks: displayHooks(agent.options.fs), tools: [rewindFilesTool, exitSessionTool(() => {
+        exitRequested = true;
+      })] }
     });
   }
   const face = dx ? dx.voice : agent;
@@ -6952,9 +7805,9 @@ async function repl(args, ai, cfg, cwd) {
   };
   const pendingImages = [];
   const grabClipboardAttachment = () => {
-    const dir = join8(tmpdir(), "agentx-pasted");
+    const dir = join9(tmpdir(), "agentx-pasted");
     try {
-      mkdirSync6(dir, { recursive: true });
+      mkdirSync7(dir, { recursive: true });
     } catch {
     }
     const img = grabClipboardImage(dir, String(Date.now()));
@@ -6963,15 +7816,17 @@ async function repl(args, ai, cfg, cwd) {
   process.on("SIGINT", () => {
     if (activeTurn) {
       activeTurn.abort();
+      voiceIO?.interrupt();
       return;
     }
+    voiceIO?.stop();
     void closeMcp(mounted);
     process.exit(130);
   });
   installCancelGuards(mounted);
   const store = new SessionStore(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 checkpoints = args.vfs || args.boddb ? new CheckpointStack(agent.options.fs) : new GitCheckpoints({ workTree: cwd, gitDir: join9(cwd, ".agent", "checkpoints.git"), addDirs: args.addDirs, sessionId: session.meta.id });
   const cpHooks = checkpoints.hooks?.();
   if (cpHooks) work.hooks = composeHooks(work.hooks, cpHooks);
   duplexPersist = () => {
@@ -6998,17 +7853,17 @@ async function repl(args, ai, cfg, cwd) {
   const fs = agent.options.fs;
   const fsBase = fs.getCwd() === "/" ? "" : fs.getCwd();
   const adot = (sub) => `${fsBase}/.agent/${sub}`;
-  const adots = (sub) => [adot(sub), `${fsBase}/.claude/${sub}`, `${homedir4()}/.agent/${sub}`, `${homedir4()}/.claude/${sub}`];
+  const adots = (sub) => [adot(sub), `${fsBase}/.claude/${sub}`, `${homedir5()}/.agent/${sub}`, `${homedir5()}/.claude/${sub}`];
   const cmds = (await loadCommands(fs, adots("commands"))).commands;
   const skills = (await loadSkills(fs, adots("skills"))).skills;
-  const histPath = join8(cwd, ".agent", "history");
-  const history = existsSync7(histPath) ? readFileSync5(histPath, "utf8").split("\n").filter(Boolean).reverse().slice(0, 500) : [];
+  const histPath = join9(cwd, ".agent", "history");
+  const history = existsSync8(histPath) ? readFileSync5(histPath, "utf8").split("\n").filter(Boolean).reverse().slice(0, 500) : [];
   const remember = (line) => {
     try {
-      mkdirSync6(join8(cwd, ".agent"), { recursive: true });
+      mkdirSync7(join9(cwd, ".agent"), { recursive: true });
       appendFileSync(histPath, line + "\n");
     } catch (e) {
-      log12.debug("history write failed", e);
+      log16.debug("history write failed", e);
     }
   };
   const ago = (t) => {
@@ -7066,7 +7921,7 @@ async function repl(args, ai, cfg, cwd) {
       try {
         store.save(session);
       } catch (e) {
-        log12.debug("session save after rewind failed", e);
+        log16.debug("session save after rewind failed", e);
       }
       err(green("  \u27F2 jumped back") + dim(` \u2014 ${face.transcript.length} message(s) kept; edit + resend
 `));
@@ -7090,10 +7945,15 @@ async function repl(args, ai, cfg, cwd) {
   const announcedTasks = /* @__PURE__ */ new Set();
   const turn = async (task) => {
     const r = await runTurn(face, store, session, task, duplex ? void 0 : checkpoints, cwd, sendVia);
+    if (voiceIO) {
+      process.stdout.write("\n");
+      editorRef?.resume();
+    }
+    voiceIO?.endSpeech();
     if (dx) {
       const fresh = [...dx.tasks.values()].filter((t) => t.status === "running" && !announcedTasks.has(t.id));
       fresh.forEach((t) => announcedTasks.add(t.id));
-      if (fresh.length) err(cyan(`  \u25D4 ${fresh.length === 1 ? `task ${fresh[0].id} (${fresh[0].label})` : `${fresh.length} tasks`} working in the background`) + dim(" \u2014 the result will appear here; keep chatting meanwhile\n"));
+      if (fresh.length) err("\r\x1B[0J" + cyan(`  \u25D4 ${fresh.length === 1 ? `task ${fresh[0].id} (${fresh[0].label})` : `${fresh.length} tasks`} working in the background`) + dim(" \u2014 the result will appear here; keep chatting meanwhile\n"));
     }
     return r;
   };
@@ -7261,6 +8121,26 @@ ${extra}` : body);
         else err(dim("  " + (duplex ? `voice ${dx.options.voiceModel} \xB7 worker ${work.model}` : work.model) + "\n"));
       }
     },
+    ...duplex ? { "voice-model": {
+      desc: "switch the duplex voice (fast) model \u2014 /voice-model <id>, or alone for a picker",
+      run: async (a) => {
+        const apply = (id) => {
+          const m = resolveModelOrNewest(id);
+          dx.options.voiceModel = m;
+          dx.voice.options.model = m;
+          err(green(`  \u2713 voice model \u2192 ${m}
+`));
+        };
+        if (a[0]) {
+          apply(a[0]);
+          return;
+        }
+        const picked = await pickModel(dx.options.voiceModel);
+        if (picked) apply(picked);
+        else err(dim(`  voice ${dx.options.voiceModel}
+`));
+      }
+    } } : {},
     reasoning: {
       desc: "extended thinking \u2014 /reasoning <off|low|medium|high|tokens>, or alone for an interactive picker (duplex: the workers')",
       run: async (a) => {
@@ -7489,7 +8369,7 @@ ${extra}` : body);
           }
           const m = mounted.splice(idx, 1)[0];
           removeWorkTools(m.tools.map((t) => t.name));
-          await m.client.close().catch((e) => log12.debug("mcp close failed", e));
+          await m.client.close().catch((e) => log16.debug("mcp close failed", e));
           err(dim(`  removed "${name}"
 `));
           return;
@@ -7604,10 +8484,10 @@ ${extra}` : body);
           return;
         }
         const md = exportMarkdown(session.meta, shown);
-        const name = a[0] ? extname(a[0]) ? a[0] : a[0] + ".md" : join8(".agent", "exports", `${session.meta.id}.md`);
+        const name = a[0] ? extname(a[0]) ? a[0] : a[0] + ".md" : join9(".agent", "exports", `${session.meta.id}.md`);
         const path = resolve3(cwd, name);
         try {
-          mkdirSync6(dirname3(path), { recursive: true });
+          mkdirSync7(dirname4(path), { recursive: true });
           writeFileSync6(path, md);
           err(green(`  \u2713 exported \u2192 ${path}
 `) + dim(`  ${shown.length} message(s) \xB7 ${md.length} chars
@@ -7628,9 +8508,9 @@ ${extra}` : body);
 `));
   const listDir = (absDir) => {
     try {
-      return readdirSync2(join8(cwd, absDir.replace(/^\/+/, "")), { withFileTypes: true }).map((d) => ({ name: d.name, dir: d.isDirectory() }));
+      return readdirSync2(join9(cwd, absDir.replace(/^\/+/, "")), { withFileTypes: true }).map((d) => ({ name: d.name, dir: d.isDirectory() }));
     } catch (e) {
-      log12.debug("completion readdir failed", absDir, e);
+      log16.debug("completion readdir failed", absDir, e);
       return null;
     }
   };
@@ -7645,21 +8525,57 @@ ${extra}` : body);
   let aborting = false;
   let pendingRewind = false;
   if (process.stdin.isTTY) {
+    const renderStashBuf = () => {
+      if (!stashBuf) return;
+      const q2 = inputStash.length ? dim(` [${inputStash.length} queued]`) : "";
+      err(`\r\x1B[K${dim("  stash \u203A ")}${stashBuf}${q2}`);
+    };
     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) {
-        aborting = true;
-        activeTurn.abort();
-        err(yellow("\n  \u238B cancelling\u2026\n"));
-      } else if (key?.name === "escape" && !pendingRewind) {
-        pendingRewind = true;
-        err(dim("  \u238B\u238B jumping back to edit\u2026\n"));
+      const k = key?.name;
+      const cancel = k === "escape" || key?.ctrl && k === "c";
+      if (cancel) {
+        if (stashBuf) {
+          stashBuf = "";
+          err("\r\x1B[K");
+          return;
+        }
+        if (!aborting) {
+          aborting = true;
+          activeTurn.abort();
+          voiceIO?.interrupt();
+          err(yellow("\n  \u238B cancelling\u2026\n"));
+        } else if (k === "escape" && !pendingRewind) {
+          pendingRewind = true;
+          err(dim("  \u238B\u238B jumping back to edit\u2026\n"));
+        }
+        return;
+      }
+      if (k === "return" || k === "enter") {
+        if (stashBuf.trim()) {
+          inputStash.push(stashBuf.trim());
+          err(`\r\x1B[K${green("  \u2713 stashed")} ${dim(`#${inputStash.length}: ${stashBuf.trim().slice(0, 50)}${stashBuf.trim().length > 50 ? "\u2026" : ""}`)}
+`);
+        }
+        stashBuf = "";
+        return;
+      }
+      if (k === "backspace") {
+        if (stashBuf.length) {
+          stashBuf = stashBuf.slice(0, -1);
+          if (stashBuf) renderStashBuf();
+          else err("\r\x1B[K");
+        }
+        return;
+      }
+      if (!key?.ctrl && !key?.meta && isPrintable(_s)) {
+        stashBuf += _s;
+        renderStashBuf();
+        return;
       }
     });
   }
@@ -7677,6 +8593,120 @@ ${extra}` : body);
   };
   let prefill;
   let tick = 0;
+  const dispatchLine = async (line) => {
+    history.unshift(line.replace(/\n+/g, " \u23CE "));
+    remember(line.replace(/\n+/g, " \u23CE "));
+    if (line.startsWith("!")) {
+      const cmd = line.slice(1).trim();
+      if (cmd) {
+        err(dim(await runShellLine(agent.options.fs, cmd) + "\n"));
+      }
+      return;
+    }
+    if (line.startsWith("#")) {
+      const note = line.slice(1).trim();
+      if (note) {
+        const where = await appendMemoryNote(agent.options.fs, agent.options.memoryDir || adot("memory"), note);
+        err(green(`  \u270E remembered \u2192 ${where}
+`));
+      }
+      return;
+    }
+    if (line.startsWith("/")) {
+      const [name, ...a] = line.slice(1).split(/\s+/);
+      if (!name) {
+        err(red("  / needs a command name\n") + dim("  (try /help)\n"));
+        return;
+      }
+      const b = builtins[name];
+      if (b) {
+        if (await b.run(a)) return "quit";
+        return;
+      }
+      const c = cmds.find((x) => x.name === name);
+      if (c) {
+        await runCommand(c, a.join(" "));
+        return;
+      }
+      const sk = skills.find((x) => x.name === name);
+      if (sk) {
+        await runSkill(sk, a.join(" "));
+        return;
+      }
+      const known = Object.keys(builtins).filter((k) => k !== "quit").map((k) => "/" + k);
+      const custom = [...cmds.map((x) => x.name), ...skills.map((x) => x.name)].map((n) => "/" + n);
+      err(red(`  unknown command /${name}
+`) + dim("  builtins: " + known.join(" ") + "\n") + (custom.length ? dim("  custom:   " + custom.join(" ") + "\n") : "") + dim("  (or /help)\n"));
+      return;
+    }
+    const task = pendingImages.length ? `${line} ${pendingImages.map((p) => "@" + p).join(" ")}` : line;
+    pendingImages.length = 0;
+    await turn(task);
+    if (exitRequested) return "quit";
+  };
+  let voicePartial = "";
+  let partialRedraw = null;
+  if (args.voice && duplex && process.stdin.isTTY) {
+    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 ? `
+[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}
+`);
+          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
+`));
+        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;
+      }
+    }
+  }
   while (true) {
     if (pendingRewind) {
       pendingRewind = false;
@@ -7684,6 +8714,7 @@ ${extra}` : body);
       if (t !== void 0) prefill = t;
     }
     aborting = false;
+    stashBuf = "";
     err("\n");
     const initial = prefill;
     prefill = void 0;
@@ -7692,12 +8723,17 @@ ${extra}` : body);
     const usd = session.meta.costUsd ?? 0;
     const computeFooter = () => {
       const parts = [];
+      if (voiceIO) {
+        const glyph = { listening: "\u{1F3A4}", thinking: "\u{1F4AD}", speaking: "\u{1F50A}", idle: "\xB7" }[voiceIO.state];
+        parts.push(voicePartial && voiceIO.state === "listening" ? `\u{1F3A4} ${voicePartial.slice(-60)}` : `${glyph} ${voiceIO.state}`);
+      }
       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 = work.reasoning;
       if (r && r !== "off") parts.push(`reasoning:${r}`);
       if (verboseOutput) parts.push("verbose");
+      if (inputStash.length) parts.push(`${inputStash.length} stashed (\u2303S to pop)`);
       const taskLines = [];
       if (dx) {
         const frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
@@ -7724,6 +8760,18 @@ ${extra}` : body);
         const picked = await pickModel(work.model);
         if (picked) setModel(picked);
         return picked;
+      },
+      onStash: (text) => {
+        inputStash.push(text);
+        err(`${green("  \u2713 stashed")} ${dim(`#${inputStash.length}: ${text.slice(0, 50)}${text.length > 50 ? "\u2026" : ""}`)}
+`);
+      },
+      onUnstash: () => {
+        if (!inputStash.length) return void 0;
+        const t = inputStash.pop();
+        err(dim(`  \u2191 unstashed${inputStash.length ? ` (${inputStash.length} left)` : ""}
+`));
+        return t;
       }
     }));
     if (result === null) break;
@@ -7733,59 +8781,27 @@ ${extra}` : body);
     }
     const line = result.trim();
     if (!line) continue;
-    history.unshift(line.replace(/\n+/g, " \u23CE "));
-    remember(line.replace(/\n+/g, " \u23CE "));
-    if (line.startsWith("!")) {
-      const cmd = line.slice(1).trim();
-      if (cmd) {
-        err(dim(await runShellLine(agent.options.fs, cmd) + "\n"));
-      }
-      continue;
-    }
-    if (line.startsWith("#")) {
-      const note = line.slice(1).trim();
-      if (note) {
-        const where = await appendMemoryNote(agent.options.fs, agent.options.memoryDir || adot("memory"), note);
-        err(green(`  \u270E remembered \u2192 ${where}
+    let quit = await dispatchLine(line) === "quit";
+    while (!quit && inputStash.length) {
+      const next = inputStash.shift();
+      err(dim(`  \u23CE stashed \u203A ${next.slice(0, 60)}${next.length > 60 ? "\u2026" : ""}
 `));
-      }
-      continue;
-    }
-    if (line.startsWith("/")) {
-      const [name, ...a] = line.slice(1).split(/\s+/);
-      if (!name) {
-        err(red("  / needs a command name\n") + dim("  (try /help)\n"));
-        continue;
-      }
-      const b = builtins[name];
-      if (b) {
-        if (await b.run(a)) break;
-        continue;
-      }
-      const c = cmds.find((x) => x.name === name);
-      if (c) {
-        await runCommand(c, a.join(" "));
-        continue;
-      }
-      const sk = skills.find((x) => x.name === name);
-      if (sk) {
-        await runSkill(sk, a.join(" "));
-        continue;
-      }
-      const known = Object.keys(builtins).filter((k) => k !== "quit").map((k) => "/" + k);
-      const custom = [...cmds.map((x) => x.name), ...skills.map((x) => x.name)].map((n) => "/" + n);
-      err(red(`  unknown command /${name}
-`) + dim("  builtins: " + known.join(" ") + "\n") + (custom.length ? dim("  custom:   " + custom.join(" ") + "\n") : "") + dim("  (or /help)\n"));
-      continue;
+      quit = await dispatchLine(next) === "quit";
     }
-    const task = pendingImages.length ? `${line} ${pendingImages.map((p) => "@" + p).join(" ")}` : line;
-    pendingImages.length = 0;
-    await turn(task);
+    if (quit) break;
   }
+  voiceIO?.stop();
   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)
+    const running = [...dx.tasks.values()].filter((t) => t.status === "running");
+    if (exitRequested && running.length) {
+      for (const t of running) {
+        t.status = "cancelled";
+        t.controller.abort();
+      }
+      err(dim(`  \u2026 cancelled ${running.length} background task(s)
+`));
+    } else if (running.length) {
+      err(dim(`  \u2026 waiting for ${running.length} background task(s) (Ctrl-C to force quit)
 `));
       await dx.idle();
       face.options.host?.flushText?.();
@@ -7861,7 +8877,7 @@ async function main() {
     }
   });
   if (args.task) {
-    const mounted = await mountMcp(cfg, new McpOAuth({ storePath: join8(cwd, ".agent", "mcp-auth.json") }));
+    const mounted = await mountMcp(cfg, new McpOAuth({ storePath: join9(cwd, ".agent", "mcp-auth.json") }));
     const agent = await makeAgent(args, ai, cfg, mounted.flatMap((m) => m.tools));
     const store = new SessionStore(cwd);
     const session = startSession(args, store, agent, cwd);