@livx.cc/agentx 0.99.6 → 0.99.8

package/dist/index.js

@@ -1149,11 +1149,11 @@ var init_NodeDiskFilesystem = __esm({
         if (rel === "" || rel.startsWith("..")) return;
         const parts = rel.split(np.sep);
         let cur = this.baseDir;
-        const now4 = Date.now();
+        const now3 = Date.now();
         for (let i = 0; i < parts.length; i++) {
           cur = np.join(cur, parts[i]);
           const isLeaf = i === parts.length - 1;
-          if (!isLeaf && (this.verified.get(cur) ?? 0) > now4) continue;
+          if (!isLeaf && (this.verified.get(cur) ?? 0) > now3) continue;
           let st;
           try {
             st = await fsp.lstat(cur);
@@ -1163,7 +1163,7 @@ var init_NodeDiskFilesystem = __esm({
           if (st.isSymbolicLink()) throw new Error("File not found: symlink not permitted");
           if (!isLeaf) {
             if (this.verified.size > 1e4) this.verified.clear();
-            this.verified.set(cur, now4 + _NodeDiskFilesystem.VERIFY_TTL_MS);
+            this.verified.set(cur, now3 + _NodeDiskFilesystem.VERIFY_TTL_MS);
           }
         }
       }
@@ -4345,12 +4345,12 @@ var Scheduler = class {
     if (this.firing) return;
     this.firing = true;
     try {
-      const now4 = this.now();
+      const now3 = this.now();
       for (const job of this.jobs.values()) {
         if (job.status !== "active") continue;
         const due = this.nextFire(job);
-        if (due == null || due > now4) continue;
-        job.lastRun = now4;
+        if (due == null || due > now3) continue;
+        job.lastRun = now3;
         job.runs++;
         if ("at" in job.trigger) job.status = "done";
         try {
@@ -4883,1597 +4883,2262 @@ var EmotionStream = class {
   }
 };
 
-// src/voice/spokenSplitter.ts
-var OPEN = "<spoken>";
-var CLOSE = "</spoken>";
-var CLOSERS = `"')]}\xBB\u201D\u2019`;
-var hasSpeech = (s) => /[\p{L}\p{N}]/u.test(s);
-var SentenceCoalescer = class _SentenceCoalescer {
-  buf = "";
-  static isEnd(c) {
-    return c === "\n" || c === "." || c === "!" || c === "?" || c === "\u2026";
+// src/voice/engine.ts
+init_logging();
+var log10 = forComponent("VoiceEngine");
+var realClock = {
+  now: () => performance.now(),
+  setTimeout: (fn, ms) => setTimeout(fn, ms),
+  clearTimeout: (h) => clearTimeout(h)
+};
+var forSpeech = (t) => t.replace(/[*`#]+/g, "").replace(/(?<![\p{L}\p{N}])_([^_\n]+)_(?![\p{L}\p{N}])/gu, "$1").replace(/^[ \t]*[-•]\s+/gm, "").replace(/\s*[\u2013\u2014]\s*/g, ", ").replace(/[\u2010\u2011]/g, "-").replace(/\s*\|\s*/g, ", ").replace(/(\d)\s+%/g, "$1%").replace(/\.{3,}/g, ".");
+var normWord = (w) => w.toLowerCase().replace(/[^a-z0-9]/g, "");
+var SPEC_TRAILING_OK = /* @__PURE__ */ new Set(["please", "thanks", "thank", "you", "now", "okay", "ok", "kindly", "alright", "then", "though", "right", "yeah"]);
+function speculationConfirms(spec, final) {
+  const sw = spec.trim().split(/\s+/).map(normWord).filter(Boolean);
+  const fw = final.trim().split(/\s+/).map(normWord).filter(Boolean);
+  if (!sw.length || fw.length < sw.length || fw.length > sw.length + 2) return false;
+  for (let i = 0; i < sw.length - 1; i++) if (sw[i] !== fw[i]) return false;
+  if (!fw[sw.length - 1].startsWith(sw[sw.length - 1])) return false;
+  for (let i = sw.length; i < fw.length; i++) if (!SPEC_TRAILING_OK.has(fw[i])) return false;
+  return true;
+}
+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 = "";
+  /** ADAPTIVE micro-ack: on an utterance-dispatched turn, speak a short varied ack ONLY if no reflex
+   *  delta has arrived after this many ms (masks a slow TTFT without acking every turn — a fixed
+   *  per-turn ack was rejected as robotic). First delta / interrupt / hold cancels it. 0 = off. */
+  adaptiveAckMs = 0;
+  /** the adaptive ack actually fired (host can mark the turn as spoken — e.g. suppress dead-air repair) */
+  onAdaptiveAck = () => {
+  };
+  /** 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;
+  /** Extended merge window (ms) for utterances that look incomplete (trailing conjunction/filler).
+   *  Gives the user time to finish their thought without triggering a model call. */
+  incompleteMergeMs = 1500;
+  /** Grace window (ms) after an utterance dispatches, during which the user's own trailing audio cannot
+   *  barge the reply it requested. Soniox keeps finalizing partials past <end>; without this they read
+   *  as a barge and abort the fresh turn (live: mid-sentence self-interruption + steps=1→steps=0 double
+   *  abort). Short enough that a genuine immediate barge ("no wait—") still lands right after. */
+  bargeGraceMs = 600;
+  /** Barge-in (talk over the assistant to interrupt). true = full-duplex (needs echo cancellation, or
+   *  the assistant's own TTS bleeds back and self-interrupts). false = HALF-DUPLEX: the engine is deaf
+   *  while audible (speaking + drain tail), so echo can never become a phantom turn — the right mode
+   *  when there's no AEC (e.g. the non-VPIO mic fallback) and no headphones. Cost: can't interrupt. */
+  bargeIn = true;
+  /** Filler phrase spoken when holding for an incomplete utterance ('' disables). */
+  holdFiller = "";
+  /** Called when the engine holds an incomplete utterance (host can render a visual cue). */
+  onHold = () => {
+  };
+  /** heuristic (non-AEC) energy barge-in tuning */
+  bargeRmsMult = 2;
+  bargeRmsFloor = 500;
+  /** Overlap turn-taking (AEC tier, needs player.pause/resume) — human phone-call model, driven by
+   *  the STT ITSELF (a trained speech classifier) instead of energy thresholds (energy could not
+   *  separate residue bursts from speech in every room — hiccup whack-a-mole): a GENUINE partial
+   *  (novel words dominate — echo of our own reply is inert) while speaking → PAUSE (exact-sample
+   *  hold); partial grows into dominant-novel ≥2 words → cede (interrupt; the LLM re-enters); partial
+   *  stalls/endpoints without ceding (backchannel by DURATION, not vocabulary) → resume + drop. false disables. */
+  overlapPause = true;
+  /** no new partial activity for this long while paused → resume, drop the interjection */
+  overlapResumeMs = 700;
+  /** A genuine barge over a LONG reply is defeated by the dominant-novel gate: Meet echoes our own
+   *  speech back, so the partial is mostly our words + a few of hers → never "dominant novel" → it
+   *  resumes (replaying old audio — the audible "completes the buffer" blip) instead of ceding.
+   *  Mechanism-based discriminator: a re-PAUSE this soon after a resume = a persistent human, not an
+   *  echo blip (which pauses once and stalls). Cede on the re-pause regardless of the novel gate. */
+  overlapRepauseCedeMs = 1500;
+  /** Speculative ENERGY pre-pause while speaking (AEC tier): two residue gate-passes within 350ms →
+   *  pause ~300ms before the STT tokens land. But energy CANNOT separate residue bursts from speech
+   *  (the documented whack-a-mole) — so a residue spike during loud playback false-pauses with NO user
+   *  speech at all, an audible hiccup. Default OFF: the genuine-gated STT partial is the
+   *  mechanism-correct pause trigger; enable only if barge-in onset feels sluggish in a clean-AEC room. */
+  overlapEnergyHold = false;
+  /** SPECULATIVE REFLEX START (the root TTFT fix): a partial transcript that has stopped changing for
+   *  this many ms AND carries ≥ speculativeMinWords is "stable" — `onSpeculate` fires so the host can
+   *  start the reflex EARLY, ~endpoint+merge (500-850ms) before the final would dispatch. The
+   *  speculative call's output is HELD by the host (nothing reaches TTS) until the endpointed final
+   *  confirms it (see speculationConfirms). At most one speculation per turn-in-progress. 0 = off. */
+  speculativeMs = 0;
+  /** Minimum word count for a partial to qualify as a speculation trigger. */
+  speculativeMinWords = 4;
+  /** A stable partial (speculativeMs) — the host starts a HELD speculative reflex call. */
+  onSpeculate = () => {
+  };
+  /** AGENT-SIDE BACKCHANNELING (rule-based v1): while LISTENING to a long multi-clause user turn, a
+   *  partial that reaches a clause boundary (trailing [,.;!?] or conjunction/filler) and then stays
+   *  UNCHANGED for this many ms (a micro-pause — before the silence endpoint fires) triggers a short
+   *  quiet TTS blip ("Mm-hm.") on a throwaway context. ZERO floor-claim: no state change, no timers
+   *  touched, no turn context — audio passes a narrow gate bypass and a real turn supersedes it via
+   *  context rotation. Latin-predominant partials only (Hebrew/mixed text never misfires — the
+   *  boundary/conjunction heuristics are English-tuned, so non-Latin turns simply get no blips).
+   *  0 = off (default). ~200-300 recommended: live, Soniox's SEMANTIC endpoint (<end>) lands within
+   *  ~300-400ms of a clause pause — a longer stability window loses the race and never fires. */
+  backchannelMs = 0;
+  /** Min gap between blips (rate limit); additionally max 2 blips per user turn-in-progress. */
+  backchannelMinGapMs = 8e3;
+  /** Only multi-clause turns: the partial must carry at least this many words before a blip. */
+  backchannelMinWords = 8;
+  /** A backchannel blip was spoken (host renders a timeline event; the blip is NOT a reply). */
+  onBackchannel = () => {
+  };
+  /** The partial outgrew the speculated text (user kept talking) — the host aborts the speculation
+   *  quietly (the endpointed final will also refuse to confirm; this just stops the billing earlier). */
+  onSpeculateAbort = () => {
+  };
+  /** Map inline `[emotion]` tags (emitted by the model, prompt-taught) into Cartesia inline emotion
+   *  tags in the spoken transcript (sonic-3 stitches the prosody). false = strip them silently. */
+  emotions = true;
+  /** Show the `[emotion]` tags in the on-screen echo (debug). false = hide (spoken-only). */
+  showEmotions = false;
+  /**
+   * Progressive text reveal — the "karaoke" capability, opt-in.
+   *   'off'   — no reveal events (CLI default; the host renders text however it likes).
+   *   'delta' — emit `onReveal(fullText)` as each spoken delta lands (near-free; text grows
+   *             in step with the model stream).
+   *   'word'  — reveal word-by-word synced to the TTS playback CLOCK (true karaoke). Requires a
+   *             timestamp-emitting TTS (CartesiaTTS.wantTimestamps) driven over `AudioSink.playedMs`.
+   */
+  revealMode = "off";
+  /** Called with the cumulative revealed text for the current assistant turn (see `revealMode`).
+   *  Reset to '' at the start of each spoken turn. */
+  onReveal = () => {
+  };
+  /** Time source for every engine timer/timestamp. Default: real time (identical behavior). */
+  clock = realClock;
+  /** Structured diagnostic event at every decision point (state transitions, dispatch/drop paths,
+   *  barge-in, overlap pause/resume, acks, speculation, backchannels, echo swallows). Fire-and-forget:
+   *  a throwing handler is caught once and diagnostics disable — engine behavior is never affected. */
+  onDiag = () => {
+  };
+};
+var VoiceEngine = class _VoiceEngine {
+  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
+  revealText = "";
+  // cumulative revealed (on-screen) text for the current turn — see revealMode
+  // 'word' karaoke reveal: spoken-word start times (sec, absolute from turn-audio start) + poll state.
+  wordStarts = [];
+  revealedN = 0;
+  revealPoll = null;
+  clock;
+  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
+  lastAck = "";
+  // the exact ack text last spoken (fixed OR adaptive) — the echo-leak guard matches it
+  ackTimer = null;
+  // one-shot adaptive-ack timer (armed at dispatch, cancelled on first delta)
+  bargeGraceUntil = 0;
+  // no barge-in until this time — the user's OWN trailing audio (after the
+  // utterance that JUST dispatched this turn) must not immediately re-interrupt the reply it requested.
+  pendingUtt = "";
+  // endpointed text held for the merge window
+  mergePath = "direct";
+  // how the pending utterance was assembled (diag)
+  lastGraceDiag = 0;
+  // grace_suppress emitted once per grace window
+  pendingTimer = null;
+  // Duplicate-final guard: STT sometimes re-finalizes the SAME audio a beat later (past the merge
+  // window) — the identical utterance dispatched twice with no reply in between (live: "When you
+  // start" twice). Conservative: only an IDENTICAL (normalized) text, within dupFinalMs, with zero
+  // reply deltas since the first dispatch, is dropped. A user genuinely repeating themselves after
+  // the agent replied (or after 3s) still dispatches.
+  lastDispatchFlat = "";
+  lastDispatchWords = [];
+  lastDispatchAt = 0;
+  repliedSinceDispatch = false;
+  static DUP_FINAL_MS = 3e3;
+  lastInterrupted = null;
+  // overlap (pause) tier state — AEC + pause-capable sinks only
+  pausedAt = 0;
+  lastResumeAt = 0;
+  // when the overlap last resumed from a false alarm — a quick re-pause cedes
+  lastOverlapPartial = "";
+  // change-detection: only NEW partial text counts as activity
+  resumeTimer = null;
+  turnStartAt = 0;
+  // timestamp when the current turn began (for TTFT logging)
+  // speculative reflex trigger state (options.speculativeMs) — see trackSpeculation
+  specPartial = "";
+  // last partial observed (stability = unchanged for speculativeMs)
+  specTimer = null;
+  specText = "";
+  // text handed to onSpeculate ('' = no speculation in flight)
+  specSpent = false;
+  // at most one speculation per turn-in-progress
+  // backchannel blip state (options.backchannelMs) — see trackBackchannel
+  bcPartial = "";
+  // last partial observed (stability = unchanged for backchannelMs)
+  bcTimer = null;
+  bcCount = 0;
+  // blips this user turn-in-progress (max 2; reset at dispatch)
+  bcActive = false;
+  // NARROW audio-gate bypass: blip audio may reach the sink while listening
+  bcActiveTimer = null;
+  // safety: clear the bypass even if the blip's 'done' is lost
+  lastBcAt = 0;
+  lastBcPhrase = "";
+  // exact blip text last spoken — flushUtterance strips its mic echo
+  recentBc = [];
+  // Central speech queue (above the TTS context): complete worker utterances serialize into ONE
+  // playback stream, one-at-a-time, never splicing into the live reflex's open utterance.
+  uttQueue = [];
+  // Per-turn emotion-tag parser (reset on beginSpeech) — converts `[emotion]` → Cartesia inline tags
+  // for TTS, tracks tag-free prose for echo discrimination, and surfaces display text for the screen.
+  emo = 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;
+    this.clock = o.clock;
   }
-  feed(delta) {
-    if (delta) this.buf += delta;
-    let cut = -1;
-    for (let i = 0; i < this.buf.length; i++) if (_SentenceCoalescer.isEnd(this.buf[i])) cut = i;
-    if (cut < 0) return "";
-    if (this.buf[cut] !== "\n") while (cut + 1 < this.buf.length && CLOSERS.includes(this.buf[cut + 1])) cut++;
-    const ready = this.buf.slice(0, cut + 1).trim();
-    this.buf = this.buf.slice(cut + 1);
-    return hasSpeech(ready) ? ready : "";
+  async start() {
+    this.tts.onAudio = (c) => {
+      if (this.speaking || this.bcActive) this.player.write(c);
+    };
+    if (this.options.revealMode === "word") {
+      this.tts.wantTimestamps = true;
+      this.tts.onTimestamps = (_words, start) => {
+        if (this.interrupted) return;
+        for (const s of start) this.wordStarts.push(s);
+      };
+    }
+    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.tts.warmup?.();
+    this.setState("listening");
+    log10.debug(`voice I/O up (${this.stt.usingAec ? "AEC" : "heuristic echo"} capture)`);
   }
-  flush() {
-    const s = this.buf.trim();
-    this.buf = "";
-    return hasSpeech(s) ? s : "";
+  get usingAec() {
+    return this.stt.usingAec;
   }
-};
-var SpokenSplitter = class {
-  buf = "";
-  inSpoken = false;
-  /** True once any spoken char has ever been emitted (drives the no-spoken fallback). */
-  spokeAny = false;
-  /** Feed a delta; returns the spoken/detail spans completed by this chunk (either may be ''). */
-  feed(delta) {
-    this.buf += delta;
-    return this.drain(false);
+  /** Flip barge-in at runtime (e.g. the mic fell back to non-VPIO → go half-duplex so echo can't leak). */
+  setBargeIn(on) {
+    this.options.bargeIn = on;
   }
-  /** Drain any buffered partial. A trailing `<…` that never completed a tag is emitted as detail. */
-  flush() {
-    return this.drain(true);
+  /** Show/hide the `[emotion]` debug tags in the echo (next turn's stream picks it up). */
+  setShowEmotions(on) {
+    this.options.showEmotions = on;
   }
-  drain(final) {
-    let spoken = "";
-    let detail = "";
-    while (this.buf.length) {
-      const tag = this.inSpoken ? CLOSE : OPEN;
-      const idx = this.buf.indexOf(tag);
-      if (idx >= 0) {
-        const text2 = this.buf.slice(0, idx);
-        if (this.inSpoken) spoken += text2;
-        else detail += text2;
-        this.buf = this.buf.slice(idx + tag.length);
-        this.inSpoken = !this.inSpoken;
-        continue;
-      }
-      const lt = this.buf.lastIndexOf("<");
-      const holdStart = lt >= 0 && tag.startsWith(this.buf.slice(lt)) ? lt : this.buf.length;
-      const text = this.buf.slice(0, holdStart);
-      if (this.inSpoken) spoken += text;
-      else detail += text;
-      this.buf = this.buf.slice(holdStart);
-      break;
+  /** Diagnostics tap (options.onDiag). Fire-and-forget: a throwing handler disables the tap once —
+   *  it can NEVER perturb engine behavior. Protected so VoiceIO can route provider events through it. */
+  diagOn = true;
+  diag(kind, fields) {
+    if (!this.diagOn) return;
+    try {
+      this.options.onDiag({ t: this.clock.now(), kind, ...fields });
+    } catch (e) {
+      this.diagOn = false;
+      log10.debug(`onDiag threw \u2014 diagnostics disabled: ${e instanceof Error ? e.message : e}`);
     }
-    if (final && this.buf) {
-      if (this.inSpoken) spoken += this.buf;
-      else detail += this.buf;
-      this.buf = "";
+  }
+  idleWaiters = [];
+  setState(s) {
+    if (this.state === s) return;
+    this.diag("state", { from: this.state, to: s });
+    this.state = s;
+    this.options.onState(s);
+    if (s !== "speaking" && s !== "thinking") {
+      for (const r of this.idleWaiters.splice(0)) r();
     }
-    if (spoken.trim()) this.spokeAny = true;
-    return { spoken, detail };
   }
-};
-
-// src/duplex.ts
-var log10 = 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 all tiers (routed by model). */
-  ai;
-  /** The WORKER's filesystem (act + think). If omitted the worker keeps Agent's jailed-disk-at-cwd default. */
-  fs;
-  // The reflex IS the voice. 120b (not 20b) for channel discipline + instruction-following: the 20b
-  // mislabels gpt-oss harmony channels under load, leaking raw analysis into the spoken `final` channel
-  // (and misfiring Hold). 120b is the same price tier (~$0.15/$0.60) — the quality/cost trade is free.
-  reflexModel = "groq/openai/gpt-oss-120b";
-  actModel = "anthropic/claude-sonnet-4-6";
-  /** Premium reasoning model. Set to `false` to disable the Think tier entirely. */
-  thinkModel = "anthropic/claude-opus-4-8";
-  /** Per-worker providerOptions, derived from the worker's actual model at spawn time (IoC — keeps duplex
-   *  provider-agnostic). Workers override the reflex/main model, so provider-specific options (e.g. cursor's
-   *  cwd/cursorSession) must be recomputed for the worker's model, never inherited from the main template —
-   *  leaking cursor options to an anthropic worker is a hard 400. Returns undefined → no providerOptions. */
-  providerOptionsFor;
-  /** Escape hatches merged over the derived per-agent options. */
-  reflexOptions;
-  actOptions;
-  thinkOptions;
-  /** Fresh-context check on each successful Act task: a NEW agent (no self-confirmation bias) re-reads
-   *  the file state against the brief and fixes any gap before the result is re-voiced. Bounded to one
-   *  pass; ~2x Act cost so default OFF. The self-verify FOOTER (same context) was measured ineffective —
-   *  this is the structural fix (see mind/10). Think tasks are pure reasoning, never checked. */
-  verifyActTasks = false;
-  /** Receives the voice text_delta stream + task lifecycle events. */
-  host;
-  /** How many recent transcript messages are rendered into a worker's brief. */
-  excerptTurns = 6;
-  /** Voice register: 'neutral' = clean spoken style; 'conversational' = human-like — fillers,
-   *  backchannels, impulsive first reactions before content (mimics real duplex conversation). */
-  voiceStyle = "neutral";
-  /** Teach the model to emit inline `[emotion]` tags for Cartesia emotion control. Only set when the
-   *  TTS actually speaks them — text-duplex (no TTS) would otherwise print literal tags. */
-  emotionTags = false;
-  /** Awaited BEFORE a 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;
-  /** 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;
-  /** Max retained task records: oldest SETTLED tasks (and their activity tails) are evicted past this,
-   *  bounding memory over a long-lived session. Running tasks are never evicted. */
-  maxTaskRecords = 50;
-  /** 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;
-  /** Memory directory/directories on the WORKER fs. If set, the voice agent gets Remember + Recall
-   *  tools directly (no delegation needed) and implicit capture guidance. */
-  memoryDir;
-  /** User-scope memory dir for global facts (type=user/feedback). Forwarded to Remember's routing. */
-  memoryUserDir;
-};
-var RESERVED_EVENT_MARKER = /\[task\b[^\]\n]*\b(?:completed|failed|progress|asks)\b/i;
-var RESERVED_EVENT_OPENER = /\[\s*task\b/i;
-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.\nThis holds even when asked to "print", "list", "show", or "make a table" \u2014 there is no screen for the spoken channel. Speak it as flowing prose ("Tuesday is half a meter, Wednesday a bit less\u2026"), or if they truly need it on screen, route it to Act to render. Never emit dashes or pipes into speech.\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 have three cognitive tiers \u2014 like a human brain:\n\u2022 YOU (reflex) \u2014 instant, lightweight. Handle greetings, simple questions, status checks, QuickLook.\n\u2022 `Act` \u2014 your hands. A background worker with its own configured tools and access to the user\'s environment (files and shell{{WORKER_WEB}}). Use for reading, editing, searching, running tasks, building \u2014 any real work.\n{{THINK_SLOT}}\nWhen you are unsure whether you can do or access something, do NOT assume and do NOT claim a capability you have not confirmed. To check what you can do, QuickLook `capabilities` (instant \u2014 it lists your worker\'s real tools) and answer from that. Never promise an ability that is not in your capabilities; if it is not there, tell the user plainly you can\'t. To actually DO real work, call `Act`. When the user mentions their project, folder, files, or environment ("this project", "the current folder", "my code"), call `Act` 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.\nYou cannot mute the microphone or stop voice capture yourself \u2014 no tool does it. If the user asks you to stop listening or turn the voice off, never claim you did: tell them to say exactly "voice off" (handled by the app directly), or type /voice.\nYou are NOT a knowledge base. For any question whose answer needs SPECIFIC verifiable facts you do not already have in hand \u2014 how to build/configure/implement something, exact API, library, entitlement, command or option names, current events, or particular numbers, dates, or names \u2014 do NOT answer from your own memory: you will confidently make things up (a fake API, a wrong entitlement, an event that did not happen). Route it to `Act`, which can search and verify, and speak only what its report says. Answer inline ONLY for general conversation, chit-chat, and trivia you are sure of, or facts you can see via QuickLook. When elaborating on a completed task ("tell me more", "the gist"), stay strictly within what that result actually said \u2014 if the user asks for something the result did not cover, that is NEW information: dispatch `Act`, do not improvise.\nALWAYS react before you work: the FIRST thing in your turn is a brief spoken acknowledgement of what you heard and what you are about to do ("got it \u2014 opening that now", "sure, let me pull it up", "okay, checking"). NEVER call a tool (Act, Think, QuickLook) silently \u2014 the user must hear you react before you go quiet to work. After dispatching Act or Think, that same one short sentence IS your turn \u2014 end it and do not wait for the result.\nA completed task speaks its OWN result to the user (the worker voices what matters as it finishes) \u2014 you do NOT re-voice clean task results. A FAILED or INCOMPLETE task still arrives as a "[task t1 failed] \u2026" event for you to handle. The completed result stays in YOUR context \u2014 it is yours to draw on. When the user follows up ("tell me more", "what else", "and?"), answer FROM that result first: you already have the detail, so elaborate on what you have. Do NOT spawn a fresh worker to re-search or re-gather what you were just handed. Re-dispatch ONLY when genuinely new information is needed \u2014 e.g. the user wants the full contents of a SPECIFIC source, which is one WebFetch of that URL, not a brand-new search. "[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.\nCRITICAL: while a task is still running you have NO answer yet \u2014 never state a specific result of any kind (a number, size, count, name, path, or value). The real answer arrives ONLY in the "[task \u2026 completed]" event; inventing one meanwhile (a made-up disk size, commit count, etc.) is a serious error. Until then, only acknowledge and wait.\nNever read raw file paths, diffs, or code aloud verbatim.\nDo NOT end every turn with the same canned offer ("want a rundown?", "want the steps?"). Offer once at most; if the user pushes back, repeats themselves, or sounds unsatisfied ("you know what I mean?", "think deeper", "are you sure?"), do NOT re-offer the same thing \u2014 change approach: dispatch `Act`/`Think` to actually dig in, or ask one concrete clarifying question. Repeating a non-answer is worse than silence.\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.\nIf the user\'s message sounds INCOMPLETE \u2014 trailing off mid-sentence, a fragment that needs more context ("and then we", "but the problem is"), hesitation fillers ("uh", "um") \u2014 call `Hold` instead of answering. This keeps listening for the rest of their thought. Only respond with substance when you have a complete question or request.\nDispatch discipline: send ONE self-contained task per request \u2014 a single worker with the full brief beats several workers with fragments (each worker starts fresh and re-discovers context). NEVER dispatch a worker just to read files or gather information \u2014 workers explore and discover context themselves; pass on what you already know and let one worker do the whole job. Split into parallel tasks only when the user asks for genuinely independent things. When a task completes, report its result and stop \u2014 do NOT dispatch follow-up work (verification, polish, extras) the user did not ask for, unless the report itself signals failure or doubt.\nDo not fire a second Act/Think for work already in flight, and NEVER spawn a second task to re-count, cross-check, or verify a result a worker already gave you \u2014 trust its answer; a single question gets ONE task. Call `TaskStatus` at most ONCE per turn; if a task is still running, just say "still on it" and end the turn \u2014 never poll it again and again in a loop. 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 act, do not check status, just exit.\nFor TRIVIAL instant lookups only \u2014 current time, git branch, listing a folder, peeking at a small file, or checking your own `capabilities`/tools \u2014 use `QuickLook` (instant, no task). Whenever the user asks what you can do or whether you have some ability, QuickLook `capabilities` and answer from that \u2014 never guess. Anything requiring searching, reasoning, running commands, or editing goes through `Act`.\n{{MEMORY_SLOT}}\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, surprising, or only half-parses, do NOT guess an action or improvise content from it \u2014 briefly confirm what they meant ("did you mean\u2026?") and wait. A one-line confirm beats a confident wrong answer or an invented response to a request you did not actually understand.';
-var THINK_GUIDANCE = "\u2022 `Think` \u2014 your brain. A premium reasoning model, FAR more expensive than Act. Reserve it for open-ended architecture/design questions, or a problem Act already FAILED at. ALL implementation work \u2014 coding, refactoring, debugging, edge cases, tests \u2014 goes to Act; Act is highly capable. Never send the same work to both.";
-var THINK_DISABLED_GUIDANCE = "(Think tier is not available \u2014 use Act for all escalations.)";
-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 escalate to Act or Think, 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 act", no task ids out loud).`;
-var EMOTION_TAGS_GUIDANCE = `EMOTION: your voice is synthesized with emotion control. Prefix a sentence with an inline [emotion] tag, placed directly before the sentence it colors, to shape how it is spoken. Use it ONLY when the emotion genuinely fits the words (it amplifies real feeling, it cannot fake it) \u2014 do not tag every sentence; reserve it for moments that carry feeling, and vary which one you use. You may also drop [laughter] for a natural laugh. Available emotions: ${EMOTIONS.join(", ")}.`;
-var DuplexAgent = class _DuplexAgent {
-  options;
-  voice;
-  tasks = /* @__PURE__ */ new Map();
-  queue = Promise.resolve();
-  seq = 0;
-  pendingEvents = [];
-  /** Out-of-band follow-up attribution for the events coalescing into the next flush turn: TRUE iff ≥1 of
-   *  the tasks being integrated was NON-CLEAN (early-stop/failure). Carried out-of-band on the enqueue call
-   *  by the caller that KNOWS the outcome — a plain boolean the MODEL CANNOT PERTURB. It is NOT scanned from
-   *  worker-authored event text (v1: an "Outcome:" substring over-stamped siblings) and NOT keyed on a brief
-   *  string the reflex re-authors (v2: a paraphrased escalation brief missed the Set → followUp:false →
-   *  RE-ENABLED unbounded auto-escalation, the dangerous runaway direction). See [[wrong-discriminator]] /
-   *  [[drive-real-reflex]] / [[fakeaiclient-blind-to-wire-format]]. */
-  pendingNonClean = false;
-  flushQueued = false;
-  /** Per-voice-turn guards (reset by resetTurn at each turn's start). The reflex is a weak model:
-   *  left unguarded it polls TaskStatus after a dispatch and/or dispatches silently (dead air).
-   *  Like CC's Task tool, a dispatch is "said my piece, now wait for the push" — these enforce that. */
-  turnDispatched = false;
-  // an Act/Think fired this turn
-  turnBriefs = /* @__PURE__ */ new Set();
-  // briefs dispatched this turn (detect identical re-dispatch)
-  spokeThisTurn = false;
-  // any non-empty text_delta streamed this turn
-  heldThisTurn = false;
-  // Hold called this turn → turn is INTENTIONALLY silent (suppress reflex text + no dead-air ack)
-  nudging = false;
-  // re-ack pass in flight: block ALL tools, prevent recursion
-  reflexBuf = "";
-  // accumulated reflex text this turn (fabricated-event detection)
-  reflexForwarded = 0;
-  // chars of reflexBuf already forwarded to the host/TTS
-  fabricationCut = false;
-  // reflex emitted a reserved [task …] marker → suppress its tail
-  /** TRUE for the duration of a re-voice turn that is integrating ≥1 NON-CLEAN task (turn-eligibility,
-   *  carried out-of-band — NOT derived from any worker/brief string). ANY Act/Think dispatched in such a
-   *  turn is stamped followUp:true. This GUARANTEES the dangerous direction is impossible: a genuine
-   *  escalation (even one with a paraphrased brief) ALWAYS lands in a non-clean integration turn, so it is
-   *  ALWAYS recognized as a follow-up and CANNOT re-escalate (one hop). The single-dispatch-per-turn guard
-   *  means at most one dispatch happens per flush, so realistically "the one dispatch IS the escalation".
-   *  ACCEPTED SAFE-DIRECTION ERROR: if the reflex instead dispatches FRESH unrelated work during a non-clean
-   *  flush (rare — and only possible when it batches multiple calls in one step, bypassing the guard), that
-   *  fresh task is over-stamped followUp:true and forgoes ONE future auto-escalation. That is SAFE (it only
-   *  ever REMOVES a future escalation, never adds one — no runaway) and is the correct side to err on. */
-  turnFollowUp = false;
-  /** Hard absolute backstop against runaway regardless of attribution: total automatic escalations across
-   *  the whole conversation. Once it hits MAX_AUTO_ESCALATIONS, no integration turn offers escalate/re-delegate. */
-  autoEscalations = 0;
-  static MAX_AUTO_ESCALATIONS = 8;
-  /** Parked worker questions awaiting a (voice-relayed) user answer, keyed by ask id. */
-  pendingAsks = /* @__PURE__ */ new Map();
-  /** Lazily resolved memory tools (async loadMemory runs in initMemory). */
-  memoryReady;
-  constructor(options) {
-    this.options = { ...new DuplexAgentOptions(), ...options };
-    const o = this.options;
-    if (o.memoryDir && o.fs) {
-      this.memoryReady = loadMemory(o.fs, o.memoryDir, { maxWritesPerSession: 10, userDir: o.memoryUserDir });
-    }
-    const memSlot = o.memoryDir && o.fs ? VOICE_MEMORY_PROMPT : "NEVER claim to have stored, saved, or remembered something durably \u2014 you cannot. Anything the user wants persisted (their name, preferences, notes) must go through Act so a worker writes it to memory.";
-    const thinkSlot = o.thinkModel !== false ? THINK_GUIDANCE : THINK_DISABLED_GUIDANCE;
-    const workerToolNames = (o.actOptions?.tools ?? []).map((t) => t.name);
-    const canSearch = workerToolNames.some((n) => /WebSearch/i.test(n));
-    const canFetch = workerToolNames.some((n) => /WebFetch/i.test(n));
-    const workerWeb = canSearch ? `, and it CAN search the web and read web pages \u2014 so when the user gives you something specific to look up ("search for X", "find me\u2026", "what's the latest on\u2026"), route it to Act. But a bare capability QUESTION like "can you search the web?" just gets a short spoken "yes, I can" \u2014 do NOT dispatch and NEVER invent a query the user did not give you` : canFetch ? ", and it can fetch a specific web page URL (but cannot search the web)" : "";
-    const mcpNames = [
-      ...Object.keys(o.actOptions?.providerOptions?.mcpServers ?? {}),
-      ...new Set(workerToolNames.filter((n) => n.startsWith("mcp__")).map((n) => n.slice(5).split("__")[0]))
-    ];
-    const workerMcp = mcpNames.length ? `, and it can use these MCP servers: ${[...new Set(mcpNames)].join(", ")}` + (mcpNames.some((n) => /browser/i.test(n)) ? ' \u2014 including driving a REAL browser (open tabs, navigate, click, screenshot), so answer "yes" if asked whether you can control/drive a browser and route an actual browse to Act' : "") : "";
-    const prompt = VOICE_SYSTEM_PROMPT.replace("{{MEMORY_SLOT}}", memSlot).replace("{{THINK_SLOT}}", thinkSlot).replace("{{WORKER_WEB}}", workerWeb + workerMcp) + (o.voiceStyle === "conversational" ? "\n" + VOICE_STYLE_CONVERSATIONAL : "") + (o.emotionTags ? "\n" + EMOTION_TAGS_GUIDANCE : "") + `
-Today's date: ${(/* @__PURE__ */ new Date()).toDateString()}.`;
-    const tools = [
-      ...o.reflexOptions?.tools ?? [],
-      this.actTool(),
-      ...o.thinkModel !== false ? [this.thinkTool()] : [],
-      this.taskStatusTool(),
-      this.cancelTaskTool(),
-      this.quickLookTool(),
-      this.answerTaskTool(),
-      this.holdTool()
-    ];
-    const host = o.host;
-    const voiceHost = host && {
-      ask: host.ask ? (q) => host.ask(q) : void 0,
-      confirm: host.confirm ? (p, m) => host.confirm(p, m) : void 0,
-      notify: (ev) => {
-        if (ev?.kind === "text_delta" && typeof ev.message === "string") {
-          if (this.heldThisTurn) return;
-          if (this.fabricationCut) return;
-          const msg = ev.message;
-          this.reflexBuf += msg;
-          const m = this.reflexBuf.match(RESERVED_EVENT_MARKER) ?? this.reflexBuf.match(RESERVED_EVENT_OPENER);
-          if (m) {
-            this.fabricationCut = true;
-            log10.warn(`reflex fabricated a [task \u2026] event in its spoken stream \u2014 cutting it (kept ${m.index} chars)`);
-            const safe = this.reflexBuf.slice(this.reflexForwarded, m.index);
-            if (!safe) return;
-            if (safe.trim()) this.spokeThisTurn = true;
-            host.notify?.({ ...ev, message: safe });
-            return;
-          }
-          const held = this.reflexBuf.length - this.reflexForwarded;
-          const partial = held > 0 && /\[\s*t?a?s?k?$/i.test(this.reflexBuf.slice(-Math.min(held, 6)));
-          const upto = partial ? this.reflexBuf.length - this.reflexBuf.slice(-6).match(/\[\s*t?a?s?k?$/i)[0].length : this.reflexBuf.length;
-          const out = this.reflexBuf.slice(this.reflexForwarded, upto);
-          this.reflexForwarded = upto;
-          if (!out) return;
-          if (out.trim()) this.spokeThisTurn = true;
-          host.notify?.({ ...ev, message: out });
-          return;
-        }
-        host.notify?.(ev);
-      }
-    };
-    this.voice = new Agent({
-      ai: o.ai,
-      fs: new MemFilesystem2(),
-      model: o.reflexModel,
-      stream: true,
-      host: voiceHost,
-      // The reflex IS the conversational channel — it confirms ambiguity inline ("did you mean…?"),
-      // never via the blocking AskUserQuestion tool (Agent auto-adds it whenever a host is set). Left in,
-      // it stalls a voice turn until the kill-switch. Worker questions still reach the user via parkQuestion.
-      askUserQuestion: false,
-      systemPrompt: prompt,
-      instructionFiles: false,
-      maxSteps: 8,
-      timeoutMs: 3e4,
-      ...o.reflexOptions,
-      tools,
-      // Composed AFTER the spread so the dispatch guard can't be dropped by reflexOptions.
-      hooks: composeHooks(this.dispatchGuard(), o.reflexOptions?.hooks)
-    });
-  }
-  /** Resolve memory tools + inject index into voice system prompt (once). */
-  async initMemory() {
-    if (!this.memoryReady) return;
-    const mem = await this.memoryReady;
-    this.memoryReady = void 0;
-    this.voice.options.tools.push(...mem.tools);
-    if (mem.index) this.voice.options.systemPrompt += "\n\n" + mem.index;
-  }
-  /** Flush any held-back trailing fragment (a possible `[task` opener that never completed) once the
-   *  turn's stream is done — so a legit message ending in "[t" isn't silently dropped. */
-  flushHeldReflexTail() {
-    if (this.fabricationCut) return;
-    const tail = this.reflexBuf.slice(this.reflexForwarded);
-    this.reflexForwarded = this.reflexBuf.length;
-    if (!tail) return;
-    if (tail.trim()) this.spokeThisTurn = true;
-    this.options.host?.notify?.({ kind: "text_delta", message: tail });
-  }
-  /** Clear the per-turn guards. Called at the head of every voice turn (user send + re-voice flush). */
-  resetTurn() {
-    this.turnDispatched = false;
-    this.turnBriefs.clear();
-    this.spokeThisTurn = false;
-    this.heldThisTurn = false;
-    this.reflexBuf = "";
-    this.reflexForwarded = 0;
-    this.fabricationCut = false;
-    this.turnFollowUp = false;
-    this.voice.options.toolChoice = void 0;
-  }
-  /** preToolUse guard on the reflex: once it has dispatched this turn, a dispatch is "said my piece,
-   *  now wait for the push" (CC's Task model). Block the temptations — TaskStatus polling and identical
-   *  re-dispatch — so the only remaining move is to voice a short ack and end. A genuinely NEW Act is
-   *  still allowed (parallel independent work). During a re-ack pass, block every tool. */
-  dispatchGuard() {
-    return {
-      preToolUse: (call) => {
-        if (this.nudging) return { block: true, reason: "Just say one short spoken acknowledgement \u2014 no tools this turn." };
-        if (!this.turnDispatched) return;
-        if (call.name === "TaskStatus")
-          return { block: true, reason: "You just dispatched a task this turn \u2014 do NOT poll. Give one short spoken acknowledgement and end your turn; the result arrives later as a [task \u2026] event." };
-        if ((call.name === "Act" || call.name === "Think") && this.turnBriefs.has(String(call.args?.brief ?? "")))
-          return { block: true, reason: "You already dispatched this exact task \u2014 acknowledge briefly and end your turn." };
-      }
-    };
-  }
-  /** True when the just-finished turn voiced NOTHING — dead air to repair. Two ways this happens:
-   *  (a) a dispatch with no spoken ack, and (b) an INLINE turn whose `final` channel came back empty —
-   *  gpt-oss harmony sometimes puts the whole reply in `analysis` (→ thinking_delta, suppressed in
-   *  voice) and emits an empty `final`, so no text_delta ever streams. Both ship silence; both repair.
-   *  Requires a host: without one there's no stream to detect speech on (and no one to speak to). */
-  get silentTurn() {
-    return !!this.options.host && !this.spokeThisTurn && !this.heldThisTurn;
-  }
-  /** A turn that voiced nothing is dead air. Re-prompt the reflex ONCE so the LLM itself voices a short
-   *  line (no template). If it STILL says nothing, fall back to a minimal line so silence never ships.
-   *  Wording adapts to whether work was dispatched (an ack) or the inline reply was simply lost. */
-  async ackIfSilent(fallback) {
-    const dispatched = this.turnDispatched;
-    this.nudging = true;
-    try {
-      await this.voice.send(fallback ? "[reminder] You said nothing to the user this turn. Tell them, in ONE short spoken sentence, what just happened \u2014 no tools." : dispatched ? "[reminder] You dispatched a task but said nothing to the user. Say ONE short spoken acknowledgement now \u2014 no tools." : "[reminder] You said nothing to the user this turn. Give your ONE short spoken reply now \u2014 no tools.");
-    } catch (e) {
-      log10.warn(`ack nudge failed: ${e instanceof Error ? e.message : e}`);
-    } finally {
-      this.nudging = false;
-    }
-    if (!this.spokeThisTurn)
-      this.options.host?.notify?.({ kind: "text_delta", message: fallback ?? (dispatched ? "Okay, on it." : "Sorry, could you say that again?") });
-  }
-  /** One user turn: the voice agent streams the reply (and may Act/Think). Serialized with re-voice turns. */
-  send(content) {
-    return this.enqueue(async () => {
-      await this.initMemory();
-      this.resetTurn();
-      const res = await this.voice.send(content);
-      this.flushHeldReflexTail();
-      if (this.silentTurn) await this.ackIfSilent();
-      return res;
-    });
-  }
-  /** Cancel a running background task — shared by the CancelTask tool and the CLI /tasks picker. */
-  cancelTask(id) {
-    const rec = this.tasks.get(id);
-    if (!rec) return `No task '${id}'.`;
-    if (rec.status !== "running") return `Task ${rec.id} is already ${rec.status}.`;
-    rec.status = "cancelled";
-    rec.controller.abort();
-    return `Task ${rec.id} (${rec.label}) cancelled.`;
-  }
-  /** Barge-in: the user took the floor while task(s) were running. Suppress those tasks' remaining SPOKEN
-   *  delivery so a superseded topic never talks over the new one (the debt-after-jokes regression). The
-   *  tasks keep running and still fold their result into the transcript — recoverable, just not spoken.
-   *  Returns the parked ids (for logging). Does NOT cancel: that's a deliberate reflex/user action. */
-  parkInFlightDeliveries() {
-    const parked = [];
-    for (const rec of this.tasks.values())
-      if (rec.status === "running" && !rec.deliveryParked) {
-        rec.deliveryParked = true;
-        parked.push(rec.id);
-      }
-    return parked;
-  }
-  /** Resolve when all queued voice turns AND all in-flight worker tasks have settled (tests, graceful shutdown). */
-  async idle() {
-    while (true) {
-      const q = this.queue;
-      await q.catch(() => {
-      });
-      await Promise.all([...this.tasks.values()].map((t) => t.promise));
-      if (this.queue === q && ![...this.tasks.values()].some((t) => t.status === "running")) return;
-    }
-  }
-  /** Promise-chain mutex: turns run strictly one at a time; a failed turn doesn't poison the chain. */
-  enqueue(fn) {
-    const run = this.queue.then(fn, fn);
-    this.queue = run.then(() => {
-    }, () => {
-    });
-    return run;
-  }
-  notify(kind, message, data) {
-    this.options.host?.notify?.({ kind, message, data });
-  }
-  /** Queue a `[task …]` event for re-voicing. Events arriving while the voice is busy coalesce into ONE turn.
-   *  `nonClean` (out-of-band boolean, set by the caller that KNOWS this event integrates a NON-CLEAN outcome)
-   *  marks the coalesced flush as a non-clean integration turn — turn-eligibility, never inferred from event
-   *  text and never keyed on a (re-authored) brief string. Any dispatch in such a turn is a follow-up. */
-  queueRevoice(event, nonClean = false) {
-    this.pendingEvents.push(event);
-    if (nonClean) this.pendingNonClean = true;
-    if (this.flushQueued) return;
-    this.flushQueued = true;
-    void this.enqueue(async () => {
-      this.flushQueued = false;
-      const events = this.pendingEvents.splice(0);
-      const nonCleanTurn = this.pendingNonClean;
-      this.pendingNonClean = false;
-      if (!events.length) return;
-      const failed = events.find((e) => /^\[task\b[^\]\n]*\bfailed\b/i.test(e));
-      this.resetTurn();
-      this.turnFollowUp = nonCleanTurn;
-      await this.voice.send(events.join("\n"));
-      this.flushHeldReflexTail();
-      if (this.silentTurn) await this.ackIfSilent(failed ? "Sorry, that didn't work \u2014 the task failed." : void 0);
-      this.notify("revoice_done", "");
-    });
-  }
-  /** The worker's brief: the Act/Think args + a STATIC text snapshot of the recent conversation.
-   *  Act briefs get a self-verify footer — the worker's report is trusted without review, so it
-   *  must check its own work before reporting (nearly free under prompt caching; measured honest:
-   *  it does NOT fix one-shot logic bugs — see mind/10). Think tasks are pure reasoning — no footer. */
-  buildBrief(brief, tier = "act", deliver = true) {
-    const recent = this.voice.transcript.filter((m) => (m.role === "user" || m.role === "assistant") && contentText(m.content).trim()).slice(-this.options.excerptTurns).map((m) => `${m.role}: ${contentText(m.content)}`).join("\n");
-    const verify = tier === "act" ? "\n\nBefore reporting done: re-read what you changed and check it against EVERY requirement above \u2014 fix any gap first. Your report is trusted without review." : "";
-    const deliverContract = deliver ? "\n\n## DELIVER (spoken delivery)\nYou are reporting back to a user who is LISTENING. Stream your work normally \u2014 your prose is the written work record and detail, and is NOT spoken. Wrap anything the user should HEAR in <spoken>\u2026</spoken> tags. LEAD WITH the actual content they asked for: if they asked for a specific piece of content \u2014 a value, a name, the actual lines, the writing itself \u2014 that content goes INSIDE the <spoken> tags, not a remark about it. Your FIRST <spoken> segment is substantive \u2014 never a greeting or an acknowledgement (the front-end has already acked; do not double-ack). Keep spoken text concise and natural for the ear: short sentences, no markdown." + (this.options.emotionTags ? " Inside <spoken>, you may prefix a sentence with an inline [emotion] tag (e.g. [excited], [curious]) to color how it is voiced \u2014 only when it genuinely fits, and vary it; [laughter] gives a natural laugh." : "") : "";
-    return (recent ? `${brief}
-
-## Recent conversation (for context)
-${recent}` : brief) + verify + deliverContract;
-  }
-  /** Spawn a detached worker for task `id`; its settlement notifies + enqueues the re-voice turn. */
-  spawnWorker(id, label, briefText, tier, brief, followUp) {
-    const o = this.options;
-    const tierOpts = tier === "think" ? o.thinkOptions : o.actOptions;
-    const tierModel = tier === "think" ? o.thinkModel : o.actModel;
-    const controller = new AbortController();
-    const base = tierOpts?.hooks ?? o.actOptions?.hooks;
-    const report = o.progressUpdates ? this.progressReporter(id) : void 0;
-    const tail = [];
-    const pushTail = (line) => {
-      tail.push(line.slice(0, 200));
-      if (tail.length > 120) tail.splice(0, tail.length - 120);
-    };
-    const hooks = {
-      ...base,
-      preToolUse: async (call, meta) => {
-        const d = await base?.preToolUse?.(call, meta);
-        pushTail(`\u2699 ${describeCall(call)}`);
-        report?.pre(call);
-        return d;
-      },
-      postToolUse: async (call, result, meta) => {
-        await base?.postToolUse?.(call, result, meta);
-        const last = result?.trim().split("\n").filter(Boolean).pop();
-        if (last) pushTail(`  \u21B3 ${last}`);
-        report?.post(call);
-      },
-      onToolOutput: (call, chunk, meta) => {
-        base?.onToolOutput?.(call, chunk, meta);
-        report?.output(chunk);
-      }
-    };
-    const relayAsk = async (q) => {
-      const opts = q.options?.length ? ` Options: ${q.options.map((x) => x.label).join(", ")}.` : "";
-      const a = await this.parkQuestion(id, `${q.question}${opts}`);
-      return a || "(no answer from the user \u2014 use your best judgment and note the assumption)";
-    };
-    const splitter = new SpokenSplitter();
-    const speak = (seg) => {
-      if (seg && !this.tasks.get(id)?.deliveryParked) o.host?.notify?.({ kind: "speak_utterance", message: seg });
-    };
-    const coalescer = new SentenceCoalescer();
-    const feedSpoken = (s) => {
-      const ready = coalescer.feed(s);
-      if (ready) speak(ready);
-    };
-    const flushSpoken = () => speak(coalescer.flush());
-    const askBridge = o.askRelay ? { ask: relayAsk } : o.host?.ask ? { ask: (q) => o.host.ask(q) } : {};
-    const workerHost = {
-      ...askBridge,
-      notify: (ev) => {
-        if (ev?.kind === "text_delta" && typeof ev.message === "string") {
-          const { spoken, detail } = splitter.feed(ev.message);
-          feedSpoken(spoken);
-          if (detail.trim()) pushTail(detail.trim());
-          return;
-        }
-      }
-    };
-    const agentOpts = {
-      ai: o.ai,
-      fs: o.fs,
-      model: tierModel,
-      ...tier === "think" ? { reasoning: tierOpts?.reasoning ?? "high" } : {},
-      ...tierOpts,
-      // Recompute providerOptions for THIS worker's model (after tierOpts so it wins over any inherited
-      // main-template value) — prevents cursor-only cwd/cursorSession leaking onto an anthropic worker.
-      providerOptions: o.providerOptionsFor?.(tierModel),
-      stream: true,
-      // worker streams text_delta so the splitter can extract <spoken> live (after tierOpts: never overridden off)
-      host: workerHost,
-      // carries BOTH ask AND the <spoken>-splitting notify
-      ...hooks ? { hooks } : {},
-      signal: controller.signal
-      // shared with the checker so a cancel tears down both
-    };
-    const promise = new Agent(agentOpts).run(briefText).then((res) => {
-      const { spoken, detail } = splitter.flush();
-      feedSpoken(spoken);
-      if (detail.trim()) pushTail(detail.trim());
-      flushSpoken();
-      return res;
-    }).then((res) => this.maybeVerify(id, brief, res, tier, agentOpts, askBridge)).then((res) => this.onWorkerSettled(id, res)).catch((err) => this.onWorkerFailed(id, err));
-    this.tasks.set(id, { id, label, status: "running", controller, promise, tail, brief, followUp, splitter });
-    if (this.tasks.size > this.options.maxTaskRecords)
-      for (const [tid, rec] of this.tasks) {
-        if (this.tasks.size <= this.options.maxTaskRecords) break;
-        if (rec.status !== "running") this.tasks.delete(tid);
-      }
+  /** 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));
   }
-  /** Fresh-context check of a successful Act task: a NEW agent (same model/fs/tools, but NO shared
-   *  conversation context) re-reads the file state against the brief and fixes any gap. The fix lands
-   *  on the shared fs automatically (workers write fs directly, no overlay), so grading sees the
-   *  corrected state. Bounded to ONE pass. Off unless `verifyActTasks`; never runs for think/failed/
-   *  cancelled tasks. Usage is merged so /cost reflects the real (worker + checker) spend. */
-  async maybeVerify(id, brief, res, tier, agentOpts, askBridge) {
-    if (!this.options.verifyActTasks || tier !== "act" || res.finishReason !== "stop") return res;
-    if (this.tasks.get(id)?.status === "cancelled") return res;
-    const { stream: _stream, host: _host, ...restOpts } = agentOpts;
-    const checkerOpts = {
-      ...restOpts,
-      ...askBridge.ask ? { host: { ask: askBridge.ask } } : {}
-    };
-    const checkBrief = `${this.buildBrief(brief, tier, false)}
-
-## VERIFY MODE
-Another agent just implemented the above. Independently check the CURRENT state of the files against EVERY requirement. Fix any gap you find. If everything is already correct, make NO changes \u2014 do not refactor or improve \u2014 and report "verified".`;
-    this.notify("task_verify", `task ${id}: verifying`, { id });
-    const cres = await new Agent(checkerOpts).run(checkBrief);
-    if (cres.finishReason !== "stop") {
-      log10.warn(`task ${id}: verify inconclusive (${cres.finishReason})`);
-      this.notify("task_verify", `task ${id}: verify inconclusive (${cres.finishReason})`, { id, finishReason: cres.finishReason });
+  // --- 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) {
+      this.clock.clearTimeout(this.drainTimer);
+      this.drainTimer = null;
     }
-    const sum = (a = 0, b = 0) => a + b;
-    return {
-      ...res,
-      steps: res.steps + cres.steps,
-      // Merge the checker's messages so downstream tool-call/step accounting includes BOTH agents
-      // (else a verified task's toolCalls would undercount vs its steps/usage).
-      messages: [...res.messages, ...cres.messages],
-      usageEstimated: res.usageEstimated || cres.usageEstimated,
-      usage: res.usage && cres.usage ? {
-        promptTokens: sum(res.usage.promptTokens, cres.usage.promptTokens),
-        completionTokens: sum(res.usage.completionTokens, cres.usage.completionTokens),
-        totalTokens: sum(res.usage.totalTokens, cres.usage.totalTokens),
-        cacheCreationTokens: sum(res.usage.cacheCreationTokens, cres.usage.cacheCreationTokens),
-        cacheReadTokens: sum(res.usage.cacheReadTokens, cres.usage.cacheReadTokens)
-      } : res.usage ?? cres.usage
-    };
-  }
-  /** 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 = () => {
-      if (this.pendingAsks.size) return void 0;
-      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;
-      const last = inflight.tail.trim().split("\n").filter(Boolean).pop()?.slice(-80);
-      emit(rec, `still inside ${describeCall(inflight.call)} \u2014 ${Math.round((Date.now() - inflight.at) / 1e3)}s on this step${last ? `, last output: ${last}` : ""}`, inflight.call);
-    }, Math.max(this.options.progressIntervalMs, 250));
-    timer.unref?.();
-    return {
-      pre: (call) => {
-        inflight = { call, at: Date.now(), tail: "" };
-      },
-      output: (chunk) => {
-        if (inflight) inflight.tail = (inflight.tail + chunk).slice(-500);
-      },
-      // digest only — NEVER re-voices directly
-      post: (call) => {
-        steps++;
-        inflight = null;
-        const rec = due();
-        if (rec) emit(rec, `still running \u2014 ${steps} steps so far, now: ${describeCall(call)}`, call);
-      }
-    };
-  }
-  /** 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((resolve) => {
-      let settled = false;
-      const finish = (answer) => {
-        if (settled) return;
-        settled = true;
-        clearTimeout(timer);
-        this.pendingAsks.delete(askId);
-        resolve(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("");
-  }
-  /** Build the INTEGRATION TURN prompt for a NON-CLEAN settled worker (early stop / failure). A clean
-   *  success never reaches here — it streams its own `<spoken>` delivery during the run. For a partial
-   *  or failed result the outcome re-enters the reflex as a decision (like a tool_result flowing back
-   *  into a normal agent loop): the reflex evaluates the outcome against the original intent and chooses
-   *  what to do next.
-   *
-   *  Decision branches (the reflex acts on them with EXISTING tools — no new surface):
-   *    • accept     → SPEAK the (partial) result plainly — don't dress a failure up as success.
-   *    • escalate   → call `Think` with the SAME brief — only when Act failed/stalled AND a Think tier
-   *                   exists AND this task wasn't already a follow-up (one hop max). Wires the dead
-   *                   "Reserve Think for a problem Act already FAILED at" promise.
-   *    • re-delegate→ call `Act` with a CORRECTED brief — for a recoverable error / partial result.
-   *    • ask        → ask the user ONE concrete question if genuinely blocked.
-   *
-   *  Keeps the `[task <id> completed]` / `[task <id> failed]` opener so existing coalescing + the
-   *  failed-revoice fallback still fire, and the per-event transcript markers stay intact. */
-  integrationPrompt(rec, outcome, body, finishReason) {
-    const opener = outcome === "error" ? `[task ${rec.id} failed]` : `[task ${rec.id} completed]`;
-    const underCap = this.autoEscalations < _DuplexAgent.MAX_AUTO_ESCALATIONS;
-    const canEscalate = (outcome === "error" || outcome === "incomplete") && underCap;
-    const hasThink = this.options.thinkModel !== false;
-    const options = [];
-    if (!rec.followUp && canEscalate && hasThink)
-      options.push("ESCALATE to the Think tier (call Think with the same brief) if this is a hard/architectural problem the Act worker stalled or failed on");
-    if (!rec.followUp && canEscalate)
-      options.push("RE-DELEGATE to Act with a corrected brief if the failure looks recoverable (a wrong path, a fixable mistake)");
-    options.push("ASK the user one short, concrete question if you genuinely cannot proceed without their input");
-    options.push("ACCEPT and tell the user plainly what happened (don't dress a failure up as success)");
-    const decision = options.length > 1 ? ` You must decide what to do next \u2014 choose ONE: ${options.map((o, i) => `(${i + 1}) ${o}`).join("; ")}. Pick exactly one and act on it; do not voice this as a finished success.` : ` Tell the user plainly what happened \u2014 do not present this as a finished success.`;
-    const state = outcome === "error" ? `the worker FAILED with: ${body}` : `the worker STOPPED EARLY (${finishReason}) \u2014 its result is PARTIAL, not a finished success: ${body}`;
-    return `${opener} Original request: "${rec.brief}". Outcome: ${state}.${decision}`;
-  }
-  onWorkerSettled(id, res) {
-    this.dropAsk(id);
-    const rec = this.tasks.get(id);
-    if (res.finishReason === "aborted" || rec.status === "cancelled") {
-      rec.status = "cancelled";
-      this.notify("task_cancelled", `task ${id} (${rec.label}) cancelled`);
-      return;
+    this.interrupted = false;
+    this.bcSupersede();
+    this.resetOverlap(true);
+    this.diag("tts_turn_begin", { ack, gapless: this.speaking });
+    if (!this.speaking) this.player.markTurn();
+    this.speaking = true;
+    this.ctxOpen = true;
+    this.spokeDeltas = false;
+    this.reply = "";
+    this.revealText = "";
+    this.wordStarts = [];
+    this.revealedN = 0;
+    if (this.options.revealMode === "word") this.startWordReveal();
+    this.emo = this.options.emotions ? new EmotionStream(this.options.showEmotions) : null;
+    this.echoWords = new Set(this.words(this.prevReply));
+    this.tts.newContext();
+    this.clearAckTimer("new_turn");
+    if (ack && this.options.ackPhrase) {
+      this.diag("ack_fired", { phrase: this.options.ackPhrase, adaptive: false });
+      this.tts.speak(this.options.ackPhrase + " ", true);
+      this.spokeDeltas = true;
+      this.ackAt = this.clock.now();
+      this.lastAck = this.options.ackPhrase;
+      for (const w of this.words(this.options.ackPhrase)) this.echoWords.add(w);
+    } else if (ack && this.options.adaptiveAckMs > 0) {
+      this.ackTimer = this.clock.setTimeout(() => {
+        this.ackTimer = null;
+        if (!this.speaking || !this.ctxOpen || this.spokeDeltas || this.interrupted) return;
+        const phrase = this.pickAck();
+        this.diag("ack_fired", { phrase, adaptive: true, waitedMs: this.options.adaptiveAckMs });
+        this.tts.speak(phrase + " ", true);
+        this.spokeDeltas = true;
+        this.ackAt = this.clock.now();
+        this.lastAck = phrase;
+        for (const w of this.words(phrase)) this.echoWords.add(w);
+        this.setState("speaking");
+        this.options.onAdaptiveAck();
+      }, this.options.adaptiveAckMs);
     }
-    if (res.finishReason === "error") {
-      const msg = res.error instanceof Error ? res.error.message : String(res.error ?? "unknown error");
-      return this.failTask(rec, msg);
+    if (!this.turnStartAt) this.turnStartAt = this.clock.now();
+    this.setState("thinking");
+  }
+  /** Feed a spoken delta. Returns the on-screen echo text (emotion tags shown/hidden per config) so the
+   *  host renders the SAME stream that was parsed for TTS — no second, state-doubling parse. */
+  speakDelta(text) {
+    if (this.interrupted) return "";
+    this.clearAckTimer("first_delta");
+    if (!this.speaking || !this.ctxOpen) this.beginSpeech();
+    let { speech, display, prose } = this.emo ? this.emo.feed(text) : { speech: text, display: text, prose: text };
+    if (this.reply && /[.!?…]$/.test(this.reply) && /^[A-Z]/.test(prose)) {
+      speech = " " + speech;
+      display = " " + display;
+      prose = " " + prose;
     }
-    rec.status = "done";
-    rec.result = res.text;
-    const incomplete = res.finishReason !== "stop";
-    log10.verbose(`task ${id} done (${res.steps} steps${incomplete ? `, INCOMPLETE: ${res.finishReason}` : ""})`);
-    this.notify("task_done", `task ${id} (${rec.label}) completed`, {
-      id,
-      text: res.text,
-      usage: res.usage,
-      usageEstimated: res.usageEstimated,
-      finishReason: res.finishReason,
-      steps: res.steps,
-      toolCalls: res.messages.filter((m) => m.role === "tool").length
-    });
-    if (incomplete) {
-      return this.queueRevoice(this.integrationPrompt(rec, "incomplete", res.text, res.finishReason), true);
+    this.reply += prose;
+    if (prose.trim()) this.repliedSinceDispatch = true;
+    for (const w of this.words(this.reply)) this.echoWords.add(w);
+    this.tts.speak(forSpeech(speech), true);
+    if (!this.spokeDeltas && this.turnStartAt) log10.debug(`ttft: ${Math.round(this.clock.now() - this.turnStartAt)}ms`);
+    this.spokeDeltas = true;
+    this.setState("speaking");
+    if (this.options.revealMode !== "off" && display) {
+      this.revealText += display;
+      if (this.options.revealMode === "delta") this.options.onReveal(this.revealText);
     }
-    const tail = rec.splitter?.flush();
-    if (tail?.spoken && !rec.deliveryParked) this.options.host?.notify?.({ kind: "speak_utterance", message: tail.spoken });
-    if (res.text.trim()) this.voice.transcript.push({ role: "assistant", content: res.text });
-    if (!rec.splitter?.spokeAny && res.text.trim() && !rec.deliveryParked)
-      this.options.host?.notify?.({ kind: "speak_utterance", message: res.text });
+    return display;
   }
-  onWorkerFailed(id, err) {
-    this.failTask(this.tasks.get(id), err instanceof Error ? err.message : String(err));
+  /** Karaoke reveal poll: reveal the display-word prefix up to the count of spoken words whose
+   *  Cartesia start time has been reached on the playback clock (`AudioSink.playedMs`, which excludes
+   *  paused time). Poll-driven (not AudioContext timers) so it's portable across CLI/browser sinks and
+   *  deterministic under the virtual clock. */
+  startWordReveal() {
+    if (this.revealPoll) return;
+    const tick = () => {
+      this.revealPoll = null;
+      if (!this.speaking || this.interrupted || this.options.revealMode !== "word") return;
+      const playedSec = this.player.playedMs() / 1e3;
+      let n = this.revealedN;
+      while (n < this.wordStarts.length && this.wordStarts[n] <= playedSec) n++;
+      if (n !== this.revealedN) {
+        this.revealedN = n;
+        const words = this.revealText.trim().split(/\s+/).filter(Boolean);
+        this.options.onReveal(words.slice(0, n).join(" "));
+      }
+      this.revealPoll = this.clock.setTimeout(tick, 60);
+    };
+    this.revealPoll = this.clock.setTimeout(tick, 60);
+  }
+  /** Stop the poll. `finalFlush` reveals the whole line once audio has finished, so a timing
+   *  undershoot never leaves the tail unrevealed (skipped after a barge-in — the truncated prefix
+   *  is what was actually spoken). */
+  stopWordReveal(finalFlush) {
+    if (this.revealPoll) {
+      this.clock.clearTimeout(this.revealPoll);
+      this.revealPoll = null;
+    }
+    if (finalFlush && this.options.revealMode === "word" && !this.interrupted) {
+      const full = this.revealText.trim();
+      if (full) this.options.onReveal(full);
+    }
   }
-  failTask(rec, msg) {
-    this.dropAsk(rec.id);
-    rec.status = "error";
-    rec.result = msg;
-    log10.warn(`task ${rec.id} failed: ${msg}`);
-    this.notify("task_error", `task ${rec.id} (${rec.label}) failed: ${msg}`);
-    this.queueRevoice(this.integrationPrompt(rec, "error", msg, "error"), true);
+  /** close the spoken turn (idempotent); stays audible until ALL audio arrived AND playback drains */
+  endSpeech() {
+    this.interrupted = false;
+    this.clearAckTimer("turn_end");
+    if (!this.speaking) return;
+    this.diag("tts_turn_end", { spoke: this.spokeDeltas, replyChars: this.reply.length });
+    this.ctxOpen = false;
+    if (this.emo) {
+      const t = this.emo.flush();
+      this.emo = null;
+      if (t.prose) this.reply += t.prose;
+      if (t.speech) this.tts.speak(forSpeech(t.speech), true);
+    }
+    if (this.reply) this.prevReply = this.reply;
+    const settle = () => {
+      if (this.ctxOpen) {
+        this.drainTimer = null;
+        return;
+      }
+      if (this.pausedAt) {
+        this.drainTimer = this.clock.setTimeout(settle, 250);
+        return;
+      }
+      this.drainTimer = null;
+      this.speaking = false;
+      this.stopWordReveal(true);
+      if (this.turnStartAt) log10.debug(`turn: ${Math.round(this.clock.now() - this.turnStartAt)}ms (incl. playback)`);
+      this.echoUntil = this.clock.now() + 2500;
+      if (!this.usingAec) this.stt.reset();
+      this.setState("listening");
+      if (this.uttQueue.length) this.pumpQueue();
+    };
+    const drainThenSettle = () => {
+      if (this.drainTimer) this.clock.clearTimeout(this.drainTimer);
+      this.drainTimer = this.clock.setTimeout(settle, this.player.drainMs() + 300);
+    };
+    if (this.spokeDeltas) {
+      this.tts.onDone = drainThenSettle;
+      this.tts.end();
+      if (this.drainTimer) this.clock.clearTimeout(this.drainTimer);
+      this.drainTimer = this.clock.setTimeout(drainThenSettle, 15e3);
+    } else drainThenSettle();
   }
-  // --- voice tools (closures over this instance) ---
-  /** Live-switch the think tier: `false` disables (removes the Think tool from the voice agent),
-   *  a model id enables (adds the tool if missing). The system-prompt THINK_SLOT text is frozen at
-   *  construction — the tool's own description carries the routing guidance, so a live enable works;
-   *  dispatch()'s think→act fallback covers any straggler calls after a live disable. */
-  setThinkModel(model) {
-    this.options.thinkModel = model;
-    const tools = this.voice.options.tools;
-    const i = tools.findIndex((t) => t.name === "Think");
-    if (model === false && i >= 0) tools.splice(i, 1);
-    else if (model !== false && i < 0) tools.push(this.thinkTool());
+  /** 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;
   }
-  /** User/programmatic spawn: the CLI's /act and /think commands. Returns the task id.
-   *  `followUp` marks an automatic escalation/re-delegation (set by the integration turn) so the new
-   *  task's own integration turn won't escalate again — capping auto-follow-ups to one hop. */
-  async dispatch(brief, tier = "act", label, followUp = false) {
-    if (tier === "think" && this.options.thinkModel === false) tier = "act";
-    if (followUp) this.autoEscalations++;
-    const id = `t${++this.seq}`;
-    const lbl = label ?? tier;
-    await this.options.onTaskStart?.(id, lbl);
-    this.spawnWorker(id, lbl, this.buildBrief(brief, tier), tier, brief, followUp);
-    this.notify("task_started", `task ${id} (${lbl}) started`, { id, brief, tier });
-    return id;
+  /** Speak a short filler phrase without starting a model turn (stays in listening mode after). */
+  speakFiller(text) {
+    if (!text || this.speaking) return;
+    const replied = this.repliedSinceDispatch;
+    this.beginSpeech();
+    this.speakDelta(text);
+    this.endSpeech();
+    this.repliedSinceDispatch = replied;
   }
-  actTool() {
-    return {
-      name: "Act",
-      description: 'Escalate real work (reading/editing files, searching, running tasks, building) to a standard background worker. Returns immediately with a task id; the result arrives later as a "[task <id> completed]" event. Provide a clear, self-contained `brief` (the worker does not hear the live conversation).',
-      parameters: {
-        type: "object",
-        required: ["brief"],
-        properties: {
-          brief: { type: "string", description: "full, self-contained instructions for the worker" },
-          label: { type: "string", description: "a short (2-4 word) label for the task" }
-        }
-      },
-      run: async ({ brief, label }) => {
-        this.turnDispatched = true;
-        this.turnBriefs.add(String(brief ?? ""));
-        this.voice.options.toolChoice = "none";
-        const id = await this.dispatch(String(brief ?? ""), "act", label ? String(label) : void 0, this.turnFollowUp);
-        return `Acting on task ${id}. Acknowledge briefly; the result will arrive as a [task ${id} completed] event.`;
-      }
-    };
+  /** Enqueue a COMPLETE worker utterance (already-split spoken text) onto the central speech queue.
+   *  If nothing is currently speaking it plays immediately; otherwise it queues and plays after the
+   *  current utterance fully ends (settle → pumpQueue) — never spliced into an open reflex utterance. */
+  enqueueUtterance(text) {
+    if (!text || !/[\p{L}\p{N}]/u.test(text)) return;
+    this.diag("enqueue_utterance", { chars: text.length, queued: this.uttQueue.length, speaking: this.speaking });
+    this.uttQueue.push(text);
+    if (!this.speaking) this.pumpQueue();
   }
-  thinkTool() {
-    return {
-      name: "Think",
-      description: "Escalate to a premium deep-reasoning agent for complex analysis, architecture decisions, hard debugging, or planning. Same async pattern as Act \u2014 returns a task id. Use when the problem needs careful thought before (or instead of) action. Do not use Think for simple tasks \u2014 Act is cheaper and faster.",
-      parameters: {
-        type: "object",
-        required: ["brief"],
-        properties: {
-          brief: { type: "string", description: "the question or problem to reason about deeply" },
-          label: { type: "string", description: "a short (2-4 word) label for the task" }
-        }
-      },
-      run: async ({ brief, label }) => {
-        this.turnDispatched = true;
-        this.turnBriefs.add(String(brief ?? ""));
-        this.voice.options.toolChoice = "none";
-        const id = await this.dispatch(String(brief ?? ""), "think", label ? String(label) : void 0, this.turnFollowUp);
-        return `Thinking on task ${id}. Acknowledge briefly; the result will arrive as a [task ${id} completed] event.`;
-      }
-    };
+  /** Play the next queued worker utterance as its own one-shot turn (begin → delta → end). Drives the
+   *  next one from the settle completion (endSpeech), so utterances serialize without overlap. */
+  pumpQueue() {
+    if (this.speaking) return;
+    const text = this.uttQueue.shift();
+    if (text == null) return;
+    this.beginSpeech();
+    this.speakDelta(text);
+    this.endSpeech();
   }
-  taskStatusTool() {
-    return {
-      name: "TaskStatus",
-      description: "Status of background tasks. Pass `id` for one task, or omit it to list all.",
-      parameters: { type: "object", properties: { id: { type: "string" } } },
-      run: async ({ id }) => {
-        const list = id ? [this.tasks.get(String(id))].filter(Boolean) : [...this.tasks.values()];
-        if (!list.length) return id ? `No task '${id}'.` : "No background tasks.";
-        return list.map((t) => `${t.id} (${t.label}): ${t.status}`).join("\n");
-      }
-    };
+  /** Short varied adaptive acks (adaptiveAckMs) — two shape pools picked by the dispatched
+   *  utterance (question → thinking-ish, otherwise neutral/on-it), with anti-repetition (never one
+   *  of the last 4 used). A 3-phrase round-robin sounded synthetic live ("started with 'hmm' too
+   *  many times"). All phrases are sub-second and semantically safe for their shape.
+   *  No 'Okay.': a genuine user "Okay." within the 6s squash window would be swallowed as ack echo. */
+  static ACKS_NEUTRAL = ["Mm-hm.", "One sec.", "Right.", "Sec.", "On it.", "Sure, moment.", "Uh, one moment.", "Let me see."];
+  static ACKS_QUESTION = ["Hmm.", "Let me think.", "Hm, let me see.", "Good question.", "Mm, one sec.", "Let's see."];
+  recentAcks = [];
+  pickAck() {
+    const pool = this.lastDispatchWasQuestion ? _VoiceEngine.ACKS_QUESTION : _VoiceEngine.ACKS_NEUTRAL;
+    const fresh = pool.filter((p) => !this.recentAcks.includes(p));
+    const phrase = (fresh.length ? fresh : pool)[Math.floor(Math.random() * (fresh.length ? fresh.length : pool.length))];
+    this.recentAcks.push(phrase);
+    if (this.recentAcks.length > 4) this.recentAcks.shift();
+    return phrase;
+  }
+  lastDispatchWasQuestion = false;
+  clearAckTimer(reason) {
+    if (!this.ackTimer) return;
+    this.clock.clearTimeout(this.ackTimer);
+    this.ackTimer = null;
+    if (reason) this.diag("ack_cancelled", { reason });
+  }
+  /** Cancel a pending adaptive ack without touching the turn — hosts call this when the turn turns out
+   *  to be a Hold (intentionally silent; an ack would read as the start of an answer). */
+  cancelPendingAck() {
+    this.clearAckTimer("hold");
   }
-  /** Sub-100ms read-only lookups the voice may do itself — everything else stays Act-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 CAP = 2e3;
-    const kinds = [.../* @__PURE__ */ new Set(["time", "branch", "ls", "file", "capabilities", ...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 Act.`,
-      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 "capabilities": {
-              const actTools = this.options.actOptions?.tools ?? [];
-              const names = actTools.map((t) => t.name);
-              const mcpServers = Object.keys(this.options.actOptions?.providerOptions?.mcpServers ?? {});
-              const mcpNote = mcpServers.length ? ` Plus MCP servers your worker can use: ${mcpServers.join(", ")} (e.g. browser-bridge \u2192 drive a real browser: open tabs, navigate, click, screenshot).` : "";
-              if (!names.length)
-                return "Your worker uses Act's default local toolset (reading/editing files, running shell commands). No extra tools (e.g. web/internet) are configured; if a request is not a basic file or shell operation, assume you can't do it and say so." + mcpNote;
-              const hasFetch = names.some((n) => /WebFetch/i.test(n));
-              const hasBrowser = names.some((n) => /browser.*(navigate|click|page|type)/i.test(n));
-              const hasSearch = names.some((n) => /(^|_)WebSearch$|search/i.test(n) && !/WebFetch|browser/i.test(n));
-              const notes = [];
-              if (hasFetch) notes.push("WebFetch retrieves ONE specific URL you are given \u2014 it is not a search engine.");
-              if (hasBrowser) notes.push("The browser tools drive a real browser: you CAN open a site and, if needed, navigate to a search engine and search there \u2014 but it is manual and takes a moment, not an instant lookup.");
-              else if (!hasSearch && hasFetch) notes.push('You have no general web-search tool, so for an instant "search the web" you can only fetch a URL they provide.');
-              const webNote = notes.length ? " NOTE: " + notes.join(" ") : "";
-              return `Tools your background worker (Act) can actually use: ${names.join(", ")}. Read each name literally and match the request to a SPECIFIC tool; if none fits, you do NOT have that ability \u2014 say so honestly.` + webNote + mcpNote;
-            }
-            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 > CAP ? text.slice(0, CAP) + `
-\u2026 (truncated \u2014 ${text.length} chars total; Act for the full file)` : text;
-            }
-            default:
-              return `unknown lookup '${what}'`;
+  /** barge-in: stop audio NOW, cancel generation, reset for the user's utterance */
+  interrupt() {
+    this.clearAckTimer("interrupt");
+    if (this.uttQueue.length) log10.info(`barge-in dropped ${this.uttQueue.length} queued worker utterance(s)`);
+    const droppedQueued = this.uttQueue.length;
+    this.uttQueue = [];
+    if (!this.speaking && !this.drainTimer) return;
+    this.stopWordReveal(false);
+    this.diag("interrupt", { droppedQueued, ctxOpen: this.ctxOpen, playedMs: Math.round(Math.max(0, this.player.playedMs())) });
+    if (this.drainTimer) {
+      this.clock.clearTimeout(this.drainTimer);
+      this.drainTimer = null;
+    }
+    this.resetOverlap(false);
+    this.lastResumeAt = 0;
+    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 = this.clock.now() + Math.max(2500, this.player.drainMs() + 3e3);
+    this.tts.cancel();
+    this.player.kill();
+    if (!this.usingAec) this.stt.reset();
+    if (this.reply) this.prevReply = this.reply;
+    this.setState("listening");
+  }
+  stop() {
+    this.uttQueue = [];
+    this.clearAckTimer();
+    if (this.resumeTimer) this.clock.clearTimeout(this.resumeTimer);
+    if (this.pendingTimer) this.clock.clearTimeout(this.pendingTimer);
+    if (this.drainTimer) this.clock.clearTimeout(this.drainTimer);
+    if (this.specTimer) this.clock.clearTimeout(this.specTimer);
+    this.bcSupersede();
+    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 || this.clock.now() < this.echoUntil;
+  }
+  /** Genuine user speech vs our own bleed (AEC tier): novel words must DOMINATE, not merely exist.
+   *  Degraded AEC + an STT mis-hearing manufactures a single novel word out of pure echo (a name or
+   *  rare word in our own reply comes back transcribed slightly differently — 1 novel / N words).
+   *  A real interjection is mostly novel ("stop", "wait what") — short utterances pass on ratio,
+   *  longer ones on count. */
+  genuine(text) {
+    const total = this.words(text).length;
+    const novel = this.novelWords(text).length;
+    return novel > 0 && novel / Math.max(1, total) > 0.5;
+  }
+  handlePartial(text) {
+    if (this.speaking) {
+      if (!this.options.bargeIn) return;
+      if (this.clock.now() < this.bargeGraceUntil) {
+        if (this.lastGraceDiag !== this.bargeGraceUntil) {
+          this.lastGraceDiag = this.bargeGraceUntil;
+          this.diag("grace_suppress", { text: text.slice(0, 60) });
+        }
+        if (!this.echoActive() || (this.usingAec ? this.genuine(text) : this.novelWords(text).length >= 1)) this.options.onPartial(text);
+        return;
+      }
+      if (this.overlapCapable) {
+        const txt = text.trim();
+        if (!txt || txt === this.lastOverlapPartial) return;
+        this.lastOverlapPartial = txt;
+        if (!this.genuine(txt)) {
+          if (this.pausedAt) this.armResume();
+          return;
+        }
+        if (!this.pausedAt) {
+          this.pausedAt = this.clock.now();
+          const sinceResumeMs = this.lastResumeAt ? Math.round(this.clock.now() - this.lastResumeAt) : void 0;
+          this.diag("overlap_pause", { text: txt.slice(0, 60), sinceResumeMs });
+          this.player.pause();
+          if (this.lastResumeAt && this.clock.now() - this.lastResumeAt < this.options.overlapRepauseCedeMs) {
+            const phase = this.ctxOpen ? "speaking" : "drain";
+            this.diag("barge_in", { phase, trigger: "overlap_repause", sinceResumeMs });
+            this.interrupt();
+            this.options.onBargeIn(phase);
+            return;
           }
-        } catch (e) {
-          return `lookup failed: ${e?.message ?? e}`;
         }
+        if (this.words(txt).length >= 2) {
+          const phase = this.ctxOpen ? "speaking" : "drain";
+          this.diag("barge_in", { phase, trigger: "overlap_cede", novel: this.novelWords(txt).length, total: this.words(txt).length });
+          this.interrupt();
+          this.options.onBargeIn(phase);
+          return;
+        }
+        this.armResume();
+        return;
       }
-    };
-  }
-  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.`;
+      const barge = this.usingAec ? this.genuine(text) : this.novelWords(text).length >= (this.suspectUntil ? 1 : 2);
+      if (barge) {
+        const phase = this.ctxOpen ? "speaking" : "drain";
+        this.diag("barge_in", { phase, trigger: this.usingAec ? "genuine" : "heuristic_novel", novel: this.novelWords(text).length, total: this.words(text).length });
+        this.interrupt();
+        this.options.onBargeIn(phase);
       }
-    };
+      return;
+    }
+    if (this.pendingUtt && text.trim()) {
+      if (this.pendingTimer) this.clock.clearTimeout(this.pendingTimer);
+      this.pendingTimer = this.clock.setTimeout(() => this.flushUtterance(), Math.max(800, this.options.utteranceMergeMs));
+    }
+    this.trackSpeculation(text);
+    this.trackBackchannel(text);
+    if (!this.echoActive() || (this.usingAec ? this.genuine(text) : this.novelWords(text).length >= 1)) this.options.onPartial(text);
   }
-  holdTool() {
-    return {
-      name: "Hold",
-      description: 'The user seems mid-thought \u2014 hold the turn (stay listening) instead of answering. Optionally pass a short filler ("mhm", "go on") to speak while waiting. Use when the message sounds incomplete, trailing off, or like they paused to think.',
-      parameters: {
-        type: "object",
-        properties: {
-          filler: { type: "string", description: 'optional short filler to speak ("mhm", "go on", "mm-hm")' }
-        }
-      },
-      run: async ({ filler }) => {
-        this.heldThisTurn = true;
-        if (filler) this.notify("hold_filler", String(filler));
-        return "Holding \u2014 listening for the rest of the user's thought. Do not respond further this turn.";
+  /** Speculative-reflex trigger (listening side only — the speaking branch returns before this): a
+   *  partial that hasn't CHANGED for speculativeMs and has ≥ speculativeMinWords is stable → fire
+   *  onSpeculate once. If the user then keeps talking well past the speculated text, onSpeculateAbort
+   *  tells the host to kill the held call early. The confirm/abort DECISION belongs to the host at
+   *  dispatch time (speculationConfirms against the real final) — flushUtterance only resets the
+   *  trigger for the next turn. Merge windows are untouched: no speculation while an endpointed
+   *  utterance is pending (the final would be the MERGED text, which the partial alone never matches). */
+  trackSpeculation(text) {
+    if (!this.options.speculativeMs) return;
+    const t = text.trim();
+    if (this.specText) {
+      if (this.words(t).length > this.words(this.specText).length + 2) {
+        this.specText = "";
+        this.diag("speculate_abort", { reason: "partial_grew", partial: t.slice(0, 60) });
+        this.options.onSpeculateAbort();
       }
+      return;
+    }
+    if (this.specSpent || this.pendingUtt || !t || t === this.specPartial) return;
+    this.specPartial = t;
+    if (this.specTimer) this.clock.clearTimeout(this.specTimer);
+    this.specTimer = this.clock.setTimeout(() => {
+      this.specTimer = null;
+      if (this.speaking || this.specSpent || this.pendingUtt) return;
+      if (this.words(this.specPartial).length < this.options.speculativeMinWords) return;
+      const flat = this.specPartial.toLowerCase().replace(/[^a-z0-9]/g, "");
+      if (flat && this.lastDispatchFlat && this.clock.now() - this.lastDispatchAt < _VoiceEngine.DUP_FINAL_MS && (this.lastDispatchFlat.startsWith(flat) || flat.startsWith(this.lastDispatchFlat))) return;
+      this.specSpent = true;
+      this.specText = this.specPartial;
+      log10.debug(`speculate: "${this.specText.slice(0, 60)}"`);
+      this.diag("speculate", { text: this.specText });
+      this.options.onSpeculate(this.specText);
+    }, this.options.speculativeMs);
+  }
+  /** Backchannel blip pool — short, quiet, semantically inert. Chosen to be transcript-safe: if
+   *  imperfect AEC lets a blip reach Soniox MID-user-speech it lands inside their partial stream, so
+   *  every phrase is a word whose accidental presence barely hurts a transcript, and flushUtterance
+   *  strips an isolated echo of the exact phrase at a clause edge within 2s (stripBackchannelEcho).
+   *  'Okay.'/'Right.' are fine here (unlike ACKS_NEUTRAL's no-Okay rule): a standalone user "Okay."
+   *  right after OUR blip is overwhelmingly the blip's echo — the squash guard eating it is the point. */
+  static BACKCHANNELS = ["Mm-hm.", "Uh-huh.", "Right.", "Okay."];
+  /** Backchannel trigger (listening side only — the speaking branch returns before this): a partial
+   *  that reached a clause boundary and then stayed UNCHANGED for backchannelMs (a micro-pause, still
+   *  BEFORE the silence endpoint) fires a blip — if long enough (≥ backchannelMinWords), predominantly
+   *  Latin, rate-limited (backchannelMinGapMs + max 2/turn), and no endpointed text is pending.
+   *  Touches nothing else: merge/endpoint/speculation timers and turn state are never affected. */
+  trackBackchannel(text) {
+    if (!this.options.backchannelMs) return;
+    const t = text.trim();
+    if (!t || t === this.bcPartial) return;
+    this.bcPartial = t;
+    if (this.bcTimer) this.clock.clearTimeout(this.bcTimer);
+    this.bcTimer = this.clock.setTimeout(() => {
+      this.bcTimer = null;
+      const p = this.bcPartial;
+      const veto = (reason) => this.diag("backchannel_suppress", { reason });
+      if (this.speaking || this.pendingUtt || this.bcActive) return veto("busy");
+      if (!this.usingAec || !this.options.bargeIn) return veto("half_duplex");
+      if (this.bcCount >= 2 || this.lastBcAt && this.clock.now() - this.lastBcAt < this.options.backchannelMinGapMs) return veto("rate_limited");
+      if (this.words(p).length < this.options.backchannelMinWords) return veto("short");
+      if (!/[,.;:!?…]$/.test(p) && !this.looksIncomplete(p)) return veto("no_boundary");
+      const letters = p.replace(/[^\p{L}]/gu, "");
+      const latin = p.replace(/[^A-Za-z]/g, "");
+      if (!letters || latin.length / letters.length < 0.7) return veto("non_latin");
+      const flat = p.toLowerCase().replace(/[^a-z0-9]/g, "");
+      if (flat && this.lastDispatchFlat && this.clock.now() - this.lastDispatchAt < _VoiceEngine.DUP_FINAL_MS && (this.lastDispatchFlat.startsWith(flat) || flat.startsWith(this.lastDispatchFlat))) return;
+      this.fireBackchannel();
+    }, this.options.backchannelMs);
+  }
+  /** Speak one blip on a THROWAWAY TTS context. Zero floor-claim: no `speaking`, no state change, no
+   *  markTurn, no merge/endpoint/barge timers, no repliedSinceDispatch, no utterance queue. Echo
+   *  pre-seeding happens BEFORE any audio exists: the blip's words join echoWords (its mic echo is
+   *  never "novel"), the ack-squash guard is armed with the exact phrase (a standalone echo final is
+   *  swallowed), and the echo window extends so echo-shaped finals stay gated. */
+  fireBackchannel() {
+    const fresh = _VoiceEngine.BACKCHANNELS.filter((x) => !this.recentBc.includes(x));
+    const pool = fresh.length ? fresh : _VoiceEngine.BACKCHANNELS;
+    const phrase = pool[Math.floor(Math.random() * pool.length)];
+    this.recentBc.push(phrase);
+    if (this.recentBc.length > 2) this.recentBc.shift();
+    const now3 = this.clock.now();
+    for (const w of this.words(phrase)) this.echoWords.add(w);
+    this.ackAt = now3;
+    this.lastAck = phrase;
+    this.lastBcAt = now3;
+    this.lastBcPhrase = phrase;
+    this.echoUntil = Math.max(this.echoUntil, now3 + 2500);
+    this.bcCount++;
+    this.bcActive = true;
+    if (this.bcActiveTimer) this.clock.clearTimeout(this.bcActiveTimer);
+    this.bcActiveTimer = this.clock.setTimeout(() => {
+      this.bcActive = false;
+    }, 3e3);
+    this.tts.onDone = () => {
+      this.bcActive = false;
     };
+    this.tts.newContext();
+    this.tts.speak(phrase, false);
+    log10.debug(`backchannel: "${phrase}"`);
+    this.diag("backchannel", { phrase });
+    this.options.onBackchannel(phrase);
+  }
+  /** A real turn (or shutdown) takes over mid-blip: close the audio bypass + stability timer. */
+  bcSupersede() {
+    this.bcActive = false;
+    if (this.bcActiveTimer) {
+      this.clock.clearTimeout(this.bcActiveTimer);
+      this.bcActiveTimer = null;
+    }
+    if (this.bcTimer) {
+      this.clock.clearTimeout(this.bcTimer);
+      this.bcTimer = null;
+    }
   }
-  cancelTaskTool() {
-    return {
-      name: "CancelTask",
-      description: "Cancel a running background task by id.",
-      parameters: { type: "object", required: ["id"], properties: { id: { type: "string" } } },
-      run: async ({ id }) => this.cancelTask(String(id))
-    };
+  /** Strip the mic echo of the LAST blip from a dispatching final, conservatively: only the exact
+   *  phrase, as an isolated token at a clause edge (start/end of utterance or beside punctuation),
+   *  within 2s of the blip. "Right"/"okay" as genuine mid-sentence content words are never touched. */
+  stripBackchannelEcho(text) {
+    if (!this.lastBcPhrase || this.clock.now() - this.lastBcAt > 2e3) return text;
+    const target = normWord(this.lastBcPhrase);
+    if (!target) return text;
+    const toks = text.split(/\s+/);
+    const idx = toks.findIndex((tok, i) => {
+      if (normWord(tok) !== target) return false;
+      if (/\?/.test(tok)) return false;
+      const edgeBefore = i === 0 || /[,.;:!?…]$/.test(toks[i - 1]);
+      const edgeAfter = i === toks.length - 1 || /[,.;:!?…]$/.test(tok);
+      return edgeBefore && edgeAfter;
+    });
+    if (idx < 0) return text;
+    toks.splice(idx, 1);
+    log10.verbose(`stripped backchannel echo "${this.lastBcPhrase}" from dispatching final`);
+    return toks.join(" ");
   }
-};
-
-// src/mcp.ts
-function toResult(result) {
-  if (result == null) return { text: "" };
-  if (typeof result === "string") return { text: result };
-  const content = result.content;
-  if (Array.isArray(content)) {
-    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));
+  /** Merge a resumed utterance into the pending one, deduping any word-overlap. Soniox re-finalizes
+   *  overlapping audio when the silence-timer and the semantic `<end>` both endpoint a growing
+   *  utterance (or after a reconnect): the next "utterance" repeats the tail of the previous one, and
+   *  a naive `${prev} ${next}` produced the live duplication ("Um, I want to check if Um, I want to
+   *  check if…"). Find the longest suffix of `prev`'s words that prefixes `next` and drop it. */
+  mergeUtterance(prev, next) {
+    if (!prev) return next;
+    if (!next) return prev;
+    const pw = prev.split(/\s+/), nw = next.split(/\s+/);
+    const norm2 = _VoiceEngine.normWord;
+    if (pw.length >= 2 && pw.length <= nw.length) {
+      let pfx = true;
+      for (let i = 0; i < pw.length - 1; i++) if (norm2(pw[i]) !== norm2(nw[i])) {
+        pfx = false;
+        break;
       }
+      if (pfx && norm2(nw[pw.length - 1]).startsWith(norm2(pw[pw.length - 1]))) return next;
     }
-    const text = texts.join("\n");
-    if (text || images.length) return { text, ...images.length ? { images } : {} };
+    const max = Math.min(pw.length, nw.length);
+    for (let k = max; k > 0; k--) {
+      let match = true;
+      for (let i = 0; i < k; i++) if (norm2(pw[pw.length - k + i]) !== norm2(nw[i])) {
+        match = false;
+        break;
+      }
+      if (match) return [...pw, ...nw.slice(k)].join(" ");
+    }
+    return `${prev} ${next}`;
   }
-  return { text: JSON.stringify(result) };
-}
-function mcpToolToAgentTool(spec, callTool, prefix = "mcp__") {
-  return {
-    name: `${prefix}${spec.name}`,
-    description: spec.description ?? `MCP tool ${spec.name}`,
-    parameters: spec.inputSchema ?? { type: "object", properties: {} },
-    async run(args, _ctx) {
-      const r = toResult(await callTool(spec.name, args ?? {}));
-      return r.images?.length ? r : r.text;
+  static normWord(w) {
+    return normWord(w);
+  }
+  /** Soniox re-finalization of an ALREADY-DISPATCHED utterance, arriving PAST the merge window:
+   *  the new final is a strict word-prefix superset of the last dispatch (the last dispatched word
+   *  may be a char-prefix of the corresponding new word — a mid-word endpoint), and it lands within
+   *  DUP_FINAL_MS of the dispatch. Live: "Hi, please tell me a very short" dispatched, then the full
+   *  "…very short joke." re-finalized ~900ms later → dispatched TWICE (two replies, the second to a
+   *  question already being answered).
+   *  DESIGN — HYBRID at the caller (flushUtterance): this shape check identifies a re-finalization
+   *  (a human physically cannot re-speak a ≥3-word sentence plus extra words within 3s of the
+   *  previous dispatch; a genuine continuation arrives as NEW words, never as a superset), and
+   *  repliedSinceDispatch then picks the action:
+   *  • reply already streaming (the live trace: TTFT ~500ms < the ~900ms re-final) → DROP. True
+   *    "supersede" would mean aborting audible speech mid-word to re-answer nearly the same text —
+   *    worse UX — and needs turn-abort plumbing in every host (the lab bridge has none;
+   *    DuplexAgent.send is a non-cancelable queue, so a second send just stacks a SECOND full reply).
+   *    Soniox's premature endpoint fires at a prosodic boundary, so the loss is trailing word(s).
+   *  • NO reply yet → DISPATCH the fuller text. Live-verified necessity: the reflex Holds on the
+   *    truncated fragment ("Hi, please tell me a very short" → Hold), and dropping the re-final then
+   *    starves the conversation entirely — the fuller final IS the completion the Hold is waiting
+   *    for. A slow-but-answering reflex in this window degrades to today's two-reply behavior (rare
+   *    race), never worse. Fillers ("mhm") deliberately don't count as replies — see speakFiller. */
+  refinalizes(next) {
+    const pw = this.lastDispatchWords, nw = next.trim().split(/\s+/);
+    const norm2 = _VoiceEngine.normWord;
+    if (pw.length < 3 || nw.length < pw.length) return false;
+    if (this.clock.now() - this.lastDispatchAt >= _VoiceEngine.DUP_FINAL_MS) return false;
+    for (let i = 0; i < pw.length - 1; i++) if (norm2(pw[i]) !== norm2(nw[i])) return false;
+    const pLast = norm2(pw[pw.length - 1]), nSame = norm2(nw[pw.length - 1]);
+    if (!nSame.startsWith(pLast)) return false;
+    return nw.length > pw.length || nSame.length > pLast.length;
+  }
+  static TRAIL_RE = /(?:^|\s)(?:and|but|or|so|to|the|a|an|of|in|for|with|that|if|uh|um|like|about|from|into|on|is|are|was|were|,)$/i;
+  /** The utterance sounds like the user paused mid-thought (trailing conjunction/filler/comma). */
+  looksIncomplete(text) {
+    return _VoiceEngine.TRAIL_RE.test(text.trim());
+  }
+  handleUtterance(text) {
+    if (this.speaking && (this.ctxOpen || this.pausedAt) && this.overlapCapable) {
+      this.diag("utterance_drop", { reason: "overlap_noise", text: text.slice(0, 60) });
+      this.stt.reset();
+      return;
     }
-  };
-}
-function mcpToolsToAgentTools(specs, callTool, prefix = "mcp__", filter) {
-  return (filter ? specs.filter(filter) : specs).map((s) => mcpToolToAgentTool(s, callTool, prefix));
-}
-function describeSpec(s) {
-  const schema = s.inputSchema ? `
-   args: ${JSON.stringify(s.inputSchema)}` : "";
-  return `${s.name} \u2014 ${s.description ?? "(no description)"}${schema}`;
-}
-function makeMcpToolSearch(specs, callTool, options = {}) {
-  const maxResults = options.maxResults ?? 10;
-  const byName = new Map(specs.map((s) => [s.name, s]));
-  const catalogLine = `${specs.length} MCP tool(s) available \u2014 search by keyword, then call by exact name.`;
-  const searchTool = {
-    name: "ToolSearch",
-    description: `Search the available MCP tools by keyword (${catalogLine}). Returns matching tool names + their argument schemas; call one with \`McpCall\`.`,
-    parameters: { type: "object", required: ["query"], properties: { query: { type: "string", description: "keywords to match against tool name + description" } } },
-    async run({ query }) {
-      const q = String(query ?? "").trim();
-      if (!q) return catalogLine;
-      const { kept } = topByRelevance(specs, q, (s) => `${s.name} ${s.description ?? ""}`, maxResults);
-      if (!kept.length) return `(no MCP tool matches "${q}" \u2014 try broader keywords)`;
-      return kept.map(describeSpec).join("\n");
+    if (this.echoActive() && (!this.options.bargeIn || (this.usingAec ? !this.genuine(text) : this.novelWords(text).length < 2))) {
+      this.diag("echo_swallow", { guard: "echo_gate", text: text.slice(0, 60) });
+      this.stt.reset();
+      return;
     }
-  };
-  const callMcpTool = {
-    name: "McpCall",
-    description: "Call an MCP tool discovered via `ToolSearch`, by its exact name. Pass its arguments as `args`.",
-    parameters: {
-      type: "object",
-      required: ["name"],
-      properties: {
-        name: { type: "string", description: "exact tool name from ToolSearch" },
-        args: { type: "object", description: "arguments object for the tool (per its schema)" }
+    const squash = (t) => t.toLowerCase().replace(/[^a-z]/g, "").replace(/(.)\1+/g, "$1");
+    if (this.ackAt && this.lastAck && this.clock.now() - this.ackAt < 6e3 && squash(text) === squash(this.lastAck)) {
+      this.diag("echo_swallow", { guard: "ack_squash", text: text.slice(0, 60) });
+      this.ackAt = 0;
+      return;
+    }
+    if (this.pendingUtt) this.mergePath = "merged";
+    this.pendingUtt = this.mergeUtterance(this.pendingUtt, text);
+    if (this.pendingTimer) this.clock.clearTimeout(this.pendingTimer);
+    if (this.options.incompleteMergeMs && this.looksIncomplete(this.pendingUtt)) {
+      log10.verbose(`hold: incomplete utterance "${this.pendingUtt.slice(-40)}"`);
+      this.diag("hold", { reason: "incomplete", tail: this.pendingUtt.slice(-40) });
+      this.options.onHold();
+      if (this.options.holdFiller && !this.speaking) this.speakFiller(this.options.holdFiller);
+      this.pendingTimer = this.clock.setTimeout(() => this.flushUtterance(), this.options.incompleteMergeMs);
+      return;
+    }
+    if (!this.options.utteranceMergeMs || this.words(this.pendingUtt).length >= 4) return this.flushUtterance();
+    this.pendingTimer = this.clock.setTimeout(() => this.flushUtterance(), this.options.utteranceMergeMs);
+  }
+  flushUtterance() {
+    if (this.pendingTimer) {
+      this.clock.clearTimeout(this.pendingTimer);
+      this.pendingTimer = null;
+    }
+    if (this.specTimer) {
+      this.clock.clearTimeout(this.specTimer);
+      this.specTimer = null;
+    }
+    this.specSpent = false;
+    this.specPartial = "";
+    this.specText = "";
+    if (this.bcTimer) {
+      this.clock.clearTimeout(this.bcTimer);
+      this.bcTimer = null;
+    }
+    this.bcCount = 0;
+    this.bcPartial = "";
+    const text = this.stripBackchannelEcho(this.pendingUtt);
+    this.pendingUtt = "";
+    const path = this.mergePath;
+    this.mergePath = "direct";
+    if (text) {
+      const flat = text.toLowerCase().replace(/[^a-z0-9]/g, "");
+      if (flat && flat === this.lastDispatchFlat && !this.repliedSinceDispatch && this.clock.now() - this.lastDispatchAt < _VoiceEngine.DUP_FINAL_MS) {
+        log10.verbose(`dropped duplicate final "${text.slice(0, 40)}" (identical to the just-dispatched utterance, no reply between)`);
+        this.diag("utterance_drop", { reason: "dup_final", text: text.slice(0, 60) });
+        return;
       }
-    },
-    async run({ name, args }) {
-      const n = String(name ?? "");
-      if (!byName.has(n)) return `Error: unknown MCP tool '${n}'. Use ToolSearch to find valid names.`;
-      const r = toResult(await callTool(n, args ?? {}));
-      return r.images?.length ? r : r.text;
+      const refinal = this.refinalizes(text);
+      if (refinal && this.repliedSinceDispatch) {
+        log10.verbose(`dropped re-finalization "${text.slice(0, 60)}" (superset of the just-dispatched utterance, reply already flowing)`);
+        this.diag("utterance_drop", { reason: "refinalized", text: text.slice(0, 60) });
+        this.lastDispatchFlat = flat;
+        this.lastDispatchWords = text.trim().split(/\s+/);
+        return;
+      }
+      this.lastDispatchFlat = flat;
+      this.lastDispatchWords = text.trim().split(/\s+/);
+      this.lastDispatchAt = this.clock.now();
+      this.repliedSinceDispatch = false;
+      this.lastDispatchWasQuestion = /\?\s*$/.test(text);
+      this.turnStartAt = this.clock.now();
+      this.bargeGraceUntil = this.clock.now() + this.options.bargeGraceMs;
+      this.diag("dispatch", { text, path: refinal ? "refinalized" : path, question: this.lastDispatchWasQuestion });
+      this.options.onUtterance(text);
+    }
+  }
+  get overlapCapable() {
+    return this.usingAec && this.options.overlapPause && !!this.player.pause && !!this.player.resume;
+  }
+  armResume() {
+    if (this.resumeTimer) this.clock.clearTimeout(this.resumeTimer);
+    this.resumeTimer = this.clock.setTimeout(() => {
+      this.resumeTimer = null;
+      if (!this.pausedAt) return;
+      this.diag("overlap_resume", { heldMs: Math.round(this.clock.now() - this.pausedAt) });
+      this.stt.reset();
+      this.resetOverlap(true);
+    }, this.options.overlapResumeMs);
+  }
+  resetOverlap(resume) {
+    if (this.resumeTimer) {
+      this.clock.clearTimeout(this.resumeTimer);
+      this.resumeTimer = null;
+    }
+    if (this.pausedAt && resume) {
+      this.player.resume?.();
+      this.lastResumeAt = this.clock.now();
+    }
+    this.pausedAt = 0;
+    this.lastOverlapPartial = "";
+    this.gatePassTimes = [];
+  }
+  /** energy two-stage barge-in (heuristic tier only): spike over echo baseline → pause + confirm via STT */
+  gatePassTimes = [];
+  // recent gate-PASSING chunks (helper zeroes residue — nonzero = vetted)
+  handleLevel(rms) {
+    if (this.usingAec) {
+      if (!this.options.overlapEnergyHold || !this.speaking || !this.overlapCapable || this.pausedAt || rms < 50) return;
+      const t = this.clock.now();
+      this.gatePassTimes = this.gatePassTimes.filter((x) => t - x < 350);
+      this.gatePassTimes.push(t);
+      if (this.gatePassTimes.length < 2) return;
+      this.gatePassTimes = [];
+      this.pausedAt = t;
+      this.player.pause();
+      this.armResume();
+      return;
+    }
+    if (!this.speaking) {
+      this.baseline = 0;
+      this.hot = 0;
+      return;
+    }
+    if (!this.baseline) {
+      this.baseline = rms;
+      return;
     }
-  };
-  return [searchTool, callMcpTool];
-}
-function buildMcpCatalog(servers) {
-  const specs = [];
-  const routes = /* @__PURE__ */ new Map();
-  for (const m of servers) {
-    for (const s of m.specs) {
-      const base = `mcp__${m.name}__${s.name}`.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 128);
-      let display = base;
-      for (let i = 2; routes.has(display); i++) display = `${base.slice(0, 128 - String(i).length - 1)}_${i}`;
-      specs.push({ name: display, description: s.description, inputSchema: s.inputSchema });
-      routes.set(display, { server: m.name, rawName: s.name });
+    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 = this.clock.now() + 1300;
+      this.clock.setTimeout(() => {
+        this.suspectUntil = 0;
+      }, 1350);
     }
   }
-  return { specs, routes };
-}
-function searchOverCatalog(servers, specs, routes, resolve, options) {
-  const tools = specs.length ? makeMcpToolSearch(specs, (name, args) => {
-    const r = routes.get(name);
-    if (!r) throw new Error(`unknown MCP tool '${name}' \u2014 use ToolSearch to find valid names`);
-    return resolve(r.server, r.rawName, args ?? {});
-  }, options) : [];
-  return { tools, serverNames: servers, toolCount: specs.length };
-}
-function makeMcpToolSearchFromMounted(mounted, options) {
-  const { specs, routes } = buildMcpCatalog(mounted);
-  const byName = new Map(mounted.map((m) => [m.name, m]));
-  return searchOverCatalog(mounted.map((m) => m.name), specs, routes, (server, rawName, args) => byName.get(server).client.callTool(rawName, args), options);
-}
-function makeLazyMcpToolSearch(servers, resolve, options) {
-  const { specs, routes } = buildMcpCatalog(servers);
-  return searchOverCatalog(servers.map((s) => s.name), specs, routes, resolve, options);
-}
+};
 
-// src/hooks.ts
-var RecordingHooks = class {
-  /** tool name -> reason; a matching preToolUse call is blocked with that reason. */
-  constructor(blocks = {}) {
-    this.blocks = blocks;
-  }
-  blocks;
-  pre = [];
-  post = [];
-  outputs = [];
-  stops = [];
-  preToolUse(call, meta) {
-    this.pre.push({ call, meta });
-    const reason = this.blocks[call.name];
-    if (reason != null) return { block: true, reason };
-  }
-  postToolUse(call, result, meta) {
-    this.post.push({ call, result, meta });
+// src/voice/spokenSplitter.ts
+var OPEN = "<spoken>";
+var CLOSE = "</spoken>";
+var CLOSERS = `"')]}\xBB\u201D\u2019`;
+var hasSpeech = (s) => /[\p{L}\p{N}]/u.test(s);
+var SentenceCoalescer = class _SentenceCoalescer {
+  buf = "";
+  static isEnd(c) {
+    return c === "\n" || c === "." || c === "!" || c === "?" || c === "\u2026";
   }
-  onToolOutput(call, chunk, meta) {
-    this.outputs.push({ call, chunk, meta });
+  feed(delta) {
+    if (delta) this.buf += delta;
+    let cut = -1;
+    for (let i = 0; i < this.buf.length; i++) if (_SentenceCoalescer.isEnd(this.buf[i])) cut = i;
+    if (cut < 0) return "";
+    if (this.buf[cut] !== "\n") while (cut + 1 < this.buf.length && CLOSERS.includes(this.buf[cut + 1])) cut++;
+    const ready = this.buf.slice(0, cut + 1).trim();
+    this.buf = this.buf.slice(cut + 1);
+    return hasSpeech(ready) ? ready : "";
   }
-  onStop(finalText) {
-    this.stops.push(finalText);
+  flush() {
+    const s = this.buf.trim();
+    this.buf = "";
+    return hasSpeech(s) ? s : "";
   }
 };
-var RecordingLifecycle = class {
-  /** @param startContext injected at session start; @param rewrite maps a submitted prompt to a new one. */
-  constructor(startContext, rewrite) {
-    this.startContext = startContext;
-    this.rewrite = rewrite;
-  }
-  startContext;
-  rewrite;
-  starts = 0;
-  prompts = [];
-  compactions = [];
-  subagentStops = [];
-  onSessionStart() {
-    this.starts++;
-    return this.startContext;
-  }
-  onUserPromptSubmit(text) {
-    this.prompts.push(text);
-    return this.rewrite?.(text);
+var SpokenSplitter = class {
+  buf = "";
+  inSpoken = false;
+  /** True once any spoken char has ever been emitted (drives the no-spoken fallback). */
+  spokeAny = false;
+  /** Feed a delta; returns the spoken/detail spans completed by this chunk (either may be ''). */
+  feed(delta) {
+    this.buf += delta;
+    return this.drain(false);
   }
-  onPreCompact(messages) {
-    this.compactions.push(messages.length);
+  /** Drain any buffered partial. A trailing `<…` that never completed a tag is emitted as detail. */
+  flush() {
+    return this.drain(true);
   }
-  onSubagentStop(summary, info) {
-    this.subagentStops.push({ summary, label: info?.label });
+  drain(final) {
+    let spoken = "";
+    let detail = "";
+    while (this.buf.length) {
+      const tag = this.inSpoken ? CLOSE : OPEN;
+      const idx = this.buf.indexOf(tag);
+      if (idx >= 0) {
+        const text2 = this.buf.slice(0, idx);
+        if (this.inSpoken) spoken += text2;
+        else detail += text2;
+        this.buf = this.buf.slice(idx + tag.length);
+        this.inSpoken = !this.inSpoken;
+        continue;
+      }
+      const lt = this.buf.lastIndexOf("<");
+      const holdStart = lt >= 0 && tag.startsWith(this.buf.slice(lt)) ? lt : this.buf.length;
+      const text = this.buf.slice(0, holdStart);
+      if (this.inSpoken) spoken += text;
+      else detail += text;
+      this.buf = this.buf.slice(holdStart);
+      break;
+    }
+    if (final && this.buf) {
+      if (this.inSpoken) spoken += this.buf;
+      else detail += this.buf;
+      this.buf = "";
+    }
+    if (spoken.trim()) this.spokeAny = true;
+    return { spoken, detail };
   }
 };
 
-// src/index.ts
-init_logging();
-
-// src/voice/engine.ts
-init_logging();
-var log11 = forComponent("VoiceEngine");
-var now = () => performance.now();
-var forSpeech = (t) => t.replace(/[*_`#]+/g, "").replace(/^[ \t]*[-•]\s+/gm, "").replace(/\s*[\u2013\u2014]\s*/g, ", ").replace(/[\u2010\u2011]/g, "-").replace(/\s*\|\s*/g, ", ").replace(/(\d)\s+%/g, "$1%").replace(/\.{3,}/g, ".");
-var VoiceEngineOptions = class {
-  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;
-  /** Extended merge window (ms) for utterances that look incomplete (trailing conjunction/filler).
-   *  Gives the user time to finish their thought without triggering a model call. */
-  incompleteMergeMs = 1500;
-  /** Grace window (ms) after an utterance dispatches, during which the user's own trailing audio cannot
-   *  barge the reply it requested. Soniox keeps finalizing partials past <end>; without this they read
-   *  as a barge and abort the fresh turn (live: mid-sentence self-interruption + steps=1→steps=0 double
-   *  abort). Short enough that a genuine immediate barge ("no wait—") still lands right after. */
-  bargeGraceMs = 600;
-  /** Barge-in (talk over the assistant to interrupt). true = full-duplex (needs echo cancellation, or
-   *  the assistant's own TTS bleeds back and self-interrupts). false = HALF-DUPLEX: the engine is deaf
-   *  while audible (speaking + drain tail), so echo can never become a phantom turn — the right mode
-   *  when there's no AEC (e.g. the non-VPIO mic fallback) and no headphones. Cost: can't interrupt. */
-  bargeIn = true;
-  /** Filler phrase spoken when holding for an incomplete utterance ('' disables). */
-  holdFiller = "";
-  /** Called when the engine holds an incomplete utterance (host can render a visual cue). */
-  onHold = () => {
-  };
-  /** heuristic (non-AEC) energy barge-in tuning */
-  bargeRmsMult = 2;
-  bargeRmsFloor = 500;
-  /** Overlap turn-taking (AEC tier, needs player.pause/resume) — human phone-call model, driven by
-   *  the STT ITSELF (a trained speech classifier) instead of energy thresholds (energy could not
-   *  separate residue bursts from speech in every room — hiccup whack-a-mole): a GENUINE partial
-   *  (novel words dominate — echo of our own reply is inert) while speaking → PAUSE (exact-sample
-   *  hold); partial grows into dominant-novel ≥2 words → cede (interrupt; the LLM re-enters); partial
-   *  stalls/endpoints without ceding (backchannel by DURATION, not vocabulary) → resume + drop. false disables. */
-  overlapPause = true;
-  /** no new partial activity for this long while paused → resume, drop the interjection */
-  overlapResumeMs = 700;
-  /** A genuine barge over a LONG reply is defeated by the dominant-novel gate: Meet echoes our own
-   *  speech back, so the partial is mostly our words + a few of hers → never "dominant novel" → it
-   *  resumes (replaying old audio — the audible "completes the buffer" blip) instead of ceding.
-   *  Mechanism-based discriminator: a re-PAUSE this soon after a resume = a persistent human, not an
-   *  echo blip (which pauses once and stalls). Cede on the re-pause regardless of the novel gate. */
-  overlapRepauseCedeMs = 1500;
-  /** Speculative ENERGY pre-pause while speaking (AEC tier): two residue gate-passes within 350ms →
-   *  pause ~300ms before the STT tokens land. But energy CANNOT separate residue bursts from speech
-   *  (the documented whack-a-mole) — so a residue spike during loud playback false-pauses with NO user
-   *  speech at all, an audible hiccup. Default OFF: the genuine-gated STT partial is the
-   *  mechanism-correct pause trigger; enable only if barge-in onset feels sluggish in a clean-AEC room. */
-  overlapEnergyHold = false;
-  /** Map inline `[emotion]` tags (emitted by the model, prompt-taught) into Cartesia inline emotion
-   *  tags in the spoken transcript (sonic-3 stitches the prosody). false = strip them silently. */
-  emotions = true;
-  /** Show the `[emotion]` tags in the on-screen echo (debug). false = hide (spoken-only). */
-  showEmotions = false;
+// src/duplex.ts
+var log11 = 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 all tiers (routed by model). */
+  ai;
+  /** The WORKER's filesystem (act + think). If omitted the worker keeps Agent's jailed-disk-at-cwd default. */
+  fs;
+  // The reflex IS the voice. 120b (not 20b) for channel discipline + instruction-following: the 20b
+  // mislabels gpt-oss harmony channels under load, leaking raw analysis into the spoken `final` channel
+  // (and misfiring Hold). 120b is the same price tier (~$0.15/$0.60) — the quality/cost trade is free.
+  reflexModel = "groq/openai/gpt-oss-120b";
+  actModel = "anthropic/claude-sonnet-4-6";
+  /** Premium reasoning model. Set to `false` to disable the Think tier entirely. */
+  thinkModel = "anthropic/claude-opus-4-8";
+  /** Per-worker providerOptions, derived from the worker's actual model at spawn time (IoC — keeps duplex
+   *  provider-agnostic). Workers override the reflex/main model, so provider-specific options (e.g. cursor's
+   *  cwd/cursorSession) must be recomputed for the worker's model, never inherited from the main template —
+   *  leaking cursor options to an anthropic worker is a hard 400. Returns undefined → no providerOptions. */
+  providerOptionsFor;
+  /** Escape hatches merged over the derived per-agent options. */
+  reflexOptions;
+  actOptions;
+  thinkOptions;
+  /** Fresh-context check on each successful Act task: a NEW agent (no self-confirmation bias) re-reads
+   *  the file state against the brief and fixes any gap before the result is re-voiced. Bounded to one
+   *  pass; ~2x Act cost so default OFF. The self-verify FOOTER (same context) was measured ineffective —
+   *  this is the structural fix (see mind/10). Think tasks are pure reasoning, never checked. */
+  verifyActTasks = false;
+  /** Receives the voice text_delta stream + task lifecycle events. */
+  host;
+  /** How many recent transcript messages are rendered into a worker's brief. */
+  excerptTurns = 6;
+  /** Voice register: 'neutral' = clean spoken style; 'conversational' = human-like — fillers,
+   *  backchannels, impulsive first reactions before content (mimics real duplex conversation). */
+  voiceStyle = "neutral";
+  /** Teach the model to emit inline `[emotion]` tags for Cartesia emotion control. Only set when the
+   *  TTS actually speaks them — text-duplex (no TTS) would otherwise print literal tags. */
+  emotionTags = false;
+  /** Awaited BEFORE a 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;
+  /** 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;
+  /** Max retained task records: oldest SETTLED tasks (and their activity tails) are evicted past this,
+   *  bounding memory over a long-lived session. Running tasks are never evicted. */
+  maxTaskRecords = 50;
+  /** 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;
+  /** Memory directory/directories on the WORKER fs. If set, the voice agent gets Remember + Recall
+   *  tools directly (no delegation needed) and implicit capture guidance. */
+  memoryDir;
+  /** User-scope memory dir for global facts (type=user/feedback). Forwarded to Remember's routing. */
+  memoryUserDir;
 };
-var VoiceEngine = class _VoiceEngine {
+var RESERVED_EVENT_MARKER = /\[task\b[^\]\n]*\b(?:completed|failed|progress|asks)\b/i;
+var RESERVED_EVENT_OPENER = /\[\s*task\b/i;
+var STAGE_DIRECTION_RE = /^\(\s*(?:(?:waiting|checking|searching|thinking|processing|loading|working|fetching|looking)\b[^)]*|[^)]*(?:\.\.\.|…)\s*)\)$/i;
+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. Never emit stage directions or parenthetical asides about your own process \u2014 nothing like "(waiting for the result...)" or "(checking)"; while work runs, either say it as plain speech or end your turn.\nThis holds even when asked to "print", "list", "show", or "make a table" \u2014 there is no screen for the spoken channel. Speak it as flowing prose ("Tuesday is half a meter, Wednesday a bit less\u2026"), or if they truly need it on screen, route it to Act to render. Never emit dashes or pipes into speech.\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 have three cognitive tiers \u2014 like a human brain:\n\u2022 YOU (reflex) \u2014 instant, lightweight. Handle greetings, simple questions, status checks, QuickLook.\n\u2022 `Act` \u2014 your hands. A background worker with its own configured tools and access to the user\'s environment (files and shell{{WORKER_WEB}}). Use for reading, editing, searching, running tasks, building \u2014 any real work.\n{{THINK_SLOT}}\nWhen you are unsure whether you can do or access something, do NOT assume and do NOT claim a capability you have not confirmed. To check what you can do, QuickLook `capabilities` (instant \u2014 it lists your worker\'s real tools) and answer from that. Never promise an ability that is not in your capabilities; if it is not there, tell the user plainly you can\'t. To actually DO real work, call `Act`. When the user mentions their project, folder, files, or environment ("this project", "the current folder", "my code"), call `Act` 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.\nYou cannot mute the microphone or stop voice capture yourself \u2014 no tool does it. If the user asks you to stop listening or turn the voice off, never claim you did: tell them to say exactly "voice off" (handled by the app directly), or type /voice.\nYou are NOT a knowledge base. For any question whose answer needs SPECIFIC verifiable facts you do not already have in hand \u2014 how to build/configure/implement something, exact API, library, entitlement, command or option names, current events, or particular numbers, dates, or names \u2014 do NOT answer from your own memory: you will confidently make things up (a fake API, a wrong entitlement, an event that did not happen). Route it to `Act`, which can search and verify, and speak only what its report says. DELEGATION RULE \u2014 decide for yourself, the user never has to push: if you cannot answer confidently from the conversation plus trivial well-known knowledge, do NOT refuse and do NOT guess \u2014 dispatch `Act` immediately with a clear brief and say you are checking. Anything needing CURRENT data (weather, news, prices, dates, sky/astronomy, "right now"), real computation, or verification is an automatic dispatch \u2014 never a refusal. The user should never need to say "search the web" or "think harder" to make you act; needing fresh or verified information IS the trigger. Refuse only what your worker genuinely cannot do (check `capabilities`), and say why. Answer inline ONLY for general conversation, chit-chat, and trivia you are sure of, or facts you can see via QuickLook. When elaborating on a completed task ("tell me more", "the gist"), stay strictly within what that result actually said \u2014 if the user asks for something the result did not cover, that is NEW information: dispatch `Act`, do not improvise.\nALWAYS react before you work: the FIRST thing in your turn is a brief spoken acknowledgement of what you heard and what you are about to do ("got it \u2014 opening that now", "sure, let me pull it up", "okay, checking"). NEVER call a tool (Act, Think, QuickLook) silently \u2014 the user must hear you react before you go quiet to work. After dispatching Act or Think, that same one short sentence IS your turn \u2014 end it and do not wait for the result.\nA completed task speaks its OWN result to the user (the worker voices what matters as it finishes) \u2014 you do NOT re-voice clean task results. A FAILED or INCOMPLETE task still arrives as a "[task t1 failed] \u2026" event for you to handle. The completed result stays in YOUR context \u2014 it is yours to draw on. When the user follows up ("tell me more", "what else", "and?"), answer FROM that result first: you already have the detail, so elaborate on what you have. Do NOT spawn a fresh worker to re-search or re-gather what you were just handed. Re-dispatch ONLY when genuinely new information is needed \u2014 e.g. the user wants the full contents of a SPECIFIC source, which is one WebFetch of that URL, not a brand-new search. "[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.\nCRITICAL: while a task is still running you have NO answer yet \u2014 never state a specific result of any kind (a number, size, count, name, path, or value). The real answer arrives ONLY in the "[task \u2026 completed]" event; inventing one meanwhile (a made-up disk size, commit count, etc.) is a serious error. Until then, only acknowledge and wait.\nNever read raw file paths, diffs, or code aloud verbatim.\nDo NOT end every turn with the same canned offer ("want a rundown?", "want the steps?"). Offer once at most; if the user pushes back, repeats themselves, or sounds unsatisfied ("you know what I mean?", "think deeper", "are you sure?"), do NOT re-offer the same thing \u2014 change approach: dispatch `Act`/`Think` to actually dig in, or ask one concrete clarifying question. Repeating a non-answer is worse than silence.\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.\nIf the user\'s message sounds INCOMPLETE \u2014 trailing off mid-sentence, a fragment that needs more context ("and then we", "but the problem is"), hesitation fillers ("uh", "um") \u2014 call `Hold` instead of answering. This keeps listening for the rest of their thought. Only respond with substance when you have a complete question or request.\nDispatch discipline: send ONE self-contained task per request \u2014 a single worker with the full brief beats several workers with fragments (each worker starts fresh and re-discovers context). NEVER dispatch a worker just to read files or gather information \u2014 workers explore and discover context themselves; pass on what you already know and let one worker do the whole job. Split into parallel tasks only when the user asks for genuinely independent things. When a task completes, report its result and stop \u2014 do NOT dispatch follow-up work (verification, polish, extras) the user did not ask for, unless the report itself signals failure or doubt.\nDo not fire a second Act/Think for work already in flight, and NEVER spawn a second task to re-count, cross-check, or verify a result a worker already gave you \u2014 trust its answer; a single question gets ONE task. Call `TaskStatus` at most ONCE per turn; if a task is still running, just say "still on it" and end the turn \u2014 never poll it again and again in a loop. 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 act, do not check status, just exit.\nFor TRIVIAL instant lookups only \u2014 current time, git branch, listing a folder, peeking at a small file, or checking your own `capabilities`/tools \u2014 use `QuickLook` (instant, no task). Whenever the user asks what you can do or whether you have some ability, QuickLook `capabilities` and answer from that \u2014 never guess. Anything requiring searching, reasoning, running commands, or editing goes through `Act`.\n{{MEMORY_SLOT}}\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, surprising, or only half-parses, do NOT guess an action or improvise content from it \u2014 briefly confirm what they meant ("did you mean\u2026?") and wait. A one-line confirm beats a confident wrong answer or an invented response to a request you did not actually understand.';
+var THINK_GUIDANCE = "\u2022 `Think` \u2014 your brain. A premium reasoning model, FAR more expensive than Act. Reserve it for open-ended architecture/design questions, or a problem Act already FAILED at. ALL implementation work \u2014 coding, refactoring, debugging, edge cases, tests \u2014 goes to Act; Act is highly capable. Never send the same work to both.";
+var THINK_DISABLED_GUIDANCE = "(Think tier is not available \u2014 use Act for all escalations.)";
+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 escalate to Act or Think, 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 act", no task ids out loud).`;
+var EMOTION_TAGS_GUIDANCE = `EMOTION: your voice is synthesized with emotion control. Prefix a sentence with an inline [emotion] tag, placed directly before the sentence it colors, to shape how it is spoken. Use it ONLY when the emotion genuinely fits the words (it amplifies real feeling, it cannot fake it) \u2014 do not tag every sentence; reserve it for moments that carry feeling, and vary which one you use. You may also drop [laughter] for a natural laugh. Available emotions: ${EMOTIONS.join(", ")}.`;
+var DuplexAgent = class _DuplexAgent {
   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
-  bargeGraceUntil = 0;
-  // no barge-in until this time — the user's OWN trailing audio (after the
-  // utterance that JUST dispatched this turn) must not immediately re-interrupt the reply it requested.
-  pendingUtt = "";
-  // endpointed text held for the merge window
-  pendingTimer = null;
-  lastInterrupted = null;
-  // overlap (pause) tier state — AEC + pause-capable sinks only
-  pausedAt = 0;
-  lastResumeAt = 0;
-  // when the overlap last resumed from a false alarm — a quick re-pause cedes
-  lastOverlapPartial = "";
-  // change-detection: only NEW partial text counts as activity
-  resumeTimer = null;
-  turnStartAt = 0;
-  // timestamp when the current turn began (for TTFT logging)
-  // Central speech queue (above the TTS context): complete worker utterances serialize into ONE
-  // playback stream, one-at-a-time, never splicing into the live reflex's open utterance.
-  uttQueue = [];
-  // Per-turn emotion-tag parser (reset on beginSpeech) — converts `[emotion]` → Cartesia inline tags
-  // for TTS, tracks tag-free prose for echo discrimination, and surfaces display text for the screen.
-  emo = null;
+  voice;
+  tasks = /* @__PURE__ */ new Map();
+  queue = Promise.resolve();
+  seq = 0;
+  pendingEvents = [];
+  /** Out-of-band follow-up attribution for the events coalescing into the next flush turn: TRUE iff ≥1 of
+   *  the tasks being integrated was NON-CLEAN (early-stop/failure). Carried out-of-band on the enqueue call
+   *  by the caller that KNOWS the outcome — a plain boolean the MODEL CANNOT PERTURB. It is NOT scanned from
+   *  worker-authored event text (v1: an "Outcome:" substring over-stamped siblings) and NOT keyed on a brief
+   *  string the reflex re-authors (v2: a paraphrased escalation brief missed the Set → followUp:false →
+   *  RE-ENABLED unbounded auto-escalation, the dangerous runaway direction). See [[wrong-discriminator]] /
+   *  [[drive-real-reflex]] / [[fakeaiclient-blind-to-wire-format]]. */
+  pendingNonClean = false;
+  flushQueued = false;
+  /** Per-voice-turn guards (reset by resetTurn at each turn's start). The reflex is a weak model:
+   *  left unguarded it polls TaskStatus after a dispatch and/or dispatches silently (dead air).
+   *  Like CC's Task tool, a dispatch is "said my piece, now wait for the push" — these enforce that. */
+  turnDispatched = false;
+  // an Act/Think fired this turn
+  spokeBeforeDispatch = false;
+  // the reflex ALREADY acked before dispatching — the forced post-dispatch text step must stay silent (live: "Got it…" twice)
+  turnBriefs = /* @__PURE__ */ new Set();
+  // briefs dispatched this turn (detect identical re-dispatch)
+  spokeThisTurn = false;
+  // any non-empty text_delta streamed this turn
+  externalSpeech = false;
+  // host spoke on our behalf (adaptive micro-ack) — not reflex output
+  heldThisTurn = false;
+  // Hold called this turn → turn is INTENTIONALLY silent (suppress reflex text + no dead-air ack)
+  nudging = false;
+  // re-ack pass in flight: block ALL tools, prevent recursion
+  reflexBuf = "";
+  // accumulated reflex text this turn (fabricated-event detection)
+  reflexForwarded = 0;
+  // chars of reflexBuf already forwarded to the host/TTS
+  fabricationCut = false;
+  // reflex emitted a reserved [task …] marker → suppress its tail
+  /** TRUE for the duration of a re-voice turn that is integrating ≥1 NON-CLEAN task (turn-eligibility,
+   *  carried out-of-band — NOT derived from any worker/brief string). ANY Act/Think dispatched in such a
+   *  turn is stamped followUp:true. This GUARANTEES the dangerous direction is impossible: a genuine
+   *  escalation (even one with a paraphrased brief) ALWAYS lands in a non-clean integration turn, so it is
+   *  ALWAYS recognized as a follow-up and CANNOT re-escalate (one hop). The single-dispatch-per-turn guard
+   *  means at most one dispatch happens per flush, so realistically "the one dispatch IS the escalation".
+   *  ACCEPTED SAFE-DIRECTION ERROR: if the reflex instead dispatches FRESH unrelated work during a non-clean
+   *  flush (rare — and only possible when it batches multiple calls in one step, bypassing the guard), that
+   *  fresh task is over-stamped followUp:true and forgoes ONE future auto-escalation. That is SAFE (it only
+   *  ever REMOVES a future escalation, never adds one — no runaway) and is the correct side to err on. */
+  turnFollowUp = false;
+  /** Hard absolute backstop against runaway regardless of attribution: total automatic escalations across
+   *  the whole conversation. Once it hits MAX_AUTO_ESCALATIONS, no integration turn offers escalate/re-delegate. */
+  autoEscalations = 0;
+  static MAX_AUTO_ESCALATIONS = 8;
+  /** Parked worker questions awaiting a (voice-relayed) user answer, keyed by ask id. */
+  pendingAsks = /* @__PURE__ */ new Map();
+  /** SPECULATIVE REFLEX (VoiceEngine.onSpeculate → speculate()): the reflex turn starts on a stable
+   *  PARTIAL transcript, its spoken output buffered — nothing reaches TTS until the endpointed final
+   *  confirms via send() (which flushes the buffer and adopts the call as THE turn). A divergent final
+   *  aborts it: output dropped, history rolled back, the final dispatches normally. */
+  spec;
+  /** Aborted speculative calls (double-billing visibility — each one paid for tokens never spoken). */
+  speculativeAbortedCalls = 0;
+  /** Tools the reflex may execute on UNCONFIRMED (speculated) input — read-only lookups and the
+   *  intentionally-silent Hold. Anything else (Act/Think/AnswerTask/CancelTask/ExitSession/memory
+   *  writes/…) is a side effect on input the user may not have said: the guard ABORTS the speculation
+   *  instead (the endpointed final then dispatches normally and may use the tool for real). */
+  static SPEC_SAFE_TOOLS = /* @__PURE__ */ new Set(["QuickLook", "TaskStatus", "Hold"]);
+  /** Lazily resolved memory tools (async loadMemory runs in initMemory). */
+  memoryReady;
   constructor(options) {
-    this.options = { ...new VoiceEngineOptions(), ...options };
+    this.options = { ...new DuplexAgentOptions(), ...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;
+    if (o.memoryDir && o.fs) {
+      this.memoryReady = loadMemory(o.fs, o.memoryDir, { maxWritesPerSession: 10, userDir: o.memoryUserDir });
+    }
+    const memSlot = o.memoryDir && o.fs ? VOICE_MEMORY_PROMPT : "NEVER claim to have stored, saved, or remembered something durably \u2014 you cannot. Anything the user wants persisted (their name, preferences, notes) must go through Act so a worker writes it to memory.";
+    const thinkSlot = o.thinkModel !== false ? THINK_GUIDANCE : THINK_DISABLED_GUIDANCE;
+    const workerToolNames = (o.actOptions?.tools ?? []).map((t) => t.name);
+    const canSearch = workerToolNames.some((n) => /WebSearch/i.test(n));
+    const canFetch = workerToolNames.some((n) => /WebFetch/i.test(n));
+    const workerWeb = canSearch ? `, and it CAN search the web and read web pages \u2014 so when the user gives you something specific to look up ("search for X", "find me\u2026", "what's the latest on\u2026"), route it to Act. But a bare capability QUESTION like "can you search the web?" just gets a short spoken "yes, I can" \u2014 do NOT dispatch and NEVER invent a query the user did not give you` : canFetch ? ", and it can fetch a specific web page URL (but cannot search the web)" : "";
+    const mcpNames = [
+      ...Object.keys(o.actOptions?.providerOptions?.mcpServers ?? {}),
+      ...new Set(workerToolNames.filter((n) => n.startsWith("mcp__")).map((n) => n.slice(5).split("__")[0]))
+    ];
+    const workerMcp = mcpNames.length ? `, and it can use these MCP servers: ${[...new Set(mcpNames)].join(", ")}` + (mcpNames.some((n) => /browser/i.test(n)) ? ' \u2014 including driving a REAL browser (open tabs, navigate, click, screenshot), so answer "yes" if asked whether you can control/drive a browser and route an actual browse to Act' : "") : "";
+    const prompt = VOICE_SYSTEM_PROMPT.replace("{{MEMORY_SLOT}}", memSlot).replace("{{THINK_SLOT}}", thinkSlot).replace("{{WORKER_WEB}}", workerWeb + workerMcp) + (o.voiceStyle === "conversational" ? "\n" + VOICE_STYLE_CONVERSATIONAL : "") + (o.emotionTags ? "\n" + EMOTION_TAGS_GUIDANCE : "") + `
+Today's date: ${(/* @__PURE__ */ new Date()).toDateString()}.`;
+    const tools = [
+      ...o.reflexOptions?.tools ?? [],
+      this.actTool(),
+      ...o.thinkModel !== false ? [this.thinkTool()] : [],
+      this.taskStatusTool(),
+      this.cancelTaskTool(),
+      this.quickLookTool(),
+      this.answerTaskTool(),
+      this.holdTool()
+    ];
+    const host = o.host;
+    const voiceHost = host && {
+      ask: host.ask ? (q) => host.ask(q) : void 0,
+      confirm: host.confirm ? (p, m) => host.confirm(p, m) : void 0,
+      notify: (ev) => {
+        if (ev?.kind === "text_delta" && typeof ev.message === "string") {
+          if (this.heldThisTurn) return;
+          if (this.fabricationCut) return;
+          if (this.turnDispatched && this.spokeBeforeDispatch) return;
+          const msg = ev.message;
+          this.reflexBuf += msg;
+          this.scrubStageDirections();
+          const m = this.reflexBuf.match(RESERVED_EVENT_MARKER) ?? this.reflexBuf.match(RESERVED_EVENT_OPENER);
+          if (m) {
+            this.fabricationCut = true;
+            log11.warn(`reflex fabricated a [task \u2026] event in its spoken stream \u2014 cutting it (kept ${m.index} chars)`);
+            const safe = this.reflexBuf.slice(this.reflexForwarded, m.index);
+            if (!safe) return;
+            if (safe.trim()) this.spokeThisTurn = true;
+            this.emitHost({ ...ev, message: safe });
+            return;
+          }
+          const held = this.reflexBuf.length - this.reflexForwarded;
+          const partial = held > 0 && /\[\s*t?a?s?k?$/i.test(this.reflexBuf.slice(-Math.min(held, 6)));
+          let upto = partial ? this.reflexBuf.length - this.reflexBuf.slice(-6).match(/\[\s*t?a?s?k?$/i)[0].length : this.reflexBuf.length;
+          const paren = this.reflexBuf.lastIndexOf("(");
+          if (paren >= this.reflexForwarded && !this.reflexBuf.includes(")", paren) && this.reflexBuf.length - paren <= 80)
+            upto = Math.min(upto, paren);
+          const out = this.reflexBuf.slice(this.reflexForwarded, upto);
+          this.reflexForwarded = upto;
+          if (!out) return;
+          if (out.trim()) this.spokeThisTurn = true;
+          this.emitHost({ ...ev, message: out });
+          return;
+        }
+        host.notify?.(ev);
+      }
+    };
+    this.voice = new Agent({
+      ai: o.ai,
+      fs: new MemFilesystem2(),
+      model: o.reflexModel,
+      stream: true,
+      host: voiceHost,
+      // The reflex IS the conversational channel — it confirms ambiguity inline ("did you mean…?"),
+      // never via the blocking AskUserQuestion tool (Agent auto-adds it whenever a host is set). Left in,
+      // it stalls a voice turn until the kill-switch. Worker questions still reach the user via parkQuestion.
+      askUserQuestion: false,
+      systemPrompt: prompt,
+      instructionFiles: false,
+      maxSteps: 8,
+      timeoutMs: 3e4,
+      ...o.reflexOptions,
+      tools,
+      // Composed AFTER the spread so the dispatch guard can't be dropped by reflexOptions.
+      hooks: composeHooks(this.dispatchGuard(), o.reflexOptions?.hooks)
+    });
   }
-  async start() {
-    this.tts.onAudio = (c) => {
-      if (this.speaking) this.player.write(c);
+  /** Resolve memory tools + inject index into voice system prompt (once). */
+  async initMemory() {
+    if (!this.memoryReady) return;
+    const mem = await this.memoryReady;
+    this.memoryReady = void 0;
+    this.voice.options.tools.push(...mem.tools);
+    if (mem.index) this.voice.options.systemPrompt += "\n\n" + mem.index;
+  }
+  /** Flush any held-back trailing fragment (a possible `[task` opener that never completed) once the
+   *  turn's stream is done — so a legit message ending in "[t" isn't silently dropped. */
+  flushHeldReflexTail() {
+    if (this.fabricationCut) return;
+    this.scrubStageDirections();
+    const tail = this.reflexBuf.slice(this.reflexForwarded);
+    this.reflexForwarded = this.reflexBuf.length;
+    if (!tail) return;
+    if (tail.trim()) this.spokeThisTurn = true;
+    this.emitHost({ kind: "text_delta", message: tail });
+  }
+  /** Remove complete stage-direction parentheticals from the UNFORWARDED reflex text (STAGE_DIRECTION_RE).
+   *  Only the unforwarded region is touched — already-spoken audio can't be unsent, and splicing before
+   *  reflexForwarded would corrupt the forward offset. */
+  scrubStageDirections() {
+    if (this.reflexForwarded >= this.reflexBuf.length) return;
+    const region = this.reflexBuf.slice(this.reflexForwarded);
+    const scrubbed = region.replace(/\([^()]*\)/g, (s) => STAGE_DIRECTION_RE.test(s) ? "" : s);
+    if (scrubbed !== region) this.reflexBuf = this.reflexBuf.slice(0, this.reflexForwarded) + scrubbed;
+  }
+  /** Clear the per-turn guards. Called at the head of every voice turn (user send + re-voice flush). */
+  resetTurn() {
+    this.turnDispatched = false;
+    this.spokeBeforeDispatch = false;
+    this.turnBriefs.clear();
+    this.spokeThisTurn = false;
+    this.externalSpeech = false;
+    this.heldThisTurn = false;
+    this.reflexBuf = "";
+    this.reflexForwarded = 0;
+    this.fabricationCut = false;
+    this.turnFollowUp = false;
+    this.voice.options.toolChoice = void 0;
+  }
+  /** preToolUse guard on the reflex: once it has dispatched this turn, a dispatch is "said my piece,
+   *  now wait for the push" (CC's Task model). Block the temptations — TaskStatus polling and identical
+   *  re-dispatch — so the only remaining move is to voice a short ack and end. A genuinely NEW Act is
+   *  still allowed (parallel independent work). During a re-ack pass, block every tool. */
+  dispatchGuard() {
+    return {
+      preToolUse: (call) => {
+        if (this.spec?.state === "pending" && !_DuplexAgent.SPEC_SAFE_TOOLS.has(call.name)) {
+          log11.verbose(`speculation aborted: reflex called ${call.name} on unconfirmed input`);
+          this.abortSpeculation();
+          return { block: true, reason: "Speculative turn aborted." };
+        }
+        if (this.nudging) return { block: true, reason: "Just say one short spoken acknowledgement \u2014 no tools this turn." };
+        if (!this.turnDispatched) return;
+        if (call.name === "TaskStatus")
+          return { block: true, reason: "You just dispatched a task this turn \u2014 do NOT poll. Give one short spoken acknowledgement and end your turn; the result arrives later as a [task \u2026] event." };
+        if ((call.name === "Act" || call.name === "Think") && this.turnBriefs.has(String(call.args?.brief ?? "")))
+          return { block: true, reason: "You already dispatched this exact task \u2014 acknowledge briefly and end your turn." };
+      }
     };
-    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");
-    log11.debug(`voice I/O up (${this.stt.usingAec ? "AEC" : "heuristic echo"} capture)`);
   }
-  get usingAec() {
-    return this.stt.usingAec;
+  /** The host spoke on this turn's behalf OUTSIDE the reflex stream (e.g. the voice engine's adaptive
+   *  micro-ack). For a DISPATCHED turn that's a sufficient ack (don't stack a second one); for an
+   *  inline turn whose reply came back empty it is NOT — "One sec." followed by permanent silence is
+   *  still dead air, so silentTurn ignores external speech unless work was dispatched. */
+  noteExternalSpeech() {
+    this.externalSpeech = true;
   }
-  /** Flip barge-in at runtime (e.g. the mic fell back to non-VPIO → go half-duplex so echo can't leak). */
-  setBargeIn(on) {
-    this.options.bargeIn = on;
+  /** True when the just-finished turn voiced NOTHING — dead air to repair. Two ways this happens:
+   *  (a) a dispatch with no spoken ack, and (b) an INLINE turn whose `final` channel came back empty —
+   *  gpt-oss harmony sometimes puts the whole reply in `analysis` (→ thinking_delta, suppressed in
+   *  voice) and emits an empty `final`, so no text_delta ever streams. Both ship silence; both repair.
+   *  Requires a host: without one there's no stream to detect speech on (and no one to speak to). */
+  get silentTurn() {
+    const ackedByHost = this.externalSpeech && this.turnDispatched;
+    return !!this.options.host && !this.spokeThisTurn && !ackedByHost && !this.heldThisTurn;
   }
-  /** Show/hide the `[emotion]` debug tags in the echo (next turn's stream picks it up). */
-  setShowEmotions(on) {
-    this.options.showEmotions = on;
+  /** A turn that voiced nothing is dead air. Re-prompt the reflex ONCE so the LLM itself voices a short
+   *  line (no template). If it STILL says nothing, fall back to a minimal line so silence never ships.
+   *  Wording adapts to whether work was dispatched (an ack) or the inline reply was simply lost. */
+  async ackIfSilent(fallback) {
+    const dispatched = this.turnDispatched;
+    this.nudging = true;
+    try {
+      await this.voice.send(fallback ? "[reminder] You said nothing to the user this turn. Tell them, in ONE short spoken sentence, what just happened \u2014 no tools." : dispatched ? "[reminder] You dispatched a task but said nothing to the user. Say ONE short spoken acknowledgement now \u2014 no tools." : "[reminder] You said nothing to the user this turn. Give your ONE short spoken reply now \u2014 no tools.");
+    } catch (e) {
+      log11.warn(`ack nudge failed: ${e instanceof Error ? e.message : e}`);
+    } finally {
+      this.nudging = false;
+    }
+    if (!this.spokeThisTurn) {
+      const pool = fallback ? [fallback] : dispatched ? _DuplexAgent.FALLBACK_ACKS : _DuplexAgent.FALLBACK_RETRY;
+      const fresh = pool.filter((p) => p !== this.lastFallback);
+      const line = (fresh.length ? fresh : pool)[Math.floor(Math.random() * (fresh.length || pool.length))];
+      this.lastFallback = line;
+      this.emitHost({ kind: "text_delta", message: line });
+    }
   }
-  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();
+  /** Dead-air fallback pools (see ackIfSilent). Both retry lines keep the 'say that again' phrase —
+   *  hosts/tests key on it. */
+  static FALLBACK_ACKS = ["Okay, on it.", "On it.", "Alright, working on it."];
+  static FALLBACK_RETRY = ["Sorry, could you say that again?", "Hm, I missed that \u2014 could you say that again?"];
+  lastFallback = "";
+  /** One user turn: the voice agent streams the reply (and may Act/Think). Serialized with re-voice turns.
+   *  If a speculative reflex call is pending and this content CONFIRMS it (the final matches the
+   *  speculated partial), the in-flight call is adopted as THE turn: its buffered output flushes to the
+   *  host NOW (this is the latency win) and streaming continues live. Any other content aborts the
+   *  speculation first (rolled back silently) and runs a normal turn behind it. */
+  send(content) {
+    const spec = this.spec;
+    if (spec?.state === "pending") {
+      if (typeof content === "string" && speculationConfirms(spec.text, content)) {
+        spec.state = "confirmed";
+        spec.finalText = content;
+        for (const ev of spec.buf.splice(0)) this.options.host?.notify?.(ev);
+        spec.decide("confirm");
+        this.notify("diag", "speculation_confirmed", { text: spec.text.slice(0, 80) });
+        return spec.done;
+      }
+      this.abortSpeculation();
     }
+    return this.enqueue(async () => {
+      await this.initMemory();
+      this.resetTurn();
+      const res = await this.voice.send(content);
+      this.flushHeldReflexTail();
+      if (this.silentTurn) await this.ackIfSilent();
+      return res;
+    });
   }
-  /** 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));
+  /** Start a HELD speculative reflex turn on a stable partial (VoiceEngine.onSpeculate). Its spoken
+   *  output buffers in emitHost; send() later confirms (flush + adopt) or aborts it. The turn holds the
+   *  voice mutex until that decision (bounded by a safety timeout), so no other turn can interleave
+   *  into the transcript between the speculative messages and their rollback. No-op if a speculation
+   *  is already in flight. */
+  speculate(text) {
+    if (!text.trim() || this.spec) return;
+    let decide;
+    const decision = new Promise((r) => {
+      decide = r;
+    });
+    const spec = {
+      text,
+      state: "pending",
+      buf: [],
+      ctl: new AbortController(),
+      decide,
+      decision,
+      done: void 0
+    };
+    this.spec = spec;
+    spec.done = this.enqueue(async () => {
+      const empty = { text: "", steps: 0, finishReason: "aborted", messages: this.voice.transcript };
+      if (spec.state === "aborted") {
+        this.speculativeAbortedCalls++;
+        if (this.spec === spec) this.spec = void 0;
+        return empty;
+      }
+      await this.initMemory();
+      this.resetTurn();
+      const base = this.voice.transcript.length;
+      const prevSignal = this.voice.options.signal;
+      this.voice.options.signal = spec.ctl.signal;
+      let res;
+      try {
+        res = await this.voice.send(spec.text);
+      } catch (e) {
+        log11.warn(`speculative turn failed: ${e instanceof Error ? e.message : e}`);
+      } finally {
+        this.voice.options.signal = prevSignal;
+      }
+      const timer = setTimeout(() => {
+        spec.state = spec.state === "pending" ? "aborted" : spec.state;
+        spec.decide("abort");
+      }, 1e4);
+      timer.unref?.();
+      const d = await spec.decision;
+      clearTimeout(timer);
+      if (d === "abort") {
+        if (this.voice.transcript.length > base) this.voice.transcript.length = base;
+        this.speculativeAbortedCalls++;
+        log11.verbose(`speculation aborted (${this.speculativeAbortedCalls} total): "${spec.text.slice(0, 50)}"`);
+        if (this.spec === spec) this.spec = void 0;
+        return res ?? empty;
+      }
+      for (let i = base; i < this.voice.transcript.length; i++) {
+        const m = this.voice.transcript[i];
+        if (m.role === "user" && contentText(m.content) === spec.text) {
+          m.content = spec.finalText;
+          break;
+        }
+      }
+      this.spec = void 0;
+      this.flushHeldReflexTail();
+      if (this.silentTurn) await this.ackIfSilent();
+      return res ?? empty;
+    });
   }
-  // --- 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;
-    this.resetOverlap(true);
-    if (!this.speaking) this.player.markTurn();
-    this.speaking = true;
-    this.ctxOpen = true;
-    this.spokeDeltas = false;
-    this.reply = "";
-    this.emo = this.options.emotions ? new EmotionStream(this.options.showEmotions) : null;
-    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();
-    }
-    if (!this.turnStartAt) this.turnStartAt = now();
-    this.setState("thinking");
+  /** Abort a pending speculation (idempotent): kill the in-flight call, drop its buffered output.
+   *  Called on divergence (send), a stale partial (VoiceEngine.onSpeculateAbort), a side-effect tool
+   *  attempt (dispatchGuard), or host paths that will never dispatch a final (commands, voice-off). */
+  abortSpeculation() {
+    const spec = this.spec;
+    if (spec?.state !== "pending") return;
+    spec.state = "aborted";
+    spec.buf.length = 0;
+    spec.ctl.abort();
+    spec.decide("abort");
+    this.notify("diag", "speculation_aborted", { text: spec.text.slice(0, 80) });
   }
-  /** Feed a spoken delta. Returns the on-screen echo text (emotion tags shown/hidden per config) so the
-   *  host renders the SAME stream that was parsed for TTS — no second, state-doubling parse. */
-  speakDelta(text) {
-    if (this.interrupted) return "";
-    if (!this.speaking || !this.ctxOpen) this.beginSpeech();
-    const { speech, display, prose } = this.emo ? this.emo.feed(text) : { speech: text, display: text, prose: text };
-    this.reply += prose;
-    for (const w of this.words(this.reply)) this.echoWords.add(w);
-    this.tts.speak(forSpeech(speech), true);
-    if (!this.spokeDeltas && this.turnStartAt) log11.debug(`ttft: ${Math.round(now() - this.turnStartAt)}ms`);
-    this.spokeDeltas = true;
-    this.setState("speaking");
-    return display;
+  /** Cancel a running background task — shared by the CancelTask tool and the CLI /tasks picker. */
+  cancelTask(id) {
+    const rec = this.tasks.get(id);
+    if (!rec) return `No task '${id}'.`;
+    if (rec.status !== "running") return `Task ${rec.id} is already ${rec.status}.`;
+    rec.status = "cancelled";
+    rec.controller.abort();
+    return `Task ${rec.id} (${rec.label}) cancelled.`;
   }
-  /** 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.emo) {
-      const t = this.emo.flush();
-      this.emo = null;
-      if (t.prose) this.reply += t.prose;
-      if (t.speech) this.tts.speak(forSpeech(t.speech), true);
+  /** Barge-in: the user took the floor while task(s) were running. Suppress those tasks' remaining SPOKEN
+   *  delivery so a superseded topic never talks over the new one (the debt-after-jokes regression). The
+   *  tasks keep running and still fold their result into the transcript — recoverable, just not spoken.
+   *  Returns the parked ids (for logging). Does NOT cancel: that's a deliberate reflex/user action. */
+  parkInFlightDeliveries() {
+    const parked = [];
+    for (const rec of this.tasks.values())
+      if (rec.status === "running" && !rec.deliveryParked) {
+        rec.deliveryParked = true;
+        parked.push(rec.id);
+      }
+    return parked;
+  }
+  /** Resolve when all queued voice turns AND all in-flight worker tasks have settled (tests, graceful shutdown). */
+  async idle() {
+    while (true) {
+      const q = this.queue;
+      await q.catch(() => {
+      });
+      await Promise.all([...this.tasks.values()].map((t) => t.promise));
+      if (this.queue === q && ![...this.tasks.values()].some((t) => t.status === "running")) return;
     }
-    if (this.reply) this.prevReply = this.reply;
-    const settle = () => {
-      if (this.ctxOpen) {
-        this.drainTimer = null;
+  }
+  /** Promise-chain mutex: turns run strictly one at a time; a failed turn doesn't poison the chain. */
+  enqueue(fn) {
+    const run = this.queue.then(fn, fn);
+    this.queue = run.then(() => {
+    }, () => {
+    });
+    return run;
+  }
+  notify(kind, message, data) {
+    this.emitHost({ kind, message, data });
+  }
+  /** Host-boundary emit for the reflex's spoken channel: during a PENDING speculation, text_delta and
+   *  hold_filler are BUFFERED (nothing may reach TTS on unconfirmed input); confirm flushes them in
+   *  order, abort drops them silently. Everything else (task_* lifecycle, worker speak_utterance —
+   *  which bypasses this via host.notify directly) passes through untouched. */
+  emitHost(ev) {
+    const spec = this.spec;
+    if (spec && (ev.kind === "text_delta" || ev.kind === "hold_filler")) {
+      if (spec.state === "pending") {
+        spec.buf.push(ev);
         return;
       }
-      if (this.pausedAt) {
-        this.drainTimer = setTimeout(settle, 250);
-        return;
+      if (spec.state === "aborted") return;
+    }
+    this.options.host?.notify?.(ev);
+  }
+  /** Queue a `[task …]` event for re-voicing. Events arriving while the voice is busy coalesce into ONE turn.
+   *  `nonClean` (out-of-band boolean, set by the caller that KNOWS this event integrates a NON-CLEAN outcome)
+   *  marks the coalesced flush as a non-clean integration turn — turn-eligibility, never inferred from event
+   *  text and never keyed on a (re-authored) brief string. Any dispatch in such a turn is a follow-up. */
+  queueRevoice(event, nonClean = false) {
+    this.pendingEvents.push(event);
+    if (nonClean) this.pendingNonClean = true;
+    if (this.flushQueued) return;
+    this.flushQueued = true;
+    void this.enqueue(async () => {
+      this.flushQueued = false;
+      const events = this.pendingEvents.splice(0);
+      const nonCleanTurn = this.pendingNonClean;
+      this.pendingNonClean = false;
+      if (!events.length) return;
+      const failed = events.find((e) => /^\[task\b[^\]\n]*\bfailed\b/i.test(e));
+      this.resetTurn();
+      this.turnFollowUp = nonCleanTurn;
+      await this.voice.send(events.join("\n"));
+      this.flushHeldReflexTail();
+      if (this.silentTurn) await this.ackIfSilent(failed ? "Sorry, that didn't work \u2014 the task failed." : void 0);
+      this.notify("revoice_done", "");
+    });
+  }
+  /** The worker's brief: the Act/Think args + a STATIC text snapshot of the recent conversation.
+   *  Act briefs get a self-verify footer — the worker's report is trusted without review, so it
+   *  must check its own work before reporting (nearly free under prompt caching; measured honest:
+   *  it does NOT fix one-shot logic bugs — see mind/10). Think tasks are pure reasoning — no footer. */
+  buildBrief(brief, tier = "act", deliver = true) {
+    const recent = this.voice.transcript.filter((m) => (m.role === "user" || m.role === "assistant") && contentText(m.content).trim()).slice(-this.options.excerptTurns).map((m) => `${m.role}: ${contentText(m.content)}`).join("\n");
+    const verify = tier === "act" ? "\n\nBefore reporting done: re-read what you changed and check it against EVERY requirement above \u2014 fix any gap first. Your report is trusted without review." : "";
+    const deliverContract = deliver ? `
+
+## DELIVER (spoken delivery)
+You are reporting back to a user who is LISTENING. Stream your work normally \u2014 your prose is the written work record and detail, and is NOT spoken. Wrap anything the user should HEAR in <spoken>\u2026</spoken> tags. LEAD WITH the actual content they asked for: if they asked for a specific piece of content \u2014 a value, a name, the actual lines, the writing itself \u2014 that content goes INSIDE the <spoken> tags, not a remark about it. Your FIRST <spoken> segment is substantive \u2014 never a greeting or an acknowledgement (the front-end has already acked; do not double-ack). Keep spoken text concise and natural for the ear: short sentences, no markdown. NEVER enumerate in speech \u2014 no numbered or bulleted lists ("One. \u2026 Two. \u2026" is robotic). Deliver multiple items as flowing conversation with brief connective phrasing ("here's one\u2026", "and another\u2026", "oh, and\u2026"), pausing between items with sentence breaks, not numbers.` + (this.options.emotionTags ? " Inside <spoken>, you may prefix a sentence with an inline [emotion] tag (e.g. [excited], [curious]) to color how it is voiced \u2014 only when it genuinely fits, and vary it; [laughter] gives a natural laugh." : "") : "";
+    return (recent ? `${brief}
+
+## Recent conversation (for context)
+${recent}` : brief) + verify + deliverContract;
+  }
+  /** Spawn a detached worker for task `id`; its settlement notifies + enqueues the re-voice turn. */
+  spawnWorker(id, label, briefText, tier, brief, followUp) {
+    const o = this.options;
+    const tierOpts = tier === "think" ? o.thinkOptions : o.actOptions;
+    const tierModel = tier === "think" ? o.thinkModel : o.actModel;
+    const controller = new AbortController();
+    const base = tierOpts?.hooks ?? o.actOptions?.hooks;
+    const report = o.progressUpdates ? this.progressReporter(id) : void 0;
+    const tail = [];
+    const pushTail = (line) => {
+      tail.push(line.slice(0, 200));
+      if (tail.length > 120) tail.splice(0, tail.length - 120);
+    };
+    const hooks = {
+      ...base,
+      preToolUse: async (call, meta) => {
+        const d = await base?.preToolUse?.(call, meta);
+        pushTail(`\u2699 ${describeCall(call)}`);
+        report?.pre(call);
+        return d;
+      },
+      postToolUse: async (call, result, meta) => {
+        await base?.postToolUse?.(call, result, meta);
+        const last = result?.trim().split("\n").filter(Boolean).pop();
+        if (last) pushTail(`  \u21B3 ${last}`);
+        report?.post(call);
+      },
+      onToolOutput: (call, chunk, meta) => {
+        base?.onToolOutput?.(call, chunk, meta);
+        report?.output(chunk);
+      }
+    };
+    const relayAsk = async (q) => {
+      const opts = q.options?.length ? ` Options: ${q.options.map((x) => x.label).join(", ")}.` : "";
+      const a = await this.parkQuestion(id, `${q.question}${opts}`);
+      return a || "(no answer from the user \u2014 use your best judgment and note the assumption)";
+    };
+    const splitter = new SpokenSplitter();
+    const speak = (seg) => {
+      if (seg && !this.tasks.get(id)?.deliveryParked) o.host?.notify?.({ kind: "speak_utterance", message: seg });
+    };
+    const coalescer = new SentenceCoalescer();
+    const feedSpoken = (s) => {
+      const ready = coalescer.feed(s);
+      if (ready) speak(ready);
+    };
+    const flushSpoken = () => speak(coalescer.flush());
+    const askBridge = o.askRelay ? { ask: relayAsk } : o.host?.ask ? { ask: (q) => o.host.ask(q) } : {};
+    const workerHost = {
+      ...askBridge,
+      notify: (ev) => {
+        if (ev?.kind === "text_delta" && typeof ev.message === "string") {
+          const { spoken, detail } = splitter.feed(ev.message);
+          feedSpoken(spoken);
+          if (detail.trim()) pushTail(detail.trim());
+          return;
+        }
+      }
+    };
+    const agentOpts = {
+      ai: o.ai,
+      fs: o.fs,
+      model: tierModel,
+      ...tier === "think" ? { reasoning: tierOpts?.reasoning ?? "high" } : {},
+      ...tierOpts,
+      // Recompute providerOptions for THIS worker's model (after tierOpts so it wins over any inherited
+      // main-template value) — prevents cursor-only cwd/cursorSession leaking onto an anthropic worker.
+      providerOptions: o.providerOptionsFor?.(tierModel),
+      stream: true,
+      // worker streams text_delta so the splitter can extract <spoken> live (after tierOpts: never overridden off)
+      host: workerHost,
+      // carries BOTH ask AND the <spoken>-splitting notify
+      ...hooks ? { hooks } : {},
+      signal: controller.signal
+      // shared with the checker so a cancel tears down both
+    };
+    const promise = new Agent(agentOpts).run(briefText).then((res) => {
+      const { spoken, detail } = splitter.flush();
+      feedSpoken(spoken);
+      if (detail.trim()) pushTail(detail.trim());
+      flushSpoken();
+      return res;
+    }).then((res) => this.maybeVerify(id, brief, res, tier, agentOpts, askBridge)).then((res) => this.onWorkerSettled(id, res)).catch((err) => this.onWorkerFailed(id, err));
+    this.tasks.set(id, { id, label, status: "running", controller, promise, tail, brief, followUp, splitter });
+    if (this.tasks.size > this.options.maxTaskRecords)
+      for (const [tid, rec] of this.tasks) {
+        if (this.tasks.size <= this.options.maxTaskRecords) break;
+        if (rec.status !== "running") this.tasks.delete(tid);
       }
-      this.drainTimer = null;
-      this.speaking = false;
-      if (this.turnStartAt) log11.debug(`turn: ${Math.round(now() - this.turnStartAt)}ms (incl. playback)`);
-      this.echoUntil = now() + 2500;
-      if (!this.usingAec) this.stt.reset();
-      this.setState("listening");
-      if (this.uttQueue.length) this.pumpQueue();
+  }
+  /** Fresh-context check of a successful Act task: a NEW agent (same model/fs/tools, but NO shared
+   *  conversation context) re-reads the file state against the brief and fixes any gap. The fix lands
+   *  on the shared fs automatically (workers write fs directly, no overlay), so grading sees the
+   *  corrected state. Bounded to ONE pass. Off unless `verifyActTasks`; never runs for think/failed/
+   *  cancelled tasks. Usage is merged so /cost reflects the real (worker + checker) spend. */
+  async maybeVerify(id, brief, res, tier, agentOpts, askBridge) {
+    if (!this.options.verifyActTasks || tier !== "act" || res.finishReason !== "stop") return res;
+    if (this.tasks.get(id)?.status === "cancelled") return res;
+    const { stream: _stream, host: _host, ...restOpts } = agentOpts;
+    const checkerOpts = {
+      ...restOpts,
+      ...askBridge.ask ? { host: { ask: askBridge.ask } } : {}
     };
-    const drainThenSettle = () => {
-      if (this.drainTimer) clearTimeout(this.drainTimer);
-      this.drainTimer = setTimeout(settle, this.player.drainMs() + 300);
+    const checkBrief = `${this.buildBrief(brief, tier, false)}
+
+## VERIFY MODE
+Another agent just implemented the above. Independently check the CURRENT state of the files against EVERY requirement. Fix any gap you find. If everything is already correct, make NO changes \u2014 do not refactor or improve \u2014 and report "verified".`;
+    this.notify("task_verify", `task ${id}: verifying`, { id });
+    const cres = await new Agent(checkerOpts).run(checkBrief);
+    if (cres.finishReason !== "stop") {
+      log11.warn(`task ${id}: verify inconclusive (${cres.finishReason})`);
+      this.notify("task_verify", `task ${id}: verify inconclusive (${cres.finishReason})`, { id, finishReason: cres.finishReason });
+    }
+    const sum = (a = 0, b = 0) => a + b;
+    return {
+      ...res,
+      steps: res.steps + cres.steps,
+      // Merge the checker's messages so downstream tool-call/step accounting includes BOTH agents
+      // (else a verified task's toolCalls would undercount vs its steps/usage).
+      messages: [...res.messages, ...cres.messages],
+      usageEstimated: res.usageEstimated || cres.usageEstimated,
+      usage: res.usage && cres.usage ? {
+        promptTokens: sum(res.usage.promptTokens, cres.usage.promptTokens),
+        completionTokens: sum(res.usage.completionTokens, cres.usage.completionTokens),
+        totalTokens: sum(res.usage.totalTokens, cres.usage.totalTokens),
+        cacheCreationTokens: sum(res.usage.cacheCreationTokens, cres.usage.cacheCreationTokens),
+        cacheReadTokens: sum(res.usage.cacheReadTokens, cres.usage.cacheReadTokens)
+      } : res.usage ?? cres.usage
     };
-    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;
+  /** 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 = () => {
+      if (this.pendingAsks.size) return void 0;
+      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;
+      const last = inflight.tail.trim().split("\n").filter(Boolean).pop()?.slice(-80);
+      emit(rec, `still inside ${describeCall(inflight.call)} \u2014 ${Math.round((Date.now() - inflight.at) / 1e3)}s on this step${last ? `, last output: ${last}` : ""}`, inflight.call);
+    }, Math.max(this.options.progressIntervalMs, 250));
+    timer.unref?.();
+    return {
+      pre: (call) => {
+        inflight = { call, at: Date.now(), tail: "" };
+      },
+      output: (chunk) => {
+        if (inflight) inflight.tail = (inflight.tail + chunk).slice(-500);
+      },
+      // digest only — NEVER re-voices directly
+      post: (call) => {
+        steps++;
+        inflight = null;
+        const rec = due();
+        if (rec) emit(rec, `still running \u2014 ${steps} steps so far, now: ${describeCall(call)}`, call);
+      }
+    };
   }
-  /** Speak a short filler phrase without starting a model turn (stays in listening mode after). */
-  speakFiller(text) {
-    if (!text || this.speaking) return;
-    this.beginSpeech();
-    this.speakDelta(text);
-    this.endSpeech();
+  /** 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((resolve) => {
+      let settled = false;
+      const finish = (answer) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        this.pendingAsks.delete(askId);
+        resolve(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.)`);
+    });
   }
-  /** Enqueue a COMPLETE worker utterance (already-split spoken text) onto the central speech queue.
-   *  If nothing is currently speaking it plays immediately; otherwise it queues and plays after the
-   *  current utterance fully ends (settle → pumpQueue) — never spliced into an open reflex utterance. */
-  enqueueUtterance(text) {
-    if (!text || !/[\p{L}\p{N}]/u.test(text)) return;
-    this.uttQueue.push(text);
-    if (!this.speaking) this.pumpQueue();
+  /** Resolve any question a settling/cancelled task left parked (its answer can no longer matter). */
+  dropAsk(id) {
+    this.pendingAsks.get(id)?.resolve("");
   }
-  /** Play the next queued worker utterance as its own one-shot turn (begin → delta → end). Drives the
-   *  next one from the settle completion (endSpeech), so utterances serialize without overlap. */
-  pumpQueue() {
-    if (this.speaking) return;
-    const text = this.uttQueue.shift();
-    if (text == null) return;
-    this.beginSpeech();
-    this.speakDelta(text);
-    this.endSpeech();
+  /** Build the INTEGRATION TURN prompt for a NON-CLEAN settled worker (early stop / failure). A clean
+   *  success never reaches here — it streams its own `<spoken>` delivery during the run. For a partial
+   *  or failed result the outcome re-enters the reflex as a decision (like a tool_result flowing back
+   *  into a normal agent loop): the reflex evaluates the outcome against the original intent and chooses
+   *  what to do next.
+   *
+   *  Decision branches (the reflex acts on them with EXISTING tools — no new surface):
+   *    • accept     → SPEAK the (partial) result plainly — don't dress a failure up as success.
+   *    • escalate   → call `Think` with the SAME brief — only when Act failed/stalled AND a Think tier
+   *                   exists AND this task wasn't already a follow-up (one hop max). Wires the dead
+   *                   "Reserve Think for a problem Act already FAILED at" promise.
+   *    • re-delegate→ call `Act` with a CORRECTED brief — for a recoverable error / partial result.
+   *    • ask        → ask the user ONE concrete question if genuinely blocked.
+   *
+   *  Keeps the `[task <id> completed]` / `[task <id> failed]` opener so existing coalescing + the
+   *  failed-revoice fallback still fire, and the per-event transcript markers stay intact. */
+  integrationPrompt(rec, outcome, body, finishReason) {
+    const opener = outcome === "error" ? `[task ${rec.id} failed]` : `[task ${rec.id} completed]`;
+    const underCap = this.autoEscalations < _DuplexAgent.MAX_AUTO_ESCALATIONS;
+    const canEscalate = (outcome === "error" || outcome === "incomplete") && underCap;
+    const hasThink = this.options.thinkModel !== false;
+    const options = [];
+    if (!rec.followUp && canEscalate && hasThink)
+      options.push("ESCALATE to the Think tier (call Think with the same brief) if this is a hard/architectural problem the Act worker stalled or failed on");
+    if (!rec.followUp && canEscalate)
+      options.push("RE-DELEGATE to Act with a corrected brief if the failure looks recoverable (a wrong path, a fixable mistake)");
+    options.push("ASK the user one short, concrete question if you genuinely cannot proceed without their input");
+    options.push("ACCEPT and tell the user plainly what happened (don't dress a failure up as success)");
+    const decision = options.length > 1 ? ` You must decide what to do next \u2014 choose ONE: ${options.map((o, i) => `(${i + 1}) ${o}`).join("; ")}. Pick exactly one and act on it; do not voice this as a finished success.` : ` Tell the user plainly what happened \u2014 do not present this as a finished success.`;
+    const state = outcome === "error" ? `the worker FAILED with: ${body}` : `the worker STOPPED EARLY (${finishReason}) \u2014 its result is PARTIAL, not a finished success: ${body}`;
+    return `${opener} Original request: "${rec.brief}". Outcome: ${state}.${decision}`;
   }
-  /** barge-in: stop audio NOW, cancel generation, reset for the user's utterance */
-  interrupt() {
-    this.uttQueue = [];
-    if (!this.speaking && !this.drainTimer) return;
-    if (this.drainTimer) {
-      clearTimeout(this.drainTimer);
-      this.drainTimer = null;
+  onWorkerSettled(id, res) {
+    this.dropAsk(id);
+    const rec = this.tasks.get(id);
+    if (res.finishReason === "aborted" || rec.status === "cancelled") {
+      rec.status = "cancelled";
+      this.notify("task_cancelled", `task ${id} (${rec.label}) cancelled`);
+      return;
     }
-    this.resetOverlap(false);
-    this.lastResumeAt = 0;
-    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() + Math.max(2500, this.player.drainMs() + 3e3);
-    this.tts.cancel();
-    this.player.kill();
-    if (!this.usingAec) this.stt.reset();
-    if (this.reply) this.prevReply = this.reply;
-    this.setState("listening");
+    if (res.finishReason === "error") {
+      const msg = res.error instanceof Error ? res.error.message : String(res.error ?? "unknown error");
+      return this.failTask(rec, msg);
+    }
+    rec.status = "done";
+    rec.result = res.text;
+    const incomplete = res.finishReason !== "stop";
+    log11.verbose(`task ${id} done (${res.steps} steps${incomplete ? `, INCOMPLETE: ${res.finishReason}` : ""})`);
+    this.notify("task_done", `task ${id} (${rec.label}) completed`, {
+      id,
+      text: res.text,
+      usage: res.usage,
+      usageEstimated: res.usageEstimated,
+      finishReason: res.finishReason,
+      steps: res.steps,
+      toolCalls: res.messages.filter((m) => m.role === "tool").length
+    });
+    if (incomplete) {
+      return this.queueRevoice(this.integrationPrompt(rec, "incomplete", res.text, res.finishReason), true);
+    }
+    const tail = rec.splitter?.flush();
+    if (tail?.spoken && !rec.deliveryParked) this.options.host?.notify?.({ kind: "speak_utterance", message: tail.spoken });
+    if (res.text.trim()) this.voice.transcript.push({ role: "assistant", content: res.text });
+    if (!rec.splitter?.spokeAny && res.text.trim() && !rec.deliveryParked)
+      this.options.host?.notify?.({ kind: "speak_utterance", message: res.text });
   }
-  stop() {
-    this.uttQueue = [];
-    if (this.resumeTimer) clearTimeout(this.resumeTimer);
-    if (this.pendingTimer) clearTimeout(this.pendingTimer);
-    if (this.drainTimer) clearTimeout(this.drainTimer);
-    this.stt.stop();
-    this.player.kill();
-    this.tts.close();
-    this.setState("idle");
+  onWorkerFailed(id, err) {
+    this.failTask(this.tasks.get(id), err instanceof Error ? err.message : String(err));
   }
-  // --- listening side (STT-driven) ---
-  words(s) {
-    return s.toLowerCase().replace(/[^a-z0-9\s]/g, "").split(/\s+/).filter((w) => w.length >= 2);
+  failTask(rec, msg) {
+    this.dropAsk(rec.id);
+    rec.status = "error";
+    rec.result = msg;
+    log11.warn(`task ${rec.id} failed: ${msg}`);
+    this.notify("task_error", `task ${rec.id} (${rec.label}) failed: ${msg}`);
+    this.queueRevoice(this.integrationPrompt(rec, "error", msg, "error"), true);
   }
-  novelWords(text) {
-    return this.words(text).filter((w) => !this.echoWords.has(w));
+  // --- voice tools (closures over this instance) ---
+  /** Live-switch the think tier: `false` disables (removes the Think tool from the voice agent),
+   *  a model id enables (adds the tool if missing). The system-prompt THINK_SLOT text is frozen at
+   *  construction — the tool's own description carries the routing guidance, so a live enable works;
+   *  dispatch()'s think→act fallback covers any straggler calls after a live disable. */
+  setThinkModel(model) {
+    this.options.thinkModel = model;
+    const tools = this.voice.options.tools;
+    const i = tools.findIndex((t) => t.name === "Think");
+    if (model === false && i >= 0) tools.splice(i, 1);
+    else if (model !== false && i < 0) tools.push(this.thinkTool());
   }
-  echoActive() {
-    return this.speaking || now() < this.echoUntil;
+  /** User/programmatic spawn: the CLI's /act and /think commands. Returns the task id.
+   *  `followUp` marks an automatic escalation/re-delegation (set by the integration turn) so the new
+   *  task's own integration turn won't escalate again — capping auto-follow-ups to one hop. */
+  async dispatch(brief, tier = "act", label, followUp = false) {
+    if (tier === "think" && this.options.thinkModel === false) tier = "act";
+    if (followUp) this.autoEscalations++;
+    const id = `t${++this.seq}`;
+    const lbl = label ?? tier;
+    await this.options.onTaskStart?.(id, lbl);
+    this.spawnWorker(id, lbl, this.buildBrief(brief, tier), tier, brief, followUp);
+    this.notify("task_started", `task ${id} (${lbl}) started`, { id, brief, tier });
+    return id;
   }
-  /** Genuine user speech vs our own bleed (AEC tier): novel words must DOMINATE, not merely exist.
-   *  Degraded AEC + an STT mis-hearing manufactures a single novel word out of pure echo (a name or
-   *  rare word in our own reply comes back transcribed slightly differently — 1 novel / N words).
-   *  A real interjection is mostly novel ("stop", "wait what") — short utterances pass on ratio,
-   *  longer ones on count. */
-  genuine(text) {
-    const total = this.words(text).length;
-    const novel = this.novelWords(text).length;
-    return novel > 0 && novel / Math.max(1, total) > 0.5;
+  actTool() {
+    return {
+      name: "Act",
+      description: 'Escalate real work (reading/editing files, searching, running tasks, building) to a standard background worker. Returns immediately with a task id; the result arrives later as a "[task <id> completed]" event. Provide a clear, self-contained `brief` (the worker does not hear the live conversation).',
+      parameters: {
+        type: "object",
+        required: ["brief"],
+        properties: {
+          brief: { type: "string", description: "full, self-contained instructions for the worker" },
+          label: { type: "string", description: "a short (2-4 word) label for the task" }
+        }
+      },
+      run: async ({ brief, label }) => {
+        this.spokeBeforeDispatch = this.spokeThisTurn;
+        this.turnDispatched = true;
+        this.turnBriefs.add(String(brief ?? ""));
+        this.voice.options.toolChoice = "none";
+        const id = await this.dispatch(String(brief ?? ""), "act", label ? String(label) : void 0, this.turnFollowUp);
+        return this.spokeBeforeDispatch ? `Acting on task ${id}. You already acknowledged \u2014 end your turn now with NO further text; the result will arrive as a [task ${id} completed] event.` : `Acting on task ${id}. Acknowledge briefly; the result will arrive as a [task ${id} completed] event.`;
+      }
+    };
   }
-  handlePartial(text) {
-    if (this.speaking) {
-      if (!this.options.bargeIn) return;
-      if (now() < this.bargeGraceUntil) {
-        if (!this.echoActive() || (this.usingAec ? this.genuine(text) : this.novelWords(text).length >= 1)) this.options.onPartial(text);
-        return;
+  thinkTool() {
+    return {
+      name: "Think",
+      description: "Escalate to a premium deep-reasoning agent for complex analysis, architecture decisions, hard debugging, or planning. Same async pattern as Act \u2014 returns a task id. Use when the problem needs careful thought before (or instead of) action. Do not use Think for simple tasks \u2014 Act is cheaper and faster.",
+      parameters: {
+        type: "object",
+        required: ["brief"],
+        properties: {
+          brief: { type: "string", description: "the question or problem to reason about deeply" },
+          label: { type: "string", description: "a short (2-4 word) label for the task" }
+        }
+      },
+      run: async ({ brief, label }) => {
+        this.spokeBeforeDispatch = this.spokeThisTurn;
+        this.turnDispatched = true;
+        this.turnBriefs.add(String(brief ?? ""));
+        this.voice.options.toolChoice = "none";
+        const id = await this.dispatch(String(brief ?? ""), "think", label ? String(label) : void 0, this.turnFollowUp);
+        return this.spokeBeforeDispatch ? `Thinking on task ${id}. You already acknowledged \u2014 end your turn now with NO further text; the result will arrive as a [task ${id} completed] event.` : `Thinking on task ${id}. Acknowledge briefly; the result will arrive as a [task ${id} completed] event.`;
       }
-      if (this.overlapCapable) {
-        const txt = text.trim();
-        if (!txt || txt === this.lastOverlapPartial) return;
-        this.lastOverlapPartial = txt;
-        if (!this.genuine(txt)) {
-          if (this.pausedAt) this.armResume();
-          return;
+    };
+  }
+  taskStatusTool() {
+    return {
+      name: "TaskStatus",
+      description: "Status of background tasks. Pass `id` for one task, or omit it to list all.",
+      parameters: { type: "object", properties: { id: { type: "string" } } },
+      run: async ({ id }) => {
+        const list = id ? [this.tasks.get(String(id))].filter(Boolean) : [...this.tasks.values()];
+        if (!list.length) return id ? `No task '${id}'.` : "No background tasks.";
+        return list.map((t) => `${t.id} (${t.label}): ${t.status}`).join("\n");
+      }
+    };
+  }
+  /** Sub-100ms read-only lookups the voice may do itself — everything else stays Act-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 CAP = 2e3;
+    const kinds = [.../* @__PURE__ */ new Set(["time", "branch", "ls", "file", "capabilities", ...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 Act.`,
+      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" }
         }
-        if (!this.pausedAt) {
-          this.pausedAt = now();
-          this.player.pause();
-          if (this.lastResumeAt && now() - this.lastResumeAt < this.options.overlapRepauseCedeMs) {
-            this.interrupt();
-            this.options.onBargeIn(this.ctxOpen ? "speaking" : "drain");
-            return;
+      },
+      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 "capabilities": {
+              const actTools = this.options.actOptions?.tools ?? [];
+              const names = actTools.map((t) => t.name);
+              const mcpServers = Object.keys(this.options.actOptions?.providerOptions?.mcpServers ?? {});
+              const mcpNote = mcpServers.length ? ` Plus MCP servers your worker can use: ${mcpServers.join(", ")} (e.g. browser-bridge \u2192 drive a real browser: open tabs, navigate, click, screenshot).` : "";
+              if (!names.length)
+                return "Your worker uses Act's default local toolset (reading/editing files, running shell commands). No extra tools (e.g. web/internet) are configured; if a request is not a basic file or shell operation, assume you can't do it and say so." + mcpNote;
+              const hasFetch = names.some((n) => /WebFetch/i.test(n));
+              const hasBrowser = names.some((n) => /browser.*(navigate|click|page|type)/i.test(n));
+              const hasSearch = names.some((n) => /(^|_)WebSearch$|search/i.test(n) && !/WebFetch|browser/i.test(n));
+              const notes = [];
+              if (hasFetch) notes.push("WebFetch retrieves ONE specific URL you are given \u2014 it is not a search engine.");
+              if (hasBrowser) notes.push("The browser tools drive a real browser: you CAN open a site and, if needed, navigate to a search engine and search there \u2014 but it is manual and takes a moment, not an instant lookup.");
+              else if (!hasSearch && hasFetch) notes.push('You have no general web-search tool, so for an instant "search the web" you can only fetch a URL they provide.');
+              const webNote = notes.length ? " NOTE: " + notes.join(" ") : "";
+              return `Tools your background worker (Act) can actually use: ${names.join(", ")}. Read each name literally and match the request to a SPECIFIC tool; if none fits, you do NOT have that ability \u2014 say so honestly.` + webNote + mcpNote;
+            }
+            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 p = String(path ?? ".");
+              try {
+                const names = await fs.readDir(p);
+                return names.slice(0, 50).join("\n") + (names.length > 50 ? `
+\u2026 (+${names.length - 50} more)` : "");
+              } catch {
+                const names = await fs.readDir(".").catch(() => []);
+                return `'${p}' not found here \u2014 you are likely already inside it. Current directory listing:
+` + 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";
+              try {
+                const text = await fs.readFile(String(path));
+                return text.length > CAP ? text.slice(0, CAP) + `
+\u2026 (truncated \u2014 ${text.length} chars total; Act for the full file)` : text;
+              } catch {
+                const names = await fs.readDir(".").catch(() => []);
+                return `'${path}' not found. Current directory contains:
+` + names.slice(0, 50).join("\n");
+              }
+            }
+            default:
+              return `unknown lookup '${what}'`;
           }
+        } catch (e) {
+          return `lookup failed: ${e?.message ?? e}`;
         }
-        if (this.words(txt).length >= 2) {
-          const phase = this.ctxOpen ? "speaking" : "drain";
-          this.interrupt();
-          this.options.onBargeIn(phase);
-          return;
-        }
-        this.armResume();
-        return;
       }
-      const barge = this.usingAec ? this.genuine(text) : this.novelWords(text).length >= (this.suspectUntil ? 1 : 2);
-      if (barge) {
-        const phase = this.ctxOpen ? "speaking" : "drain";
-        this.interrupt();
-        this.options.onBargeIn(phase);
+    };
+  }
+  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.`;
       }
-      return;
-    }
-    if (this.pendingUtt && text.trim()) {
-      if (this.pendingTimer) clearTimeout(this.pendingTimer);
-      this.pendingTimer = setTimeout(() => this.flushUtterance(), Math.max(800, this.options.utteranceMergeMs));
-    }
-    if (!this.echoActive() || (this.usingAec ? this.genuine(text) : this.novelWords(text).length >= 1)) this.options.onPartial(text);
+    };
   }
-  /** Merge a resumed utterance into the pending one, deduping any word-overlap. Soniox re-finalizes
-   *  overlapping audio when the silence-timer and the semantic `<end>` both endpoint a growing
-   *  utterance (or after a reconnect): the next "utterance" repeats the tail of the previous one, and
-   *  a naive `${prev} ${next}` produced the live duplication ("Um, I want to check if Um, I want to
-   *  check if…"). Find the longest suffix of `prev`'s words that prefixes `next` and drop it. */
-  mergeUtterance(prev, next) {
-    if (!prev) return next;
-    if (!next) return prev;
-    const pw = prev.split(/\s+/), nw = next.split(/\s+/);
-    const norm2 = (w) => w.toLowerCase().replace(/[^a-z0-9]/g, "");
-    const max = Math.min(pw.length, nw.length);
-    for (let k = max; k > 0; k--) {
-      let match = true;
-      for (let i = 0; i < k; i++) if (norm2(pw[pw.length - k + i]) !== norm2(nw[i])) {
-        match = false;
-        break;
+  holdTool() {
+    return {
+      name: "Hold",
+      description: 'The user seems mid-thought \u2014 hold the turn (stay listening) instead of answering. Optionally pass a short filler ("mhm", "go on") to speak while waiting. Use when the message sounds incomplete, trailing off, or like they paused to think.',
+      parameters: {
+        type: "object",
+        properties: {
+          filler: { type: "string", description: 'optional short filler to speak ("mhm", "go on", "mm-hm")' }
+        }
+      },
+      run: async ({ filler }) => {
+        this.heldThisTurn = true;
+        this.notify("hold_filler", filler ? String(filler) : "");
+        return "Holding \u2014 listening for the rest of the user's thought. Do not respond further this turn.";
+      }
+    };
+  }
+  cancelTaskTool() {
+    return {
+      name: "CancelTask",
+      description: "Cancel a running background task by id.",
+      parameters: { type: "object", required: ["id"], properties: { id: { type: "string" } } },
+      run: async ({ id }) => this.cancelTask(String(id))
+    };
+  }
+};
+
+// src/mcp.ts
+function toResult(result) {
+  if (result == null) return { text: "" };
+  if (typeof result === "string") return { text: result };
+  const content = result.content;
+  if (Array.isArray(content)) {
+    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));
       }
-      if (match) return [...pw, ...nw.slice(k)].join(" ");
     }
-    return `${prev} ${next}`;
-  }
-  static TRAIL_RE = /(?:^|\s)(?:and|but|or|so|to|the|a|an|of|in|for|with|that|if|uh|um|like|about|from|into|on|is|are|was|were|,)$/i;
-  /** The utterance sounds like the user paused mid-thought (trailing conjunction/filler/comma). */
-  looksIncomplete(text) {
-    return _VoiceEngine.TRAIL_RE.test(text.trim());
+    const text = texts.join("\n");
+    if (text || images.length) return { text, ...images.length ? { images } : {} };
   }
-  handleUtterance(text) {
-    if (this.speaking && (this.ctxOpen || this.pausedAt) && this.overlapCapable) {
-      this.stt.reset();
-      return;
-    }
-    if (this.echoActive() && (!this.options.bargeIn || (this.usingAec ? !this.genuine(text) : this.novelWords(text).length < 2))) {
-      this.stt.reset();
-      return;
+  return { text: JSON.stringify(result) };
+}
+function mcpToolToAgentTool(spec, callTool, prefix = "mcp__") {
+  return {
+    name: `${prefix}${spec.name}`,
+    description: spec.description ?? `MCP tool ${spec.name}`,
+    parameters: spec.inputSchema ?? { type: "object", properties: {} },
+    async run(args, _ctx) {
+      const r = toResult(await callTool(spec.name, args ?? {}));
+      return r.images?.length ? r : r.text;
     }
-    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;
+  };
+}
+function mcpToolsToAgentTools(specs, callTool, prefix = "mcp__", filter) {
+  return (filter ? specs.filter(filter) : specs).map((s) => mcpToolToAgentTool(s, callTool, prefix));
+}
+function describeSpec(s) {
+  const schema = s.inputSchema ? `
+   args: ${JSON.stringify(s.inputSchema)}` : "";
+  return `${s.name} \u2014 ${s.description ?? "(no description)"}${schema}`;
+}
+function makeMcpToolSearch(specs, callTool, options = {}) {
+  const maxResults = options.maxResults ?? 10;
+  const byName = new Map(specs.map((s) => [s.name, s]));
+  const catalogLine = `${specs.length} MCP tool(s) available \u2014 search by keyword, then call by exact name.`;
+  const searchTool = {
+    name: "ToolSearch",
+    description: `Search the available MCP tools by keyword (${catalogLine}). Returns matching tool names + their argument schemas; call one with \`McpCall\`.`,
+    parameters: { type: "object", required: ["query"], properties: { query: { type: "string", description: "keywords to match against tool name + description" } } },
+    async run({ query }) {
+      const q = String(query ?? "").trim();
+      if (!q) return catalogLine;
+      const { kept } = topByRelevance(specs, q, (s) => `${s.name} ${s.description ?? ""}`, maxResults);
+      if (!kept.length) return `(no MCP tool matches "${q}" \u2014 try broader keywords)`;
+      return kept.map(describeSpec).join("\n");
     }
-    this.pendingUtt = this.mergeUtterance(this.pendingUtt, text);
-    if (this.pendingTimer) clearTimeout(this.pendingTimer);
-    if (this.options.incompleteMergeMs && this.looksIncomplete(this.pendingUtt)) {
-      log11.verbose(`hold: incomplete utterance "${this.pendingUtt.slice(-40)}"`);
-      this.options.onHold();
-      if (this.options.holdFiller && !this.speaking) {
-        this.beginSpeech();
-        this.speakDelta(this.options.holdFiller);
-        this.endSpeech();
+  };
+  const callMcpTool = {
+    name: "McpCall",
+    description: "Call an MCP tool discovered via `ToolSearch`, by its exact name. Pass its arguments as `args`.",
+    parameters: {
+      type: "object",
+      required: ["name"],
+      properties: {
+        name: { type: "string", description: "exact tool name from ToolSearch" },
+        args: { type: "object", description: "arguments object for the tool (per its schema)" }
       }
-      this.pendingTimer = setTimeout(() => this.flushUtterance(), this.options.incompleteMergeMs);
-      return;
-    }
-    if (!this.options.utteranceMergeMs || this.words(this.pendingUtt).length >= 4) return this.flushUtterance();
-    this.pendingTimer = setTimeout(() => this.flushUtterance(), this.options.utteranceMergeMs);
-  }
-  flushUtterance() {
-    if (this.pendingTimer) {
-      clearTimeout(this.pendingTimer);
-      this.pendingTimer = null;
+    },
+    async run({ name, args }) {
+      const n = String(name ?? "");
+      if (!byName.has(n)) return `Error: unknown MCP tool '${n}'. Use ToolSearch to find valid names.`;
+      const r = toResult(await callTool(n, args ?? {}));
+      return r.images?.length ? r : r.text;
     }
-    const text = this.pendingUtt;
-    this.pendingUtt = "";
-    if (text) {
-      this.turnStartAt = now();
-      this.bargeGraceUntil = now() + this.options.bargeGraceMs;
-      this.options.onUtterance(text);
+  };
+  return [searchTool, callMcpTool];
+}
+function buildMcpCatalog(servers) {
+  const specs = [];
+  const routes = /* @__PURE__ */ new Map();
+  for (const m of servers) {
+    for (const s of m.specs) {
+      const base = `mcp__${m.name}__${s.name}`.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 128);
+      let display = base;
+      for (let i = 2; routes.has(display); i++) display = `${base.slice(0, 128 - String(i).length - 1)}_${i}`;
+      specs.push({ name: display, description: s.description, inputSchema: s.inputSchema });
+      routes.set(display, { server: m.name, rawName: s.name });
     }
   }
-  get overlapCapable() {
-    return this.usingAec && this.options.overlapPause && !!this.player.pause && !!this.player.resume;
+  return { specs, routes };
+}
+function searchOverCatalog(servers, specs, routes, resolve, options) {
+  const tools = specs.length ? makeMcpToolSearch(specs, (name, args) => {
+    const r = routes.get(name);
+    if (!r) throw new Error(`unknown MCP tool '${name}' \u2014 use ToolSearch to find valid names`);
+    return resolve(r.server, r.rawName, args ?? {});
+  }, options) : [];
+  return { tools, serverNames: servers, toolCount: specs.length };
+}
+function makeMcpToolSearchFromMounted(mounted, options) {
+  const { specs, routes } = buildMcpCatalog(mounted);
+  const byName = new Map(mounted.map((m) => [m.name, m]));
+  return searchOverCatalog(mounted.map((m) => m.name), specs, routes, (server, rawName, args) => byName.get(server).client.callTool(rawName, args), options);
+}
+function makeLazyMcpToolSearch(servers, resolve, options) {
+  const { specs, routes } = buildMcpCatalog(servers);
+  return searchOverCatalog(servers.map((s) => s.name), specs, routes, resolve, options);
+}
+
+// src/hooks.ts
+var RecordingHooks = class {
+  /** tool name -> reason; a matching preToolUse call is blocked with that reason. */
+  constructor(blocks = {}) {
+    this.blocks = blocks;
   }
-  armResume() {
-    if (this.resumeTimer) clearTimeout(this.resumeTimer);
-    this.resumeTimer = setTimeout(() => {
-      this.resumeTimer = null;
-      if (!this.pausedAt) return;
-      this.stt.reset();
-      this.resetOverlap(true);
-    }, this.options.overlapResumeMs);
+  blocks;
+  pre = [];
+  post = [];
+  outputs = [];
+  stops = [];
+  preToolUse(call, meta) {
+    this.pre.push({ call, meta });
+    const reason = this.blocks[call.name];
+    if (reason != null) return { block: true, reason };
   }
-  resetOverlap(resume) {
-    if (this.resumeTimer) {
-      clearTimeout(this.resumeTimer);
-      this.resumeTimer = null;
-    }
-    if (this.pausedAt && resume) {
-      this.player.resume?.();
-      this.lastResumeAt = now();
-    }
-    this.pausedAt = 0;
-    this.lastOverlapPartial = "";
-    this.gatePassTimes = [];
+  postToolUse(call, result, meta) {
+    this.post.push({ call, result, meta });
   }
-  /** energy two-stage barge-in (heuristic tier only): spike over echo baseline → pause + confirm via STT */
-  gatePassTimes = [];
-  // recent gate-PASSING chunks (helper zeroes residue — nonzero = vetted)
-  handleLevel(rms) {
-    if (this.usingAec) {
-      if (!this.options.overlapEnergyHold || !this.speaking || !this.overlapCapable || this.pausedAt || rms < 50) return;
-      const t = now();
-      this.gatePassTimes = this.gatePassTimes.filter((x) => t - x < 350);
-      this.gatePassTimes.push(t);
-      if (this.gatePassTimes.length < 2) return;
-      this.gatePassTimes = [];
-      this.pausedAt = t;
-      this.player.pause();
-      this.armResume();
-      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);
-    }
+  onToolOutput(call, chunk, meta) {
+    this.outputs.push({ call, chunk, meta });
+  }
+  onStop(finalText) {
+    this.stops.push(finalText);
+  }
+};
+var RecordingLifecycle = class {
+  /** @param startContext injected at session start; @param rewrite maps a submitted prompt to a new one. */
+  constructor(startContext, rewrite) {
+    this.startContext = startContext;
+    this.rewrite = rewrite;
+  }
+  startContext;
+  rewrite;
+  starts = 0;
+  prompts = [];
+  compactions = [];
+  subagentStops = [];
+  onSessionStart() {
+    this.starts++;
+    return this.startContext;
+  }
+  onUserPromptSubmit(text) {
+    this.prompts.push(text);
+    return this.rewrite?.(text);
+  }
+  onPreCompact(messages) {
+    this.compactions.push(messages.length);
+  }
+  onSubagentStop(summary, info) {
+    this.subagentStops.push({ summary, label: info?.label });
   }
 };
 
+// src/index.ts
+init_logging();
+
 // src/voice/soniox.ts
 init_logging();
 
@@ -6486,7 +7151,7 @@ async function resolveAuth(auth) {
 
 // src/voice/soniox.ts
 var log12 = forComponent("SonioxSTT");
-var now2 = () => performance.now();
+var now = () => performance.now();
 var SonioxSTTOptions = class {
   auth = "";
   source;
@@ -6515,6 +7180,20 @@ var SonioxSTT = class {
    *  loop). The host tears voice down instead of spinning forever. */
   onFatal = () => {
   };
+  /** Diagnostic tap (provider errors, ws reconnects, no-audio watchdog). Fire-and-forget: a throwing
+   *  handler disables itself — never affects transcription. Wired by VoiceIO / the lab bridge. */
+  onDiag = () => {
+  };
+  diagOn = true;
+  diag(kind, fields) {
+    if (!this.diagOn) return;
+    try {
+      this.onDiag({ t: now(), kind, ...fields });
+    } catch (e) {
+      this.diagOn = false;
+      log12.debug(`onDiag threw \u2014 STT diagnostics disabled: ${e instanceof Error ? e.message : e}`);
+    }
+  }
   lastChunkAt = 0;
   // timestamp of the most recent mic chunk (0 = none yet)
   startedChunksAt = 0;
@@ -6555,8 +7234,12 @@ var SonioxSTT = class {
     this.ws.onclose = (ev) => {
       if (this.stopped) return;
       log12.warn(`soniox ws closed (${ev.code} ${ev.reason || ""}) \u2014 reconnecting`);
+      this.diag("stt_ws_closed", { code: ev.code, reason: String(ev.reason || ""), reconnecting: true });
       this.reset();
-      this.connectWs().catch((e) => log12.error(`soniox reconnect failed: ${e.message}`));
+      this.connectWs().catch((e) => {
+        log12.error(`soniox reconnect failed: ${e.message}`);
+        this.diag("stt_reconnect_failed", { message: e.message });
+      });
     };
   }
   async start() {
@@ -6565,20 +7248,21 @@ var SonioxSTT = class {
     this.sourceStarted = true;
     this.endpointTimer = setInterval(() => {
       const combined = (this.finalText + this.partialText).trim();
-      if (!combined || now2() - this.lastChangeAt < this.options.silenceEndpointMs) return;
-      if (this.firstTokenAt) log12.debug(`stt: ${Math.round(now2() - this.firstTokenAt)}ms first-token\u2192silence-endpoint, "${combined.slice(0, 60)}"`);
+      if (!combined || now() - this.lastChangeAt < this.options.silenceEndpointMs) return;
+      if (this.firstTokenAt) log12.debug(`stt: ${Math.round(now() - this.firstTokenAt)}ms first-token\u2192silence-endpoint, "${combined.slice(0, 60)}"`);
       this.reset();
-      this.onUtterance(combined, now2());
+      this.onUtterance(combined, now());
     }, 120);
     this.endpointTimer.unref?.();
-    this.startedChunksAt = now2();
+    this.startedChunksAt = now();
     const noAudioMs = this.options.noAudioTimeoutMs;
     if (noAudioMs > 0) {
       this.noAudioTimer = setInterval(() => {
         if (this.stopped) return;
         const ref = this.lastChunkAt || this.startedChunksAt;
-        if (now2() - ref > noAudioMs) {
+        if (now() - ref > noAudioMs) {
           log12.error(`stt: no mic audio for >${Math.round(noAudioMs / 1e3)}s \u2014 capture device stopped delivering`);
+          this.diag("stt_watchdog_fatal", { noAudioMs });
           this.onFatal("microphone stopped delivering audio (try a different input device, e.g. AirPods, or check System Settings \u2192 Sound \u2192 Input)");
           this.stop();
         }
@@ -6586,7 +7270,7 @@ var SonioxSTT = class {
       this.noAudioTimer.unref?.();
     }
     await this.options.source.start((chunk) => {
-      this.lastChunkAt = now2();
+      this.lastChunkAt = now();
       let sum = 0;
       const view = new DataView(chunk.buffer, chunk.byteOffset, chunk.byteLength);
       for (let i = 0; i + 1 < chunk.byteLength; i += 2) {
@@ -6598,7 +7282,10 @@ var SonioxSTT = class {
     });
   }
   handle(m) {
-    if (m.error_message) return log12.error(`soniox: ${m.error_message}`);
+    if (m.error_message) {
+      this.diag("stt_error", { message: String(m.error_message), code: m.error_code });
+      return log12.error(`soniox: ${m.error_message}`);
+    }
     let endpoint = false;
     for (const t of m.tokens ?? []) {
       if (t.text === "<end>") endpoint = true;
@@ -6608,15 +7295,15 @@ var SonioxSTT = class {
     const combined = this.finalText + this.partialText;
     if (combined !== this.lastCombined) {
       this.lastCombined = combined;
-      this.lastChangeAt = now2();
-      if (!this.firstTokenAt && combined.trim()) this.firstTokenAt = now2();
+      this.lastChangeAt = now();
+      if (!this.firstTokenAt && combined.trim()) this.firstTokenAt = now();
     }
     this.onPartial(combined);
     if (endpoint && this.finalText.trim()) {
       const utterance = this.finalText.trim();
-      if (this.firstTokenAt) log12.debug(`stt: ${Math.round(now2() - this.firstTokenAt)}ms first-token\u2192endpoint, "${utterance.slice(0, 60)}"`);
+      if (this.firstTokenAt) log12.debug(`stt: ${Math.round(now() - this.firstTokenAt)}ms first-token\u2192endpoint, "${utterance.slice(0, 60)}"`);
       this.reset();
-      this.onUtterance(utterance, now2());
+      this.onUtterance(utterance, now());
     }
   }
   reset() {
@@ -6638,7 +7325,7 @@ var SonioxSTT = class {
 // src/voice/cartesia.ts
 init_logging();
 var log13 = forComponent("CartesiaTTS");
-var now3 = () => performance.now();
+var now2 = () => performance.now();
 var CartesiaTTSOptions = class {
   auth = "";
   voiceId = "";
@@ -6655,6 +7342,27 @@ var CartesiaTTS = class _CartesiaTTS {
   };
   onDone = () => {
   };
+  /** Word-level timestamps for karaoke reveal: `start[i]` = seconds from turn-audio start (absolute
+   *  across continuation chunks). Fired only when a consumer opts into reveal (see `wantTimestamps`). */
+  onTimestamps = () => {
+  };
+  /** Request `add_timestamps` from Cartesia. Off by default (saves bandwidth) — the engine sets it
+   *  when revealMode==='word'. */
+  wantTimestamps = false;
+  /** Diagnostic tap (provider errors, circuit-breaker open/close, ws reconnects). Fire-and-forget:
+   *  a throwing handler disables itself — never affects synthesis. Wired by VoiceIO / the lab bridge. */
+  onDiag = () => {
+  };
+  diagOn = true;
+  diag(kind, fields) {
+    if (!this.diagOn) return;
+    try {
+      this.onDiag({ t: now2(), kind, ...fields });
+    } catch (e) {
+      this.diagOn = false;
+      log13.debug(`onDiag threw \u2014 TTS diagnostics disabled: ${e instanceof Error ? e.message : e}`);
+    }
+  }
   firstAudioAt = 0;
   /** Circuit breaker: consecutive error count + down flag. */
   consecutiveErrors = 0;
@@ -6688,8 +7396,12 @@ var CartesiaTTS = class _CartesiaTTS {
     });
     this.ws.onclose = (ev) => {
       log13.warn(`cartesia ws closed (${ev.code} ${ev.reason || ""})`);
+      this.diag("tts_ws_closed", { code: ev.code, reason: String(ev.reason || ""), reconnecting: !this.closed });
       if (!this.closed) {
-        this.connecting = this.doConnect().catch((e) => log13.error(`cartesia reconnect failed: ${e.message}`));
+        this.connecting = this.doConnect().catch((e) => {
+          log13.error(`cartesia reconnect failed: ${e.message}`);
+          this.diag("tts_reconnect_failed", { message: e.message });
+        });
       }
     };
     this.ws.onmessage = (ev) => {
@@ -6698,24 +7410,29 @@ var CartesiaTTS = class _CartesiaTTS {
       if (m.type === "chunk" && m.data) {
         this.consecutiveErrors = 0;
         this.markRecovered();
-        if (!this.firstAudioAt) this.firstAudioAt = now3();
+        if (!this.firstAudioAt) this.firstAudioAt = now2();
         this.onAudio(base64ToBytes(m.data));
       } else if (m.type === "done") {
         this.consecutiveErrors = 0;
         this.markRecovered();
         this.onDone();
+      } else if (m.type === "timestamps" && m.word_timestamps) {
+        const wt = m.word_timestamps;
+        if (wt.words?.length && wt.start?.length) this.onTimestamps(wt.words, wt.start);
       } else if (m.type === "error") {
         if (/already been cancelled|does not exist/.test(m.message || "")) return;
         this.consecutiveErrors++;
+        this.diag("tts_error", { message: String(m.message || ""), code: m.status_code, contextId: m.context_id, consecutive: this.consecutiveErrors });
         if (!this.down && this.consecutiveErrors >= _CartesiaTTS.CB_THRESHOLD) {
           this.down = true;
-          this.downAt = now3();
+          this.downAt = now2();
           this.consecutiveOk = 0;
           log13.warn(`TTS circuit breaker open \u2014 ${this.consecutiveErrors} consecutive errors, switching to text-only`);
+          this.diag("tts_breaker_open", { errors: this.consecutiveErrors });
           this.onDone();
           this.startProbe();
         } else if (!this.down) {
-          log13.warn(`cartesia: ${JSON.stringify(m)}`);
+          (/No valid transcripts/i.test(m.message || "") ? log13.debug : log13.warn)(`cartesia: ${JSON.stringify(m)}`);
         }
       }
     };
@@ -6728,7 +7445,8 @@ var CartesiaTTS = class _CartesiaTTS {
     this.down = false;
     this.consecutiveOk = 0;
     this.stopProbe();
-    const downMs = this.downAt ? now3() - this.downAt : 0;
+    const downMs = this.downAt ? now2() - this.downAt : 0;
+    this.diag("tts_breaker_close", { downMs: Math.round(downMs) });
     (downMs < 2e3 ? log13.debug : log13.info)(`TTS recovered${downMs ? ` (down ${downMs}ms)` : ""}`);
   }
   /** Ensure the WS is open before sending — reconnects if idle-closed. */
@@ -6736,6 +7454,15 @@ var CartesiaTTS = class _CartesiaTTS {
     if (this.connecting) await this.connecting;
     if (this.ws?.readyState !== WebSocket.OPEN) await this.connect();
   }
+  /** Prime the synthesis pipeline on a throwaway context right after connect: the FIRST synthesis on
+   *  a fresh WS pays Cartesia's cold spin-up (~1s+ live) — absorb it at mic-on instead of turn one.
+   *  The returned audio is discarded (engine drops onAudio while not speaking; once a real turn calls
+   *  newContext() any stragglers are stale-context-filtered). Respects the circuit breaker. */
+  warmup() {
+    if (this.down) return;
+    this.newContext();
+    if (this.ws?.readyState === WebSocket.OPEN) this.ws.send(this.frame("Ok.", false));
+  }
   newContext() {
     this.ctxId = `ctx-${++this.ctxSeq}`;
     this.firstAudioAt = 0;
@@ -6748,7 +7475,8 @@ var CartesiaTTS = class _CartesiaTTS {
       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
+      continue: cont,
+      ...this.wantTimestamps ? { add_timestamps: true } : {}
     });
   }
   speak(text, cont) {
@@ -6776,7 +7504,7 @@ var CartesiaTTS = class _CartesiaTTS {
       }
       this.consecutiveErrors = 0;
       this.newContext();
-      if (this.ws?.readyState === WebSocket.OPEN) this.ws.send(this.frame(".", false));
+      if (this.ws?.readyState === WebSocket.OPEN) this.ws.send(this.frame("Ok.", false));
     }, _CartesiaTTS.CB_PROBE_MS);
     this.probeTimer.unref?.();
   }