@livx.cc/agentx 0.99.57 → 0.99.59

package/dist/index.js

@@ -3391,6 +3391,7 @@ function resolveModelAlias(input) {
   const slash = input.indexOf("/");
   const prefix = slash === -1 ? "" : input.slice(0, slash + 1);
   const rest = slash === -1 ? input : input.slice(slash + 1);
+  if (prefix === "claude-code/") return input;
   return prefix + (MODEL_ALIASES[rest.toLowerCase()] ?? rest);
 }
 function modelProvider(model) {
@@ -6565,6 +6566,130 @@ var EmotionStream = class {
   }
 };
 
+// node_modules/@bod.ee/voice/src/core/endpointing.ts
+var INCOMPLETE_ENDINGS = /* @__PURE__ */ new Set([
+  // Conjunctions
+  "and",
+  "but",
+  "or",
+  "so",
+  "because",
+  "although",
+  "though",
+  "while",
+  "since",
+  "unless",
+  "if",
+  "when",
+  "where",
+  // Prepositions
+  "to",
+  "for",
+  "with",
+  "about",
+  "of",
+  "at",
+  "in",
+  "on",
+  "from",
+  "by",
+  "into",
+  "through",
+  // Articles / determiners
+  "the",
+  "a",
+  "an",
+  "this",
+  "that",
+  "these",
+  "those",
+  "my",
+  "your",
+  "his",
+  "her",
+  "our",
+  "their",
+  // Bare pronouns ("…as I asked it" — the live case above)
+  "i",
+  "you",
+  "we",
+  "they",
+  "he",
+  "she",
+  "it",
+  // Fillers (thinking)
+  "um",
+  "uh",
+  "like",
+  "well"
+]);
+var CONTINUATION_MARKERS = [
+  "you know",
+  "i mean",
+  "the thing is",
+  "let me think",
+  "first of all",
+  "on one hand",
+  "for example"
+];
+var COMPLETE_ENDINGS = /* @__PURE__ */ new Set([
+  "yeah",
+  "yes",
+  "no",
+  "nah",
+  "okay",
+  "ok",
+  "sure",
+  "right",
+  "thanks",
+  "bye",
+  "absolutely",
+  "definitely",
+  "exactly",
+  "correct",
+  "true",
+  "false"
+]);
+function isTranscriptComplete(text) {
+  const trimmed = text.trim();
+  if (!trimmed) return false;
+  if (/[.?!]$/.test(trimmed)) return true;
+  const words = trimmed.toLowerCase().split(/\s+/);
+  const lastWord = words[words.length - 1];
+  if (COMPLETE_ENDINGS.has(lastWord)) return true;
+  if (INCOMPLETE_ENDINGS.has(lastWord)) return false;
+  const lower = trimmed.toLowerCase();
+  for (const marker of CONTINUATION_MARKERS) if (lower.endsWith(marker)) return false;
+  if (words.length <= 2) return false;
+  return true;
+}
+var MAX_HOLD_MS = 2e3;
+var MIN_MERGE_HOLD_MS = 800;
+function endpointTier(transcript) {
+  const t = transcript.trim();
+  if (!isTranscriptComplete(t)) return 1;
+  return /[.?!]$/.test(t) ? 3 : 2;
+}
+function tierHoldMs(tier, ctx) {
+  if (tier === 1) return ctx.incompleteMs;
+  if (tier === 2) return Math.round((ctx.baseMs + ctx.incompleteMs) / 2);
+  return ctx.baseMs;
+}
+function computeHoldMs(ctx) {
+  const t = ctx.transcript.trim();
+  const tier = endpointTier(t);
+  let ms = tierHoldMs(tier, ctx);
+  const ai = ctx.lastAiMessage?.trim();
+  if (ai) {
+    if (/\?$/.test(ai)) ms -= 300;
+    if (ai.split(/\s+/).length > 60) ms += 400;
+  }
+  const lastWord = t.toLowerCase().split(/\s+/).pop();
+  if (lastWord === "um" || lastWord === "uh" || lastWord === "hmm") ms += 500;
+  const floor = tier === 3 ? ctx.baseMs : Math.max(ctx.baseMs, Math.min(tierHoldMs(tier, ctx), MIN_MERGE_HOLD_MS));
+  return Math.max(floor, Math.min(MAX_HOLD_MS, ms));
+}
+
 // node_modules/@bod.ee/voice/src/core/engine.ts
 var log13 = forComponent2("VoiceEngine");
 var realClock = {
@@ -6573,7 +6698,7 @@ var realClock = {
   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 normWord = (w) => w.toLowerCase().replace(/[^\p{L}\p{M}\p{N}]/gu, "");
 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);
@@ -6584,11 +6709,27 @@ function speculationConfirms(spec, final) {
   for (let i = sw.length; i < fw.length; i++) if (!SPEC_TRAILING_OK.has(fw[i])) return false;
   return true;
 }
+function heardPrefix(text, spoken, lookahead = 4) {
+  const toks = [...text.matchAll(/\S+/g)];
+  let i = 0, at = 0;
+  for (const w of spoken) {
+    const nw = normWord(w);
+    if (!nw) continue;
+    for (let k = i; k < Math.min(toks.length, i + lookahead); k++)
+      if (normWord(toks[k][0]) === nw) {
+        at = toks[k].index;
+        i = k + 1;
+        break;
+      }
+  }
+  return at;
+}
 var VoiceEngineOptions = class {
   stt;
   tts;
   player;
-  /** a final utterance arrived (endpoint) — host dispatches it as a turn */
+  /** a final utterance arrived (endpoint) — host dispatches it as a turn. `meta.supersedes` marks a fuller
+   *  re-finalization of the utterance dispatched just before it: replace that turn, don't add one. */
   onUtterance = () => {
   };
   /** live partial transcript while listening (host renders the 🎤 line) */
@@ -6596,6 +6737,14 @@ var VoiceEngineOptions = class {
   };
   onState = () => {
   };
+  /** The assistant's spoken turn finished AUDIBLY — every TTS chunk arrived AND playback drained.
+   *  Fires from the same `settle()` that returns the engine to 'listening', just before that state
+   *  change. Distinct from the host's `endSpeech()`, which only closes the TEXT stream (audio is
+   *  still playing at that point). NOT fired for a turn cut by barge-in — the host gets `onBargeIn`
+   *  instead. Also fires for engine-internal speech (adaptive ack, filler, queued utterances), so a
+   *  host that only cares about ITS turns should gate on its own open-turn flag. Default no-op. */
+  onSpeechEnd = () => {
+  };
   /** 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). */
@@ -6610,6 +6759,14 @@ var VoiceEngineOptions = class {
   /** the adaptive ack actually fired (host can mark the turn as spoken — e.g. suppress dead-air repair) */
   onAdaptiveAck = () => {
   };
+  /** HOST-CHOSEN adaptive ack: asked once per armed ack (at beginSpeech(true), i.e. at dispatch) so a slow pick
+   *  runs in parallel with the reflex. Return the phrase to speak, or `null` = stay silent this turn. A Promise
+   *  still pending when the ack is due gets up to another `adaptiveAckMs` (then the turn stays silent — a wrong
+   *  ack is worse than none); a rejection falls back to the default pools. Unset (null) = the engine's own
+   *  shape-picked pools (ACKS_NEUTRAL / ACKS_QUESTION). Phrases enter the echo set like the defaults — keep them
+   *  short and not a lone word users say on their own ("okay", "yeah"): the ack-squash guard drops a user
+   *  utterance that equals the last ack. */
+  pickAck = null;
   /** 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. */
@@ -6617,6 +6774,21 @@ var VoiceEngineOptions = class {
   /** 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;
+  /** ADAPTIVE endpoint hold (opt-in; default OFF = today's byte-identical two-tier behavior).
+   *  The fixed merge tiers (`utteranceMergeMs` vs `incompleteMergeMs`, chosen by a trailing-word
+   *  regex, and skipped entirely at ≥4 words) dispatch mid-thought FRAGMENTS as their own turn: live,
+   *  "…give me the best" dispatched, got an empty reply, and "…give me the best of it." arrived 766ms
+   *  later as a second turn. When true, every endpointed utterance is held for
+   *  `computeHoldMs(...)` — sized by linguistic completeness, whether the STT emitted a sentence-final
+   *  mark, and what the assistant last said — so the continuation MERGES instead of burning a turn.
+   *  COST — this is strictly slower than the default path, never faster: today every ≥4-word utterance
+   *  dispatches at 0ms (the fast path below), so adaptive ADDS the whole hold — ~350ms to every
+   *  sentence-final utterance, ~925ms to every complete-looking unpunctuated one (the common case),
+   *  and up to 2s on a mid-thought fragment. Paid on turns that didn't need it, to stop burning a turn
+   *  (empty reply + blank bubble) on the ones that did — hence opt-in. Also changes `onHold` timing:
+   *  it now fires on every tier-2/3 hold, not only on `looksIncomplete` (`holdFiller` stays tier-1
+   *  only). See core/endpointing.ts. */
+  adaptiveEndpointing = false;
   /** 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
@@ -6627,6 +6799,15 @@ var VoiceEngineOptions = class {
    *  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;
+  /** Which barge-in TIER to run — the host's override of the mic's self-report.
+   *  - `'auto'` (default) — trust `stt.usingAec`: AEC tier when the mic reports echo cancellation
+   *    applied, heuristic/energy tier otherwise. Unchanged legacy behavior.
+   *  - `'aec'` — force the AEC tier (STT stays live through TTS; barge decided by the dominant-novel
+   *    gate + overlap pause) even if the mic reports no echo cancellation.
+   *  - `'energy'` — force the heuristic tier (echo-baseline EMA spike arms `suspectUntil`, novel-word
+   *    count decides; STT buffer reset after our own audio) even if the mic REPORTS echoCancellation.
+   *    Mobile Safari reports `true` while cancelling poorly — that report is what this overrides. */
+  bargeInMode = "auto";
   /** 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). */
@@ -6650,6 +6831,15 @@ var VoiceEngineOptions = class {
    *  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;
+  /** HOST-DECIDED short overlaps (opt-in; 0 = off = cede on ≥2 genuine words, as always). The fast "≥2 novel words →
+   *  cede" rule cannot tell a reaction ("Oh, that's new") from a barge, and it fires ~300ms before a host-side judge
+   *  (e.g. an AI instinct) can answer — so a judge could never keep a delivery going (live 20260923-125143: ceded on
+   *  "Oh, that", the judge said keep_talking 300ms later). When > 0, a SHORT genuine overlap (≤ overlapDecideMaxWords,
+   *  no '?', no stop/question word) keeps the pause and waits for `decideOverlap()`; with no decision after this many
+   *  ms it cedes. Long or obvious barges still cede instantly. Audio is already paused, so waiting costs no talk-over. */
+  overlapDecideMs = 0;
+  /** Longest overlap (words) the host decides; also how far an overlap the host kept may grow before it cedes. */
+  overlapDecideMaxWords = 4;
   /** 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
@@ -6702,6 +6892,10 @@ var VoiceEngineOptions = class {
    *             timestamp-emitting TTS (CartesiaTTS.wantTimestamps) driven over `AudioSink.playedMs`.
    */
   revealMode = "off";
+  /** Locate EXACTLY what the user heard when a barge cuts speech: request word timestamps from the TTS (when it
+   *  supports them) and match them against the playback clock (InterruptedReply `heard`/`exact`). Independent of
+   *  `revealMode` — no reveal events. Without timestamps the cut falls back to the ~15 chars/s estimate. */
+  heardTimestamps = true;
   /** Called with the cumulative revealed text for the current assistant turn (see `revealMode`).
    *  Reset to '' at the start of each spoken turn. */
   onReveal = () => {
@@ -6732,8 +6926,27 @@ var VoiceEngine = class _VoiceEngine {
   // 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 = [];
+  wordTexts = [];
+  // the timestamped words, parallel to wordStarts (heard-cut matching)
+  ackWords = 0;
+  // leading timestamped words that are the ack spoken on this turn's context, not the reply
   revealedN = 0;
   revealPoll = null;
+  // Sub-turn timestamp anchoring. A TTS context emits word starts relative to ITS OWN audio start, so
+  // `wordStarts` (one flat turn timeline) is only valid while the turn stays on one context. It does
+  // not: `subturnBoundary()` rotates the context, and Cartesia ALSO rotates it on its own (~5s idle
+  // timeout mid tool-call) — after which starts restart at 0 and every remaining word instantly
+  // satisfies the reveal predicate, dumping the whole segment on screen.
+  // Fix is deterministic, not detective: at a boundary we FORCE the rotation ourselves, so the new
+  // context's origin is always known — it is the turn-audio position where its first byte lands,
+  // captured from the sink at that byte (`playedMs + drainMs` = content seconds written so far).
+  // Starts arriving before that byte are held in `wordPending` and rebased when it does.
+  wordOrigin = 0;
+  // sec offset added to incoming starts (0 = first sub-turn)
+  wordAnchorPending = false;
+  // awaiting the new sub-turn's first audio byte
+  wordPending = [];
+  // [word, start] received while pending, rebased on capture
   clock;
   drainTimer = null;
   // heuristic tier state (inert under AEC) — frozen as validated in the experiment
@@ -6764,6 +6977,8 @@ var VoiceEngine = class _VoiceEngine {
   // endpointed text held for the merge window
   mergePath = "direct";
   // how the pending utterance was assembled (diag)
+  holdTier = 0;
+  // adaptive tier of the hold this dispatch came out of (diag; 0 = none)
   lastGraceDiag = 0;
   // grace_suppress emitted once per grace window
   pendingTimer = null;
@@ -6774,10 +6989,24 @@ var VoiceEngine = class _VoiceEngine {
   // the agent replied (or after 3s) still dispatches.
   lastDispatchFlat = "";
   lastDispatchWords = [];
+  lastDispatchText = "";
   lastDispatchAt = 0;
   repliedSinceDispatch = false;
+  dispatchReply = "";
+  // the agent's prose since the last dispatch (answeredSinceDispatch)
   static DUP_FINAL_MS = 3e3;
   lastInterrupted = null;
+  queuedTurn = false;
+  // the current spoken turn is a queued worker utterance (pumpQueue), not a host turn
+  // host-decided overlap (options.overlapDecideMs): pending decision timer, a final that landed while waiting, and
+  // the window in which the overlap the host chose to talk over is absorbed (its growth + its final)
+  decideTimer = null;
+  decideSince = 0;
+  // when this hold began waiting for the host — caps re-decisions (3× overlapDecideMs)
+  decideHeldFinal = "";
+  overlapKeptUntil = 0;
+  overlapKept = "";
+  // what the host judged keep_talking on — only THOSE words are absorbed
   // overlap (pause) tier state — AEC + pause-capable sinks only
   pausedAt = 0;
   lastResumeAt = 0;
@@ -6826,13 +7055,21 @@ var VoiceEngine = class _VoiceEngine {
   }
   async start() {
     this.tts.onAudio = (c) => {
-      if (this.speaking || this.bcActive) this.player.write(c);
+      if (!this.speaking && !this.bcActive) return;
+      if (this.wordAnchorPending && this.speaking) this.anchorSubturn();
+      this.player.write(c);
     };
-    if (this.options.revealMode === "word") {
+    if (this.options.revealMode === "word" || this.options.heardTimestamps) {
       this.tts.wantTimestamps = true;
-      this.tts.onTimestamps = (_words, start) => {
+      this.tts.onTimestamps = (words, start) => {
         if (this.interrupted) return;
-        for (const s of start) this.wordStarts.push(s);
+        start.forEach((s, i) => {
+          if (this.wordAnchorPending) this.wordPending.push([words[i] ?? "", s]);
+          else {
+            this.wordStarts.push(this.wordOrigin + s);
+            this.wordTexts.push(words[i] ?? "");
+          }
+        });
       };
     }
     this.stt.onPartial = (text) => this.handlePartial(text);
@@ -6841,10 +7078,15 @@ var VoiceEngine = class _VoiceEngine {
     await Promise.all([this.tts.connect(), this.stt.start()]);
     this.tts.warmup?.();
     this.setState("listening");
-    log13.debug(`voice I/O up (${this.stt.usingAec ? "AEC" : "heuristic echo"} capture)`);
+    if (this.options.bargeInMode === "aec" && !this.stt.usingAec)
+      log13.warn("bargeInMode=aec but mic does not report echoCancellation applied \u2014 STT may transcribe the assistant");
+    log13.debug(`voice I/O up (${this.usingAec ? "AEC" : "heuristic echo"} capture, mode=${this.options.bargeInMode}, mic reports aec=${this.stt.usingAec})`);
   }
+  /** The RESOLVED barge-in tier (the single seam every tier branch reads). `bargeInMode` overrides
+   *  the mic's self-report — see the option doc for why the report is not trustworthy on mobile. */
   get usingAec() {
-    return this.stt.usingAec;
+    const m = this.options.bargeInMode;
+    return m === "aec" ? true : m === "energy" ? false : this.stt.usingAec;
   }
   /** Flip barge-in at runtime (e.g. the mic fell back to non-VPIO → go half-duplex so echo can't leak). */
   setBargeIn(on) {
@@ -6876,6 +7118,12 @@ var VoiceEngine = class _VoiceEngine {
       for (const r of this.idleWaiters.splice(0)) r();
     }
   }
+  /** True while the assistant is AUDIBLE — deltas flowing or queued audio still draining. Goes false
+   *  exactly when `onSpeechEnd` fires (or immediately on barge-in). Lets a host tell "the turn closed
+   *  but audio is still playing" from "there was nothing to play", without waiting for a callback. */
+  get audible() {
+    return this.speaking;
+  }
   /** Resolve when the engine is no longer speaking (immediate if already idle). */
   awaitIdle() {
     if (this.state !== "speaking" && this.state !== "thinking") return Promise.resolve();
@@ -6892,19 +7140,31 @@ var VoiceEngine = class _VoiceEngine {
       this.drainTimer = null;
     }
     this.interrupted = false;
+    this.queuedTurn = false;
     this.bcSupersede();
     this.resetOverlap(true);
+    const acked = ack && this.dispatchRefinal && this.ackSpent;
+    if (acked) {
+      ack = false;
+      this.diag("ack_skipped", { reason: "refinal" });
+    }
     this.diag("tts_turn_begin", { ack, gapless: this.speaking });
+    const gapless = this.speaking;
     if (!this.speaking) this.player.markTurn();
     this.speaking = true;
     this.ctxOpen = true;
     this.spokeDeltas = false;
-    this.adaptiveAckFired = false;
-    this.ackProbe = null;
+    this.adaptiveAckFired = acked;
+    this.ackProbe = acked ? "" : null;
+    this.ackPickedFired = false;
     this.reply = "";
     this.revealText = "";
     this.wordStarts = [];
+    this.wordTexts = [];
+    this.ackWords = 0;
     this.revealedN = 0;
+    this.resetSubturnAnchor();
+    if (gapless) this.wordAnchorPending = true;
     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));
@@ -6916,23 +7176,27 @@ var VoiceEngine = class _VoiceEngine {
       this.spokeDeltas = true;
       this.ackAt = this.clock.now();
       this.lastAck = this.options.ackPhrase;
+      this.ackSpent = true;
+      this.ackWords = this.options.ackPhrase.trim().split(/\s+/).length;
       for (const w of this.words(this.options.ackPhrase)) this.echoWords.add(w);
     } else if (ack && this.options.adaptiveAckMs > 0) {
+      const pick = this.startAckPick();
+      const ms = this.options.adaptiveAckMs;
       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.adaptiveAckFired = true;
-        this.ackProbe = "";
-        this.options.onAdaptiveAck();
-      }, this.options.adaptiveAckMs);
+        if (!pick.pending) return this.fireAck(pick.phrase, pick.picked);
+        this.ackTimer = this.clock.setTimeout(() => {
+          this.ackTimer = null;
+          pick.onDone = null;
+          this.ackPick = null;
+          this.diag("ack_cancelled", { reason: "pick_late" });
+        }, ms);
+        pick.onDone = () => {
+          this.clearAckTimer();
+          this.fireAck(pick.phrase, pick.picked);
+        };
+      }, ms);
+      this.ackPick = pick;
     }
     if (!this.turnStartAt) this.turnStartAt = this.clock.now();
     this.setState("thinking");
@@ -6952,11 +7216,16 @@ var VoiceEngine = class _VoiceEngine {
       this.adaptiveAckFired = false;
       const lead = m ? m[1] : bare;
       const norm2 = lead.replace(/[^a-z ]/gi, " ").replace(/\s+/g, " ").trim().toLowerCase();
+      const same = this.ackPickedFired ? bare.match(_VoiceEngine.leadingPhrase(this.lastAck)) : null;
       if (_VoiceEngine.ACK_LEADING.test(norm2)) {
         const rest = m ? m[2] : "";
         this.diag("reflex_ack_suppressed", { lead: lead.trim() });
         if (!rest.trim()) return "";
         text = rest;
+      } else if (same) {
+        this.diag("reflex_ack_suppressed", { lead: same[0].trim() });
+        text = bare.slice(same[0].length);
+        if (!text.trim()) return "";
       } else {
         text = probe;
       }
@@ -6969,7 +7238,10 @@ var VoiceEngine = class _VoiceEngine {
       prose = " " + prose;
     }
     this.reply += prose;
-    if (prose.trim()) this.repliedSinceDispatch = true;
+    if (prose.trim()) {
+      this.repliedSinceDispatch = true;
+      this.dispatchReply += prose;
+    }
     for (const w of this.words(this.reply)) this.echoWords.add(w);
     this.tts.speak(forSpeech(speech), true);
     if (!this.spokeDeltas && this.turnStartAt) log13.debug(`ttft: ${Math.round(this.clock.now() - this.turnStartAt)}ms`);
@@ -6981,6 +7253,42 @@ var VoiceEngine = class _VoiceEngine {
     }
     return display;
   }
+  /** Sub-turn seam: the host's agent stream interrupted the reply with a tool call, so the spoken
+   *  turn continues on a FRESH TTS context. Flushes the current context and opens the next, then
+   *  re-anchors the karaoke timeline at the position the next context's first audio byte lands on.
+   *
+   *  Rotating unconditionally is the point: Cartesia restarts word timestamps at 0 for each context
+   *  and ALSO rotates on its own after ~5s idle — so leaving the context alone makes reveal timing
+   *  depend on an invisible server-side timer (short gap = one timeline, long gap = a restart we
+   *  never saw). By always rotating, the origin is always known and never inferred.
+   *
+   *  No-op outside an open turn. Reveal text/word ordering is unchanged — only the time origin. */
+  subturnBoundary() {
+    if (!this.speaking || !this.ctxOpen) return;
+    this.diag("tts_subturn_boundary", { playedMs: Math.round(Math.max(0, this.player.playedMs())) });
+    this.tts.end();
+    this.tts.newContext();
+    this.wordAnchorPending = true;
+    this.wordPending = [];
+  }
+  /** Capture the current sub-turn's time origin = content seconds already written to the sink.
+   *  `playedMs + drainMs` is that sum in both regimes (mid-playback it telescopes to the scheduled
+   *  content; fully drained, drainMs is 0 and playedMs has reached the scheduled total). */
+  anchorSubturn() {
+    this.wordAnchorPending = false;
+    this.wordOrigin = Math.max(0, this.player.playedMs() + this.player.drainMs()) / 1e3;
+    this.diag("reveal_anchor", { originSec: Number(this.wordOrigin.toFixed(3)), held: this.wordPending.length });
+    for (const [w, s] of this.wordPending) {
+      this.wordStarts.push(this.wordOrigin + s);
+      this.wordTexts.push(w);
+    }
+    this.wordPending = [];
+  }
+  resetSubturnAnchor() {
+    this.wordOrigin = 0;
+    this.wordAnchorPending = false;
+    this.wordPending = [];
+  }
   /** 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
@@ -7052,6 +7360,11 @@ var VoiceEngine = class _VoiceEngine {
       if (this.turnStartAt) log13.debug(`turn: ${Math.round(this.clock.now() - this.turnStartAt)}ms (incl. playback)`);
       this.echoUntil = this.clock.now() + 2500;
       if (!this.usingAec) this.stt.reset();
+      try {
+        this.options.onSpeechEnd();
+      } catch (e) {
+        log13.warn(`onSpeechEnd threw: ${e instanceof Error ? e.message : e}`);
+      }
       this.setState("listening");
       if (this.uttQueue.length) this.pumpQueue();
     };
@@ -7066,8 +7379,9 @@ var VoiceEngine = class _VoiceEngine {
       this.drainTimer = this.clock.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. */
+  /** What the last barge-in cut — the reply that was playing (and its estimated heard part) plus every queued worker
+   *  utterance it dropped — consumed by the host to tell the model what the user did NOT hear, or to park the rest of
+   *  a delivery for resuming. Cleared on read. */
   takeInterruptedReply() {
     const r = this.lastInterrupted;
     this.lastInterrupted = null;
@@ -7076,11 +7390,12 @@ var VoiceEngine = class _VoiceEngine {
   /** 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;
+    const replied = this.repliedSinceDispatch, reply = this.dispatchReply;
     this.beginSpeech();
     this.speakDelta(text);
     this.endSpeech();
     this.repliedSinceDispatch = replied;
+    this.dispatchReply = reply;
   }
   /** 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
@@ -7098,6 +7413,7 @@ var VoiceEngine = class _VoiceEngine {
     const text = this.uttQueue.shift();
     if (text == null) return;
     this.beginSpeech();
+    this.queuedTurn = true;
     this.speakDelta(text);
     this.endSpeech();
   }
@@ -7112,6 +7428,69 @@ var VoiceEngine = class _VoiceEngine {
    *  micro-ack already spoke one. Anchored end-to-end so only a whole ack-only clause matches. */
   static ACK_LEADING = /^(?:(?:okay|ok|alright|sure|yeah|yep|right|got it|on it|still|still on it|still working on it|working on it|checking|one sec|one moment|mm hm|mmhm|hmm|let me (?:see|check|think))[ ,]*)+$/;
   recentAcks = [];
+  /** The armed turn's ack choice: the host's `pickAck` (sync or async); `phrase` undefined = the default pools, drawn
+   *  only when the ack actually fires. `onDone` is set only while the ack is due and the pick is still pending. */
+  ackPick = null;
+  startAckPick() {
+    const host = this.options.pickAck;
+    const pick = { pending: false, phrase: void 0, picked: !!host, onDone: null };
+    if (!host) return pick;
+    const ctx = { text: this.lastDispatchText, question: this.lastDispatchWasQuestion, barged: this.bargedBeforeDispatch };
+    const fallback = (e) => {
+      log13.warn(`pickAck failed \u2014 using the default pools: ${e instanceof Error ? e.message : e}`);
+      pick.picked = false;
+      return void 0;
+    };
+    let r;
+    try {
+      r = host(ctx);
+    } catch (e) {
+      pick.phrase = fallback(e);
+      return pick;
+    }
+    if (typeof r?.then !== "function") {
+      pick.phrase = r;
+      return pick;
+    }
+    pick.pending = true;
+    Promise.resolve(r).catch(fallback).then((phrase) => {
+      pick.pending = false;
+      pick.phrase = phrase;
+      if (this.ackPick === pick) pick.onDone?.();
+    });
+    return pick;
+  }
+  /** Speak the adaptive ack (null = the host chose silence, undefined = draw from the default pools) — only if the
+   *  turn is still waiting on its reflex. */
+  fireAck(phrase, picked) {
+    this.ackPick = null;
+    if (!this.speaking || !this.ctxOpen || this.spokeDeltas || this.interrupted) return;
+    if (phrase === void 0) phrase = this.pickAck();
+    if (phrase === null || !phrase.trim()) {
+      this.diag("ack_skipped", { reason: "silent" });
+      return;
+    }
+    this.diag("ack_fired", { phrase, adaptive: true, waitedMs: this.options.adaptiveAckMs, ...picked ? { picked } : {} });
+    this.tts.speak(phrase + " ", true);
+    this.spokeDeltas = true;
+    this.ackAt = this.clock.now();
+    this.lastAck = phrase;
+    this.ackSpent = true;
+    this.ackWords = phrase.trim().split(/\s+/).length;
+    for (const w of this.words(phrase)) this.echoWords.add(w);
+    this.setState("speaking");
+    this.adaptiveAckFired = true;
+    this.ackProbe = "";
+    this.ackPickedFired = picked;
+    this.options.onAdaptiveAck();
+  }
+  /** `phrase`'s words at the very start of a text, any punctuation between them ("Oh no." ~ "oh, no —"). */
+  static leadingPhrase(phrase) {
+    const w = phrase.toLowerCase().match(/[a-z0-9]+/g) ?? [];
+    return w.length ? new RegExp(`^[^a-z0-9]*${w.join("[^a-z0-9]+")}(?![a-z0-9])[^a-z0-9]*`, "i") : /$^/;
+  }
+  ackPickedFired = false;
+  // the fired ack was the host's pick → the probe also strips the reflex repeating it
   pickAck() {
     const pool = this.lastDispatchWasQuestion ? _VoiceEngine.ACKS_QUESTION : _VoiceEngine.ACKS_NEUTRAL;
     const fresh = pool.filter((p) => !this.recentAcks.includes(p));
@@ -7121,7 +7500,16 @@ var VoiceEngine = class _VoiceEngine {
     return phrase;
   }
   lastDispatchWasQuestion = false;
+  dispatchRefinal = false;
+  // the last dispatch re-finalized (superseded) the one before it — same logical turn
+  ackSpent = false;
+  // an ack already played for the current logical turn (reset by a non-refinal dispatch)
+  bargedSinceDispatch = false;
+  // an effective interrupt landed since the last dispatch
+  bargedBeforeDispatch = false;
+  // …as of the last dispatch (AckContext.barged)
   clearAckTimer(reason) {
+    if (reason) this.ackPick = null;
     if (!this.ackTimer) return;
     this.clock.clearTimeout(this.ackTimer);
     this.ackTimer = null;
@@ -7137,11 +7525,16 @@ var VoiceEngine = class _VoiceEngine {
     this.clearAckTimer("interrupt");
     this.adaptiveAckFired = false;
     this.ackProbe = null;
-    if (this.uttQueue.length) log13.info(`barge-in dropped ${this.uttQueue.length} queued worker utterance(s)`);
-    const droppedQueued = this.uttQueue.length;
-    this.uttQueue = [];
-    if (!this.speaking && !this.drainTimer) return;
+    const queued = this.uttQueue.splice(0);
+    const droppedQueued = queued.length;
+    if (droppedQueued) log13.info(`barge-in cut ${droppedQueued} queued worker utterance(s) \u2014 handed to the host`);
+    this.overlapKeptUntil = 0;
+    if (!this.speaking && !this.drainTimer) {
+      if (droppedQueued) this.lastInterrupted = { full: "", heard: "", queued, queuedTurn: false };
+      return;
+    }
     this.stopWordReveal(false);
+    this.resetSubturnAnchor();
     this.diag("interrupt", { droppedQueued, ctxOpen: this.ctxOpen, playedMs: Math.round(Math.max(0, this.player.playedMs())) });
     if (this.drainTimer) {
       this.clock.clearTimeout(this.drainTimer);
@@ -7149,8 +7542,9 @@ var VoiceEngine = class _VoiceEngine {
     }
     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) };
+    const { heard, exact } = this.heardCut();
+    if (this.reply || droppedQueued) this.lastInterrupted = { full: this.reply, heard, exact, queued, queuedTurn: this.queuedTurn };
+    if (heard.length < this.reply.length || droppedQueued) this.bargedSinceDispatch = true;
     this.speaking = false;
     this.ctxOpen = false;
     this.interrupted = true;
@@ -7162,8 +7556,23 @@ var VoiceEngine = class _VoiceEngine {
     if (this.reply) this.prevReply = this.reply;
     this.setState("listening");
   }
+  /** How much of the reply the user heard at a cut (paused time is excluded by the sink's playedMs). Exact from the
+   *  TTS word timestamps the playback clock has reached (the ack's leading words skipped); without timestamps, an
+   *  estimate — played seconds × ~15 chars/s of TTS speech, coarse and often mid-word. */
+  heardCut() {
+    const played = Math.max(0, this.player.playedMs());
+    if (!this.wordTexts.length) return { heard: this.reply.slice(0, Math.round(played / 1e3 * 15)), exact: false };
+    let n = 0;
+    while (n < this.wordStarts.length && this.wordStarts[n] <= played / 1e3) n++;
+    if (!this.ctxOpen && n === this.wordStarts.length && played / 1e3 - this.wordStarts[n - 1] >= 0.4) return { heard: this.reply, exact: true };
+    return { heard: this.reply.slice(0, heardPrefix(this.reply, this.wordTexts.slice(this.ackWords, n))), exact: true };
+  }
   stop() {
     this.uttQueue = [];
+    if (this.decideTimer) {
+      this.clock.clearTimeout(this.decideTimer);
+      this.decideTimer = null;
+    }
     this.clearAckTimer();
     if (this.resumeTimer) this.clock.clearTimeout(this.resumeTimer);
     if (this.pendingTimer) this.clock.clearTimeout(this.pendingTimer);
@@ -7176,9 +7585,41 @@ var VoiceEngine = class _VoiceEngine {
     this.setState("idle");
   }
   // --- listening side (STT-driven) ---
+  /** Echo-comparable tokens. Our text and the STT's rendering of it must tokenize alike: every non-alphanumeric
+   *  (em-dash, non-breaking hyphen, nbsp, …) SEPARATES words — deleting it glued "releases—GPT‑6" into
+   *  "releasesgpt6" and the echo gate missed our own words. Numbers take the spoken form STT may hear: letter/digit
+   *  runs split ("K2.8" → k 2 point 8), a decimal point is "point", number words are digits ("five" → 5).
+   *  Apostrophes are dropped (it's → its). Words under 2 letters are noise; digits are kept. Any script counts (Unicode
+   *  letters/marks/digits): an ASCII-only split gave Hebrew speech ZERO words, which the echo gate read as pure echo
+   *  (live 20260923-125143: "סבתא מחוץ לדלת?" and "תודה." swallowed). */
   words(s) {
-    return s.toLowerCase().replace(/[^a-z0-9\s]/g, "").split(/\s+/).filter((w) => w.length >= 2);
-  }
+    return s.toLowerCase().replace(/['’]/g, "").replace(/(\d)\.(?=\d)/g, "$1 point ").replace(new RegExp("(\\p{L})(?=\\d)|(\\d)(?=\\p{L})", "gu"), "$1$2 ").split(/[^\p{L}\p{M}\p{N}]+/u).map((w) => _VoiceEngine.NUMBER_WORDS[w] ?? w).filter((w) => w.length >= 2 || /\d/.test(w));
+  }
+  static NUMBER_WORDS = Object.fromEntries(
+    [
+      "zero",
+      "one",
+      "two",
+      "three",
+      "four",
+      "five",
+      "six",
+      "seven",
+      "eight",
+      "nine",
+      "ten",
+      "eleven",
+      "twelve",
+      "thirteen",
+      "fourteen",
+      "fifteen",
+      "sixteen",
+      "seventeen",
+      "eighteen",
+      "nineteen",
+      "twenty"
+    ].map((w, i) => [w, String(i)])
+  );
   novelWords(text) {
     return this.words(text).filter((w) => !this.echoWords.has(w));
   }
@@ -7195,6 +7636,22 @@ var VoiceEngine = class _VoiceEngine {
     const novel = this.novelWords(text).length;
     return novel > 0 && novel / Math.max(1, total) > 0.5;
   }
+  /** Echo verdict for a FINAL in the echo window (AEC tier). Bag-of-words genuine() alone swallowed real replies
+   *  that reuse a few of our words — live 20260923-102258, right after a barge over "…Gemini 3.8 Flash…":
+   *  "Wait, there is a new Gemini model?" (3 novel / 6) was dropped twice and the user had to repeat it. Echo
+   *  of our own audio reproduces RUNS of what we said, in order (mis-hearings break a word, not the run); a
+   *  reply that shares vocabulary scatters it. So a ≥4-word final that fails the bag test is echo only if at
+   *  least half its words sit in a word pair we actually said. Shorter finals can't show order → bag rule. */
+  echoFinal(text) {
+    if (this.genuine(text)) return false;
+    const w = this.words(text);
+    if (w.length < 4) return true;
+    const said = this.words(`${this.prevReply} ${this.reply} ${this.lastAck}`);
+    const pairs = new Set(said.slice(1).map((x, i) => `${said[i]} ${x}`));
+    const inRun = w.map(() => false);
+    for (let i = 1; i < w.length; i++) if (pairs.has(`${w[i - 1]} ${w[i]}`)) inRun[i - 1] = inRun[i] = true;
+    return inRun.filter(Boolean).length * 2 >= w.length;
+  }
   handlePartial(text) {
     if (this.speaking) {
       if (!this.options.bargeIn) return;
@@ -7206,14 +7663,29 @@ var VoiceEngine = class _VoiceEngine {
         if (!this.echoActive() || (this.usingAec ? this.genuine(text) : this.novelWords(text).length >= 1)) this.options.onPartial(text);
         return;
       }
+      if (this.echoesDispatch(text, true)) {
+        if (this.lastDupPartial !== text.trim()) {
+          this.lastDupPartial = text.trim();
+          this.diag("dup_partial", { reason: "dup_final", text: text.slice(0, 60) });
+        }
+        if (this.pausedAt) {
+          this.diag("overlap_resume", { heldMs: Math.round(this.clock.now() - this.pausedAt), reason: "dup_final" });
+          this.resetOverlap(true);
+        }
+        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();
+          if (this.pausedAt && !this.decideTimer) this.armResume();
           return;
         }
+        if (this.overlapKeptUntil && this.clock.now() < this.overlapKeptUntil) {
+          if (!this.unjudged(txt)) return;
+          this.overlapKeptUntil = 0;
+        }
         if (!this.pausedAt) {
           this.pausedAt = this.clock.now();
           const sinceResumeMs = this.lastResumeAt ? Math.round(this.clock.now() - this.lastResumeAt) : void 0;
@@ -7228,13 +7700,14 @@ var VoiceEngine = class _VoiceEngine {
           }
         }
         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);
+          if (this.options.overlapDecideMs > 0 && this.shortOverlap(txt)) {
+            this.awaitOverlapDecision(txt);
+            return;
+          }
+          this.cedeOverlap("overlap_cede", txt);
           return;
         }
-        this.armResume();
+        if (!this.decideTimer) this.armResume();
         return;
       }
       const barge = this.usingAec ? this.genuine(text) : this.novelWords(text).length >= (this.suspectUntil ? 1 : 2);
@@ -7279,7 +7752,7 @@ var VoiceEngine = class _VoiceEngine {
       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, "");
+      const flat = normWord(this.specPartial);
       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;
@@ -7318,7 +7791,7 @@ var VoiceEngine = class _VoiceEngine {
       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, "");
+      const flat = normWord(p);
       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);
@@ -7406,6 +7879,10 @@ var VoiceEngine = class _VoiceEngine {
       }
       if (pfx && norm2(nw[pw.length - 1]).startsWith(norm2(pw[pw.length - 1]))) return next;
     }
+    if (_VoiceEngine.restates(prev, next)) {
+      this.diag("merge_restated", { dropped: prev.slice(0, 60) });
+      return next;
+    }
     const max = Math.min(pw.length, nw.length);
     for (let k = max; k > 0; k--) {
       let match = true;
@@ -7420,6 +7897,25 @@ var VoiceEngine = class _VoiceEngine {
   static normWord(w) {
     return normWord(w);
   }
+  /** `next` RESTATES the held, unfinished `prev` — the user restarted ("Wo- wait, can you explain more about" →
+   *  "What— wait, can you explain more about that? …", live 20260924-093945, where both landed in the dispatch).
+   *  Keep only the later version. Conservative: prev's words from index i ≤ 2 through its END reappear contiguously
+   *  in next starting at j ≤ 2, that run is ≥4 words and ≥75% of prev. i > 0 with j = 0 is NOT a restart — that is
+   *  an overlapping re-final continuing prev ("Tell me about the" + "about the weather"), deduped by the caller
+   *  keeping prev's head. prev's last word may be a char-prefix (a mid-word endpoint). */
+  static restates(prev, next) {
+    const p = prev.split(/\s+/).map(normWord).filter(Boolean), n = next.split(/\s+/).map(normWord).filter(Boolean);
+    for (let i = 0; i <= 2; i++) {
+      const k = p.length - i;
+      if (k < 4 || k < 0.75 * p.length) return false;
+      for (let j = i === 0 ? 0 : 1; j <= 2 && j + k <= n.length; j++) {
+        let ok = true;
+        for (let x = 0; x < k && ok; x++) ok = x === k - 1 ? n[j + x].startsWith(p[i + x]) : n[j + x] === p[i + x];
+        if (ok) return true;
+      }
+    }
+    return false;
+  }
   /** 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
@@ -7450,18 +7946,71 @@ var VoiceEngine = class _VoiceEngine {
     if (!nSame.startsWith(pLast)) return false;
     return nw.length > pw.length || nSame.length > pLast.length;
   }
+  /** The STT re-emitting (part of) the utterance just dispatched: ≥2 words that form a contiguous run of the dispatched
+   *  words, within DUP_FINAL_MS. A merged dispatch ("Okay." + "Um, check for the recent news in AI.") has its later
+   *  segment come back as a partial/final a beat later — the identical/superset guards miss a PIECE. A human cannot
+   *  re-speak a ≥2-word stretch of what they said within ~1s; one word ("stop") is never treated as a duplicate.
+   *  `partial`: the last word may be cut mid-word ("…news in A"). */
+  echoesDispatch(text, partial = false) {
+    if (!this.lastDispatchWords.length || this.clock.now() - this.lastDispatchAt >= _VoiceEngine.DUP_FINAL_MS) return false;
+    const d = this.lastDispatchWords.map(normWord).filter(Boolean), w = text.trim().split(/\s+/).map(normWord).filter(Boolean);
+    if (w.length < 2 || w.length > d.length) return false;
+    const last = w.length - 1;
+    outer: for (let i = 0; i + w.length <= d.length; i++) {
+      for (let k = 0; k < w.length; k++) if (partial && k === last ? !d[i + k].startsWith(w[k]) : d[i + k] !== w[k]) continue outer;
+      return true;
+    }
+    return false;
+  }
+  /** The agent replied since the dispatch with more than an acknowledgement (ACK_LEADING: "On it.", "Sure, one sec."). */
+  answeredSinceDispatch() {
+    return this.repliedSinceDispatch && !_VoiceEngine.ACK_LEADING.test(this.dispatchReply.replace(/[^a-z ]/gi, " ").replace(/\s+/g, " ").trim().toLowerCase());
+  }
+  lastDupPartial = "";
+  // dup_partial diag once per distinct partial
   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 user's line right after a barge cut our speech (or a re-final growing it), with no terminal punctuation:
+   *  they took the floor mid-thought — Soniox closes on the pause, not the thought (live 20260923-192543: "But isn't it"
+   *  → "…can be done" → "…with boxing" → "…or semantic?" dispatched 4 times). Held like an incomplete utterance. */
+  unfinishedBargeLine(text) {
+    const line = this.bargedSinceDispatch || this.bargedBeforeDispatch && this.refinalizes(text);
+    return line && !/[.?!…]["'”’)\]]*$/.test(text.trim()) && !_VoiceEngine.CONTROL_RE.test(text.trim());
+  }
+  /** A short line that is complete on its own ("Stop", "Yes", "Okay, stop", "go on") — never held as unfinished. */
+  static CONTROL_RE = ((w) => new RegExp(`^${w}(?:[\\s,]+${w})*[.!?\u2026]*$`, "i"))("(?:stop|wait|yes|yeah|yep|no|nope|okay|ok|go on|continue|never ?mind)");
   /** The utterance sounds like the user paused mid-thought (trailing conjunction/filler/comma). */
   looksIncomplete(text) {
-    return _VoiceEngine.TRAIL_RE.test(text.trim());
+    return _VoiceEngine.TRAIL_RE.test(text.trim()) && !_VoiceEngine.CONTROL_RE.test(text.trim());
   }
   handleUtterance(text) {
-    if (this.speaking && (this.ctxOpen || this.pausedAt) && this.overlapCapable) {
+    if (this.speaking && this.echoesDispatch(text)) {
+      this.diag("utterance_drop", { reason: "dup_final", text: text.slice(0, 60) });
+      if (this.pausedAt) {
+        this.diag("overlap_resume", { heldMs: Math.round(this.clock.now() - this.pausedAt), reason: "dup_final" });
+        this.resetOverlap(true);
+      }
+      return;
+    }
+    if (this.decideTimer) {
+      this.decideHeldFinal = this.mergeUtterance(this.decideHeldFinal, text);
+      this.diag("utterance_held", { reason: "overlap_decide", text: text.slice(0, 60) });
+      return;
+    }
+    if (this.overlapKeptUntil) {
+      const kept = this.clock.now() < this.overlapKeptUntil && !this.unjudged(text);
+      this.overlapKeptUntil = 0;
+      if (kept) {
+        this.diag("utterance_drop", { reason: "overlap_kept", text: text.slice(0, 60) });
+        return;
+      }
+    }
+    const ownTail = !this.pausedAt && (this.clock.now() < this.bargeGraceUntil || this.refinalizes(text));
+    if (this.speaking && (this.ctxOpen || this.pausedAt) && this.overlapCapable && !ownTail) {
       this.diag("utterance_drop", { reason: "overlap_noise", text: text.slice(0, 60) });
       this.stt.reset();
       return;
     }
-    if (this.echoActive() && (!this.options.bargeIn || (this.usingAec ? !this.genuine(text) : this.novelWords(text).length < 2))) {
+    if (this.echoActive() && (!this.options.bargeIn || (this.usingAec ? this.echoFinal(text) : this.novelWords(text).length < 2))) {
       this.diag("echo_swallow", { guard: "echo_gate", text: text.slice(0, 60) });
       this.stt.reset();
       return;
@@ -7475,9 +8024,28 @@ var VoiceEngine = class _VoiceEngine {
     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)) {
+    if (this.options.adaptiveEndpointing) {
+      const holdMs = computeHoldMs({
+        transcript: this.pendingUtt,
+        lastAiMessage: this.prevReply,
+        baseMs: this.options.utteranceMergeMs,
+        incompleteMs: this.options.incompleteMergeMs
+      });
+      const tier = endpointTier(this.pendingUtt);
+      this.holdTier = tier;
+      this.diag("hold", { reason: "adaptive", tier, punctuated: tier === 3, holdMs, tail: this.pendingUtt.slice(-40) });
+      if (holdMs > this.options.utteranceMergeMs) {
+        this.options.onHold();
+        if (tier === 1 && this.options.holdFiller && !this.speaking) this.speakFiller(this.options.holdFiller);
+      }
+      if (holdMs <= 0) return this.flushUtterance();
+      this.pendingTimer = this.clock.setTimeout(() => this.flushUtterance(), holdMs);
+      return;
+    }
+    const bargeHold = !this.looksIncomplete(this.pendingUtt) && this.unfinishedBargeLine(this.pendingUtt);
+    if (this.options.incompleteMergeMs && (bargeHold || this.looksIncomplete(this.pendingUtt))) {
       log13.verbose(`hold: incomplete utterance "${this.pendingUtt.slice(-40)}"`);
-      this.diag("hold", { reason: "incomplete", tail: this.pendingUtt.slice(-40) });
+      this.diag("hold", { reason: bargeHold ? "barge_unfinished" : "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);
@@ -7508,9 +8076,13 @@ var VoiceEngine = class _VoiceEngine {
     this.pendingUtt = "";
     const path = this.mergePath;
     this.mergePath = "direct";
+    const heldTier = this.holdTier;
+    this.holdTier = 0;
     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) {
+      const flat = normWord(text);
+      const answered = this.answeredSinceDispatch();
+      const part = flat !== this.lastDispatchFlat && !answered && this.echoesDispatch(text);
+      if (part || flat && flat === this.lastDispatchFlat && !answered && this.clock.now() - this.lastDispatchAt < _VoiceEngine.DUP_FINAL_MS) {
         log13.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;
@@ -7521,22 +8093,121 @@ var VoiceEngine = class _VoiceEngine {
         this.diag("utterance_drop", { reason: "refinalized", text: text.slice(0, 60) });
         this.lastDispatchFlat = flat;
         this.lastDispatchWords = text.trim().split(/\s+/);
+        this.lastDispatchText = text;
         return;
       }
+      const meta = refinal ? { supersedes: this.lastDispatchText } : void 0;
       this.lastDispatchFlat = flat;
       this.lastDispatchWords = text.trim().split(/\s+/);
+      this.lastDispatchText = text;
       this.lastDispatchAt = this.clock.now();
       this.repliedSinceDispatch = false;
+      this.dispatchReply = "";
       this.lastDispatchWasQuestion = /\?\s*$/.test(text);
+      this.bargedBeforeDispatch = refinal ? this.bargedBeforeDispatch || this.bargedSinceDispatch : this.bargedSinceDispatch;
+      this.bargedSinceDispatch = false;
+      this.dispatchRefinal = refinal;
+      if (!refinal) this.ackSpent = false;
       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);
+      this.diag("dispatch", { text, path: refinal ? "refinalized" : path, heldTier, question: this.lastDispatchWasQuestion, ...this.bargedBeforeDispatch ? { barged: true } : {} });
+      this.options.onUtterance(text, meta);
     }
   }
   get overlapCapable() {
     return this.usingAec && this.options.overlapPause && !!this.player.pause && !!this.player.resume;
   }
+  /** Stop/question words that make an overlap an obvious barge — never held for a host decision. */
+  static OVERLAP_CEDE_WORDS = /* @__PURE__ */ new Set([
+    "stop",
+    "wait",
+    "no",
+    "hold",
+    "hang",
+    "pause",
+    "quiet",
+    "enough",
+    "shut",
+    "cancel",
+    "what",
+    "why",
+    "how",
+    "who",
+    "when",
+    "where",
+    "which"
+  ]);
+  /** A short, non-urgent overlap: the kind a listener cue or reaction takes (see overlapDecideMs). */
+  shortOverlap(text) {
+    const w = this.words(text);
+    return w.length <= this.options.overlapDecideMaxWords && !/\?/.test(text) && !w.some((x) => _VoiceEngine.OVERLAP_CEDE_WORDS.has(x));
+  }
+  /** Cede the floor to an overlap: interrupt, tell the host, then dispatch a final that was held while deciding. */
+  cedeOverlap(trigger, txt) {
+    const phase = this.ctxOpen ? "speaking" : "drain";
+    const held = this.decideHeldFinal;
+    this.decideHeldFinal = "";
+    this.diag("barge_in", { phase, trigger, novel: this.novelWords(txt).length, total: this.words(txt).length });
+    this.interrupt();
+    this.options.onBargeIn(phase);
+    if (held) this.handleUtterance(held);
+  }
+  /** Wait (bounded) for the host's verdict. `fresh` = a re-decision on grown text: it gets its own window — the host
+   *  was only just asked about it (live: "Oh," → "Oh, that" → "Oh, that— that's new" outgrew every verdict, and the
+   *  first window ran out mid-chase, ceding a reaction Jev kept) — but the whole hold is capped at 3× the window. */
+  awaitOverlapDecision(txt, fresh = false) {
+    if (this.decideTimer && !fresh) return;
+    if (this.resumeTimer) {
+      this.clock.clearTimeout(this.resumeTimer);
+      this.resumeTimer = null;
+    }
+    if (this.decideTimer) this.clock.clearTimeout(this.decideTimer);
+    const now3 = this.clock.now(), ms = this.options.overlapDecideMs;
+    if (!this.decideSince) this.decideSince = now3;
+    const wait = Math.min(ms, this.decideSince + 3 * ms - now3);
+    this.diag("overlap_await", { text: txt.slice(0, 60), ms: wait });
+    this.decideTimer = this.clock.setTimeout(() => {
+      this.decideTimer = null;
+      if (this.pausedAt) this.cedeOverlap("overlap_decide_timeout", this.lastOverlapPartial || txt);
+    }, Math.max(0, wait));
+  }
+  /** Words in `text` the host's keep_talking verdict never covered (the overlap grew after it judged). */
+  unjudged(text) {
+    const seen = new Set(this.words(this.overlapKept));
+    return this.words(text).some((w) => !seen.has(w));
+  }
+  /** The host's verdict on the overlap the engine is holding (overlapDecideMs, or any live overlap pause):
+   *  'yield' cedes the floor (a final that landed meanwhile is dispatched); 'keep_talking' resumes playback and
+   *  absorbs the rest of THAT reaction — `heard`, the text the verdict judged (default: the live partial); its final
+   *  is dropped. Words beyond `heard` are a new overlap, decided afresh: if the partial/final has already grown past
+   *  it, the hold stays and `overlap_pause` is re-emitted for a new verdict (bounded by overlapDecideMs, else it
+   *  cedes; a re-decision gets its own window, the whole hold capped at 3× it) and this returns false. Also false when no overlap hold is live (the engine already decided). */
+  decideOverlap(choice, heard) {
+    if (!this.pausedAt || !this.speaking) return false;
+    if (choice === "yield") {
+      this.cedeOverlap("host_yield", this.lastOverlapPartial);
+      return true;
+    }
+    this.overlapKept = heard?.trim() || this.lastOverlapPartial;
+    const grown = this.decideHeldFinal || this.lastOverlapPartial;
+    if (this.unjudged(grown)) {
+      if (!(this.options.overlapDecideMs > 0 && this.shortOverlap(grown))) {
+        this.cedeOverlap("overlap_cede", grown);
+        return false;
+      }
+      this.diag("overlap_pause", { text: grown.slice(0, 60), redecide: true });
+      this.awaitOverlapDecision(grown, true);
+      return false;
+    }
+    const held = this.decideHeldFinal;
+    this.decideHeldFinal = "";
+    this.diag("overlap_resume", { heldMs: Math.round(this.clock.now() - this.pausedAt), reason: "host_keep" });
+    if (held) this.diag("utterance_drop", { reason: "overlap_kept", text: held.slice(0, 60) });
+    this.overlapKeptUntil = held ? 0 : this.clock.now() + 4e3;
+    this.resetOverlap(true);
+    this.lastResumeAt = 0;
+    return true;
+  }
   armResume() {
     if (this.resumeTimer) this.clock.clearTimeout(this.resumeTimer);
     this.resumeTimer = this.clock.setTimeout(() => {
@@ -7552,6 +8223,20 @@ var VoiceEngine = class _VoiceEngine {
       this.clock.clearTimeout(this.resumeTimer);
       this.resumeTimer = null;
     }
+    if (this.decideTimer) {
+      this.clock.clearTimeout(this.decideTimer);
+      this.decideTimer = null;
+    }
+    this.decideSince = 0;
+    const held = this.decideHeldFinal;
+    this.decideHeldFinal = "";
+    if (held) {
+      this.diag("utterance_release", { reason: "overlap_hold_exit", text: held.slice(0, 60) });
+      this.pendingUtt = this.mergeUtterance(this.pendingUtt, held);
+      if (this.pendingTimer) this.clock.clearTimeout(this.pendingTimer);
+      this.pendingTimer = this.clock.setTimeout(() => this.flushUtterance(), 0);
+    }
+    if (this.pausedAt) this.diag("overlap_end", { resumed: resume, heldMs: Math.round(this.clock.now() - this.pausedAt) });
     if (this.pausedAt && resume) {
       this.player.resume?.();
       this.lastResumeAt = this.clock.now();
@@ -7617,7 +8302,8 @@ var SentenceCoalescer = class _SentenceCoalescer {
   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;
+    const decimal = (i) => this.buf[i] === "." && /\d/.test(this.buf[i - 1] ?? "") && (i + 1 === this.buf.length || /\d/.test(this.buf[i + 1]));
+    for (let i = 0; i < this.buf.length; i++) if (_SentenceCoalescer.isEnd(this.buf[i]) && !decimal(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();
@@ -7632,9 +8318,14 @@ var SentenceCoalescer = class _SentenceCoalescer {
 };
 var SpokenSplitter = class {
   buf = "";
-  inSpoken = false;
+  open = false;
   /** True once any spoken char has ever been emitted (drives the no-spoken fallback). */
   spokeAny = false;
+  /** Inside a `<spoken>` block after the last feed. Once it is false, a caller coalescing sentences can flush: nothing
+   *  more of that block is coming (a held "…in 2026." would otherwise wait for the next spoken text or the stream end). */
+  get inSpoken() {
+    return this.open;
+  }
   /** Feed a delta; returns the spoken/detail spans completed by this chunk (either may be ''). */
   feed(delta) {
     this.buf += delta;
@@ -7648,26 +8339,26 @@ var SpokenSplitter = class {
     let spoken = "";
     let detail = "";
     while (this.buf.length) {
-      const tag = this.inSpoken ? CLOSE : OPEN;
+      const tag = this.open ? CLOSE : OPEN;
       const idx = this.buf.indexOf(tag);
       if (idx >= 0) {
         const text2 = this.buf.slice(0, idx);
-        if (this.inSpoken) spoken += text2;
+        if (this.open) spoken += text2;
         else detail += text2;
         this.buf = this.buf.slice(idx + tag.length);
-        this.inSpoken = !this.inSpoken;
+        this.open = !this.open;
         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;
+      if (this.open) spoken += text;
       else detail += text;
       this.buf = this.buf.slice(holdStart);
       break;
     }
     if (final && this.buf) {
-      if (this.inSpoken) spoken += this.buf;
+      if (this.open) spoken += this.buf;
       else detail += this.buf;
       this.buf = "";
     }
@@ -7682,7 +8373,11 @@ var now = () => performance.now();
 var SonioxSTTOptions = class {
   auth = "";
   source;
-  model = "stt-rt-preview";
+  /** `stt-rt-preview` was RETIRED (aliased to the two-generations-old v3 on 2025-10-31), so every
+   *  caller that never set this was silently running an old model while the alias kept it working —
+   *  the failure mode of a default that is a moving vendor pointer. Pin a real version instead;
+   *  `stt-rt-v5` is live today (verified against GET https://api.soniox.com/v1/models). */
+  model = "stt-rt-v5";
   languageHints = ["en"];
   /** Client-side endpoint: finalized text + no new tokens for this long = utterance (don't wait for
    *  Soniox's semantic <end>, which adds 0.5-1.5s — the difference between ping-pong and lag). */
@@ -8055,6 +8750,15 @@ function base64ToBytes(b64) {
   return out;
 }
 
+// node_modules/@bod.ee/voice/src/adapters/fish.ts
+var log16 = forComponent2("FishTTS");
+
+// node_modules/@bod.ee/voice/src/adapters/grok.ts
+var log17 = forComponent2("GrokTTS");
+
+// node_modules/@bod.ee/voice/src/adapters/grok-stt.ts
+var log18 = forComponent2("GrokSTT");
+
 // src/voice/engine.ts
 init_logging();
 configureLogging((name) => {
@@ -8063,8 +8767,158 @@ configureLogging((name) => {
   return { debug: at("debug"), verbose: at("verbose"), info: at("info"), warn: at("warn"), error: at("error") };
 });
 
+// src/voice/instinct.ts
+init_logging();
+var log19 = forComponent("Instinct");
+var ACK_SITUATIONS = {
+  hard_question: `a question that takes real thought, judgment or looking something up ("what's the biggest takeaway?", "how should I structure this?")`,
+  simple_question: 'a quick question with an instant, obvious answer ("how are you?", "what time is it?", "can you hear me?")',
+  emotional_bad: "they share something bad, sad, painful, worrying or frustrating",
+  emotional_good: "they share good news, excitement, relief or pride",
+  challenge: `they doubt, question or push back on what you just said ("are you sure?", "why do you say that?", "that doesn't sound right")`,
+  surprise: `they react with surprise or disbelief to what you said ("oh, that's new", "really?", "no way", "oh.")`,
+  agreement: `they agree with you, confirm, or tell you to go on ("exactly", "yes, that's it", "okay, so continue")`,
+  goodbye: "they are wrapping up the conversation or saying goodbye",
+  command: 'a request or instruction for you to do, find, check or tell them something ("tell me the news", "check my calendar")',
+  silent: 'ONLY when nothing was really said yet: an unfinished fragment or false start, a mic check or count ("one, two"), a bare greeting or filler ("hey", "um")'
+};
+var INTENT_ACK_OVER = {
+  stop: Object.keys(ACK_SITUATIONS).filter((s) => s !== "silent"),
+  steer: ["command"],
+  resume: ["agreement", "silent"],
+  aside: []
+};
+function interruptionNote(cut, intent) {
+  const full = cut.full.trim();
+  let at = Math.min(cut.heard.length, cut.full.length);
+  if (/\S/.test(cut.full[at] ?? "") && /\S/.test(cut.full[at - 1] ?? "")) at = cut.full.lastIndexOf(" ", at) + 1;
+  const heardWords = cut.full.slice(0, at).trim().split(/\s+/).filter(Boolean).length;
+  const unheard = cut.full.slice(at).trim();
+  const landed = heardWords < 4 ? "They cut in almost at once \u2014 treat all of it as unsaid." : `They heard everything before this part. They missed the rest of it: "${unheard}".`;
+  const how = {
+    resume: "They did not ask anything new. Carry on with the part they missed \u2014 no restart, no apology.",
+    aside: "It was an aside. Answer it briefly FIRST, then finish the part they missed, adjusted to anything they just said. Say each point once: skip whatever they already heard and whatever your answer just covered.",
+    steer: "They steered away. Follow their new direction; carry over only what still matters from your unfinished point, or drop it.",
+    stop: "They want you to stop. Do not resume; at most a few words of acknowledgement.",
+    unknown: "Decide like a person would: if it was an aside, answer it and then finish your point; if they steered away, follow them and drop or adapt the rest."
+  };
+  return `
+[the user interrupted you mid-speech. You were saying: "${full}" ${landed} ${how[intent ?? "unknown"]} Just talk, like a person picking the thread back up: never tell them what they heard or missed, never say where you were cut off, and never quote your earlier words back. If their words are still an unfinished fragment, call Hold instead of answering.]`;
+}
+
+// src/voice/unsaid.ts
+init_logging();
+var log20 = forComponent("Unsaid");
+var STOP2 = new Set("that this with have from they them their there then than what when were will would your about into just also been some only over more most very which while after before because these those does here".split(" "));
+var contentStems = (s) => (s.toLowerCase().match(/[a-z0-9']+/g) ?? []).filter((w) => w.length >= 4 && !STOP2.has(w)).map((w) => w.slice(0, 4));
+var SAID_OVERLAP = 0.6;
+var UNSAID_OVERLAP = 0.25;
+var CONVEYED_MIN = 0.3;
+function splitClauses(text) {
+  return text.split(/(?<=[.!?…])\s+|(?<=;)\s+|(?<=,)\s+(?=(?:and|but)\b)/i).map((s) => s.trim()).filter((s) => contentStems(s).length > 0);
+}
+var overlap = (clause, said) => {
+  const w = contentStems(clause);
+  return w.filter((x) => said.has(x)).length / w.length;
+};
+var INSTRUCTIONS = "A voice assistant was interrupted mid-delivery; ASSISTANT_SAID is what it then said aloud. Did the MAIN POINT of this clause of the unheard delivery reach the listener through ASSISTANT_SAID \u2014 would hearing the clause too add nothing important? Different words, casual phrasing, rounder numbers, or a missing minor detail (a name, an exact figure) still count as conveyed. Not conveyed only when the clause's main point is absent from ASSISTANT_SAID, even if a neighbouring point is there.";
+async function unsaidClauses(pieces, spoken, decider, timeoutMs = 5e3) {
+  const said = new Set(contentStems(spoken));
+  const open = splitClauses(pieces.join(" ")).map((c) => ({ c, r: overlap(c, said) })).filter((x) => x.r < SAID_OVERLAP);
+  if (!open.length) return [];
+  const fallback = () => open.filter((x) => x.r < UNSAID_OVERLAP).map((x) => x.c);
+  if (!decider) return fallback();
+  const state = { assistant_said: spoken };
+  const questions = {};
+  open.forEach((x, i) => {
+    state[`c${i}`] = x.c;
+    questions[`c${i}`] = { type: "noul", instructions: `${INSTRUCTIONS} The clause is c${i}.`, criteria: { true: `the main point of c${i} reached the listener`, false: `the main point of c${i} is missing` } };
+  });
+  let timer;
+  try {
+    const { answers } = await Promise.race([
+      decider.decide({ state, questions }),
+      new Promise((_, rej) => {
+        timer = setTimeout(() => rej(new Error(`no verdict in ${timeoutMs}ms`)), timeoutMs);
+      })
+    ]);
+    return open.filter((_, i) => {
+      const p = Number(answers[`c${i}`]?.noul);
+      if (!Number.isFinite(p)) throw new Error(`no noul for c${i}`);
+      return p < CONVEYED_MIN;
+    }).map((x) => x.c);
+  } catch (e) {
+    log20.warn(`unsaid judge failed \u2014 only near-zero-overlap clauses count as unsaid: ${e.message}`);
+    return fallback();
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// src/voice/leak.ts
+var TOOL = String.raw`(?:QuickLook|TaskStatus|CancelTask|AnswerTask|ExitSession|Act|Think|Hold(?! on\b))`;
+var SUSPECT = [
+  /\b(?:user|assistant)\b/i,
+  /\b(?:instructions?|guidelines?|polic(?:y|ies)|system prompt|developer (?:message|instructions?|prompt))\b/i,
+  new RegExp(String.raw`\b${TOOL}\b`),
+  /\bwe (?:need to|have to|should|must|ought to)\b|(?:^|[.!?]\s*)(?:need to|should|must|let's)\b/i,
+  /\bi (?:need to|have to|should|must) (?:respond|reply|answer|output|produce|comply|acknowledge|say|ask|greet|call|use|dispatch|wait|keep|avoid|not)\b/i,
+  /\b(?:respond|reply|output|produce|comply|acknowledge?)\w*\b/i,
+  /\bwe(?: have|'ve)\b|\bwe (?:already )?(?:responded|replied|dispatched|used|called|did|gave|said|asked)\b/i,
+  /\bno (?:further|more|other)\b/i,
+  /\[\s*task\b|\bt\d+\b|\bwait(?:ing)? for (?:the )?(?:events?|results?|task)\b/i,
+  /\w\s*\{\s*"|\bwhat:\s*"/,
+  /\b(?:last|previous) (?:response|reply|message|turn)\b|\bthe (?:conversation|transcript|context)\b/i
+];
+var STRICT = [
+  // the listener as a third-person subject opening the sentence ("The user wants…", telegraphic "User wants…")
+  /^(?:the )?user(?:'s)? (?:asks|asked|wants|wanted|said|says|is (?:asking|saying|speaking|referring|requesting)|just (?:said|asked)|requests|requested|mentioned|seems|keeps|repeated|typed|provided|expects|explicitly)\b/i,
+  /\b(?:if|when|since|because) user (?:is|keeps|wants|says|said|asks|asked|seems)\b/i,
+  /\bwe have (?:an? )?(?:user (?:who|request|message|asking|saying)|conversation (?:where|with)|new user message)\b|^we have task\b/i,
+  /\bthe assistant(?:'s (?:context|last|previous) (?:response|reply|turn|message)| (?:responded|replied) with)\b/i,
+  // planning its own reply
+  /\b(?:we|i) (?:need to|have to|should|must) (?:respond|reply|answer)(?:\s*:|\s+(?:briefly|concisely|accordingly|according to|appropriately|to the user|with (?:a |the )?(?:brief|short|result|acknowledg)))/i,
+  /\b(?:we|i) (?:need to|should|must) output\b|^(?:we|i) must comply[.!]?$/i,
+  /\bno (?:further|more|other) (?:response|reply|output)s? (?:is )?(?:needed|required|necessary)\b/i,
+  /\bwe(?: have|'ve)? (?:already )?(?:responded|replied)[.!]?$/i,
+  // its own protocol: using its tools, tool-call syntax, task events
+  new RegExp(String.raw`(?:\b[Ww]e(?: need to| should| must| have to| will|'ll)|\b[Ll]et'?s|^[Ss]hould|^[Nn]ow we should) (?:call|use|do|dispatch(?: to)?|invoke) (?:the )?${TOOL}\b`),
+  new RegExp(String.raw`\b(?:[Ww]e (?:called|dispatched)|responded with) ${TOOL}\b|\b${TOOL}\s*\{|\bwhat:\s*"|\b${TOOL} (?:tool )?(?:brief|call|args?|arguments)\b`),
+  /\bwait(?:ing)? for (?:the )?(?:events?|t\d+)\b|\bt\d+ (?:completed|failed)\b|\[\s*task\b/i
+];
+var SENTENCE_END = new RegExp(`[.!?\u2026]+["')\\]]*(?:\\s|(?=\\p{Lu}|\\[))`, "gu");
+var SENTENCE_SPLIT = new RegExp(`(?<=[.!?\u2026]+["')\\]]*)(?:\\s+|(?=\\p{Lu}|\\[))`, "u");
+var clean2 = (s) => s.replace(/\[[a-z_ ]+\]\s*/gi, "").trim();
+function isLeakSuspect(sentence) {
+  const s = clean2(sentence);
+  return SUSPECT.some((re) => re.test(s));
+}
+function isStrictLeak(sentence) {
+  return sentence.split(SENTENCE_SPLIT).some((x) => {
+    const s = clean2(x);
+    return STRICT.some((re) => re.test(s));
+  });
+}
+var JUDGE_INSTRUCTIONS = `This sentence was produced by a voice assistant's reply stream and is about to be read aloud to the user. Is it the assistant's private scratchpad reasoning that leaked out \u2014 talking ABOUT the conversation instead of TO the listener? Leaked reasoning: refers to the listener in the third person ("the user wants\u2026", "user said\u2026"), plans its own reply ("we need to respond\u2026", "we should output\u2026", "I should answer briefly"), cites its own guidelines/instructions, or narrates its internal tool calls and task events (QuickLook, Act, Think, Hold, TaskStatus, "t2 completed") as steps it is taking. Speech: anything said TO the listener \u2014 answers, questions, offers, news, advice, explaining what it can do when asked, even if it mentions a user, an assistant, a policy, instructions, replying, or a tool.`;
+var LEAK_JUDGE_THRESHOLD = 0.6;
+async function judgeLeak(decider, sentence, userSaid) {
+  const { answers } = await decider.decide({
+    state: { what_the_user_just_said: userSaid.slice(-600) || null, sentence_about_to_be_spoken: clean2(sentence) },
+    questions: {
+      q: {
+        type: "noul",
+        instructions: JUDGE_INSTRUCTIONS,
+        criteria: { true: "leaked private reasoning \u2014 must not be spoken", false: "said to the listener \u2014 fine to speak" }
+      }
+    }
+  });
+  const p = Number(answers.q.noul);
+  if (!Number.isFinite(p)) throw new Error("leak judge: no noul in the answer");
+  return p;
+}
+
 // src/duplex.ts
-var log16 = forComponent("DuplexAgent");
+var log21 = 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)})` : "";
@@ -8106,6 +8960,13 @@ var DuplexAgentOptions = class {
   /** 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;
+  /** Judge a post-barge line while a delivery is parked: resume it now, answer an aside and carry it on (the reflex,
+   *  told what was heard — see asideNote), or drop it (steer/stop). Unset → the conservative `isTrivialBarge` allowlist (resume | steer); a throwing judge
+   *  falls back to it too. */
+  bargeIntent;
+  /** Typed-decision model (e.g. ai.libx.js DecideClient → Jev). Judges reflex sentences the leak screen flags as
+   *  SUSPECT (src/voice/leak.ts) — only suspects pay the ~300ms call. Unset → only the strict leak shapes are cut. */
+  decider;
   /** Awaited BEFORE a worker spawns — open a per-task checkpoint frame, audit, etc.
    *  (post-spawn would race the worker's first edits). */
   onTaskStart;
@@ -8114,6 +8975,13 @@ var DuplexAgentOptions = class {
   progressUpdates = false;
   /** Min ms between progress re-voices per task. */
   progressIntervalMs = 25e3;
+  /** Spoken budget of ONE task delivery (chars, ~3 short sentences). Past it the rest is parked — cut at a sentence
+   *  boundary, `spokenOffer` spoken instead — so "go on" continues it once (the parked/resume path) and an aside or
+   *  steer handles it like any parked delivery. The worker is also asked for a short spoken summary + one offer (the
+   *  source); this is the backstop. Live 20260924-093945: ~20s and ~70s monologues whose closing choice went unspoken.
+   *  The full result always folds into the transcript. 0 = unbudgeted. */
+  spokenBudgetChars = 0;
+  spokenOffer = "There's more. Want me to go on?";
   /** 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). */
@@ -8132,20 +9000,30 @@ var DuplexAgentOptions = class {
   /** User-scope memory dir for global facts (type=user/feedback). Forwarded to Remember's routing. */
   memoryUserDir;
 };
+var SESSION_ID_RE = /^\d{8}-\d{6}(?:-[\w-]+)?$/;
 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;
 function nowLine() {
   return `Current date and time: ${(/* @__PURE__ */ new Date()).toLocaleString("en-US", { weekday: "long", year: "numeric", month: "long", day: "numeric", hour: "numeric", minute: "2-digit", timeZoneName: "short" })}`;
 }
+var STOP_INTENT = /\b(stop|cancel|no|nope|nah|never\s?mind|nvm|forget it|drop it|don'?t|quiet|shut up|enough|hold on|wait|pause|hang on|actually)\b/;
 function isTrivialBarge(text) {
   const t = text.trim().toLowerCase().replace(/[.,!?…\s]+$/g, "").replace(/^[.,!?…\s]+/, "");
   if (!t) return false;
-  if (/\b(stop|cancel|no|nope|nah|never\s?mind|nvm|forget it|drop it|don'?t|quiet|shut up|enough|hold on|wait|pause|hang on|actually)\b/.test(t)) return false;
+  if (STOP_INTENT.test(t)) return false;
   const core = t.replace(/^(?:oh|um+|uh+|er+|hmm+|ah+|well|so|okay|ok|yeah|yep)[\s,]+/, "").trim();
   return /^(?:oh|um+|uh+|er+|hmm+|ah+|sorry|oops|whoops|my bad|pardon|excuse me|apologies|go on|go ahead|continue|keep going|carry on|as you were|please continue|you were saying|sorry go on|sorry continue|go on then|go on please)$/.test(core || t);
 }
-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. Exactly ONE short line: never stack a second acknowledgement, and never narrate your own presence or status while waiting ("I\'m here", "let me see", "still checking" right after you already acked). One clean ack then silence reads as competent; repeated check-ins read as nervous.\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 on a genuinely LONG wait you MAY give one brief half-sentence aside, but only occasionally; silence while working is normal and fine (the user knows you are on it). Do NOT narrate every step or re-announce yourself. 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, give one brief status aside and end the turn \u2014 never poll it again and again in a loop. "Still on it" is ONLY for a repeat check on a task you already acknowledged earlier \u2014 NEVER as the ack when you first dispatch work ("still" is wrong when nothing was running yet; use a fresh "on it"/"got it, checking" instead). 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.';
+function isOfferAcceptance(text) {
+  const t = text.trim().toLowerCase().replace(/[.,!?…]+/g, " ").replace(/\s+/g, " ").trim();
+  if (!t || STOP_INTENT.test(t)) return false;
+  const core = t.replace(/^(?:oh|um+|uh+|well|so|okay|ok|alright)\s+/, "");
+  return /^(?:(?:yes|yeah|yep|yup|sure|ok|okay|alright)(?: please| sure| go on| go ahead| tell me more| do it| why not)?|please|please do|sure thing|go for it|do it|more|tell me more|what else|and then|sounds good|absolutely|definitely|of course|why not|i'?d like that|let'?s hear it|let'?s do it)$/.test(core || t);
+}
+var isQuestion = (s) => /\?["'”’)\]]*$/.test(s.trim());
+var OFFER_OVERRUN = 150;
+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. Exactly ONE short line: never stack a second acknowledgement, and never narrate your own presence or status while waiting ("I\'m here", "let me see", "still checking" right after you already acked). One clean ack then silence reads as competent; repeated check-ins read as nervous.\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 on a genuinely LONG wait you MAY give one brief half-sentence aside, but only occasionally; silence while working is normal and fine (the user knows you are on it). Do NOT narrate every step or re-announce yourself. 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 exists ONLY once the task finishes (the worker speaks it, and `TaskStatus` then returns it); 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, give one brief status aside and end the turn \u2014 never poll it again and again in a loop. "Still on it" is ONLY for a repeat check on a task you already acknowledged earlier \u2014 NEVER as the ack when you first dispatch work ("still" is wrong when nothing was running yet; use a fresh "on it"/"got it, checking" instead). 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).`;
@@ -8160,14 +9038,22 @@ var DuplexAgent = class _DuplexAgent {
    *  (TaskRecord.createdTurn) so parking can tell a prior-topic task from the current turn's fresh one. */
   turn = 0;
   pendingEvents = [];
-  /** Spoken text of parked deliveries that have SETTLED, awaiting a trivial-barge resume decision on the
-   *  next turn (a substantive turn clears it — the result stays in the transcript, recoverable by asking). */
+  /** THE parked delivery: every piece the user has NOT heard, in speaking order — the unheard rest a barge cut out of
+   *  the voice queue (parkCutDelivery) followed by each segment a barge-parked task produced since (deliverSegment).
+   *  Nothing already voiced is ever added, so a resume never repeats what was heard. The next line's barge intent
+   *  decides: resume → spoken verbatim, aside → handed to the reflex to carry on after its answer (asideNote) — both
+   *  send the barge-parked tasks live again; steer/stop → cleared, and those tasks
+   *  are moved on from (the full result stays in the transcript, recoverable by asking). `task` = the owner, so a
+   *  task whose outcome goes to an integration turn takes its pieces back (dropParked). */
   parkedRedeliver = [];
-  /** A trivial barge arrived while a parked delivery was STILL RUNNING → resume it the moment it settles. */
-  awaitTrivialRedeliver = false;
-  /** Set by a SUBSTANTIVE turn after a barge: the user moved on, so a parked delivery that settles LATER
-   *  must NOT arm a resume (else a much-later "go on" replays a stale result). Reset by a fresh barge. */
-  suppressParkedResume = false;
+  /** parkedRedeliver length when the last barge parked (parkInFlightDeliveries): the cut it hands over later
+   *  (parkCutDelivery) was voiced BEFORE anything parked since, so it is inserted here. */
+  bargeMark = 0;
+  /** The last barge cut a REFLEX reply (parkCutDelivery): a "go on" is then the reflex's to answer — it runs a normal
+   *  turn (the host's interruption note continues the reply), and only then does the parked delivery resume. */
+  reflexCut = false;
+  /** Recent live task segments → their task id: attributes a cut delivery (parkCutDelivery) to the task that spoke it. */
+  voicedBy = /* @__PURE__ */ new Map();
   /** 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
@@ -8200,6 +9086,24 @@ var DuplexAgent = class _DuplexAgent {
   // chars of reflexBuf already forwarded to the host/TTS
   fabricationCut = false;
   // reflex emitted a reserved [task …] marker → suppress its tail
+  leakCuts = [];
+  // heads of analysis-register leaks cut this turn — scrubbed from the transcript at turn end
+  leakStep = false;
+  // the CURRENT step's tail is muted by a leak cut (the next step speaks again, unlike a fabricated marker)
+  leakHit = false;
+  // this turn (or its repair) had a leak cut — the dead-air fallback must not blame the user
+  stepMarks = [];
+  // reflexBuf offsets where a step ended (its text is complete there)
+  leakVerdicts = /* @__PURE__ */ new Map();
+  // judged suspect sentences this turn (true = leak)
+  judging;
+  // the in-flight leak judge (one at a time — the gate is sequential)
+  turnGen = 0;
+  // bumped whenever the gated stream is replaced — a late verdict for an old one is dropped
+  turnSpoken = "";
+  // reflex text actually forwarded to the host this turn
+  turnBase = 0;
+  // transcript length at turn start (scope for the leak scrub)
   /** 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
@@ -8248,7 +9152,8 @@ var DuplexAgent = class _DuplexAgent {
       ...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 : "") + `
+    const prompt = VOICE_SYSTEM_PROMPT.replace("{{MEMORY_SLOT}}", memSlot).replace("{{THINK_SLOT}}", thinkSlot).replace("{{WORKER_WEB}}", workerWeb + workerMcp) + (o.quickLook?.sessions ? `
+Past conversations with this user are saved. When they refer to an EARLIER conversation or session ("last time", "the previous session", "you already did it before", "earlier today"), call QuickLook what:"sessions" (then what:"sessions" with path:"<id>" to read one) BEFORE answering \u2014 never say it does not exist without checking. Report only what the recap says: if it does not say why something happened, say you don't know \u2014 never guess a motive.` : "") + (o.voiceStyle === "conversational" ? "\n" + VOICE_STYLE_CONVERSATIONAL : "") + (o.emotionTags ? "\n" + EMOTION_TAGS_GUIDANCE : "") + `
 ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today", "now", "current", "recent", "latest", "this year" \u2014 to THIS moment. When the user asks about something recent (news, sports, events), they mean near this date, not a well-known past instance; brief your worker with the current year so it searches for what is happening NOW, not a famous older event.`;
     const tools = [
       ...o.reflexOptions?.tools ?? [],
@@ -8269,32 +9174,26 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
           if (this.heldThisTurn) return;
           if (this.fabricationCut) return;
           if (this.turnDispatched && this.spokeBeforeDispatch) return;
-          const msg = ev.message;
-          this.reflexBuf += msg;
-          this.scrubStageDirections();
+          this.reflexBuf += ev.message;
           const m = this.reflexBuf.match(RESERVED_EVENT_MARKER) ?? this.reflexBuf.match(RESERVED_EVENT_OPENER);
           if (m) {
             this.fabricationCut = true;
-            log16.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 });
+            log21.warn(`reflex fabricated a [task \u2026] event in its spoken stream \u2014 cutting it (kept ${m.index} chars)`);
+            this.reflexBuf = this.reflexBuf.slice(0, Math.max(m.index, this.reflexForwarded));
+            this.pumpReflex(true);
             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 });
+          this.pumpReflex(false);
           return;
         }
+        if (ev?.kind === "turn_start" || ev?.kind === "tool_use") {
+          this.stepMarks.push(this.reflexBuf.length);
+          if (this.leakStep) {
+            this.leakStep = false;
+            this.reflexForwarded = this.reflexBuf.length;
+          }
+          this.pumpReflex(false);
+        }
         host.notify?.(ev);
       }
     };
@@ -8328,16 +9227,163 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
     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 });
+  /** Forward what the reflex's spoken-stream gates allow (text_delta → host/TTS; forwarded audio can't be unsent):
+   *  - hold a trailing fragment that could be a `[task` opener split across deltas ("[ta" + "sk"), and an UNCLOSED
+   *    "(" (a stage direction is judged — and dropped — only once its ")" arrives; bounded at 80 chars);
+   *  - the leak gate: whole sentences only, each screened by isLeakSuspect the moment it completes — a strict match
+   *    is cut, any other suspect waits for the decider's verdict (judgeLeak) while the rest queues behind it.
+   *  `final` = the stream is done: release the holds and judge whatever is left as a sentence. Text before a step
+   *  boundary (stepMarks) is complete — no holds, its tail is a sentence. Idempotent; re-run as verdicts land. */
+  pumpReflex(final) {
+    for (; ; ) {
+      if (this.leakStep) return;
+      this.scrubStageDirections();
+      const from = this.reflexForwarded;
+      const buf = this.reflexBuf;
+      const lastMark = Math.max(from, ...this.stepMarks);
+      let upto = buf.length;
+      if (!final && upto > lastMark) {
+        const tail = buf.slice(Math.max(lastMark, upto - 6)).match(/\[\s*t?a?s?k?$/i);
+        if (tail) upto -= tail[0].length;
+        const paren = buf.lastIndexOf("(");
+        if (paren >= lastMark && !buf.includes(")", paren) && buf.length - paren <= 80) upto = Math.min(upto, paren);
+      }
+      if (upto <= from) return;
+      const region = buf.slice(from, upto);
+      const ends = [...region.matchAll(SENTENCE_END)].map((m) => m.index + m[0].length);
+      for (const k of this.stepMarks) if (k > from && k <= upto) ends.push(k - from);
+      if (final || !ends.length && region.length >= 160) ends.push(region.length);
+      ends.sort((a, b) => a - b);
+      let ok = 0, leak;
+      for (const e of ends) {
+        if (e <= ok) continue;
+        const v = this.leakVerdict(region.slice(ok, e));
+        if (v === void 0) break;
+        if (v) {
+          leak = region.slice(ok, e);
+          break;
+        }
+        ok = e;
+      }
+      this.forwardReflex(from + ok);
+      if (leak === void 0) return;
+      const at = from + ok;
+      this.leakHit = true;
+      this.leakCuts.push(leak.trim().slice(0, 40));
+      log21.warn(`reflex spoke its own analysis ("${leak.trim().slice(0, 40)}\u2026") \u2014 cut before TTS`);
+      this.notify("diag", "analysis_leak", { text: leak.trim().slice(0, 80), at: this.turnSpoken.trim() ? "mid_reply" : "before_speech" });
+      const next = this.stepMarks.find((k) => k > at);
+      if (next === void 0) {
+        this.reflexForwarded = buf.length;
+        this.leakStep = true;
+        return;
+      }
+      this.reflexForwarded = next;
+    }
+  }
+  forwardReflex(to) {
+    const out = this.reflexBuf.slice(this.reflexForwarded, to);
+    this.reflexForwarded = Math.max(this.reflexForwarded, to);
+    if (!out) return;
+    if (out.trim()) this.spokeThisTurn = true;
+    this.turnSpoken += out;
+    this.emitHost({ kind: "text_delta", message: out });
+  }
+  /** Leak verdict for one complete sentence: false = speak, true = cut, undefined = the judge is still out.
+   *  Non-suspects pass free; strict shapes are cut without a call; other suspects go to the decider (if any) —
+   *  one call at a time, cached per turn. A failed/slow judge fails OPEN (speech is never muted on a guess). */
+  leakVerdict(sentence) {
+    const s = sentence.trim();
+    if (!s || !isLeakSuspect(s)) return false;
+    if (isStrictLeak(s)) return true;
+    const decider = this.options.decider;
+    if (!decider) return false;
+    const known = this.leakVerdicts.get(s);
+    if (known !== void 0 || this.judging) return known;
+    const gen = this.turnGen, t0 = performance.now();
+    const userSaid = [...this.voice.transcript].reverse().map((m) => m.role === "user" ? contentText(m.content) : "").find((t) => t && !t.startsWith("[reminder]")) ?? "";
+    let timer;
+    const timeout = new Promise((_, rej) => {
+      timer = setTimeout(() => rej(new Error(`no verdict in ${_DuplexAgent.LEAK_JUDGE_TIMEOUT_MS}ms`)), _DuplexAgent.LEAK_JUDGE_TIMEOUT_MS);
+    });
+    this.judging = Promise.race([judgeLeak(decider, s, userSaid), timeout]).then((p) => {
+      this.notify("diag", "leak_judge", { text: s.slice(0, 80), p: Math.round(p * 100) / 100, ms: Math.round(performance.now() - t0) });
+      return p >= LEAK_JUDGE_THRESHOLD;
+    }, (e) => {
+      log21.warn(`leak judge failed \u2014 speaking the sentence: ${e.message}`);
+      return false;
+    }).then((leak) => {
+      clearTimeout(timer);
+      if (gen !== this.turnGen) return;
+      this.judging = void 0;
+      this.leakVerdicts.set(s, leak);
+      this.pumpReflex(false);
+    });
+    return void 0;
+  }
+  static LEAK_JUDGE_TIMEOUT_MS = 1500;
+  /** The stream is done: settle every pending verdict and release everything the gates still hold. */
+  async drainReflex() {
+    for (; ; ) {
+      this.pumpReflex(true);
+      if (!this.judging) return;
+      await this.judging;
+    }
+  }
+  /** Drop any in-flight judge of the current stream (its verdict must not pump a stream that moved on). */
+  dropJudge() {
+    this.turnGen++;
+    this.judging = void 0;
+  }
+  /** Remove a cut analysis leak from this turn's assistant message(s) — left in, it primes the next turn to
+   *  leak again and reads as something we said. Keeps any legit prefix; drops a message left empty. */
+  scrubLeakFromTranscript() {
+    const keys = this.leakCuts.splice(0);
+    const t = this.voice.transcript;
+    for (const key of keys) {
+      let i = t.length - 1;
+      while (i >= this.turnBase && !(t[i].role === "assistant" && typeof t[i].content === "string" && t[i].content.includes(key))) i--;
+      if (i < this.turnBase) {
+        log21.warn("analysis leak cut, but its text was not found in the transcript to scrub");
+        continue;
+      }
+      const m = t[i];
+      m.content = m.content.slice(0, m.content.indexOf(key)).trimEnd();
+      if (!m.content && !m.tool_calls?.length) t.splice(i, 1);
+    }
+  }
+  /** A Hold turn is silent BY DESIGN: every reflex text after the Hold is muted (voiceHost drops it), so none of it may
+   *  persist either — the transcript is what the agent SAID. Live 20260923-125143 msg 10: the model's reasoning ("We
+   *  need to respond according to guidelines… So we should hold") was saved as an assistant reply and fed every later
+   *  turn. Strips the text of assistant messages after the Hold call (tool calls stay — they happened); a message left
+   *  empty is removed. */
+  scrubHeldText() {
+    if (!this.heldThisTurn) return;
+    const t = this.voice.transcript;
+    let i = this.turnBase;
+    while (i < t.length && !t[i].tool_calls?.some((c) => c.function.name === "Hold")) i++;
+    for (let j = t.length - 1; j > i; j--) {
+      const m = t[j];
+      if (m.role !== "assistant" || !contentText(m.content).trim()) continue;
+      if (m.tool_calls?.length) m.content = "";
+      else t.splice(j, 1);
+    }
+  }
+  /** Shared turn epilogue (user turn, confirmed speculation, re-voice): release held text, scrub a cut leak,
+   *  then repair dead air — unless the turn was ABORTED: the user took the floor (barge-in / Esc), which is
+   *  not dead air, and a nudge would run on the same aborted signal (live: the "[reminder]" landed in the
+   *  transcript as a user turn with no reply, session 20260923-101910 msg 27). */
+  async endTurn(res, fallback) {
+    if (res?.finishReason === "aborted") {
+      this.dropJudge();
+      this.scrubLeakFromTranscript();
+      this.scrubHeldText();
+      return;
+    }
+    await this.drainReflex();
+    this.scrubLeakFromTranscript();
+    this.scrubHeldText();
+    if (this.silentTurn) await this.ackIfSilent(fallback);
   }
   /** 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
@@ -8359,6 +9405,14 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
     this.reflexBuf = "";
     this.reflexForwarded = 0;
     this.fabricationCut = false;
+    this.leakCuts = [];
+    this.leakStep = this.leakHit = false;
+    this.stepMarks = [];
+    this.leakVerdicts.clear();
+    this.turnSpoken = "";
+    this.offerOpen = false;
+    this.dropJudge();
+    this.turnBase = this.voice.transcript.length;
     this.turnFollowUp = false;
     this.voice.options.toolChoice = void 0;
   }
@@ -8370,7 +9424,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
     return {
       preToolUse: (call) => {
         if (this.spec?.state === "pending" && !_DuplexAgent.SPEC_SAFE_TOOLS.has(call.name)) {
-          log16.verbose(`speculation aborted: reflex called ${call.name} on unconfirmed input`);
+          log21.verbose(`speculation aborted: reflex called ${call.name} on unconfirmed input`);
           this.abortSpeculation();
           return { block: true, reason: "Speculative turn aborted." };
         }
@@ -8404,16 +9458,27 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
    *  Wording adapts to whether work was dispatched (an ack) or the inline reply was simply lost. */
   async ackIfSilent(fallback) {
     const dispatched = this.turnDispatched;
+    const reminder = 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.";
+    const base = this.voice.transcript.length;
+    this.fabricationCut = this.leakStep = false;
+    this.reflexBuf = "";
+    this.reflexForwarded = 0;
+    this.stepMarks = [];
+    this.dropJudge();
     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.");
+      await this.voice.send(reminder);
     } catch (e) {
-      log16.warn(`ack nudge failed: ${e instanceof Error ? e.message : e}`);
+      log21.warn(`ack nudge failed: ${e instanceof Error ? e.message : e}`);
     } finally {
       this.nudging = false;
+      const i = this.voice.transcript.findIndex((m, k) => k >= base && m.role === "user" && m.content === reminder);
+      if (i >= 0) this.voice.transcript.splice(i, 1);
+      await this.drainReflex();
+      this.scrubLeakFromTranscript();
     }
     if (!this.spokeThisTurn) {
-      const pool = fallback ? [fallback] : dispatched ? _DuplexAgent.FALLBACK_ACKS : _DuplexAgent.FALLBACK_RETRY;
+      const pool = fallback ? [fallback] : dispatched ? _DuplexAgent.FALLBACK_ACKS : this.leakHit ? _DuplexAgent.FALLBACK_OWN : _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;
@@ -8424,26 +9489,134 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
    *  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?"];
+  static FALLBACK_OWN = ["Sorry, I lost my train of thought there \u2014 give me that one more time?", "Hm, I got tangled up \u2014 ask me that once more?"];
   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) {
-    if (typeof content === "string" && isTrivialBarge(content) && this.hasParkedDelivery()) {
-      if (this.spec) this.abortSpeculation();
-      return this.enqueue(async () => {
-        this.resetTurn();
-        if (!this.redeliverParked()) this.awaitTrivialRedeliver = true;
-        return { text: "", steps: 0, finishReason: "stop", messages: [] };
+   *  speculation first (rolled back silently) and runs a normal turn behind it.
+   *  `opts.id` names the turn; `opts.replaces` names an earlier one this content REPLACES — the voice engine's
+   *  fuller re-finalization of an utterance whose reply had not started ("…previous" → "…previous
+   *  conversation."). The replaced turn is skipped if it has not run yet, else aborted and rolled back out of
+   *  the transcript (kept only if it already dispatched work) — one reply, to the full text. */
+  send(content, opts) {
+    if (opts?.replaces) this.replaceTurn(opts.replaces);
+    const cur = this.voice.options.signal;
+    const ext = cur && cur === this.turnSignal?.own ? this.turnSignal.ext : cur;
+    const rec = opts?.id ? this.trackTurn(opts.id) : void 0;
+    if (rec?.superseded) {
+      this.notify("diag", "turn_replaced", { id: opts.id, ran: false });
+      return Promise.resolve(_DuplexAgent.replacedResult(this.voice.transcript));
+    }
+    const reflexCut = this.reflexCut;
+    this.reflexCut = false;
+    if (typeof content === "string" && this.hasParkedDelivery()) {
+      const fallback = () => isTrivialBarge(content) ? "resume" : "steer";
+      const accepted = this.offerOpen && this.parkedRedeliver.length > 0 && this.parkedRedeliver.every((p) => p.task === this.offer.task) && (isOfferAcceptance(content) || isTrivialBarge(content));
+      const judge = accepted ? void 0 : this.options.bargeIntent;
+      return (accepted ? Promise.resolve("resume") : judge ? judge(content).catch((e) => {
+        log21.warn(`bargeIntent judge failed \u2014 using the allowlist: ${e.message}`);
+        return fallback();
+      }) : Promise.resolve(fallback())).then((intent) => {
+        this.notify("diag", "barge_intent", { intent, text: content.slice(0, 80) });
+        if (intent === "resume" && !reflexCut) return this.resumeParked();
+        if (intent === "aside" || intent === "resume") {
+          const told = intent === "aside" ? [...this.parkedRedeliver] : [];
+          return this.sendTurn(intent === "aside" ? content + this.asideNote(told) : content, true, rec, ext).then(async (r) => {
+            if (r.finishReason === "aborted" || this.heldThisTurn) return r;
+            const missed = unsaidClauses(told.map((p) => p.text), this.turnSpoken, this.options.decider);
+            const turn = this.turn;
+            this.parkedRedeliver = this.parkedRedeliver.filter((p) => !told.includes(p));
+            await this.resumeParked();
+            void missed.then((m) => {
+              const dropped = m.filter((c) => !isQuestion(c)).join(" ").replace(/[,;]$/, ".");
+              if (!dropped || this.turn !== turn) return;
+              this.parkedRedeliver.unshift({ text: dropped, task: told.at(-1)?.task });
+              this.notify("diag", "aside_dropped", { text: dropped.slice(0, 80) });
+            });
+            return r;
+          });
+        }
+        return this.sendTurn(content, false, rec, ext);
       });
     }
+    return this.sendTurn(content, false, rec, ext);
+  }
+  /** Host-named user turns (send opts.id), so a later send can replace one. Bounded; a replace that arrives
+   *  BEFORE its target (the host's dispatch hops can reorder) leaves a pre-superseded record behind. */
+  userTurns = /* @__PURE__ */ new Map();
+  turnSignal;
+  // the combined signal a named turn installed while it runs
+  trackTurn(id) {
+    let rec = this.userTurns.get(id);
+    if (!rec) {
+      rec = { ctl: new AbortController(), done: false, superseded: false };
+      this.userTurns.set(id, rec);
+      if (this.userTurns.size > 32) this.userTurns.delete(this.userTurns.keys().next().value);
+    }
+    return rec;
+  }
+  replaceTurn(id) {
+    const rec = this.trackTurn(id);
+    if (rec.done) {
+      const drop = rec.dropped;
+      rec.dropped = void 0;
+      if (drop?.length) void this.enqueue(async () => {
+        const t = this.voice.transcript;
+        for (const m of drop) {
+          const i = t.indexOf(m);
+          if (i >= 0) t.splice(i, 1);
+        }
+        this.notify("diag", "turn_replaced", { ran: true, rolledBack: true, late: true });
+      });
+      return;
+    }
+    if (rec.superseded) return;
+    rec.superseded = true;
+    rec.ctl.abort();
+  }
+  static replacedResult(messages) {
+    return { text: "", steps: 0, finishReason: "aborted", messages };
+  }
+  /** A turn replaced mid-run: mute whatever it still holds, and erase it from the transcript (the replacing turn
+   *  carries the user's full words) — unless it already dispatched work or SPOKE: the task is real, and the user
+   *  heard those words, so both stay visible to the replacing turn. An aborted stream never reaches the transcript,
+   *  so what was spoken is recorded as the replaced turn's reply. */
+  dropReplacedTurn() {
+    this.fabricationCut = true;
+    this.reflexBuf = this.reflexBuf.slice(0, this.reflexForwarded);
+    this.dropJudge();
+    const spoke = this.turnSpoken.trim();
+    const rolledBack = !this.turnDispatched && !spoke;
+    if (rolledBack) this.voice.transcript.length = this.turnBase;
+    else if (spoke) {
+      const t = this.voice.transcript;
+      const have = t.slice(this.turnBase).filter((m) => m.role === "assistant").map((m) => contentText(m.content)).join(" ");
+      if (!have.includes(spoke)) t.push({ role: "assistant", content: spoke });
+    }
+    this.notify("diag", "turn_replaced", { ran: true, rolledBack, spoke: !!spoke });
+    return _DuplexAgent.replacedResult(this.voice.transcript);
+  }
+  resumeParked() {
+    if (this.spec) this.abortSpeculation();
+    return this.enqueue(async () => {
+      this.resetTurn();
+      this.redeliverParked();
+      for (const t of this.tasks.values()) if (t.status === "running" && t.deliveryParked === "barge") t.deliveryParked = void 0;
+      return { text: "", steps: 0, finishReason: "stop", messages: [] };
+    });
+  }
+  sendTurn(content, keepParked = false, rec, ext) {
     const spec = this.spec;
     if (spec?.state === "pending") {
       if (typeof content === "string" && speculationConfirms(spec.text, content)) {
         spec.state = "confirmed";
         spec.finalText = content;
+        if (rec) {
+          spec.rec = rec;
+          rec.ctl.signal.addEventListener("abort", () => spec.ctl.abort(), { once: true });
+        }
         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) });
@@ -8455,12 +9628,32 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
       await this.initMemory();
       this.resetTurn();
       this.turn++;
-      this.awaitTrivialRedeliver = false;
-      this.parkedRedeliver = [];
-      this.suppressParkedResume = true;
-      const res = await this.voice.send(content);
-      this.flushHeldReflexTail();
-      if (this.silentTurn) await this.ackIfSilent();
+      if (!keepParked) {
+        this.parkedRedeliver = [];
+        for (const t of this.tasks.values()) if (t.deliveryParked === "barge") t.deliveryParked = "moved_on";
+      }
+      if (rec?.superseded) {
+        this.notify("diag", "turn_replaced", { ran: false });
+        return _DuplexAgent.replacedResult(this.voice.transcript);
+      }
+      const signal = rec && (ext ? AbortSignal.any([ext, rec.ctl.signal]) : rec.ctl.signal);
+      if (signal) {
+        this.voice.options.signal = signal;
+        this.turnSignal = { own: signal, ext };
+      }
+      let res;
+      try {
+        res = await this.voice.send(content);
+      } finally {
+        if (signal) {
+          this.voice.options.signal = ext;
+          this.turnSignal = void 0;
+        }
+        if (rec) rec.done = true;
+      }
+      if (rec?.superseded) return this.dropReplacedTurn();
+      if (rec && res.finishReason === "aborted" && !this.turnDispatched && !this.turnSpoken.trim()) rec.dropped = this.voice.transcript.slice(this.turnBase);
+      await this.endTurn(res);
       return res;
     });
   }
@@ -8501,7 +9694,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
       try {
         res = await this.voice.send(spec.text);
       } catch (e) {
-        log16.warn(`speculative turn failed: ${e instanceof Error ? e.message : e}`);
+        log21.warn(`speculative turn failed: ${e instanceof Error ? e.message : e}`);
       } finally {
         this.voice.options.signal = prevSignal;
       }
@@ -8515,7 +9708,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
       if (d === "abort") {
         if (this.voice.transcript.length > base) this.voice.transcript.length = base;
         this.speculativeAbortedCalls++;
-        log16.verbose(`speculation aborted (${this.speculativeAbortedCalls} total): "${spec.text.slice(0, 50)}"`);
+        log21.verbose(`speculation aborted (${this.speculativeAbortedCalls} total): "${spec.text.slice(0, 50)}"`);
         if (this.spec === spec) this.spec = void 0;
         return res ?? empty;
       }
@@ -8527,8 +9720,9 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
         }
       }
       this.spec = void 0;
-      this.flushHeldReflexTail();
-      if (this.silentTurn) await this.ackIfSilent();
+      if (spec.rec) spec.rec.done = true;
+      if (spec.rec?.superseded) return this.dropReplacedTurn();
+      await this.endTurn(res);
       return res ?? empty;
     });
   }
@@ -8557,37 +9751,125 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
    *  superseded topic never talks over the new one (the debt-after-jokes regression). Tasks keep running and
    *  still fold their result into the transcript — recoverable, just not spoken. Returns parked ids (logging).
    *  Does NOT cancel. Two callers, two shapes:
-   *   - BARGE (default): the user interrupted AUDIO. Park EVERY running task (including this turn's) — the
-   *     worker they cut off must stop, whatever turn launched it — and re-arm trivial-barge auto-resume so a
-   *     following "go on" can bring the parked delivery back.
-   *   - SUPERSEDE (`priorTurnsOnly`, `reenableResume:false`, from dispatch()): a new dispatch redirected to
-   *     fresh work. Park only PRIOR-turn tasks so parallel siblings dispatched in the SAME turn don't silence
-   *     each other, and keep them suppressed (the user moved on — don't resurface on a stray "go on"). */
-  parkInFlightDeliveries(reenableResume = true, priorTurnsOnly = false) {
-    if (reenableResume) this.suppressParkedResume = false;
+   *   - BARGE (default): the user interrupted AUDIO. Park EVERY live running task (including this turn's) — the
+   *     worker they cut off must stop, whatever turn launched it — as 'barge', so a following "go on" can bring
+   *     it back. A task the user already moved on from stays moved on: a barge never revives it.
+   *   - SUPERSEDE (`priorTurnsOnly`, `barge:false`, from dispatch()): a new dispatch redirected to fresh work.
+   *     Park only PRIOR-turn live tasks so parallel siblings dispatched in the SAME turn don't silence each other,
+   *     as 'moved_on' (don't resurface on a stray "go on"). */
+  parkInFlightDeliveries(barge = true, priorTurnsOnly = false) {
+    if (barge) {
+      this.bargeMark = this.parkedRedeliver.length;
+      this.reflexCut = false;
+      this.offerOpen = false;
+    }
     const parked = [];
     for (const rec of this.tasks.values())
       if (rec.status === "running" && !rec.deliveryParked && (!priorTurnsOnly || rec.createdTurn < this.turn)) {
-        rec.deliveryParked = true;
+        rec.deliveryParked = barge ? "barge" : "moved_on";
         parked.push(rec.id);
       }
     return parked;
   }
-  /** True while there is a parked delivery to potentially resume: either one already settled (queued) or
-   *  one still running that was parked by a barge. */
+  /** A barge-in cut a worker delivery the VOICE ENGINE was still speaking — the queued utterances it dropped plus the
+   *  unheard rest of the one playing (cli splitCut). It joins the parked delivery AHEAD of whatever parked tasks
+   *  produced since the barge (it was voiced first); the user's next line runs the barge-intent judge — resume it,
+   *  answer an aside and carry it on, or drop it on a steer/stop. `heard` = the cut utterance's part the user DID hear
+   *  (the aside note tells the reflex what was heard vs missed).
+   *  Live 20260923-125143: "Oh, that— that's new." cut an iOS-news delivery and its 6 remaining utterances vanished.
+   *  `reflexCut` = the barge cut a REFLEX reply (the host's cut had a reply): a "go on" then runs the reflex (see send).
+   *  A cut spoken by a task the user moved on from (or whose outcome went to an integration turn) is not parked. */
+  parkCutDelivery(text, reflexCut = false, heard = "") {
+    this.reflexCut = reflexCut;
+    const t = text.trim();
+    if (!t) return;
+    if (this.offer.text && this.offer.text.endsWith(t)) {
+      this.offerOpen = !reflexCut;
+      return;
+    }
+    if (t.split(SENTENCE_SPLIT).every(isQuestion)) return;
+    const first = t.split(/(?<=[.!?])\s/)[0];
+    const task = [...this.voicedBy].reverse().find(([seg]) => t.includes(seg) || first.length >= 16 && seg.includes(first))?.[1];
+    if (task && this.tasks.get(task)?.deliveryParked === "moved_on") return;
+    this.parkedRedeliver.splice(Math.min(this.bargeMark, this.parkedRedeliver.length), 0, { text: t, task, ...heard ? { heard } : {} });
+    this.notify("diag", "delivery_parked", { chars: t.length });
+  }
+  /** One spoken segment of a task's delivery — the ONLY path a worker's speech takes (streamed segments, the settle
+   *  tail, the no-spoken fallback). Live → the voice queue; barge-parked → the parked delivery, in order; superseded
+   *  (the user moved on) → nowhere (the result still folds into the transcript at settle). */
+  deliverSegment(rec, seg) {
+    if (!seg.trim()) return;
+    if (rec) rec.spokenText = (rec.spokenText ? rec.spokenText + " " : "") + seg;
+    if (!rec?.deliveryParked) {
+      const [say, rest] = rec ? this.budgetSplit(rec, seg) : [seg, ""];
+      if (say) {
+        this.offerOpen = false;
+        this.options.host?.notify?.({ kind: "speak_utterance", message: say });
+        if (rec) {
+          this.voicedBy.set(say.trim(), rec.id);
+          if (this.voicedBy.size > 64) this.voicedBy.delete(this.voicedBy.keys().next().value);
+        }
+      }
+      if (!rest || !rec) return;
+      rec.deliveryParked = "barge";
+      this.parkedRedeliver.push({ text: rest, task: rec.id });
+      if (this.options.spokenOffer) {
+        this.offer = { text: rec.capOffer = this.options.spokenOffer, task: rec.id };
+        this.offerOpen = true;
+        this.options.host?.notify?.({ kind: "speak_utterance", message: this.offer.text });
+      }
+      this.notify("diag", "delivery_budget", { task: rec.id, spoke: rec.voicedChars, parked: rest.length });
+    } else if (rec.deliveryParked === "barge") this.parkedRedeliver.push({ text: seg, task: rec.id });
+  }
+  /** Split a delivery segment at the spoken budget (whole sentences; the first sentence always speaks): what to voice
+   *  now, and the rest to park. Marks the budget spent on a cut, so a resumed delivery runs on unbudgeted. */
+  budgetSplit(rec, seg) {
+    const cap = this.options.spokenBudgetChars;
+    if (!cap || rec.budgetSpent) return [seg, ""];
+    const sents = seg.trim().split(SENTENCE_SPLIT);
+    let used = rec.voicedChars ?? 0, n = 0;
+    while (n < sents.length && (!used || used + sents[n].length <= cap)) used += sents[n++].length + 1;
+    const over = sents.slice(n);
+    if (!over.length || over.length === 1 && isQuestion(over[0]) && over[0].length <= OFFER_OVERRUN && used <= cap) {
+      rec.voicedChars = used + (over[0] ? over[0].length + 1 : 0);
+      return [seg, ""];
+    }
+    rec.voicedChars = used;
+    rec.budgetSpent = true;
+    return [sents.slice(0, n).join(" "), sents.slice(n).join(" ")];
+  }
+  /** The cap offer last spoken and the task whose rest it offers — a barge over it is not a delivery to park
+   *  (parkCutDelivery). */
+  offer = { text: "", task: "" };
+  /** The cap offer was the last thing voiced (no delivery or turn has spoken since) — a plain yes accepts it (send). */
+  offerOpen = false;
+  /** The task's outcome now belongs to its integration turn (failed / stopped early): take back its parked pieces and
+   *  keep it from being revived — a "go on" must not replay raw segments of a result the reflex is about to explain. */
+  dropParked(rec) {
+    this.parkedRedeliver = this.parkedRedeliver.filter((p) => p.task !== rec.id);
+    if (rec.deliveryParked) rec.deliveryParked = "moved_on";
+  }
+  /** True while there is a parked delivery the next line may resume: unheard text already parked, or a barge-parked
+   *  task still running (one the user moved on from does not count). */
   hasParkedDelivery() {
-    return this.parkedRedeliver.length > 0 || [...this.tasks.values()].some((t) => t.status === "running" && t.deliveryParked);
-  }
-  /** Speak any settled-and-queued parked delivery now (trivial-barge resume). Returns false if nothing was
-   *  queued yet (the caller then arms awaitTrivialRedeliver so the task resumes the instant it settles). */
+    return this.parkedRedeliver.length > 0 || [...this.tasks.values()].some((t) => t.status === "running" && t.deliveryParked === "barge");
+  }
+  /** The note for an aside over a parked delivery: the same reply-interruption note a cut reflex reply gets
+   *  (interruptionNote), over the delivery as it was being said — the cut utterance's heard part, then every unheard
+   *  piece. Nothing parked yet (the task is still working) → its result simply follows the answer. */
+  asideNote(told) {
+    const rest = told.map((p) => p.text).join(" ").trim();
+    if (!rest) return "\n[you were in the middle of delivering a task result \u2014 answer this briefly; the rest of the result follows right after your answer. If their words are an unfinished fragment, call Hold instead.]";
+    const heard = told[0]?.heard ?? "";
+    return interruptionNote({ full: heard + rest, heard }, "aside");
+  }
+  /** Speak the parked delivery now (resume), in order, and clear it. */
   redeliverParked() {
-    if (!this.parkedRedeliver.length) return false;
-    const text = this.parkedRedeliver.splice(0).join(" ").trim();
-    if (text) {
-      this.options.host?.notify?.({ kind: "speak_utterance", message: text });
-      this.notify("diag", "parked_redelivered", { chars: text.length });
-    }
-    return true;
+    const text = this.parkedRedeliver.splice(0).map((p) => p.text).join(" ").trim();
+    if (!text) return;
+    this.offerOpen = false;
+    this.options.host?.notify?.({ kind: "speak_utterance", message: text });
+    this.notify("diag", "parked_redelivered", { chars: text.length });
   }
   /** Resolve when all queued voice turns AND all in-flight worker tasks have settled (tests, graceful shutdown). */
   async idle() {
@@ -8643,9 +9925,8 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
       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);
+      const res = await this.voice.send(events.join("\n"));
+      await this.endTurn(res, failed ? "Sorry, that didn't work \u2014 the task failed." : void 0);
       this.notify("revoice_done", "");
     });
   }
@@ -8653,13 +9934,14 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
    *  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. */
+  /** Static text snapshot of the last `turns` user/assistant messages (`role: text` lines). */
+  recentExcerpt(turns = this.options.excerptTurns) {
+    return this.voice.transcript.filter((m) => (m.role === "user" || m.role === "assistant") && contentText(m.content).trim()).slice(-turns).map((m) => `${m.role}: ${contentText(m.content)}`).join("\n");
+  }
   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 recent = this.recentExcerpt();
     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." : "") : "";
+    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.spokenBudgetChars ? `Speak a SHORT summary only: at most three short sentences with the one thing that matters most, then ONE short offer that names what else you have, as a question they can answer in a word \u2014 under ${this.options.spokenBudgetChars} characters in all, the offer included. Everything else stays in your written prose (it is kept and they can ask for it); spoken text past that budget is cut and held until they ask. ` : "") + `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 `${nowLine()}.
 
 ` + (recent ? `${brief}
@@ -8705,12 +9987,7 @@ ${recent}` : brief) + verify + deliverContract;
       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) return;
-      const r = this.tasks.get(id);
-      if (r) r.spokenText = (r.spokenText ? r.spokenText + " " : "") + seg;
-      if (!r?.deliveryParked) o.host?.notify?.({ kind: "speak_utterance", message: seg });
-    };
+    const speak = (seg) => this.deliverSegment(this.tasks.get(id), seg);
     const coalescer = new SentenceCoalescer();
     const feedSpoken = (s) => {
       const ready = coalescer.feed(s);
@@ -8724,6 +10001,7 @@ ${recent}` : brief) + verify + deliverContract;
         if (ev?.kind === "text_delta" && typeof ev.message === "string") {
           const { spoken, detail } = splitter.feed(ev.message);
           feedSpoken(spoken);
+          if (!splitter.inSpoken) flushSpoken();
           if (detail.trim()) pushTail(detail.trim());
           return;
         }
@@ -8780,7 +10058,7 @@ Another agent just implemented the above. Independently check the CURRENT state
     this.notify("task_verify", `task ${id}: verifying`, { id });
     const cres = await new Agent(checkerOpts).run(checkBrief);
     if (cres.finishReason !== "stop") {
-      log16.warn(`task ${id}: verify inconclusive (${cres.finishReason})`);
+      log21.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;
@@ -8811,7 +10089,7 @@ Another agent just implemented the above. Independently check the CURRENT state
     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;
+      return rec && rec.status === "running" && !rec.deliveryParked && Date.now() - lastAt >= this.options.progressIntervalMs ? rec : void 0;
     };
     const emit = (rec, line, call) => {
       lastAt = Date.now();
@@ -8916,7 +10194,7 @@ Another agent just implemented the above. Independently check the CURRENT state
     rec.status = "done";
     rec.result = res.text;
     const incomplete = res.finishReason !== "stop" && res.finishReason !== "empty";
-    log16.verbose(`task ${id} done (${res.steps} steps${incomplete ? `, INCOMPLETE: ${res.finishReason}` : ""})`);
+    log21.verbose(`task ${id} done (${res.steps} steps${incomplete ? `, INCOMPLETE: ${res.finishReason}` : ""})`);
     this.notify("task_done", `task ${id} (${rec.label}) completed`, {
       id,
       text: res.text,
@@ -8928,46 +10206,39 @@ Another agent just implemented the above. Independently check the CURRENT state
     });
     if (incomplete) {
       if (this.foldIfSuperseded(rec, res.text)) return;
+      this.dropParked(rec);
       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.deliveryParked && !this.suppressParkedResume) {
-      const gist = (rec.spokenText ?? "").trim() || res.text.trim();
-      if (gist) {
-        if (this.awaitTrivialRedeliver) {
-          this.awaitTrivialRedeliver = false;
-          this.options.host?.notify?.({ kind: "speak_utterance", message: gist });
-          this.notify("diag", "parked_redelivered", { chars: gist.length });
-        } else this.parkedRedeliver.push(gist);
-      }
-    }
-    if (!rec.splitter?.spokeAny && res.text.trim() && !rec.deliveryParked)
-      this.options.host?.notify?.({ kind: "speak_utterance", message: res.text });
+    if (tail?.spoken) this.deliverSegment(rec, tail.spoken);
+    if (!rec.splitter?.spokeAny && res.text.trim()) this.deliverSegment(rec, res.text);
+    if (res.text.trim()) this.voice.transcript.push({ role: "assistant", content: res.text + (rec.capOffer ? `
+
+(Said aloud in place of the rest of the spoken summary: "${rec.capOffer}")` : "") });
   }
   onWorkerFailed(id, err) {
     this.failTask(this.tasks.get(id), err instanceof Error ? err.message : String(err));
   }
-  /** A delivery the user has SUPERSEDED — parked AND moved on (suppressParkedResume, set by a redirect) —
+  /** A delivery the user has SUPERSEDED — moved on from (deliveryParked 'moved_on', set by a redirect) —
    *  must not hijack the voice when it settles late (partial or failed): that would talk over the new topic
    *  and, worse, auto-escalate work the user already abandoned. Fold a recoverable note into the transcript
    *  instead (the reflex can surface it if asked) and report true so the caller skips queueRevoice. A merely
-   *  barge-parked task (suppressParkedResume false — a "go on" may still resume it) is NOT superseded: it
+   *  barge-parked task ('barge' — a "go on" may still resume it) is NOT superseded: it
    *  keeps the normal surfacing path so a failure the user still cares about is not swallowed. */
   foldIfSuperseded(rec, note) {
-    if (!(rec.deliveryParked && this.suppressParkedResume)) return false;
+    if (rec.deliveryParked !== "moved_on") return false;
     if (note.trim()) this.voice.transcript.push({ role: "assistant", content: note });
-    log16.verbose(`task ${rec.id} settled but superseded (${rec.status}) \u2014 folded into transcript, not voiced`);
+    log21.verbose(`task ${rec.id} settled but superseded (${rec.status}) \u2014 folded into transcript, not voiced`);
     return true;
   }
   failTask(rec, msg) {
     this.dropAsk(rec.id);
     rec.status = "error";
     rec.result = msg;
-    log16.warn(`task ${rec.id} failed: ${msg}`);
+    log21.warn(`task ${rec.id} failed: ${msg}`);
     this.notify("task_error", `task ${rec.id} (${rec.label}) failed: ${msg}`);
     if (this.foldIfSuperseded(rec, `The "${rec.label}" task failed: ${msg}`)) return;
+    this.dropParked(rec);
     this.queueRevoice(this.integrationPrompt(rec, "error", msg, "error"), true);
   }
   // --- voice tools (closures over this instance) ---
@@ -8996,10 +10267,18 @@ Another agent just implemented the above. Independently check the CURRENT state
     this.notify("task_started", `task ${id} (${lbl}) started`, { id, brief, tier });
     return id;
   }
+  /** Tool result for a dispatch. The task is ALREADY RUNNING — live, the terse "Acknowledge briefly" drew
+   *  "Did you want me to look up today's news?" right after dispatching exactly that (session 20260923-101910
+   *  msg 18). Also truthful about delivery: a clean result is spoken by the worker itself and lands in
+   *  context (TaskStatus returns it); only failures come back as a [task … failed] event. */
+  dispatchResult(id, verb) {
+    const after = `The worker speaks its result to the user itself when done (TaskStatus ${id} returns it).`;
+    return this.spokeBeforeDispatch ? `${verb} task ${id} \u2014 it is already running. You already acknowledged \u2014 end your turn now with NO further text. ${after}` : `${verb} task ${id} \u2014 it is already running. Now tell the user in ONE short sentence that you are on it (what you are doing) \u2014 do NOT ask whether they want it; it is already happening. ${after}`;
+  }
   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).',
+      description: 'Escalate real work (reading/editing files, searching, running tasks, building) to a standard background worker. Returns immediately with a task id; when it finishes the worker speaks its result to the user itself (failures arrive as a "[task <id> failed]" event). Provide a clear, self-contained `brief` (the worker does not hear the live conversation).',
       parameters: {
         type: "object",
         required: ["brief"],
@@ -9014,7 +10293,7 @@ Another agent just implemented the above. Independently check the CURRENT state
         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.`;
+        return this.dispatchResult(id, "Acting on");
       }
     };
   }
@@ -9036,7 +10315,7 @@ Another agent just implemented the above. Independently check the CURRENT state
         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.`;
+        return this.dispatchResult(id, "Thinking on");
       }
     };
   }
@@ -9048,7 +10327,13 @@ Another agent just implemented the above. Independently check the CURRENT state
       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");
+        const cap = id ? 1500 : 300;
+        const clip = (x) => x.length > cap ? `${x.slice(0, cap)}\u2026 (truncated)` : x;
+        return list.map((t) => {
+          const head = `${t.id} (${t.label}): ${t.status}`;
+          const body = (t.status === "done" ? t.spokenText?.trim() || t.result?.trim() : t.status === "error" ? t.result?.trim() : "") ?? "";
+          return body ? `${head}. ${t.status === "error" ? "Error" : "Result"}: ${clip(body)}` : head;
+        }).join("\n");
       }
     };
   }
@@ -9060,18 +10345,20 @@ Another agent just implemented the above. Independently check the CURRENT state
     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.`,
+      description: `Instant read-only lookup \u2014 one of: ${kinds.join(", ")}. ` + (kinds.includes("sessions") ? '`sessions` = EARLIER conversations with this user: what:"sessions" lists them; what:"sessions" with path:"<session id>" reads one (not what:"file"). ' : "") + "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" }
+          path: { type: "string", description: 'for ls/file: the path to look at; for sessions: a session id (or "previous")' }
         }
       },
       run: async ({ what, path }) => {
         const fs = this.options.fs;
         try {
+          const sessions = this.options.quickLook?.sessions;
+          if (sessions && (what === "file" || what === "ls") && SESSION_ID_RE.test(String(path ?? "").trim())) return await sessions(String(path).trim());
           const over = this.options.quickLook?.[String(what)];
           if (over) return await over(path ? String(path) : void 0);
           switch (String(what)) {
@@ -9179,6 +10466,250 @@ Another agent just implemented the above. Independently check the CURRENT state
   }
 };
 
+// src/modelRouter.ts
+init_llm();
+init_logging();
+var log22 = forComponent("ModelRouter");
+var ModelRouterOptions = class {
+  classifier = jevClassifier();
+  /** Capability tiers → model id (any provider). fast/standard run the main session; premium is only ever an offload. */
+  models = { fast: "anthropic/claude-haiku-4-5-20251001", standard: "anthropic/claude-sonnet-4-6", premium: "anthropic/claude-opus-5-5" };
+  /** Escalate to a stronger tier when it holds at least this much probability mass (upward bias). */
+  threshold = 0.25;
+  /** P(same thread) at or above which the previous premium side-conversation is resumed. */
+  sameThreadAt = 0.5;
+  classifyTimeoutMs = 1e4;
+  /** Host-supplied pricing (model, usage) → USD, so mixed-model turns are costed per model. */
+  costOf = () => 0;
+  /** Step budget for the premium sub-agent. */
+  offloadMaxSteps = 40;
+  /** Host-supplied provider options per model (e.g. claude-code's subscription env); applied on every tier switch + the offload child. */
+  providerOptionsFor;
+};
+function pickTier(c, th) {
+  const o = c.probs.premium ?? 0, s = c.probs.standard ?? 0;
+  if (o >= th || c.choice === "premium") return "premium";
+  if (c.choice === "standard" || s + o >= th) return "standard";
+  return "fast";
+}
+function textTurns(msgs) {
+  const out = [];
+  for (const m of msgs) {
+    if (m.role === "user") {
+      const t = contentText(m.content).trim();
+      if (t) out.push({ user: t, assistant: "" });
+    } else if (m.role === "assistant" && out.length) {
+      const t = contentText(m.content).trim();
+      if (t) out[out.length - 1].assistant = (out[out.length - 1].assistant + "\n" + t).trim();
+    }
+  }
+  return out;
+}
+var fmtTurns = (ts) => ts.map((t) => `USER: ${t.user}
+ASSISTANT: ${t.assistant || "(no text reply)"}`).join("\n\n");
+var addUsage = (a, b) => {
+  if (!a) return b;
+  if (!b) return a;
+  return {
+    promptTokens: a.promptTokens + b.promptTokens,
+    completionTokens: a.completionTokens + b.completionTokens,
+    totalTokens: a.totalTokens + b.totalTokens,
+    cacheCreationTokens: (a.cacheCreationTokens ?? 0) + (b.cacheCreationTokens ?? 0),
+    cacheReadTokens: (a.cacheReadTokens ?? 0) + (b.cacheReadTokens ?? 0)
+  };
+};
+var ModelRouter = class {
+  constructor(options) {
+    this.options = options;
+    this.options = { ...new ModelRouterOptions(), ...options };
+  }
+  options;
+  state = {};
+  get o() {
+    return this.options;
+  }
+  /** Classify one turn. Never throws: classifier failure/timeout ⇒ standard. */
+  async decide(transcript, next) {
+    const o = this.o;
+    const main = this.state.main === o.models.fast ? "fast" : "standard";
+    const input = {
+      previousModel: main,
+      history: textTurns(transcript).slice(-4).map((t) => ({ user: t.user.slice(0, 1500), assistant: t.assistant.slice(0, 1500) })),
+      next,
+      lastOffload: this.state.offload?.question
+    };
+    const t0 = performance.now();
+    let d;
+    try {
+      let timer;
+      const c = await Promise.race([
+        o.classifier(input),
+        new Promise((_, rej) => {
+          timer = setTimeout(() => rej(new Error(`classifier timeout ${o.classifyTimeoutMs}ms`)), o.classifyTimeoutMs);
+        })
+      ]).finally(() => clearTimeout(timer));
+      const tier = pickTier(c, o.threshold);
+      d = { tier, model: o.models[tier], probs: c.probs, choice: c.choice, sameThread: c.sameThread, classifyMs: Math.round(performance.now() - t0) };
+      if (tier === "premium") d.offload = this.state.offload && (c.sameThread ?? 0) >= o.sameThreadAt ? "continue" : "fresh";
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      log22.warn(`classifier failed, falling back to standard: ${msg}`);
+      d = { tier: "standard", model: o.models.standard, probs: {}, fallback: msg, classifyMs: Math.round(performance.now() - t0) };
+    }
+    log22.info(`route ${d.tier}${d.offload ? `(${d.offload})` : ""} \xB7 argmax=${d.choice ?? "-"} \xB7 p=${JSON.stringify(d.probs)}${d.sameThread != null ? ` \xB7 same=${d.sameThread.toFixed(2)}` : ""} \xB7 ${d.classifyMs}ms`);
+    return d;
+  }
+  /** Run one user turn on `agent` with routing. Returns a RunResult carrying `costUsd` + `routing`. */
+  async send(agent, content) {
+    const o = this.o;
+    const text = contentText(content);
+    const d = await this.decide(agent.transcript, text);
+    if (d.tier !== "premium") {
+      this.use(agent, this.state.main = d.model);
+      const res = await agent.send(content);
+      return { ...res, costUsd: o.costOf(d.model, res.usage), routing: d };
+    }
+    this.use(agent, this.state.main ??= o.models.standard);
+    return this.offload(agent, content, text, d);
+  }
+  async offload(agent, content, text, d) {
+    const o = this.o, main = this.state.main;
+    const prev = this.state.offload;
+    const cont = d.offload === "continue" && prev && prev.mainLen <= agent.transcript.length;
+    let briefUsage, prompt;
+    if (cont) {
+      const delta = textTurns(agent.transcript.slice(prev.mainLen));
+      prompt = `Follow-up in the same thread.${delta.length ? ` Since your last answer the main conversation continued:
+
+${fmtTurns(delta)}
+` : ""}
+
+New request:
+${text}`;
+    } else {
+      const b = await this.brief(agent, text);
+      briefUsage = b.usage;
+      const last2 = textTurns(agent.transcript).slice(-2);
+      prompt = `You are handling a hard turn delegated by the main agent of an ongoing session. You do NOT see its conversation \u2014 only this brief. Do the work with your tools, then reply to the user directly (your reply is shown as the session's answer).
+
+--- brief from the main agent ---
+${b.text}
+
+${last2.length ? `--- last turns (verbatim) ---
+${fmtTurns(last2)}
+
+` : ""}--- current user request (verbatim) ---
+${text}`;
+    }
+    const child = this.spawn(agent);
+    const res = cont ? (child.transcript = prev.messages, await child.send(prompt)) : await child.run(prompt);
+    this.state.offloads = (this.state.offloads ?? 0) + 1;
+    if (cont) this.state.reuses = (this.state.reuses ?? 0) + 1;
+    const answer = res.text || `(premium sub-agent finished with no reply; finishReason=${res.finishReason})`;
+    agent.transcript.push({ role: "user", content }, { role: "assistant", content: answer });
+    this.state.offload = { messages: child.transcript, mainLen: agent.transcript.length, question: text };
+    log22.info(`offload ${cont ? "continue" : "fresh"} done \xB7 ${res.finishReason} \xB7 ${res.steps} steps`);
+    const costUsd = o.costOf(main, briefUsage) + o.costOf(o.models.premium, res.usage);
+    return { ...res, text: answer, messages: agent.transcript, usage: addUsage(briefUsage, res.usage), costUsd, routing: d };
+  }
+  /** The main model writes the task brief on its own (cached) context, tools off; the transcript is restored after. */
+  async brief(agent, text) {
+    const snap = agent.transcript.slice();
+    const { host, toolChoice, maxSteps } = agent.options;
+    Object.assign(agent.options, { host: void 0, toolChoice: "none", maxSteps: 1 });
+    try {
+      const r = await agent.send(`[router] The next request is being delegated to a stronger sub-agent that will NOT see this conversation. Write the self-contained brief you would hand it (<=200 words): the task, the relevant facts/files/decisions established so far, constraints. Output only the brief.
+
+The request:
+${text}`);
+      return { text: r.text.trim() || text, usage: r.usage };
+    } catch (e) {
+      log22.warn(`brief failed, sending the raw request: ${e instanceof Error ? e.message : String(e)}`);
+      return { text };
+    } finally {
+      agent.transcript = snap;
+      Object.assign(agent.options, { host, toolChoice, maxSteps });
+    }
+  }
+  use(agent, model) {
+    agent.options.model = model;
+    if (this.o.providerOptionsFor) agent.options.providerOptions = this.o.providerOptionsFor(model);
+  }
+  spawn(agent) {
+    const a = agent.options;
+    const co = childOptionsFor(
+      { ai: a.ai, model: a.model, fs: a.fs, tools: a.tools, systemPrompt: a.systemPrompt, hooks: a.hooks, maxSteps: this.o.offloadMaxSteps, traceDir: a.traceDir, providerOptionsFor: this.o.providerOptionsFor },
+      a.fs,
+      a.depth ?? 0,
+      a.maxDepth ?? 2,
+      void 0,
+      this.o.models.premium
+    );
+    if (typeof co === "string") throw new Error(co);
+    co.signal = a.signal;
+    return new Agent(co);
+  }
+};
+var JEV_KEYS = ["AI_GATEWAY_API_KEY", "OPENROUTER_API_KEY", "TYPESAFE_API_KEY"];
+async function loadJev(opts) {
+  const mod = await import(opts.jevModule ?? process.env.AGENTX_JEV_MODULE ?? "@livx.cc/mcp-jev/jev");
+  const env = { ...process.env };
+  const file = opts.envFile ?? process.env.AGENTX_JEV_ENV;
+  if (file) {
+    const { readFileSync: readFileSync3 } = await import("fs");
+    for (const l of readFileSync3(file, "utf8").split("\n")) {
+      const m = l.match(/^\s*([A-Z0-9_]+)\s*=\s*(.*?)\s*$/);
+      if (m && !env[m[1]]) env[m[1]] = m[2].replace(/^['"]|['"]$/g, "");
+    }
+  }
+  return { mod, env };
+}
+async function jevAvailable(opts = {}) {
+  try {
+    const { env } = await loadJev(opts);
+    return JEV_KEYS.some((k) => env[k]?.trim());
+  } catch (e) {
+    log22.debug(`jev unavailable: ${e instanceof Error ? e.message : String(e)}`);
+    return false;
+  }
+}
+function jevClassifier(opts = {}) {
+  let router;
+  const load = async () => {
+    const { mod, env } = await loadJev(opts);
+    return new mod.JevRouter({ env });
+  };
+  return async (input) => {
+    const jev = await (router ??= load().catch((e) => {
+      router = void 0;
+      throw e;
+    }));
+    const questions = [{
+      id: "tier",
+      type: "choice",
+      instructions: "Pick the CHEAPEST model that will handle the NEXT assistant turn correctly for this coding-agent conversation. Staying on previousModel keeps its prompt cache warm; switch only when the next turn clearly needs more (or much less) capability.",
+      criteria: {
+        fast: "Trivial: commands, lookups, acknowledgements, commits, mechanical single-file edits, short rewrites.",
+        standard: "Standard engineering: features, bounded refactors, reviews, tests, following a clear trace, summarising.",
+        premium: "Hard: root-causing subtle/intermittent bugs, concurrency, security semantics, architecture trade-offs, quantitative reasoning."
+      }
+    }];
+    if (input.lastOffload) questions.push({
+      id: "sameThread",
+      type: "boolean",
+      instructions: "Does nextUserMessage continue the same line of work as lastOffload (the previous hard request, handled by a specialist) \u2014 a follow-up, refinement or next step of it \u2014 rather than a new, unrelated topic?"
+    });
+    const state = { previousModel: input.previousModel, history: input.history, nextUserMessage: input.next, ...input.lastOffload ? { lastOffload: input.lastOffload } : {} };
+    const r = await jev.evaluate({ state, questions }, opts.provider);
+    const a = r.answers.tier;
+    const map = (k) => k;
+    const probs = {};
+    for (const [k, v] of Object.entries(a.probabilities ?? {})) probs[map(k)] = v;
+    const st = r.answers.sameThread;
+    return { choice: map(a.choice), probs, sameThread: st ? st.probability ?? (st.value ? 1 : 0) : void 0 };
+  };
+}
+
 // src/mcp.ts
 function toResult(result) {
   if (result == null) return { text: "" };
@@ -9444,6 +10975,8 @@ export {
   MEMORY_PROMPT,
   MODEL_ALIASES,
   MemFilesystem3 as MemFilesystem,
+  ModelRouter,
+  ModelRouterOptions,
   MountFilesystem,
   NodeDiskFilesystem,
   OverlayFilesystem,
@@ -9505,6 +11038,8 @@ export {
   imagePart,
   imageRefPart,
   imageRefResult,
+  jevAvailable,
+  jevClassifier,
   lessonCapture,
   loadAgents,
   loadCommands,
@@ -9539,6 +11074,7 @@ export {
   parseCron,
   parseDdgHtml,
   parseImageRef,
+  pickTier,
   planMode,
   raceAttempts,
   readTool,