@livx.cc/agentx 0.99.91 → 0.99.93

package/dist/cli.js

@@ -3778,6 +3778,38 @@ async function loadMemory(fs, dir, opts = {}) {
 - (${restSlugs.length} more learnings, slugs only \u2014 call \`Recall\` if relevant): ${restSlugs.join(", ")}` : "");
   return { index, tools };
 }
+var TERM_STOPWORDS = new Set(`the and for but not you your yours our ours his her hers its their they them this that these those
+there here what when where which who whom whose why how all any each every some many much more most few other such only own same
+also just very can will would should could may might must shall have has had does did done was were are been being use used using
+always never often sometimes usually once then than now today tomorrow yesterday before after later soon first last next new old
+read write see make take give get set keep run add note notes user users company name names project projects team work works
+working home inbox label labels file files code prefer prefers please don't doesn't via per with without from into about over
+under yes okay important example one two three monday tuesday wednesday thursday friday saturday sunday`.split(/\s+/));
+var SECRET_RE = /\b(code\s*word|pass(word|phrase|code)?|token|secret|api[\s_-]*key|key|pin|credentials?|otp|2fa|private)\b/i;
+async function memoryTerms(fs, dir, extra = [], max = 30) {
+  const out = /* @__PURE__ */ new Map();
+  const add = (t) => {
+    const k = t.toLowerCase();
+    if (t.length > 2 && !TERM_STOPWORDS.has(k) && !out.has(k)) out.set(k, t);
+  };
+  extra.filter(Boolean).forEach(add);
+  const bodies = { user: [], other: [] };
+  for (const d of (Array.isArray(dir) ? dir : [dir]).filter(Boolean)) {
+    if (!await fs.exists(`${d}/MEMORY.md`)) continue;
+    const slugs = [...(await fs.readFile(`${d}/MEMORY.md`)).matchAll(/\]\(([^)/]+)\.md\)/g)].map((m) => m[1]);
+    for (const slug2 of slugs) {
+      const path = `${d}/${slug2}.md`;
+      if (!await fs.exists(path)) continue;
+      const { block, body } = splitFrontmatter(await fs.readFile(path));
+      const type = grabField(block, "type");
+      if (!["user", "project", "reference"].includes(type ?? "") || SECRET_RE.test(body)) continue;
+      bodies[type === "user" ? "user" : "other"].push(body);
+    }
+  }
+  for (const body of [...bodies.user, ...bodies.other])
+    for (const m of body.matchAll(/\b(?:[A-Z][a-z]+[A-Za-z]*|[A-Z]{3,})\b/g)) add(m[0]);
+  return [...out.values()].slice(0, max);
+}
 function slugify(s, fallback = "note") {
   const base = String(s ?? "").trim().toLowerCase().replace(/\.md$/i, "").replace(/[^\w\s-]/g, "").replace(/[\s_]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 48);
   return base || fallback;
@@ -9670,6 +9702,19 @@ async function judgeLeak(decider, sentence, userSaid) {
   if (!Number.isFinite(p)) throw new Error("leak judge: no noul in the answer");
   return p;
 }
+function scrubSpokenJunk(text, final = false) {
+  let s = text.replace(/[​-‍⁠]/g, "").replace(/\[\s*emotion\b([^[\]]*)\]/gi, (_m, inner) => {
+    const e = normalizeEmotion(inner.trim());
+    return e ? `[${e}]` : "";
+  }).replace(/\[[^\p{L}\p{N}[\]]*\]/gu, "").replace(/(?:[\s ]*(?:…|\.{2,}|[—–]|-{2,})){3,}/g, (m) => /^[\s ]/.test(m) ? " \u2026" : "\u2026");
+  if (final) s = s.replace(/\[\s*emotion\b[^\]]*$/i, "");
+  return s;
+}
+function isRepeatOf(sentence, spoken) {
+  const norm3 = (x) => x.replace(/\[[a-z_ ]+\]/gi, "").replace(/[^\p{L}\p{N}]+/gu, " ").trim().toLowerCase();
+  const s = norm3(sentence);
+  return s.replace(/ /g, "").length >= 16 && spoken.split(SENTENCE_SPLIT).some((x) => norm3(x) === s);
+}
 
 // src/duplex.ts
 var log21 = forComponent("DuplexAgent");
@@ -9712,6 +9757,10 @@ var DuplexAgentOptions = class {
   host;
   /** How many recent transcript messages are rendered into a worker's brief. */
   excerptTurns = 6;
+  /** A Hold turn whose user says nothing more for this long is answered after all (a re-voice turn told they stopped):
+   *  without it a wrong Hold left the turn as a lone "mm-hm" forever. 0 = off. Only for a host that reports the user's
+   *  live speech via userActive() — else a slow talker's next words would be spoken over. */
+  holdResumeMs = 0;
   /** Voice register: 'neutral' = clean spoken style; 'conversational' = human-like — fillers,
    *  backchannels, impulsive first reactions before content (mimics real duplex conversation). */
   voiceStyle = "neutral";
@@ -9752,6 +9801,9 @@ var DuplexAgentOptions = class {
   /** Host overrides for QuickLook lookups (keyed by `what`). The engine's defaults go through the
    *  (possibly jailed) fs — e.g. `.git/**` is deny-listed, so the CLI supplies 'branch' itself. */
   quickLook;
+  /** Extra roots QuickLook ls/file try for a relative path not found under the cwd (the CLI passes ~ and ~/Documents:
+   *  a spoken "Projects/X" means ~/Documents/Projects/X far more often than <cwd>/Projects/X). */
+  lookRoots = [];
   /** Memory directory/directories on the WORKER fs. If set, the voice agent gets Remember + Recall
    *  tools directly (no delegation needed) and implicit capture guidance. */
   memoryDir;
@@ -9759,6 +9811,60 @@ 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;
+  let pre = 0;
+  while (pre < a.length && a[pre] === b[pre]) pre++;
+  const grams = (x) => new Set(Array.from({ length: Math.max(0, x.length - 1) }, (_, i) => x.slice(i, i + 2)));
+  const ga = grams(a), gb = grams(b);
+  let common = 0;
+  for (const g of ga) if (gb.has(g)) common++;
+  return pre * 2 + 2 * common / (ga.size + gb.size || 1);
+}
 var RESERVED_EVENT_MARKER = /\[task\b[^\]\n]*\b(?:completed|failed|progress|asks)\b/i;
 var RESERVED_EVENT_OPENER = /\[\s*task\b/i;
 var STAGE_DIRECTION_RE = /^\(\s*(?:(?:waiting|checking|searching|thinking|processing|loading|working|fetching|looking)\b[^)]*|[^)]*(?:\.\.\.|…)\s*)\)$/i;
@@ -9781,11 +9887,11 @@ 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.\n"[task t1 asks] \u2026" events are QUESTIONS from a background task \u2014 relay to the user in your own words, short, then end your turn. When the user answers, call `AnswerTask` with that id and their answer. NEVER answer on the user\'s behalf for permissions or risky operations; if their reply is ambiguous, confirm first.\nIf the user\'s message sounds INCOMPLETE \u2014 trailing off mid-sentence, a fragment that needs more context ("and then we", "but the problem is"), hesitation fillers ("uh", "um") \u2014 call `Hold` instead of answering. This keeps listening for the rest of their thought. Only respond with substance when you have a complete question or request.\nDispatch discipline: send ONE self-contained task per request \u2014 a single worker with the full brief beats several workers with fragments (each worker starts fresh and re-discovers context). NEVER dispatch a worker just to read files or gather information \u2014 workers explore and discover context themselves; pass on what you already know and let one worker do the whole job. Split into parallel tasks only when the user asks for genuinely independent things. When a task completes, report its result and stop \u2014 do NOT dispatch follow-up work (verification, polish, extras) the user did not ask for, unless the report itself signals failure or doubt.\nDo not fire a second Act/Think for work already in flight, and NEVER spawn a second task to re-count, cross-check, or verify a result a worker already gave you \u2014 trust its answer; a single question gets ONE task. Call `TaskStatus` at most ONCE per turn; if a task is still running, give one brief status aside and end the turn \u2014 never poll it again and again in a loop. "Still on it" is ONLY for a repeat check on a task you already acknowledged earlier \u2014 NEVER as the ack when you first dispatch work ("still" is wrong when nothing was running yet; use a fresh "on it"/"got it, checking" instead). Use `CancelTask` when the user asks to stop something.\nPRIORITY: when the user says goodbye or wants to end/finish/wrap up the session ("ok bye", "that\'s all", "let\'s finish", "let\'s end", "goodnight", "exit", "wrap up"), call `ExitSession` IMMEDIATELY \u2014 do not act, do not check status, just exit.\nFor TRIVIAL instant lookups only \u2014 current time, git branch, listing a folder, peeking at a small file, or checking your own `capabilities`/tools \u2014 use `QuickLook` (instant, no task). Whenever the user asks what you can do or whether you have some ability, QuickLook `capabilities` and answer from that \u2014 never guess. Anything requiring searching, reasoning, running commands, or editing goes through `Act`.\n{{MEMORY_SLOT}}\nUser messages may arrive via speech-to-text and can carry transcription artifacts \u2014 odd words, cut-offs, homophones ("for you" vs "folder"). Read for INTENT, not surface text. If a message seems garbled, surprising, or only half-parses, do NOT guess an action or improvise content from it \u2014 briefly confirm what they meant ("did you mean\u2026?") and wait. A one-line confirm beats a confident wrong answer or an invented response to a request you did not actually understand.';
+var VOICE_SYSTEM_PROMPT = 'You are a spoken voice assistant \u2014 the user HEARS everything you say. Use short sentences. One idea per sentence. No markdown, no bullet lists, no code blocks, no headings, no emoji. Never emit stage directions or parenthetical asides about your own process \u2014 nothing like "(waiting for the result...)" or "(checking)"; while work runs, either say it as plain speech or end your turn.\nThis holds even when asked to "print", "list", "show", or "make a table" \u2014 there is no screen for the spoken channel. Speak it as flowing prose ("Tuesday is half a meter, Wednesday a bit less\u2026"), or if they truly need it on screen, route it to Act to render. Never emit dashes or pipes into speech.\nKeep turns SHORT \u2014 one to three sentences, then stop. Never lecture, enumerate cases, or add caveats unprompted. Conversation is a fast exchange: give the one thing asked, and let the user pull more if they want it.\nYou have three cognitive tiers \u2014 like a human brain:\n\u2022 YOU (reflex) \u2014 instant, lightweight. Handle greetings, simple questions, status checks, QuickLook.\n\u2022 `Act` \u2014 your hands. A background worker with its own configured tools and access to the user\'s environment (files and shell{{WORKER_WEB}}). Use for reading, editing, searching, running tasks, building \u2014 any real work.\n{{THINK_SLOT}}\nWhen you are unsure whether you can do or access something, do NOT assume and do NOT claim a capability you have not confirmed. To check what you can do, QuickLook `capabilities` (instant \u2014 it lists your worker\'s real tools) and answer from that. Never promise an ability that is not in your capabilities; if it is not there, tell the user plainly you can\'t. To actually DO real work, call `Act`. When the user mentions their project, folder, files, or environment ("this project", "the current folder", "my code"), call `Act` IMMEDIATELY \u2014 do not ask for paths or details the worker can discover itself. Never pretend to have done the work or invent results \u2014 the worker\'s report is your only source.\nYou cannot mute the microphone or stop voice capture yourself \u2014 no tool does it. If the user asks you to stop listening or turn the voice off, never claim you did: tell them to say exactly "voice off" (handled by the app directly), or type /voice.\nYou are NOT a knowledge base. For any question whose answer needs SPECIFIC verifiable facts you do not already have in hand \u2014 how to build/configure/implement something, exact API, library, entitlement, command or option names, current events, or particular numbers, dates, or names \u2014 do NOT answer from your own memory: you will confidently make things up (a fake API, a wrong entitlement, an event that did not happen). Route it to `Act`, which can search and verify, and speak only what its report says. DELEGATION RULE \u2014 decide for yourself, the user never has to push: if you cannot answer confidently from the conversation plus trivial well-known knowledge, do NOT refuse and do NOT guess \u2014 dispatch `Act` immediately with a clear brief and say you are checking. Anything needing CURRENT data (weather, news, prices, dates, sky/astronomy, "right now"), real computation, or verification is an automatic dispatch \u2014 never a refusal. The user should never need to say "search the web" or "think harder" to make you act; needing fresh or verified information IS the trigger. Refuse only what your worker genuinely cannot do (check `capabilities`), and say why. Answer inline ONLY for general conversation, chit-chat, and trivia you are sure of, or facts you can see via QuickLook. When elaborating on a completed task ("tell me more", "the gist"), stay strictly within what that result actually said \u2014 if the user asks for something the result did not cover, that is NEW information: dispatch `Act`, do not improvise.\nALWAYS react before you work: the FIRST thing in your turn is a brief spoken acknowledgement of what you heard and what you are about to do ("got it \u2014 opening that now", "sure, let me pull it up", "okay, checking"). NEVER call a tool (Act, Think, QuickLook) silently \u2014 the user must hear you react before you go quiet to work. After dispatching Act or Think, that same one short sentence IS your turn \u2014 end it and do not wait for the result. Exactly ONE short line: never stack a second acknowledgement, and never narrate your own presence or status while waiting ("I\'m here", "let me see", "still checking" right after you already acked). One clean ack then silence reads as competent; repeated check-ins read as nervous.\nA completed task speaks its OWN result to the user (the worker voices what matters as it finishes) \u2014 you do NOT re-voice clean task results. A FAILED or INCOMPLETE task still arrives as a "[task t1 failed] \u2026" event for you to handle. The completed result stays in YOUR context \u2014 it is yours to draw on. When the user follows up ("tell me more", "what else", "and?"), answer FROM that result first: you already have the detail, so elaborate on what you have. Do NOT spawn a fresh worker to re-search or re-gather what you were just handed. Re-dispatch ONLY when genuinely new information is needed \u2014 e.g. the user wants the full contents of a SPECIFIC source, which is one WebFetch of that URL, not a brand-new search. "[task t1 progress] \u2026" events are interim status, NOT results \u2014 on a genuinely LONG wait you MAY give one brief half-sentence aside, but only occasionally; silence while working is normal and fine (the user knows you are on it). Do NOT narrate every step or re-announce yourself. Never present progress as a finished result.\nCRITICAL: while a task is still running you have NO answer yet \u2014 never state a specific result of any kind (a number, size, count, name, path, or value). The real answer exists ONLY once the task finishes (the worker speaks it, and `TaskStatus` then returns it); inventing one meanwhile (a made-up disk size, commit count, etc.) is a serious error. Until then, only acknowledge and wait.\nNever read raw file paths, diffs, or code aloud verbatim.\nDo NOT end every turn with the same canned offer ("want a rundown?", "want the steps?"). Offer once at most; if the user pushes back, repeats themselves, or sounds unsatisfied ("you know what I mean?", "think deeper", "are you sure?"), do NOT re-offer the same thing \u2014 change approach: dispatch `Act`/`Think` to actually dig in, or ask one concrete clarifying question. Repeating a non-answer is worse than silence.\n"[task t1 asks] \u2026" events are QUESTIONS from a background task \u2014 relay to the user in your own words, short, then end your turn. When the user answers, call `AnswerTask` with that id and their answer. NEVER answer on the user\'s behalf for permissions or risky operations; if their reply is ambiguous, confirm first.\nIf the user\'s message sounds INCOMPLETE \u2014 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 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 THINK_GUIDANCE = "\u2022 `Think` \u2014 your brain. A premium reasoning model, FAR more expensive than Act. Reserve it for open-ended architecture/design questions, or a problem Act already FAILED at. ALL implementation work \u2014 coding, refactoring, debugging, edge cases, tests \u2014 goes to Act; Act is highly capable. Never send the same work to both.";
 var THINK_DISABLED_GUIDANCE = "(Think tier is not available \u2014 use Act for all escalations.)";
 var VOICE_STYLE_CONVERSATIONAL = `Speak like a person in a live conversation, not an assistant reading a script. React first, then deliver: a quick impulsive beat ("oh nice", "hmm, hold on", "ah, got it") before the substance. Use contractions always. Vary sentence length \u2014 some very short. Light fillers and backchannels are fine ("mm-hm", "right", "let's see") but at most one per reply \u2014 never stack them. When you escalate to Act or Think, say it like a human would ("hang on, let me actually dig into that \u2014 gimme a minute") instead of announcing a task. When a result comes back, react to it like you just found out ("okay so \u2014 turns out\u2026"). Match the user's energy: a quick question gets a quick answer \u2014 a few words is a perfectly good turn. Prefer a short answer plus an offer ("want the details?") over covering everything. Never narrate your own mechanics (no "I will now act", no task ids out loud).`;
-var EMOTION_TAGS_GUIDANCE = `EMOTION: your voice is synthesized with emotion control. Prefix a sentence with an inline [emotion] tag, placed directly before the sentence it colors, to shape how it is spoken. Use it ONLY when the emotion genuinely fits the words (it amplifies real feeling, it cannot fake it) \u2014 do not tag every sentence; reserve it for moments that carry feeling, and vary which one you use. You may also drop [laughter] for a natural laugh. Available emotions: ${EMOTIONS.join(", ")}.`;
+var EMOTION_TAGS_GUIDANCE = `EMOTION: your voice is synthesized with emotion control. Prefix a sentence with an inline emotion tag \u2014 ONE emotion word from the list below in square brackets, the word alone (never the word "emotion" itself, never a guess or a question mark), placed directly before the sentence it colors, to shape how it is spoken. Use it ONLY when the emotion genuinely fits the words (it amplifies real feeling, it cannot fake it) \u2014 do not tag every sentence; reserve it for moments that carry feeling, and vary which one you use. You may also drop [laughter] for a natural laugh. Available emotions: ${EMOTIONS.join(", ")}.`;
 var DuplexAgent = class _DuplexAgent {
   options;
   voice;
@@ -9836,6 +9942,10 @@ var DuplexAgent = class _DuplexAgent {
   // host spoke on our behalf (adaptive micro-ack) — not reflex output
   heldThisTurn = false;
   // Hold called this turn → turn is INTENTIONALLY silent (suppress reflex text + no dead-air ack)
+  holdTimer = null;
+  // armed by a Hold turn's end (holdResumeMs)
+  holdResumed = false;
+  // the hold expired: the resume turn must answer (Hold refused) — until the user speaks
   nudging = false;
   // re-ack pass in flight: block ALL tools, prevent recursion
   reflexBuf = "";
@@ -9846,6 +9956,10 @@ var DuplexAgent = class _DuplexAgent {
   // reflex emitted a reserved [task …] marker → suppress its tail
   leakCuts = [];
   // heads of analysis-register leaks cut this turn — scrubbed from the transcript at turn end
+  midPhraseBounced = false;
+  // this turn's dispatch on a mid-phrase fragment was already bounced to Hold
+  repeatCuts = [];
+  // same-turn repeated sentences skipped this turn — their LATER copy is scrubbed from the transcript
   leakStep = false;
   // the CURRENT step's tail is muted by a leak cut (the next step speaks again, unlike a fabricated marker)
   leakHit = false;
@@ -10009,7 +10123,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
   pumpReflex(final) {
     for (; ; ) {
       if (this.leakStep) return;
-      this.scrubStageDirections();
+      this.scrubUnforwarded(final);
       const from = this.reflexForwarded;
       const buf = this.reflexBuf;
       const lastMark = Math.max(from, ...this.stepMarks);
@@ -10019,6 +10133,8 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
         if (tail) upto -= tail[0].length;
         const paren = buf.lastIndexOf("(");
         if (paren >= lastMark && !buf.includes(")", paren) && buf.length - paren <= 80) upto = Math.min(upto, paren);
+        const brk = buf.lastIndexOf("[");
+        if (brk >= lastMark && !buf.includes("]", brk) && buf.length - brk <= 60) upto = Math.min(upto, brk);
       }
       if (upto <= from) return;
       const region = buf.slice(from, upto);
@@ -10026,9 +10142,14 @@ ${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;
+      let ok = 0, leak, repeat;
       for (const e of ends) {
         if (e <= ok) continue;
+        const sent = region.slice(ok, e);
+        if (sent.trim() && !/[\p{L}\p{N}]/u.test(sent) || isRepeatOf(sent, this.turnSpoken + region.slice(0, ok))) {
+          repeat = e;
+          break;
+        }
         const v = this.leakVerdict(region.slice(ok, e));
         if (v === void 0) break;
         if (v) {
@@ -10038,6 +10159,15 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
         ok = e;
       }
       this.forwardReflex(from + ok);
+      if (repeat !== void 0) {
+        const cut = region.slice(ok, repeat).trim();
+        if (/[\p{L}\p{N}]/u.test(cut)) {
+          this.repeatCuts.push(cut);
+          this.notify("diag", "reflex_repeat", { text: cut.slice(0, 80) });
+        }
+        this.reflexForwarded = from + repeat;
+        continue;
+      }
       if (leak === void 0) return;
       const at = from + ok;
       this.leakHit = true;
@@ -10112,6 +10242,22 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
   scrubLeakFromTranscript() {
     const keys = this.leakCuts.splice(0);
     const t = this.voice.transcript;
+    for (let i = this.turnBase; i < t.length; i++) {
+      const m = t[i];
+      if (m.role === "assistant" && typeof m.content === "string") m.content = scrubSpokenJunk(m.content, true).trim();
+    }
+    for (const cut of this.repeatCuts.splice(0)) {
+      const rep = cut.replace(/^(?:\[[^\]]*\]\s*)+/, "");
+      if (!rep) continue;
+      for (let i = t.length - 1; i >= this.turnBase; i--) {
+        const m = t[i];
+        if (m.role !== "assistant" || typeof m.content !== "string") continue;
+        const at = m.content.lastIndexOf(rep);
+        if (at <= 0 && !(at === 0 && t.slice(this.turnBase, i).some((x) => x.role === "assistant" && contentText(x.content).includes(rep)))) continue;
+        m.content = (m.content.slice(0, at).replace(/\[[^\]]*\]\s*$/, "") + m.content.slice(at + rep.length)).trim();
+        break;
+      }
+    }
     for (const key of keys) {
       let i = t.length - 1;
       while (i >= this.turnBase && !(t[i].role === "assistant" && typeof t[i].content === "string" && t[i].content.includes(key))) i--;
@@ -10155,17 +10301,32 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
     await this.drainReflex();
     this.scrubLeakFromTranscript();
     this.scrubHeldText();
+    if (this.heldThisTurn) {
+      this.armHoldResume();
+      return;
+    }
     if (this.silentTurn && res?.finishReason === "error" && refusedCall(res.error)) this.emitHost({ kind: "text_delta", message: fallback ?? _DuplexAgent.FALLBACK_ERROR });
     else if (this.silentTurn) await this.ackIfSilent(fallback);
   }
-  /** Remove complete stage-direction parentheticals from the UNFORWARDED reflex text (STAGE_DIRECTION_RE).
-   *  Only the unforwarded region is touched — already-spoken audio can't be unsent, and splicing before
-   *  reflexForwarded would corrupt the forward offset. */
-  scrubStageDirections() {
-    if (this.reflexForwarded >= this.reflexBuf.length) return;
-    const region = this.reflexBuf.slice(this.reflexForwarded);
-    const scrubbed = region.replace(/\([^()]*\)/g, (s) => STAGE_DIRECTION_RE.test(s) ? "" : s);
-    if (scrubbed !== region) this.reflexBuf = this.reflexBuf.slice(0, this.reflexForwarded) + scrubbed;
+  /** Rewrite the UNFORWARDED reflex text: drop complete stage-direction parentheticals (STAGE_DIRECTION_RE) and spoken
+   *  junk (scrubSpokenJunk). Only the unforwarded region is touched — already-spoken audio can't be unsent, and
+   *  splicing before reflexForwarded would corrupt the forward offset. Rewritten per step segment so the stepMarks
+   *  after it move with the text (a mark is a reflexBuf offset); a segment that ends at a step mark is complete. */
+  scrubUnforwarded(final) {
+    const from = this.reflexForwarded, buf = this.reflexBuf;
+    if (from >= buf.length) return;
+    const scrub = (seg, complete) => scrubSpokenJunk(seg.replace(/\([^()]*\)/g, (x) => STAGE_DIRECTION_RE.test(x) ? "" : x), complete);
+    const marks = new Set(this.stepMarks.filter((k) => k > from && k <= buf.length));
+    let out = buf.slice(0, from), at = from;
+    const moved = /* @__PURE__ */ new Map();
+    for (const k of [.../* @__PURE__ */ new Set([...marks, buf.length])].sort((x, y) => x - y)) {
+      out += scrub(buf.slice(at, k), final || marks.has(k));
+      moved.set(k, out.length);
+      at = k;
+    }
+    if (out === buf) return;
+    this.reflexBuf = out;
+    this.stepMarks = this.stepMarks.map((k) => moved.get(k) ?? k);
   }
   /** Clear the per-turn guards. Called at the head of every voice turn (user send + re-voice flush). */
   resetTurn() {
@@ -10179,6 +10340,8 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
     this.reflexForwarded = 0;
     this.fabricationCut = false;
     this.leakCuts = [];
+    this.repeatCuts = [];
+    this.midPhraseBounced = false;
     this.leakStep = this.leakHit = false;
     this.stepMarks = [];
     this.leakVerdicts.clear();
@@ -10202,6 +10365,13 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
           return { block: true, reason: "Speculative turn aborted." };
         }
         if (this.nudging) return { block: true, reason: "Just say one short spoken acknowledgement \u2014 no tools this turn." };
+        if ((call.name === "Act" || call.name === "Think") && !this.turnDispatched && !this.midPhraseBounced) {
+          const said = [...this.voice.transcript].reverse().find((m) => m.role === "user");
+          if (said && endsMidPhrase(contentText(said.content))) {
+            this.midPhraseBounced = true;
+            return { block: true, reason: "The user stopped mid-phrase \u2014 the rest of their request is still coming. Call Hold now (no filler) and wait for it; do not dispatch on a fragment." };
+          }
+        }
         if (!this.turnDispatched) return;
         if (call.name === "TaskStatus")
           return { block: true, reason: "You just dispatched a task this turn \u2014 do NOT poll. Give one short spoken acknowledgement and end your turn; the result arrives later as a [task \u2026] event." };
@@ -10217,6 +10387,27 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
   noteExternalSpeech() {
     this.externalSpeech = true;
   }
+  /** The user is speaking (a live partial, a barge): a pending Hold expiry waits for them again. */
+  userActive() {
+    if (this.holdTimer) this.armHoldResume();
+  }
+  clearHoldResume() {
+    if (this.holdTimer) clearTimeout(this.holdTimer);
+    this.holdTimer = null;
+  }
+  armHoldResume() {
+    this.clearHoldResume();
+    const ms = this.options.holdResumeMs;
+    if (!ms) return;
+    this.holdTimer = setTimeout(() => {
+      this.holdTimer = null;
+      this.holdResumed = true;
+      this.notify("diag", "hold_expired", { ms });
+      this.queueRevoice(_DuplexAgent.HOLD_EXPIRED);
+    }, ms);
+    this.holdTimer.unref?.();
+  }
+  static HOLD_EXPIRED = "[the user stopped there and did not go on \u2014 respond to what they said now; if it is unclear, ask one short question. Do not Hold.]";
   /** True when the just-finished turn voiced NOTHING — dead air to repair. Two ways this happens:
    *  (a) a dispatch with no spoken ack, and (b) an INLINE turn whose `final` channel came back empty —
    *  gpt-oss harmony sometimes puts the whole reply in `analysis` (→ thinking_delta, suppressed in
@@ -10279,6 +10470,8 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
    *  second Act). The host gets `turn_replace` {id, replaces, rolledBack, followed?}: only a rollback drops the replaced
    *  line; `followed` = the kept turn whose follow-up ran (absent: the merged text ran). */
   send(content, opts) {
+    this.clearHoldResume();
+    this.holdResumed = false;
     if (opts?.replaces) this.replaceTurn(opts.replaces);
     const cur = this.voice.options.signal;
     const ext = cur && cur === this.turnSignal?.own ? this.turnSignal.ext : cur;
@@ -10535,6 +10728,20 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
     spec.decide("abort");
     this.notify("diag", "speculation_aborted", { text: spec.text.slice(0, 80) });
   }
+  /** Fold a refinement into a RUNNING task's worker (Agent.inject — picked up at its next step) instead of cancel +
+   *  respawn: live 20261013-085238 one request spoken over three fragments became t5 → cancel → t6 → cancel → t7, each
+   *  worker restarting from zero. Returns the id when amended, undefined when the task is not running (→ dispatch new). */
+  amendTask(id, brief) {
+    const rec = this.tasks.get(id);
+    if (!rec || rec.status !== "running" || !rec.worker || !brief.trim()) return void 0;
+    rec.worker.inject(`[update from the user while you work \u2014 fold it into the SAME task, do not start over]
+${brief}`);
+    rec.brief += `
+
+Update: ${brief}`;
+    this.notify("diag", "task_amended", { id, brief: brief.slice(0, 80) });
+    return rec.id;
+  }
   /** Cancel a running background task — shared by the CancelTask tool and the CLI /tasks picker. */
   cancelTask(id) {
     const rec = this.tasks.get(id);
@@ -10821,14 +11028,15 @@ ${recent}` : brief) + verify + deliverContract;
       signal: controller.signal
       // shared with the checker so a cancel tears down both
     };
-    const promise = new Agent(agentOpts).run(briefText).then((res) => {
+    const worker = new Agent(agentOpts);
+    const promise = worker.run(briefText).then((res) => {
       const { spoken, detail } = splitter.flush();
       feedSpoken(spoken);
       if (detail.trim()) pushTail(detail.trim());
       flushSpoken();
       return res;
     }).then((res) => this.maybeVerify(id, brief, res, tier, agentOpts, askBridge)).then((res) => this.onWorkerSettled(id, res)).catch((err2) => this.onWorkerFailed(id, err2));
-    this.tasks.set(id, { id, label, status: "running", controller, promise, tail, brief, followUp, splitter, createdTurn: this.turn });
+    this.tasks.set(id, { id, label, status: "running", controller, promise, tail, brief, followUp, splitter, createdTurn: this.turn, worker });
     if (this.tasks.size > this.options.maxTaskRecords)
       for (const [tid, rec] of this.tasks) {
         if (this.tasks.size <= this.options.maxTaskRecords) break;
@@ -11081,14 +11289,17 @@ Another agent just implemented the above. Independently check the CURRENT state
         required: ["brief"],
         properties: {
           brief: { type: "string", description: "full, self-contained instructions for the worker" },
-          label: { type: "string", description: "a short (2-4 word) label for the task" }
+          label: { type: "string", description: "a short (2-4 word) label for the task" },
+          refines: { type: "string", description: "id of a STILL-RUNNING task this message only adds detail to or corrects (a path, a name, a spelling) \u2014 the running worker is updated in place instead of starting a new task" }
         }
       },
-      run: async ({ brief, label }) => {
+      run: async ({ brief, label, refines }) => {
         this.spokeBeforeDispatch = this.spokeThisTurn;
         this.turnDispatched = true;
         this.turnBriefs.add(String(brief ?? ""));
         this.voice.options.toolChoice = "none";
+        const amended = refines ? this.amendTask(String(refines), String(brief ?? "")) : void 0;
+        if (amended) return this.dispatchResult(amended, "Updated the running");
         const id = await this.dispatch(String(brief ?? ""), "act", label ? String(label) : void 0, this.turnFollowUp);
         return this.dispatchResult(id, "Acting on");
       }
@@ -11186,29 +11397,36 @@ Another agent just implemented the above. Independently check the CURRENT state
             case "ls": {
               if (!fs) return "unavailable (no filesystem)";
               const p = String(path ?? ".");
-              try {
-                const names = await fs.readDir(p);
-                return names.slice(0, 50).join("\n") + (names.length > 50 ? `
-\u2026 (+${names.length - 50} more)` : "");
-              } catch {
-                const names = await fs.readDir(".").catch(() => []);
-                return `'${p}' not found here \u2014 you are likely already inside it. Current directory listing:
-` + names.slice(0, 50).join("\n") + (names.length > 50 ? `
+              const list = (at, names) => (at === p ? "" : `(${at})
+`) + names.slice(0, 50).join("\n") + (names.length > 50 ? `
 \u2026 (+${names.length - 50} more)` : "");
+              for (const at of this.lookCandidates(p)) {
+                try {
+                  return list(at, await fs.readDir(at));
+                } catch {
+                }
               }
+              const cwd = (fs.getCwd?.() ?? "").replace(/\/+$/, "");
+              if (cwd && p.replace(/^\.\/|\/+$/g, "") === cwd.split("/").pop()) return `'${p}' is the current directory:
+` + list(".", await fs.readDir(".").catch(() => []));
+              return await this.lookMiss(p);
             }
             case "file": {
               if (!fs) return "unavailable (no filesystem)";
               if (!path) return "file lookup needs a path";
-              try {
-                const text = await fs.readFile(String(path));
-                return text.length > CAP2 ? text.slice(0, CAP2) + `
-\u2026 (truncated \u2014 ${text.length} chars total; Act for the full file)` : text;
-              } catch {
-                const names = await fs.readDir(".").catch(() => []);
-                return `'${path}' not found. Current directory contains:
-` + names.slice(0, 50).join("\n");
+              for (const at of this.lookCandidates(String(path))) {
+                let text;
+                try {
+                  text = await fs.readFile(at);
+                } catch {
+                  continue;
+                }
+                const head = at === String(path) ? "" : `(${at})
+`;
+                return head + (text.length > CAP2 ? text.slice(0, CAP2) + `
+\u2026 (truncated \u2014 ${text.length} chars total; Act for the full file)` : text);
               }
+              return await this.lookMiss(String(path));
             }
             default:
               return `unknown lookup '${what}'`;
@@ -11219,6 +11437,41 @@ Another agent just implemented the above. Independently check the CURRENT state
       }
     };
   }
+  /** Where QuickLook tries a path: as given (cwd-relative or absolute), then — relative only — under each lookRoot. */
+  lookCandidates(p) {
+    const rel = p.replace(/^~\/?/, "");
+    const roots = this.options.lookRoots;
+    if (p.startsWith("~")) return roots.length ? [`${roots[0].replace(/\/+$/, "")}/${rel}`.replace(/\/$/, "")] : [p];
+    if (p.startsWith("/")) return [p];
+    return [p, ...roots.map((r) => `${r.replace(/\/+$/, "")}/${rel}`)];
+  }
+  /** A QuickLook path not found anywhere: say where it looked and, at the deepest folder that DID exist, the few closest
+   *  names (a mis-heard segment — "Lead Sheets" for "Livshitz" — is usually one of them). Never the whole cwd listing:
+   *  live 20261013-085238 dumped it three times for three spellings of the same path. */
+  async lookMiss(p) {
+    const fs = this.options.fs;
+    const segs = p.replace(/^~\/?/, "").split("/").filter((x) => x && x !== ".");
+    const bases = p.startsWith("/") ? ["/"] : p.startsWith("~") ? this.options.lookRoots.slice(0, 1) : [".", ...this.options.lookRoots];
+    let best;
+    for (const base of bases) {
+      let dir = base;
+      for (let i = 0; i < segs.length; i++) {
+        const names = await fs.readDir(dir).catch(() => void 0);
+        if (!names) break;
+        const hit = names.find((n) => n.toLowerCase() === segs[i].toLowerCase());
+        if (!hit) {
+          if (i > (best?.depth ?? -1)) best = { dir, depth: i, names };
+          break;
+        }
+        dir = dir === "." ? hit : `${dir.replace(/\/+$/, "")}/${hit}`;
+      }
+    }
+    const where = ["the current folder", ...this.options.lookRoots].join(", ");
+    if (!best || !best.names.length) return `'${p}' not found (looked under ${where}). Ask the user for the exact path, or Act to search for it.`;
+    const missing = segs[best.depth];
+    const close = [...best.names].sort((x, y) => nameScore(missing, y) - nameScore(missing, x)).slice(0, 6);
+    return `'${p}' not found (looked under ${where}). '${missing}' is not in ${best.dir} \u2014 closest names there: ${close.join(", ")}. If one of these is what they meant (speech-to-text often mishears names), use it; otherwise ask the user or Act to search.`;
+  }
   answerTaskTool() {
     return {
       name: "AnswerTask",
@@ -11247,6 +11500,8 @@ Another agent just implemented the above. Independently check the CURRENT state
         }
       },
       run: async ({ filler }) => {
+        if (this.heldThisTurn) return "Already holding \u2014 stay silent.";
+        if (this.holdResumed) return "Not now \u2014 the user already stopped after those words. Answer them now in one or two short sentences, or ask one short question.";
         this.heldThisTurn = true;
         this.notify("hold_filler", filler ? String(filler) : "");
         return "Holding \u2014 listening for the rest of the user's thought. Do not respond further this turn.";
@@ -11256,13 +11511,21 @@ Another agent just implemented the above. Independently check the CURRENT state
   cancelTaskTool() {
     return {
       name: "CancelTask",
-      description: "Cancel a running background task by id.",
-      parameters: { type: "object", required: ["id"], properties: { id: { type: "string" } } },
+      description: 'Cancel a running background task by id \u2014 or id "all" to cancel EVERY running task (the user said "stop everything", "stop all the searches").',
+      parameters: { type: "object", required: ["id"], properties: { id: { type: "string", description: 'a task id, or "all"' } } },
       // Cancel-and-redirect ("stop — do Y instead") is ONE user line: live, the reflex cancelled, said "fetching Y now" and
       // never dispatched (2/5 Bare voice runs). The tool result is where it looks next — tell it the redirect needs Act.
+      // "Stop all the searches" cancelled one task (and hit a done one) and left t4 running (live 20261013-085238): the
+      // result always names what is STILL running, and "all" stops every one in a single call.
       run: async ({ id }) => {
-        const r = this.cancelTask(String(id));
-        return this.tasks.get(String(id))?.status === "cancelled" && r.endsWith("cancelled.") ? `${r} If the user's message ALSO asked for different work (a redirect \u2014 "instead\u2026", "actually\u2026", "do Y"), call Act NOW with that new brief: saying you are on it without calling Act does nothing. If they only asked to stop, just acknowledge in a few words.` : r;
+        const want = String(id ?? "").trim();
+        const running = () => [...this.tasks.values()].filter((t) => t.status === "running");
+        const ids = /^(?:all|\*|everything)$/i.test(want) ? running().map((t) => t.id) : [want];
+        const lines = ids.length ? ids.map((x) => this.cancelTask(x)) : ["No running tasks."];
+        const left = running();
+        const tail = left.length ? ` Still running: ${left.map((t) => `${t.id} (${t.label})`).join(", ")} \u2014 if the user asked to stop ALL, cancel these too (or call CancelTask with id "all").` : " No tasks are running now.";
+        const cancelled = ids.some((x) => this.tasks.get(x)?.status === "cancelled");
+        return lines.join(" ") + tail + (cancelled ? ` If the user's message ALSO asked for different work (a redirect \u2014 "instead\u2026", "actually\u2026", "do Y"), call Act NOW with that new brief: saying you are on it without calling Act does nothing. If they only asked to stop, just acknowledge in a few words.` : "");
       }
     };
   }
@@ -13192,6 +13455,8 @@ var VoiceIOOptions = class extends VoiceEngineOptions {
   sonioxApiKey = process.env.SONIOX_API_KEY ?? "";
   cartesiaApiKey = process.env.CARTESIA_API_KEY ?? "";
   cartesiaVoiceId = process.env.CARTESIA_VOICE_ID ?? "";
+  /** STT custom vocabulary (names/companies/projects) — biases Soniox toward them (see memoryTerms). */
+  sttTerms = [];
   emotions = process.env.VOICE_EMOTIONS !== "0";
   // Cartesia inline emotion tags (sonic-3)
   /** CLI voice default: mask a slow reflex TTFT with a one-shot varied micro-ack (a FIXED per-turn
@@ -13222,7 +13487,7 @@ var VoiceIO = class extends VoiceEngine {
     const duplex = bin ? new AecDuplexAudio(bin) : null;
     super({
       ...o,
-      stt: o.stt ?? new SonioxSTT({ auth: o.sonioxApiKey, source: duplex ?? new NodeMicSource() }),
+      stt: o.stt ?? new SonioxSTT({ auth: o.sonioxApiKey, source: duplex ?? new NodeMicSource(), terms: o.sttTerms }),
       tts: o.tts ?? new CartesiaTTS({ auth: o.cartesiaApiKey, voiceId: o.cartesiaVoiceId }),
       player: o.player ?? duplex ?? new Player(),
       bargeRmsMult: Number(process.env.BARGE_RMS_MULT || o.bargeRmsMult),
@@ -13429,7 +13694,7 @@ var scriptOf = (w) => SCRIPTS.find(([re]) => {
   re.lastIndex = 0;
   return re.test(w);
 })?.[1] ?? null;
-function detectLanguage(text) {
+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) {
@@ -13437,9 +13702,10 @@ function detectLanguage(text) {
     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) ? best : null;
+  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" });
@@ -13488,8 +13754,8 @@ function validateBank(raw, lang, minPerKind = 3) {
 }
 var KIND_HINT = {
   backchannel: 'tiny listener cues while they keep talking (like "mm-hm", "right") \u2014 never takes the turn',
-  filler: 'soft thinking sounds at their pause (like "hmm\u2026")',
-  bridge: 'quick lead-ins before the real answer while it is prepared (like "let me check\u2014")',
+  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) {
@@ -13522,6 +13788,7 @@ var ChannelBanksOptions = class {
   fallback = { en: EN_BANK };
   now = () => Date.now();
 };
+var BANK_VERSION = 2;
 var ChannelBanks = class {
   constructor(options) {
     this.options = options;
@@ -13552,6 +13819,10 @@ var ChannelBanks = class {
       if (e.code !== "ENOENT") log29.warn(`bank cache ${f} unreadable \u2014 regenerating: ${e.message}`);
       return null;
     });
+    if (cached && cached.v !== BANK_VERSION) {
+      log29.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) {
@@ -13578,7 +13849,7 @@ var ChannelBanks = class {
       this.banks.set(lang, bank);
       log29.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(), bank }))).catch((e) => log29.warn(`bank cache write ${f} failed: ${e.message}`));
+      if (f) await mkdir(this.o.cacheDir, { recursive: true }).then(() => writeFile(f, JSON.stringify({ at: this.o.now(), v: BANK_VERSION, bank }))).catch((e) => log29.warn(`bank cache write ${f} failed: ${e.message}`));
     } catch (e) {
       log29.warn(`bank ${lang}: generation failed \u2014 ${have ? "keeping the cached bank" : lang in this.o.fallback ? "fallback bank" : "silent"}: ${e.message}`);
     } finally {
@@ -13601,7 +13872,8 @@ var SecondChannelOptions = class {
    *  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 = ["backchannel", "bridge"];
+  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 = () => {
   };
@@ -13627,7 +13899,12 @@ var SecondChannelOptions = class {
   avoidLines = 4;
   /** Canned picks exclude the last N picks of the same kind. */
   bankExclude = 2;
-  backchannelMinWords = 8;
+  backchannelMinWords = 6;
+  /** 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;
@@ -13660,13 +13937,14 @@ var SecondChannel = class {
   heard = "";
   userSpeaking = false;
   main = "idle";
-  lead = "";
   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;
@@ -13698,9 +13976,11 @@ var SecondChannel = class {
     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);
+    const l = detectLanguage(text, !!this.lang);
     if (l) this.setLanguage(l);
   }
   get bank() {
@@ -13722,6 +14002,11 @@ var SecondChannel = class {
       this.pauseTimer = null;
       this.onPause(this.o.fillerPauseMs);
     }, this.o.fillerPauseMs);
+    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);
+    }, 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). */
@@ -13730,6 +14015,10 @@ var SecondChannel = class {
       clearTimeout(this.pauseTimer);
       this.pauseTimer = null;
     }
+    if (this.bcTimer) {
+      clearTimeout(this.bcTimer);
+      this.bcTimer = null;
+    }
     this.userSpeaking = false;
     void this.consider("pause", ms);
   }
@@ -13738,22 +14027,30 @@ var SecondChannel = class {
     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.lead = "";
       this.bridged = false;
       return;
     }
     if (s === "queued") {
       this.gen++;
       this.userSpeaking = false;
-      this.lead = "";
       this.bridged = false;
-      if (this.pauseTimer) clearTimeout(this.pauseTimer);
-      this.pauseTimer = null;
+      for (const k of ["pauseTimer", "bcTimer", "bridgeTimer"]) {
+        if (this[k]) clearTimeout(this[k]);
+        this[k] = null;
+      }
+      if (this.o.bridgeDelayMs > 0) this.bridgeTimer = setTimeout(() => {
+        this.bridgeTimer = null;
+        void this.consider("working");
+      }, this.o.bridgeDelayMs);
+      else void this.consider("working");
     }
-    if (s === "queued" || s === "thinking" || s === "streaming_text") 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) {
@@ -13762,10 +14059,9 @@ var SecondChannel = class {
     this.main = "idle";
     this.onAgentState("queued");
   }
-  /** The main answer's streamed text (before its audio): a bridge can lead into it. */
+  /** The main answer's streamed text (before its audio): channel-1 is responding — no bridge from here on. */
   onMainTokens(text) {
-    if (this.lead.length < 120) this.lead += text;
-    if (this.main === "queued" || this.main === "thinking") this.onAgentState("streaming_text");
+    if (text.trim() && (this.main === "queued" || this.main === "thinking")) this.onAgentState("streaming_text");
   }
   /** The user barged in: cut the in-flight line now and drop every pending decision. */
   onBargeIn() {
@@ -13794,9 +14090,6 @@ var SecondChannel = class {
   get audioLocked() {
     return this.main === "first_audio" || this.main === "speaking";
   }
-  get working() {
-    return this.main === "queued" || this.main === "thinking" || this.main === "streaming_text";
-  }
   tail() {
     return words2(this.heard).slice(-this.o.microWords).join(" ");
   }
@@ -13805,21 +14098,29 @@ var SecondChannel = class {
     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";
     if (k === "filler") return !this.userSpeaking && this.main === "idle";
-    return this.working && !this.bridged;
+    return (this.main === "queued" || this.main === "thinking") && !this.bridged;
   }
   /** 0ms rule: the candidate line for this trigger, or silence. */
-  rule(trigger, pauseMs = 0) {
+  rule(trigger, pauseMs = 0, breath = false) {
     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" ? w.length >= this.o.backchannelMinWords && /[,.;:!?…]$/.test(this.heard) ? "backchannel" : null : trigger === "pause" ? pauseMs >= this.o.fillerPauseMs && w.length >= this.o.fillerMinWords ? "filler" : null : w.length >= this.o.bridgeMinWords ? "bridge" : null;
+    const k = trigger === "interim" ? this.backchannelMoment(w.length, breath) ? "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";
   }
-  async consider(trigger, pauseMs) {
+  /** 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 (n < this.o.backchannelMinWords || /\?$/.test(this.heard)) return false;
+    if (/[.!]$/.test(this.heard)) return n >= 2 * this.o.backchannelMinWords;
+    return breath || /[,;:…]$/.test(this.heard);
+  }
+  async consider(trigger, pauseMs, breath = false) {
     if (this.busy) return;
     const n0 = words2(this.heard).length;
     this.decidedAt = n0;
-    const rule = this.rule(trigger, pauseMs);
+    const rule = this.rule(trigger, pauseMs, breath);
     if (rule === "silence") return;
     this.busy = true;
     const gen = this.gen, t0 = this.o.now();
@@ -13859,7 +14160,7 @@ var SecondChannel = class {
   async line(kind) {
     if (this.o.generate && this.o.generateFor.includes(kind)) {
       const ac = new AbortController();
-      const ctx = { kind, heard: this.tail(), state: this.main, avoid: [...this.recent], lang: this.lang, ...this.lead ? { lead: this.lead } : {} };
+      const ctx = { kind, heard: this.tail(), state: this.main, avoid: [...this.recent], lang: this.lang };
       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);
@@ -13907,17 +14208,16 @@ var SecondChannel = class {
   }
 };
 var KIND_HINT2 = {
-  backchannel: "a tiny listener cue while they keep talking \u2014 shows you follow THEIR point, does not take the turn",
-  filler: "a soft thinking sound at their pause",
-  bridge: "a quick lead-in before the real answer, while it is being prepared"
+  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")'
 };
 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]}.
 The user just said: "${c.heard}"
 The assistant is: ${c.state}.
-` + (c.lead ? `The real answer begins: "${c.lead.trim()}" \u2014 lead naturally into it; do not repeat it.
-` : "") + (c.avoid.length ? `Do not reuse any of: ${c.avoid.map((a) => `"${a}"`).join(", ")}.
+` + (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 });
@@ -17055,7 +17355,8 @@ function parseArgs(argv) {
     else if (x === "--duplex-v2") {
       a.duplex = true;
       a.duplexV2 = true;
-    } else if (x === "--conversational" || x === "--convo" || x === "--voice") {
+    } else if (x === "--channel-only") a.channelOnly = true;
+    else if (x === "--conversational" || x === "--convo" || x === "--voice") {
       a.voice = true;
       a.duplex = true;
     } else if (x === "--voice-model") a.voiceModel = val(++i, x);
@@ -17094,10 +17395,11 @@ function parseArgs(argv) {
   if (a.seed && !a.boddb) throw new Error("--seed only applies with --boddb (it seeds the database from cwd on first run)");
   if (a.worktree && (a.vfs || a.boddb)) throw new Error("--worktree is a real-disk concept \u2014 incompatible with --vfs/--boddb");
   if (a.duplex && (a.task || a.print)) throw new Error("--duplex is interactive-only (a conversational mode) \u2014 drop the task/-p");
-  if (a.inputFormat && (!a.duplex && !a.print || a.outputFormat !== "stream-json")) throw new Error("--input-format stream-json needs --output-format stream-json and --duplex (or --voice) or -p");
+  if (a.inputFormat && (!a.duplex && !a.print && !a.channelOnly || a.outputFormat !== "stream-json")) throw new Error("--input-format stream-json needs --output-format stream-json and --duplex (or --voice), --channel-only or -p");
+  if (a.channelOnly && !a.inputFormat) throw new Error("--channel-only needs --input-format stream-json --output-format stream-json");
   if (a.duplex && a.plan) throw new Error("--plan is not supported in --duplex (workers are non-interactive; a plan could never be approved)");
   if (a.voiceSystemPrompt && !a.duplex) throw new Error("--voice-system-prompt only applies with --duplex");
-  if (a.voiceModel && !a.duplex) throw new Error("--voice-model only applies with --duplex");
+  if (a.voiceModel && !a.duplex && !a.channelOnly) throw new Error("--voice-model only applies with --duplex or --channel-only");
   if (a.thinkModel !== void 0 && !a.duplex) throw new Error("--think-model/--no-think only apply with --duplex");
   if (!canPrompt && (a.ask || a.plan))
     throw new Error(`${a.ask ? "--ask" : "--plan"} needs an interactive terminal to approve on \u2014 none is attached (stdin/stderr are not a TTY). For an unattended run use --yes, or pre-authorize with rules in .agent/permissions.json.`);
@@ -17141,6 +17443,8 @@ Flags:
                        to a background worker agent (-m model); results are re-voiced when ready
   --duplex-v2          duplex + a second voice channel: backchannels, fillers and bridges that never
                        enter the agent's history (headless: stdin interim/pause/agent_state, stdout channel)
+  --channel-only       headless (--input-format stream-json): ONLY the second channel, for a host whose main
+                       answer comes from elsewhere (stdin user/text/barge/interim/pause/agent_state, stdout channel)
   --conversational     duplex with a conversation-native register \u2014 short fast turns, fillers,
                        impulsive reactions, human pacing (implies --duplex; aliases: --convo, --voice)
                        with SONIOX_API_KEY + CARTESIA_API_KEY(+VOICE_ID) set: real voice I/O \u2014 mic in,
@@ -18584,6 +18888,8 @@ async function repl(args, ai, cfg, cwd) {
       onTaskStart: async (_id, label) => {
         await checkpoints.begin(label);
       },
+      lookRoots: [homedir10(), join16(homedir10(), "Documents")],
+      // QuickLook: a spoken "Projects/X" usually means ~/Documents/Projects/X
       // The jail deny-lists .git/** (VCS internals can carry credentials), so the engine's fs-based
       // 'branch' lookup can't see it — supply it host-side (one safe read-only file).
       quickLook: {
@@ -20216,8 +20522,14 @@ ${out}
     }
     const fakeVoice = process.env.AGENTX_VOICE_FAKE ? fakeVoiceParts(process.env.AGENTX_VOICE_FAKE) : null;
     voiceDiag = new JsonlDiagSink(join16(store.dir, `${session.meta.id}.voice.jsonl`));
+    const sttTerms = agent.options.fs && agent.options.memoryDir ? await memoryTerms(agent.options.fs, agent.options.memoryDir, [basename4(agent.options.fs?.getCwd() ?? process.cwd())]).catch((e) => {
+      err(dim(`  (stt terms: ${e?.message ?? e})
+`));
+      return [];
+    }) : [basename4(agent.options.fs?.getCwd() ?? process.cwd())];
     voiceIO = new VoiceIO({
       ...fakeVoice ?? {},
+      sttTerms,
       onDiag: (ev) => voiceDiag?.push(ev),
       emotions: emotionsOn,
       showEmotions,
@@ -20243,6 +20555,7 @@ ${out}
       onPartial: (text) => {
         if (text === voicePartial) return;
         voicePartial = text;
+        if (text.trim()) dx?.userActive();
         if (!partialRedraw) partialRedraw = setTimeout(() => {
           partialRedraw = null;
           editorRef?.redrawNow();
@@ -20375,6 +20688,7 @@ ${out}
     };
     try {
       await voiceIO.start();
+      if (dx) dx.options.holdResumeMs = HOLD_RESUME_MS;
       if (args.duplexV2 && dx) {
         const v = voiceIO;
         bindSecondChannel(v, makeSecondChannel(ai, dx.options.reflexModel, { show: (t) => {
@@ -20632,6 +20946,7 @@ function duplexError(e, reflexModel) {
   const code = e?.statusCode;
   return code && !msg.includes(String(code)) ? `${msg} (${code})` : msg;
 }
+var HOLD_RESUME_MS = 4e3;
 var leakDecider = () => {
   const o = voiceDeciderOptions();
   return o ? new DecideClient(o) : void 0;
@@ -20663,8 +20978,10 @@ async function duplexServe(args, ai, cfg, cwd) {
         sc?.onMainTokens(String(e.message ?? ""));
       } else if (k === "thinking_delta") out({ type: "thinking", text: e.message });
       else if (k === "speak_utterance") out({ type: "speak", text: e.message });
-      else if (k === "hold_filler") out({ type: "filler", text: e.message });
-      else if (k === "turn_replace") out({ type: "replaced", ...e.data });
+      else if (k === "hold_filler") {
+        out({ type: "filler", text: e.message });
+        sc?.onAgentState("idle");
+      } else if (k === "turn_replace") out({ type: "replaced", ...e.data });
       else if (k === "revoice_done") {
         out({ type: "revoice_done" });
         persist();
@@ -20690,7 +21007,9 @@ async function duplexServe(args, ai, cfg, cwd) {
     host,
     // --voice: the CLI voice register (progress asides, spoken budget). No emotion tags: the host's TTS may not speak them.
     ...args.voice ? { voiceStyle: "conversational", progressUpdates: true, spokenBudgetChars: 350 } : {},
-    reflexOptions: { fs: agent.options.fs, tools: [exitSessionTool(() => out({ type: "exit" }))] }
+    reflexOptions: { fs: agent.options.fs, tools: [exitSessionTool(() => out({ type: "exit" }))] },
+    ...args.duplexV2 ? { holdResumeMs: HOLD_RESUME_MS } : {}
+    // v2 hosts stream the user's partials (userActive) — v1 hosts don't
   });
   if (args.voiceSystemPrompt) dx.voice.options.systemPrompt += "\n\n" + args.voiceSystemPrompt;
   let scTurn = 0;
@@ -20718,9 +21037,11 @@ async function duplexServe(args, ai, cfg, cwd) {
       }
       if (m.type === "barge") {
         sc?.onBargeIn();
+        dx.userActive();
         activeTurn?.abort();
         dx.parkInFlightDeliveries();
       } else if (sc && channelInput(sc, m)) {
+        if (m.type === "interim" && String(m.text ?? "").trim()) dx.userActive();
       } else if (m.type === "cancel") out({ type: "task", kind: "cancel_result", id: m.task, message: dx.cancelTask(String(m.task)) });
       else if (m.type === "exit") rl.close();
       else if (m.type === "user" && typeof m.text === "string" && m.text.trim()) {
@@ -20753,6 +21074,28 @@ async function duplexServe(args, ai, cfg, cwd) {
   persist();
   await closeMcp(mounted);
 }
+async function channelServe(args, ai, cfg) {
+  const out = (o) => process.stdout.write(JSON.stringify(o) + "\n");
+  const { reflexModel, notes } = duplexModels({ voiceModel: args.voiceModel, reflexModel: cfg.reflexModel, thinkModel: false, actModel: String(args.model ?? cfg.model ?? ""), apiKeys: { ...cfg.apiKeys, ...apiKeysFromEnv() } });
+  const model = reflexModel ?? new DuplexAgentOptions().reflexModel;
+  const sc = makeSecondChannel(ai, model, { show: (text, kind) => out({ type: "channel", kind, text }) });
+  out({ type: "ready", model, ...notes.length ? { notes } : {} });
+  const rl = createInterface({ input: process.stdin });
+  rl.on("line", (line) => {
+    let m;
+    try {
+      m = JSON.parse(line);
+    } catch {
+      return;
+    }
+    if (channelInput(sc, m)) return;
+    if (m.type === "user" && typeof m.text === "string") sc.onUserTurn(m.text);
+    else if (m.type === "text" && typeof m.text === "string") sc.onMainTokens(m.text);
+    else if (m.type === "barge") sc.onBargeIn();
+    else if (m.type === "exit") rl.close();
+  });
+  await new Promise((r) => rl.on("close", () => r()));
+}
 function readStdinSteers() {
   const early = [];
   let sink, got;
@@ -20922,6 +21265,10 @@ async function main() {
     worktreeCleanup?.();
     process.exit(ok ? 0 : res?.finishReason === "needs_input" ? 2 : 1);
   }
+  if (args.inputFormat && args.channelOnly) {
+    await channelServe(args, ai, cfg);
+    process.exit(0);
+  }
   if (args.inputFormat) {
     await duplexServe(args, ai, cfg, cwd);
     worktreeCleanup?.();