@inetafrica/open-claudia 3.4.14 → 3.4.15

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 3.4.15
+
+- Preserve complete Kazee speech turns with protocol-2 segment matching, bounded pending finals, and cancellation when speech resumes during an endpoint decision. Keep compatibility with older speech servers, including a delayed protocol-ready message.
+- Stop obsolete speech and remove superseded queued call turns on interruption or hangup. Use a fresh provider conversation with bounded spoken history while preserving identity, policy and recall. In-progress tools continue under their existing lifecycle.
+- Add `open-claudia call-say` for explicit complete answer sentences before the provider finishes. Each request is bound to the active call and run, redacted, and checked by the outbound reply guard. Retries are idempotent; final delivery removes the exact prefix already spoken. Provider previews and reasoning remain unspoken; this does not add token streaming to the provider transport.
+- Replace repeated thinking sounds with optional delayed fixed cues from the separate speech controller. Endpoint and cue models require the corresponding speech-service deployment; model quality, live latency and Android acceptance remain separate verification gates.
+- Isolate permission-test fixtures from inherited test-launcher approval without changing production permission gates.
+
 ## 3.4.14
 
 - Subscribe to managed call audio only when gateway-authenticated publisher metadata identifies a User. Exclude bots, the current bot's other feeds, and missing or malformed classifications before creating subscriber connections or speech streams.

package/bin/cli.js

@@ -277,6 +277,33 @@ switch (command) {
     break;
   }
 
+  case "call-say": {
+    if (args[1] === "--help" || args[1] === "-h") {
+      console.log("Usage: open-claudia call-say [--id <request-id>] <text>\nOr: open-claudia call-say [--id <request-id>] --stdin\nSpeak one checked 1–450 character chunk into the current call turn. Wait for completion; reuse an ID only when retrying identical text.");
+      break;
+    }
+    const parts = args.slice(1);
+    let requestId = require("crypto").randomUUID();
+    if (parts[0] === "--id") { parts.shift(); requestId = parts.shift(); }
+    const text = parts.length === 1 && parts[0] === "--stdin"
+      ? require("fs").readFileSync(0, "utf8").trim() : parts.join(" ").trim();
+    if (!text || text.length > 450 || !/^[A-Za-z0-9_-]{1,80}$/.test(requestId || "")) {
+      console.error("Provide a valid request ID and 1–450 characters of spoken text.");
+      process.exit(2);
+    }
+    (async () => {
+      try {
+        const result = await require("./loopback-client").postJson("call-say", { text, requestId });
+        if (result.ok !== true || result.spoken !== true) throw new Error("Speech was not completed");
+        console.log(result.duplicate ? "Already spoken." : "Spoken.");
+      } catch (error) {
+        console.error(error.message);
+        process.exitCode = 1;
+      }
+    })();
+    break;
+  }
+
   case "say": {
     // Agents probe with --help before speaking; don't synthesize the flag.
     if (args[1] === "--help" || args[1] === "-h") {
@@ -563,6 +590,7 @@ Send tools (only work inside an active bot-spawned task):
   open-claudia send-photo <path> [caption]
   open-claudia send-voice <path>
   open-claudia say "<text>"          Synthesize the text (TTS) and send it as a voice note
+  open-claudia call-say "<text>"     Speak a checked sentence into the active call turn
   open-claudia tts "<text>" --out <path>     Synthesize to a FILE without sending (voice-overs,
                                              narration; ext picks format; --voice <id> optional)
   open-claudia transcribe <file>     Speech-to-text: print the transcript of an audio/video file

package/bin/loopback-client.js

@@ -75,6 +75,7 @@ function postJson(kind, body) {
   const sameProject = !ctx.project || !requestedProject || requestedProject === ctx.project;
   const payload = JSON.stringify({
     ...body,
+    ...(kind === "call-say" ? { callSpeechToken: process.env.OC_CALL_SPEECH_TOKEN || "" } : {}),
     channelId: ctx.channelId,
     adapter: ctx.adapterId,
     userId: ctx.userId,

package/channels/kazee/call/manager.js

@@ -86,13 +86,21 @@ class KazeeCallManager {
   }
 
   _sessionEnded(session, reason) {
+    // 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");
     if (this.session !== session) return;
-    this.session = null;
+    this._detachSession(session);
     if (this.adapter._socket?.connected) this.adapter._socket.emit("call:end", {
       ...session.callIdentity, chatId: session.chatId, toUserId: session.callerId, reason,
     });
   }
 
+  _detachSession(session) {
+    session?._voiceTurn?.controller.abort("call-ended");
+    if (this.session === session) this.session = null;
+  }
+
   _manageLease(session, access) {
     if (!access) return;
     const socket = this.adapter._socket;
@@ -103,7 +111,7 @@ class KazeeCallManager {
       if (this.session !== session || session.closed) return;
       console.warn(`Kazee managed call lease ${reason}`);
       socket.emit("call:end", { ...session.callIdentity, deviceId: this.deviceId, chatId: session.chatId, toUserId: session.callerId, reason: "network-timeout" });
-      this.session = null;
+      this._detachSession(session);
       session.close(`lease-${reason}`).catch(() => console.error("Kazee call lease cleanup failed"));
     }, access.leaseExpiresAt, randomUUID);
   }
@@ -141,7 +149,8 @@ class KazeeCallManager {
       const boundIdentity = access ? { ...publicCallIdentity(access), deviceId: this.deviceId, generation: access.generation } : identity;
       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),
+        onTranscript: (text, meta) => this._transcript(text, { ...payload, ...boundIdentity }, meta, session),
+        onSpeechStart: () => this._speechStart(session),
         onMediaReady: () => this._mediaReady(session),
         onEnded: reason => { session?._leaseHeartbeat?.close(); pending.controller.abort(); this._sessionEnded(session, reason); },
       });
@@ -156,7 +165,7 @@ class KazeeCallManager {
       if (session._mediaReady) session._leaseHeartbeat?.activate();
     } catch (_) {
       const cancelled = pending.controller.signal.aborted;
-      if (this.session === session) this.session = null;
+      this._detachSession(session);
       if (session) await session.close("connect-failed").catch(() => {});
       if (!cancelled) reject("connection_failed");
     } finally { if (this._pending === pending) this._pending = null; }
@@ -187,7 +196,8 @@ class KazeeCallManager {
       const remote = { ...identity, chatId: chat, fromUserId: target, fromUserName: "" };
       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),
+        onTranscript: (text, meta) => this._transcript(text, remote, meta, session),
+        onSpeechStart: () => this._speechStart(session),
         onMediaReady: () => this._mediaReady(session),
         onEnded: reason => { session?._leaseHeartbeat?.close(); pending.controller.abort(); this._clearRingTimer(); this._sessionEnded(session, reason); },
       });
@@ -202,7 +212,7 @@ class KazeeCallManager {
       this._ringTimer.unref?.();
       return { ...identity, chatId: chat, toUserId: target };
     } catch (error) {
-      if (this.session === session) this.session = null;
+      this._detachSession(session);
       if (session) await session.close("connect-failed").catch(() => {});
       throw error;
     } finally { if (this._pending === pending) this._pending = null; }
@@ -223,7 +233,7 @@ class KazeeCallManager {
     // Caller hanging up while ringing: chat-central finalizes the CallLog as
     // missed and dismisses the callee's ringing UI/push.
     this.adapter._socket?.emit("call:end", { ...session.callIdentity, toUserId, chatId });
-    this.session = null;
+    this._detachSession(session);
     await session.close("no-answer").catch(() => {});
   }
 
@@ -231,23 +241,65 @@ class KazeeCallManager {
     if (this._ringTimer) { clearTimeout(this._ringTimer); this._ringTimer = null; }
   }
 
-  _transcript(text, incoming, meta = {}) {
+  _speechStart(session) {
+    if (session?._voiceTurn) session._voiceTurn.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.
+  }
+
+  _rememberSpeech(session, role, text) {
+    const history = session._voiceHistory ||= [];
+    if (role === "assistant" && history.at(-1)?.role === "assistant") {
+      history.at(-1).text = `${history.at(-1).text} ${text}`.slice(-6000);
+    } else history.push({ role, text: String(text).slice(-6000) });
+    while (history.length > 8 || history.reduce((size, entry) => size + entry.text.length, 0) > 12000) history.shift();
+  }
+
+  _transcript(text, incoming, meta = {}, sourceSession = this.session) {
     const session = this.session;
-    if (!session || !text) return;
+    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 };
+    session._voiceTurn = turn;
     const callAdapter = Object.create(this.adapter);
+    callAdapter.callHistory = (session._voiceHistory || []).map(entry => ({ ...entry }));
+    callAdapter.callTurn = { signal: turn.controller.signal };
+    this._rememberSpeech(session, "user", attributed);
     // Provider narration/previews are useful in chat but must never be spoken
-    // into a call. Only the settled, guarded final answer reaches send().
+    // into a call. send() receives settled answers; explicit sentence speech
+    // enters separately through the call-turn lease and outbound reply guard.
     callAdapter.suppressStreamPreview = true;
     // Recall/tooltrace banners route through the same send() as the answer —
     // without this flag the TTS reads memory-debug lines to the caller.
     callAdapter.suppressChatVisibility = true;
     // Prompt builder switches to phone-call brevity when it sees this.
     callAdapter.liveCall = true;
+    const spokenSentences = [];
+    callAdapter.isCallTurnActive = () => !turn.muted && !turn.controller.signal.aborted &&
+      !session.closed && this.session === session && session._voiceTurn === turn;
+    callAdapter.cancelCallSpeech = () => {
+      if (this.session === session && session._voiceTurn === 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;
+    };
+    callAdapter.speakSentence = async response => {
+      const spoken = await speak(response);
+      if (spoken) spokenSentences.push(response);
+      return spoken;
+    };
     callAdapter.send = async (_channelId, response) => {
-      await session.speak(response);
+      const remainder = require("../../../core/call-speech").unspokenSuffix(response, spokenSentences);
+      if (remainder) await speak(remainder);
       return true;
     };
     callAdapter.edit = async () => true;
@@ -275,7 +327,7 @@ class KazeeCallManager {
     if (payload.roomId != null && Number(payload.roomId) !== this.session.roomId) return;
     // Terminal server state is authoritative; ended attempts are never revived.
     const session = this.session;
-    this.session = null;
+    this._detachSession(session);
     await session.close("remote-ended");
   }
 
@@ -283,7 +335,7 @@ class KazeeCallManager {
     if (!this.session || !this._matches(payload)) return;
     if (payload.roomId != null && Number(payload.roomId) !== this.session.roomId) return;
     const session = this.session;
-    this.session = null;
+    this._detachSession(session);
     await session.close("remote-rejected");
   }
 
@@ -292,7 +344,7 @@ class KazeeCallManager {
     this._clearRingTimer();
     if (!this.session) return;
     const session = this.session;
-    this.session = null;
+    this._detachSession(session);
     await session.close("adapter-stopped");
   }
 }

package/channels/kazee/call/session.js

@@ -4,7 +4,8 @@ const { MediaStreamTrack, RTCPeerConnection, RtpHeader, RtpPacket } = require("w
 const { JanusClient } = require("./janus-client");
 const { projectAssignedIce, supportedIceServers } = require("./access");
 const { AdaptiveTurnDetector, OpusAudioCodec, WEBRTC_SAMPLES, downsample48To16, upsampleTo48 } = require("./audio");
-const { SpeechStream, synthesizePcm, synthesizeStream: synthesizeStreamPcm } = require("./speech-client");
+const { SpeechStream, synthesizePcm, synthesizeStream: synthesizeStreamPcm, detectTurn, selectAcknowledgement, CUE_PHRASES } = require("./speech-client");
+const { SpeechTurnGate } = require("./turn-gate");
 const ttsVoice = require("../../../core/tts-voice");
 
 const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
@@ -42,40 +43,18 @@ const WORD_RESCUE_MIN_MS = 1500;
 const WORD_RESCUE_NO_CADENCE_MS = 4000;
 const WORD_WAIT_MAX_MS = 4000;
 const FINAL_WAIT_MS = 2500;
+const SEGMENT_FINAL_WAIT_MS = 12000;
 const MIN_DISPATCH_WORDS = 2;
 const MAX_DURATION_GOODBYE = "We've hit the call time limit, so I'll hang up now. Message me any time.";
 const IDLE_GOODBYE = "I haven't heard anything for a while, so I'll hang up now. Message me any time.";
 
-// Audible state cues: a short ack chime when the caller finishes speaking, then
-// a soft periodic tick while the turn is being worked on — dead air otherwise
-// reads as a dropped call.
-const THINK_TICK_INTERVAL_MS = 1600;
-const THINKING_MAX_MS = 5 * 60_000;
-
-function tonePcm48(segments, gain = 0.08) {
-  const rate = 48000;
-  const fade = Math.floor(rate * 0.012);
-  const buffers = segments.map(({ freq, ms }) => {
-    const samples = Math.floor((rate * ms) / 1000);
-    const buf = Buffer.alloc(samples * 2);
-    for (let i = 0; i < samples; i += 1) {
-      let a = gain;
-      if (i < fade) a *= i / fade;
-      if (i > samples - fade) a *= Math.max(0, (samples - i) / fade);
-      buf.writeInt16LE(Math.round(Math.sin((2 * Math.PI * freq * i) / rate) * a * 32767), i * 2);
-    }
-    return buf;
-  });
-  return Buffer.concat(buffers);
-}
-
-// Rising two-tone "heard you", and a quieter single "still here" pulse.
-const ACK_CHIME_PCM48 = tonePcm48([{ freq: 660, ms: 90 }, { freq: 990, ms: 110 }], 0.09);
-const THINK_TICK_PCM48 = tonePcm48([{ freq: 520, ms: 90 }], 0.045);
+// One optional spoken cue after a delay, never periodic beeps.
+const ACK_DELAY_MS = 2800;
 
 class KazeeCallSession {
   constructor({ roomId, chatId, callerId, botUserId, janusUrl, janusToken, janusTokenExpiresAt, roomToken, roomTokenExpiresAt, managedRoom = false, refreshRoomAccess, iceServers = [], iceCredentialsExpiresAt, onTranscript, onEnded, onMediaReady,
     maxCallMs, idleMs, finalWaitMs, synthesize = synthesizePcm, synthesizeStream = null, asCaller = false, greeting = null,
+    turnDecision = detectTurn, acknowledgement = selectAcknowledgement, onSpeechStart,
     JanusClientImpl = JanusClient, PeerConnectionImpl = RTCPeerConnection, SpeechStreamImpl = SpeechStream } = {}) {
     this.roomId = Number(roomId);
     this.chatId = String(chatId);
@@ -103,6 +82,11 @@ class KazeeCallSession {
     this._transportIceExpiry = new Map();
     this._transportExpiryTimer = null;
     this.onTranscript = onTranscript || (() => {});
+    this.onSpeechStart = onSpeechStart || (() => {});
+    this.turnDecision = turnDecision;
+    this.acknowledgement = acknowledgement;
+    this._cueController = null;
+    this._cueRevision = 0;
     this.onEnded = onEnded || (() => {});
     this.onMediaReady = onMediaReady || (() => {});
     this._sentRtp = false;
@@ -392,8 +376,9 @@ class KazeeCallSession {
         codec: new OpusAudioCodec(),
         vad: new AdaptiveTurnDetector(),
         stt: new this.SpeechStreamImpl({
-          onTranscript: (text) => this._onFeedFinal(feedId, text),
-          onPartial: (text) => this._onFeedPartial(feedId, text),
+          onTranscript: (text, meta) => this._onFeedFinal(feedId, text, meta),
+          onPartial: (text, meta) => this._onFeedPartial(feedId, text, meta),
+          onDisconnect: () => this._resetRecognition(feedId),
         }),
         prebuffer: [],
         pending: [],
@@ -407,7 +392,9 @@ class KazeeCallSession {
         noiseCommit: false,
         fallbackUsed: false,
         finalTimer: null,
+        segments: new Map(),
       };
+      sub.turnGate = new SpeechTurnGate({ decide: this.turnDecision, commit: reason => this._commitTurn(feedId, reason) });
       this.subscribers.set(feedId, sub);
       pc.onTrack.subscribe((track) => {
         if (track.kind === "audio") track.onReceiveRtp.subscribe((packet) => this._onFeedRtp(feedId, packet));
@@ -452,9 +439,26 @@ class KazeeCallSession {
     }
   }
 
-  _onFeedPartial(feedId, text) {
+  _resetRecognition(feedId) {
+    const sub = this.subscribers.get(feedId);
+    if (!sub) return;
+    for (const segment of sub.segments.values()) clearTimeout(segment.timer);
+    sub.segments.clear();
+    if (sub.finalTimer) clearTimeout(sub.finalTimer);
+    sub.finalTimer = null;
+    sub.lastPartial = sub.partialAtCommit = "";
+    sub.wordCount = sub.lastWordAt = sub.awaitingWordsSince = 0;
+    sub.wordGaps = [];
+    sub.noiseCommit = sub.fallbackUsed = false;
+    sub.vad.reset();
+    sub.turnGate?.reset();
+    this._stopThinking();
+  }
+
+  _onFeedPartial(feedId, text, meta = {}) {
     const sub = this.subscribers.get(feedId);
     if (!sub || this.closed) return;
+    if (meta.protocol === 2 && (meta.streamId !== sub.stt.streamId || meta.segmentId !== sub.stt.segmentId)) return;
     const partial = String(text || "");
     const prevWords = countWords(sub.lastPartial);
     const words = countWords(partial);
@@ -469,7 +473,7 @@ class KazeeCallSession {
     }
     sub.wordCount += words - prevWords;
     sub.lastWordAt = now;
-    if (sub.awaitingWordsSince) this._commitTurn(feedId, "words-arrived");
+    if (sub.awaitingWordsSince && sub.stt.protocol !== 2) this._commitTurn(feedId, "words-arrived");
   }
 
   // Interims arrive in bursts whose cadence tracks recogniser health (jig
@@ -485,23 +489,49 @@ class KazeeCallSession {
     const sub = this.subscribers.get(feedId);
     if (!sub || this.closed) return;
     sub.awaitingWordsSince = 0;
+    sub.turnGate?.reset();
     if (sub.vad.active) sub.vad.reset();
     this._lastHeard = Date.now();
     clog(`Kazee call turn commit: feed=${feedId} reason=${reason} words=${sub.wordCount}`);
-    sub.stt.commit().catch((error) => console.error("Kazee call STT commit:", error.message));
-    if (!sub.noiseCommit) {
-      this._playCue(ACK_CHIME_PCM48).catch(() => {});
-      // STT finalization takes seconds; start ticking at commit so the
-      // chime→first-tick stretch doesn't read as a dead line.
-      this._startThinking();
-    }
-    // Finals routinely never arrive; after finalWaitMs the interim transcript
-    // is dispatched in their place.
+    const versioned = sub.stt.protocol === 2 && typeof sub.stt.commitTurn === "function";
+    if (versioned) {
+      if (sub.segments.size >= 4) {
+        this.close("speech-backlog").catch(() => {});
+        return;
+      }
+      const commit = sub.stt.commitTurn();
+      const key = `${commit.streamId}:${commit.segmentId}`;
+      const segment = { noiseCommit: sub.noiseCommit, committedAt: Date.now(), timer: null };
+      sub.segments.set(key, segment);
+      segment.timer = setTimeout(() => {
+        if (!sub.segments.delete(key)) return;
+        clog(`Kazee call final timeout: feed=${feedId} segment=${key}`);
+        this._stopThinking();
+        // Never substitute an old or unfinished transcript. Ask for a repeat
+        // only when the caller is quiet, so recovery cannot interrupt them.
+        if (!this.closed && !segment.noiseCommit && !this._speakActive &&
+            ![...this.subscribers.values()].some(peer => peer?.vad?.active)) {
+          this.speak("I missed that. Could you repeat it?").catch(() => {});
+        }
+      }, SEGMENT_FINAL_WAIT_MS);
+      segment.timer.unref?.();
+      commit.pending.catch(() => {
+        clearTimeout(segment.timer);
+        sub.segments.delete(key);
+        clog(`Kazee call STT commit failed: feed=${feedId} segment=${key}`);
+      });
+    } else {
+      sub.stt.commit().catch((error) => console.error("Kazee call STT commit:", error.message));
+    }
+    // Recognition must finish before any acknowledgement claims a heard turn.
+    // The legacy fallback is retained only for older speech deployments.
     sub.partialAtCommit = sub.lastPartial;
+    sub.lastPartial = "";
     sub.fallbackUsed = false;
     if (sub.finalTimer) clearTimeout(sub.finalTimer);
-    sub.finalTimer = setTimeout(() => this._finalFallback(feedId), this.finalWaitMs);
-    if (typeof sub.finalTimer.unref === "function") sub.finalTimer.unref();
+    sub.finalTimer = versioned ? null : setTimeout(() => this._finalFallback(feedId), this.finalWaitMs);
+    sub.finalTimer?.unref?.();
+    if (versioned) sub.noiseCommit = false;
     sub.wordCount = 0;
     sub.lastWordAt = 0;
     sub.wordGaps = [];
@@ -511,19 +541,28 @@ class KazeeCallSession {
     const sub = this.subscribers.get(feedId);
     if (!sub || this.closed) return;
     sub.finalTimer = null;
-    // Partials keep growing after commit while the decoder catches up; accept
-    // the grown text only if it extends the committed snapshot (anything else
-    // belongs to the next turn).
-    const current = sub.lastPartial || "";
+    // Legacy services cannot label late partials. Use only the committed
+    // snapshot; newer text could belong to a different utterance.
     const snapshot = sub.partialAtCommit || "";
-    const text = current.length > snapshot.length && current.startsWith(snapshot) ? current : snapshot;
+    const text = snapshot;
     sub.fallbackUsed = true;
     clog(`Kazee call final fallback: feed=${feedId} chars=${text.trim().length}`);
     this._dispatchTranscript(feedId, text);
   }
 
-  _onFeedFinal(feedId, text) {
+  _onFeedFinal(feedId, text, meta = {}) {
     const sub = this.subscribers.get(feedId);
+    if (!sub || this.closed) return;
+    if (meta.protocol === 2) {
+      const key = `${meta.streamId}:${meta.segmentId}`;
+      const segment = sub.segments.get(key);
+      if (!segment || meta.streamId !== sub.stt.streamId) return;
+      sub.segments.delete(key);
+      clearTimeout(segment.timer);
+      clog(`Kazee call final ready: feed=${feedId} segment=${key} wait=${Date.now() - segment.committedAt}ms`);
+      this._dispatchTranscript(feedId, text, { noiseCommit: segment.noiseCommit, utteranceId: key });
+      return;
+    }
     if (sub?.finalTimer) {
       clearTimeout(sub.finalTimer);
       sub.finalTimer = null;
@@ -536,11 +575,11 @@ class KazeeCallSession {
     this._dispatchTranscript(feedId, text);
   }
 
-  _dispatchTranscript(feedId, text) {
+  _dispatchTranscript(feedId, text, options = {}) {
     const sub = this.subscribers.get(feedId);
     const trimmed = String(text || "").trim();
-    if (sub?.noiseCommit) {
-      sub.noiseCommit = false;
+    if (options.noiseCommit ?? sub?.noiseCommit) {
+      if (options.noiseCommit === undefined) sub.noiseCommit = false;
       // A turn the recogniser never put words in was background noise; babble
       // occasionally leaks a single stray word into the transcript too.
       if (countWords(trimmed) < MIN_DISPATCH_WORDS) {
@@ -550,14 +589,16 @@ class KazeeCallSession {
       }
     }
     clog(`Kazee call transcript: feed=${feedId} chars=${trimmed.length}${trimmed.length ? "" : " (noise commit)"}`);
-    if (trimmed) this._startThinking();
+    if (trimmed) this._startThinking(trimmed);
     // Empty finalization (noise commit): nothing dispatches, no reply is
     // coming — don't tick into the void.
     else if (!this._speakActive && !this._speakQueue.length) this._stopThinking();
+    if (!trimmed) return;
     this.onTranscript(text, {
       feedId,
       display: sub?.display || "",
       participants: this.subscribers.size,
+      ...(options.utteranceId ? { utteranceId: options.utteranceId } : {}),
     });
   }
 
@@ -580,32 +621,34 @@ class KazeeCallSession {
     this._reportMediaReady();
   }
 
-  // Writes a short cue into the outbound track. Yields to real speech: the
-  // moment an utterance is active (or starting), remaining frames are dropped.
-  async _playCue(pcm48) {
-    if (this.closed || this.speaking || this._speakActive || !this.publisher) return;
-    for (let offset = 0; offset < pcm48.length; offset += WEBRTC_SAMPLES * 2) {
-      if (this.closed || this.speaking || this._speakActive) return;
-      this._writeFrame(pcm48.subarray(offset, offset + WEBRTC_SAMPLES * 2));
-      await wait(20);
-    }
-  }
-
-  _startThinking() {
-    if (this.closed || this._thinkTimer) return;
-    this._thinkingSince = Date.now();
-    this._thinkTimer = setInterval(() => {
-      if (this.closed || Date.now() - this._thinkingSince > THINKING_MAX_MS) return this._stopThinking();
-      if (this.speaking || this._speakActive) return;
-      this._playCue(THINK_TICK_PCM48).catch(() => {});
-    }, THINK_TICK_INTERVAL_MS);
-    if (typeof this._thinkTimer.unref === "function") this._thinkTimer.unref();
+  _startThinking(text = "", state = "waiting") {
+    this._stopThinking();
+    if (this.closed || !text) return;
+    const revision = this._cueRevision;
+    this._thinkTimer = setTimeout(async () => {
+      this._thinkTimer = null;
+      if (this.closed || this.speaking || this._speakActive ||
+          [...this.subscribers.values()].some(sub => sub?.vad?.active || sub?.turnGate?.pending)) return;
+      const controller = new AbortController();
+      this._cueController = controller;
+      try {
+        const cue = await this.acknowledgement(text, state, { signal: controller.signal });
+        if (cue && revision === this._cueRevision && !this.closed && !this._speakActive &&
+            ![...this.subscribers.values()].some(sub => sub?.vad?.active || sub?.turnGate?.pending)) {
+          await this.speak(cue);
+        }
+      } catch (_) { /* A missing cue never delays an answer. */ }
+      finally { if (this._cueController === controller) this._cueController = null; }
+    }, ACK_DELAY_MS);
+    this._thinkTimer.unref?.();
   }
 
   _stopThinking() {
-    if (!this._thinkTimer) return;
-    clearInterval(this._thinkTimer);
+    this._cueRevision += 1;
+    if (this._thinkTimer) clearTimeout(this._thinkTimer);
     this._thinkTimer = null;
+    this._cueController?.abort();
+    this._cueController = null;
   }
 
   _onFeedRtp(feedId, packet) {
@@ -626,6 +669,28 @@ class KazeeCallSession {
     sub.vad.boostTo = this.speaking ? SPEAKING_THRESHOLD_DB : null;
     const event = sub.vad.push(pcm);
     const pcm16 = downsample48To16(pcm);
+    if (sub.stt.protocol === 2 && sub.turnGate) {
+      if (event?.type === "start") {
+        sub.turnGate.resume();
+        this._lastHeard = Date.now();
+        this.cancelSpeech();
+        this._stopThinking();
+        this.onSpeechStart({ feedId });
+        for (const frame of sub.prebuffer.splice(0)) {
+          sub.turnGate.audio(frame);
+          this._feedAudio(sub, frame);
+        }
+      }
+      if (sub.vad.active || event || sub.turnGate.pending) {
+        sub.turnGate.audio(pcm16);
+        this._feedAudio(sub, pcm16);
+        if (event?.type === "commit") sub.turnGate.candidate(event.reason);
+      } else {
+        sub.prebuffer.push(pcm16);
+        if (sub.prebuffer.length > PREBUFFER_FRAMES) sub.prebuffer.shift();
+      }
+      return;
+    }
     if (sub.awaitingWordsSince) {
       // Energy closed the turn but the recogniser hasn't produced a word yet:
       // hold the commit and keep streaming audio so a slow decode still lands.
@@ -634,7 +699,8 @@ class KazeeCallSession {
         // Caller resumed before any words arrived — same turn continues.
         sub.awaitingWordsSince = 0;
         this._lastHeard = Date.now();
-        if (this.speaking) this.cancelSpeech();
+        this.cancelSpeech();
+        this.onSpeechStart({ feedId });
         this._stopThinking();
         return;
       }
@@ -653,7 +719,8 @@ class KazeeCallSession {
       this._lastHeard = Date.now();
       clog(`Kazee call VAD start: feed=${feedId}`);
       // Barge-in: the human wins — stop talking and listen.
-      if (this.speaking) this.cancelSpeech();
+      this.cancelSpeech();
+      this.onSpeechStart({ feedId });
       this._stopThinking();
       for (const frame of sub.prebuffer.splice(0)) this._feedAudio(sub, frame);
     }
@@ -694,6 +761,7 @@ class KazeeCallSession {
 
   cancelSpeech() {
     this._speakGen += 1;
+    this._synthController?.abort();
     for (const item of this._speakQueue.splice(0)) item.resolve(false);
   }
 
@@ -704,8 +772,11 @@ class KazeeCallSession {
       try {
         while (this._speakQueue.length && !this.closed) {
           const item = this._speakQueue.shift();
+          const controller = new AbortController();
+          this._synthController = controller;
           try { item.resolve(await this._playUtterance(item.text, this._speakGen)); }
-          catch (error) { item.reject(error); }
+          catch (error) { if (controller.signal.aborted) item.resolve(false); else item.reject(error); }
+          finally { if (this._synthController === controller) this._synthController = null; }
         }
       } finally {
         this._speakActive = false;
@@ -737,7 +808,7 @@ class KazeeCallSession {
     // Cache only audio rendered by the real service: the key is voice+text, so
     // PCM from an injected synthesize would leak across sessions.
     const usingService = this.synthesizeStream !== null || this.synthesize === synthesizePcm;
-    const cacheable = usingService && (text === this.greeting || text === MAX_DURATION_GOODBYE || text === IDLE_GOODBYE);
+    const cacheable = usingService && (text === this.greeting || text === MAX_DURATION_GOODBYE || text === IDLE_GOODBYE || Object.values(CUE_PHRASES).includes(text));
     const cacheKey = `${ttsVoice.getVoice()}::${text}`;
     const synthStart = Date.now();
     if (cacheable && SYNTH_CACHE.has(cacheKey)) {
@@ -752,7 +823,7 @@ class KazeeCallSession {
         clog(`Kazee call stream synth failed (${error.message}); buffering`);
       }
     }
-    const synthesized = await this.synthesize(text);
+    const synthesized = await this.synthesize(text, { signal: this._synthController?.signal });
     if (this.closed || gen !== this._speakGen) return false;
     const pcm48 = upsampleTo48(synthesized.pcm, synthesized.sampleRate);
     clog(`Kazee call speak: synth=${Date.now() - synthStart}ms chars=${text.length}`);
@@ -763,7 +834,7 @@ class KazeeCallSession {
   // Plays TTS as it downloads: the service streams PCM, but buffering the full
   // response cost ~3s of silence before the first word on every reply.
   async _playStreaming(text, gen, { cacheable, cacheKey, synthStart }) {
-    const { sampleRate, chunks } = await this.synthesizeStream(text);
+    const { sampleRate, chunks } = await this.synthesizeStream(text, { signal: this._synthController?.signal });
     if (this.closed || gen !== this._speakGen) return false;
     let rawCarry = Buffer.alloc(0); // an odd byte straddling a chunk boundary splits a sample
     let frameCarry = Buffer.alloc(0);
@@ -844,6 +915,9 @@ class KazeeCallSession {
     this._transportIceExpiry.delete(sub.pc);
     this._armTransportExpiry();
     if (sub.finalTimer) clearTimeout(sub.finalTimer);
+    for (const segment of sub.segments.values()) clearTimeout(segment.timer);
+    sub.segments.clear();
+    sub.turnGate?.close();
     try { sub.stt.close(); } catch (_) {}
     try { sub.codec.close(); } catch (_) {}
     try { await sub.pc.close(); } catch (_) {}