@inetafrica/open-claudia 3.5.47 → 3.5.59

package/channels/kazee/call/quick-voice.js

@@ -0,0 +1,610 @@
+"use strict";
+
+// The quick voice: a small, kept-warm model that says a short, fitting line
+// the moment the caller finishes ("Sure, let me check the call logs."), and a
+// brief "still on it" line while the full agent works. It never answers a
+// question itself that needs the full agent's tools: that agent's call turn
+// does the work, and the quick voice says its answer in its own words
+// (answerMessage; 11 Oct 17:47, the caller: "it should handle everything"),
+// so the call has one voice that knows what it already said. One process per
+// call, spawned through the provider's own utility invocation (binary, env and
+// credentials come from the provider, never from here). Ported from the 5 Oct
+// front-voice test build.
+
+const { spawn } = require("child_process");
+const { StringDecoder } = require("string_decoder");
+const { killProcessTree } = require("../../../core/process-tree");
+const { redactSensitive } = require("../../../core/redact");
+
+const KILL_GRACE_MS = 2000;
+const MAX_BUFFER_BYTES = 1024 * 1024;
+const MAX_LINE_CHARS = 120;
+// Claudia's words passed to the quick voice, and its spoken reply for them.
+const RELAY_INPUT_CHARS = 1500;
+const RELAY_OUTPUT_CHARS = 1500;
+const EFFORTS = new Set(["low", "medium", "high", "xhigh", "max"]);
+
+// The bot's .env is parsed into the config object, not process.env: read the
+// config first, the environment second.
+function setting(name) {
+  let value = process.env[name];
+  try { value = require("../../../core/config").config?.[name] ?? value; } catch (_) {}
+  return String(value ?? "").trim();
+}
+
+// Measured 11 Oct, warm process, thinking off, 23 call lines with traps
+// ("Did you hear me?", "Are you sure?"): Haiku 4.5 finished its line in
+// 0.8-1.1 s (Sonnet 5 at low effort 1.7-1.9 s); both kept every rule once the
+// prompt named the traps (a looser prompt let Haiku answer "you said it once").
+// On by default since 3.5.58 (the fleet release of the call work, Sumeet
+// 13 Oct: "can we roll it out the rest of the fleet?"), on Opus 5.5 as on the
+// owner's own bot; KAZEE_CALL_QUICK_VOICE=off brings back the full agent alone.
+function quickVoiceSettings(read = setting) {
+  const effort = read("KAZEE_CALL_QUICK_EFFORT").toLowerCase() || "low";
+  return {
+    enabled: !/^(?:off|0|false|no)$/i.test(read("KAZEE_CALL_QUICK_VOICE")),
+    model: read("KAZEE_CALL_QUICK_MODEL") || "claude-opus-5-5",
+    effort: EFFORTS.has(effort) ? effort : "low",
+    thinking: /^(?:on|1|true|yes)$/i.test(read("KAZEE_CALL_QUICK_THINKING")),
+    // It says the full agent's answers too (manager.js _relay); off: they
+    // play as the full agent wrote them, as before.
+    relay: !/^(?:off|0|false|no)$/i.test(read("KAZEE_CALL_QUICK_RELAY")),
+    // It starts on the words heard when the caller stopped, before the
+    // recogniser's final (manager.js _earlyWords); off: it waits for the final.
+    early: !/^(?:off|0|false|no)$/i.test(read("KAZEE_CALL_QUICK_EARLY")),
+  };
+}
+
+function ownerDisplayName() {
+  try {
+    const name = String(require("../../../core/people").owners()?.[0]?.name || "").trim();
+    return name && name.toLowerCase() !== "owner" ? name : "";
+  } catch (_) {
+    return "";
+  }
+}
+
+// Caller words and spoken history only: no file paths, links, ids or secrets
+// reach the quick voice.
+function scrubLine(text) {
+  return redactSensitive(String(text || ""))
+    .replace(/https?:\/\/\S+/gi, "a link")
+    .replace(/(?:~|\.{1,2})?\/[\w.@%+-]+(?:\/[\w.@%+-]*)+/g, "a file")
+    .replace(/\b(?=[A-Za-z0-9_-]*\d)[A-Za-z0-9_-]{16,}\b/g, "an id")
+    .replace(/\[REDACTED[^\]]*\]/g, "something private")
+    .replace(/[`*_#>|[\]]/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function buildQuickPrompt({ ownerName = "", relay = false } = {}) {
+  const owner = scrubLine(ownerName).slice(0, 60) || "the caller";
+  return [
+    `You are the quick voice of Claudia, ${owner}'s assistant, on a live phone call with ${owner}.`,
+    relay
+      ? "You are the only voice on the call. Claudia herself (the full assistant, with tools) does the real work in the background; her answers reach you as text ([Answer]) and you say them to the caller."
+      : "You keep the conversation going. Claudia herself (the full assistant, with tools) does the real work in the background, and her answers are spoken when they are ready.",
+    "",
+    "A message about what the caller just said starts with [Caller], then [Work]: what Claudia is doing for them right now, then [Now]: their local day and time. Start your reply with ONE tag, then the spoken line on the same line.",
+    "",
+    "You answer yourself whatever you can answer from what you are given: the time or day from [Now], what Claudia is doing or already answered on this call from [Work], what you two were working on from the chat you were given at call start, and everyday general knowledge that does not depend on their business, systems, people, data or anything recent (a spelling, simple sums, a well-known fact). Never make them wait for Claudia for those. Anything about their business, systems, people, data, money, or anything recent or that you are not sure of, is Claudia's.",
+    "",
+    "When [Work] says Claudia is not working on anything:",
+    "- [[SELF]] when your line fully handles it and Claudia is not needed: a greeting, \"Are you there?\", \"Can you hear me?\", thanks, okay, small talk, what you two were working on (only from [Work] or the chat you were given at call start), or a question you answer yourself (see above), like \"What time is it?\".",
+    "- A [[SELF]] line answers first, plainly. Then it keeps things moving: when a next step follows naturally, end with it in a few words, an offer or a suggestion like \"Want me to set that up?\" or \"Does that answer it?\"; otherwise a short \"Anything else on that?\" or \"What shall we look at next?\". Never change the subject just to fill a gap, vary it, and never sound like you are ending the call.",
+    "- [[IGNORE]] and no line when it was plainly not meant for you: they were talking to someone else (another person's name, \"hang on\" to someone nearby), or it is a TV, radio, video or other people talking in the background. If your last words were cut off, they are said again after. If it could be for you, it is.",
+    "- [[BYE]] when they want the call to end (\"Bye\", \"Hang up\", \"I have to go\", \"No, hang up\"): a goodbye of 2 to 8 words, like \"Okay, talk soon. Bye.\" The call ends right after your line. Never say you are hanging up without this tag.",
+    "- When they want something done and then the call ended (\"Do that, then hang up and call me back\"), start with [[JOB]] [[BYE]]: the call ends right after your line, and Claudia does it and reports in the chat. Say so in 4 to 10 words, like \"Sure, I'll do that and message you. Bye.\"",
+    "- [[JOB]] for everything else: any other question, fact, check, lookup or action. Your line only shows you heard (see Holding lines).",
+    "- Anything they want done, changed or tried is [[JOB]], however small: \"Change your voice\", \"Try saying something\", \"Send me that\". You cannot do anything yourself; only Claudia can.",
+    "- Anything about what can be seen on the call (\"Can you see me?\", \"What am I holding?\", \"How do I look?\") is [[JOB]]: only Claudia can look at their camera.",
+    "- \"What's going on?\", \"You're taking long\", \"Did you do it?\" or \"I'm still waiting\" while Claudia is not working on anything: [[JOB]], so she can find what was missed.",
+    "When unsure, [[JOB]].",
+    "",
+    "When [Work] says Claudia is working on something:",
+    "- [[IGNORE]] and no line: they were talking to someone else, or it was not meant for you (another person's name, \"hang on\" to someone nearby, background talk).",
+    "- [[ANSWER]] for a check-in (\"You there?\"), thanks, okay, small talk, a status question (\"What are you doing?\", \"How's it going?\"), or a question you answer yourself (see above), like \"What time is it?\": 4 to 16 words, like \"Still here, reading the call logs now.\" or \"It's quarter to two.\" Status only from [Work]; never guess how long is left or say it is nearly done. The work carries on.",
+    "- [[ADD]] for a new question or request: Claudia does it right after the current work. Say something like \"Sure, I'll check that next.\" That includes anything to do later (\"Say apple at some point\", \"Remind me after this\"), and anything that mixes a check-in or a complaint with a request.",
+    "- [[REPLACE]] when they change their mind about the current work, stop it, or correct it: \"Stop\", \"Never mind\", \"Forget that\", \"No, check the mail instead\", and corrections like \"No, that's not what I asked\", \"That wasn't my question\" or \"No, but...\" followed by what they meant. Say something like \"Okay, dropping that.\", or for a correction \"Got it, let me look at that instead.\" The current work and its unsaid answer are stopped, and what they said now runs instead.",
+    "- [[BYE]] when they want the call to end: the call ends right after your line, and Claudia finishes the work and reports in the chat. Say something like \"Sure, I'll finish that and message you. Bye.\" If they also ask for something new, [[ADD]] [[BYE]].",
+    "When unsure, [[ADD]].",
+    "",
+    "Holding lines, for [[JOB]], 2 to 8 words:",
+    "- a question: \"Good question, one sec.\", or a line naming the topic, like \"Let me look at the budget.\"",
+    "- a request: \"Sure, let me check the call logs.\", naming the thing in two or three words.",
+    "- a correction or \"that's wrong\": \"Okay, let me look again.\"",
+    "Never answer a [[JOB]] yourself, even when you think you know: \"How many times did I say hello?\" gets \"Let me check.\", never \"Twice.\"; \"Are you sure?\" gets \"Let me double-check.\".",
+    "",
+    "Always: never give facts, numbers, yes or no, opinions or apologies that [Work], [Now] or everyday general knowledge do not give you; never say anything was done, found, sent or changed unless [Work] says so in plain words. For sending, changing, booking or deleting anything, say \"Sure, one sec.\" and never that it is being done.",
+    "No lists, emoji, symbols or markdown.",
+    "",
+    "[Work] may say your last words were cut off when they started talking. Then [[REPEAT]] when they were checking in, asking you to say it again, or saying something that needs no answer (\"Are you still there?\", \"Sorry, say again?\", \"Go on\"): your line is only a lead-in of 2 to 6 words, like \"Sorry, as I was saying.\"; never say the cut words yourself, they are spoken right after your line. If they asked or said something new, tag it as usual.",
+    "",
+    "A message that starts with [Still working] means Claudia is still on it: reply with no tag, one short varied line of 3 to 10 words. If it gives a step or something she said that you have not mentioned yet, say that in plain words, like \"Reading the call logs now.\"; otherwise something like \"Still on it, nearly there.\" Never repeat an earlier line word for word.",
+    "",
+    "A message that starts with [Call start] means the caller is ringing in, and gives the end of your recent text chat with them. Reply with no tag: say the line Claudia opens the call with: 6 to 16 words, starting with \"Hey\" and their first name. Name what you were last working on together in two to five plain words, like \"Still on the calls update?\" or \"Back to the Books revert?\", then a short \"What's up?\". If the chat is unclear, just ask what's up. Only name a topic the chat shows; never say it is done, fixed or live unless the chat says so in plain words, and never give numbers, dates or file names. Never ask whether they can hear you. If it says you are calling them, open instead with why you are calling, in two to five plain words, like \"Calling to test the new greeting.\", then a short \"Got a minute?\"; take the reason from the note when it gives one.",
+
+  ].join("\n");
+}
+
+// Measured 11 Oct (Haiku 4.5, cold process, ~1.6k chars of chat): the
+// greeting is ready ~1.8 s after the call comes in.
+const GREETING_ENTRIES = 6;
+const GREETING_ENTRY_CHARS = 300;
+// A thread call (thread-context.js): more of the thread, and its last brief.
+const THREAD_GREETING_ENTRIES = 12;
+const THREAD_BRIEF_CHARS = 1500;
+// Older than this, "where we left off" is stale: the fixed greeting, with no
+// extra ring (Haiku named a 9-hour-old topic despite the prompt, 11 Oct).
+const GREETING_RECENT_MS = 6 * 60 * 60 * 1000;
+
+// Wakeups and watches are filed as the caller's turns; they are not things
+// the caller said.
+const SCHEDULED_TURN = /^\[?\s*(?:Watch triggered|Watch expired|Watch check timing out|Scheduled wakeup|Wakeup:)/i;
+
+// The call-start note: how long ago the chat was, then its last few
+// messages, scrubbed like every other line. Empty when there is no recent
+// chat to go on (the fixed greeting is used then). outgoing: Claudia is
+// ringing them, with the reason she gave (open-claudia call --about), if any.
+// context is the chat's last entries, or for a call placed inside a thread
+// { entries, thread: { title, brief, briefAt } } (manager.js greetingContext):
+// the call is about that thread however old its last turn is.
+function greetingMessage(context, now = Date.now(), { outgoing = false, reason = "" } = {}) {
+  const thread = context && !Array.isArray(context) && context.thread ? context.thread : null;
+  const entries = Array.isArray(context) ? context : (Array.isArray(context?.entries) ? context.entries : []);
+  const recent = entries
+    .filter((entry) => !(entry?.role === "user" && SCHEDULED_TURN.test(String(entry?.text || "").trim())))
+    .map((entry) => ({ who: entry?.role === "user" ? "Caller" : "Claudia", text: scrubLine(entry?.text).slice(0, GREETING_ENTRY_CHARS), at: Date.parse(entry?.timestamp || "") }))
+    .filter((entry) => entry.text)
+    .slice(-(thread ? THREAD_GREETING_ENTRIES : GREETING_ENTRIES));
+  const why = outgoing ? scrubLine(reason).slice(0, GREETING_ENTRY_CHARS).replace(/[\s.!?]+$/, "") : "";
+  if (thread) return threadGreetingMessage(thread, recent, now, { outgoing, why });
+  const last = recent.at(-1)?.at;
+  const fresh = recent.length > 0 && Number.isFinite(last) && now - last <= GREETING_RECENT_MS;
+  if (!fresh && !why) return "";
+  const opening = outgoing
+    ? `[Call start] You are calling them; they are about to pick up.${why ? ` Why you are calling: ${why}.` : ""}`
+    : "[Call start] The caller is ringing in.";
+  if (!fresh) return [opening, "", "Say the greeting."].join("\n");
+  const minutes = Math.max(0, Math.round((now - last) / 60000));
+  const when = minutes < 1 ? "just now" : minutes < 120 ? `${minutes} minutes ago` : `${Math.round(minutes / 60)} hours ago`;
+  return [
+    `${opening} The last message in your chat with them was ${when}. The end of that chat, oldest first:`,
+    ...recent.map((entry) => `${entry.who}: ${entry.text}`),
+    "",
+    "Say the greeting.",
+  ].join("\n");
+}
+
+function agoText(at, now) {
+  const minutes = Math.max(0, Math.round((now - at) / 60000));
+  if (minutes < 1) return "just now";
+  if (minutes < 120) return `${minutes} minutes ago`;
+  const hours = Math.round(minutes / 60);
+  return hours < 48 ? `${hours} hours ago` : `${Math.round(hours / 24)} days ago`;
+}
+
+// The call-start note of a thread call: what the thread is, where it stood at
+// its last brief, then its last turns. Never empty: the thread is the topic.
+function threadGreetingMessage(thread, recent, now, { outgoing, why }) {
+  const title = scrubLine(thread.title).slice(0, 80);
+  const named = title ? ` "${title}"` : "";
+  const opening = outgoing
+    ? `[Call start] You are calling them from your chat thread${named}; they are about to pick up.${why ? ` Why you are calling: ${why}.` : ""}`
+    : `[Call start] The caller is ringing in from your chat thread${named}.`;
+  const lines = [`${opening} The call is about that thread's topic: keep to it unless they change it.`];
+  const brief = scrubLine(thread.brief).slice(0, THREAD_BRIEF_CHARS);
+  if (brief) {
+    const when = Number.isFinite(Number(thread.briefAt)) && Number(thread.briefAt) > 0 ? ` (${agoText(Number(thread.briefAt), now)})` : "";
+    lines.push("", `Where the thread stood at its last summary${when}: ${brief}`);
+  }
+  const last = recent.at(-1)?.at;
+  if (recent.length) {
+    lines.push("", `The end of that thread${Number.isFinite(last) ? ` (last message ${agoText(last, now)})` : ""}, oldest first:`,
+      ...recent.map((entry) => `${entry.who}: ${entry.text}`));
+  }
+  lines.push("", "Say the greeting: name the thread's topic in a few words.");
+  return lines.join("\n");
+}
+
+// What the quick voice should say for one utterance, or a filler while the
+// full agent is still working.
+//
+// The work note tells the quick voice what Claudia is doing for the caller,
+// from the call's own job board (manager.js _board): the job running now, how
+// long, its steps and what it has said so far, what waits after it, and what
+// was answered earlier on the call. Only this lets the quick voice answer a
+// status question or a check-in without a lookup of its own.
+function workNote(board = {}) {
+  const quote = (text, max) => `"${scrubLine(text).slice(0, max)}"`;
+  const parts = [];
+  const current = board?.current;
+  if (current?.ready) {
+    parts.push(`Claudia has finished ${quote(current.question, 200)}; her answer is spoken right after your line, so never give it yourself.`);
+  } else if (current) {
+    parts.push(`Claudia is working on ${quote(current.question, 200)}, ${Math.round(current.seconds || 0)} seconds in.`);
+    const steps = (current.steps || []).slice(-4).map((step) => scrubLine(step).slice(0, 60)).filter(Boolean);
+    if (steps.length) parts.push(`Steps so far: ${steps.join("; ")}.`);
+    const said = (current.said || []).slice(-2).map((line) => quote(line, 200));
+    if (said.length) parts.push(`She has said so far: ${said.join(" ")}.`);
+  } else parts.push("Claudia is not working on anything.");
+  // Words cut off by the caller starting to talk (session.js cutSpeech): the
+  // quick voice may have them said again ([[REPEAT]]).
+  if (board?.cut) parts.push(`Your last words were cut off when they started talking; they did not hear: ${quote(board.cut, 200)}.`);
+  const next = (board?.next || []).slice(0, 3).map((question) => quote(question, 120));
+  if (next.length) parts.push(`Next after it: ${next.join(", ")}.`);
+  const earlier = (board?.earlier || []).slice(-2).map((item) => `asked ${quote(item.question, 120)}, she answered ${quote(item.answer, 240)}`);
+  if (earlier.length) parts.push(`Earlier on this call: ${earlier.join("; ")}.`);
+  return parts.join(" ");
+}
+
+// The caller's local day and time, so "What time is it?" never waits for
+// the full agent (11 Oct: the quick voice held it for 32 s). OC_TIMEZONE as
+// in core/cards.js.
+function nowNote(now = Date.now()) {
+  const date = new Date(now);
+  const timeZone = process.env.OC_TIMEZONE || "Africa/Nairobi";
+  try {
+    const day = date.toLocaleDateString("en-GB", { timeZone, weekday: "long", day: "numeric", month: "long" });
+    const time = date.toLocaleTimeString("en-US", { timeZone, hour: "numeric", minute: "2-digit" }).toLowerCase();
+    return `${day}, ${time}`;
+  } catch (_) {
+    return date.toUTCString();
+  }
+}
+
+// The same words for an early start (manager.js _earlyWords): case,
+// punctuation and spacing aside, as the final often only adds those.
+function sameWords(a, b) {
+  const key = (text) => String(text || "").toLowerCase().replace(/[^\p{L}\p{N}\s]/gu, "").replace(/\s+/g, " ").trim();
+  return key(a) === key(b);
+}
+
+// A reply the caller never heard: it answered words the recogniser then
+// heard differently, or that were noise. The next message says so, so the
+// quick voice neither thinks it said it nor answers those words again.
+const UNSAID_NOTE = "[Not said] Your last reply was never spoken: the words it answered were misheard or were noise. Treat them as unheard.";
+
+function utteranceMessage(text, board, now = Date.now()) {
+  return `[Caller] ${scrubLine(text).slice(0, 600)}\n[Work] ${workNote(board)}\n[Now] ${nowNote(now)}`;
+}
+
+// Claudia's answer to an earlier question is next, and the talk moved on
+// since it was asked (manager.js _leadIn): a few words naming its topic. The
+// rule rides in the message, not the system prompt: a "no tag" rule there
+// cost the caller lines their tags (a cold "Hello?" lost [[SELF]], 11 Oct).
+function leadInMessage(question) {
+  return `[Lead-in] Claudia's answer to "${scrubLine(question).slice(0, 200)}" is about to be spoken, after the talk moved on to something else. Reply with no tag: 2 to 6 words naming that topic, so the caller knows which question the answer is for, like "Back to the mail backup." or "On your voice question." Never give any part of the answer.`;
+}
+
+// Claudia's words for the caller, for the quick voice to say (manager.js
+// _relay): in its own words, leaving out what the caller already heard,
+// which its own replies on this call show. The rules ride in the message, as
+// for lead-ins. 11 Oct 18:28: two answers explained the same thing one after
+// the other ("you just started re-explaining the same thing").
+function answerMessage({ question = "", answer = "", done = true, movedOn = "", quietSeconds = null } = {}) {
+  const asked = `"${scrubLine(question).slice(0, 200)}"`;
+  return [
+    `[Answer] ${done ? `Claudia's answer to ${asked}` : `Part of Claudia's answer to ${asked} (she is still working)`}: "${scrubLine(answer).slice(0, RELAY_INPUT_CHARS)}"`,
+    movedOn ? `Since it was asked, the talk moved on to "${scrubLine(movedOn).slice(0, 200)}": open with 2 to 6 words naming this answer's topic, like "Back to the mail backup."` : "",
+    Number.isFinite(quietSeconds) ? `The caller last heard you ${Math.round(quietSeconds)} seconds ago.` : "",
+    "Reply with no tag: say it to the caller yourself, in your own words, as one short spoken reply.",
+    "- Keep every fact, number, name, time and yes or no exactly as she wrote it, and add nothing she did not say.",
+    "- To the caller you and she are one assistant: her \"I\" and \"me\" stay \"I\" and \"me\". Never call her Claudia, she or her.",
+    "- Leave out anything already said on this call, by you or by her: your earlier replies show what the caller heard. Never explain the same thing twice.",
+    "- When nothing in it is new to the caller, or it only says what she is about to do (\"Checking the settings now\") and they heard you in the last 8 seconds: reply [[SKIP]] and nothing else.",
+    "- Keep her closing offer, suggestion or question (\"Want me to fix it now?\"). If she has none and she answered a direct question at length, you may end with a short \"Does that answer it?\". Never change the subject.",
+    "- Phone style: short sentences, no lists, symbols or markdown.",
+  ].filter(Boolean).join("\n");
+}
+
+// The quick voice's reply to an [Answer]: what to say, or skip (nothing new).
+const SKIP_TAG = /^\s*\[{1,2}\s*SKIP\s*\]{1,2}/i;
+function relayText(raw) {
+  const text = String(raw || "");
+  if (SKIP_TAG.test(text)) return { skip: true, text: "" };
+  const clean = scrubLine(text.replace(/\[\[[^\]]*\]\]/g, " ")).replace(/^["']|["']$/g, "").trim();
+  return { skip: false, text: /[A-Za-z]/.test(clean) ? clean.slice(0, RELAY_OUTPUT_CHARS) : "" };
+}
+
+// The first sentence of an [Answer] reply still being written, once more text
+// follows it, so it is said while the rest is written. "" until then, while a
+// tag is still being written, and for [[SKIP]].
+function firstSentence(raw) {
+  const text = String(raw || "");
+  if (/^\s*\[/.test(text) && !text.includes("]")) return "";
+  const { skip, text: clean } = relayText(text);
+  if (skip) return "";
+  return clean.match(/^.+?[.!?](?=\s+\S)/)?.[0] || "";
+}
+
+function fillerMessage(text, seconds, board) {
+  const current = board?.current;
+  const extra = current ? workNote({ current: { ...current, question: text, seconds } }).replace(/^Claudia is working on "[^"]*", \d+ seconds in\.\s*/, "") : "";
+  return `[Still working] on "${scrubLine(text).slice(0, 200)}", ${Math.round(seconds)} seconds in.${extra ? ` ${extra}` : ""}`;
+}
+
+// The quick voice's decision, from the tag that opens its reply. SELF/JOB
+// when no work is running; ANSWER/ADD/REPLACE while it is; IGNORE (not
+// meant for Claudia) and REPEAT (cut-off words said again) either way. No tag (or
+// a garbled one): null, and the caller of this falls back to the safe choice.
+const QUICK_ACTIONS = new Set(["SELF", "JOB", "IGNORE", "ANSWER", "ADD", "REPLACE", "REPEAT", "BYE"]);
+function parseQuickReply(text) {
+  const raw = String(text || "");
+  // [[SELF]], or at the very start [SELF] or a bare SELF: Haiku 5.5 wrote
+  // every tag with single brackets ("[SELF] Yes, I'm here."), 11 Oct bench.
+  // BYE may come with another tag ("[[JOB]] [[BYE]]": do it, then hang up);
+  // the other tag is the action, and bye says the call ends after it.
+  const tags = [...raw.matchAll(/\[\[\s*([A-Za-z]+)\s*\]\]/g)].map((m) => m[1].toUpperCase()).filter((tag) => QUICK_ACTIONS.has(tag));
+  const lead = tags.length ? null : raw.match(/^\s*\[?\s*(SELF|JOB|IGNORE|ANSWER|ADD|REPLACE|REPEAT|BYE)\s*\]?(?=[\s:.,-]|$)[\s:.-]*/);
+  if (lead) tags.push(lead[1].toUpperCase());
+  let rest = lead ? raw.replace(lead[0], " ") : raw;
+  const second = rest.match(/^\s*\[\s*BYE\s*\][\s:.-]*/);
+  if (second) { tags.push("BYE"); rest = rest.replace(second[0], " "); }
+  const bye = tags.includes("BYE");
+  const action = tags.find((tag) => tag !== "BYE") || (bye ? "BYE" : null);
+  const line = action === "IGNORE" ? "" : spokenLine(rest.replace(/\[\[[^\]]*\]\]/g, " "));
+  return { action, bye, line };
+}
+
+// A line the quick voice said it handled alone, but which promises work
+// ("Let me grab a test clip. One sec."): only Claudia can do things, so the
+// job runs (11 Oct: two such promises were made and their jobs dropped).
+function promisesWork(line) {
+  return /\b(?:let me|i'll (?:check|look|grab|get|send|switch|change|find|pull|run|do|try|set)|one sec(?:ond)?|give me a (?:sec|second|moment|minute))\b/i.test(String(line || ""));
+}
+
+// A spoken line from model text: first line only, no control or markup,
+// bounded. Empty means "say nothing".
+// The lead-in before cut-off words are said again ([[REPEAT]]): the model's
+// own line when it is a short lead, else a plain one (Haiku 4.5 sometimes
+// says the cut words itself, and the caller would hear them twice).
+function repeatLead(line, cut) {
+  const words = (text) => String(text || "").toLowerCase().replace(/[^a-z0-9' ]+/g, " ").split(/\s+/).filter(Boolean);
+  const lead = words(line);
+  const cutWords = words(cut);
+  const echoes = lead.some((_, i) => i + 3 <= lead.length && cutWords.join(" ").includes(lead.slice(i, i + 3).join(" ")));
+  return !lead.length || lead.length > 8 || echoes ? "Sorry, as I was saying." : line;
+}
+
+function spokenLine(text) {
+  const line = String(text || "").split("\n").map((part) => part.trim()).find(Boolean) || "";
+  const clean = scrubLine(line).replace(/^["']|["']$/g, "").trim();
+  if (!clean || !/[A-Za-z]/.test(clean)) return "";
+  return clean.length > MAX_LINE_CHARS ? `${clean.slice(0, MAX_LINE_CHARS - 1)}…` : clean;
+}
+
+class QuickVoiceProcess {
+  constructor({ provider, settings = quickVoiceSettings(), systemPrompt, cwd = process.cwd(), spawnImpl = spawn, maxRestarts = 1, log = () => {} } = {}) {
+    this.provider = provider;
+    this.settings = settings;
+    this.systemPrompt = systemPrompt;
+    this.cwd = cwd;
+    this.spawnImpl = spawnImpl;
+    this.maxRestarts = maxRestarts;
+    this.log = log;
+    this.proc = null;
+    this.restarts = 0;
+    this.stopped = false;
+    this.queue = []; // generations awaiting their result, oldest first
+    this._seq = 0;
+    this._unsaid = false;
+    this._stopPromise = null;
+  }
+
+  static supported(provider) {
+    return provider?.id === "claude" && provider.capabilities?.persistentUtilityStream?.support === "native" &&
+      typeof provider.buildUtilityInvocation === "function";
+  }
+
+  invocation() {
+    const { model, effort, thinking } = this.settings;
+    const invocation = this.provider.buildUtilityInvocation({
+      purpose: "call-quick-voice",
+      tier: "low",
+      model,
+      effort,
+      coreInstructions: this.systemPrompt,
+      dynamicContext: "",
+      userPrompt: "",
+      readOnly: true,
+      fresh: true,
+    });
+    const args = [...invocation.args];
+    // The slim prompt replaces the CLI's default system prompt (no tool docs
+    // to read), which is most of what makes a warm reply start in about a second.
+    const appendAt = args.indexOf("--append-system-prompt");
+    if (appendAt >= 0) args[appendAt] = "--system-prompt";
+    const printAt = args.indexOf("-p");
+    args.splice(printAt >= 0 ? printAt + 1 : 0, 0,
+      "--input-format", "stream-json", "--include-partial-messages",
+      "--tools", "", "--strict-mcp-config", "--setting-sources", "");
+    if (!args.includes("--no-session-persistence")) args.push("--no-session-persistence");
+    const env = { ...invocation.env, OC_PROVIDER: this.provider.id, OC_UTILITY_PURPOSE: "call-quick-voice" };
+    // Thinking off: Haiku 4.5 went from 2-3 s to 0.7 s to its first word.
+    if (!thinking) env.MAX_THINKING_TOKENS = "0";
+    return { binary: invocation.binary, args, env };
+  }
+
+  start() {
+    if (this.stopped || this.proc) return this.proc;
+    const { binary, args, env } = this.invocation();
+    const proc = this.spawnImpl(binary, args, {
+      cwd: this.cwd, env, stdio: ["pipe", "pipe", "pipe"], detached: process.platform !== "win32", shell: false,
+    });
+    this.proc = proc;
+    this._unsaid = false;
+    const decoder = new StringDecoder("utf8");
+    let buffer = "";
+    proc.stdout.on("data", (data) => {
+      if (this.proc !== proc) return;
+      buffer += decoder.write(data);
+      if (buffer.length > MAX_BUFFER_BYTES) { buffer = ""; this._crashed(proc, "buffer"); return; }
+      let newline;
+      while ((newline = buffer.indexOf("\n")) >= 0) {
+        const line = buffer.slice(0, newline).trim();
+        buffer = buffer.slice(newline + 1);
+        if (!line) continue;
+        let event;
+        try { event = JSON.parse(line); } catch (_) { continue; }
+        this._onEvent(event);
+      }
+    });
+    proc.stderr.on("data", () => {});
+    proc.stdin.on("error", () => {});
+    proc.on("error", () => this._crashed(proc, "spawn-error"));
+    proc.on("close", () => this._crashed(proc, "exited"));
+    this.log(`started pid=${proc.pid ?? "?"} model=${this.settings.model} effort=${this.settings.effort} thinking=${this.settings.thinking ? "on" : "off"}`);
+    return proc;
+  }
+
+  ready() {
+    const proc = this.proc;
+    return !this.stopped && !!proc && proc.exitCode === null && proc.signalCode === null && !proc.stdin.destroyed;
+  }
+
+  // One user message; resolves with the reply text as soon as its text block
+  // closes (before the CLI's end-of-turn work), or "" when cancelled/failed.
+  // onText: called with the reply so far as it is written.
+  say(content, { onText = null } = {}) {
+    if (!this.ready()) return { generation: null, text: Promise.resolve("") };
+    let resolve;
+    const text = new Promise((done) => { resolve = done; });
+    const generation = { id: ++this._seq, text: "", cancelled: false, settled: false, resolve, onText, content: String(content), proc: null };
+    this.queue.push(generation);
+    if (this.queue[0] === generation) this._writeNext();
+    return { generation, text };
+  }
+
+  // One message in the CLI at a time: messages that wait in the CLI while it
+  // is busy can be merged into one turn with one result (11 Oct bench: a
+  // stopped line and the next got a single reply, so the next never
+  // resolved, and every reply after it would go to the wrong message). The
+  // next is written when the turn before it ends; one stopped before it was
+  // written is never sent.
+  _writeNext() {
+    while (this.queue.length && this.ready()) {
+      const generation = this.queue[0];
+      if (generation.proc) return;
+      if (generation.cancelled) { this.queue.shift(); generation.settled = true; continue; }
+      const body = this._unsaid ? `${UNSAID_NOTE}\n${generation.content}` : generation.content;
+      try {
+        this.proc.stdin.write(`${JSON.stringify({ type: "user", message: { role: "user", content: body } })}\n`);
+        generation.proc = this.proc;
+        this._unsaid = false;
+        return;
+      } catch (_) {
+        this.queue.shift();
+        generation.settled = true;
+        generation.resolve("");
+      }
+    }
+  }
+
+  // A message it was sent stays in its history even when cancelled: the next
+  // one tells it that reply was never said (UNSAID_NOTE).
+  retract(generation) {
+    if (!generation) return;
+    this.cancel(generation);
+    // Only a message the running process got: a restart starts a new history.
+    if (generation.proc && generation.proc === this.proc) this._unsaid = true;
+  }
+
+  // Stops the in-flight generation (Claude Code's stream-json control
+  // protocol); the CLI then closes that turn with an error result.
+  cancel(generation) {
+    if (!generation || generation.cancelled) return;
+    generation.cancelled = true;
+    generation.resolve("");
+    if (!generation.proc && !generation.settled) {
+      this.queue = this.queue.filter((item) => item !== generation);
+      generation.settled = true;
+      return;
+    }
+    if (generation.settled || this.queue[0] !== generation || !this.ready()) return;
+    try {
+      this.proc.stdin.write(`${JSON.stringify({ type: "control_request", request_id: `quick-interrupt-${generation.id}`, request: { subtype: "interrupt" } })}\n`);
+    } catch (_) {}
+  }
+
+  _onEvent(event) {
+    const generation = this.queue[0];
+    if (!generation) return;
+    if (event.type === "stream_event") {
+      const inner = event.event || {};
+      if (inner.type === "content_block_delta" && inner.delta?.type === "text_delta" && typeof inner.delta.text === "string") {
+        generation.text += inner.delta.text;
+        if (!generation.cancelled && generation.onText) {
+          try { generation.onText(generation.text); } catch (_) {}
+        }
+      } else if (inner.type === "content_block_stop" && generation.text.trim()) {
+        generation.resolve(generation.cancelled ? "" : generation.text);
+      }
+    } else if (event.type === "assistant" && !generation.text && Array.isArray(event.message?.content)) {
+      // A CLI without partial messages: the whole reply at once.
+      generation.text = event.message.content.filter((block) => block?.type === "text").map((block) => block.text || "").join("");
+    } else if (event.type === "result") {
+      this.queue.shift();
+      generation.settled = true;
+      generation.resolve(generation.cancelled || event.is_error ? "" : generation.text);
+      this._writeNext();
+    }
+  }
+
+  _crashed(proc, reason) {
+    if (this.proc !== proc) return;
+    this.proc = null;
+    for (const generation of this.queue.splice(0)) { generation.settled = true; generation.resolve(""); }
+    try { killProcessTree(proc.pid, "SIGKILL"); } catch (_) {}
+    if (this.stopped) return;
+    if (this.restarts >= this.maxRestarts) {
+      this.log(`gave up reason=${reason} restarts=${this.restarts}`);
+      return;
+    }
+    this.restarts += 1;
+    this.log(`restart reason=${reason} restarts=${this.restarts}`);
+    try { this.start(); } catch (error) { this.log(`restart failed: ${error.message}`); }
+  }
+
+  stop() {
+    if (this._stopPromise) return this._stopPromise;
+    this.stopped = true;
+    live.delete(this);
+    const proc = this.proc;
+    this.proc = null;
+    for (const generation of this.queue.splice(0)) { generation.settled = true; generation.cancelled = true; generation.resolve(""); }
+    if (!proc) return (this._stopPromise = Promise.resolve());
+    this._stopPromise = new Promise((resolve) => {
+      let killTimer = null;
+      const finish = () => { if (killTimer) clearTimeout(killTimer); resolve(); };
+      if (proc.exitCode !== null || proc.signalCode !== null) return finish();
+      proc.once("close", finish);
+      try { proc.stdin.end(); } catch (_) {}
+      try { killProcessTree(proc.pid, "SIGTERM"); } catch (_) { try { proc.kill("SIGTERM"); } catch (_) {} }
+      killTimer = setTimeout(() => {
+        try { killProcessTree(proc.pid, "SIGKILL"); } catch (_) { try { proc.kill("SIGKILL"); } catch (_) {} }
+      }, KILL_GRACE_MS);
+      killTimer.unref?.();
+    });
+    return this._stopPromise;
+  }
+}
+
+// A bot exit never leaves a quick-voice process behind.
+const live = new Set();
+function track(quick) {
+  live.add(quick);
+  return quick;
+}
+process.on("exit", () => {
+  for (const quick of live) {
+    const pid = quick.proc?.pid;
+    if (pid) { try { killProcessTree(pid, "SIGKILL"); } catch (_) {} }
+  }
+});
+
+module.exports = {
+  QuickVoiceProcess, quickVoiceSettings, buildQuickPrompt, utteranceMessage, fillerMessage, greetingMessage, spokenLine,
+  workNote, parseQuickReply, promisesWork, QUICK_ACTIONS, leadInMessage, nowNote, repeatLead, answerMessage, relayText, firstSentence,
+  scrubLine, ownerDisplayName, track, GREETING_ENTRIES, THREAD_GREETING_ENTRIES, sameWords, UNSAID_NOTE,
+};