@inetafrica/open-claudia 3.5.47 → 3.5.59

package/channels/kazee/call/manager.js

@@ -5,6 +5,9 @@ const { CallLeaseHeartbeat } = require("./lease");
 const { publicCallIdentity, requestRoomAccess, supportedIceServers } = require("./access");
 const { canonicalForChannel } = require("../../../core/identity");
 const { KazeeCallSession } = require("./session");
+const quickVoice = require("./quick-voice");
+const threadContext = require("./thread-context");
+const { stepForTool } = require("./job-steps");
 
 const DEFAULT_JANUS_URL = "wss://janus.kazee.africa/ws";
 const DEFAULT_ICE_SERVERS = [
@@ -14,6 +17,145 @@ const DEFAULT_ICE_SERVERS = [
 // FCM push TTL is 60s and chat-central treats ringing logs as fresh for 90s.
 // This is the outbound invitation deadline; terminal server events end it early.
 const RING_TIMEOUT_MS = 60_000;
+const qlog = (msg) => console.log(`${new Date().toISOString()} Kazee call quick: ${msg}`);
+// The quick line must be ready this soon after the words, or it is skipped:
+// by then the full agent is close to speaking itself.
+const QUICK_LINE_MAX_MS = 3500;
+// While the full agent works: a "still on it" line after this much quiet,
+// at most a few per turn, never after the answer.
+const QUICK_FILLER_QUIET_MS = 8000;
+const QUICK_FILLER_MAX = 3;
+const QUICK_TICK_MS = 500;
+// The phone keeps ringing while the quick voice writes an opening line from
+// the recent chat (~1.8 s, measured 11 Oct); past this, the fixed greeting.
+const QUICK_GREETING_MAX_MS = 3500;
+// A thread call reads the thread first (its title from the server, its last
+// brief, more of its turns), so its opening line gets longer to be written.
+const QUICK_THREAD_GREETING_MAX_MS = 6000;
+// A held answer waits at most this long for its lead-in; a plain one after.
+// Haiku 4.5 wrote them in 0.8-1.7 s on 11 Oct, and most are written while
+// the line before them still plays.
+const QUICK_LEAD_IN_MAX_MS = 1500;
+// The quick voice's first sentence for an answer it says (_relay) must be
+// ready this soon, or the answer is said as written. Its short lines took
+// 1.6-2.5 s on Opus 5.5 (11 Oct 18:21 call).
+const QUICK_RELAY_MAX_MS = 6000;
+// When the quick voice says the answers, nothing else will speak first, so
+// its holding line is said even when this late; past it, the "still on it"
+// line takes over (fillerQuietMs). 11 Oct 18:58: a line ready at 3.8 s was
+// skipped under the 3.5 s limit, and the caller heard nothing for 14 s.
+const QUICK_RELAY_LINE_MAX_MS = 8000;
+// Words that already say which question they answer need no lead-in.
+const LEAD_IN_ALREADY = /^(?:back to|on (?:the|your)|about (?:the|your)|as for|and on|now,? on)\b/i;
+// Words at which a message said while work runs is never only a check-in
+// (_routeBusy): "You there?" is 2, "Hey, are you still there? I can't hear
+// anything" 9, the 11 Oct complaint that hid a request 70.
+const LONG_UTTERANCE_WORDS = 20;
+// After the goodbye of a caller who wants the call ended while work is open:
+// this long with nothing playing, then the call ends (_hangUpWhenDone).
+const HANG_UP_QUIET_MS = 2000;
+const countWords = (text) => String(text || "").trim().split(/\s+/).filter(Boolean).length;
+
+// Runs fn in the call's chat context, as the full agent's turns do. A call
+// placed inside a thread runs in that thread's conversation.
+function inChat({ adapter, chatId, userId, threadId = null }, fn) {
+  const { runInChat } = require("../../../core/context");
+  const { conversationKeyFor, roomKeyFor } = require("../../../core/identity");
+  const transport = adapter?.type || "kazee";
+  const thread = threadId ? String(threadId) : null;
+  return runInChat({
+    adapter, channelId: String(chatId), userId: String(userId), transport, threadId: thread,
+    canonicalUserId: canonicalForChannel(transport, String(userId)),
+    conversationKey: conversationKeyFor(transport, String(chatId), thread),
+    roomKey: roomKeyFor(transport, String(chatId)),
+  }, fn);
+}
+
+// A thread id as Kazee sends it (a Mongo ObjectId), else none.
+function threadIdOf(value) {
+  const id = String(value || "").trim();
+  return /^[a-f0-9]{24}$/i.test(id) ? id : null;
+}
+
+// The provider the call's chat runs on: the quick voice uses its CLI and
+// credentials, as the full agent's turns do.
+function chatProvider(target) {
+  const id = inChat(target, () => {
+    const state = require("../../../core/state");
+    return state.getActiveProvider(state.currentState());
+  });
+  return id ? require("../../../core/providers").registry.getProvider(id) : null;
+}
+
+// The end of the call's chat, for the opening line. A chat turn files its
+// transcript under the conversation's own project (run-context's
+// projectSnapshot), not the shared workspace session, so read it from there.
+function recentChat(target, limit = quickVoice.GREETING_ENTRIES) {
+  return inChat(target, () => {
+    const current = require("../../../core/state").currentState();
+    const transcripts = require("../../../core/transcripts");
+    const project = require("../../../core/run-context").projectSnapshot(current, current.currentSession?.dir || null, undefined);
+    return transcripts.recentTranscriptEntries({ limit }, transcripts.transcriptStateForRun({ project }, current));
+  });
+}
+
+// The newest archived brief of the conversation target names (its thread's
+// own, for a thread call): thread-context.js newestBrief.
+function conversationBrief(target) {
+  return inChat(target, () => {
+    const current = require("../../../core/state").currentState();
+    const transcripts = require("../../../core/transcripts");
+    const project = require("../../../core/run-context").projectSnapshot(current, current.currentSession?.dir || null, undefined);
+    const info = transcripts.transcriptProjectInfo(transcripts.transcriptStateForRun({ project }, current));
+    return threadContext.newestBrief(info?.transcriptPath);
+  });
+}
+
+// What a call knows of its chat when it starts. A plain call: the end of the
+// chat, for the opening line. A thread call (thread-context.js): the thread's
+// title, its last brief and more of its turns, for the opening line, plus the
+// note every full-agent turn on the call carries.
+async function greetingContext(target) {
+  const threadId = threadIdOf(target?.threadId);
+  if (!threadId) return recentChat(target);
+  const scoped = { ...target, threadId };
+  let entries = [];
+  try { entries = await recentChat(scoped, threadContext.THREAD_ENTRIES); } catch (_) {}
+  let brief = null;
+  try { brief = conversationBrief(scoped); } catch (_) {}
+  const title = await threadContext.threadTitle(target.adapter, target.chatId, threadId);
+  return {
+    entries,
+    thread: {
+      id: threadId,
+      title,
+      briefAt: brief?.at || null,
+      brief: brief ? threadContext.briefHead(brief.text, threadContext.BRIEF_QUICK_CHARS) : "",
+      agentNote: threadContext.agentNote({ title, brief }),
+    },
+  };
+}
+
+// Work asked for on a call that then ended goes on in the call's chat: a
+// wake-up due now, so it runs as an ordinary chat turn (a full answer in chat
+// form, not phone brevity) and survives a restart. Calls are owner-only.
+// The scheduler takes the job's project, session and model/effort from the
+// current chat, so the job is made inside the call's chat (11 Oct: made
+// outside it, the job got the default "tickets" session and failed).
+function carryOnInChat({ adapter, chatId, userId, prompt, threadId = null }) {
+  const transport = adapter?.type || "kazee";
+  const canonicalUserId = canonicalForChannel(transport, String(userId));
+  const owner = String(userId) === String(adapter?.ownerUserId || "");
+  // A thread call's work carries on in its thread.
+  const thread = threadIdOf(threadId);
+  return inChat({ adapter, chatId, userId, threadId: thread }, () => require("../../../core/scheduler").addJob({
+    kind: "wakeup", adapter: adapter?.id || null, adapterType: transport,
+    channelId: String(chatId), threadId: thread, canonicalUserId, userId: String(userId),
+    createdBy: { canonicalUserId, userId: String(userId), channelId: String(chatId), adapterType: transport, owner, name: null, at: new Date().toISOString() },
+    prompt, label: "Carry on from the call", source: "call", fireAt: Date.now(),
+  }));
+}
+
 const OUTGOING_GREETING = "Hey, it's Claudia. Can you hear me okay?";
 // Inbound must greet too: callers get silence until they speak first, which
 // reads as a dead call (live test 2026-08-08 — media was up, caller hung up).
@@ -21,7 +163,9 @@ const INCOMING_GREETING = "Hey, it's Claudia — you're through. Can you hear me
 
 class KazeeCallManager {
   constructor({ adapter, SessionImpl = KazeeCallSession, janusUrl = process.env.KAZEE_JANUS_URL || DEFAULT_JANUS_URL,
-    iceServers = DEFAULT_ICE_SERVERS, deviceId = randomUUID() } = {}) {
+    iceServers = DEFAULT_ICE_SERVERS, deviceId = randomUUID(), resolveQuickProvider = chatProvider, quickSpawn = undefined,
+    quickSettings = quickVoice.quickVoiceSettings, quickTiming = {}, resolveGreetingContext = greetingContext, carryOn = carryOnInChat,
+    dispatchJob = null } = {}) {
     this.adapter = adapter;
     this.SessionImpl = SessionImpl;
     this.janusUrl = janusUrl;
@@ -30,6 +174,15 @@ class KazeeCallManager {
     this.deviceId = deviceId;
     this._pending = null;
     this._ringTimer = null;
+    this.resolveQuickProvider = resolveQuickProvider;
+    this.quickSpawn = quickSpawn;
+    this.quickSettings = quickSettings;
+    this.quickTiming = { lineMaxMs: QUICK_LINE_MAX_MS, fillerQuietMs: QUICK_FILLER_QUIET_MS, fillerMax: QUICK_FILLER_MAX, tickMs: QUICK_TICK_MS, greetingMaxMs: QUICK_GREETING_MAX_MS, threadGreetingMaxMs: QUICK_THREAD_GREETING_MAX_MS, leadInMaxMs: QUICK_LEAD_IN_MAX_MS, relayMaxMs: QUICK_RELAY_MAX_MS, relayLineMaxMs: QUICK_RELAY_LINE_MAX_MS, ...quickTiming };
+    this.resolveGreetingContext = resolveGreetingContext;
+    this.carryOn = carryOn;
+    // Where a full-agent job goes: this process's router, or (when the
+    // switchboard holds the call) the brain across the link.
+    this.dispatchJob = dispatchJob || ((envelope) => this.adapter._emit("message", envelope));
   }
 
   wire(socket) {
@@ -86,9 +239,13 @@ class KazeeCallManager {
   }
 
   _sessionEnded(session, reason) {
+    // Their line dropped and never came back (session.js _dropTick): the work
+    // carries on in the chat, and the chat says why the call ended.
+    if (reason === "connection-lost") this._lineLost(session);
     // Several terminal paths clear this.session before close() calls back.
     // Invalidate the closed call's work even when it no longer owns the slot.
-    session?._voiceTurn?.controller.abort("call-ended");
+    for (const job of [...(session?._jobs || []), session?._voiceTurn].filter(Boolean)) job.controller.abort("call-ended");
+    this._stopQuickVoice(session);
     if (this.session !== session) return;
     this._detachSession(session);
     if (this.adapter._socket?.connected) this.adapter._socket.emit("call:end", {
@@ -97,7 +254,8 @@ class KazeeCallManager {
   }
 
   _detachSession(session) {
-    session?._voiceTurn?.controller.abort("call-ended");
+    for (const job of [...(session?._jobs || []), session?._voiceTurn].filter(Boolean)) job.controller.abort("call-ended");
+    this._stopQuickVoice(session);
     if (this.session === session) this.session = null;
   }
 
@@ -132,7 +290,9 @@ class KazeeCallManager {
     if (!callerId || !chatId || !Number.isSafeInteger(roomId) || roomId <= 0) return reject("invalid_call");
     if (payload.roomAdmissionRequired !== undefined && typeof payload.roomAdmissionRequired !== 'boolean') return reject("invalid_call");
     if (callerId !== String(this.adapter.ownerUserId || "")) return reject("not_allowed");
-    if (callType !== "audio") return reject("unsupported_media");
+    // A video call is answered too: the caller's camera becomes stills the
+    // full agent can look at (camera.js); the bot itself sends only its voice.
+    if (callType !== "audio" && callType !== "video") return reject("unsupported_media");
     if (this.session || this._pending) return reject("busy");
     const pending = { identity: { ...identity, chatId }, controller: new AbortController() };
     this._pending = pending;
@@ -150,17 +310,29 @@ class KazeeCallManager {
       session = new this.SessionImpl({ roomId, chatId, callerId, botUserId: this.adapter.botUserId,
         ...this._sessionOptions(config, access, boundIdentity, pending.controller.signal), greeting: INCOMING_GREETING,
         onTranscript: (text, meta) => this._transcript(text, { ...payload, ...boundIdentity }, meta, session),
+        onEarlyWords: (text, meta) => this._earlyWords(text, meta, session),
+        onUtteranceDropped: (utteranceId) => this._dropEarly(session, utteranceId, "no turn"),
         onSpeechStart: () => this._speechStart(session),
+        onSpeechNoise: () => this._speechNoise(session),
         onMediaReady: () => this._mediaReady(session),
         onEnded: reason => { session?._leaseHeartbeat?.close(); pending.controller.abort(); this._sessionEnded(session, reason); },
       });
       session.callIdentity = boundIdentity;
       session.chatId = chatId;
+      // Rung from inside a thread (chat-central passes the checked root).
+      session.threadId = threadIdOf(payload.threadRootId);
       this.session = session;
+      this._callContext(session, chatId, callerId);
+      this._startQuickVoice(session, chatId, callerId);
+      const greeting = this._prepareGreeting(session, chatId, callerId);
       this._manageLease(session, access);
       await session.start();
       if (this.session !== session || session.closed || pending.controller.signal.aborted) return;
-      this.adapter._socket?.emit("call:accept", { ...boundIdentity, toUserId: callerId, callType: "audio", chatId, roomId });
+      // Answer once the opening line is ready, so the caller hears ringing,
+      // not silence, while it is written.
+      if (greeting) await greeting;
+      if (this.session !== session || session.closed || pending.controller.signal.aborted) return;
+      this.adapter._socket?.emit("call:accept", { ...boundIdentity, toUserId: callerId, callType, chatId, roomId });
       session._accepted = true;
       if (session._mediaReady) session._leaseHeartbeat?.activate();
     } catch (_) {
@@ -176,9 +348,11 @@ class KazeeCallManager {
   // the callee (socket + FCM/VoIP push). The callee's publisher appearing in
   // the room is what completes the media leg — the existing auto-subscribe in
   // the session handles that, so acceptance needs no extra media work here.
-  async outgoing({ chatId, toUserId } = {}) {
+  async outgoing({ chatId, toUserId, reason, threadId } = {}) {
     const target = String(toUserId || this.adapter.ownerUserId || "");
     const chat = String(chatId || "");
+    // Placed from a thread turn: the call belongs to that thread.
+    const thread = threadIdOf(threadId);
     if (!target || !chat) throw new Error("missing chatId/toUserId");
     if (target !== String(this.adapter.ownerUserId || "")) throw new Error("Calls are restricted to the owner");
     if (this.session || this._pending) throw new Error("busy: a call session is already active");
@@ -197,20 +371,29 @@ class KazeeCallManager {
       session = new this.SessionImpl({ roomId, chatId: chat, callerId: target, botUserId: this.adapter.botUserId,
         ...this._sessionOptions(config, access, identity, pending.controller.signal), asCaller: true, greeting: OUTGOING_GREETING,
         onTranscript: (text, meta) => this._transcript(text, remote, meta, session),
+        onEarlyWords: (text, meta) => this._earlyWords(text, meta, session),
+        onUtteranceDropped: (utteranceId) => this._dropEarly(session, utteranceId, "no turn"),
         onSpeechStart: () => this._speechStart(session),
+        onSpeechNoise: () => this._speechNoise(session),
         onMediaReady: () => this._mediaReady(session),
         onEnded: reason => { session?._leaseHeartbeat?.close(); pending.controller.abort(); this._clearRingTimer(); this._sessionEnded(session, reason); },
       });
       session.callIdentity = identity;
       session.chatId = chat;
+      session.threadId = thread;
       this.session = session;
+      this._callContext(session, chat, target);
+      this._startQuickVoice(session, chat, target);
+      // Written while the phone rings; the session speaks it once the callee
+      // picks up (no accept to hold on this side).
+      this._prepareGreeting(session, chat, target, { outgoing: true, reason });
       this._manageLease(session, access);
       await session.start();
       if (this.session !== session || session.closed || pending.controller.signal.aborted) throw new Error("Call cancelled");
-      this.adapter._socket.emit("call:invite", { ...identity, toUserId: target, callType: "audio", chatId: chat });
+      this.adapter._socket.emit("call:invite", { ...identity, toUserId: target, callType: "audio", chatId: chat, ...(thread ? { threadRootId: thread } : {}) });
       this._ringTimer = setTimeout(() => { this._ringTimer = null; this._ringTimeout(target, chat, roomId).catch(() => console.error("Kazee call ring timeout failed")); }, RING_TIMEOUT_MS);
       this._ringTimer.unref?.();
-      return { ...identity, chatId: chat, toUserId: target };
+      return { ...identity, chatId: chat, toUserId: target, ...(thread ? { threadId: thread } : {}) };
     } catch (error) {
       this._detachSession(session);
       if (session) await session.close("connect-failed").catch(() => {});
@@ -242,11 +425,395 @@ class KazeeCallManager {
   }
 
   _speechStart(session) {
-    if (session?._voiceTurn) session._voiceTurn.muted = true;
+    // Hold every job's speech while the caller talks; what they say next
+    // decides whether it is let through, waits, or is dropped (_routeBusy).
+    for (const job of session?._jobs || []) job.muted = true;
     // Sound alone is not a new request. Cancel queued work only once a new
     // complete transcript exists; a cough must not discard an accepted ask.
   }
 
+  // The sound that muted the turn had no words in it: not a new request, so
+  // the answer being worked on may speak again (11 Oct: wind while walking
+  // muted a lookup's answer for good, and the caller heard nothing).
+  _speechNoise(session) {
+    if (this.session !== session || session.closed) return;
+    if ((session._jobs || []).some((job) => job.muted && !job.controller.signal.aborted)) {
+      this._releaseJobs(session);
+      console.log(`${new Date().toISOString()} Kazee call noise: muted turn resumed`);
+    }
+    // A sound with no words cut an answer (or the greeting) off: say the rest.
+    this._resumeCut(session, "noise");
+  }
+
+  // Say again the words a caller cut off by accident (session.js _bargeIn):
+  // after a noise, a check-in, "say again", or words that need no answer.
+  // plain: the quick voice already led in ("Sorry, as I was saying.").
+  // Only a real new question drops them (_dropCut).
+  _resumeCut(session, why, { plain = false } = {}) {
+    if (this.session !== session || session.closed) return false;
+    const cut = session.takeCutSpeech?.();
+    if (!cut?.text) return false;
+    const text = plain || cut.fromStart ? cut.text : `Sorry, as I was saying. ${cut.text}`;
+    qlog(`resume cut (${why}) chars=${cut.text.length}${cut.fromStart ? " from start" : ""}`);
+    this._rememberSpeech(session, "assistant", cut.text);
+    session.speak(text, { resumable: true }).catch(() => {});
+    return true;
+  }
+
+  _dropCut(session, why) {
+    const cut = session.takeCutSpeech?.();
+    if (cut?.text) qlog(`cut dropped (${why}) chars=${cut.text.length}`);
+  }
+
+  // The caller asked to end the call ([[BYE]]). Right after the goodbye, or
+  // once the work they asked for is done and its answer said ([[JOB]]
+  // [[BYE]]). 11 Oct: "Hanging up now" and "Okay, talk soon" were said
+  // twice and the call stayed up until they hung up themselves.
+  async _hangUp(session, why) {
+    if (this.session !== session || session.closed) return;
+    session._hangUpPending = false;
+    qlog(`hang up (${why})`);
+    await session.close("goodbye").catch(() => {});
+  }
+
+  // Wanting the call ended while work is open ([[JOB]] [[BYE]], or [[BYE]]
+  // / [[ADD]] [[BYE]] while Claudia works): once the goodbye has played and
+  // the line is quiet for a moment, the call ends and the work carries on in
+  // the chat (_carryOn). 11 Oct 15:13: waiting for the work first kept the
+  // caller on the line 64 s ("You still didn't hang up").
+  _hangUpWhenDone(session) {
+    if (session._hangUpPending) return;
+    session._hangUpPending = true;
+    qlog("hang up after the goodbye, work carries on in the chat");
+    (async () => {
+      // Quiet for a moment, not just between two sentences of a line.
+      let quietSince = 0;
+      while (session._hangUpPending && this.session === session && !session.closed) {
+        await new Promise((resolve) => { const timer = setTimeout(resolve, this.quickTiming.tickMs); timer.unref?.(); });
+        const busy = session.speechBusy?.() || session.callerTalking?.();
+        if (busy) { quietSince = 0; continue; }
+        quietSince ||= Date.now();
+        if (Date.now() - quietSince < HANG_UP_QUIET_MS || !session._hangUpPending) continue;
+        this._carryOn(session);
+        await this._hangUp(session, "work carries on in the chat");
+      }
+    })().catch((error) => qlog(`hang up failed: ${error.message}`));
+  }
+
+  // The call is ending with work still open. Each job not done yet is stopped
+  // and asked again as a chat turn, so it runs once, in full, and answers in
+  // chat form. A running one too: a call run keeps lookups short and offers
+  // longer work "after the call", so left to finish it only promised (11 Oct
+  // 17:05: "Okay, just fix it and then call me back" got "I'm on it" in the
+  // chat and nothing ran). An answer still held back is posted as it is.
+  _carryOn(session, { dropped = false } = {}) {
+    const asked = [];
+    for (const job of this._openJobs(session)) {
+      if (job.done) {
+        const held = job.pending.splice(0).join(" ").trim();
+        if (held) this._postToChat(session, held);
+      } else {
+        job.started = job.running;
+        this._dropJob(session, job, "cancelled");
+        asked.push(job);
+      }
+    }
+    if (!asked.length) return 0;
+    qlog(`carried on in the chat: asked=${asked.length} running=${asked.filter((job) => job.started).length}`);
+    const name = String(asked[0]?.incoming?.fromUserName || "").trim() || "The caller";
+    const call = (session._voiceHistory || []).slice(-6)
+      .map((entry) => `${entry.role === "user" ? name : "Claudia"}: ${entry.text.slice(-600)}`).join("\n");
+    for (const job of asked) {
+      const prompt = [
+        dropped
+          ? `[Carried on from a call] On the Kazee call that just ended, ${name} asked for this, then their line dropped and did not come back, so the call ended and the work carries on here. Do it now and report the result in this chat. If they asked to be called back when it is done, place the call once it is ready.`
+          : `[Carried on from a call] On the Kazee call that just ended, ${name} asked for this and wanted the call ended, so it was hung up and the work carries on here. Do it now and report the result in this chat. If they asked to be called back when it is done, place the call once it is ready.`,
+        `Asked on the call: "${job.question}"`,
+        job.started ? "Work on it had started during the call and was stopped; anything it already changed is in place." : "",
+        call ? `The call's last words (most recent last):\n${call}` : "",
+      ].filter(Boolean).join("\n");
+      try { this.carryOn({ adapter: this.adapter, chatId: session.chatId, userId: job.incoming?.fromUserId || session.callerId, prompt, ...(session.threadId ? { threadId: session.threadId } : {}) }); }
+      catch (error) { qlog(`carry on failed: ${error.message}`); }
+    }
+    const short = (text) => (text.length > 120 ? `${text.slice(0, 117)}...` : text);
+    const lead = dropped ? "Your line dropped and didn't come back, so I ended the call." : "Call ended.";
+    this._postToChat(session, `${lead} Carrying on here: ${asked.map((job) => `"${short(job.question)}"`).join("; ")}`);
+    return asked.length;
+  }
+
+  _lineLost(session) {
+    const carried = this._carryOn(session, { dropped: true });
+    if (carried) return;
+    const heard = String(session.lastHeardText?.() || "").trim();
+    const last = heard ? ` The last thing I heard was: "${heard.length > 160 ? `${heard.slice(0, 157)}...` : heard}"` : "";
+    this._postToChat(session, `Your line dropped and didn't come back within 30 seconds, so I ended the call.${last} Call me back when you can.`);
+  }
+
+  _postToChat(session, text) {
+    const chatId = String(session?.chatId || "");
+    if (!chatId || typeof this.adapter?.send !== "function") return Promise.resolve(false);
+    // A thread call's notes go to its thread.
+    const opts = session?.threadId ? [{ threadId: session.threadId }] : [];
+    return Promise.resolve(this.adapter.send(chatId, text, ...opts)).catch((error) => { qlog(`chat post failed: ${error.message}`); return false; });
+  }
+
+  _keepCall(session, why) {
+    if (!session?._hangUpPending) return;
+    session._hangUpPending = false;
+    qlog(`hang up cancelled (${why})`);
+  }
+
+  // ── Jobs: the full agent's work on a call ────────────────────────
+  //
+  // Each request the full agent works on is a job: the running one first,
+  // then any the caller added while it ran (they run in order in the call's
+  // lane). A job's speech is held, never dropped, while the caller talks, and
+  // goes out once the quick voice has decided what their words meant. Only a
+  // change of mind (REPLACE) or a call end stops a job.
+
+  // Work the caller's next words bear on: running or queued jobs, and a
+  // finished one whose answer is still held (it came in while they talked).
+  _openJobs(session) {
+    return (session?._jobs || []).filter((job) => !job.controller.signal.aborted && (!job.done || job.pending.length));
+  }
+
+  _releaseJobs(session) {
+    // Done jobs too: an answer that arrived while the caller talked waits here.
+    for (const job of (session?._jobs || []).filter((other) => !other.controller.signal.aborted)) {
+      job.muted = false;
+      job.flush?.().catch?.(() => {});
+    }
+  }
+
+
+  // What the quick voice is told about the work (quick-voice.js workNote).
+  _board(session, { except = null } = {}) {
+    const open = this._openJobs(session).filter((job) => job !== except);
+    const current = open.find((job) => job.done) || open.find((job) => job.running) || open[0] || null;
+    return {
+      current: current ? { question: current.question, seconds: (Date.now() - (current.runningSince || current.startedAt)) / 1000, steps: current.steps, said: current.said, ready: current.done } : null,
+      next: open.filter((job) => job !== current && !job.done).map((job) => job.question),
+      // An answer still waiting to be spoken is not "earlier": the quick
+      // voice must not tell it first.
+      earlier: (session?._answered || []).filter((item) => !item.job?.pending.length).slice(-2).map(({ question, answer }) => ({ question, answer })),
+      cut: session?.cutSpeech?.()?.text || "",
+    };
+  }
+
+    // ── Quick voice ───────────────────────────────────────────────────
+
+  _startQuickVoice(session, chatId, userId) {
+    let settings;
+    try { settings = this.quickSettings(); } catch (_) { return; }
+    if (!settings?.enabled) return;
+    let provider = null;
+    try { provider = this.resolveQuickProvider({ adapter: this.adapter, chatId, userId }); } catch (_) {}
+    if (!quickVoice.QuickVoiceProcess.supported(provider)) {
+      qlog(`off: provider ${provider?.id || "none"} has no warm stream`);
+      return;
+    }
+    const relay = settings.relay === true;
+    const quick = quickVoice.track(new quickVoice.QuickVoiceProcess({
+      provider, settings, spawnImpl: this.quickSpawn, log: qlog,
+      systemPrompt: quickVoice.buildQuickPrompt({ ownerName: quickVoice.ownerDisplayName(), relay }),
+    }));
+    session._quick = quick;
+    session._quickRelay = relay;
+    session._quickEarly = settings.early === true;
+    // The quick voice says the first line itself; the session's delayed cue
+    // would only double it.
+    session.acknowledgement = async () => null;
+    try { quick.start(); } catch (error) {
+      qlog(`start failed: ${error.message}`);
+      session._quick = null;
+      quick.stop().catch?.(() => {});
+    }
+  }
+
+  // While the phone rings, the quick voice reads the end of the chat and
+  // writes an opening line that picks up where things were left ("Hey Sumeet,
+  // still on the calls update? What's up?"). Nothing to go on, a failure or
+  // past greetingMaxMs: the fixed greeting, at once.
+  _prepareGreeting(session, chatId, userId, note = {}) {
+    const quick = session?._quick;
+    if (!quick?.ready()) return null;
+    const started = Date.now();
+    let expired = false;
+    let generation = null;
+    let timer = null;
+    const deadline = new Promise((resolve) => {
+      timer = setTimeout(() => { expired = true; resolve(null); }, session.threadId ? this.quickTiming.threadGreetingMaxMs : this.quickTiming.greetingMaxMs);
+      timer.unref?.();
+    });
+    const write = (async () => {
+      const message = quickVoice.greetingMessage(await this._callContext(session, chatId, userId), Date.now(), note);
+      if (!message || expired || session._quick !== quick) return "";
+      const asked = quick.say(message);
+      generation = asked.generation;
+      return quickVoice.spokenLine(await asked.text);
+    })().catch(() => "");
+    const line = Promise.race([write, deadline]).then((text) => {
+      clearTimeout(timer);
+      const ready = Date.now() - started;
+      if (!text) {
+        if (text === null) quick.cancel(generation);
+        qlog(`greeting ${text === null ? "late" : "skipped"} ready=${ready}ms, fixed greeting used`);
+        return "";
+      }
+      qlog(`greeting ready=${ready}ms chars=${text.length}`);
+      this._rememberSpeech(session, "assistant", text);
+      return text;
+    });
+    session.greetingLine = line;
+    return line;
+  }
+
+  // What the call knows of its chat, asked once per call (greetingContext):
+  // the opening line reads it, and a thread call keeps the thread's note for
+  // every full-agent turn (_startJob).
+  _callContext(session, chatId, userId) {
+    if (!session._context) {
+      const target = { adapter: this.adapter, chatId, userId, ...(session.threadId ? { threadId: session.threadId } : {}) };
+      session._context = Promise.resolve()
+        .then(() => this.resolveGreetingContext(target))
+        .then((context) => {
+          const thread = context && !Array.isArray(context) ? context.thread : null;
+          if (thread) {
+            session._threadNote = String(thread.agentNote || "");
+            qlog(`thread call: thread=${String(session.threadId).slice(-6)} title=${thread.title ? "yes" : "no"} brief=${thread.brief ? "yes" : "no"} turns=${Array.isArray(context.entries) ? context.entries.length : 0}`);
+          }
+          return context;
+        })
+        .catch(() => []);
+    }
+    return session._context;
+  }
+
+  _stopQuickVoice(session) {
+    const quick = session?._quick;
+    if (!quick) return;
+    session._quick = null;
+    quick.stop().catch?.(() => {});
+  }
+
+  // One utterance: a short fitting line as soon as the quick voice has it,
+  // then a "still on it" line whenever the full agent leaves the caller in
+  // silence, until its answer arrives. Never over the caller, never after
+  // the answer, never once a newer utterance took over.
+  _quickTurn(session, turn, text, { firstLine = true, early = null } = {}) {
+    const quick = session._quick;
+    const timing = this.quickTiming;
+    const open = () => !turn.done && !turn.controller.signal.aborted &&
+      !session.closed && this.session === session && (session._jobs || []).includes(turn) && session._quick === quick;
+    const live = () => !turn.muted && open();
+    const sayLine = async (message, label, { maxMs = Infinity, unlessSpoke = false, decide = false, early: started = null } = {}) => {
+      const asked = Date.now();
+      const { generation, text: reply } = started?.asked || quick.say(message);
+      const cancel = () => quick.cancel(generation);
+      turn.controller.signal.addEventListener("abort", cancel, { once: true });
+      let raw = "";
+      try { raw = await reply; }
+      finally { turn.controller.signal.removeEventListener("abort", cancel); }
+      const parsed = decide ? quickVoice.parseQuickReply(raw) : { action: null, line: quickVoice.spokenLine(raw) };
+      // Nothing was cut off: REPEAT can only mean it handled the words alone.
+      const cutText = session.cutSpeech?.()?.text || "";
+      if (parsed.action === "REPEAT" && !cutText) parsed.action = "SELF";
+      if (parsed.action === "REPEAT") parsed.line = quickVoice.repeatLead(parsed.line, cutText);
+      const promised = decide && parsed.action === "SELF" && quickVoice.promisesWork(parsed.line);
+      if (promised) parsed.action = "JOB";
+      const { line } = parsed;
+      const ready = Date.now() - asked;
+      // Not meant for Claudia (the TV, someone else in the room): no work, no
+      // line, and what their words cut off is said again (11 Oct 17:51: words
+      // stop her, then the quick voice decides whether they were for her).
+      // Late, or the full agent already answering: the job stands.
+      if (decide && parsed.action === "IGNORE" && !turn.spoke && open() && ready <= maxMs) {
+        qlog(`route: IGNORE ready=${ready}ms, job dropped heard=${JSON.stringify(quickVoice.scrubLine(text).slice(0, 80))}`);
+        this._dropJob(session, turn, "ignored");
+        this._resumeCut(session, "not for me");
+        return false;
+      }
+      // The quick voice handled it alone ("Are you there?"): the full agent's
+      // job for it is dropped, unless it has already started answering.
+      const self = decide && ["SELF", "REPEAT", "BYE"].includes(parsed.action) && !turn.spoke && open() && ready <= maxMs;
+      if (self) {
+        qlog(`route: ${parsed.action} ready=${ready}ms, job dropped heard=${JSON.stringify(quickVoice.scrubLine(text).slice(0, 80))} line=${JSON.stringify(line || "")}`);
+        this._dropJob(session, turn, "self");
+        if (parsed.action !== "BYE") this._keepCall(session, "caller talked on");
+      } else if (decide) {
+        this._dropCut(session, "new question");
+        // The job runs: logged too, so a call review sees every decision.
+        const said = promised ? " (said SELF, promised work)" : parsed.action && parsed.action !== "JOB" ? ` (said ${parsed.action})` : parsed.action ? "" : " (said no tag)";
+        qlog(`route: JOB${said}${parsed.bye ? " then BYE" : ""} ready=${ready}ms heard=${JSON.stringify(quickVoice.scrubLine(text).slice(0, 80))} line=${JSON.stringify(line || "")}`);
+        if (parsed.bye) this._hangUpWhenDone(session);
+        else this._keepCall(session, "new work");
+      }
+      // Handled alone: after [[REPEAT]] (a check-in, "say again") the cut-off
+      // words go out after the lead-in. After anything else the caller moved
+      // on, as the quick voice was told, so they are dropped (11 Oct 17:45: an
+      // answer said again after a new line on the same thing, "why you
+      // repeating yourself").
+      const resume = () => {
+        if (self && parsed.action === "REPEAT") this._resumeCut(session, "repeat", { plain: true });
+        else if (self) this._dropCut(session, parsed.action === "BYE" ? "goodbye" : "moved on");
+      };
+      // Handled alone, the line IS the answer: a sound that stops it, or the
+      // caller still talking when it is ready, keeps it for after the sound
+      // instead of losing it (11 Oct 17:31: "Do we try it" and "Are you
+      // ready" both went unanswered). Earlier cut-off words wait behind it,
+      // not spoken over the caller.
+      const keep = self && parsed.action !== "BYE";
+      const talking = session.callerTalking?.();
+      if (!line || !(self || live()) || ready > maxMs || (unlessSpoke && turn.spoke) || talking) {
+        if (keep && line && talking && session.keepUnsaid) {
+          session.keepUnsaid(line);
+          qlog(`${label} kept for later (caller talking) ready=${ready}ms chars=${line.length}`);
+          return false;
+        }
+        qlog(`${label} skipped ready=${ready}ms${talking ? " (caller talking)" : ""}`);
+        resume();
+        return false;
+      }
+      qlog(`${label} ready=${ready}ms chars=${line.length}`);
+      const spoken = await session.speak(line, keep ? { resumable: true } : undefined);
+      if (spoken !== false && (self || live())) this._rememberSpeech(session, "assistant", line);
+      if (spoken === false && keep) {
+        qlog(`${label} cut, kept for later chars=${line.length}`);
+        return false;
+      }
+      resume();
+      // Cut off mid-goodbye: they are still talking, so the call stays up.
+      if (self && parsed.action === "BYE" && spoken !== false && !session.callerTalking?.()) await this._hangUp(session, "goodbye");
+      return spoken !== false && (self || live());
+    };
+    (async () => {
+      const lineMaxMs = this._relaying(session) ? timing.relayLineMaxMs : timing.lineMaxMs;
+      if (firstLine) await sayLine(quickVoice.utteranceMessage(text, this._board(session, { except: turn })), "line", { maxMs: lineMaxMs, unlessSpoke: true, decide: true, early });
+      // A job the caller added waits its turn: no "still on it" for it until
+      // the full agent is actually on it.
+      while (open() && !turn.running && this._openJobs(session)[0] !== turn) {
+        await new Promise((resolve) => { const timer = setTimeout(resolve, timing.tickMs); timer.unref?.(); });
+      }
+      let fillers = 0;
+      let lastFillerAt = Date.now();
+      // While the job is open, not while it is unmuted: a cough mutes it for
+      // a moment, and the fillers must come back after (11 Oct: one noise
+      // ended them for good, and the caller sat through 28 s of silence).
+      while (fillers < timing.fillerMax && open()) {
+        await new Promise((resolve) => { const timer = setTimeout(resolve, timing.tickMs); timer.unref?.(); });
+        if (!open()) break;
+        // Not while it writes an answer of hers to say: that is next.
+        if (!live() || session.speechBusy?.() || session.callerTalking?.() || session._relayBusy) continue;
+        const quietSince = Math.max(turn.runningSince || turn.startedAt, lastFillerAt, session._lastSpokeAt || 0);
+        if (Date.now() - quietSince < timing.fillerQuietMs) continue;
+        fillers += 1;
+        lastFillerAt = Date.now();
+        await sayLine(quickVoice.fillerMessage(text, (Date.now() - (turn.runningSince || turn.startedAt)) / 1000, this._board(session)), `filler ${fillers}`);
+        lastFillerAt = Date.now();
+      }
+    })().catch((error) => qlog(`turn failed: ${error.message}`));
+  }
+
   _rememberSpeech(session, role, text) {
     const history = session._voiceHistory ||= [];
     if (role === "assistant" && history.at(-1)?.role === "assistant") {
@@ -255,19 +822,407 @@ class KazeeCallManager {
     while (history.length > 8 || history.reduce((size, entry) => size + entry.text.length, 0) > 12000) history.shift();
   }
 
+  // Take back the last words remembered for the assistant when they were
+  // never said. Consecutive lines share one entry, so only their tail goes.
+  _forgetSpeech(session, text) {
+    const history = session._voiceHistory || [];
+    const last = history.at(-1);
+    const words = String(text).slice(-6000);
+    if (last?.role !== "assistant") return;
+    if (last.text === words) history.pop();
+    else if (last.text.endsWith(` ${words}`)) last.text = last.text.slice(0, -(words.length + 1));
+  }
+
+  // A job's written answer, no longer waiting to be said: these words of it
+  // (when given), or all of it.
+  _settleUnsaid(session, job, texts = null) {
+    if (!session?._unsaid?.length) return;
+    const left = [...(texts || [])];
+    session._unsaid = session._unsaid.filter((entry) => {
+      if (entry.job !== job) return true;
+      if (!texts) return false;
+      const at = left.indexOf(entry.text);
+      if (at < 0) return true;
+      left.splice(at, 1);
+      return false;
+    });
+  }
+
   _transcript(text, incoming, meta = {}, sourceSession = this.session) {
     const session = this.session;
     if (!session || session.closed || sourceSession !== session || !text) return;
     // In a group room, tell the provider who is talking; 1:1 stays unprefixed.
     const speaker = String(meta.display || "").trim();
     const attributed = (meta.participants || 0) > 1 && speaker ? `${speaker}: ${text}` : text;
-    session._voiceTurn?.controller.abort("superseded");
-    const turn = { controller: new AbortController(), muted: false };
+    const early = this._takeEarly(session, attributed, meta);
+    // Work is running and the quick voice is up: it decides what these words
+    // mean for that work. Otherwise they start a job.
+    if (this._openJobs(session).length && session._quick?.ready()) return this._routeBusy(session, attributed, incoming, meta, early);
+    // No quick voice to decide: the newest words take over, as before.
+    if (!session._quick?.ready()) {
+      session._voiceTurn?.controller.abort("superseded");
+      for (const job of this._openJobs(session)) job.controller.abort("superseded");
+    }
+    return this._startJob(session, attributed, incoming, meta, { early });
+  }
+
+  // The words heard when the caller stopped (session.js _commitTurn), about
+  // 0.7 s before the recogniser's final (median 688 ms over 273 finals, 11
+  // Oct). The quick voice starts on them now, with the message the final
+  // would send; _transcript uses that reply only if the final has the same
+  // words and the work has not changed. The full agent waits for the final.
+  // One at a time, so the quick voice hears the caller in order.
+  _earlyWords(text, meta = {}, sourceSession = this.session) {
+    const session = this.session;
+    if (!session || session.closed || sourceSession !== session || !text || !meta.utteranceId) return;
+    if (!session._quickEarly || !session._quick?.ready() || session._early) return;
+    const speaker = String(meta.display || "").trim();
+    const attributed = (meta.participants || 0) > 1 && speaker ? `${speaker}: ${text}` : text;
+    session._early = {
+      utteranceId: meta.utteranceId, text: attributed, quick: session._quick, jobs: this._openJobs(session), at: Date.now(),
+      asked: session._quick.say(quickVoice.utteranceMessage(attributed, this._board(session))),
+    };
+  }
+
+  // The early reply for the final's words, or null. A final with other words
+  // (or other work by now) stops it, and the quick voice is told it was
+  // never said. Another utterance's final leaves it for its own.
+  _takeEarly(session, attributed, meta = {}) {
+    const early = session._early;
+    if (!early || early.utteranceId !== meta.utteranceId) return null;
+    session._early = null;
+    const jobs = this._openJobs(session);
+    const why = early.quick !== session._quick || !session._quick?.ready() ? "quick voice changed"
+      : !quickVoice.sameWords(early.text, attributed) ? "other words"
+        : jobs.length !== early.jobs.length || jobs.some((job, i) => job !== early.jobs[i]) ? "work changed" : "";
+    if (why) {
+      early.quick.retract(early.asked.generation);
+      qlog(`early start dropped (${why})`);
+      return null;
+    }
+    qlog(`early start used ${Date.now() - early.at}ms ahead`);
+    return early;
+  }
+
+  _dropEarly(session, utteranceId, reason) {
+    const early = session?._early;
+    if (!early || early.utteranceId !== utteranceId) return;
+    session._early = null;
+    early.quick.retract(early.asked.generation);
+    qlog(`early start dropped (${reason})`);
+  }
+
+  // Words said while a job runs. The quick voice tags them (quick-voice.js):
+  // IGNORE (not for Claudia), ANSWER (a check-in or status, answered from the
+  // job board), ADD (another request, run after the current one) or REPLACE
+  // (a change of mind: the current work is stopped). No usable tag in time:
+  // ADD, so nothing is lost and nothing is stopped by a guess.
+  async _routeBusy(session, text, incoming, meta, early = null) {
+    const quick = session._quick;
+    this._rememberSpeech(session, "user", text);
+    const asked = Date.now();
+    const { generation, text: reply } = early?.asked || quick.say(quickVoice.utteranceMessage(text, this._board(session)));
+    let timer = null;
+    const late = new Promise((resolve) => { timer = setTimeout(() => resolve(null), this.quickTiming.lineMaxMs); timer.unref?.(); });
+    const raw = await Promise.race([reply.catch(() => ""), late]);
+    clearTimeout(timer);
+    if (raw === null) quick.cancel(generation);
+    if (this.session !== session || session.closed) return;
+    const parsed = quickVoice.parseQuickReply(raw || "");
+    const cutText = session.cutSpeech?.()?.text || "";
+    if (parsed.action === "REPEAT" && !cutText) parsed.action = "ANSWER";
+    if (parsed.action === "REPEAT") parsed.line = quickVoice.repeatLead(parsed.line, cutText);
+    let action = parsed.action === "SELF" ? "ANSWER" : (["IGNORE", "ANSWER", "ADD", "REPLACE", "REPEAT", "BYE"].includes(parsed.action) ? parsed.action : "ADD");
+    // A long message is never only a check-in: what it asks would be lost,
+    // as ANSWER starts no work (11 Oct: "say apple at some point" inside a
+    // 70-word complaint was answered "Got it" and never done).
+    const long = action === "ANSWER" && countWords(text) >= LONG_UTTERANCE_WORDS;
+    if (long) action = "ADD";
+    const ready = Date.now() - asked;
+    qlog(`route: ${action}${parsed.action && parsed.action !== action ? ` (said ${parsed.action || "no tag"}${long ? ", long" : ""})` : ""}${parsed.bye && action !== "BYE" ? " then BYE" : ""}${raw === null ? " (late)" : ""} ready=${ready}ms heard=${JSON.stringify(quickVoice.scrubLine(text).slice(0, 80))} line=${JSON.stringify(parsed.line || "")}`);
+    // keep: the line is the whole answer (ANSWER), so the caller still
+    // talking, or a sound that stops it, keeps it for later, as in _quickTurn.
+    const sayLine = async ({ keep = false } = {}) => {
+      if (!parsed.line || raw === null) return false;
+      if (session.callerTalking?.()) {
+        if (!keep || !session.keepUnsaid) return "talking";
+        session.keepUnsaid(parsed.line);
+        qlog(`answer kept for later (caller talking) chars=${parsed.line.length}`);
+        return "kept";
+      }
+      const spoken = await session.speak(parsed.line, keep ? { resumable: true } : undefined);
+      if (spoken === false) {
+        if (!keep) return false;
+        qlog(`answer cut chars=${parsed.line.length}`);
+        return "kept";
+      }
+      this._rememberSpeech(session, "assistant", parsed.line);
+      return true;
+    };
+    if (action === "REPLACE" || action === "ADD") this._dropCut(session, "new question");
+    // Wanting the call ended waits for the work to be done and said.
+    if (parsed.bye) this._hangUpWhenDone(session);
+    else if (action === "REPLACE" || action === "ADD") this._keepCall(session, "new work");
+    if (action === "BYE") {
+      await sayLine();
+      this._dropCut(session, "goodbye");
+      this._releaseJobs(session);
+      return;
+    }
+    if (action === "REPLACE") {
+      for (const job of this._openJobs(session)) this._dropJob(session, job, "replaced");
+      this._moveTalk(session, { question: text, placeholder: true });
+      await sayLine();
+      return this._startJob(session, text, incoming, meta, { remembered: true, firstLine: false });
+    }
+    if (action === "ADD") {
+      // The talk is now on the new question: a held answer that goes out
+      // next opens with a few words naming its own topic (_leadIn).
+      this._moveTalk(session, { question: text, placeholder: true });
+      const line = sayLine();
+      this._releaseJobs(session);
+      await line;
+      return this._startJob(session, text, incoming, meta, { remembered: true, firstLine: false });
+    }
+    const said = action === "ANSWER" || action === "REPEAT" ? await sayLine({ keep: action === "ANSWER" }) : false;
+    // Their next words already started: the cut words wait (a sound with no
+    // words, or the next turn, decides), never spoken over them (11 Oct
+    // 18:24: a REPEAT replayed 545 characters while they talked).
+    if (said === "talking") qlog(`resume held (caller talking) chars=${session.cutSpeech?.()?.text.length || 0}`);
+    else if (said !== "kept") this._resumeCut(session, action.toLowerCase(), { plain: action === "REPEAT" });
+    this._releaseJobs(session);
+  }
+
+  // Stop a job for good: its run is stopped (runner stopCallRunWhenDropped),
+  // and what it held back is never spoken.
+  _dropJob(session, job, reason) {
+    job.pending = [];
+    this._settleUnsaid(session, job);
+    job.controller.abort(reason);
+    session._jobs = (session._jobs || []).filter((other) => other !== job);
+  }
+
+  // ── Lead-ins ─────────────────────────────────────────────────────
+  //
+  // session._talk is what the call is on now: the job last asked or heard.
+  // When a job speaks after the talk moved on (another question was asked or
+  // answered in between), its words open with a few naming its topic: "Back
+  // to the mail backup." (11 Oct test: two answers ran together with no
+  // lead-in, and the caller could not tell which question each was for.)
+  _moveTalk(session, topic) {
+    session._talk = topic;
+    // Write each waiting job's lead-in now, so it is ready when its turn comes.
+    // Not when the quick voice says the answers: it opens them itself (_relay).
+    if (!session._quick?.ready() || this._relaying(session)) return;
+    for (const job of this._openJobs(session)) {
+      if (job !== topic && !job.leadIn) job.leadIn = this._writeLeadIn(session, job);
+    }
+  }
+
+  _writeLeadIn(session, job) {
+    const quick = session._quick;
+    const asked = Date.now();
+    const { generation, text } = quick.say(quickVoice.leadInMessage(job.question));
+    job.controller.signal.addEventListener("abort", () => quick.cancel(generation), { once: true });
+    return text.then((raw) => {
+      const line = quickVoice.spokenLine(String(raw || "").replace(/\[\[[^\]]*\]\]/g, " "));
+      qlog(`lead-in ready=${Date.now() - asked}ms line=${JSON.stringify(line)}`);
+      return line;
+    }).catch(() => "");
+  }
+
+  // The words a job opens with when the talk moved on: the quick voice's
+  // lead-in if it is ready in time, else a plain one. None when the call is
+  // still on this job, without a quick voice, or when the words already
+  // name their topic ("On your voice question, ...").
+  async _leadIn(session, job, response) {
+    if (session._talk === job || !session._quick?.ready() || !job.question) return "";
+    if (LEAD_IN_ALREADY.test(String(response || "").trim())) return "";
+    // Kept on the job until it has spoken, so a talk move meanwhile does not
+    // write it a second one.
+    const pending = job.leadIn ||= this._writeLeadIn(session, job);
+    let timer = null;
+    const late = new Promise((resolve) => { timer = setTimeout(() => resolve(null), this.quickTiming.leadInMaxMs); timer.unref?.(); });
+    const line = await Promise.race([pending, late]);
+    clearTimeout(timer);
+    return line || "On your earlier question.";
+  }
+
+  // ── The quick voice says the answers ─────────────────────────────
+  //
+  // The call has one voice (11 Oct 17:47, the caller: "it should handle
+  // everything"). The full agent's words go to the quick voice as text, and
+  // it says them in its own words. Everything said on the call went through
+  // it, so its own replies show what the caller already heard: it leaves that
+  // out, or skips words that add nothing (11 Oct 18:28: a second answer
+  // explained the setup again, "you just started re-explaining the same
+  // thing"). Its first sentence is said while it writes the rest. Slow, or
+  // gone: the words are said as written.
+
+  _relaying(session) {
+    return !!session?._quickRelay && !!session._quick?.ready();
+  }
+
+  // Resolves once what the quick voice made of the words has been said:
+  // true when it was said (or rightly skipped), false when it was not.
+  // One at a time per call, so each one sees what the one before said.
+  _relay(session, turn, texts) {
+    const words = texts.map((text) => String(text || "").trim()).filter(Boolean).join(" ");
+    if (!words) return Promise.resolve(false);
+    const queued = (session._relayChain || Promise.resolve()).then(() => this._relayNow(session, turn, words));
+    // Worded: what was said is remembered now (_sayRelayed), or nothing new
+    // was (SKIP). Either way the written words are no longer the call's.
+    const settle = () => this._settleUnsaid(session, turn, texts);
+    queued.then(settle, settle);
+    session._relayChain = queued.catch(() => {});
+    return queued.then((result) => result.played, () => false);
+  }
+
+  async _relayNow(session, turn, words) {
+    const quick = session._quick;
+    const gone = () => turn.controller.signal.aborted || this.session !== session || session.closed;
+    if (gone()) return { played: Promise.resolve(false) };
+    if (!this._relaying(session)) return { played: this._speakAsWritten(session, turn, words) };
+    const talk = session._talk;
+    const movedOn = talk && talk !== turn && talk.question && talk.question !== turn.question ? talk.question : "";
+    this._moveTalk(session, turn);
+    const quietSeconds = session._lastSpokeAt ? (Date.now() - session._lastSpokeAt) / 1000 : null;
+    const asked = Date.now();
+    const parts = [];
+    let first = "";
+    let settled = false;
+    session._relayBusy = (session._relayBusy || 0) + 1;
+    try {
+      const { generation, text } = quick.say(quickVoice.answerMessage({ question: turn.question, answer: words, done: turn.done, movedOn, quietSeconds }), {
+        onText: (raw) => {
+          if (first || settled || gone()) return;
+          first = quickVoice.firstSentence(raw);
+          if (!first) return;
+          qlog(`relay first sentence ready=${Date.now() - asked}ms chars=${first.length}`);
+          parts.push(this._sayRelayed(session, turn, first));
+        },
+      });
+      const cancel = () => quick.cancel(generation);
+      turn.controller.signal.addEventListener("abort", cancel, { once: true });
+      let timer = null;
+      const late = new Promise((resolve) => { timer = setTimeout(() => resolve(null), this.quickTiming.relayMaxMs); timer.unref?.(); });
+      let raw = await Promise.race([text, late]);
+      // Its first sentence went out in time: the rest is close behind.
+      if (raw === null && first) raw = await text;
+      clearTimeout(timer);
+      settled = true;
+      turn.controller.signal.removeEventListener("abort", cancel);
+      if (gone()) return { played: Promise.resolve(false) };
+      const ready = Date.now() - asked;
+      if (raw === null) {
+        quick.cancel(generation);
+        qlog(`relay late ready=${ready}ms, said as written chars=${words.length}`);
+        return { played: this._speakAsWritten(session, turn, words) };
+      }
+      const reply = quickVoice.relayText(raw);
+      if (reply.skip && !first) {
+        qlog(`relay: SKIP ready=${ready}ms, nothing new chars=${words.length}`);
+        return { played: Promise.resolve(true) };
+      }
+      if (!reply.text && !first) {
+        qlog(`relay failed ready=${ready}ms, said as written chars=${words.length}`);
+        return { played: this._speakAsWritten(session, turn, words) };
+      }
+      let rest = reply.text;
+      if (first) {
+        const at = rest.indexOf(first);
+        rest = at >= 0 ? rest.slice(at + first.length).trim() : "";
+      }
+      if (rest) parts.push(this._sayRelayed(session, turn, rest));
+      qlog(`relay ready=${ready}ms chars=${words.length}->${first.length + rest.length}`);
+      return { played: Promise.all(parts).then((results) => results.some(Boolean)) };
+    } finally {
+      session._relayBusy -= 1;
+    }
+  }
+
+  // One part of what the quick voice made of an answer. The caller talking
+  // (their words muted the job): kept after the words they cut off, said
+  // after a sound or a check-in, dropped by a new question (as cut words are).
+  async _sayRelayed(session, turn, part) {
+    if (turn.controller.signal.aborted || this.session !== session || session.closed) return false;
+    if (turn.muted || session._hangUpPending || session.callerTalking?.()) {
+      session.keepUnsaid?.(part, { after: true });
+      qlog(`relay kept for later (caller talking) chars=${part.length}`);
+      return false;
+    }
+    // Remembered when due, as in _speakAsWritten.
+    this._rememberSpeech(session, "assistant", part);
+    const spoken = await session.speak(part, { resumable: true });
+    if (spoken !== false && !turn.controller.signal.aborted && this.session === session && !session.closed) {
+      turn.spoke = true;
+      turn.said.push(part);
+      return true;
+    }
+    if (spoken === false) this._forgetSpeech(session, part);
+    return false;
+  }
+
+  // The full agent's words as it wrote them: no quick voice to say them, or
+  // the quick voice was too slow. A lead-in first when the talk moved on.
+  async _speakAsWritten(session, turn, response) {
+    // Remembered when it is due to be said, not once heard: the run ends
+    // without waiting for its answer to play (send below), and a job queued
+    // behind it reads the call so far when its prompt is built.
+    this._rememberSpeech(session, "assistant", response);
+    this._settleUnsaid(session, turn, [response]);
+    const lead = await this._leadIn(session, turn, response);
+    if (turn.controller.signal.aborted || this.session !== session || session.closed) return false;
+    if (session._talk !== turn) this._moveTalk(session, turn);
+    turn.leadIn = null;
+    const spoken = await session.speak(lead ? `${lead} ${response}` : response, { resumable: true });
+    if (spoken !== false && !turn.controller.signal.aborted && this.session === session && !session.closed) {
+      turn.spoke = true;
+      turn.said.push(response);
+      return true;
+    }
+    // Never said (cut off, or the call ended): not part of the call.
+    if (spoken === false) this._forgetSpeech(session, response);
+    return false;
+  }
+
+  _startJob(session, attributed, incoming, meta = {}, { remembered = false, firstLine = true, early: earlyStart = null } = {}) {
+    const speaker = String(meta.display || "").trim();
+    const turn = {
+      controller: new AbortController(), muted: false, done: false, spoke: false, startedAt: Date.now(),
+      question: attributed, running: false, runningSince: 0, steps: [], said: [], pending: [], answer: "",
+      incoming,
+    };
+    session._jobs = [...(session._jobs || []).filter((job) => !job.controller.signal.aborted && (!job.done || job.pending.length)), turn];
     session._voiceTurn = turn;
+    // A new question is what the call is on. One the caller added while
+    // work ran (_routeBusy) moved the talk when it was asked; it becomes
+    // this job unless something was heard since.
+    if (!remembered || (session._talk?.placeholder && session._talk.question === attributed)) this._moveTalk(session, turn);
     const callAdapter = Object.create(this.adapter);
     callAdapter.callHistory = (session._voiceHistory || []).map(entry => ({ ...entry }));
+    if (remembered && callAdapter.callHistory.at(-1)?.role === "user" && callAdapter.callHistory.at(-1).text === attributed) callAdapter.callHistory.pop();
     callAdapter.callTurn = { signal: turn.controller.signal };
-    this._rememberSpeech(session, "user", attributed);
+    // A thread call: every turn carries the thread's note (thread-context.js).
+    if (session._threadNote) callAdapter.liveCallThreadNote = session._threadNote;
+    if (!remembered) this._rememberSpeech(session, "user", attributed);
+    // Read when the prompt is built, not when queued: a job the caller added
+    // starts after the one before it, and must hear that job's answer.
+    const ownEntry = [...(session._voiceHistory || [])].reverse().find((entry) => entry.role === "user" && entry.text === attributed);
+    // An earlier job's answer is remembered when said, and the quick voice
+    // takes a few seconds to word it (_relay): until then it is read from
+    // what that job wrote. 12 Oct 07:20: a follow-up's prompt was built 1 s
+    // after the first run ended, 3 s before its answer was said, and it
+    // explained the audio routing all over again.
+    callAdapter.liveCallHistory = () => {
+      const history = (session._voiceHistory || []).filter((entry) => entry !== ownEntry).map((entry) => ({ ...entry }));
+      for (const { job, text } of session._unsaid || []) {
+        if (job === turn || job.controller.signal.aborted) continue;
+        if (history.at(-1)?.role === "assistant") history.at(-1).text = `${history.at(-1).text} ${text}`;
+        else history.push({ role: "assistant", text });
+      }
+      return history;
+    };
     // Provider narration/previews are useful in chat but must never be spoken
     // into a call. send() receives settled answers; explicit sentence speech
     // enters separately through the call-turn lease and outbound reply guard.
@@ -277,29 +1232,89 @@ class KazeeCallManager {
     callAdapter.suppressChatVisibility = true;
     // Prompt builder switches to phone-call brevity when it sees this.
     callAdapter.liveCall = true;
+    // The quick voice says the first line; the prompt then skips its own.
+    callAdapter.quickVoice = !!session._quick?.ready();
+    // ... and says this job's answer in its own words (_relay).
+    callAdapter.quickRelay = callAdapter.quickVoice && this._relaying(session);
+    // The caller's camera, read when the prompt is built (system-prompt.js).
+    callAdapter.liveCallCamera = () => session.cameraStill?.() || null;
     const spokenSentences = [];
-    callAdapter.isCallTurnActive = () => !turn.muted && !turn.controller.signal.aborted &&
-      !session.closed && this.session === session && session._voiceTurn === turn;
+    const open = () => !turn.controller.signal.aborted && !turn.done &&
+      !session.closed && this.session === session && (session._jobs || []).includes(turn);
+    // Held while the caller talks, never refused: the call-say CLI must not
+    // see a held job as stale (11 Oct: "loopback 409 ... stale").
+    callAdapter.isCallTurnActive = () => !turn.controller.signal.aborted &&
+      !session.closed && this.session === session && (session._jobs || []).includes(turn);
     callAdapter.cancelCallSpeech = () => {
-      if (this.session === session && session._voiceTurn === turn) session.cancelSpeech();
+      if (this.session === session && (session._jobs || []).includes(turn)) session.cancelSpeech();
     };
-    const speak = async response => {
-      if (!callAdapter.isCallTurnActive()) return false;
-      const spoken = await session.speak(response);
-      if (spoken !== false && callAdapter.isCallTurnActive()) {
-        this._rememberSpeech(session, "assistant", response);
-        return true;
-      }
-      return false;
+    // The job board: the runner reports when the full agent starts on this
+    // job and each tool it uses (core/runner.js onCallStage/onCallActivity).
+    callAdapter.onCallStage = (stage) => {
+      if (stage === "started" && !turn.running) { turn.running = true; turn.runningSince = Date.now(); }
+    };
+    callAdapter.onCallActivity = (event) => {
+      const step = event?.type === "tool_start" ? stepForTool(event.name, event.detail) : null;
+      if (step && turn.steps.at(-1) !== step) turn.steps.push(step);
+      if (turn.steps.length > 8) turn.steps.shift();
+    };
+    const speakNow = (response) => (this._relaying(session)
+      ? this._relay(session, turn, [response])
+      : this._speakAsWritten(session, turn, response));
+    // A job speaks only while it is on the board: a finished job leaves it
+    // once its last words are out, and never speaks again. After a goodbye
+    // its words wait and go to the chat (_carryOn): 11 Oct 17:05 an answer
+    // that came in after "Bye" was said for 15 s, and the call stayed up
+    // until the caller spoke again.
+    const speak = async (response) => {
+      if (turn.controller.signal.aborted || session.closed || this.session !== session || !(session._jobs || []).includes(turn)) return false;
+      if (turn.muted || session._hangUpPending) { turn.pending.push(response); return true; }
+      return speakNow(response);
+    };
+    turn.flush = async () => {
+      const free = () => turn.pending.length && !turn.muted && !session._hangUpPending && !turn.controller.signal.aborted;
+      // Held words go to the quick voice together: one reply, said once.
+      if (this._relaying(session) && free()) return this._relay(session, turn, turn.pending.splice(0));
+      while (free()) await speakNow(turn.pending.shift());
     };
     callAdapter.speakSentence = async response => {
       const spoken = await speak(response);
       if (spoken) spokenSentences.push(response);
       return spoken;
     };
+    // The answer handed over at the run's result event (core/runner.js
+    // earlyCallAnswer), before its process exits: the same words delivered
+    // after it are not said again, only anything past them.
+    let early = "";
+    const sameWords = (text) => String(text || "").trim().replace(/\s+/g, " ");
+    callAdapter.earlyCallAnswer = async (response) => {
+      if (early || !sameWords(response)) return false;
+      early = sameWords(response);
+      return deliver(response);
+    };
     callAdapter.send = async (_channelId, response) => {
+      const words = sameWords(response);
+      if (early && (!words || early.includes(words))) return true;
+      return deliver(early && words.startsWith(early) ? words.slice(early.length).trim() : response);
+    };
+    const deliver = async (response) => {
       const remainder = require("../../../core/call-speech").unspokenSuffix(response, spokenSentences);
-      if (remainder) await speak(remainder);
+      turn.answer = String(response || "");
+      if (turn.answer && !turn.controller.signal.aborted) {
+        session._answered = [...(session._answered || []), { question: turn.question, answer: turn.answer.slice(0, 400), job: turn }].slice(-4);
+      }
+      // Done, but kept on the board until the next job starts: a long reply
+      // can arrive in more than one send, and held words still go out.
+      turn.done = true;
+      // Not awaited: the run is over once its answer is written, so a job
+      // the caller added starts while this one is heard (session.speak plays
+      // them in order). 11 Oct: a queued question waited 27 s for the answer
+      // before it to finish playing before its run even began.
+      if (remainder) {
+        if (!turn.controller.signal.aborted) session._unsaid = [...(session._unsaid || []), { job: turn, text: remainder }].slice(-4);
+        // Not said (off the board, or the call moved on): not the call's.
+        speak(remainder).then((spoken) => { if (spoken === false) this._settleUnsaid(session, turn, [remainder]); }, () => this._settleUnsaid(session, turn, [remainder]));
+      }
       return true;
     };
     callAdapter.edit = async () => true;
@@ -308,9 +1323,13 @@ class KazeeCallManager {
       console.warn(`Kazee call ignored file voice response ${voicePath}; streamed TTS is active`);
       return true;
     };
-    this.adapter._emit("message", {
+    if (callAdapter.quickVoice) this._quickTurn(session, turn, attributed, { firstLine, early: earlyStart });
+    else if (earlyStart) earlyStart.quick.retract(earlyStart.asked.generation);
+    this.dispatchJob({
       adapter: callAdapter,
       channelId: String(incoming.chatId),
+      // A thread call's turns run in the thread's conversation.
+      ...(session.threadId ? { threadId: session.threadId } : {}),
       canonicalUserId: canonicalForChannel("kazee", String(incoming.fromUserId)),
       userId: String(incoming.fromUserId),
       type: "text",
@@ -318,7 +1337,8 @@ class KazeeCallManager {
       messageId: `call-${incoming.roomId}-${Date.now()}`,
       from: { id: String(incoming.fromUserId), name: incoming.fromUserName || "" },
       raw: { ...incoming, source: "kazee-call", ephemeralAudio: true, speaker: speaker || undefined, feedId: meta.feedId },
-    });
+    }, { turn, session });
+    return turn;
   }
 
   async ended(payload = {}) {
@@ -347,6 +1367,15 @@ class KazeeCallManager {
     this._detachSession(session);
     await session.close("adapter-stopped");
   }
+
+  // The switchboard is stopping for good (not a brain restart): end the call
+  // so the caller's app hangs up now, not after chat-central's 20 s grace.
+  async shutdown(reason = "switchboard-stopped") {
+    this._pending?.controller.abort();
+    this._clearRingTimer();
+    if (!this.session) return;
+    await this.session.close(reason);
+  }
 }
 
-module.exports = { KazeeCallManager, DEFAULT_ICE_SERVERS, DEFAULT_JANUS_URL };
+module.exports = { KazeeCallManager, DEFAULT_ICE_SERVERS, DEFAULT_JANUS_URL, recentChat, greetingContext, carryOnInChat, threadIdOf };