@livx.cc/agentx 0.99.105 → 0.99.106

package/dist/index.js

@@ -683,16 +683,16 @@ ${entries.map((s) => "  " + s).join("\n")}`);
   return blocks.length ? blocks.join("\n") : `(no ${label} found)`;
 }
 function fuzzyLineReplace(content, oldStr, newStr) {
-  const norm2 = (s) => s.trim();
+  const norm4 = (s) => s.trim();
   const cl = content.split("\n");
-  const ol = oldStr.split("\n").map(norm2);
+  const ol = oldStr.split("\n").map(norm4);
   while (ol.length && ol[ol.length - 1] === "") ol.pop();
   while (ol.length && ol[0] === "") ol.shift();
   if (!ol.length) return null;
   const matches = [];
   for (let i2 = 0; i2 + ol.length <= cl.length; i2++) {
     let ok = true;
-    for (let j = 0; j < ol.length; j++) if (norm2(cl[i2 + j]) !== ol[j]) {
+    for (let j = 0; j < ol.length; j++) if (norm4(cl[i2 + j]) !== ol[j]) {
       ok = false;
       break;
     }
@@ -3149,7 +3149,7 @@ var init_tools_shell = __esm({
 });
 
 // src/ccBridge.ts
-var CC_BRIDGED = /* @__PURE__ */ new Set(["Recall", "Remember", "MemorySearch"]);
+var CC_BRIDGED = /* @__PURE__ */ new Set(["Recall", "Remember", "MemorySearch", "Forget"]);
 function ccToolServer(name, tools, call) {
   const instance = {
     async connect(t) {
@@ -3508,8 +3508,9 @@ init_tools_structured();
 var MAX_INDEX = 25;
 var MAX_INDEX_LINES = 200;
 var MAX_INDEX_BYTES = 25e3;
-var MEMORY_PROMPT = '## Memory guidelines\n**When to Remember:** user corrections ("no, do X instead"), preferences ("I prefer Y"), project constraints, recurring gotchas, role/context ("I\'m a data scientist"), workflow patterns confirmed by the user. Capture the WHY, not just the what.\n**When NOT to Remember:** task-specific scratch, transient state, things derivable from code/git, conversation filler, anything already in instruction files. If removing the memory wouldn\'t change future behavior, don\'t save it.\n**Types** (pass to Remember \u2014 this determines where the memory is stored):\n- `user` \u2014 role, preferences, knowledge level, collaboration style (GLOBAL \u2014 follows you across projects)\n- `feedback` \u2014 corrections, what to avoid/repeat, with WHY (GLOBAL)\n- `project` \u2014 ongoing work, goals, constraints, deadlines (LOCAL to this project; convert relative dates to absolute)\n- `reference` \u2014 pointers to external resources, URLs, vendor docs (LOCAL to this project)\n**Before acting on a recalled memory:** verify it\'s still true \u2014 a memory naming a file/function/flag is a claim from when it was written. Grep/read to confirm before recommending. Stale memory \u2192 update via Remember (same slug overwrites).\n**Dedup:** before writing, check if a similar memory exists (Recall or MemorySearch). Update the existing one rather than creating duplicates.\nCall `Recall` with a slug (or multiple slugs/a pattern) to load full bodies when relevant.\nCall `MemorySearch` with a query to find memories by content when you don\'t know the slug.\nCall `Remember` to persist a durable fact for future sessions.';
-var VOICE_MEMORY_PROMPT = `You have Remember and Recall tools \u2014 use them directly, no delegation needed.
+var MEMORY_PROMPT = '## Memory guidelines\n**When to Remember:** user corrections ("no, do X instead"), preferences ("I prefer Y"), project constraints, recurring gotchas, role/context ("I\'m a data scientist"), workflow patterns confirmed by the user. Capture the WHY, not just the what.\n**When NOT to Remember:** task-specific scratch, transient state, things derivable from code/git, conversation filler, anything already in instruction files. If removing the memory wouldn\'t change future behavior, don\'t save it.\n**Types** (pass to Remember \u2014 this determines where the memory is stored):\n- `user` \u2014 role, preferences, knowledge level, collaboration style (GLOBAL \u2014 follows you across projects)\n- `feedback` \u2014 corrections, what to avoid/repeat, with WHY (GLOBAL)\n- `project` \u2014 ongoing work, goals, constraints, deadlines (LOCAL to this project; convert relative dates to absolute)\n- `reference` \u2014 pointers to external resources, URLs, vendor docs (LOCAL to this project)\n**Before acting on a recalled memory:** verify it\'s still true \u2014 a memory naming a file/function/flag is a claim from when it was written. Grep/read to confirm before recommending. Stale memory \u2192 update via Remember (same slug overwrites).\n**Forget:** when the user asks to remove/delete/forget a memory, call `Forget` with its slug \u2014 it deletes the fact and its index line. Never "remove" by re-Remembering a note that says it was removed: that keeps the memory.\n**Dedup:** before writing, check if a similar memory exists (Recall or MemorySearch). Update the existing one rather than creating duplicates.\nCall `Recall` with a slug (or multiple slugs/a pattern) to load full bodies when relevant.\nCall `MemorySearch` with a query to find memories by content when you don\'t know the slug.\nCall `Remember` to persist a durable fact for future sessions.';
+var VOICE_MEMORY_PROMPT = `You have Remember, Recall and Forget tools \u2014 use them directly, no delegation needed.
+When the user asks to remove/delete/forget something you remember, call Forget with its slug (MemorySearch first if unsure) \u2014 never Remember a "removed" note over it; only say it is gone after Forget confirms.
 IMPLICIT CAPTURE: when the user shares their name, role, a preference, a correction ("no, do X instead"), or a project constraint \u2014 call Remember immediately without announcing it. Natural memory, not a ceremony.
 For explicit "remember X" requests, also call Remember directly and confirm briefly ("got it").
 Do NOT remember: transient task details, conversation filler, things you'd forget in a real conversation.
@@ -3518,7 +3519,7 @@ For anything requiring files, shell, or web \u2014 still Act.`;
 async function loadMemory(fs, dir, opts = {}) {
   const dirs = (Array.isArray(dir) ? dir : [dir]).filter(Boolean);
   const writeDir = dirs[0];
-  const tools = [recallTool(fs, dirs), rememberTool(fs, writeDir, opts), memorySearchTool(fs, dirs)];
+  const tools = [recallTool(fs, dirs), rememberTool(fs, writeDir, opts), memorySearchTool(fs, dirs), forgetTool(fs, [...dirs, ...opts.userDir ? [opts.userDir] : []])];
   const allPointers = [];
   const seenSlugs = /* @__PURE__ */ new Set();
   let header = "";
@@ -3760,6 +3761,39 @@ function rememberTool(fs, dir, memOpts = {}) {
     }
   };
 }
+async function forgetFact(fs, dirs, slug2) {
+  const from = [];
+  for (const d of [...new Set(dirs.filter(Boolean))]) {
+    const path = `${d}/${slug2}.md`;
+    const had = await fs.exists(path);
+    if (had) await fs.deleteFile(path);
+    const indexPath = `${d}/MEMORY.md`;
+    let unindexed = false;
+    if (await fs.exists(indexPath)) {
+      const lines = (await fs.readFile(indexPath)).split("\n");
+      const kept = lines.filter((l) => !l.includes(`(${slug2}.md)`));
+      if (kept.length !== lines.length) {
+        await fs.writeFile(indexPath, kept.join("\n"));
+        unindexed = true;
+      }
+    }
+    if (had || unindexed) from.push(d);
+  }
+  return from;
+}
+function forgetTool(fs, dirs) {
+  return {
+    name: "Forget",
+    description: 'Delete a memory for good (its fact file and index line) when the user asks to remove, delete or forget it. Pass the slug (MemorySearch if unsure). Re-Remembering a "removed" note does NOT delete anything.',
+    parameters: { type: "object", required: ["slug"], properties: { slug: { type: "string", description: "fact slug (filename without .md)" } } },
+    async run({ slug: slug2 }, _ctx) {
+      const s = cleanSlug(slug2);
+      if (!s) return "Error: pass the slug to forget.";
+      const from = await forgetFact(fs, dirs, s);
+      return from.length ? `Forgot '${s}' \u2014 deleted from ${from.length} memory scope(s); it will not be recalled again.` : `Error: no memory '${s}' found (nothing deleted). Use MemorySearch to find the right slug.`;
+    }
+  };
+}
 
 // src/instructions.ts
 var DEFAULT_NAMES = ["AGENT.md", "AGENTS.md", "CLAUDE.md"];
@@ -5981,14 +6015,14 @@ function summarize(messages, focus) {
   if (lastAssistant) lines.push(`last assistant: ${lastAssistant}`);
   if (carried.length) lines.push("earlier recap:", ...carried.map((l) => `  ${l}`));
   if (focus?.trim()) {
-    const words = focus.toLowerCase().split(/\s+/).filter((w) => w.length > 2);
+    const words3 = focus.toLowerCase().split(/\s+/).filter((w) => w.length > 2);
     const kept = [];
     const ordered = [...messages.filter((m) => !isSyntheticSummary(m)), ...messages.filter(isSyntheticSummary)];
     outer: for (const msg of ordered) {
       if (msg.role === "tool") continue;
       for (const line of contentText(msg.content).split("\n")) {
         const l = line.toLowerCase();
-        if (line.trim() && words.some((w) => l.includes(w))) {
+        if (line.trim() && words3.some((w) => l.includes(w))) {
           kept.push(line.trim().slice(0, 200));
           if (kept.length >= 12) break outer;
         }
@@ -7121,13 +7155,13 @@ 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];
+  const words3 = trimmed.toLowerCase().split(/\s+/);
+  const lastWord = words3[words3.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;
+  if (words3.length <= 2) return false;
   return true;
 }
 var MAX_HOLD_MS = 2e3;
@@ -7528,13 +7562,13 @@ var VoiceEngine = class _VoiceEngine {
     };
     if (this.options.revealMode === "word" || this.options.heardTimestamps) {
       this.tts.wantTimestamps = true;
-      this.tts.onTimestamps = (words, start) => {
+      this.tts.onTimestamps = (words3, start) => {
         if (this.interrupted) return;
         start.forEach((s, i) => {
-          if (this.wordAnchorPending) this.wordPending.push([words[i] ?? "", s]);
+          if (this.wordAnchorPending) this.wordPending.push([words3[i] ?? "", s]);
           else {
             this.wordStarts.push(this.wordOrigin + s);
-            this.wordTexts.push(words[i] ?? "");
+            this.wordTexts.push(words3[i] ?? "");
           }
         });
       };
@@ -7676,22 +7710,22 @@ var VoiceEngine = class _VoiceEngine {
     if (this.adaptiveAckFired && this.ackProbe !== null) {
       this.ackProbe += text;
       const probe = this.ackProbe;
-      const bare = probe.replace(/\[emotion[^\]]*\]/gi, "").replace(/^\s+/, "");
-      const m = bare.match(/^([^.!?…\n]*[.!?…\n])([\s\S]*)$/);
-      if (!m && bare.length < 80) return "";
+      const bare2 = probe.replace(/\[emotion[^\]]*\]/gi, "").replace(/^\s+/, "");
+      const m = bare2.match(/^([^.!?…\n]*[.!?…\n])([\s\S]*)$/);
+      if (!m && bare2.length < 80) return "";
       this.ackProbe = null;
       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 lead2 = m ? m[1] : bare2;
+      const norm4 = lead2.replace(/[^a-z ]/gi, " ").replace(/\s+/g, " ").trim().toLowerCase();
+      const same = this.ackPickedFired ? bare2.match(_VoiceEngine.leadingPhrase(this.lastAck)) : null;
+      if (_VoiceEngine.ACK_LEADING.test(norm4)) {
         const rest = m ? m[2] : "";
-        this.diag("reflex_ack_suppressed", { lead: lead.trim() });
+        this.diag("reflex_ack_suppressed", { lead: lead2.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);
+        text = bare2.slice(same[0].length);
         if (!text.trim()) return "";
       } else {
         text = probe;
@@ -7770,8 +7804,8 @@ var VoiceEngine = class _VoiceEngine {
       while (n < this.wordStarts.length && this.wordStarts[n] <= playedSec) n++;
       if (n !== this.revealedN) {
         this.revealedN = n;
-        const words = this.revealText.trim().split(/\s+/).filter(Boolean);
-        this.options.onReveal(words.slice(0, n).join(" "));
+        const words3 = this.revealText.trim().split(/\s+/).filter(Boolean);
+        this.options.onReveal(words3.slice(0, n).join(" "));
       }
       this.revealPoll = this.clock.setTimeout(tick, 60);
     };
@@ -7798,8 +7832,8 @@ var VoiceEngine = class _VoiceEngine {
     this.adaptiveAckFired = false;
     this.ackProbe = null;
     if (heldProbe) {
-      const norm2 = heldProbe.replace(/\[emotion[^\]]*\]/gi, "").replace(/[^a-z ]/gi, " ").replace(/\s+/g, " ").trim().toLowerCase();
-      if (_VoiceEngine.ACK_LEADING.test(norm2)) this.diag("reflex_ack_suppressed", { lead: heldProbe.trim() });
+      const norm4 = heldProbe.replace(/\[emotion[^\]]*\]/gi, "").replace(/[^a-z ]/gi, " ").replace(/\s+/g, " ").trim().toLowerCase();
+      if (_VoiceEngine.ACK_LEADING.test(norm4)) this.diag("reflex_ack_suppressed", { lead: heldProbe.trim() });
       else this.speakDelta(heldProbe);
     }
     if (!this.speaking) return;
@@ -8337,14 +8371,14 @@ var VoiceEngine = class _VoiceEngine {
     if (!prev) return next;
     if (!next) return prev;
     const pw = prev.split(/\s+/), nw = next.split(/\s+/);
-    const norm2 = _VoiceEngine.normWord;
+    const norm4 = _VoiceEngine.normWord;
     if (pw.length >= 2 && pw.length <= nw.length) {
       let pfx = true;
-      for (let i = 0; i < pw.length - 1; i++) if (norm2(pw[i]) !== norm2(nw[i])) {
+      for (let i = 0; i < pw.length - 1; i++) if (norm4(pw[i]) !== norm4(nw[i])) {
         pfx = false;
         break;
       }
-      if (pfx && norm2(nw[pw.length - 1]).startsWith(norm2(pw[pw.length - 1]))) return next;
+      if (pfx && norm4(nw[pw.length - 1]).startsWith(norm4(pw[pw.length - 1]))) return next;
     }
     if (_VoiceEngine.restates(prev, next)) {
       this.diag("merge_restated", { dropped: prev.slice(0, 60) });
@@ -8353,7 +8387,7 @@ var VoiceEngine = class _VoiceEngine {
     const max = Math.min(pw.length, nw.length);
     for (let k = max; k > 0; k--) {
       let match = true;
-      for (let i = 0; i < k; i++) if (norm2(pw[pw.length - k + i]) !== norm2(nw[i])) {
+      for (let i = 0; i < k; i++) if (norm4(pw[pw.length - k + i]) !== norm4(nw[i])) {
         match = false;
         break;
       }
@@ -8405,11 +8439,11 @@ var VoiceEngine = class _VoiceEngine {
    *    race), never worse. Fillers ("mhm") deliberately don't count as replies — see speakFiller. */
   refinalizes(next) {
     const pw = this.lastDispatchWords, nw = next.trim().split(/\s+/);
-    const norm2 = _VoiceEngine.normWord;
+    const norm4 = _VoiceEngine.normWord;
     if (pw.length < 3 || nw.length < pw.length) return false;
     if (this.clock.now() - this.lastDispatchAt >= _VoiceEngine.DUP_FINAL_MS) return false;
-    for (let i = 0; i < pw.length - 1; i++) if (norm2(pw[i]) !== norm2(nw[i])) return false;
-    const pLast = norm2(pw[pw.length - 1]), nSame = norm2(nw[pw.length - 1]);
+    for (let i = 0; i < pw.length - 1; i++) if (norm4(pw[i]) !== norm4(nw[i])) return false;
+    const pLast = norm4(pw[pw.length - 1]), nSame = norm4(nw[pw.length - 1]);
     if (!nSame.startsWith(pLast)) return false;
     return nw.length > pw.length || nSame.length > pLast.length;
   }
@@ -9241,7 +9275,98 @@ import { AIClient, DecideClient, JevAdapter, LlmDecideAdapter } from "ai.libx.js
 // src/voice/overlap.ts
 init_logging();
 var log20 = forComponent("Overlap");
+var norm2 = (s) => s.toLowerCase().replace(/[’']/g, "'").replace(/[^\p{L}\p{N}' -]+/gu, " ").replace(/\s+/g, " ").trim();
+var HARD = /\b(?:stop|wait|no|nope|nah|hold on|hang on|hold up|pause|cancel|quiet|enough|shut up|never ?mind|actually|but|sorry what|what|why|how|who|when|where|which|can you|could you|tell me|i mean|excuse me)\b/;
 var ACK = new Set("yeah yea yes yep yup ya ok okay k right sure true totally exactly definitely absolutely indeed mm mmm hmm mhm mm-hm uh-huh uh huh aha ah oh ooh wow nice cool great awesome perfect good fine interesting gotcha got it i see makes sense fair agreed correct of course for sure lol ha haha hahaha heh hehe yeah yeah alright all right sweet neat oh nice oh wow oh cool oh okay oh yeah oh right that's right that's true thats right thats true love it i know me too same".split(" "));
+var LEAD = /* @__PURE__ */ new Set(["and", "so", "um", "uh", "er", "well", "oh"]);
+var LEADER = /* @__PURE__ */ new Set(["yeah", "yea", "yes", "yep", "yup", "ok", "okay", "right", "sure", "alright", "mm", "mhm", "hmm", "uh-huh", "totally", "exactly", "true"]);
+var PHRASES = ["got it", "i see", "makes sense", "of course", "for sure", "all right", "that's right", "that's true", "thats right", "thats true", "love it", "i know", "me too", "uh huh"];
+function overlapRule(text) {
+  if (/\?/.test(text)) return "cut";
+  let t = norm2(text);
+  if (!t) return void 0;
+  if (HARD.test(t)) return "cut";
+  for (const p of PHRASES) t = t.split(p).join(" ");
+  const words3 = t.split(/[\s-]+/).filter(Boolean);
+  const ack = (w) => ACK.has(w) || /^(?:ha)+h?$|^(?:he)+h?$|^m+(?:hm+)?$|^h?m+$/.test(w);
+  if (words3.every(ack)) return "keep";
+  const lead2 = words3.findIndex((w) => !LEAD.has(w));
+  if (lead2 >= 0 && LEADER.has(words3[lead2]) && words3.slice(lead2).filter((w) => !ack(w) && !LEAD.has(w)).length <= 1) return "keep";
+  return void 0;
+}
+function fastOverlapModel(ai, model = "groq/qwen/qwen3.8-27b") {
+  return async (heard, signal) => {
+    const prompt = 'Live voice call. The assistant is mid-sentence and the user just said this over it: "' + heard + '"\nIs it ONLY a listener cue \u2014 agreement, acknowledgement, a short reaction or laugh \u2014 so the assistant should keep talking? Answer no if they want the floor: a question, objection, correction, request, or new information.\nAnswer yes or no.';
+    const reasoning = /qwen/.test(model) ? { providerOptions: { reasoning_effort: "none" } } : /gpt-oss/.test(model) ? { providerOptions: { reasoning_effort: "low" } } : {};
+    const r = await ai.chat({ model, messages: [{ role: "user", content: prompt }], stream: false, signal, temperature: 0, maxTokens: /gpt-oss/.test(model) ? 200 : 3, ...reasoning });
+    const a = (r.content ?? "").trim().toLowerCase();
+    return /^yes/.test(a) ? "keep" : /^no/.test(a) ? "cut" : null;
+  };
+}
+var OverlapJudgeOptions = class {
+  /** The fast model for ambiguous overlaps; absent → ambiguous cuts. */
+  model;
+  /** A model verdict later than this is dropped → cut. 600ms: groq qwen measured p50 ~100ms / max ~230ms in isolation
+   *  (24 calls, 2026-10-14) but live, beside the reflex + chatty-channel calls, 2 of 2 ambiguous verdicts missed 300ms
+   *  and cut the reply. The engine holds the overlap up to 900ms (bindOverlapInstinct) — a slightly later keep beats
+   *  a cut, so the budget sits well inside that hold. */
+  budgetMs = 600;
+  onDecision = () => {
+  };
+  now = () => performance.now();
+};
+var OverlapJudge = class {
+  constructor(options) {
+    this.options = options;
+    this.options = { ...new OverlapJudgeOptions(), ...options };
+  }
+  options;
+  get o() {
+    return this.options;
+  }
+  async judge(heard) {
+    const t0 = this.o.now();
+    const done = (verdict, by) => {
+      const d = { verdict, by, ms: Math.round(this.o.now() - t0) };
+      if (by === "late" || by === "error" || by === "none") log20.warn(`overlap "${heard.slice(0, 60)}": no verdict (${by}, ${d.ms}ms) \u2192 cut`);
+      else log20.debug(`overlap "${heard.slice(0, 60)}": ${verdict} by ${by} ${d.ms}ms`);
+      this.o.onDecision(heard, d);
+      return d;
+    };
+    const rule = overlapRule(heard);
+    if (rule) return done(rule, "rule");
+    if (!this.o.model) return done("cut", "none");
+    const ctl = new AbortController();
+    let timer;
+    const late = new Promise((r) => {
+      timer = setTimeout(() => {
+        ctl.abort();
+        r("late");
+      }, this.o.budgetMs);
+    });
+    try {
+      const v = await Promise.race([this.o.model(heard, ctl.signal).catch((e) => {
+        if (!ctl.signal.aborted) log20.warn(`overlap model failed: ${e.message}`);
+        return "error";
+      }), late]);
+      if (v === "late" || v === "error") return done("cut", v);
+      return v ? done(v, "model") : done("cut", "error");
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+};
+function overlapModelFor(ai, env = process.env) {
+  const model = env.AGENTX_CHANNEL_DECIDER_MODEL || void 0;
+  if (!model && !env.GROQ_API_KEY) return void 0;
+  const m = fastOverlapModel(ai, model);
+  const t0 = performance.now();
+  void m("yeah", AbortSignal.timeout(1e4)).then(
+    () => log20.debug(`fast model warm in ${Math.round(performance.now() - t0)}ms`),
+    (e) => log20.warn(`fast model warm-up failed (the first overlap verdict may be late): ${e?.message ?? e}`)
+  );
+  return m;
+}
 
 // src/voice/instinct.ts
 var log21 = forComponent("Instinct");
@@ -9257,6 +9382,17 @@ var ACK_SITUATIONS = {
   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 CHANNEL_ACTIONS = {
+  silence: 'the default \u2014 nothing to add. ALWAYS for a greeting, thanks, a yes/no, or any short complete turn the real reply will answer instantly ("hey", "how are you?", "thanks"); also mid-word or mid-clause',
+  backchannel: 'they are mid-way through a longer story or explanation (several clauses) and just closed a clause: a tiny "mm-hm"/"right" shows you follow, without taking the turn',
+  filler: 'they paused mid-thought, searching for words, and a soft "hmm" keeps the line warm',
+  bridge: 'they finished a substantial request or hard question and the real answer takes a moment: a short "let me check\u2014" lead-in'
+};
+var CHANNEL_BANK = {
+  backchannel: ["Mm-hm.", "Right.", "Mm, yeah.", "Uh-huh.", "I see.", "Mm."],
+  filler: ["Hmm\u2026", "Mm\u2026", "Hm, mm\u2026", "Ahh\u2026"],
+  bridge: ["Let me check\u2014", "One sec, looking\u2014", "Hm, let me see\u2014", "Okay, give me a moment\u2014", "Let me think on that\u2014"]
+};
 var INTENT_ACK_OVER = {
   stop: Object.keys(ACK_SITUATIONS).filter((s) => s !== "silent"),
   steer: ["command"],
@@ -9330,6 +9466,34 @@ async function unsaidClauses(pieces, spoken, decider, timeoutMs = 5e3) {
   }
 }
 
+// src/voice/spelling.ts
+var GROUP = String.raw`(?:\b[A-Za-z](?:-[A-Za-z]){1,}\b|\b[A-Z](?: [A-Z]){2,}\b)`;
+var SEP = String.raw`\s*(?:\b[Dd]ot\b|\b[Pp]eriod\b|\.)\s*`;
+var RUN = new RegExp(`${GROUP}(?:${SEP}${GROUP})*`, "g");
+function spelledOut(text) {
+  const out = [];
+  for (const m of text.matchAll(RUN)) {
+    const raw = m[0];
+    if (!/^[A-Za-z][- ]/.test(raw)) continue;
+    const parts = raw.split(new RegExp(SEP)).map((g) => g.replace(/[- ]/g, ""));
+    const word = parts.join(".");
+    if (word.replace(/\./g, "").length < 3) continue;
+    const s = parts.length > 1 ? word.toLowerCase() : word;
+    if (!out.includes(s)) out.push(s);
+  }
+  return out;
+}
+function spellingNote(text) {
+  const w = spelledOut(text);
+  return w.length ? `
+[spelled out letter by letter: ${w.map((x) => `"${x}"`).join(", ")} \u2014 that spelling is exact and replaces the word you heard]` : "";
+}
+
+// src/voice/channelLang.ts
+init_logging();
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { join as join5 } from "path";
+
 // src/voice/leak.ts
 var TOOL = String.raw`(?:QuickLook|TaskStatus|CancelTask|AnswerTask|ExitSession|Act|Think|Hold(?! on\b))`;
 var SUSPECT = [
@@ -9407,13 +9571,480 @@ function scrubSpokenJunk(text, final = false) {
   return s;
 }
 function isRepeatOf(sentence, spoken) {
-  const norm2 = (x) => x.replace(/\[[a-z_ ]+\]/gi, "").replace(/[^\p{L}\p{N}]+/gu, " ").trim().toLowerCase();
-  const s = norm2(sentence);
-  return s.replace(/ /g, "").length >= 16 && spoken.split(SENTENCE_SPLIT).some((x) => norm2(x) === s);
+  const norm4 = (x) => x.replace(/\[[a-z_ ]+\]/gi, "").replace(/[^\p{L}\p{N}]+/gu, " ").trim().toLowerCase();
+  const s = norm4(sentence);
+  return s.replace(/ /g, "").length >= 16 && spoken.split(SENTENCE_SPLIT).some((x) => norm4(x) === s);
 }
+var LEAD_TAGS = String.raw`^(?:\s*\[[^\]]*\]\s*)*\s*`;
+var RESULT_CLAIM_RE = new RegExp(LEAD_TAGS + String.raw`(?:(?:all\s+)?done|finished|(?:i\s+)?found|i(?:['’]ve|\s+have)?\s+(?:found|checked|looked|scanned|searched)|there\s+(?:are|is|were|was)\s+no|no\s+(?:files?|results?|matches|sessions?))\b`, "i");
+var DONE_CLAIM_RE = new RegExp(LEAD_TAGS + String.raw`(?:(?:all\s+)?done|finished|it['’]?s\s+(?:done|finished)|completed?)\b`, "i");
+
+// src/voice/channelLang.ts
+var log23 = forComponent("ChannelBanks");
+var LINE_KINDS = ["backchannel", "filler", "bridge"];
+var BANK_KEYS = [...LINE_KINDS, "phatic"];
+var EN_PHATIC = [
+  "hey",
+  "hi",
+  "hello",
+  "yo",
+  "hiya",
+  "morning",
+  "good morning",
+  "good evening",
+  "good afternoon",
+  "thanks",
+  "thank you",
+  "ok",
+  "okay",
+  "yes",
+  "yeah",
+  "yep",
+  "no",
+  "nope",
+  "sure",
+  "bye",
+  "goodbye",
+  "how are you",
+  "what's up",
+  "whats up",
+  "can you hear me"
+];
+var EN_BANK = { ...CHANNEL_BANK, phatic: EN_PHATIC };
+var HE_BANK = {
+  backchannel: ["\u05D0\u05D4\u05D4", "\u05DB\u05DF", "\u05E0\u05DB\u05D5\u05DF", "\u05D0\u05D5\u05E7\u05D9\u05D9", "\u05DE\u05DE", "\u05D1\u05E8\u05D5\u05E8", "\u05D5\u05D5\u05D0\u05D5", "\u05D9\u05E4\u05D4", "\u05D1\u05D8\u05D7", "\u05D0\u05D4, \u05DB\u05DF"],
+  filler: ["\u05DE\u05DE\u2026", "\u05D0\u05D4\u05D4\u2026", "\u05DB\u05DF\u2026", "\u05D0\u05DE\u05DE\u2026", "\u05DE\u05DE, \u05DB\u05DF\u2026", "\u05D0\u05D5\u05E7\u05D9\u05D9\u2026"],
+  bridge: ["\u05E8\u05D2\u05E2\u2026", "\u05E9\u05E0\u05D9\u05D9\u05D4\u2026", "\u05E8\u05E7 \u05E9\u05E0\u05D9\u05D9\u05D4\u2026", "\u05E8\u05D2\u05E2 \u05D0\u05D7\u05D3\u2026", "\u05DE\u05D9\u05D3\u2026", "\u05E2\u05D5\u05D3 \u05E8\u05D2\u05E2\u2026", "\u05D0\u05D5\u05E7\u05D9\u05D9, \u05E8\u05D2\u05E2\u2026", "\u05E9\u05E0\u05D9\u05D9\u05D4, \u05E8\u05D2\u05E2\u2026"],
+  phatic: [
+    "\u05D4\u05D9\u05D9",
+    "\u05D4\u05D9",
+    "\u05E9\u05DC\u05D5\u05DD",
+    "\u05D0\u05D4\u05DC\u05DF",
+    "\u05DE\u05D4 \u05E0\u05E9\u05DE\u05E2",
+    "\u05DE\u05D4 \u05E7\u05D5\u05E8\u05D4",
+    "\u05EA\u05D5\u05D3\u05D4",
+    "\u05EA\u05D5\u05D3\u05D4 \u05E8\u05D1\u05D4",
+    "\u05DB\u05DF",
+    "\u05DC\u05D0",
+    "\u05D0\u05D5\u05E7\u05D9\u05D9",
+    "\u05D1\u05E1\u05D3\u05E8",
+    "\u05D1\u05D9\u05D9",
+    "\u05DC\u05D4\u05EA\u05E8\u05D0\u05D5\u05EA",
+    "\u05D1\u05D5\u05E7\u05E8 \u05D8\u05D5\u05D1",
+    "\u05E2\u05E8\u05D1 \u05D8\u05D5\u05D1",
+    "\u05D0\u05EA\u05D4 \u05E9\u05D5\u05DE\u05E2 \u05D0\u05D5\u05EA\u05D9",
+    "\u05D0\u05EA \u05E9\u05D5\u05DE\u05E2\u05EA \u05D0\u05D5\u05EA\u05D9"
+  ]
+};
+var primaryLang = (tag) => tag.trim().toLowerCase().split(/[-_]/)[0];
+function isPhatic(text, bank) {
+  const t = norm3(text);
+  return !!t && !!bank?.phatic?.some((p) => {
+    const q = norm3(p);
+    return !!q && (t === q || t.startsWith(q + " "));
+  });
+}
+var SKIP = new Set("um uh uhm erm hmm mm oh ok okay so no yes yeah yep well hey hi and but right alright actually like now then wait hang on me speaker \u05D0\u05D5\u05E7\u05D9\u05D9 \u05D8\u05D5\u05D1 \u05D0\u05D6 \u05DC\u05D0 \u05DB\u05DF \u05E8\u05D2\u05E2 \u05D0\u05D4 \u05D0\u05DE \u05D9\u05D0\u05DC\u05DC\u05D4 \u05D5".split(" "));
+var ASK = "what whats how why where when who which whose is are was were do does did can could would will should shall have has may isnt arent dont doesnt didnt cant wont check open show tell find search look send run go lets please take give make write explain select focus order try compare list use set activate highlight outline capture start stop read play call book create add remove delete put type click close switch help get summarize translate mark keep remind schedule \u05DE\u05D4 \u05D0\u05D9\u05DA \u05DC\u05DE\u05D4 \u05D0\u05D9\u05E4\u05D4 \u05DE\u05EA\u05D9 \u05DE\u05D9 \u05D4\u05D0\u05DD \u05DB\u05DE\u05D4 \u05EA\u05DF \u05EA\u05E0\u05D9 \u05EA\u05D2\u05D9\u05D3 \u05EA\u05D2\u05D9\u05D3\u05D9 \u05D1\u05D5\u05D0 \u05D1\u05D5\u05D0\u05D9".split(" ");
+var WANT = /^(i (want|need|would like|d like|wanna)|אני (רוצה|צריך|צריכה|מבקש|מבקשת))(\s|$)/u;
+var lead = (text) => {
+  const w = text.toLowerCase().replace(/[^\p{L}\p{N}\s]+/gu, "").split(/\s+/).filter(Boolean);
+  let i = 0;
+  while (i < w.length && (SKIP.has(w[i]) || /^\d+$/.test(w[i]))) i++;
+  return w.slice(i);
+};
+function requestOpener(text) {
+  const w = lead(text);
+  if (!w.length) return false;
+  return ASK.includes(w[0]) || WANT.test(w.slice(0, 4).join(" ")) || new RegExp("^\u05EA\\p{Script=Hebrew}{2,}$", "u").test(w[0]);
+}
+function pendingQuestion(text, lastWords = 6) {
+  const all = text.toLowerCase().replace(/[^\p{L}\p{N}'\s.!?]+/gu, " ");
+  const sentence = all.split(/[.!?]/).at(-1).split(/\s+/).filter(Boolean);
+  const t = sentence.slice(-lastWords).join(" ");
+  return /\b(can|could|would|will|do|does|did|is|are|should)\s+(you|we|i|it|there|they|he|she)\b/.test(t) || /(^|\s)(האם|אתה יכול|את יכולה)(\s|$)/u.test(t) || /\b(what|why|how|where|when|who|which)\s+(do|does|did|is|are|should|would|can|could|will)\s+(you|we|i|it|they|he|she)\b/.test(sentence.slice(-4 * lastWords).join(" "));
+}
+var SCRIPTS = [
+  [new RegExp("\\p{Script=Hebrew}", "gu"), "he"],
+  [new RegExp("\\p{Script=Arabic}", "gu"), "ar"],
+  [new RegExp("\\p{Script=Cyrillic}", "gu"), "ru"],
+  [new RegExp("\\p{Script=Greek}", "gu"), "el"],
+  [/[\p{Script=Hiragana}\p{Script=Katakana}]/gu, "ja"],
+  [new RegExp("\\p{Script=Hangul}", "gu"), "ko"],
+  [new RegExp("\\p{Script=Han}", "gu"), "zh"],
+  [new RegExp("\\p{Script=Thai}", "gu"), "th"],
+  [new RegExp("\\p{Script=Devanagari}", "gu"), "hi"],
+  [new RegExp("\\p{Script=Latin}", "gu"), "latin"]
+];
+var STOP3 = Object.fromEntries(Object.entries({
+  en: "hi hello hey yes no a thanks let see check one sec just give right well look the and is are you i it to of that what this was have with for not but my me",
+  // 'a'/'no' are English too: without them 'thanks a lot', 'long time no see' failed fitsLanguage('en')
+  es: "hola s\xED gracias bueno a me te lo se le del al el la los las que es y de en un una por para con no pero mi yo qu\xE9 est\xE1",
+  fr: "bonjour salut oui merci le la les est et de des un une que je tu il pas pour avec mais mon qui",
+  de: "hallo ja danke der die das und ist ich du nicht ein eine mit zu was aber mein wie auch",
+  it: "ciao grazie s\xEC a mi ti si il lo la gli che \xE8 e di un una non per con ma mio io sono",
+  pt: "ol\xE1 oi sim obrigado obrigada o a os as que \xE9 e de em um uma n\xE3o para com mas meu eu voc\xEA",
+  nl: "hoi dank de het een en is ik je niet van dat met voor maar mijn wat"
+}).map(([k, v]) => [k, new Set(v.split(" "))]));
+var scriptOf = (w) => SCRIPTS.find(([re]) => {
+  re.lastIndex = 0;
+  return re.test(w);
+})?.[1] ?? null;
+function detectLanguage(text, switching = false) {
+  const ws = text.toLowerCase().match(new RegExp("\\p{L}+", "gu")) ?? [];
+  const n = /* @__PURE__ */ new Map();
+  for (const w of ws) {
+    const s = scriptOf(w);
+    if (s) n.set(s, (n.get(s) ?? 0) + 1);
+  }
+  const [best, c] = [...n].sort((a2, b2) => b2[1] - a2[1])[0] ?? [null, 0];
+  if (best !== "latin") return c >= 1 && (best === "zh" || best === "ja" || c >= 2 || ws.length === 1 && !switching) ? best : null;
+  const score = Object.entries(STOP3).map(([l2, s]) => [l2, ws.filter((w) => s.has(w)).length]).sort((a2, b2) => b2[1] - a2[1]);
+  const [[l, a], [, b]] = score;
+  if (switching) return a - b >= 2 && ws.length >= 4 ? l : null;
+  return a > b && (a >= 2 || a === 1 && ws.length <= 3) ? l : null;
+}
+var NAMES = new Intl.DisplayNames(["en"], { type: "language" });
+var languageName = (lang) => {
+  try {
+    return NAMES.of(lang) ?? lang;
+  } catch {
+    return lang;
+  }
+};
+function fitsLanguage(line, lang) {
+  const own = SCRIPTS.find(([, l]) => l === lang)?.[0];
+  if (own) return (line.match(own)?.length ?? 0) > 0 && !new RegExp("\\p{Script=Latin}{2,}", "u").test(line);
+  if (/[^\p{Script=Latin}\p{M}\p{P}\p{Z}\p{N}\p{S}]/u.test(line)) return false;
+  const mine = STOP3[lang];
+  const ws = line.toLowerCase().match(new RegExp("\\p{L}+", "gu")) ?? [];
+  return !ws.some((w) => !mine?.has(w) && Object.entries(STOP3).some(([l, s]) => l !== lang && s.has(w)));
+}
+var norm3 = (s) => s.toLowerCase().replace(/[^\p{L}\p{N}' ]/gu, "").replace(/\s+/g, " ").trim();
+function cleanLine(s, lang, maxWords = 6) {
+  const raw = s.trim().split("\n")[0];
+  const l = raw.replace(/^[-*•\d.)\s]+/, "").replace(/^["'“”«»]+|["'“”«»]+$/g, "").replace(new RegExp("^\\p{L}+:\\s*", "u"), "").trim();
+  if (!l || isLeakSuspect(raw) || isLeakSuspect(l)) {
+    if (l) log23.debug(`line "${raw}" reads as meta \u2014 rejected`);
+    return "";
+  }
+  if (lang && !fitsLanguage(l, lang)) {
+    log23.debug(`line "${l}" is not ${lang} \u2014 rejected`);
+    return "";
+  }
+  return l.split(/\s+/).length > maxWords || l.length > 60 ? "" : l;
+}
+var SPEAKER_FILLER = /^(?:so|well|actually|basically|anyway|anyways|like|you know|i mean|kind of|sort of|literally|honestly|and|but|because|then|the thing is)\b/i;
+function validateBank(raw, lang, minPerKind = 3) {
+  if (!raw || typeof raw !== "object") return null;
+  const out = {};
+  for (const k of BANK_KEYS) {
+    const v = raw[k];
+    const seen = /* @__PURE__ */ new Set();
+    out[k] = (Array.isArray(v) ? v : []).filter((x) => typeof x === "string").map((x) => cleanLine(x, lang)).filter((x) => x && !(k === "filler" && SPEAKER_FILLER.test(norm3(x))) && !seen.has(norm3(x)) && seen.add(norm3(x)));
+    if (out[k].length < minPerKind) {
+      log23.warn(`bank ${lang}: only ${out[k].length} valid ${k} lines \u2014 rejected`);
+      return null;
+    }
+  }
+  return out;
+}
+var KIND_HINT = {
+  backchannel: 'tiny listener cues while they keep talking (like "mm-hm", "right") \u2014 never takes the turn',
+  filler: 'soft LISTENER sounds while they pause mid-thought (like "mm\u2026", "mhm", "yeah\u2026") \u2014 never a word that continues or completes their sentence ("kind of", "basically", "you know") and never the start of yours',
+  bridge: `neutral one-moment cues while the answer is prepared (like "let me see\u2026", "one sec\u2026") \u2014 never the start of a statement or opinion ("the thing is", "well actually", "here's the deal")`,
+  phatic: 'greetings, thanks and yes/no openers a person starts a turn with (like "hi", "thanks", "how are you")'
+};
+function fastBankGenerator(ai, model, perKind = 12) {
+  return async (lang, avoid, signal) => {
+    const name = languageName(lang);
+    const prompt = `Write short spoken side-sounds for a live voice conversation, in ${name} (natural, casual, how native ${name} speakers really talk \u2014 not translated English). ${perKind} varied lines per kind, 1-4 words each \u2014 short, idiomatic, grammatical everyday phrases a native would actually say:
+${BANK_KEYS.map((k) => `- ${k}: ${KIND_HINT[k]}`).join("\n")}
+` + (avoid.length ? `Do not repeat these existing ones: ${avoid.slice(0, 60).join(" | ")}
+` : "") + `Reply with JSON only: {"backchannel":[...],"filler":[...],"bridge":[...],"phatic":[...]}. Every line in ${name}; no explanations.`;
+    const reasoning = /gpt-oss/.test(model) ? { providerOptions: { reasoning_effort: "low" } } : {};
+    const r = await ai.chat({ model, messages: [{ role: "user", content: prompt }], stream: false, signal, maxTokens: 2e3, ...reasoning });
+    const m = (r.content ?? "").match(/\{[\s\S]*\}/);
+    if (!m) throw new Error(`no JSON in bank reply: ${(r.content ?? "").slice(0, 80)}`);
+    return JSON.parse(m[0]);
+  };
+}
+var ChannelBanksOptions = class {
+  /** Raw bank for a language (fastBankGenerator). Absent → English fallback only. */
+  generate;
+  /** Disk cache dir (one `<lang>.json` per language). Absent → in-memory only. */
+  cacheDir;
+  /** A cached bank older than this is still used, and topped up by one background call. */
+  refreshMs = 24 * 36e5;
+  /** Lines kept per kind (newest win) — the cap on growth. */
+  maxPerKind = 40;
+  timeoutMs = 2e4;
+  /** After a failed cold generation, the next attempt waits this long. */
+  retryMs = 6e4;
+  /** Cold-start/offline banks (English only by default). */
+  fallback = { en: EN_BANK };
+  /** Hand-checked banks: used as-is for their language — never generated, cached or topped up. */
+  curated = { he: HE_BANK };
+  now = () => Date.now();
+};
+var BANK_VERSION = 2;
+var ChannelBanks = class {
+  constructor(options) {
+    this.options = options;
+    this.options = { ...new ChannelBanksOptions(), ...options };
+  }
+  options;
+  banks = /* @__PURE__ */ new Map();
+  pending = /* @__PURE__ */ new Map();
+  get o() {
+    return this.options;
+  }
+  /** The bank to speak from for `lang` now — generated/cached, else the fallback, else null (= stay silent). */
+  get(lang) {
+    return this.o.curated[lang] ?? this.banks.get(lang) ?? this.o.fallback[lang] ?? null;
+  }
+  /** Load (cache) and/or generate `lang`'s bank in the background. Never throws, never blocks the caller. */
+  ensure(lang) {
+    if (this.o.curated[lang]) return Promise.resolve();
+    if (!this.pending.has(lang)) this.pending.set(lang, this.load(lang));
+    return this.pending.get(lang);
+  }
+  file(lang) {
+    return this.o.cacheDir ? join5(this.o.cacheDir, `${lang.replace(/[^\w-]/g, "")}.json`) : null;
+  }
+  async load(lang) {
+    const f = this.file(lang);
+    let cached = null;
+    if (f) cached = await readFile(f, "utf8").then((s) => JSON.parse(s)).catch((e) => {
+      if (e.code !== "ENOENT") log23.warn(`bank cache ${f} unreadable \u2014 regenerating: ${e.message}`);
+      return null;
+    });
+    if (cached && cached.v !== BANK_VERSION) {
+      log23.debug(`bank ${lang}: cache v${cached.v ?? 1} predates v${BANK_VERSION} \u2014 regenerating`);
+      cached = null;
+    }
+    const valid = cached && validateBank(cached.bank, lang, 0);
+    const complete = !!valid && BANK_KEYS.every((k) => valid[k].length);
+    if (valid) {
+      for (const k of BANK_KEYS) if (!valid[k].length) valid[k] = [...this.o.fallback[lang]?.[k] ?? []];
+      this.banks.set(lang, valid);
+      log23.debug(`bank ${lang}: cache hit (${BANK_KEYS.map((k) => valid[k].length).join("/")})${complete ? "" : " \u2014 missing kinds, refreshing"}`);
+    }
+    if (complete && this.o.now() - cached.at < this.o.refreshMs) return;
+    await this.generate(lang, valid);
+  }
+  async generate(lang, have) {
+    if (!this.o.generate) return;
+    const ac = new AbortController();
+    const t = setTimeout(() => ac.abort(), this.o.timeoutMs);
+    const t0 = this.o.now();
+    try {
+      const fresh = validateBank(await this.o.generate(lang, have ? BANK_KEYS.flatMap((k) => have[k]) : [], ac.signal), lang);
+      if (!fresh) return;
+      const bank = {};
+      for (const k of BANK_KEYS) {
+        const seen = /* @__PURE__ */ new Set();
+        bank[k] = [...fresh[k], ...have?.[k] ?? []].filter((x) => !seen.has(norm3(x)) && seen.add(norm3(x))).slice(0, this.o.maxPerKind);
+      }
+      this.banks.set(lang, bank);
+      log23.debug(`bank ${lang}: ${have ? "refreshed" : "generated"} (${BANK_KEYS.map((k) => bank[k].length).join("/")}) in ${Math.round(this.o.now() - t0)}ms`);
+      const f = this.file(lang);
+      if (f) await mkdir(this.o.cacheDir, { recursive: true }).then(() => writeFile(f, JSON.stringify({ at: this.o.now(), v: BANK_VERSION, bank }))).catch((e) => log23.warn(`bank cache write ${f} failed: ${e.message}`));
+    } catch (e) {
+      log23.warn(`bank ${lang}: generation failed \u2014 ${have ? "keeping the cached bank" : lang in this.o.fallback ? "fallback bank" : "silent"}: ${e.message}`);
+    } finally {
+      clearTimeout(t);
+      if (!this.banks.has(lang)) setTimeout(() => this.pending.delete(lang), this.o.retryMs).unref?.();
+    }
+  }
+};
+
+// src/voice/turnGate.ts
+var MID_PHRASE_WORDS = /* @__PURE__ */ new Set([
+  "slash",
+  "backslash",
+  "dash",
+  "hyphen",
+  "dot",
+  "underscore",
+  "colon",
+  "comma",
+  "and",
+  "or",
+  "but",
+  "so",
+  "because",
+  "if",
+  "then",
+  "called",
+  "named",
+  "the",
+  "a",
+  "an",
+  "my",
+  "your",
+  "our",
+  "their",
+  "is",
+  "are",
+  "um",
+  "uh",
+  // Hebrew connectives/prepositions a request cannot end on ("תפתח את", "ואז")
+  "\u05E9\u05DC",
+  "\u05D0\u05EA",
+  "\u05E2\u05DD",
+  "\u05E2\u05DC",
+  "\u05D0\u05D1\u05DC",
+  "\u05D0\u05D5",
+  "\u05DB\u05D9",
+  "\u05D0\u05DD",
+  "\u05D5\u05D0\u05D6",
+  "\u05D5\u05D2\u05DD",
+  "\u05DB\u05DE\u05D5",
+  "\u05DC\u05D2\u05D1\u05D9",
+  "\u05D1\u05E9\u05D1\u05D9\u05DC",
+  "\u05D0\u05DC",
+  "\u05E2\u05D3",
+  "\u05D0\u05D7\u05E8\u05D9",
+  "\u05DC\u05E4\u05E0\u05D9",
+  "\u05E9\u05D6\u05D4",
+  "\u05D0\u05D4",
+  "\u05D0\u05DE\u05DE"
+]);
+var TRAILING_PREPS = /* @__PURE__ */ new Set(["to", "for", "with", "about", "of", "at", "in", "on", "from", "by", "into", "under", "inside"]);
+var QUESTION_START = /^(?:what|who|whom|whose|where|when|why|how|which|is|are|was|were|do|does|did|can|could|will|would|should|have|has)\b/i;
+var PHRASAL_HOST = /* @__PURE__ */ new Set(["it", "this", "that", "them", "him", "her", "me", "us", "you", "up", "out", "off", "down", "back", "over", "away"]);
+function endsMidPhrase(text) {
+  const t = text.split("\n[")[0].trim();
+  if (!t || /[.?!…]["')\]]*$/.test(t)) return false;
+  if (/\b[a-z][\w+.-]*:\/\/\S+$/i.test(t)) return false;
+  if (/[,/\\:\-–—]$/.test(t)) return true;
+  const [last, prev] = (t.toLowerCase().match(/[\p{L}']+/gu) ?? []).reverse();
+  if (!last) return false;
+  if (TRAILING_PREPS.has(last)) return !QUESTION_START.test(t) && !PHRASAL_HOST.has(prev);
+  return MID_PHRASE_WORDS.has(last);
+}
+var words = (s) => s.trim() ? s.trim().split(/\s+/) : [];
+function isClosing(text) {
+  return words(text).length <= 8 && /(?:^|[^\p{L}])(?:good ?bye|bye|see you|good ?night|talk (?:to you )?later|hang up|end (?:the )?call|ביי|להתראות|נתראה|לילה טוב|יאללה ביי)(?:$|[^\p{L}])/iu.test(text);
+}
+var TurnGateOptions = class {
+  holdMs = 1200;
+  /** An identical final within this window is a duplicate. */
+  dupWindowMs = 5e3;
+  /** A fuller final within this window of the last turn (or with its sttId) is a re-final of it. */
+  refinalWindowMs = 5e3;
+  onTurn = () => {
+  };
+  onDrop = () => {
+  };
+  /** A final is being held (ends mid-phrase) — the fill channel may cover it with a filler, never a bridge. */
+  onHold = () => {
+  };
+  now = () => performance.now();
+};
+var TurnGate = class {
+  constructor(options) {
+    this.options = options;
+    this.options = { ...new TurnGateOptions(), ...options };
+  }
+  options;
+  last;
+  held;
+  seq = 0;
+  closed = false;
+  get o() {
+    return this.options;
+  }
+  /** A closing turn went out — the call is ending. */
+  get ending() {
+    return this.closed;
+  }
+  /** Is a final held right now? */
+  get holding() {
+    return !!this.held;
+  }
+  /** The last turn sent (id + text), if any. */
+  get lastTurn() {
+    return this.last && { id: this.last.id, text: this.last.text, started: this.last.started };
+  }
+  /** An STT final. */
+  final(text, sttId) {
+    let t = text.trim();
+    if (!t) return this.o.onDrop(text, "empty");
+    if (this.held) {
+      const h = this.held;
+      clearTimeout(h.timer);
+      this.held = void 0;
+      if (!(norm3(t) + " ").startsWith(norm3(h.text) + " ")) t = `${h.text} ${t}`;
+      sttId ??= h.sttId;
+    }
+    const key = norm3(t), now3 = this.o.now(), last = this.last;
+    if (last) {
+      const age = now3 - last.at;
+      if (key === last.key && age < this.o.dupWindowMs) return this.o.onDrop(t, "dupe");
+      const sameStt = !!sttId && sttId === last.sttId;
+      if ((sameStt || age < this.o.refinalWindowMs) && key && (last.key + " ").startsWith(key + " ")) return this.o.onDrop(t, "stale");
+      if (sameStt || age < this.o.refinalWindowMs && key.startsWith(last.key + " ")) return this.refinal(last, t, key, sttId);
+    }
+    if (this.closed && isClosing(t)) return this.o.onDrop(t, "goodbye");
+    if (endsMidPhrase(t)) {
+      this.held = { text: t, sttId, timer: setTimeout(() => this.flush(), this.o.holdMs) };
+      return this.o.onHold(t);
+    }
+    this.send(t, key, sttId, "new");
+  }
+  /** The user is speaking again (a partial): a held fragment waits for the rest. */
+  speaking() {
+    if (!this.held) return;
+    clearTimeout(this.held.timer);
+    this.held.timer = setTimeout(() => this.flush(), this.o.holdMs);
+  }
+  /** MAIN started replying to turn `id` (its first text/tool/audio): a later re-final only adds its new words. */
+  replyStarted(id) {
+    if (this.last?.id === id) this.last.started = true;
+  }
+  /** Send a held fragment now (e.g. the call ends). */
+  flush() {
+    const h = this.held;
+    if (!h) return;
+    clearTimeout(h.timer);
+    this.held = void 0;
+    if (this.closed && isClosing(h.text)) return this.o.onDrop(h.text, "goodbye");
+    this.send(h.text, norm3(h.text), h.sttId, "new");
+  }
+  end() {
+    if (this.held) {
+      clearTimeout(this.held.timer);
+      this.held = void 0;
+    }
+  }
+  refinal(last, t, key, sttId) {
+    if (!last.started) return this.send(t, key, sttId ?? last.sttId, "replace", last.id);
+    const a = words(last.text), b = words(t);
+    let i = 0;
+    while (i < a.length && i < b.length && norm3(a[i]) === norm3(b[i])) i++;
+    const extra = b.slice(i).join(" ");
+    if (!norm3(extra)) return this.o.onDrop(t, "stale");
+    if (this.closed && isClosing(extra)) return this.o.onDrop(t, "goodbye");
+    this.last = { ...last, text: t, key, at: this.o.now() };
+    this.emit(extra, "extend");
+  }
+  send(t, key, sttId, kind, replaces) {
+    const id = this.emit(t, kind, replaces);
+    this.last = { id, text: t, key, sttId, at: this.o.now(), started: false };
+  }
+  emit(text, kind, replaces) {
+    const id = `u${++this.seq}`;
+    if (isClosing(text)) this.closed = true;
+    if (this.last && kind === "extend") this.last.id = id;
+    this.o.onTurn({ id, text, kind, ...replaces ? { replaces } : {} });
+    return id;
+  }
+};
 
 // src/duplex.ts
-var log23 = forComponent("DuplexAgent");
+var log24 = 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)})` : "";
@@ -9426,12 +10057,19 @@ function refusedCall(e) {
 function rateLimited(e) {
   return Number(e?.statusCode ?? e?.status) === 429 || /rate.?limit|RATE_LIMIT|tokens per minute|too many requests/i.test(String(e?.message ?? e?.code ?? e ?? ""));
 }
-var LEAD_TAGS = String.raw`^(?:\s*\[[^\]]*\]\s*)*\s*`;
-var RESULT_CLAIM_RE = new RegExp(LEAD_TAGS + String.raw`(?:(?:all\s+)?done|finished|(?:i\s+)?found|i(?:['’]ve|\s+have)?\s+(?:found|checked|looked|scanned|searched)|there\s+(?:are|is|were|was)\s+no|no\s+(?:files?|results?|matches|sessions?))\b`, "i");
-var DONE_CLAIM_RE = new RegExp(LEAD_TAGS + String.raw`(?:(?:all\s+)?done|finished|it['’]?s\s+(?:done|finished)|completed?)\b`, "i");
+var bare = (s) => s.replace(/\[[^\]]*\]/g, " ").replace(/[\s\u00a0]+/g, " ").trim().toLowerCase();
+function restarts(stub, next) {
+  const w = bare(stub).match(/^[\p{L}\p{N}'’]+/u)?.[0];
+  return !!w && bare(next).startsWith(w);
+}
+function isFalseStart(sentence) {
+  const s = sentence.replace(/\[[^\]]*\]/g, " ").replace(/[\s\u00a0]+/g, " ").trim();
+  const m = s.match(/^([\p{L}\p{N}'’]+(?: [\p{L}\p{N}'’,]+)?)\s*(?:…|\.{2,})[\s.…]*$/u);
+  return !!m && !/^(?:h+m+|u+m+|u+h+|o+h+|a+h+|well|so|er+m*)$/i.test(m[1]);
+}
 function wordOverlap(sentence, prior) {
-  const words = (x) => x.replace(/\[[^\]]*\]/g, " ").toLowerCase().replace(/['’]/g, "").match(new RegExp("\\p{L}{4,}", "gu")) ?? [];
-  const have = new Set(words(prior)), ws = words(sentence);
+  const words3 = (x) => x.replace(/\[[^\]]*\]/g, " ").toLowerCase().replace(/['’]/g, "").match(new RegExp("\\p{L}{4,}", "gu")) ?? [];
+  const have = new Set(words3(prior)), ws = words3(sentence);
   return ws.length ? ws.filter((w) => have.has(w)).length / ws.length : 0;
 }
 var DuplexAgentOptions = class {
@@ -9525,49 +10163,6 @@ var DuplexAgentOptions = class {
   memoryUserDir;
 };
 var SESSION_ID_RE = /^\d{8}-\d{6}(?:-[\w-]+)?$/;
-var MID_PHRASE_WORDS = /* @__PURE__ */ new Set([
-  "slash",
-  "backslash",
-  "dash",
-  "hyphen",
-  "dot",
-  "underscore",
-  "colon",
-  "comma",
-  "and",
-  "or",
-  "but",
-  "so",
-  "because",
-  "if",
-  "then",
-  "called",
-  "named",
-  "the",
-  "a",
-  "an",
-  "my",
-  "your",
-  "our",
-  "their",
-  "is",
-  "are",
-  "um",
-  "uh"
-]);
-var TRAILING_PREPS = /* @__PURE__ */ new Set(["to", "for", "with", "about", "of", "at", "in", "on", "from", "by", "into", "under", "inside"]);
-var QUESTION_START = /^(?:what|who|whom|whose|where|when|why|how|which|is|are|was|were|do|does|did|can|could|will|would|should|have|has)\b/i;
-var PHRASAL_HOST = /* @__PURE__ */ new Set(["it", "this", "that", "them", "him", "her", "me", "us", "you", "up", "out", "off", "down", "back", "over", "away"]);
-function endsMidPhrase(text) {
-  const t = text.split("\n[")[0].trim();
-  if (!t || /[.?!…]["')\]]*$/.test(t)) return false;
-  if (/\b[a-z][\w+.-]*:\/\/\S+$/i.test(t)) return false;
-  if (/[,/\\:\-–—]$/.test(t)) return true;
-  const [last, prev] = (t.toLowerCase().match(/[\p{L}']+/gu) ?? []).reverse();
-  if (!last) return false;
-  if (TRAILING_PREPS.has(last)) return !QUESTION_START.test(t) && !PHRASAL_HOST.has(prev);
-  return MID_PHRASE_WORDS.has(last);
-}
 function nameScore(want, have) {
   const a = want.toLowerCase().replace(/[^\p{L}\p{N}]/gu, ""), b = have.toLowerCase().replace(/[^\p{L}\p{N}]/gu, "");
   if (!a || !b) return 0;
@@ -9601,7 +10196,7 @@ function isOfferAcceptance(text) {
 }
 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. A short yes or agreement right after you asked or offered something answers THAT question: act on it now (dispatch the work it needs) \u2014 never re-ask it, rephrase it, or narrow it into a new question. When the user says you looked in the wrong place, or doubts a "not found", do not defend the search you did: dispatch `Act` with their hint (the place, the id, the tool they name). Only say you checked or searched something you actually checked with a tool this conversation \u2014 name exactly what you looked at.\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 it ENDS mid-sentence or on a hesitation ("and then we", "but the problem is", "so I was, um") \u2014 call `Hold` instead of answering. A hesitation INSIDE a finished message ("can you, um, open it?") does not make it incomplete, and an unclear or odd but finished message is not a fragment: answer it, or ask one short question \u2014 never Hold on it. 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 \u2014 to stop everything ("stop all", "cancel everything") pass id "all". When the user restates, continues, or rephrases a question a still-running task is already answering, it is the SAME question \u2014 do not answer it yourself (the task\'s answer is coming; two answers confuse): say briefly that you are on it. When the user only ADDS to or CORRECTS a request whose task is still running (a detail, a path, a name, a spelling), call `Act` with `refines` set to that task id \u2014 it updates the running worker in place; never cancel and re-dispatch for a refinement.\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 (audio transcribed to text) and can carry transcription errors \u2014 odd words, cut-offs, homophones ("for you" vs "folder"), and especially MISHEARD NAMES: a surname, company, or project name often comes out as ordinary sound-alike words. Read for INTENT, not surface text, and do not silently rewrite what they said. If a message seems garbled, surprising, or only half-parses, or a word sounds like a name you already know (from memory or this conversation) but is spelled differently, treat it with suspicion \u2014 do NOT act on the odd word blindly or improvise content from it; briefly confirm what they meant ("did you mean\u2026?") and wait. A one-line confirm beats a confident wrong answer. NEVER save to memory a name, spelling, or term you only HEARD (it may be a transcription error) \u2014 when the user spells something aloud, read the spelling back and get a yes before storing it.';
+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. A short yes or agreement right after you asked or offered something answers THAT question: act on it now (dispatch the work it needs) \u2014 never re-ask it, rephrase it, or narrow it into a new question. When the user says you looked in the wrong place, or doubts a "not found", do not defend the search you did: dispatch `Act` with their hint (the place, the id, the tool they name). Only say you checked or searched something you actually checked with a tool this conversation \u2014 name exactly what you looked at.\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 it ENDS mid-sentence or on a hesitation ("and then we", "but the problem is", "so I was, um") \u2014 call `Hold` instead of answering. A hesitation INSIDE a finished message ("can you, um, open it?") does not make it incomplete, and an unclear or odd but finished message is not a fragment: answer it, or ask one short question \u2014 never Hold on it. 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 \u2014 to stop everything ("stop all", "cancel everything") pass id "all". When the user restates, continues, or rephrases a question a still-running task is already answering, it is the SAME question \u2014 do not answer it yourself (the task\'s answer is coming; two answers confuse): say briefly that you are on it. When the user only ADDS to or CORRECTS a request whose task is still running (a detail, a path, a name, a spelling), call `Act` with `refines` set to that task id \u2014 it updates the running worker in place; never cancel and re-dispatch for a refinement.\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 (audio transcribed to text) and can carry transcription errors \u2014 odd words, cut-offs, homophones ("for you" vs "folder"), and especially MISHEARD NAMES: a surname, company, or project name often comes out as ordinary sound-alike words. Read for INTENT, not surface text, and do not silently rewrite what they said. If a message seems garbled, surprising, or only half-parses, or a word sounds like a name you already know (from memory or this conversation) but is spelled differently, treat it with suspicion \u2014 do NOT act on the odd word blindly or improvise content from it; briefly confirm what they meant ("did you mean\u2026?") and wait. A one-line confirm beats a confident wrong answer. SPELLED-OUT WORDS: when the user spells something letter by letter (single letters joined by dashes or spaces, "dot" for "."), the spelling is EXACT and OVERRIDES the word you heard: assemble exactly those letters and use that string \u2014 never keep the sound-alike word, never blend the two, never add letters they did not say. A message noting `[spelled out letter by letter: "\u2026"]` has done the assembly for you. If you already used the heard word, say the corrected one back once.\nNEVER save to memory a name, spelling, or term you only HEARD (it may be a transcription error) \u2014 when the user spells something aloud, read the spelling back and get a yes before storing it.';
 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).`;
@@ -9768,7 +10363,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
           const m = this.reflexBuf.match(RESERVED_EVENT_MARKER) ?? this.reflexBuf.match(RESERVED_EVENT_OPENER);
           if (m) {
             this.fabricationCut = true;
-            log23.warn(`reflex fabricated a [task \u2026] event in its spoken stream \u2014 cutting it (kept ${m.index} chars)`);
+            log24.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;
@@ -9860,10 +10455,18 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
       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, repeat;
+      let ok = 0, leak, repeat, stub;
       for (const e of ends) {
         if (e <= ok) continue;
         const sent = region.slice(ok, e);
+        if (isFalseStart(sent)) {
+          const e2 = ends.find((x) => x > e);
+          if (e2 === void 0 && !final) break;
+          if (e2 !== void 0 && restarts(sent, region.slice(e, e2))) {
+            stub = [ok, e];
+            break;
+          }
+        }
         if (sent.trim() && !/[\p{L}\p{N}]/u.test(sent) || isRepeatOf(sent, this.turnSpoken + region.slice(0, ok))) {
           repeat = e;
           break;
@@ -9878,6 +10481,16 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
         ok = e;
       }
       this.forwardReflex(from + ok);
+      if (stub) {
+        const [a, b] = [from + stub[0], from + stub[1]];
+        this.repeatCuts.push(region.slice(stub[0], stub[1]).trim());
+        this.notify("diag", "reflex_stub", { text: region.slice(stub[0], stub[1]).trim().slice(0, 40) });
+        this.reflexBuf = this.reflexBuf.slice(0, a) + this.reflexBuf.slice(b);
+        this.stepMarks = this.stepMarks.map((k) => k >= b ? k - (b - a) : k > a ? a : k);
+        if (this.dispatchAt >= b) this.dispatchAt -= b - a;
+        else if (this.dispatchAt > a) this.dispatchAt = a;
+        continue;
+      }
       if (repeat !== void 0) {
         const cut = region.slice(ok, repeat).trim();
         if (/[\p{L}\p{N}]/u.test(cut)) {
@@ -9892,7 +10505,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
       this.leakHit = true;
       this.leakCuts.push(leak.trim().slice(0, 40));
       const why = this.cutKind === "claim" ? "stated a result no task has given yet" : this.cutKind === "restart" ? "started a second, restated reply" : "spoke its own analysis";
-      log23.warn(`reflex ${why} ("${leak.trim().slice(0, 40)}\u2026") \u2014 cut before TTS`);
+      log24.warn(`reflex ${why} ("${leak.trim().slice(0, 40)}\u2026") \u2014 cut before TTS`);
       this.notify("diag", this.cutKind === "claim" ? "result_claim" : this.cutKind === "restart" ? "reply_restart" : "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) {
@@ -9933,7 +10546,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
       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) => {
-      log23.warn(`leak judge failed \u2014 speaking the sentence: ${e.message}`);
+      log24.warn(`leak judge failed \u2014 speaking the sentence: ${e.message}`);
       return false;
     }).then((leak) => {
       clearTimeout(timer);
@@ -10005,7 +10618,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
       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) {
-        log23.warn("analysis leak cut, but its text was not found in the transcript to scrub");
+        log24.warn("analysis leak cut, but its text was not found in the transcript to scrub");
         continue;
       }
       const m = t[i];
@@ -10019,10 +10632,12 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
    *  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 ackedDispatch = !this.heldThisTurn && this.turnDispatched && this.spokeBeforeDispatch;
+    if (!this.heldThisTurn && !ackedDispatch) return;
+    const anchor = (n) => ackedDispatch ? n === "Act" || n === "Think" : n === "Hold";
     const t = this.voice.transcript;
     let i = this.turnBase;
-    while (i < t.length && !t[i].tool_calls?.some((c) => c.function.name === "Hold")) i++;
+    while (i < t.length && !t[i].tool_calls?.some((c) => anchor(c.function.name))) i++;
     for (let j = t.length - 1; j > i; j--) {
       const m = t[j];
       if (m.role !== "assistant" || !contentText(m.content).trim()) continue;
@@ -10060,7 +10675,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
     const res = await this.voice.send(content);
     const fb = this.options.reflexFallbackModel, model = this.voice.options.model;
     if (res.finishReason !== "error" || !rateLimited(res.error) || !fb || fb === model || fb.includes("/") && model.includes("/") && fb.split("/")[0] !== model.split("/")[0] || this.turnDispatched || this.turnSpoken.trim()) return res;
-    log23.warn(`reflex ${model} rate-limited \u2014 re-running the turn on ${fb}`);
+    log24.warn(`reflex ${model} rate-limited \u2014 re-running the turn on ${fb}`);
     this.notify("diag", "reflex_fallback", { from: model, to: fb });
     this.voice.transcript.length = base;
     this.voice.options.model = fb;
@@ -10093,7 +10708,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
     try {
       await this.voice.send(reminder);
     } catch (e) {
-      log23.warn(`follow-through nudge failed: ${e instanceof Error ? e.message : e}`);
+      log24.warn(`follow-through nudge failed: ${e instanceof Error ? e.message : e}`);
     } finally {
       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);
@@ -10154,7 +10769,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)) {
-          log23.verbose(`speculation aborted: reflex called ${call.name} on unconfirmed input`);
+          log24.verbose(`speculation aborted: reflex called ${call.name} on unconfirmed input`);
           this.abortSpeculation();
           return { block: true, reason: "Speculative turn aborted." };
         }
@@ -10236,7 +10851,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
     try {
       await this.voice.send(reminder);
     } catch (e) {
-      log23.warn(`ack nudge failed: ${e instanceof Error ? e.message : e}`);
+      log24.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);
@@ -10291,7 +10906,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
       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) => {
-        log23.warn(`bargeIntent judge failed \u2014 using the allowlist: ${e.message}`);
+        log24.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) });
@@ -10434,6 +11049,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
         this.voice.options.signal = signal;
         this.turnSignal = { own: signal, ext };
       }
+      if (typeof content === "string") content += spellingNote(content);
       let res;
       try {
         res = await this.reflexSend(content);
@@ -10487,7 +11103,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
       try {
         res = await this.voice.send(spec.text);
       } catch (e) {
-        log23.warn(`speculative turn failed: ${e instanceof Error ? e.message : e}`);
+        log24.warn(`speculative turn failed: ${e instanceof Error ? e.message : e}`);
       } finally {
         this.voice.options.signal = prevSignal;
       }
@@ -10501,7 +11117,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++;
-        log23.verbose(`speculation aborted (${this.speculativeAbortedCalls} total): "${spec.text.slice(0, 50)}"`);
+        log24.verbose(`speculation aborted (${this.speculativeAbortedCalls} total): "${spec.text.slice(0, 50)}"`);
         if (this.spec === spec) this.spec = void 0;
         return res ?? empty;
       }
@@ -10765,7 +11381,7 @@ Update: ${brief}`;
   }
   buildBrief(brief, tier = "act", deliver = true) {
     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 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. A command exiting 0 or echoing its input means it was ACCEPTED, not that it worked: before you say a web address was opened or reached, confirm it exists (its host resolves in DNS and answers an HTTP request); if it does not, report that it does not exist instead of success, and name the address you tried." : "";
     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. Never read a file path, URL, command or code aloud, nor spell one out ("slash \u2026 slash \u2026") \u2014 say it the way a person would, by the name of the folder, project, file or site; the exact text stays in your written prose. ' + (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()}.
 
@@ -10884,7 +11500,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") {
-      log23.warn(`task ${id}: verify inconclusive (${cres.finishReason})`);
+      log24.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;
@@ -11020,7 +11636,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";
-    log23.verbose(`task ${id} done (${res.steps} steps${incomplete ? `, INCOMPLETE: ${res.finishReason}` : ""})`);
+    log24.verbose(`task ${id} done (${res.steps} steps${incomplete ? `, INCOMPLETE: ${res.finishReason}` : ""})`);
     this.notify("task_done", `task ${id} (${rec.label}) completed`, {
       id,
       text: res.text,
@@ -11054,14 +11670,14 @@ Another agent just implemented the above. Independently check the CURRENT state
   foldIfSuperseded(rec, note) {
     if (rec.deliveryParked !== "moved_on") return false;
     if (note.trim()) this.voice.transcript.push({ role: "assistant", content: note });
-    log23.verbose(`task ${rec.id} settled but superseded (${rec.status}) \u2014 folded into transcript, not voiced`);
+    log24.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;
-    log23.warn(`task ${rec.id} failed: ${msg}`);
+    log24.warn(`task ${rec.id} failed: ${msg}`);
     this.notify("task_error", `task ${rec.id} (${rec.label}) failed: ${msg}`, { id: rec.id });
     if (this.foldIfSuperseded(rec, `The "${rec.label}" task failed: ${msg}`)) return;
     this.dropParked(rec);
@@ -11365,7 +11981,7 @@ Another agent just implemented the above. Independently check the CURRENT state
 init_llm();
 init_logging();
 init_models();
-var log24 = forComponent("ModelRouter");
+var log25 = forComponent("ModelRouter");
 var ModelRouterOptions = class {
   classifier = jevClassifier();
   /** Capability tiers → model id (any provider). basic/standard run the main session; premium is only ever an offload. */
@@ -11449,10 +12065,10 @@ var ModelRouter = class {
       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);
-      log24.warn(`classifier failed, falling back to standard: ${msg}`);
+      log25.warn(`classifier failed, falling back to standard: ${msg}`);
       d = { tier: "standard", model: o.models.standard, probs: {}, fallback: msg, classifyMs: Math.round(performance.now() - t0) };
     }
-    log24.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`);
+    log25.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`. */
@@ -11504,7 +12120,7 @@ ${text}`;
     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 };
-    log24.info(`offload ${cont ? "continue" : "fresh"} done \xB7 ${res.finishReason} \xB7 ${res.steps} steps`);
+    log25.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 };
   }
@@ -11520,7 +12136,7 @@ The request:
 ${text}`);
       return { text: r.text.trim() || text, usage: r.usage };
     } catch (e) {
-      log24.warn(`brief failed, sending the raw request: ${e instanceof Error ? e.message : String(e)}`);
+      log25.warn(`brief failed, sending the raw request: ${e instanceof Error ? e.message : String(e)}`);
       return { text };
     } finally {
       agent.transcript = snap;
@@ -11565,7 +12181,7 @@ async function jevAvailable(opts = {}) {
     const { env } = await loadJev(opts);
     return JEV_KEYS.some((k) => env[k]?.trim());
   } catch (e) {
-    log24.debug(`jev unavailable: ${e instanceof Error ? e.message : String(e)}`);
+    log25.debug(`jev unavailable: ${e instanceof Error ? e.message : String(e)}`);
     return false;
   }
 }
@@ -11843,6 +12459,979 @@ var RecordingLifecycle = class {
 
 // src/index.ts
 init_logging();
+
+// src/voice/call.ts
+init_logging();
+init_models();
+
+// src/voice/progress.ts
+init_logging();
+var log26 = forComponent("Progress");
+var HE_RESULT_CLAIM = /(?:^|\s)(?:מצאתי|סיימתי|בוצע|הנה|אין)(?=\s|$|[.,!…])/u;
+var TOPICS = [
+  [/kanban|board|card|\bkb\b|list_cards/, "board"],
+  [/mail|gmail|inbox/, "mail"],
+  [/calendar|event|schedule/, "calendar"],
+  [/memory|recall|remember/, "memory"],
+  [/web_?search|websearch|fetch|browse|url|page|tab|browser/, "web"],
+  [/grep|glob|search|find|lookup|quicklook/, "search"],
+  [/edit|write|patch|create|update|save|delete|move/, "write"],
+  [/shell|bash|exec|run|command|terminal/, "run"],
+  [/read|open|view|cat|look|get|list|ls/, "read"]
+];
+var PROGRESS_TEMPLATES = {
+  en: {
+    board: ["checking the board\u2026", "looking at the cards\u2026"],
+    mail: ["checking the mail\u2026", "going through the inbox\u2026"],
+    calendar: ["checking the calendar\u2026", "looking at the schedule\u2026"],
+    memory: ["checking my notes\u2026", "looking back\u2026"],
+    web: ["reading the page\u2026", "looking it up online\u2026"],
+    search: ["searching\u2026", "still looking\u2026"],
+    write: ["making the change\u2026", "writing it down\u2026"],
+    run: ["running it\u2026", "still running\u2026"],
+    read: ["reading it\u2026", "going through it\u2026"]
+  },
+  he: {
+    // plural present: gender-neutral for a voice of either gender
+    board: ["\u05D1\u05D5\u05D3\u05E7\u05D9\u05DD \u05D1\u05DC\u05D5\u05D7\u2026", "\u05DE\u05E1\u05EA\u05DB\u05DC\u05D9\u05DD \u05E2\u05DC \u05D4\u05DB\u05E8\u05D8\u05D9\u05E1\u05D9\u05DD\u2026"],
+    mail: ["\u05D1\u05D5\u05D3\u05E7\u05D9\u05DD \u05D0\u05EA \u05D4\u05DE\u05D9\u05D9\u05DC\u2026", "\u05E2\u05D5\u05D1\u05E8\u05D9\u05DD \u05E2\u05DC \u05D4\u05D3\u05D5\u05D0\u05E8\u2026"],
+    calendar: ["\u05D1\u05D5\u05D3\u05E7\u05D9\u05DD \u05D1\u05D9\u05D5\u05DE\u05DF\u2026", "\u05DE\u05E1\u05EA\u05DB\u05DC\u05D9\u05DD \u05D1\u05DC\u05D5\u05F4\u05D6\u2026"],
+    memory: ["\u05D1\u05D5\u05D3\u05E7\u05D9\u05DD \u05D1\u05E8\u05E9\u05D9\u05DE\u05D5\u05EA\u2026", "\u05DE\u05D7\u05E4\u05E9\u05D9\u05DD \u05D1\u05D6\u05D9\u05DB\u05E8\u05D5\u05DF\u2026"],
+    web: ["\u05E7\u05D5\u05E8\u05D0\u05D9\u05DD \u05D0\u05EA \u05D4\u05D3\u05E3\u2026", "\u05DE\u05D7\u05E4\u05E9\u05D9\u05DD \u05D1\u05E8\u05E9\u05EA\u2026"],
+    search: ["\u05DE\u05D7\u05E4\u05E9\u05D9\u05DD\u2026", "\u05E2\u05D3\u05D9\u05D9\u05DF \u05DE\u05D7\u05E4\u05E9\u05D9\u05DD\u2026"],
+    write: ["\u05DE\u05D1\u05E6\u05E2\u05D9\u05DD \u05D0\u05EA \u05D4\u05E9\u05D9\u05E0\u05D5\u05D9\u2026", "\u05DB\u05D5\u05EA\u05D1\u05D9\u05DD \u05D0\u05EA \u05D6\u05D4\u2026"],
+    run: ["\u05DE\u05E8\u05D9\u05E6\u05D9\u05DD\u2026", "\u05E2\u05D3\u05D9\u05D9\u05DF \u05E8\u05E5\u2026"],
+    read: ["\u05E7\u05D5\u05E8\u05D0\u05D9\u05DD\u2026", "\u05E2\u05D5\u05D1\u05E8\u05D9\u05DD \u05E2\u05DC \u05D6\u05D4\u2026"]
+  }
+};
+var ProgressOptions = class {
+  templates = PROGRESS_TEMPLATES;
+  /** Fast-model fallback for a tool with no template (fastProgressGenerator). Absent → silence. */
+  generate;
+  generateBudgetMs = 800;
+  /** Speak only when nothing has been audible for this long. */
+  silenceMs = 3e3;
+  /** At most one progress line per this long. */
+  gapMs = 4e3;
+  now = () => performance.now();
+};
+function argsHint(args) {
+  if (!args || typeof args !== "object") return typeof args === "string" ? args.slice(0, 40) : "";
+  const s = Object.values(args).find((v) => typeof v === "string" && v.trim());
+  return typeof s === "string" ? s.trim().replace(/\s+/g, " ").slice(0, 40) : "";
+}
+var Progress = class {
+  constructor(options) {
+    this.options = options;
+    this.options = { ...new ProgressOptions(), ...options };
+  }
+  options;
+  said = /* @__PURE__ */ new Set();
+  lastAt = -Infinity;
+  streamed = false;
+  get o() {
+    return this.options;
+  }
+  /** A new MAIN turn started. */
+  turn() {
+    this.streamed = false;
+  }
+  /** MAIN's text streamed this turn: no more progress lines for it. */
+  text() {
+    this.streamed = true;
+  }
+  /** May a line play now? (the caller passes when the user last heard anything) */
+  due(lastAudibleAt) {
+    const now3 = this.o.now();
+    return !this.streamed && now3 - lastAudibleAt >= this.o.silenceMs && now3 - this.lastAt >= this.o.gapMs;
+  }
+  /** Mark `line` spoken. */
+  spoke(line) {
+    this.said.add(norm3(line));
+    this.lastAt = this.o.now();
+  }
+  /** The line for this tool call in `lang`, or '' (no template and no/late/invalid generation, a repeat, a result claim). */
+  async line(tool, args, lang) {
+    if (this.streamed) return "";
+    const name = tool.toLowerCase();
+    const topic = TOPICS.find(([re]) => re.test(name))?.[1];
+    const pool = topic ? this.o.templates[lang]?.[topic] ?? [] : [];
+    const fresh = pool.find((l2) => !this.said.has(norm3(l2)));
+    if (fresh) return fresh;
+    if (!this.o.generate) return "";
+    const ac = new AbortController();
+    let t;
+    const late = new Promise((r) => {
+      t = setTimeout(() => {
+        ac.abort();
+        r(null);
+      }, this.o.generateBudgetMs);
+    });
+    const raw = await Promise.race([this.o.generate(tool, argsHint(args), lang, ac.signal).catch((e) => {
+      log26.warn(`progress line failed: ${e?.message ?? e}`);
+      return null;
+    }), late]).finally(() => clearTimeout(t));
+    const l = cleanLine(raw ?? "", lang, 5);
+    if (!l || RESULT_CLAIM_RE.test(l) || HE_RESULT_CLAIM.test(l) || this.said.has(norm3(l)) || this.streamed) return "";
+    return l;
+  }
+};
+function fastProgressGenerator(ai, model) {
+  return async (tool, hint, lang, signal) => {
+    const prompt = `An assistant on a live voice call is running the tool "${tool}"${hint ? ` (about: "${hint}")` : ""}. Write ONE spoken line of 2-5 words, in ${languageName(lang)}, saying what it is doing right now (like "checking the board\u2026"). Never state a result or a finding. Output only the line.`;
+    const reasoning = /gpt-oss/.test(model) ? { providerOptions: { reasoning_effort: "low" } } : {};
+    const r = await ai.chat({ model, messages: [{ role: "user", content: prompt }], stream: false, signal, maxTokens: 150, ...reasoning });
+    return r.content ?? "";
+  };
+}
+
+// src/voice/secondChannel.ts
+init_logging();
+
+// src/voice/backchannelPlan.ts
+init_logging();
+var log27 = forComponent("BackchannelPlan");
+var silentTurn = (p) => p.density === "none" || p.turn === "short_command" || p.turn === "question";
+var cueWords = (s) => s.toLowerCase().replace(/[^\p{L}\p{N}'\s]+/gu, " ").split(/\s+/).filter(Boolean);
+function matchCue(plan, heard, from = 0) {
+  if (!plan || silentTurn(plan)) return null;
+  const w = cueWords(heard);
+  for (let i = Math.max(0, from); i < w.length; i++) {
+    for (const c of plan.cues) {
+      for (const p of c.when) {
+        const pw = p.split(" ");
+        if (i + pw.length <= w.length && pw.every((x, j) => w[i + j] === x)) return c;
+      }
+    }
+  }
+  return null;
+}
+
+// src/voice/secondChannel.ts
+var log28 = forComponent("SecondChannel");
+var CHANNEL_MODES = {
+  turn: { kinds: ["bridge"], bridgeDelayMs: 1500 },
+  normal: {},
+  chatty: {
+    anticipate: true,
+    cueOnly: false,
+    generateFor: ["backchannel", "bridge"],
+    reactionGapMs: 6e3,
+    generateBudgetMs: 400,
+    // A breath must outlast the word cadence: at ~2.5 words/s interims arrive every ~400ms, so a 250ms "breath" fired after
+    // every word and only the 1.2s gaps held it (~25 lines per 30s, live probe). Lines ≥2.5s apart (light after light 3s), ≤6 in any 30s.
+    backchannelMinWords: 5,
+    backchannelGapMs: 3e3,
+    minGapMs: 2500,
+    backchannelPauseMs: 500,
+    maxPerWindow: 6
+  }
+};
+var CHANNEL_MODE_NAMES = Object.keys(CHANNEL_MODES);
+var SecondChannelOptions = class {
+  /** Preset (CHANNEL_MODES) under the explicit options. */
+  mode = "normal";
+  /** Line kinds this channel may speak. */
+  kinds = ["backchannel", "filler", "bridge"];
+  /** A generated (content) backchannel needs this long since the last one; in between, canned light cues. 0 = always. */
+  reactionGapMs = 0;
+  /** Refiner (Jev/fast LLM): the choice over CHANNEL_ACTIONS, or null on failure. Absent → the rule alone decides.
+   *  `state.rule` is the kind the rule proposed (fastChannelDecider answers yes/no on it). `signal` aborts a late call. */
+  decide;
+  /** Fast-model line writer (see fastLineGenerator). Absent or late → the canned bank. */
+  generate;
+  /** Per-language banks (ChannelBanks). Absent → the hardcoded English bank, and silence in any other language. */
+  banks;
+  /** The host's language (BCP-47; pinned — detection never overrides it). Absent → unknown until the user's words
+   *  tell it confidently; the channel is silent until then (never English by default). */
+  lang;
+  /** Kinds worth generating (content-conditioned); the rest are canned sounds. */
+  generateFor = ["bridge"];
+  // a backchannel is timing, not content: canned at 0ms (a generated one arrived after the micro-pause)
+  /** Host TTS on the second channel; resolves when the line finished playing. `false` = the host could not play it. */
+  speak = () => {
+  };
+  /** Host UI (caption / muted line) — never history. */
+  show = () => {
+  };
+  /** Stop the in-flight line's audio now (barge-in only). */
+  cancel = () => {
+  };
+  onEvent = () => {
+  };
+  /** Echo cancellation on: backchannels may play while the user speaks. Off (half-duplex) → fillers/bridges in silences only. */
+  aec = false;
+  decideEveryWords = 3;
+  decisionBudgetMs = 300;
+  generateBudgetMs = 500;
+  minGapMs = 2500;
+  /** Backchannel after backchannel needs this gap (~4-6 cues in a 30s monologue — Para phone call 2026-10-13: 5s left
+   *  one cue in a long statement). */
+  backchannelGapMs = 3e3;
+  /** Soft cap: at most this many backchannels in any `windowMs` (0 = none). */
+  maxPerWindow = 0;
+  windowMs = 3e4;
+  /** The user resumes within this long of their last words after a line of theirs was dispatched: the same statement goes
+   *  on (an STT endpoint mid-monologue) — its words still count toward the backchannel guards, and it is no fresh request. */
+  continueMs = 3e3;
+  /** A decision whose partial grew by this many words while in flight is stale → dropped. */
+  staleWords = 3;
+  microWords = 30;
+  avoidLines = 4;
+  /** Canned picks exclude the last N picks of the same kind. */
+  bankExclude = 2;
+  /** A backchannel needs a substantial chunk first: a turn of ≤8 words is a request/answer, not a story (replay: most
+   *  misplaced "mm-hm"s fired at words 6-8 of a short command). */
+  backchannelMinWords = 10;
+  /** A turn that opens as a question/command (requestOpener) holds backchannels until it has grown into an explanation. */
+  requestHoldWords = 18;
+  /** No new interim for this long mid-utterance (a breath / clause gap, shorter than a pause) → a backchannel moment. */
+  backchannelPauseMs = 350;
+  /** A bridge waits this long after the user's turn is dispatched, and plays only if channel-1 has said nothing yet
+   *  (a fast reply/ack needs no bridge — one before it reads as the agent starting a different sentence). 0 = at once. */
+  bridgeDelayMs = 1200;
+  /** No new interim for this long → a pause (hosts may also call onPause). */
+  fillerPauseMs = 700;
+  fillerMinWords = 4;
+  bridgeMinWords = 5;
+  /** ANTICIPATE (backchannelPlan.ts): plan the user's next turn off the hot path (after the agent's reply / at turn start,
+   *  revised once at `reviseAtWords`); live, a backchannel fires only on a planned cue, at a `cuePauseMs` breath, with the
+   *  cue's line and no decider call. A silent plan (short command / question / density none) vetoes backchannels. No plan
+   *  yet / failed / late → the reactive path. Off by default (AGENTX_CHANNEL_ANTICIPATE=1). */
+  anticipate = false;
+  plan;
+  planBudgetMs = 4e3;
+  reviseAtWords = 7;
+  /** A predicted moment needs only a short breath (the decision is already made). */
+  cuePauseMs = 200;
+  /** A cue counts only within the last N words (older matches were gated or passed). */
+  cueWindow = 6;
+  /** true: a plan fires on its cues only. false: a non-silent plan with density normal/high also lets the reactive breath
+   *  backchannel through (the plan then only vetoes short commands / questions / low density). */
+  cueOnly = true;
+  onPlan = () => {
+  };
+  now = () => performance.now();
+  random = Math.random;
+};
+var words2 = (s) => s.trim() ? s.trim().split(/\s+/) : [];
+function withBudget(p, ms, what, ac) {
+  let t;
+  const late = new Promise((r) => {
+    t = setTimeout(() => {
+      log28.debug(`${what}: over the ${ms}ms budget \u2014 dropped`);
+      ac?.abort();
+      r(null);
+    }, ms);
+  });
+  return Promise.race([p.catch((e) => {
+    const msg = String(e?.message ?? e);
+    if (e?.name === "AbortError" || /aborted/i.test(msg)) log28.debug(`${what}: aborted after its budget`);
+    else log28.warn(`${what} failed \u2014 falling back: ${msg}`);
+    return null;
+  }), late]).finally(() => clearTimeout(t));
+}
+var SecondChannel = class {
+  constructor(options) {
+    this.options = options;
+    const preset = CHANNEL_MODES[options?.mode ?? "normal"] ?? {};
+    const base = new SecondChannelOptions();
+    this.options = { ...base, ...preset, ...options };
+    for (const k of Object.keys(preset)) if (!options || !(k in options)) this.normalTiming[k] = base[k];
+    this.startedAt = this.o.now();
+    if (this.o.lang) this.setLanguage(this.o.lang, true);
+  }
+  options;
+  heard = "";
+  userSpeaking = false;
+  main = "idle";
+  gen = 0;
+  // bumped by barge-in / a new user turn → in-flight decisions drop
+  decidedAt = 0;
+  // word count at the last decision
+  busy = false;
+  pauseTimer = null;
+  bcTimer = null;
+  bridgeTimer = null;
+  lastAt = -Infinity;
+  lastKind = null;
+  live = null;
+  // our last line, until channel-1 audio takes the floor
+  cutLine = null;
+  // the line the last barge actually cut (spoke())
+  bridged = false;
+  // one bridge per main turn
+  recent = [];
+  picks = /* @__PURE__ */ new Map();
+  inflight = null;
+  startedAt;
+  lang = null;
+  carried = 0;
+  // words of this statement already dispatched (a monologue split by STT endpoints)
+  floorWords = 0;
+  // carried + the last dispatched line's words
+  lastHeardAt = -Infinity;
+  pinned = false;
+  // anticipate: the plan for the user's current/next turn (turnNo bumps per dispatched turn → a late plan is dropped)
+  turnNo = 0;
+  plan = null;
+  planning = false;
+  planTries = 0;
+  // per turn: the reply-end plan + one turn-start retry, never a call per interim
+  revised = false;
+  cueFrom = 0;
+  // word index after the last planned backchannel
+  reply = "";
+  // channel-1's text this turn (the plan's context)
+  lastUser = "";
+  lastReactAt = -Infinity;
+  normalTiming = {};
+  // chatty without aec: the preset's keys back at their defaults
+  degradedLogged = false;
+  /** The language lines are spoken in (detected from the user's words, or set by the host). */
+  get language() {
+    return this.lang;
+  }
+  /** Switch language: its bank starts loading in the background. `host` = the host's STT-reported language — it pins
+   *  the language (later detection never overrides it; only another host call does). Tags normalize to 'he-IL' → 'he'. */
+  setLanguage(tag, host = false) {
+    if (!tag || this.pinned && !host) return;
+    if (host) this.pinned = true;
+    const lang = primaryLang(tag);
+    if (!lang || lang === this.lang) return;
+    log28.debug(`language ${this.lang} \u2192 ${lang}`);
+    this.lang = lang;
+    this.recent = [];
+    this.picks.clear();
+    void this.o.banks?.ensure(lang);
+  }
+  /** Once a language is known, switching needs strong evidence (detectLanguage's `switching`): an English "Um," read as
+   *  Portuguese flipped a live session to pt (silence until a pt bank was generated — it then spoke Portuguese). */
+  detect(text) {
+    if (this.pinned) return;
+    const l = detectLanguage(text, !!this.lang);
+    if (l) this.setLanguage(l);
+  }
+  get bank() {
+    return this.lang ? this.o.banks ? this.o.banks.get(this.lang) : this.lang === "en" ? EN_BANK : null : null;
+  }
+  get o() {
+    const o = this.options;
+    return o.mode !== "chatty" || o.aec ? o : { ...o, ...this.normalTiming };
+  }
+  /** The user's live partial for the current turn (the whole partial, not a delta). */
+  onInterim(text) {
+    const t = text.trim();
+    if (!t || t === this.heard) return;
+    if (this.main !== "idle" || !this.heard) this.carried = this.o.now() - this.lastHeardAt < this.o.continueMs ? this.floorWords : 0;
+    this.lastHeardAt = this.o.now();
+    if (this.main !== "idle") this.onAgentState("idle");
+    this.heard = t;
+    this.detect(t);
+    this.userSpeaking = true;
+    if (this.pauseTimer) clearTimeout(this.pauseTimer);
+    this.pauseTimer = setTimeout(() => {
+      this.pauseTimer = null;
+      this.onPause(this.o.fillerPauseMs);
+    }, this.o.fillerPauseMs);
+    let cue = null;
+    if (this.o.anticipate) {
+      const n = words2(t).length;
+      if (!this.plan && !this.planning && this.planTries < 2) this.requestPlan();
+      else if (this.plan && !this.revised && n >= this.o.reviseAtWords) {
+        this.revised = true;
+        this.requestPlan(t);
+      }
+      cue = matchCue(this.plan, t, Math.max(this.cueFrom, n - this.o.cueWindow));
+    }
+    if (this.bcTimer) clearTimeout(this.bcTimer);
+    this.bcTimer = this.o.aec ? setTimeout(() => {
+      this.bcTimer = null;
+      if (this.userSpeaking && this.heard === t) void this.consider("interim", 0, true, cue);
+    }, cue ? this.o.cuePauseMs : this.o.backchannelPauseMs) : null;
+    if (words2(t).length - this.decidedAt >= this.o.decideEveryWords) void this.consider("interim");
+  }
+  /** The user went quiet for `ms` (host VAD/STT pause, or the internal interim timer). */
+  onPause(ms) {
+    if (this.pauseTimer) {
+      clearTimeout(this.pauseTimer);
+      this.pauseTimer = null;
+    }
+    if (this.bcTimer) {
+      clearTimeout(this.bcTimer);
+      this.bcTimer = null;
+    }
+    this.userSpeaking = false;
+    void this.consider("pause", ms);
+  }
+  /** Channel-1 lifecycle. `queued` = the user's turn was dispatched to the main agent. */
+  onAgentState(s) {
+    if (s === this.main) return;
+    this.main = s;
+    if (s === "first_audio" || s === "speaking") this.live = null;
+    if (s !== "queued" && s !== "thinking" && this.bridgeTimer) {
+      clearTimeout(this.bridgeTimer);
+      this.bridgeTimer = null;
+    }
+    if (s === "idle") {
+      this.heard = "";
+      this.decidedAt = 0;
+      this.bridged = false;
+      this.cueFrom = 0;
+      if (this.o.anticipate && this.reply.trim() && !this.plan && !this.planning) this.requestPlan();
+      return;
+    }
+    if (s === "queued") {
+      this.turnNo++;
+      this.plan = null;
+      this.planning = false;
+      this.planTries = 0;
+      this.revised = false;
+      this.reply = "";
+      this.gen++;
+      this.userSpeaking = false;
+      this.bridged = false;
+      if (this.lastKind === "bridge") this.lastKind = null;
+      for (const k of ["pauseTimer", "bcTimer", "bridgeTimer"]) {
+        if (this[k]) clearTimeout(this[k]);
+        this[k] = null;
+      }
+      const wait = Math.max(this.o.bridgeDelayMs, this.o.minGapMs - (this.o.now() - this.lastAt));
+      if (wait > 0) this.bridgeTimer = setTimeout(() => {
+        this.bridgeTimer = null;
+        void this.consider("working");
+      }, wait);
+      else void this.consider("working");
+    }
+  }
+  /** The user's final line was dispatched to the main agent (its words are the bridge's micro-context). */
+  onUserTurn(text) {
+    this.heard = text.trim();
+    this.floorWords = this.carried + words2(this.heard).length;
+    this.lastUser = this.heard;
+    this.detect(this.heard);
+    this.main = "idle";
+    this.onAgentState("queued");
+  }
+  /** The main answer's streamed text (before its audio): channel-1 is responding — no bridge from here on. */
+  onMainTokens(text) {
+    this.noteReply(text);
+    if (text.trim() && (this.main === "queued" || this.main === "thinking")) this.onAgentState("streaming_text");
+  }
+  /** Channel-1's reply text (a delta) — only the plan's context; no state change (hosts without onMainTokens). */
+  noteReply(text) {
+    this.reply += text;
+  }
+  /** The user barged in: cut the in-flight line now and drop every pending decision. */
+  onBargeIn() {
+    this.gen++;
+    this.cutLine = this.inflight || this.live ? this.live : null;
+    if (this.inflight) {
+      this.inflight = null;
+      try {
+        this.o.cancel();
+      } catch (e) {
+        log28.warn(`cancel threw: ${e.message}`);
+      }
+    }
+  }
+  /** Is `text` the line the last barge-in cut (ours, still holding the floor)? Hosts strip it from the cut reply — it is
+   *  not the agent's speech. By identity, not by text: a real reply that merely repeats a recent line is kept. Consumed once. */
+  spoke(text) {
+    const c = this.cutLine;
+    this.cutLine = null;
+    return !!c && c === text.trim();
+  }
+  /** Resolves when the in-flight line finished playing (immediately when none) — hosts enqueue channel-1 audio behind it. */
+  drain() {
+    return this.inflight ?? Promise.resolve();
+  }
+  /** Channel-1's last reply ended on a CLOSED question (yes/no, "X or Y?", a confirm): the user's current turn answers or
+   *  corrects it. An open invitation ("what happened?") is different — a story follows, and reactions fit it. */
+  get answeringUs() {
+    return this.main === "idle" && closedQuestion(this.reply);
+  }
+  get audioLocked() {
+    return this.main === "first_audio" || this.main === "speaking";
+  }
+  tail() {
+    return words2(this.heard).slice(-this.o.microWords).join(" ");
+  }
+  /** Hard gates every line passes, whoever proposed it. */
+  allowed(k) {
+    if (!this.o.kinds.includes(k)) return false;
+    if (this.audioLocked || this.inflight || this.o.now() - this.lastAt < this.o.minGapMs || k === this.lastKind && (k !== "backchannel" || this.o.now() - this.lastAt < this.o.backchannelGapMs)) return false;
+    if (k === "backchannel") return this.o.aec && this.userSpeaking && this.main === "idle" && !this.capped();
+    if (k === "filler") return !this.userSpeaking && this.main === "idle";
+    return (this.main === "queued" || this.main === "thinking") && !this.bridged;
+  }
+  bcTimes = [];
+  capped() {
+    if (!this.o.maxPerWindow) return false;
+    const from = this.o.now() - this.o.windowMs;
+    this.bcTimes = this.bcTimes.filter((t) => t > from);
+    return this.bcTimes.length >= this.o.maxPerWindow;
+  }
+  /** 0ms rule: the candidate line for this trigger, or silence. */
+  rule(trigger, pauseMs = 0, breath = false, cue = null) {
+    const w = words2(this.heard);
+    if (!this.lang) return "silence";
+    if (w.length <= 3 || w.length <= 6 && isPhatic(this.heard, this.bank)) return "silence";
+    const k = trigger === "interim" ? this.backchannelMoment(w.length, breath) && (!this.o.anticipate || !this.plan || !silentTurn(this.plan) && (!!cue || !this.o.cueOnly && this.plan.density !== "low")) ? "backchannel" : null : trigger === "pause" ? pauseMs >= this.o.fillerPauseMs && w.length >= this.o.fillerMinWords ? "filler" : null : w.length >= this.o.bridgeMinWords ? "bridge" : null;
+    return k && this.allowed(k) ? k : "silence";
+  }
+  /** Plan (or, with `heard`, revise) the backchannels of the user's turn — async, never on the hot path. */
+  requestPlan(heard) {
+    if (!this.o.plan || !this.lang) return;
+    const turn = this.turnNo, t0 = this.o.now(), ac = new AbortController();
+    if (!heard) {
+      this.planning = true;
+      this.planTries++;
+    }
+    const ctx = { agent: this.reply.trim(), user: words2(this.lastUser).slice(-30).join(" "), recent: [...this.recent], lang: this.lang, heard };
+    void withBudget(this.o.plan(ctx, ac.signal), this.o.planBudgetMs, heard ? "plan revision" : "plan").then((p) => {
+      if (p === null) ac.abort();
+      if (turn !== this.turnNo) return;
+      if (!heard) this.planning = false;
+      if (!p) return;
+      this.plan = p;
+      this.o.onPlan(p, !!heard, Math.round(this.o.now() - t0));
+    });
+  }
+  /** A clause boundary mid-floor: a breath or a comma-like close. Not a question (it wants the answer, not "mm-hm"), and a
+   *  sentence end only deep into a story — a short request's end is the end of their turn (replay: "mm-hm" right after
+   *  "Check hacker news for recent news.", just before the final). */
+  backchannelMoment(n, breath) {
+    if (/\?$/.test(this.heard) || pendingQuestion(this.heard)) return false;
+    if (this.carried) n += this.carried;
+    else if (n < this.o.requestHoldWords && requestOpener(this.heard)) return false;
+    if (n < this.o.backchannelMinWords) return false;
+    if (/[.!]$/.test(this.heard)) return n >= 2 * this.o.backchannelMinWords;
+    return breath || /[,;:…]$/.test(this.heard);
+  }
+  async consider(trigger, pauseMs, breath = false, cue = null) {
+    if (this.busy) return;
+    const n0 = words2(this.heard).length;
+    this.decidedAt = n0;
+    if (!(this.o.anticipate && this.plan && trigger === "interim")) cue = null;
+    const opts = this.options;
+    if (opts.mode === "chatty" && !opts.aec && !this.degradedLogged) {
+      this.degradedLogged = true;
+      log28.info("chatty mode without echo cancellation \u2014 normal timing (our lines would re-trigger the mic)");
+    }
+    const rule = this.rule(trigger, pauseMs, breath, cue);
+    if (rule === "silence") return;
+    this.busy = true;
+    const gen = this.gen, t0 = this.o.now();
+    const ev = (e) => this.o.onEvent({ trigger, rule, ms: Math.round(this.o.now() - t0), ...cue ? { cue: cue.line } : {}, ...e });
+    const stale = () => gen !== this.gen || words2(this.heard).length - n0 >= this.o.staleWords;
+    try {
+      let kind = rule;
+      let choice;
+      if (this.o.decide && !cue) {
+        const ac = new AbortController();
+        const d = await withBudget(this.o.decide(this.tail(), { ...this.state(pauseMs), rule }, ac.signal), this.o.decisionBudgetMs, "channel decision", ac);
+        choice = d?.choice;
+        if (choice && choice in CHANNEL_ACTIONS && (choice === "silence" || this.allowed(choice))) kind = choice;
+        else if (choice && choice in CHANNEL_ACTIONS) log28.debug(`decider chose ${choice} for a ${rule} moment \u2014 the rule stands`);
+      }
+      if (kind === "silence") return ev({ choice, acted: "silence" });
+      if (stale()) return ev({ choice, kind, acted: "stale" });
+      if (!this.allowed(kind)) return ev({ choice, kind, acted: "gated" });
+      const react = kind === "backchannel" && !this.answeringUs && this.o.now() - this.lastReactAt >= this.o.reactionGapMs;
+      const text = cue && react && !this.recent.some((r) => norm3(r) === norm3(cue.line)) ? cue.line : await this.line(kind, react);
+      if (!text) return ev({ choice, kind, acted: "no_bank" });
+      if (stale()) return ev({ choice, kind, text, acted: "stale" });
+      if (!this.allowed(kind)) return ev({ choice, kind, text, acted: "gated" });
+      const said = this.say(kind, text);
+      if (said && cue) this.cueFrom = words2(this.heard).length;
+      if (said && kind === "backchannel" && this.o.reactionGapMs && !this.bank?.backchannel.some((b) => norm3(b) === norm3(text))) this.lastReactAt = this.o.now();
+      ev({ choice, kind, text, acted: said ? "spoken" : "skipped" });
+    } finally {
+      this.busy = false;
+    }
+  }
+  state(pauseMs) {
+    const now3 = this.o.now();
+    return {
+      user_speaking: this.userSpeaking,
+      pause_ms: pauseMs ?? null,
+      agent_state: this.main,
+      last_line: this.recent.at(-1) ?? null,
+      ms_since_last_line: Number.isFinite(this.lastAt) ? Math.round(now3 - this.lastAt) : null,
+      call_ms: Math.round(now3 - this.startedAt)
+    };
+  }
+  async line(kind, react = true) {
+    if (this.o.generate && this.o.generateFor.includes(kind) && (kind !== "backchannel" || react)) {
+      const ac = new AbortController();
+      const ctx = { kind, heard: this.tail(), state: this.main, avoid: [...this.recent], lang: this.lang, ...kind === "backchannel" && this.o.reactionGapMs ? { react: true } : {} };
+      const raw = await withBudget(this.o.generate(ctx, ac.signal), this.o.generateBudgetMs, `${kind} generate`);
+      if (raw === null) ac.abort();
+      const text = cleanLine(raw ?? "", this.lang);
+      if (text && !this.recent.some((r) => norm3(r) === norm3(text))) return text;
+      if (text) log28.debug(`generated "${text}" repeats a recent line \u2014 canned`);
+    }
+    return this.pick(kind);
+  }
+  /** Canned rotation in the user's language: never one of the last `bankExclude` picks of this kind, nor a recent
+   *  line. '' = no bank for this language yet (silence). */
+  pick(kind) {
+    const pool = this.bank?.[kind] ?? [];
+    if (!pool.length) return "";
+    const hist = this.picks.get(kind) ?? [];
+    const recent = new Set([...hist.slice(-this.o.bankExclude), ...this.recent].map(norm3));
+    const fresh = pool.filter((x) => !recent.has(norm3(x)));
+    const from = fresh.length ? fresh : pool;
+    const p = from[Math.floor(this.o.random() * from.length)];
+    this.picks.set(kind, [...hist, p].slice(-this.o.bankExclude));
+    return p;
+  }
+  say(kind, text) {
+    let r;
+    try {
+      r = this.o.speak(text, kind);
+    } catch (e) {
+      log28.warn(`speak threw \u2014 line dropped: ${e.message}`);
+      return false;
+    }
+    if (r === false) return false;
+    this.lastAt = this.o.now();
+    this.lastKind = kind;
+    if (kind === "backchannel") this.bcTimes.push(this.lastAt);
+    if (kind === "bridge") this.bridged = true;
+    this.recent = [...this.recent, text].slice(-this.o.avoidLines);
+    this.live = text.trim();
+    this.o.show(text, kind);
+    const p = Promise.resolve(r).then(() => {
+    }, (e) => {
+      log28.warn(`channel line playback failed: ${e?.message ?? e}`);
+    }).finally(() => {
+      if (this.inflight === p) this.inflight = null;
+    });
+    this.inflight = p;
+    return true;
+  }
+};
+var FAST_ASK = {
+  backchannel: 'The user is still talking and just took a breath. Would an attentive human listener say a tiny "mm-hm" now? Yes ONLY if they are telling a story/explaining across several clauses. No if it is a request, command, question, or they are mid-request.',
+  filler: 'The user went quiet mid-turn. Would a human listener make a soft "hmm\u2026" now? Yes ONLY if their sentence is unfinished and they are searching for words. No if they said a complete request, question, answer, thanks or remark (the reply comes next).',
+  bridge: `The user finished and the assistant's answer is taking a moment. Would a human say a short "let me check\u2014" now? Yes if they asked for real work or a substantial/hard question. No for small talk, a greeting, thanks, an ok/yes/agreement.`
+};
+function fastChannelDecider(ai, model = "groq/qwen/qwen3.8-27b") {
+  return async (heard, state, signal) => {
+    const kind = state.rule;
+    if (!(kind in FAST_ASK)) return null;
+    const prompt = `Live voice call. ${FAST_ASK[kind]}
+So far the user said: "${heard}"
+Answer yes or no.`;
+    const reasoning = /qwen/.test(model) ? { providerOptions: { reasoning_effort: "none" } } : /gpt-oss/.test(model) ? { providerOptions: { reasoning_effort: "low" } } : {};
+    const r = await ai.chat({ model, messages: [{ role: "user", content: prompt }], stream: false, signal, temperature: 0, maxTokens: /gpt-oss/.test(model) ? 200 : 3, ...reasoning });
+    const a = (r.content ?? "").trim().toLowerCase();
+    return /^yes/.test(a) ? { choice: kind } : /^no/.test(a) ? { choice: "silence" } : null;
+  };
+}
+function channelDecide(ai, instinct, env = process.env) {
+  const model = env.AGENTX_CHANNEL_DECIDER_MODEL || void 0;
+  if (model || env.GROQ_API_KEY) return fastChannelDecider(ai, model);
+  return instinct ? (heard, state) => instinct.channel(heard, state) : void 0;
+}
+var KIND_HINT2 = {
+  backchannel: 'a tiny listener cue while they keep talking ("mm-hm", "right", "yeah") \u2014 shows you follow, never takes the turn',
+  filler: 'a soft listener sound while THEY search for words ("mm\u2026", "mhm", "yeah\u2026") \u2014 never a word that continues their sentence or starts yours',
+  bridge: 'a neutral one-moment cue while the answer is prepared ("let me see\u2026", "one sec\u2026") \u2014 never the start of a statement or opinion ("the thing is", "well actually")'
+};
+var REACT_HINT = 'a short reaction to their LAST words instead: feeling ("oh no", "ha, nice", "ugh"), surprise ("wait, really?", "huh"), a light laugh if they joke or laugh ("ha!"), or an echo of their key word ("the deploy?") \u2014 still never asks for an answer or takes the turn; if nothing there deserves a reaction, a plain "mm-hm"';
+function fastLineGenerator(ai, model) {
+  return async (c, signal) => {
+    const prompt = `You voice the tiny side-sounds of a live spoken conversation. Write ONE line of 1-5 words: ${KIND_HINT2[c.kind]}.
+` + (c.react ? `Here the line may be ${REACT_HINT}.
+` : "") + `The user just said: "${c.heard}"
+The assistant is: ${c.state}.
+` + (c.avoid.length ? `Do not reuse any of: ${c.avoid.map((a) => `"${a}"`).join(", ")}.
+` : "") + `React to their actual words, casually, in ${languageName(c.lang)}. Output only the line.`;
+    const reasoning = /gpt-oss/.test(model) ? { providerOptions: { reasoning_effort: "low" } } : {};
+    const r = await ai.chat({ model, messages: [{ role: "user", content: prompt }], stream: false, signal, maxTokens: 150, ...reasoning });
+    return r.content ?? "";
+  };
+}
+function closedQuestion(reply) {
+  const t = reply.replace(/\[[^\]]*\]|<\/?[a-z]+>/gi, " ").replace(/\s+/g, " ").trim();
+  if (!/\?["'’”)]*$/.test(t)) return false;
+  const q = t.split(/(?<=[.!?])\s+(?=\S)/).pop().replace(/^(?:(?:so|ok(?:ay)?|and|but|just to (?:confirm|check)|to confirm|quick (?:check|question)|got it)[,:—–-]*\s+)+/i, "");
+  return /^(?:should|shall|do|does|did|is|are|was|were|can|could|would|will|may|have|has|want|wanna)\b/i.test(q) || /\bor\b/i.test(q);
+}
+
+// src/voice/call.ts
+var log29 = forComponent("VoiceCall");
+var VoiceCallOptions = class {
+  /** Host runs MAIN with exactly `text` (a replace: roll the `replaces` turn back first). */
+  sendTurn = () => {
+  };
+  /** Host aborts a running MAIN turn (barge-in). */
+  abortTurn = () => {
+  };
+  /** Host TTS (fill lane): resolves when played; `false` = could not play. */
+  speak = () => false;
+  /** Stop the in-flight fill line now (barge-in only). */
+  cancel = () => {
+  };
+  /** Host caption — never history. */
+  show = () => {
+  };
+  /** The fast model (lines, banks, progress) — used only with `ai`. */
+  fastModel = latestClaude("haiku");
+  /** Model client for the fast model + the channel decider / overlap judge. Absent → canned lines and rules only. */
+  ai;
+  /** Cache dir for per-language banks (ChannelBanks). */
+  bankCacheDir;
+  /** The host STT's language (BCP-47) — the starting language; each turn's own words still decide. */
+  lang;
+  aec = false;
+  mode = "normal";
+  gate = {};
+  progress = {};
+  /** Extra SecondChannel options (tests, tuning). speak/show/cancel are always VoiceCall's own. */
+  channel = {};
+  onMetric = () => {
+  };
+  now = () => performance.now();
+};
+var VoiceCall = class {
+  constructor(options) {
+    this.options = options;
+    this.options = { ...new VoiceCallOptions(), ...options };
+    const o = this.o;
+    if (o.lang) this.lang = primaryLang(o.lang);
+    const ai = o.ai;
+    this.fill = new SecondChannel({
+      ...ai ? {
+        banks: new ChannelBanks({ generate: fastBankGenerator(ai, o.fastModel), ...o.bankCacheDir ? { cacheDir: o.bankCacheDir } : {} }),
+        decide: channelDecide(ai),
+        generate: fastLineGenerator(ai, o.fastModel)
+      } : {},
+      mode: o.mode,
+      aec: o.aec,
+      ...this.lang ? { lang: this.lang } : {},
+      ...o.channel,
+      speak: (text, kind) => this.say(text, kind),
+      show: (text, kind) => o.show(text, kind),
+      cancel: () => o.cancel(),
+      now: o.now
+    });
+    this.progress = new Progress({ ...ai ? { generate: fastProgressGenerator(ai, o.fastModel) } : {}, now: o.now, ...o.progress });
+    this.judge = new OverlapJudge({ ...ai ? { model: overlapModelFor(ai) } : {}, now: o.now });
+    this.gate = new TurnGate({
+      now: o.now,
+      ...o.gate,
+      onTurn: (t) => this.onTurn(t),
+      onDrop: (text, why) => this.onDrop(text, why),
+      onHold: (text) => o.onMetric({ name: "hold", text })
+    });
+  }
+  options;
+  fill;
+  gate;
+  progress;
+  judge;
+  cur;
+  lang = null;
+  lastAudibleAt = -Infinity;
+  firstFinalAt = null;
+  // the first final of the turn being formed (hold/merge)
+  progressTimer = null;
+  ended = false;
+  get o() {
+    return this.options;
+  }
+  /** The language the fill channel speaks right now (null = unknown → silent). */
+  get language() {
+    return this.lang;
+  }
+  /** The MAIN turn in flight (or the last one). */
+  get turn() {
+    return this.cur && { id: this.cur.id, text: this.cur.text, running: this.cur.running };
+  }
+  /** The host STT's language (BCP-47): the current language until the user's words say otherwise. */
+  setLanguage(tag) {
+    const l = primaryLang(tag);
+    if (!l) return;
+    this.lang = l;
+    this.fill.setLanguage(l, true);
+  }
+  /** STT partial (the whole partial). */
+  interim(text, _atMs, aec) {
+    if (this.ended || !text.trim()) return;
+    if (typeof aec === "boolean") this.fill.options.aec = aec;
+    this.gate.speaking();
+    this.follow(text);
+    this.fill.onInterim(text);
+  }
+  /** STT final → TurnGate. */
+  final(text, sttId) {
+    if (this.ended) return;
+    this.firstFinalAt ??= this.o.now();
+    this.gate.final(text, sttId);
+  }
+  /** A v2 host that decides turns itself: the user's line already went to MAIN (no TurnGate, no sendTurn) — the fill
+   *  channel follows its language and covers the wait. */
+  hostTurn(text) {
+    if (this.ended || !text.trim()) return;
+    this.follow(text);
+    this.fill.onUserTurn(text);
+  }
+  pause(ms) {
+    if (!this.ended) this.fill.onPause(ms);
+  }
+  /** MAIN's stream. */
+  main(ev) {
+    const c = this.cur;
+    if (!c || ev.id && ev.id !== c.id) return;
+    switch (ev.type) {
+      case "start":
+        c.running = true;
+        return;
+      case "text":
+        if (!ev.text) return;
+        if (!c.streamed) {
+          c.streamed = true;
+          this.gate.replyStarted(c.id);
+          this.progress.text();
+          this.clearProgress();
+        }
+        this.fill.onMainTokens(ev.text);
+        return;
+      case "tool":
+        this.gate.replyStarted(c.id);
+        void this.onTool(c, ev.name ?? "", ev.args);
+        return;
+      case "tool_done":
+        return;
+      case "audio":
+        this.lastAudibleAt = this.o.now();
+        this.fill.onAgentState("first_audio");
+        this.sounded(c, "main");
+        if (!c.worded) {
+          c.worded = true;
+          this.o.onMetric({ name: "first_word", id: c.id, ms: Math.round(this.o.now() - c.at), by: "main" });
+        }
+        return;
+      case "done":
+      case "error":
+        c.running = false;
+        this.clearProgress();
+        this.fill.onAgentState("idle");
+        return;
+    }
+  }
+  /** The user barged in (hard): cut fill + MAIN audio (the host cuts its own), abort a running MAIN turn. */
+  barge() {
+    this.fill.onBargeIn();
+    this.clearProgress();
+    try {
+      this.o.cancel();
+    } catch (e) {
+      log29.warn(`cancel threw: ${e.message}`);
+    }
+    if (this.cur?.running) {
+      this.cur.running = false;
+      this.o.abortTurn(this.cur.id);
+    }
+  }
+  /** Soft barge-in: keep (a listener cue — no turn) or cut (→ barge()). */
+  async overlap(text) {
+    const d = await this.judge.judge(text);
+    if (d.verdict === "cut") this.barge();
+    return d.verdict;
+  }
+  /** Did the last barge cut OUR fill line `text`? (hosts strip it from the cut reply — it is not MAIN's speech) */
+  spoke(text) {
+    return this.fill.spoke(text);
+  }
+  /** Resolves when the in-flight fill line finished — hosts queue MAIN audio behind it (stack, don't cut). */
+  drain() {
+    return this.fill.drain();
+  }
+  end() {
+    this.ended = true;
+    this.gate.end();
+    this.clearProgress();
+  }
+  // ---- internals ----
+  /** Follow the user's language from their own words: a confident detection, else the current language if the words
+   *  fit it, else unknown (silent). Pinned into the channel so its own detection never diverges. */
+  follow(text) {
+    const l = detectLanguage(text) ?? (this.lang && fitsLanguage(text, this.lang) ? this.lang : null);
+    if (l !== this.lang) this.o.onMetric({ name: "lang", lang: l, text });
+    this.lang = l;
+    if (l) this.fill.setLanguage(l, true);
+  }
+  onTurn(t) {
+    const at = this.firstFinalAt ?? this.o.now();
+    this.firstFinalAt = null;
+    this.follow(t.text);
+    this.clearProgress();
+    this.cur = { id: t.id, text: t.text, at, running: true, streamed: false, sounded: false, worded: false };
+    this.progress.turn();
+    this.o.onMetric({ name: "turn", id: t.id, kind: t.kind, text: t.text });
+    this.o.sendTurn(t.text, { id: t.id, ...t.replaces ? { replaces: t.replaces } : {} });
+    if (t.kind === "new") this.fill.onUserTurn(t.text);
+  }
+  onDrop(text, why) {
+    if (!this.gate.holding) this.firstFinalAt = null;
+    this.o.onMetric({ name: "drop", kind: why, text });
+  }
+  /** Every fill/progress line passes here: only in the turn's known language, never after the call ended. */
+  say(text, kind) {
+    if (this.ended || !this.lang || this.fill.language !== this.lang) return false;
+    let r;
+    try {
+      r = this.o.speak(text, kind);
+    } catch (e) {
+      log29.warn(`speak threw: ${e.message}`);
+      return false;
+    }
+    if (r === false) return false;
+    this.lastAudibleAt = this.o.now();
+    this.o.onMetric({ name: "fill", kind, text, lang: this.lang });
+    if (this.cur && (kind === "bridge" || kind === "progress")) this.sounded(this.cur, kind === "progress" ? "progress" : "fill");
+    else if (this.cur && this.cur.running && !this.cur.sounded && kind === "filler") this.sounded(this.cur, "fill");
+    return r;
+  }
+  sounded(c, by) {
+    if (c.sounded) return;
+    c.sounded = true;
+    this.o.onMetric({ name: "first_sound", id: c.id, ms: Math.round(this.o.now() - c.at), by });
+  }
+  async onTool(c, name, args) {
+    const lang = this.lang;
+    if (!lang || c.streamed) return;
+    const line = await this.progress.line(name, args, lang);
+    if (!line || this.cur !== c || c.streamed || !c.running || this.lang !== lang) return;
+    this.clearProgress();
+    const tryNow = () => {
+      this.progressTimer = null;
+      if (this.ended || this.cur !== c || c.streamed || !c.running) return;
+      if (!this.progress.due(this.lastAudibleAt)) {
+        this.progressTimer = setTimeout(tryNow, 250);
+        return;
+      }
+      if (this.say(line, "progress") !== false) {
+        this.progress.spoke(line);
+        this.o.show(line, "progress");
+      }
+    };
+    tryNow();
+  }
+  clearProgress() {
+    if (this.progressTimer) {
+      clearTimeout(this.progressTimer);
+      this.progressTimer = null;
+    }
+  }
+};
+
+// src/index.ts
 init_llm();
 import { MemFilesystem as MemFilesystem3, IndexedDbFilesystem, CommandExecutor as CommandExecutor2, registerHeadlessCommands as registerHeadlessCommands2 } from "@livx.cc/wcli/core";
 export {
@@ -11876,8 +13465,11 @@ export {
   MountFilesystem,
   NodeDiskFilesystem,
   OverlayFilesystem,
+  PROGRESS_TEMPLATES,
   PermissionOptions,
   PermissionPolicy,
+  Progress,
+  ProgressOptions,
   RecordingHooks,
   RecordingLifecycle,
   SCRATCH_DIR,
@@ -11889,8 +13481,12 @@ export {
   SonioxSTT,
   SonioxSTTOptions,
   TTS_SAMPLE_RATE,
+  TurnGate,
+  TurnGateOptions,
   VOICE_MEMORY_PROMPT,
   VOICE_SYSTEM_PROMPT,
+  VoiceCall,
+  VoiceCallOptions,
   VoiceEngine,
   VoiceEngineOptions,
   applyEditsTool,
@@ -11914,6 +13510,7 @@ export {
   elideImages,
   elideInlineImages,
   elideStaleImages,
+  endsMidPhrase,
   enterWorktree,
   estimateTokens,
   exitSessionTool,
@@ -11924,6 +13521,7 @@ export {
   expandTemplate,
   findGitRoot,
   forComponent,
+  forgetFact,
   formatJobNotice,
   fullAgentOptions,
   getOrCreateWorktree,
@@ -11935,6 +13533,7 @@ export {
   imagePart,
   imageRefPart,
   imageRefResult,
+  isClosing,
   jevAvailable,
   jevClassifier,
   latestClaude,