agent.libx.js 0.92.6 → 0.92.8

package/cli/cli.ts

@@ -983,9 +983,24 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
   let duplexPersist: () => void = () => {}; // bound once the session exists (re-voice fires async)
   let duplexAccount: (data: any) => void = () => {}; // worker cost → session meta (bound below)
   // Workers are non-interactive: a permission 'ask' can't pop a menu mid-conversation (it would fight
-  // the line editor for raw stdin). Auto-deny with a narratable reason — the worker adapts or reports
-  // back and the voice narrates it. Allow/deny rules (config, --allowedTools, --yes) apply as-is.
+  // the line editor for raw stdin). VOICE mode relays the ask through the conversation (park →
+  // '[task asks]' re-voice → spoken yes/no via AnswerTask; timeout → deny). Text duplex (and the
+  // relay's timeout path) auto-denies with a narratable reason — the worker adapts or reports back.
+  let permSeq = 0;
   const duplexAsk = async (call: ToolUse): Promise<{ decision: 'allow' | 'deny' }> => {
+    if (args.voice && dx) {
+      const hint = summarizeCall(call.name, call.args).slice(0, 80);
+      // NB: perm asks are keyed perm-N (PermissionPolicy.ask carries no task identity), so a
+      // cancelled task can't clean its parked perm question — bounded by askTimeoutMs → deny.
+      const id = `perm-${++permSeq}`;
+      err('\r\x1b[0J' + yellow(`  ? worker asks to run ${call.name}`) + dim(` ${hint} — say yes/no (or it auto-denies)\n`));
+      editorRef?.redrawNow();
+      const a = await dx.parkQuestion(id, `Permission: may the background worker run ${call.name}${hint ? ` (${hint})` : ''}? Yes or no.`);
+      const allow = /^\s*(y(es|ep|eah)?|sure|ok(ay)?|allow|go|approved?|do it)\b/i.test(a);
+      err('\r\x1b[0J' + dim(`  ${allow ? '✓ allowed' : '⊘ denied'} ${call.name} (${a.trim() || 'no answer'})\n`));
+      editorRef?.redrawNow();
+      return { decision: allow ? 'allow' : 'deny' };
+    }
     err('\r\x1b[0J' + yellow(`  ⊘ worker asked to run ${call.name} — auto-denied (no interactive approval in duplex; use --yes or --allowedTools)\n`));
     editorRef?.redrawNow(); // background event at a live prompt — repaint below the notice
     return { decision: 'deny' };
@@ -1073,7 +1088,7 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
       workerModel: agent.options.model,
       workerOptions,
       host,
-      ...(args.voice ? { voiceStyle: 'conversational' as const, progressUpdates: true } : {}), // voice: narrate throttled worker progress (dead air is worse than a short aside)
+      ...(args.voice ? { voiceStyle: 'conversational' as const, progressUpdates: true, askRelay: true } : {}), // voice: progress asides + worker questions relayed through the conversation
       // 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); },

package/dist/cli.js

@@ -3445,11 +3445,17 @@ var DuplexAgentOptions = class {
   progressUpdates = false;
   /** Min ms between progress re-voices per task. */
   progressIntervalMs = 25e3;
+  /** Relay worker questions (AskUserQuestion + permission asks via parkQuestion) through the VOICE:
+   *  the question re-voices as '[task <id> asks] …', the user answers conversationally, and the
+   *  voice model resolves it with the AnswerTask tool. Off → host.ask passthrough (text menus). */
+  askRelay = false;
+  /** Parked questions auto-resolve empty after this long (callers map '' to deny/best-judgment). */
+  askTimeoutMs = 12e4;
   /** 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. "[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_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.\n"[task t1 asks] \u2026" events are QUESTIONS from a background task \u2014 relay to the user in your own words, short, then end your turn. When the user answers, call `AnswerTask` with that id and their answer. NEVER answer on the user\'s behalf for permissions or risky operations; if their reply is ambiguous, confirm first.\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;
@@ -3459,6 +3465,8 @@ var DuplexAgent = class {
   seq = 0;
   pendingEvents = [];
   flushQueued = false;
+  /** Parked worker questions awaiting a (voice-relayed) user answer, keyed by ask id. */
+  pendingAsks = /* @__PURE__ */ new Map();
   constructor(options) {
     this.options = { ...new DuplexAgentOptions(), ...options };
     const o = this.options;
@@ -3481,7 +3489,7 @@ Today's date: ${(/* @__PURE__ */ new Date()).toDateString()}.`,
       // 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(), this.quickLookTool()]
+      tools: [...o.voiceOptions?.tools ?? [], this.delegateTool(), this.taskStatusTool(), this.cancelTaskTool(), this.quickLookTool(), this.answerTaskTool()]
     });
   }
   /** One user turn: the voice agent streams the reply (and may Delegate). Serialized with re-voice turns. */
@@ -3552,12 +3560,19 @@ ${recent}` : brief;
         report.output(chunk);
       }
     } : base;
+    const relayAsk = async (q2) => {
+      const opts = q2.options?.length ? ` Options: ${q2.options.map((x) => x.label).join(", ")}.` : "";
+      const a = await this.parkQuestion(id, `${q2.question}${opts}`);
+      return a || "(no answer from the user \u2014 use your best judgment and note the assumption)";
+    };
+    const workerHost = o.askRelay ? { ask: relayAsk } : o.host?.ask ? { ask: (q2) => o.host.ask(q2) } : void 0;
     const worker = new Agent({
       ai: o.ai,
       fs: o.fs,
       model: o.workerModel,
       ...o.workerOptions,
       // may override ai/fs/model/tools/… —
+      ...workerHost ? { host: workerHost } : {},
       ...hooks ? { hooks } : {},
       signal: controller.signal
       // …but never the per-task cancellation signal
@@ -3606,7 +3621,35 @@ ${recent}` : brief;
       }
     };
   }
+  /** Park a question under `askId` (a task id, or any unique key for permission asks): re-voices
+   *  '[task <id> asks] …' and resolves with the user's answer via AnswerTask — or '' on timeout/
+   *  task settle (callers map '' to deny / best-judgment). Workers never block forever. */
+  parkQuestion(askId, question) {
+    return new Promise((resolve4) => {
+      let settled = false;
+      const finish = (answer) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        this.pendingAsks.delete(askId);
+        resolve4(answer);
+      };
+      const timer = setTimeout(() => {
+        this.notify("task_ask_timeout", `task ${askId}: question timed out \u2014 proceeding without an answer`);
+        finish("");
+      }, this.options.askTimeoutMs);
+      this.pendingAsks.set(askId, { question, resolve: finish });
+      this.notify("task_ask", `task ${askId} asks: ${question}`, { id: askId, question });
+      this.queueRevoice(`[task ${askId} asks] ${question}
+(Relay this to the user in your own words. When they answer, call AnswerTask with id "${askId}" and their answer.)`);
+    });
+  }
+  /** Resolve any question a settling/cancelled task left parked (its answer can no longer matter). */
+  dropAsk(id) {
+    this.pendingAsks.get(id)?.resolve("");
+  }
   onWorkerSettled(id, res) {
+    this.dropAsk(id);
     const rec = this.tasks.get(id);
     if (res.finishReason === "aborted" || rec.status === "cancelled") {
       rec.status = "cancelled";
@@ -3626,6 +3669,7 @@ ${recent}` : brief;
     this.failTask(this.tasks.get(id), err2 instanceof Error ? err2.message : String(err2));
   }
   failTask(rec, msg) {
+    this.dropAsk(rec.id);
     rec.status = "error";
     log6.warn(`task ${rec.id} failed: ${msg}`);
     this.notify("task_error", `task ${rec.id} (${rec.label}) failed: ${msg}`);
@@ -3718,6 +3762,23 @@ ${recent}` : brief;
       }
     };
   }
+  answerTaskTool() {
+    return {
+      name: "AnswerTask",
+      description: `Relay the user's answer to a pending question from a background task (the "[task <id> asks]" events). Pass the id from the event and the user's answer.`,
+      parameters: {
+        type: "object",
+        required: ["id", "answer"],
+        properties: { id: { type: "string" }, answer: { type: "string", description: "the user's answer, verbatim or faithfully summarized" } }
+      },
+      run: async ({ id, answer }) => {
+        const ask = this.pendingAsks.get(String(id));
+        if (!ask) return `No pending question for '${id}' \u2014 it may have been answered already or timed out.`;
+        ask.resolve(String(answer ?? ""));
+        return `Answer relayed \u2014 task ${id} resumes.`;
+      }
+    };
+  }
   cancelTaskTool() {
     return {
       name: "CancelTask",
@@ -3805,6 +3866,18 @@ var VoiceEngineOptions = class {
   /** heuristic (non-AEC) energy barge-in tuning */
   bargeRmsMult = 2;
   bargeRmsFloor = 500;
+  /** Overlap turn-taking (AEC tier, needs player.pause/resume) — human phone-call model:
+   *  onset → PAUSE (exact-sample hold, nothing lost); sustained overlap → cede (interrupt; the LLM
+   *  re-enters). Brief overlaps that die out (backchannels — "mm-hm", decided by DURATION, not
+   *  vocabulary) resume from the precise sample and are dropped. false disables. */
+  overlapPause = true;
+  /** sustained overlap ≥ this → cede the turn */
+  overlapSustainMs = 350;
+  /** quiet for this long while paused → resume, drop the interjection */
+  overlapResumeMs = 700;
+  /** energy floor for "overlap candidate" — must sit ABOVE typical room ambient (~110 rms measured;
+   *  ungated ambient re-arming the resume timer forever was a live wedge). User speech ≫ 300. */
+  overlapRms = 300;
 };
 var VoiceEngine = class {
   options;
@@ -3835,6 +3908,13 @@ var VoiceEngine = class {
   // endpointed text held for the merge window
   pendingTimer = null;
   lastInterrupted = null;
+  // overlap (pause) tier state — AEC + pause-capable sinks only
+  pausedAt = 0;
+  overlapLoud = 0;
+  // loud chunks since pause (sustain must be real sound, not two clicks)
+  overlapLastLoudAt = 0;
+  // continuity guard: a gap re-arms the onset (sparse noise ≠ sustained speech)
+  resumeTimer = null;
   constructor(options) {
     this.options = { ...new VoiceEngineOptions(), ...options };
     const o = this.options;
@@ -3882,6 +3962,7 @@ var VoiceEngine = class {
       this.drainTimer = null;
     }
     this.interrupted = false;
+    this.resetOverlap(true);
     if (!this.speaking) this.player.markTurn();
     this.speaking = true;
     this.ctxOpen = true;
@@ -3916,6 +3997,10 @@ var VoiceEngine = class {
         this.drainTimer = null;
         return;
       }
+      if (this.pausedAt) {
+        this.drainTimer = setTimeout(settle, 250);
+        return;
+      }
       this.drainTimer = null;
       this.speaking = false;
       this.echoUntil = now() + 2500;
@@ -3947,6 +4032,7 @@ var VoiceEngine = class {
       clearTimeout(this.drainTimer);
       this.drainTimer = null;
     }
+    this.resetOverlap(false);
     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;
@@ -3961,6 +4047,7 @@ var VoiceEngine = class {
     this.setState("listening");
   }
   stop() {
+    if (this.resumeTimer) clearTimeout(this.resumeTimer);
     if (this.pendingTimer) clearTimeout(this.pendingTimer);
     if (this.drainTimer) clearTimeout(this.drainTimer);
     this.stt.stop();
@@ -3986,12 +4073,11 @@ var VoiceEngine = class {
   genuine(text) {
     const total = this.words(text).length;
     const novel = this.novelWords(text).length;
-    if (!novel) return false;
-    return novel >= 2 || novel / Math.max(1, total) > 0.5;
+    return novel > 0 && novel / Math.max(1, total) > 0.5;
   }
   handlePartial(text) {
     if (this.speaking) {
-      const barge = this.usingAec ? this.genuine(text) : this.novelWords(text).length >= (this.suspectUntil ? 1 : 2);
+      const barge = this.overlapCapable ? false : this.usingAec ? this.genuine(text) : this.novelWords(text).length >= (this.suspectUntil ? 1 : 2);
       if (barge) {
         const phase = this.ctxOpen ? "speaking" : "drain";
         this.interrupt();
@@ -4008,6 +4094,10 @@ var VoiceEngine = class {
     if (!this.echoActive() || (this.usingAec ? this.genuine(text) : this.novelWords(text).length >= 1)) this.options.onPartial(text);
   }
   handleUtterance(text) {
+    if (this.speaking && this.ctxOpen && this.overlapCapable) {
+      this.stt.reset();
+      return;
+    }
     if (this.echoActive() && (this.usingAec ? !this.genuine(text) : this.novelWords(text).length < 2)) {
       this.stt.reset();
       return;
@@ -4031,9 +4121,63 @@ var VoiceEngine = class {
     this.pendingUtt = "";
     if (text) this.options.onUtterance(text);
   }
+  get overlapCapable() {
+    return this.usingAec && this.options.overlapPause && !!this.player.pause && !!this.player.resume;
+  }
+  /** Overlap turn-taking (AEC tier): onset → pause (exact-sample hold); sustained → cede; died out
+   *  → resume. No vocabulary anywhere — duration and persistence decide (backchannels are short
+   *  and stop). Nothing is lost across a pause, so a false positive costs only a brief hold. */
+  handleOverlap(rms) {
+    const o = this.options;
+    if (!this.speaking || !this.overlapCapable) return;
+    if (rms < o.overlapRms) return;
+    const t = now();
+    if (!this.pausedAt) {
+      this.overlapLoud = t - this.overlapLastLoudAt <= 60 ? this.overlapLoud + 1 : 1;
+      this.overlapLastLoudAt = t;
+      if (this.overlapLoud < 3) return;
+      this.pausedAt = t;
+      this.player.pause();
+      this.armResume();
+      return;
+    }
+    if (t - this.overlapLastLoudAt > 300) {
+      this.pausedAt = t;
+      this.overlapLoud = 1;
+      this.overlapLastLoudAt = t;
+      this.armResume();
+      return;
+    }
+    this.overlapLastLoudAt = t;
+    this.overlapLoud++;
+    if (t - this.pausedAt >= o.overlapSustainMs && this.overlapLoud >= 4) {
+      const phase = this.ctxOpen ? "speaking" : "drain";
+      this.interrupt();
+      this.options.onBargeIn(phase);
+      return;
+    }
+    this.armResume();
+  }
+  armResume() {
+    if (this.resumeTimer) clearTimeout(this.resumeTimer);
+    this.resumeTimer = setTimeout(() => {
+      this.resumeTimer = null;
+      if (!this.pausedAt) return;
+      this.resetOverlap(true);
+    }, this.options.overlapResumeMs);
+  }
+  resetOverlap(resume) {
+    if (this.resumeTimer) {
+      clearTimeout(this.resumeTimer);
+      this.resumeTimer = null;
+    }
+    if (this.pausedAt && resume) this.player.resume?.();
+    this.pausedAt = 0;
+    this.overlapLoud = 0;
+  }
   /** energy two-stage barge-in (heuristic tier only): spike over echo baseline → pause + confirm via STT */
   handleLevel(rms) {
-    if (this.usingAec) return;
+    if (this.usingAec) return this.handleOverlap(rms);
     if (!this.speaking) {
       this.baseline = 0;
       this.hot = 0;
@@ -4983,6 +5127,102 @@ var NodeMicSource = class {
     }, 500).unref?.();
   }
 };
+var AecDuplexAudio = class {
+  constructor(bin) {
+    this.bin = bin;
+  }
+  bin;
+  aec = true;
+  proc = null;
+  stopped = false;
+  bytesWritten = 0;
+  startedAt = 0;
+  // --- AudioSource ---
+  start(onChunk) {
+    this.proc = spawn2(this.bin, [], { stdio: ["pipe", "pipe", "ignore"] });
+    this.proc.stdin.on("error", () => {
+    });
+    this.proc.on("exit", (c) => {
+      if (c && !this.stopped) log12.error(`aec duplex audio exited (${c}) \u2014 check mic permission / 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?.();
+  }
+  // --- AudioSink (frame writer; same played/drain byte-math as the ffplay Player) ---
+  frame(payload) {
+    const stdin = this.proc?.stdin;
+    if (!stdin || stdin.destroyed) return;
+    const hdr = Buffer.alloc(4);
+    hdr.writeUInt32LE(payload ? payload.length : 0);
+    stdin.write(hdr);
+    if (payload?.length) stdin.write(payload);
+  }
+  markTurn() {
+    this.frame(null);
+    this.bytesWritten = 0;
+    this.startedAt = 0;
+    this.pausedSince = 0;
+    this.pausedAccum = 0;
+  }
+  write(chunk) {
+    if (!this.startedAt) this.startedAt = now4();
+    this.bytesWritten += chunk.length;
+    this.frame(chunk);
+  }
+  playedMs() {
+    return this.startedAt ? now4() - this.startedAt - this.pausedMs() : 0;
+  }
+  drainMs() {
+    if (!this.startedAt) return 0;
+    const queuedMs = this.bytesWritten / (TTS_SAMPLE_RATE * 2) * 1e3;
+    return Math.max(0, queuedMs - (now4() - this.startedAt - this.pausedMs()));
+  }
+  /** barge-in: silence NOW (in-band flush) — the capture side keeps running */
+  kill() {
+    this.frame(null);
+    this.bytesWritten = 0;
+    this.startedAt = 0;
+    this.pausedSince = 0;
+    this.pausedAccum = 0;
+  }
+  /** overlap trail-off: exact-sample PAUSE (len==0xFFFFFFFF) / RESUME (len==0xFFFFFFFE) frames */
+  pausedSince = 0;
+  pausedAccum = 0;
+  ctl(code) {
+    const stdin = this.proc?.stdin;
+    if (!stdin || stdin.destroyed) return;
+    const f = Buffer.alloc(4);
+    f.writeUInt32LE(code, 0);
+    stdin.write(f);
+  }
+  pause() {
+    if (this.pausedSince) return;
+    this.pausedSince = now4();
+    this.ctl(4294967295);
+  }
+  resume() {
+    if (!this.pausedSince) return;
+    this.pausedAccum += now4() - this.pausedSince;
+    this.pausedSince = 0;
+    this.ctl(4294967294);
+  }
+  /** total paused time this turn — excluded from played/drain math (the tape held still) */
+  pausedMs() {
+    return this.pausedAccum + (this.pausedSince ? now4() - this.pausedSince : 0);
+  }
+};
 var VoiceIOOptions = class extends VoiceEngineOptions {
   sonioxApiKey = process.env.SONIOX_API_KEY ?? "";
   cartesiaApiKey = process.env.CARTESIA_API_KEY ?? "";
@@ -4991,11 +5231,13 @@ var VoiceIOOptions = class extends VoiceEngineOptions {
 var VoiceIO = class extends VoiceEngine {
   constructor(options) {
     const o = { ...new VoiceIOOptions(), ...options };
+    const bin = !o.stt || !o.player ? resolveAecBinary() : null;
+    const duplex = bin ? new AecDuplexAudio(bin) : null;
     super({
       ...o,
-      stt: o.stt ?? new SonioxSTT({ auth: o.sonioxApiKey, source: new NodeMicSource() }),
+      stt: o.stt ?? new SonioxSTT({ auth: o.sonioxApiKey, source: duplex ?? new NodeMicSource() }),
       tts: o.tts ?? new CartesiaTTS({ auth: o.cartesiaApiKey, voiceId: o.cartesiaVoiceId }),
-      player: o.player ?? new Player(),
+      player: o.player ?? duplex ?? new Player(),
       bargeRmsMult: Number(process.env.BARGE_RMS_MULT || o.bargeRmsMult),
       bargeRmsFloor: Number(process.env.BARGE_RMS_FLOOR || o.bargeRmsFloor)
     });
@@ -7720,7 +7962,21 @@ async function repl(args, ai, cfg, cwd) {
   };
   let duplexAccount = () => {
   };
+  let permSeq = 0;
   const duplexAsk = async (call) => {
+    if (args.voice && dx) {
+      const hint = summarizeCall(call.name, call.args).slice(0, 80);
+      const id = `perm-${++permSeq}`;
+      err("\r\x1B[0J" + yellow(`  ? worker asks to run ${call.name}`) + dim(` ${hint} \u2014 say yes/no (or it auto-denies)
+`));
+      editorRef?.redrawNow();
+      const a = await dx.parkQuestion(id, `Permission: may the background worker run ${call.name}${hint ? ` (${hint})` : ""}? Yes or no.`);
+      const allow = /^\s*(y(es|ep|eah)?|sure|ok(ay)?|allow|go|approved?|do it)\b/i.test(a);
+      err("\r\x1B[0J" + dim(`  ${allow ? "\u2713 allowed" : "\u2298 denied"} ${call.name} (${a.trim() || "no answer"})
+`));
+      editorRef?.redrawNow();
+      return { decision: allow ? "allow" : "deny" };
+    }
     err("\r\x1B[0J" + yellow(`  \u2298 worker asked to run ${call.name} \u2014 auto-denied (no interactive approval in duplex; use --yes or --allowedTools)
 `));
     editorRef?.redrawNow();
@@ -7794,8 +8050,8 @@ async function repl(args, ai, cfg, cwd) {
       workerModel: agent.options.model,
       workerOptions,
       host,
-      ...args.voice ? { voiceStyle: "conversational", progressUpdates: true } : {},
-      // voice: narrate throttled worker progress (dead air is worse than a short aside)
+      ...args.voice ? { voiceStyle: "conversational", progressUpdates: true, askRelay: true } : {},
+      // voice: progress asides + worker questions relayed through the conversation
       // 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) => {