@inetafrica/open-claudia 3.5.47 → 3.5.58

package/channels/kazee/call/session.js

@@ -1,11 +1,14 @@
 "use strict";
 
-const { MediaStreamTrack, RTCPeerConnection, RtpHeader, RtpPacket } = require("werift");
+const { MediaStreamTrack, RTCPeerConnection, RTCRtpHeaderExtensionParameters, RtpHeader, RtpPacket } = require("werift");
 const { JanusClient } = require("./janus-client");
 const { projectAssignedIce, supportedIceServers } = require("./access");
-const { AdaptiveTurnDetector, OpusAudioCodec, WEBRTC_SAMPLES, downsample48To16, upsampleTo48 } = require("./audio");
+const { AdaptiveTurnDetector, OpusAudioCodec, WEBRTC_SAMPLES, downsample48To16, upsampleTo48, rmsDbfs } = require("./audio");
 const { SpeechStream, synthesizePcm, synthesizeStream: synthesizeStreamPcm, detectTurn, selectAcknowledgement, CUE_PHRASES } = require("./speech-client");
 const { SpeechTurnGate } = require("./turn-gate");
+const { CameraStills, VIDEO_ORIENTATION_URI, orientationExtensionId } = require("./camera");
+const path = require("path");
+const { MAX_SEGMENT_BYTES, missDir, segmentLevel, keepMiss, settings } = require("./miss-capture");
 const ttsVoice = require("../../../core/tts-voice");
 
 const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
@@ -22,6 +25,31 @@ const SYNTH_CACHE = new Map();
 // double as the STT/TTS timing measurements chat-side estimates lacked.
 const clog = (msg) => console.log(`${new Date().toISOString()} ${msg}`);
 
+// What came in from a caller, for the close log (13 Oct: a call heard no
+// words while packets arrived; the log could not say whether the audio was
+// silent, undecodable, or never loud enough for the voice gate). Levels are
+// whole dBFS per 20 ms frame, counted from -100 to 0.
+function newHeard() { return { frames: 0, decodeErrors: 0, starts: 0, hist: new Array(101).fill(0) }; }
+function noteHeard(heard, db) {
+  heard.frames += 1;
+  const at = Number.isFinite(db) ? Math.max(-100, Math.min(0, Math.round(db))) : -100;
+  heard.hist[at + 100] += 1;
+}
+function heardPercentile(heard, q) {
+  if (!heard.frames) return null;
+  const want = Math.max(1, Math.ceil(heard.frames * q));
+  for (let i = 0, seen = 0; i < heard.hist.length; i += 1) {
+    seen += heard.hist[i];
+    if (seen >= want) return i - 100;
+  }
+  return 0;
+}
+function heardSummary(heard, thresholdDb) {
+  const p = (q) => { const v = heardPercentile(heard, q); return v === null ? "none" : `${v}dB`; };
+  return `frames=${heard.frames} decode-errors=${heard.decodeErrors} p10=${p(0.1)} p50=${p(0.5)} p90=${p(0.9)} max=${p(1)} ` +
+    `voice-starts=${heard.starts} gate=${Number.isFinite(thresholdDb) ? Math.round(thresholdDb) : "none"}dB`;
+}
+
 // While TTS plays, the caller's device can leak bot audio back through its mic.
 // Require a much louder signal before treating incoming audio as human speech.
 const SPEAKING_THRESHOLD_DB = -26;
@@ -47,14 +75,158 @@ 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.";
+// Waiting on the caller and hearing no words, only sound or silence (Sumeet,
+// 12 Oct: the 06:47 call went silent for 100 s while his words were lost):
+// ask twice, then say goodbye and hang up unless words arrive in the grace.
+// Never while work runs or anyone is speaking.
+const CHECK_IN_MS = 10_000;
+const CHECK_IN_TICK_MS = 1000;
+const CHECK_IN_GRACE_MS = 5000;
+const CHECK_IN_SOUND_GRACE_MS = 3000;
+const CHECK_IN_LINES = ["Are you still there? I can't hear anything.", "I still can't hear you. Are you there?"];
+const NO_WORDS_GOODBYE = "I haven't been able to hear anything for a while, so I'll end this call. Call me back if you still need me.";
+
+// The caller's line, not the caller (Sumeet, 12 Oct 07:40): their audio
+// packets stopped. A phone sends one every 20 ms while the mic is open, and
+// at least every 400 ms even when it saves data in silence (Opus DTX), so 3 s
+// without one is the line. The moment they come back I say so, with the last
+// words I heard; after 30 s I give up and hang up.
+const DROP_MS = 3000;
+const DROP_GIVE_UP_MS = 30_000;
+const LINE_BACK_LEAD = "Sorry, I lost you there for a moment.";
+const LINE_BACK_NOTHING = `${LINE_BACK_LEAD} Can you hear me now?`;
+const LINE_BACK_RESUME = "As I was saying,";
+const LINE_BACK_WORDS = 12;
+// A soft hiss while I am not talking (Sumeet, 12 Oct 07:40), so a quiet line
+// still sounds alive and a dead one sounds dead. KAZEE_CALL_HUM sets its level
+// in dBFS, or "off".
+const HUM_DB = -55;
+// Speech writes a frame every 20 ms; the hiss fills only real gaps.
+const HUM_AFTER_SPEECH_MS = 60;
+// A speech frame this quiet (peak) carries nothing audible.
+const SILENT_FRAME_PEAK = 33;
+// With the hiss on, the bot should never go this long without sending.
+const SENT_GAP_MS = 1000;
+// A caller's app labels its audio stream when they mute or hold: Janus stops
+// forwarding a muted caller's audio and tells nobody, so without the label a
+// mute looked exactly like a dropped line (12 Oct). Janus passes a stream's
+// description on to everyone in the room. Apps without it act as before.
+const AUDIO_OFF_LABELS = new Set(["muted", "held"]);
+const HUM_FRAMES = 100;
+
+function humLevel(env = settings()) {
+  const raw = String(env.KAZEE_CALL_HUM ?? "").trim();
+  if (/^(off|false|no|0)$/i.test(raw)) return null;
+  const db = Number(raw);
+  return raw && Number.isFinite(db) && db < -20 ? db : HUM_DB;
+}
+
+// Two seconds of soft, slightly muffled noise at the given level, as 20 ms
+// frames to loop.
+function humFrames(db, frames = HUM_FRAMES) {
+  const samples = WEBRTC_SAMPLES * frames;
+  const raw = new Float64Array(samples);
+  let low = 0;
+  let sum = 0;
+  for (let i = 0; i < samples; i += 1) {
+    low += 0.3 * ((Math.random() * 2 - 1) - low);
+    raw[i] = low;
+    sum += low * low;
+  }
+  const scale = (32768 * 10 ** (db / 20)) / Math.sqrt(sum / samples || 1);
+  const pcm = Buffer.alloc(samples * 2);
+  for (let i = 0; i < samples; i += 1) pcm.writeInt16LE(Math.max(-32768, Math.min(32767, Math.round(raw[i] * scale))), i * 2);
+  return Array.from({ length: frames }, (_, k) => pcm.subarray(k * WEBRTC_SAMPLES * 2, (k + 1) * WEBRTC_SAMPLES * 2));
+}
+
+// Never holds the process open (a test or a closing bot).
+const softWait = (ms) => new Promise((resolve) => { const timer = setTimeout(resolve, ms); timer.unref?.(); });
 
 // One optional spoken cue after a delay, never periodic beeps.
 const ACK_DELAY_MS = 2800;
+// Cut-off words (cutSpeech): kept this long for the manager to say again.
+const CUT_KEEP_MS = 30_000;
+// Mary on Pocket TTS speaks ~16 characters a second (11 Oct, 370 chars in
+// 23.1 s); a little under, so the resume starts no later than the cut.
+const SPOKEN_CHARS_PER_SECOND = 14;
+// A line stopped with this little of it left (by the estimate above) counts
+// as heard: nothing is kept to say again.
+const HEARD_ENOUGH_LEFT_MS = 1500;
+// Words stop us, not sound (11 Oct 17:51: chewing stopped every reply, and a
+// sound gate fails in public or with a film on). Over our speech the caller's
+// turn starts at this many real words in the interim transcript; when we are
+// quiet, at one. Pipecat's MinWordsUserTurnStartStrategy counts the same way.
+const INTERRUPT_WORDS = 2;
+const FILLER_WORDS = new Set(["um", "umm", "uh", "uhh", "uhm", "erm", "er", "ah", "ahh", "oh", "mm", "mmm", "hmm", "hm", "mhm", "uh-huh", "huh", "ha"]);
+
+const wordList = (text) => String(text || "").toLowerCase().replace(/[^\p{L}\p{N}'\s-]/gu, " ").split(/\s+/).filter(Boolean);
+
+// Words someone really said: no fillers, and none of our own line (spoken)
+// coming back through their speaker. A word is ours when it and a neighbour
+// form a pair our line has; the caller's own words after it still count.
+function realWords(text, spoken = "") {
+  const words = wordList(text).filter((word) => !FILLER_WORDS.has(word));
+  if (words.length < 2 || !spoken) return words.length;
+  const ours = wordList(spoken);
+  const pairs = new Set(ours.slice(1).map((word, i) => `${ours[i]} ${word}`));
+  const echo = words.map(() => false);
+  for (let i = 1; i < words.length; i += 1) {
+    if (pairs.has(`${words[i - 1]} ${words[i]}`)) echo[i - 1] = echo[i] = true;
+  }
+  return echo.filter((isEcho) => !isEcho).length;
+}
+
+// What an offer carries, for the log: "audio:0:sendonly,video:1:port0".
+function sdpStreams(sdp) {
+  const out = [];
+  for (const block of String(sdp || "").split(/\r?\n(?=m=)/)) {
+    const m = block.match(/^m=(\w+) (\d+)/);
+    if (!m) continue;
+    const mid = block.match(/\na=mid:(\S+)/)?.[1] ?? "?";
+    const dir = block.match(/\na=(sendrecv|sendonly|recvonly|inactive)\b/)?.[1];
+    out.push(`${m[1]}:${mid}${m[2] === "0" ? ":port0" : ""}${dir ? `:${dir}` : ""}`);
+  }
+  return out.join(",") || "none";
+}
+
+// The caller's stream mids a subscriber offer really carries: from the
+// offer's streams list, minus m-lines Janus left inactive or with port 0
+// (a stream the caller had stopped). Same rule as the web app's
+// callMediaTracks.ts observe.
+function receivedMids(data, sdp) {
+  const sections = String(sdp || "").split(/\r?\n(?=m=)/).slice(1);
+  const mids = new Set();
+  for (const stream of data?.streams || []) {
+    const section = sections[Number(stream?.mindex)];
+    if (!section || stream.feed_mid == null || stream.active === false) continue;
+    if (/^m=\S+ 0 /.test(section) || /\na=inactive\r?(?:\n|$)/.test(section)) continue;
+    mids.add(String(stream.feed_mid));
+  }
+  return mids;
+}
+
+// The part of a line not yet heard after heardMs of playback, from the start
+// of the sentence it was cut in (a restart mid-word is hard to follow).
+// Under 1.5 s in, the whole line.
+function unheardText(text, heardMs) {
+  const full = String(text || "").trim();
+  if (!full || heardMs < 1500) return full;
+  const heardChars = (heardMs / 1000) * SPOKEN_CHARS_PER_SECOND;
+  const sentences = full.match(/[^.!?]+(?:[.!?]+["')\]]*|$)\s*/g) || [full];
+  let end = 0;
+  for (let i = 0; i < sentences.length; i += 1) {
+    end += sentences[i].length;
+    if (end > heardChars) return sentences.slice(i).join("").trim();
+  }
+  // Cut means it was still playing: the estimate ran past the end, so at
+  // least the last sentence went unheard.
+  return sentences.at(-1).trim();
+}
 
 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,
+    maxCallMs, idleMs, checkInMs, checkInGraceMs, dropMs, dropGiveUpMs, humDb, finalWaitMs, synthesize = synthesizePcm, synthesizeStream = null, asCaller = false, greeting = null,
+    turnDecision = detectTurn, acknowledgement = selectAcknowledgement, onSpeechStart, onSpeechNoise, onEarlyWords, onUtteranceDropped,
     JanusClientImpl = JanusClient, PeerConnectionImpl = RTCPeerConnection, SpeechStreamImpl = SpeechStream } = {}) {
     this.roomId = Number(roomId);
     this.chatId = String(chatId);
@@ -69,6 +241,9 @@ class KazeeCallSession {
     this.privateId = null;
     this.publisherId = null;
     this.greeting = greeting ? String(greeting) : null;
+    // Optional promise of a better opening line (the quick voice's greeting
+    // from the recent chat); empty or failed means the fixed greeting.
+    this.greetingLine = null;
     this._greeted = false;
     this._publisherUp = false;
     this._createdRoom = false;
@@ -83,6 +258,12 @@ class KazeeCallSession {
     this._transportExpiryTimer = null;
     this.onTranscript = onTranscript || (() => {});
     this.onSpeechStart = onSpeechStart || (() => {});
+    // The words heard when a turn was committed, before its final; and a
+    // committed turn that will never reach onTranscript (manager.js
+    // _earlyWords).
+    this.onEarlyWords = onEarlyWords || (() => {});
+    this.onUtteranceDropped = onUtteranceDropped || (() => {});
+    this.onSpeechNoise = onSpeechNoise || (() => {});
     this.turnDecision = turnDecision;
     this.acknowledgement = acknowledgement;
     this._cueController = null;
@@ -99,6 +280,25 @@ class KazeeCallSession {
     this.synthesizeStream = synthesizeStream ?? (synthesize === synthesizePcm ? synthesizeStreamPcm : null);
     this.maxCallMs = Number(maxCallMs ?? process.env.KAZEE_CALL_MAX_MS) || DEFAULT_MAX_CALL_MS;
     this.idleMs = Number(idleMs ?? process.env.KAZEE_CALL_IDLE_MS) || DEFAULT_IDLE_MS;
+    // Where segments that came back without words are kept (miss-capture.js).
+    this.missDir = missDir();
+    this.checkInMs = Number(checkInMs) || CHECK_IN_MS;
+    this.checkInGraceMs = Number(checkInGraceMs) || CHECK_IN_GRACE_MS;
+    this._lastWordsAt = 0;
+    this._workedAt = 0;
+    this._checkIns = 0;
+    this._checkInTimer = null;
+    this.dropMs = Number(dropMs) || DROP_MS;
+    this.dropGiveUpMs = Number(dropGiveUpMs) || DROP_GIVE_UP_MS;
+    this._lineDropped = null;
+    this._lastHeardText = "";
+    // Lines made ahead of time (the line-back while the caller is gone).
+    this._prepared = new Map();
+    this.humDb = humDb === undefined ? humLevel() : humDb;
+    this._lastSpeechFrameAt = 0;
+    // What went out, for the close log (12 Oct: the hiss went unheard and
+    // nothing showed whether it was ever sent).
+    this._sent = { speech: 0, silentSpeech: 0, hum: 0, gaps1s: 0, longestGapMs: 0, lastAt: 0 };
     this.finalWaitMs = Number(finalWaitMs) || FINAL_WAIT_MS;
     this.joinRetries = DEFAULT_JOIN_RETRIES;
     this.joinRetryDelayMs = DEFAULT_JOIN_RETRY_DELAY_MS;
@@ -111,6 +311,8 @@ class KazeeCallSession {
     this._speakQueue = [];
     this._speakActive = false;
     this._speakGen = 0;
+    this._speaking = null; // the item being said: { text, resumable, startedAt }
+    this._cut = null; // words the caller cut off: { text, fromStart, at }
     this._startedAt = 0;
     this._lastHeard = 0;
     this._lastSpokeAt = 0;
@@ -149,10 +351,14 @@ class KazeeCallSession {
     return { token: this.roomToken };
   }
 
-  _newPeerConnection() {
+  _newPeerConnection({ camera = false } = {}) {
     const expiresAt = this.iceCredentialsExpiresAt;
     if (this.managedRoom && (!Number.isFinite(expiresAt) || expiresAt <= Date.now() + 1000)) throw new Error("Call relay credentials unavailable");
-    const pc = new this.PeerConnectionImpl({ iceServers: this.iceServers });
+    // A feed's connection also takes the caller's camera; with the
+    // orientation extension a phone held upright gives an upright still.
+    const pc = new this.PeerConnectionImpl(camera
+      ? { iceServers: this.iceServers, headerExtensions: { audio: [], video: [new RTCRtpHeaderExtensionParameters({ id: 13, uri: VIDEO_ORIENTATION_URI })] } }
+      : { iceServers: this.iceServers });
     if (Number.isFinite(expiresAt)) {
       this._transportIceExpiry.set(pc, expiresAt);
       this._armTransportExpiry();
@@ -217,6 +423,13 @@ class KazeeCallSession {
     this._lastSpokeAt = this._startedAt;
     this._limitTimer = setInterval(() => { this._enforceLimits().catch(() => {}); }, LIMIT_CHECK_MS);
     if (typeof this._limitTimer.unref === "function") this._limitTimer.unref();
+    this._lastWordsAt = this._startedAt;
+    this._checkInTimer = setInterval(() => {
+      this._dropTick();
+      this._checkInTick().catch(() => {});
+    }, CHECK_IN_TICK_MS);
+    this._checkInTimer.unref?.();
+    if (this.humDb != null) this._humLoop().catch((error) => console.error("Kazee call hum:", error.message));
   }
 
   async _onPublisherEvent(frame) {
@@ -242,6 +455,10 @@ class KazeeCallSession {
       const feedId = Number(publisher.id);
       if (Number.isSafeInteger(feedId) && feedId > 0 && feedId !== this.publisherId && !this.subscribers.has(feedId)) {
         await this._subscribe(feedId, publisher.display, publisher.metadata);
+        this._noteAudioState(feedId, this.subscribers.get(feedId), publisher.streams);
+      } else if (this.subscribers.get(feedId)) {
+        this._noteAudioState(feedId, this.subscribers.get(feedId), publisher.streams);
+        await this._askForNewStreams(feedId, this.subscribers.get(feedId), publisher.streams);
       }
     }
     if (data.videoroom === "joined") {
@@ -338,7 +555,11 @@ class KazeeCallSession {
     if (!this.greeting || this._greeted || this.closed) return;
     if (!this._publisherUp || this.subscribers.size === 0) return;
     this._greeted = true;
-    this.speak(this.greeting).catch((error) => console.error("Kazee call greeting:", error.message));
+    const fixed = this.greeting;
+    Promise.resolve(this.greetingLine).catch(() => "").then((line) => {
+      if (this.closed) return null;
+      return this.speak(String(line || "").trim() || fixed, { resumable: true });
+    }).catch((error) => console.error("Kazee call greeting:", error.message));
   }
 
   async _subscribe(feedId, display, metadata) {
@@ -366,15 +587,17 @@ class KazeeCallSession {
       const roomAuth = await this._roomAuth();
       const handle = await this.janus.attach();
       if (this.closed) { await this.janus.detach(handle); this.subscribers.delete(feedId); return; }
-      const pc = this._newPeerConnection();
+      const pc = this._newPeerConnection({ camera: true });
       pc.iceConnectionStateChange?.subscribe?.((state) => clog(`Kazee call subscriber ICE: ${state} feed=${feedId}`));
       const sub = {
         handle,
         pc,
         display: String(display || ""),
+        metadata,
         // Opus decoders are stateful, so each feed needs its own.
         codec: new OpusAudioCodec(),
         vad: new AdaptiveTurnDetector(),
+        heard: newHeard(),
         stt: new this.SpeechStreamImpl({
           onTranscript: (text, meta) => this._onFeedFinal(feedId, text, meta),
           onPartial: (text, meta) => this._onFeedPartial(feedId, text, meta),
@@ -393,11 +616,21 @@ class KazeeCallSession {
         fallbackUsed: false,
         finalTimer: null,
         segments: new Map(),
+        // Audio sent for the open segment, kept until its final (miss-capture.js).
+        segAudio: [],
+        segBytes: 0,
+        // Packet timing: a drop is the line, not silence (_dropTick).
+        lastRtpAt: 0,
+        rtpPackets: 0,
+        maxRtpGap: 0,
+        rtpGaps400: 0,
+        rtpGaps1s: 0,
       };
       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));
+        if (track.kind === "video") this._onFeedVideo(feedId, sub, pc, track);
       });
       this.janus.onHandle(handle, (frame) => this._onSubscriberEvent(feedId, frame));
       const attached = await this.janus.message(handle, { ...roomAuth, request: "join", ptype: "subscriber", room: this.roomId, feed: feedId, ...(this.privateId != null ? { private_id: this.privateId } : {}) });
@@ -428,8 +661,44 @@ class KazeeCallSession {
       if (data.error_code != null) error.code = Number(data.error_code);
       throw error;
     }
+    if (frame.jsep) {
+      sub.orientationId = orientationExtensionId(frame.jsep.sdp);
+      sub.camera?.setOrientationExtension(sub.orientationId);
+    }
+    // What the feed carries changed: a camera asked for (_askForNewStreams)
+    // or a stream the caller stopped. Janus offers the feed again
+    // ("updated"), answered the same way. The join's own offer ("attached")
+    // arrives twice, as the join's reply and as a handle event; answering
+    // that copy again kept the caller's audio from ever connecting (11 Oct
+    // 3.5.37/3.5.38 calls), so only a new offer counts.
+    if (frame.jsep?.type === "offer" && sub.started && data.videoroom !== "attached" && frame.jsep.sdp !== sub.offerSdp) {
+      sub.offerSdp = frame.jsep.sdp;
+      sub.receiving = receivedMids(data, frame.jsep.sdp);
+      sub.askedMids = null;
+      // A failed re-offer must not cost the call its audio: the feed stays as
+      // it was (only the camera is missed).
+      clog(`Kazee call subscriber renegotiating: feed=${feedId} event=${data.videoroom || "?"}`);
+      try {
+        await sub.pc.setRemoteDescription(frame.jsep);
+        const answer = await sub.pc.createAnswer();
+        await sub.pc.setLocalDescription(answer);
+        await this.janus.message(sub.handle, { request: "start", room: this.roomId }, sub.pc.localDescription);
+        clog(`Kazee call subscriber renegotiated: feed=${feedId}`);
+      } catch (error) {
+        const have = (sub.pc.getTransceivers?.() || []).map((t) => `${t.kind}:${t.mid}:${t.currentDirection || t.direction}`).join(",");
+        console.error(`Kazee call subscriber renegotiation failed: feed=${feedId} ${error.message} offer=${sdpStreams(frame.jsep.sdp)} have=${have || "none"}`);
+        // The connection could not take the new stream (11 Oct 17:44, werift:
+        // "Transceiver with mid=1 not found", camera never seen): join the
+        // feed again, once, so one fresh offer carries audio and camera. The
+        // caller's audio pauses for a moment instead of the camera being lost.
+        if (!sub.rejoined) setImmediate(() => this._rejoinFeed(feedId, sub).catch((rejoinError) => console.error(`Kazee call subscriber rejoin failed: feed=${feedId} ${rejoinError.message}`)));
+      }
+      return;
+    }
     if (frame.jsep && !sub.started) {
       sub.started = true;
+      sub.offerSdp = frame.jsep.sdp;
+      sub.receiving = receivedMids(data, frame.jsep.sdp);
       await sub.pc.setRemoteDescription(frame.jsep);
       this._flushTrickle(sub);
       const answer = await sub.pc.createAnswer();
@@ -439,17 +708,114 @@ class KazeeCallSession {
     }
   }
 
+  // Join a feed again from scratch (a re-offer the connection could not take).
+  async _rejoinFeed(feedId, sub) {
+    if (this.closed || this.subscribers.get(feedId) !== sub) return;
+    clog(`Kazee call subscriber rejoining: feed=${feedId}`);
+    await this._removeSubscriber(feedId);
+    await this._subscribe(feedId, sub.display, sub.metadata);
+    const fresh = this.subscribers.get(feedId);
+    if (fresh) fresh.rejoined = true;
+  }
+
+  // A camera switched on mid-call: Janus 1.4 tells only the room's publishers
+  // (a "publishers" event listing the feed's streams), never a subscriber
+  // that joined the whole feed, so the new or re-enabled video is asked for
+  // with "update" (as the web app does, callMediaTracks.ts). Janus answers
+  // with an "updated" offer (_consumeSubscriberFrame). 11 Oct 17:04: the
+  // caller's camera was on and no video ever reached the bot.
+  // The caller muted, held or came back (AUDIO_OFF_LABELS).
+  _noteAudioState(feedId, sub, streams) {
+    if (!sub || !Array.isArray(streams)) return;
+    const audio = streams.find((stream) => stream?.type === "audio" && typeof stream.description === "string");
+    if (!audio) return;
+    const label = audio.description.trim().toLowerCase();
+    const off = AUDIO_OFF_LABELS.has(label) ? label : null;
+    if ((sub.audioOff || null) === off) return;
+    sub.audioOff = off;
+    const now = Date.now();
+    clog(`Kazee call caller ${off || "unmuted"}: feed=${feedId}`);
+    if (!off) {
+      // Their audio is about to flow again: the silence was theirs, not the
+      // line's, and the quiet clock starts now.
+      if (sub.lastRtpAt) sub.lastRtpAt = now;
+      this._workedAt = now;
+      this._checkIns = 0;
+      return;
+    }
+    if (this._lineDropped && !this._liveFeeds().length) {
+      // The label came after the drop was called: it was a mute. Nothing to
+      // apologise for; what they missed is said again, they are listening.
+      clog(`Kazee call line drop was a ${off}: feed=${feedId}`);
+      this._prepared.delete(this._lineDropped.line);
+      this._lineDropped = null;
+      this._resumeCut();
+    }
+  }
+
+  // Callers whose audio should be arriving: heard from, and not muted.
+  _liveFeeds() {
+    return [...this.subscribers.values()].filter((sub) => sub?.lastRtpAt && !sub.audioOff);
+  }
+
+  async _askForNewStreams(feedId, sub, streams) {
+    if (!sub?.started || !sub.receiving || !Array.isArray(streams)) return;
+    const wanted = streams
+      .filter((stream) => stream?.type === "video" && !stream.disabled && stream.mid != null)
+      .map((stream) => String(stream.mid))
+      .filter((mid) => !sub.receiving.has(mid) && !sub.askedMids?.has(mid));
+    if (!wanted.length) return;
+    sub.askedMids = new Set([...(sub.askedMids || []), ...wanted]);
+    clog(`Kazee call subscriber asking for new streams: feed=${feedId} mids=${wanted.join(",")}`);
+    try {
+      const reply = await this.janus.message(sub.handle, { request: "update", subscribe: wanted.map((mid) => ({ feed: feedId, mid })) });
+      if (reply?.jsep) await this._consumeSubscriberFrame(feedId, reply);
+    } catch (error) {
+      // The caller keeps their audio; only the camera is missed.
+      console.error(`Kazee call subscriber update failed: feed=${feedId} ${error.message}`);
+    }
+  }
+
+  // The caller's camera: stills for the full agent (camera.js). The sender
+  // is asked for a keyframe (PLI) whenever the stills need one.
+  _onFeedVideo(feedId, sub, pc, track) {
+    if (sub.camera || this.closed) return;
+    const receiver = () => pc.getTransceivers?.().find((transceiver) => transceiver.receiver?.tracks?.includes(track))?.receiver;
+    sub.camera = new CameraStills({
+      feedId,
+      requestKeyframe: async () => { if (track.ssrc != null) await receiver()?.sendRtcpPLI(track.ssrc); },
+    });
+    sub.camera.setOrientationExtension(sub.orientationId ?? null);
+    clog(`Kazee call camera track: feed=${feedId}`);
+    track.onReceiveRtp.subscribe((packet) => sub.camera?.push(packet));
+  }
+
+  // The newest still of a caller's camera, or null: { path, ageMs, receiving }.
+  cameraStill() {
+    let best = null;
+    for (const sub of this.subscribers.values()) {
+      const still = sub?.camera?.latest();
+      if (still && (!best || still.ageMs < best.ageMs)) best = still;
+    }
+    return best;
+  }
+
   _resetRecognition(feedId) {
     const sub = this.subscribers.get(feedId);
     if (!sub) return;
-    for (const segment of sub.segments.values()) clearTimeout(segment.timer);
+    for (const [key, segment] of sub.segments) {
+      clearTimeout(segment.timer);
+      this._utteranceDropped(key);
+    }
     sub.segments.clear();
+    this._takeSegmentAudio(sub);
     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.wordsStarted = sub.overSpeech = sub.underSpeech = false;
     sub.vad.reset();
     sub.turnGate?.reset();
     this._stopThinking();
@@ -473,9 +839,25 @@ class KazeeCallSession {
     }
     sub.wordCount += words - prevWords;
     sub.lastWordAt = now;
+    this._heardWords();
+    if (!sub.wordsStarted) {
+      const busy = this.speechBusy();
+      const real = realWords(partial, busy ? this._speaking?.text : "");
+      if (real >= (busy ? INTERRUPT_WORDS : 1)) this._wordsStarted(feedId, sub, real, busy);
+    }
     if (sub.awaitingWordsSince && sub.stt.protocol !== 2) this._commitTurn(feedId, "words-arrived");
   }
 
+  // The caller is talking: real words came through. Only now do we stop
+  // talking and hold the work's answers; a sound alone did neither.
+  _wordsStarted(feedId, sub, words, overSpeech) {
+    sub.wordsStarted = true;
+    if (overSpeech) clog(`Kazee call words over speech: feed=${feedId} words=${words}`);
+    this._bargeIn();
+    this._stopThinking();
+    this.onSpeechStart({ feedId });
+  }
+
   // Interims arrive in bursts whose cadence tracks recogniser health (jig
   // measured 1–20s between new words on a struggling service); a fixed stall
   // gate would cut callers off mid-sentence on a slow day.
@@ -492,8 +874,14 @@ class KazeeCallSession {
     sub.turnGate?.reset();
     if (sub.vad.active) sub.vad.reset();
     this._lastHeard = Date.now();
+    const audio = this._takeSegmentAudio(sub);
     clog(`Kazee call turn commit: feed=${feedId} reason=${reason} words=${sub.wordCount}`);
+    // Started over our speech and never reached the word gate: a "yeah" or
+    // "mm-hmm" while we talk, or a few words of background.
+    const underSpeech = !!sub.overSpeech && !sub.wordsStarted;
+    sub.wordsStarted = sub.overSpeech = false;
     const versioned = sub.stt.protocol === 2 && typeof sub.stt.commitTurn === "function";
+    let early = null;
     if (versioned) {
       if (sub.segments.size >= 4) {
         this.close("speech-backlog").catch(() => {});
@@ -501,11 +889,12 @@ class KazeeCallSession {
       }
       const commit = sub.stt.commitTurn();
       const key = `${commit.streamId}:${commit.segmentId}`;
-      const segment = { noiseCommit: sub.noiseCommit, committedAt: Date.now(), timer: null };
+      const segment = { noiseCommit: sub.noiseCommit, underSpeech, committedAt: Date.now(), timer: null, audio };
       sub.segments.set(key, segment);
       segment.timer = setTimeout(() => {
         if (!sub.segments.delete(key)) return;
         clog(`Kazee call final timeout: feed=${feedId} segment=${key}`);
+        this._utteranceDropped(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.
@@ -519,8 +908,17 @@ class KazeeCallSession {
         clearTimeout(segment.timer);
         sub.segments.delete(key);
         clog(`Kazee call STT commit failed: feed=${feedId} segment=${key}`);
+        this._utteranceDropped(key);
       });
+      // The words heard so far are usually the final's own words, which take
+      // another 0.69 s (median of 273 finals, 11 Oct): the quick voice may
+      // start on them now, and the final confirms or replaces them.
+      const heard = String(sub.lastPartial || "").trim();
+      if (!segment.noiseCommit && countWords(heard) >= MIN_DISPATCH_WORDS && !(underSpeech && this.speechBusy())) {
+        early = { text: heard, meta: { feedId, display: sub.display || "", participants: this.subscribers.size, utteranceId: key } };
+      }
     } else {
+      sub.underSpeech = underSpeech;
       sub.stt.commit().catch((error) => console.error("Kazee call STT commit:", error.message));
     }
     // Recognition must finish before any acknowledgement claims a heard turn.
@@ -535,6 +933,14 @@ class KazeeCallSession {
     sub.wordCount = 0;
     sub.lastWordAt = 0;
     sub.wordGaps = [];
+    if (early) {
+      try { this.onEarlyWords(early.text, early.meta); } catch (error) { console.error("Kazee call early words:", error.message); }
+    }
+  }
+
+  _utteranceDropped(utteranceId) {
+    if (!utteranceId) return;
+    try { this.onUtteranceDropped(utteranceId); } catch (_) {}
   }
 
   _finalFallback(feedId) {
@@ -559,8 +965,11 @@ class KazeeCallSession {
       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 });
+      const level = segmentLevel(segment.audio);
+      clog(`Kazee call final ready: feed=${feedId} segment=${key} wait=${Date.now() - segment.committedAt}ms ` +
+        `audio=${Math.round((segment.audio?.length || 0) / 32)}ms level=${level.rms}dB loud=${level.loud}dB`);
+      if (!String(text || "").trim()) this._keepMiss(key, segment.audio, level);
+      this._dispatchTranscript(feedId, text, { noiseCommit: segment.noiseCommit, underSpeech: segment.underSpeech, utteranceId: key });
       return;
     }
     if (sub?.finalTimer) {
@@ -584,16 +993,28 @@ class KazeeCallSession {
       // occasionally leaks a single stray word into the transcript too.
       if (countWords(trimmed) < MIN_DISPATCH_WORDS) {
         clog(`Kazee call noise turn dropped: feed=${feedId} words=${countWords(trimmed)}`);
+        this._utteranceDropped(options.utteranceId);
         if (!this._speakActive && !this._speakQueue.length) this._stopThinking();
+        this._speechWasNoise(feedId);
         return;
       }
     }
+    const underSpeech = options.underSpeech ?? sub?.underSpeech;
+    if (options.underSpeech === undefined && sub) sub.underSpeech = false;
+    // Said over us and too few real words to stop us, and we are still
+    // talking: not a turn (Pipecat drops these too). Once we are quiet, a
+    // short "yes" is an answer and goes through.
+    if (underSpeech && trimmed && this.speechBusy()) {
+      clog(`Kazee call words under speech dropped: feed=${feedId} words=${countWords(trimmed)}`);
+      this._utteranceDropped(options.utteranceId);
+      return;
+    }
     clog(`Kazee call transcript: feed=${feedId} chars=${trimmed.length}${trimmed.length ? "" : " (noise commit)"}`);
-    if (trimmed) this._startThinking(trimmed);
+    if (trimmed) { this._heardWords(); this._lastHeardText = 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;
+    if (!trimmed) { this._utteranceDropped(options.utteranceId); this._speechWasNoise(feedId); return; }
     this.onTranscript(text, {
       feedId,
       display: sub?.display || "",
@@ -602,14 +1023,26 @@ class KazeeCallSession {
     });
   }
 
+  // Speech start muted the turn being worked on, in case it was a new ask. A
+  // sound the recogniser found no words in (wind, footsteps, a cough) was not:
+  // unless someone is still talking or another segment is pending, the
+  // muted turn gets its voice back.
+  _speechWasNoise(feedId) {
+    if ([...this.subscribers.values()].some(peer => peer?.vad?.active || peer?.turnGate?.pending ||
+        peer?.awaitingWordsSince || peer?.segments?.size)) return;
+    this.onSpeechNoise({ feedId });
+  }
+
   _reportMediaReady() {
     if (this.closed || this._reportedMediaReady || !this._sentRtp || !this._receivedRtp) return;
     this._reportedMediaReady = true;
     this.onMediaReady();
   }
 
-  _writeFrame(frame) {
+  _writeFrame(frame, { hum = false } = {}) {
     if (this.closed || !this.publisher?.track?.writeRtp) return;
+    this._countSent(frame, hum);
+    if (!hum) this._lastSpeechFrameAt = Date.now();
     if (frame.length < WEBRTC_SAMPLES * 2) frame = Buffer.concat([frame, Buffer.alloc(WEBRTC_SAMPLES * 2 - frame.length)]);
     const opus = this.codec.encode(frame);
     const payloadType = this.publisher?.sender?.codec?.payloadType || 111;
@@ -621,20 +1054,37 @@ class KazeeCallSession {
     this._reportMediaReady();
   }
 
+  _countSent(frame, hum) {
+    const sent = this._sent;
+    const now = Date.now();
+    if (sent.lastAt && this.humDb != null) {
+      const gap = now - sent.lastAt;
+      if (gap > sent.longestGapMs) sent.longestGapMs = gap;
+      if (gap >= SENT_GAP_MS) {
+        sent.gaps1s += 1;
+        clog(`Kazee call sent nothing for ${gap}ms (hiss on)`);
+      }
+    }
+    sent.lastAt = now;
+    if (hum) { sent.hum += 1; return; }
+    sent.speech += 1;
+    let peak = 0;
+    for (let i = 0; i + 1 < frame.length && peak < SILENT_FRAME_PEAK; i += 2) peak = Math.max(peak, Math.abs(frame.readInt16LE(i)));
+    if (peak < SILENT_FRAME_PEAK) sent.silentSpeech += 1;
+  }
+
   _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;
+      if (this.closed || this.speaking || this._speakActive || this.callerTalking()) 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)) {
+        if (cue && revision === this._cueRevision && !this.closed && !this._speakActive && !this.callerTalking()) {
           await this.speak(cue);
         }
       } catch (_) { /* A missing cue never delays an answer. */ }
@@ -661,21 +1111,23 @@ class KazeeCallSession {
       sub.firstRtpAt = Date.now();
       clog(`Kazee call first RTP: feed=${feedId}`);
     }
+    this._rtpArrived(feedId, sub);
     let pcm;
-    try { pcm = sub.codec.decode(packet.payload); } catch (_) { return; }
+    try { pcm = sub.codec.decode(packet.payload); } catch (_) { if (sub.heard) sub.heard.decodeErrors += 1; return; }
+    if (sub.heard) noteHeard(sub.heard, rmsDbfs(pcm));
     // Echo guard: raise the effective threshold while the bot speaks; the
     // adaptive floor keeps sampling the un-boosted base so echo never pollutes
     // the noise-floor estimate.
     sub.vad.boostTo = this.speaking ? SPEAKING_THRESHOLD_DB : null;
     const event = sub.vad.push(pcm);
+    if (event?.type === "start" && sub.heard) sub.heard.starts += 1;
     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 });
+        // A sound: listen for words (_onFeedPartial), keep talking.
+        if (this.speechBusy()) sub.overSpeech = true;
         for (const frame of sub.prebuffer.splice(0)) {
           sub.turnGate.audio(frame);
           this._feedAudio(sub, frame);
@@ -699,9 +1151,7 @@ class KazeeCallSession {
         // Caller resumed before any words arrived — same turn continues.
         sub.awaitingWordsSince = 0;
         this._lastHeard = Date.now();
-        this.cancelSpeech();
-        this.onSpeechStart({ feedId });
-        this._stopThinking();
+        if (this.speechBusy()) sub.overSpeech = true;
         return;
       }
       if (Date.now() - sub.awaitingWordsSince >= WORD_WAIT_MAX_MS) {
@@ -718,10 +1168,8 @@ class KazeeCallSession {
     if (event?.type === "start") {
       this._lastHeard = Date.now();
       clog(`Kazee call VAD start: feed=${feedId}`);
-      // Barge-in: the human wins — stop talking and listen.
-      this.cancelSpeech();
-      this.onSpeechStart({ feedId });
-      this._stopThinking();
+      // A sound: listen for words (_onFeedPartial), keep talking.
+      if (this.speechBusy()) sub.overSpeech = true;
       for (const frame of sub.prebuffer.splice(0)) this._feedAudio(sub, frame);
     }
     this._feedAudio(sub, pcm16);
@@ -748,17 +1196,104 @@ class KazeeCallSession {
   // A transient speech-service blip drops frames but must not end a live call;
   // SpeechStream reconnects on the next send.
   _feedAudio(sub, pcm16) {
+    if (sub.segBytes < MAX_SEGMENT_BYTES) {
+      sub.segAudio.push(pcm16);
+      sub.segBytes += pcm16.length;
+    }
     sub.stt.audio(pcm16).catch((error) => console.error("Kazee call STT send:", error.message));
   }
 
-  speak(text) {
+  _takeSegmentAudio(sub) {
+    const audio = sub.segAudio?.length ? Buffer.concat(sub.segAudio) : Buffer.alloc(0);
+    sub.segAudio = [];
+    sub.segBytes = 0;
+    return audio;
+  }
+
+  // A segment the recogniser found no words in: kept for a day when
+  // KAZEE_CALL_KEEP_MISSES is on, so a lost question can be listened to.
+  _keepMiss(key, audio, level) {
+    if (!this.missDir) return;
+    try {
+      const file = keepMiss(this.missDir, `${this.roomId}-${key}-${Date.now()}`, audio);
+      if (file) clog(`Kazee call miss kept: ${path.basename(file)} loud=${level.loud}dB`);
+    } catch (error) {
+      console.error("Kazee call miss keep:", error.message);
+    }
+  }
+
+  // For the quick voice: someone is talking, with words (a sound alone is
+  // not talking), or their turn is being decided; speechBusy: speech is
+  // playing or queued.
+  callerTalking() {
+    return [...this.subscribers.values()].some(sub => sub?.wordsStarted && (sub.vad?.active || sub.turnGate?.pending || sub.awaitingWordsSince));
+  }
+
+  speechBusy() {
+    return !!(this.speaking || this._speakActive || this._speakQueue.length);
+  }
+
+  // resumable: an answer or the greeting, which is said again when the
+  // caller cuts it off by accident (cutSpeech); quick lines are not.
+  speak(text, { resumable = false } = {}) {
     if (this.closed || !String(text || "").trim()) return Promise.resolve(false);
     return new Promise((resolve, reject) => {
-      this._speakQueue.push({ text: String(text), resolve, reject });
+      this._speakQueue.push({ text: String(text), resumable, resolve, reject });
       this._drainSpeech();
     });
   }
 
+  // The caller started talking: the human wins, so stop talking and listen,
+  // but keep the words they did not hear yet (11 Oct: "Are you still there?"
+  // over the start of a 539-character answer threw it away for good).
+  // Words cut off earlier and not said yet stay behind the new ones (11 Oct:
+  // a reply cut while the greeting's rest waited lost the greeting's rest).
+  _bargeIn() {
+    const current = this._speaking;
+    const queued = this._speakQueue.filter((item) => item.resumable).map((item) => item.text);
+    const heardMs = current?.startedAt ? Date.now() - current.startedAt : 0;
+    // Stopped in its last moments, the line was heard: the caller is
+    // answering it (11 Oct 17:43: a 61-character question cut 0.4 s from its
+    // end was asked three times over).
+    const leftMs = current?.startedAt ? (current.text.length / SPOKEN_CHARS_PER_SECOND) * 1000 - heardMs : Infinity;
+    const rest = current?.resumable && leftMs > HEARD_ENOUGH_LEFT_MS ? unheardText(current.text, heardMs) : "";
+    const prior = this.cutSpeech();
+    const text = [rest, ...queued, prior?.text].filter(Boolean).join(" ").trim();
+    if (rest || queued.length) this._cut = { text, fromStart: rest ? rest === current.text : true, at: Date.now() };
+    // Logged: a reply stopped before its first sound was invisible (11 Oct
+    // 17:31, "Ready when you are" never played and nothing said why).
+    if (current || this._speakQueue.length) {
+      const when = !current ? "queued" : current.startedAt ? `after ${heardMs}ms` : "before first audio";
+      clog(`Kazee call barge-in: speech cut ${when} chars=${current?.text.length || 0} queued=${this._speakQueue.length} kept=${rest || queued.length ? text.length : 0}`);
+    }
+    this.cancelSpeech();
+  }
+
+  // A reply that could not be said yet (the caller was talking): kept like
+  // cut-off words, said after a no-words sound or offered to the next turn.
+  // after: it carries on from the words already kept (the rest of an answer
+  // whose start was cut off), so it goes behind them.
+  keepUnsaid(text, { after = false } = {}) {
+    const words = String(text || "").trim();
+    if (!words) return;
+    const prior = this.cutSpeech();
+    const parts = after ? [prior?.text, words] : [words, prior?.text];
+    this._cut = { text: parts.filter(Boolean).join(" "), fromStart: after && prior ? prior.fromStart : true, at: Date.now() };
+  }
+
+  // Words cut off in the last 30 s, still unsaid: { text, fromStart }, or null.
+  // takeCutSpeech also forgets them, so they are said again at most once.
+  cutSpeech() {
+    const cut = this._cut;
+    return cut && Date.now() - cut.at <= CUT_KEEP_MS ? { text: cut.text, fromStart: cut.fromStart } : null;
+  }
+
+  takeCutSpeech() {
+    const cut = this.cutSpeech();
+    this._cut = null;
+    return cut;
+  }
+
   cancelSpeech() {
     this._speakGen += 1;
     this._synthController?.abort();
@@ -771,12 +1306,18 @@ class KazeeCallSession {
     (async () => {
       try {
         while (this._speakQueue.length && !this.closed) {
+          // The caller's line is down: what is queued waits for it.
+          if (this._lineDropped) { await wait(100); continue; }
           const item = this._speakQueue.shift();
           const controller = new AbortController();
           this._synthController = controller;
+          this._speaking = { text: item.text, resumable: item.resumable, startedAt: 0 };
           try { item.resolve(await this._playUtterance(item.text, this._speakGen)); }
           catch (error) { if (controller.signal.aborted) item.resolve(false); else item.reject(error); }
-          finally { if (this._synthController === controller) this._synthController = null; }
+          finally {
+            if (this._synthController === controller) this._synthController = null;
+            this._speaking = null;
+          }
         }
       } finally {
         this._speakActive = false;
@@ -788,6 +1329,7 @@ class KazeeCallSession {
   async _playPcm48(pcm48, gen) {
     this._stopThinking();
     this.speaking = true;
+    if (this._speaking && !this._speaking.startedAt) this._speaking.startedAt = Date.now();
     try {
       // Drift-corrected pacing: a naive wait(20) accumulates encode time and
       // timer slop, audibly stretching long utterances.
@@ -808,13 +1350,24 @@ 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 || Object.values(CUE_PHRASES).includes(text));
+    const cacheable = usingService && (text === this.greeting || text === MAX_DURATION_GOODBYE || text === IDLE_GOODBYE ||
+      text === NO_WORDS_GOODBYE || CHECK_IN_LINES.includes(text) || Object.values(CUE_PHRASES).includes(text));
     const cacheKey = `${ttsVoice.getVoice()}::${text}`;
     const synthStart = Date.now();
     if (cacheable && SYNTH_CACHE.has(cacheKey)) {
       clog(`Kazee call speak: cached chars=${text.length}`);
       return this._playPcm48(SYNTH_CACHE.get(cacheKey), gen);
     }
+    const prepared = this._prepared.get(text);
+    if (prepared) {
+      this._prepared.delete(text);
+      const pcm48 = await prepared.catch(() => null);
+      if (this.closed || gen !== this._speakGen) return false;
+      if (pcm48) {
+        clog(`Kazee call speak: prepared chars=${text.length}`);
+        return this._playPcm48(pcm48, gen);
+      }
+    }
     if (this.synthesizeStream) {
       try {
         return await this._playStreaming(text, gen, { cacheable, cacheKey, synthStart });
@@ -859,6 +1412,7 @@ class KazeeCallSession {
           this._stopThinking();
           this.speaking = true;
           startAt = Date.now();
+          if (this._speaking && !this._speaking.startedAt) this._speaking.startedAt = startAt;
         }
         frameCarry = frameCarry.length ? Buffer.concat([frameCarry, pcm48]) : pcm48;
         let offset = 0;
@@ -882,6 +1436,191 @@ class KazeeCallSession {
     }
   }
 
+  // ── The line ────────────────────────────────────────────────────
+
+  _rtpArrived(feedId, sub) {
+    const now = Date.now();
+    if (sub.lastRtpAt) {
+      const gap = now - sub.lastRtpAt;
+      if (gap > sub.maxRtpGap) sub.maxRtpGap = gap;
+      if (gap >= 400) sub.rtpGaps400 += 1;
+      if (gap >= 1000) {
+        sub.rtpGaps1s += 1;
+        clog(`Kazee call RTP gap: feed=${feedId} ${gap}ms`);
+      }
+    }
+    sub.lastRtpAt = now;
+    sub.rtpPackets += 1;
+    if (this._lineDropped) this._lineBack(feedId, now);
+  }
+
+  // No packets from anyone for dropMs: the line dropped. What I was saying
+  // stops and is kept, what is queued waits, the check-in clock stops, and
+  // the line-back is made now so it plays the moment they return.
+  _dropTick() {
+    if (this.closed || this._ending) return;
+    // A muted caller's silence is theirs (_noteAudioState).
+    const feeds = this._liveFeeds();
+    if (!feeds.length && !this._lineDropped) return;
+    const now = Date.now();
+    if (this._lineDropped) {
+      if (now - this._lineDropped.since < this.dropGiveUpMs) return;
+      clog(`Kazee call line lost: no audio for ${Math.round((now - this._lineDropped.since) / 1000)} s, hanging up`);
+      this.close("connection-lost").catch(() => {});
+      return;
+    }
+    const last = Math.max(...feeds.map((sub) => sub.lastRtpAt));
+    if (now - last < this.dropMs) return;
+    const heard = this._lastHeardWords();
+    const line = heard ? `${LINE_BACK_LEAD} The last thing I heard was: ${heard}.` : LINE_BACK_NOTHING;
+    this._lineDropped = { since: last, line };
+    clog(`Kazee call line dropped: no audio for ${now - last} ms${heard ? `, last heard ${countWords(heard)} words` : ""}`);
+    if (this.speechBusy()) this._bargeIn();
+    this._prepare(line);
+  }
+
+  _lineBack(feedId, now) {
+    const { since, line } = this._lineDropped;
+    this._lineDropped = null;
+    clog(`Kazee call line back: feed=${feedId} after ${now - since} ms`);
+    // The quiet clock starts again from now, not from before the drop.
+    this._workedAt = now;
+    const missed = this._missedWords();
+    // First, ahead of anything that queued while they were gone, with the
+    // words they missed right after; queued together so nothing gets between.
+    const items = [{ text: line }, missed && { text: missed, resumable: true }].filter(Boolean)
+      .map(({ text, resumable = false }) => ({ text, resumable, resolve: () => {}, reject: () => {} }));
+    this._speakQueue.unshift(...items);
+    this._drainSpeech();
+  }
+
+  // "As I was saying, ..." with the words a drop cut off, or "".
+  _missedWords() {
+    const cut = this.takeCutSpeech();
+    return cut ? `${LINE_BACK_RESUME} ${cut.text.replace(/^([A-Z])(?=[a-z])/, (letter) => letter.toLowerCase())}` : "";
+  }
+
+  _resumeCut() {
+    const missed = this._missedWords();
+    if (missed) this._speakQueue.unshift({ text: missed, resumable: true, resolve: () => {}, reject: () => {} });
+    this._drainSpeech();
+  }
+
+  // The last words heard: the sentence they were in the middle of, or else
+  // their last full one; its last few words.
+  _lastHeardWords() {
+    const live = [...this.subscribers.values()].map((sub) => String(sub?.lastPartial || "").trim()).find((text) => countWords(text));
+    const words = String(live || this._lastHeardText || "").trim().replace(/[.!?,;:]+$/, "").split(/\s+/).filter(Boolean);
+    return words.slice(-LINE_BACK_WORDS).join(" ");
+  }
+
+  lastHeardText() {
+    return this._lastHeardText;
+  }
+
+  // Synthesized ahead, played by _playUtterance when the same text is said.
+  _prepare(text) {
+    if (this._prepared.has(text)) return;
+    const pending = Promise.resolve()
+      .then(() => this.synthesize(text))
+      .then((synthesized) => upsampleTo48(synthesized.pcm, synthesized.sampleRate));
+    pending.catch(() => {});
+    this._prepared.set(text, pending);
+  }
+
+  // The hiss: a frame every 20 ms whenever no speech frame went out in the
+  // last 60 ms, from my first words on (before them nothing is sent, as
+  // before, so ringing and media-ready are unchanged).
+  async _humLoop() {
+    const frames = humFrames(this.humDb);
+    let anchor = 0;
+    let sent = 0;
+    let next = 0;
+    while (!this.closed) {
+      const now = Date.now();
+      // Never inside a line: a voice stream that stalls mid-sentence would
+      // get hiss between its words and run the call's clock ahead.
+      if (!this._lastSpeechFrameAt || now - this._lastSpeechFrameAt < HUM_AFTER_SPEECH_MS || this._speaking?.startedAt ||
+          !this.publisher?.track?.writeRtp) {
+        anchor = 0;
+        await softWait(20);
+        continue;
+      }
+      if (!anchor) { anchor = now; sent = 0; }
+      this._writeFrame(frames[next], { hum: true });
+      next = (next + 1) % frames.length;
+      sent += 1;
+      const delay = anchor + sent * 20 - Date.now();
+      if (delay > 0) await softWait(delay);
+      else if (delay < -200) anchor = 0;
+    }
+  }
+
+  _heardWords() {
+    this._lastWordsAt = Date.now();
+    this._checkIns = 0;
+  }
+
+  // Work the caller is waiting on: a call job not yet answered (manager.js
+  // _startJob/_openJobs), or a turn about to be.
+  _working() {
+    if (this._thinkTimer || this._hangUpPending) return true;
+    return (this._jobs || []).some(job => !job.controller?.signal?.aborted && (!job.done || job.pending?.length));
+  }
+
+  // Someone is mid-sound or a segment is still being recognised: not a gap
+  // to speak into, though sound alone never counts as being heard.
+  _soundPending() {
+    return [...this.subscribers.values()].some(sub => sub && (sub.vad?.active || sub.turnGate?.pending ||
+      sub.awaitingWordsSince || sub.segments?.size));
+  }
+
+  async _checkInTick() {
+    // A dropped line is not the caller being quiet (_dropTick).
+    if (this.closed || this._ending || this._checkingIn || this._lineDropped) return;
+    // Only once the caller's audio is arriving: not while ringing.
+    if (![...this.subscribers.values()].some(sub => sub?.firstRtpAt)) return;
+    const now = Date.now();
+    // Muted on purpose: they are listening, not gone.
+    if ([...this.subscribers.values()].every(sub => !sub?.firstRtpAt || sub.audioOff)) { this._workedAt = now; return; }
+    if (this._working()) { this._workedAt = now; return; }
+    if (this.speechBusy() || this._soundPending()) return;
+    if (now - Math.max(this._lastWordsAt, this._lastSpokeAt, this._workedAt) < this.checkInMs) return;
+    this._checkingIn = true;
+    try {
+      if (this._checkIns < CHECK_IN_LINES.length) {
+        const line = CHECK_IN_LINES[this._checkIns];
+        this._checkIns += 1;
+        clog(`Kazee call check-in: ${this._checkIns} of ${CHECK_IN_LINES.length}, no words for ${Math.round((now - this._lastWordsAt) / 1000)} s`);
+        await this.speak(line);
+        return;
+      }
+      await this._noWordsGoodbye();
+    } finally {
+      this._checkingIn = false;
+    }
+  }
+
+  async _noWordsGoodbye() {
+    this._ending = true;
+    const wordsBefore = this._lastWordsAt;
+    clog("Kazee call check-in: no words after the check-ins, saying goodbye");
+    try { await this.speak(NO_WORDS_GOODBYE); } catch (_) {}
+    const heard = () => this._lastWordsAt !== wordsBefore;
+    const graceEnd = Date.now() + this.checkInGraceMs;
+    while (!this.closed && !heard() && Date.now() < graceEnd) await wait(100);
+    // Mid-sound at the deadline: give its words a moment to arrive.
+    const soundEnd = Date.now() + CHECK_IN_SOUND_GRACE_MS;
+    while (!this.closed && !heard() && this._soundPending() && Date.now() < soundEnd) await wait(100);
+    if (this.closed) return;
+    if (heard()) {
+      clog("Kazee call check-in: words in the grace, staying on");
+      this._ending = false;
+      return;
+    }
+    await this.close("no-words");
+  }
+
   async _enforceLimits() {
     if (this.closed || this._ending) return;
     const now = Date.now();
@@ -912,12 +1651,20 @@ class KazeeCallSession {
     const sub = this.subscribers.get(feedId);
     if (!sub) return;
     this.subscribers.delete(feedId);
+    // Measured per call: how far apart the caller's packets really came.
+    if (sub.rtpPackets) clog(`Kazee call RTP: feed=${feedId} packets=${sub.rtpPackets} max-gap=${sub.maxRtpGap}ms gaps>=400ms=${sub.rtpGaps400} gaps>=1s=${sub.rtpGaps1s}`);
+    if (sub.heard?.frames || sub.heard?.decodeErrors) clog(`Kazee call heard: feed=${feedId} ${heardSummary(sub.heard, sub.vad?.thresholdDb)}`);
     this._transportIceExpiry.delete(sub.pc);
     this._armTransportExpiry();
     if (sub.finalTimer) clearTimeout(sub.finalTimer);
-    for (const segment of sub.segments.values()) clearTimeout(segment.timer);
+    for (const [key, segment] of sub.segments) {
+      clearTimeout(segment.timer);
+      this._utteranceDropped(key);
+    }
     sub.segments.clear();
+    this._takeSegmentAudio(sub);
     sub.turnGate?.close();
+    try { sub.camera?.close(); } catch (_) {}
     try { sub.stt.close(); } catch (_) {}
     try { sub.codec.close(); } catch (_) {}
     try { await sub.pc.close(); } catch (_) {}
@@ -933,7 +1680,10 @@ class KazeeCallSession {
     this._transportIceExpiry.clear();
     this._leaseHeartbeat?.close();
     console.log(`Kazee call session closed: room=${this.roomId} reason=${reason}`);
+    const sent = this._sent;
+    if (sent.speech || sent.hum) clog(`Kazee call sent: speech=${sent.speech} silent-speech=${sent.silentSpeech} hiss=${sent.hum} gaps>=1s=${sent.gaps1s} longest-gap=${sent.longestGapMs}ms`);
     if (this._limitTimer) { clearInterval(this._limitTimer); this._limitTimer = null; }
+    if (this._checkInTimer) { clearInterval(this._checkInTimer); this._checkInTimer = null; }
     this._clearPublishTimer();
     this._stopThinking();
     this.cancelSpeech();
@@ -950,4 +1700,5 @@ class KazeeCallSession {
   }
 }
 
-module.exports = { KazeeCallSession };
+module.exports = {
+  unheardText, realWords, KazeeCallSession, newHeard, noteHeard, heardSummary };