@inetafrica/open-claudia 3.1.13 → 3.1.16

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## v3.1.16 — CI-deflake: no live network in unit tests, CI-safe enforcer deadlines
+
+- Identical bot behaviour to v3.1.15 (which never shipped: its pipeline died twice on loaded-runner test flakes — the tag is retired unretagged per release hygiene).
+- `test-telegram-conflict-heal-guard.js` stubbed `_probeTelegramReachable`/`_anyTurnActive`: the wedge-exit assertion used to probe the real api.telegram.org, so a slow/blocked CI egress sent `_heal` down the outage-pause path instead of the exit under test. It also now isolates `OPEN_CLAUDIA_CONFIG_DIR` — the exercised exit path was writing a bogus "polling wedged" `last-exit.json` into the real `~/.open-claudia` on every local test run.
+- `test-provider-enforcer.js` deadlines made CI-safe: the judged-probe service backstop 2000→8000ms (children answer in ms; 2000 was missed by child boot under runner load), the deliberate-timeout probe 2500→5000ms boot headroom.
+
+## v3.1.15 — Voice-note replies speak a conversational summary, not the chat text
+
+- Replying to a voice note used to TTS the full formatted chat answer verbatim — bullets, emoji, pipeline IDs and all ("this isn't human hearable"). On voice-reply turns the provider is now asked to end its reply with a dedicated spoken script in `<voice-script>` markers: the chat message keeps the full text answer (script stripped), and only the script — two to four conversational sentences written for the ear — is synthesized into the voice note.
+- If the provider omits the script, a sanitizing fallback (`speechFallback`) strips code blocks, HTML, URLs, emoji, and list markers, caps the speech at the opening sentences, and closes with "The rest is in the text message." — a verbatim readout can no longer reach TTS on text channels.
+- The Kazee call bridge keeps its existing in-call guidance and streams `voiceScript || finalText`, so stray markers are never spoken there either.
+- New extraction/fallback/wiring assertions in `test-media-speech.js`.
+
+## v3.1.14 — Call bridge production hardening: serialized speech, barge-in, group attribution, limits
+
+- **TTS is serialized through a queue with cancellation.** Concurrent `speak()` calls used to interleave two 20ms-frame RTP loops over the same sequence/timestamp counters — garbled audio whenever the provider emitted more than one message. Utterances now play strictly one at a time; `cancelSpeech()` (generation-based) stops the current utterance mid-frame and resolves everything queued, and `close()` cancels so no pending `speak()` can hang the adapter.
+- **Barge-in + echo gate.** While the bot is speaking, the VAD threshold rises from −38 to −26 dBFS so the caller's device echoing the bot's own TTS can't trigger STT; genuine speech over the gate cancels playback immediately — you can interrupt her mid-answer like a real call.
+- **Group calls get per-feed pipelines and speaker attribution.** Each subscribed feed now has its own Opus decoder (they're stateful — one shared decoder produced garbage on 2+ feeds), its own VAD, and its own STT stream. Transcripts carry `{feedId, display, participants}`; with more than one participant in the room the provider sees `alice@…: text`, so group calls stop reading as one merged anonymous voice. STT send/commit failures now log and drop the frame instead of killing the whole call (the stream self-heals on the next send).
+- **Calls end on their own when they should.** 30-minute duration cap (`KAZEE_CALL_MAX_MS`) and 2-minute idle timeout (`KAZEE_CALL_IDLE_MS`), both announced with a spoken goodbye; if the caller barges in during the idle goodbye the call stays up. A leaked session can no longer hold Janus/STT resources forever.
+- **First syllables reach STT.** A 240ms pre-onset ring buffer flushes into the STT stream when a turn starts, so VAD onset latency stops clipping the start of every utterance.
+- The five existing call tests plus new `test-kazee-call-session.js` (serialization, cancellation, echo gate, barge-in, prebuffer, attribution, idle/max limits, close semantics) are wired into the main `npm test` chain — call regressions now block every release, not just `test:kazee-call` runs.
+
 ## v3.1.13 — Owner-only Kazee calls reach Open Claudia
 
 - Accepts incoming audio calls from the configured Kazee owner only; external, video, malformed, and concurrent calls are rejected before any media session is created.

package/channels/kazee/call/manager.js

@@ -43,7 +43,7 @@ class KazeeCallManager {
     const session = new this.SessionImpl({
       roomId, chatId, callerId, botUserId: this.adapter.botUserId,
       janusUrl: this.janusUrl, iceServers: this.iceServers,
-      onTranscript: (text) => this._transcript(text, payload),
+      onTranscript: (text, meta) => this._transcript(text, payload, meta),
       onEnded: () => { if (this.session === session) this.session = null; },
     });
     this.session = session;
@@ -60,9 +60,12 @@ class KazeeCallManager {
     }
   }
 
-  _transcript(text, incoming) {
+  _transcript(text, incoming, meta = {}) {
     const session = this.session;
     if (!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;
     const callAdapter = Object.create(this.adapter);
     // Provider narration/previews are useful in chat but must never be spoken
     // into a call. Only the settled, guarded final answer reaches send().
@@ -83,10 +86,10 @@ class KazeeCallManager {
       canonicalUserId: canonicalForChannel("kazee", String(incoming.fromUserId)),
       userId: String(incoming.fromUserId),
       type: "text",
-      text,
+      text: attributed,
       messageId: `call-${incoming.roomId}-${Date.now()}`,
       from: { id: String(incoming.fromUserId), name: incoming.fromUserName || "" },
-      raw: { ...incoming, source: "kazee-call", ephemeralAudio: true },
+      raw: { ...incoming, source: "kazee-call", ephemeralAudio: true, speaker: speaker || undefined, feedId: meta.feedId },
     });
   }
 

package/channels/kazee/call/session.js

@@ -7,8 +7,20 @@ const { SpeechStream, synthesizePcm } = require("./speech-client");
 
 const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
+const BASE_THRESHOLD_DB = -38;
+// 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;
+const PREBUFFER_FRAMES = 12; // 240ms of pre-onset audio so first syllables reach STT
+const LIMIT_CHECK_MS = 10_000;
+const DEFAULT_MAX_CALL_MS = 30 * 60_000;
+const DEFAULT_IDLE_MS = 2 * 60_000;
+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.";
+
 class KazeeCallSession {
   constructor({ roomId, chatId, callerId, botUserId, janusUrl, iceServers = [], onTranscript, onEnded,
+    maxCallMs, idleMs, synthesize = synthesizePcm,
     JanusClientImpl = JanusClient, PeerConnectionImpl = RTCPeerConnection, SpeechStreamImpl = SpeechStream } = {}) {
     this.roomId = Number(roomId);
     this.chatId = String(chatId);
@@ -20,13 +32,23 @@ class KazeeCallSession {
     this.iceServers = iceServers;
     this.onTranscript = onTranscript || (() => {});
     this.onEnded = onEnded || (() => {});
+    this.synthesize = synthesize;
+    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;
     this.codec = new OpusAudioCodec();
-    this.vad = new TurnDetector();
-    this.stt = new SpeechStreamImpl({ onTranscript: this.onTranscript });
     this.publisher = null;
     this.publisherHandle = null;
     this.subscribers = new Map();
     this.closed = false;
+    this.speaking = false;
+    this._speakQueue = [];
+    this._speakActive = false;
+    this._speakGen = 0;
+    this._startedAt = 0;
+    this._lastHeard = 0;
+    this._lastSpokeAt = 0;
+    this._limitTimer = null;
+    this._ending = false;
     this.sequence = Math.floor(Math.random() * 65535);
     this.timestamp = Math.floor(Math.random() * 0xffffffff);
     this.ssrc = Math.floor(Math.random() * 0xffffffff);
@@ -40,7 +62,11 @@ class KazeeCallSession {
       request: "join", ptype: "publisher", room: this.roomId, display: `open-claudia:${this.botUserId}`,
     });
     await this._consumePublisherFrame(joined);
-    await this.stt.connect();
+    this._startedAt = Date.now();
+    this._lastHeard = this._startedAt;
+    this._lastSpokeAt = this._startedAt;
+    this._limitTimer = setInterval(() => { this._enforceLimits().catch(() => {}); }, LIMIT_CHECK_MS);
+    if (typeof this._limitTimer.unref === "function") this._limitTimer.unref();
   }
 
   async _onPublisherEvent(frame) {
@@ -52,8 +78,9 @@ class KazeeCallSession {
     const data = frame?.plugindata?.data || {};
     if (data.error) throw new Error(data.error);
     for (const publisher of data.publishers || []) {
-      if (!this.subscribers.has(Number(publisher.id)) && !String(publisher.display || "").startsWith("open-claudia:")) {
-        await this._subscribe(Number(publisher.id));
+      const feedId = Number(publisher.id);
+      if (!this.subscribers.has(feedId) && !String(publisher.display || "").startsWith("open-claudia:")) {
+        await this._subscribe(feedId, publisher.display);
       }
     }
     if (data.videoroom === "joined" && !this.publisher) await this._publish();
@@ -76,17 +103,27 @@ class KazeeCallSession {
     await pc.setRemoteDescription(answer);
   }
 
-  async _subscribe(feedId) {
+  async _subscribe(feedId, display) {
     const handle = await this.janus.attach();
     const pc = new this.PeerConnectionImpl({ iceServers: this.iceServers });
-    const sub = { handle, pc };
+    const sub = {
+      handle,
+      pc,
+      display: String(display || ""),
+      // Opus decoders are stateful, so each feed needs its own.
+      codec: new OpusAudioCodec(),
+      vad: new TurnDetector({ thresholdDb: BASE_THRESHOLD_DB }),
+      stt: new this.SpeechStreamImpl({ onTranscript: (text) => this._onFeedTranscript(feedId, text) }),
+      prebuffer: [],
+    };
     this.subscribers.set(feedId, sub);
     pc.onTrack.subscribe((track) => {
-      if (track.kind === "audio") track.onReceiveRtp.subscribe((packet) => this._onIncomingRtp(packet));
+      if (track.kind === "audio") track.onReceiveRtp.subscribe((packet) => this._onFeedRtp(feedId, packet));
     });
     this.janus.onHandle(handle, (frame) => this._onSubscriberEvent(feedId, frame));
     const attached = await this.janus.message(handle, { request: "join", ptype: "subscriber", room: this.roomId, feed: feedId });
     await this._consumeSubscriberFrame(feedId, attached);
+    await sub.stt.connect().catch((error) => console.error("Kazee call STT connect:", error.message));
   }
 
   async _onSubscriberEvent(feedId, frame) {
@@ -108,36 +145,126 @@ class KazeeCallSession {
     }
   }
 
-  _onIncomingRtp(packet) {
+  _onFeedTranscript(feedId, text) {
+    const sub = this.subscribers.get(feedId);
+    this.onTranscript(text, {
+      feedId,
+      display: sub?.display || "",
+      participants: this.subscribers.size,
+    });
+  }
+
+  _onFeedRtp(feedId, packet) {
     if (this.closed || !packet?.payload?.length) return;
+    const sub = this.subscribers.get(feedId);
+    if (!sub) return;
     let pcm;
-    try { pcm = this.codec.decode(packet.payload); } catch (_) { return; }
-    const event = this.vad.push(pcm);
-    if (this.vad.active || event?.type === "start") this.stt.audio(downsample48To16(pcm)).catch((e) => this.close(`stt:${e.message}`));
-    if (event?.type === "commit") this.stt.commit().catch((e) => this.close(`stt:${e.message}`));
+    try { pcm = sub.codec.decode(packet.payload); } catch (_) { return; }
+    sub.vad.thresholdDb = this.speaking ? SPEAKING_THRESHOLD_DB : BASE_THRESHOLD_DB;
+    const event = sub.vad.push(pcm);
+    const pcm16 = downsample48To16(pcm);
+    if (!sub.vad.active && !event) {
+      sub.prebuffer.push(pcm16);
+      if (sub.prebuffer.length > PREBUFFER_FRAMES) sub.prebuffer.shift();
+      return;
+    }
+    if (event?.type === "start") {
+      this._lastHeard = Date.now();
+      // Barge-in: the human wins — stop talking and listen.
+      if (this.speaking) this.cancelSpeech();
+      for (const frame of sub.prebuffer.splice(0)) this._feedAudio(sub, frame);
+    }
+    this._feedAudio(sub, pcm16);
+    if (event?.type === "commit") {
+      this._lastHeard = Date.now();
+      sub.stt.commit().catch((error) => console.error("Kazee call STT commit:", error.message));
+    }
+  }
+
+  // A transient speech-service blip drops frames but must not end a live call;
+  // SpeechStream reconnects on the next send.
+  _feedAudio(sub, pcm16) {
+    sub.stt.audio(pcm16).catch((error) => console.error("Kazee call STT send:", error.message));
   }
 
-  async speak(text) {
-    if (this.closed || !String(text || "").trim()) return;
-    const synthesized = await synthesizePcm(String(text));
+  speak(text) {
+    if (this.closed || !String(text || "").trim()) return Promise.resolve(false);
+    return new Promise((resolve, reject) => {
+      this._speakQueue.push({ text: String(text), resolve, reject });
+      this._drainSpeech();
+    });
+  }
+
+  cancelSpeech() {
+    this._speakGen += 1;
+    for (const item of this._speakQueue.splice(0)) item.resolve(false);
+  }
+
+  _drainSpeech() {
+    if (this._speakActive) return;
+    this._speakActive = true;
+    (async () => {
+      try {
+        while (this._speakQueue.length && !this.closed) {
+          const item = this._speakQueue.shift();
+          try { item.resolve(await this._playUtterance(item.text, this._speakGen)); }
+          catch (error) { item.reject(error); }
+        }
+      } finally {
+        this._speakActive = false;
+        this.speaking = false;
+      }
+    })();
+  }
+
+  async _playUtterance(text, gen) {
+    const synthesized = await this.synthesize(text);
+    if (this.closed || gen !== this._speakGen) return false;
     const pcm48 = upsampleTo48(synthesized.pcm, synthesized.sampleRate);
-    for (let offset = 0; offset < pcm48.length && !this.closed; offset += WEBRTC_SAMPLES * 2) {
-      let frame = pcm48.subarray(offset, offset + WEBRTC_SAMPLES * 2);
-      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;
-      this.publisher?.track?.writeRtp(new RtpPacket(new RtpHeader({
-        payloadType, sequenceNumber: this.sequence++ & 0xffff, timestamp: this.timestamp >>> 0, ssrc: this.ssrc,
-      }), opus));
-      this.timestamp = (this.timestamp + WEBRTC_SAMPLES) >>> 0;
-      await wait(20);
+    this.speaking = true;
+    try {
+      for (let offset = 0; offset < pcm48.length; offset += WEBRTC_SAMPLES * 2) {
+        if (this.closed || gen !== this._speakGen) return false;
+        let frame = pcm48.subarray(offset, offset + WEBRTC_SAMPLES * 2);
+        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;
+        this.publisher?.track?.writeRtp(new RtpPacket(new RtpHeader({
+          payloadType, sequenceNumber: this.sequence++ & 0xffff, timestamp: this.timestamp >>> 0, ssrc: this.ssrc,
+        }), opus));
+        this.timestamp = (this.timestamp + WEBRTC_SAMPLES) >>> 0;
+        await wait(20);
+      }
+      return true;
+    } finally {
+      this._lastSpokeAt = Date.now();
+    }
+  }
+
+  async _enforceLimits() {
+    if (this.closed || this._ending) return;
+    const now = Date.now();
+    const overMax = now - this._startedAt >= this.maxCallMs;
+    const speechIdle = !this.speaking && !this._speakActive && !this._speakQueue.length;
+    const idle = speechIdle && now - Math.max(this._lastHeard, this._lastSpokeAt) >= this.idleMs;
+    if (!overMax && !idle) return;
+    this._ending = true;
+    const heardBefore = this._lastHeard;
+    try { await this.speak(overMax ? MAX_DURATION_GOODBYE : IDLE_GOODBYE); } catch (_) {}
+    if (!overMax && this._lastHeard > heardBefore && !this.closed) {
+      // The caller barged in during the goodbye — stay on the line.
+      this._ending = false;
+      return;
     }
+    await this.close(overMax ? "max-duration" : "idle-timeout");
   }
 
   async _removeSubscriber(feedId) {
     const sub = this.subscribers.get(feedId);
     if (!sub) return;
     this.subscribers.delete(feedId);
+    try { sub.stt.close(); } catch (_) {}
+    try { sub.codec.close(); } catch (_) {}
     try { await sub.pc.close(); } catch (_) {}
     try { await this.janus.detach(sub.handle); } catch (_) {}
   }
@@ -145,7 +272,8 @@ class KazeeCallSession {
   async close(reason = "ended") {
     if (this.closed) return;
     this.closed = true;
-    this.stt.close();
+    if (this._limitTimer) { clearInterval(this._limitTimer); this._limitTimer = null; }
+    this.cancelSpeech();
     for (const feed of [...this.subscribers.keys()]) await this._removeSubscriber(feed);
     try { await this.publisher?.pc?.close(); } catch (_) {}
     try { await this.janus.detach(this.publisherHandle); } catch (_) {}

package/core/runner.js

@@ -1647,6 +1647,18 @@ async function deliverForegroundResult(result, runContext, state = currentState(
     }
   }
 
+  // The <voice-script> block (if the provider wrote one) is a spoken summary
+  // for the voice note — strip it from the chat text; the guard above already
+  // vetted the full output including the script.
+  const { VOICE_REPLY_MODE } = require("./config");
+  const { shouldReplyWithVoice, extractVoiceScript, speechFallback } = require("./voice-policy");
+  let voiceScript = "";
+  if (result.ok) {
+    const parts = extractVoiceScript(finalText);
+    voiceScript = parts.script;
+    finalText = parts.text || parts.script || finalText;
+  }
+
   const chunks = splitMessage(finalText);
   for (let index = 0; index < chunks.length; index += 1) {
     let sent = await send(chunks[index], telegramHtmlOpts(index === 0 ? { replyTo: runContext.replyToMsgId } : {}));
@@ -1654,25 +1666,26 @@ async function deliverForegroundResult(result, runContext, state = currentState(
     if (!sent.ok) throw new Error(`failed to deliver response chunk ${index + 1}`);
   }
 
-  const { VOICE_REPLY_MODE } = require("./config");
-  const { shouldReplyWithVoice } = require("./voice-policy");
   const shouldSpeak = shouldReplyWithVoice(VOICE_REPLY_MODE, runContext.lastInputWasVoice);
   if (result.ok && shouldSpeak) {
     const { currentTransport } = require("./context");
     if (currentTransport() === "voice") {
-      const sentences = splitSentences(finalText);
+      const sentences = splitSentences(voiceScript || finalText);
       let spoke = false;
       for (const sentence of sentences) {
         const clip = await synthSentenceMp3(sentence);
         if (clip) { spoke = true; await sendVoice(clip); }
       }
       if (!spoke) {
-        const voicePath = await textToVoice(finalText);
+        const voicePath = await textToVoice(voiceScript || finalText);
         if (voicePath) await sendVoice(voicePath);
       }
       await sendVoiceEnd();
     } else {
-      const voicePath = await textToVoice(finalText);
+      // Never TTS the formatted chat text verbatim: use the provider's spoken
+      // script, else a sanitized short fallback.
+      const spoken = voiceScript || speechFallback(finalText);
+      const voicePath = spoken ? await textToVoice(spoken) : null;
       if (voicePath) await sendVoice(voicePath);
     }
   }

package/core/system-prompt.js

@@ -995,10 +995,29 @@ const VOICE_REPLY_GUIDANCE = [
   "- If the answer genuinely needs code or exact detail, say so briefly and offer to send it as text rather than reading it aloud.",
 ].join("\n");
 
+// Text-channel voice turns (a Telegram/Kazee voice note): the chat reply stays
+// a normal full text answer, but a voice note is ALSO sent back. Asking for a
+// dedicated spoken script — stripped from the text by the runner — is what
+// keeps that voice note conversational instead of a verbatim TTS of the
+// formatted chat text.
+const VOICE_NOTE_GUIDANCE = [
+  "",
+  "",
+  "## Voice note reply",
+  "The user sent this message as a voice note, and a spoken voice note will be sent back alongside your text reply. Do both:",
+  "- Write your normal text reply as usual — full detail and formatting are fine; it is delivered as text.",
+  "- End the reply with a spoken script between <voice-script> and </voice-script> markers. That block is stripped from the text message and only synthesized to audio.",
+  "Script rules: two to four short sentences a person would naturally SAY — summarise the essence conversationally, do not re-read the text reply. No formatting, no emoji, no lists. Never speak code, IDs, file paths, URLs, or command syntax — describe them in plain words or say the details are in the text message.",
+].join("\n");
+
 function voiceReplyGuidance(opts = {}) {
   try {
     const { currentTransport } = require("./context");
-    if (currentTransport() === "voice" && promptState(opts).lastInputWasVoice) return VOICE_REPLY_GUIDANCE;
+    const state = promptState(opts);
+    if (currentTransport() === "voice") return state.lastInputWasVoice ? VOICE_REPLY_GUIDANCE : "";
+    const { VOICE_REPLY_MODE } = require("./config");
+    const { shouldReplyWithVoice } = require("./voice-policy");
+    if (shouldReplyWithVoice(VOICE_REPLY_MODE, state.lastInputWasVoice)) return VOICE_NOTE_GUIDANCE;
   } catch (e) {}
   return "";
 }

package/core/voice-policy.js

@@ -4,4 +4,49 @@ function shouldReplyWithVoice(mode, lastInputWasVoice) {
   return mode === "always" || (mode === "on-voice-input" && !!lastInputWasVoice);
 }
 
-module.exports = { shouldReplyWithVoice };
+// On voice-reply turns the provider is asked (system-prompt voice-note
+// guidance) to end its reply with a spoken script between these markers. The
+// block is stripped from the chat text and ONLY synthesized — chat keeps the
+// full formatted answer while the voice note carries an ear-friendly summary
+// instead of a verbatim TTS readout of bullets, emoji, and IDs.
+const VOICE_SCRIPT_RE = /<voice-script>([\s\S]*?)(?:<\/voice-script>|$)/gi;
+
+function extractVoiceScript(text) {
+  const raw = String(text || "");
+  const scripts = [];
+  const stripped = raw.replace(VOICE_SCRIPT_RE, (_match, body) => {
+    const clean = String(body || "").trim();
+    if (clean) scripts.push(clean);
+    return "";
+  });
+  return { text: stripped.trim(), script: scripts.join(" ").trim() };
+}
+
+// Last-resort shaping when the provider supplied no <voice-script>: strip
+// everything that reads badly aloud and cap to the opening sentences, so a
+// missed script degrades to a short spoken intro rather than a verbatim dump
+// of formatted text into TTS.
+const FALLBACK_MAX_CHARS = 400;
+
+function speechFallback(text) {
+  const plain = String(text || "")
+    .replace(/```[\s\S]*?```/g, " ")
+    .replace(/<[^>\n]{0,120}>/g, " ")
+    .replace(/https?:\/\/\S+/gi, " ")
+    .replace(/[\u{1F000}-\u{1FAFF}\u{2600}-\u{27BF}\u{2B00}-\u{2BFF}\u{FE0F}\u{200D}]/gu, "")
+    .replace(/^\s*[-*•▸►]+\s+/gm, "")
+    .replace(/[*_`#|]+/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+  if (plain.length <= FALLBACK_MAX_CHARS) return plain;
+  const sentences = plain.match(/[^.!?]+[.!?]+(?:\s+|$)/g) || [];
+  let out = "";
+  for (const sentence of sentences) {
+    if (out && out.length + sentence.length > FALLBACK_MAX_CHARS) break;
+    out += sentence;
+  }
+  out = out.trim() || plain.slice(0, FALLBACK_MAX_CHARS).trim();
+  return `${out} The rest is in the text message.`;
+}
+
+module.exports = { shouldReplyWithVoice, extractVoiceScript, speechFallback };

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "3.1.13",
+  "version": "3.1.16",
   "description": "An always-on, provider-agnostic coding-agent harness for Claude Code and OpenAI Codex via chat",
   "main": "bot.js",
   "bin": {
     "open-claudia": "./bin/cli.js"
   },
   "scripts": {
-    "test:kazee-call": "node test-kazee-call-audio.js && node test-kazee-call-janus.js && node test-kazee-call-webrtc.js && node test-kazee-call-speech.js && node test-kazee-call-manager.js",
+    "test:kazee-call": "node test-kazee-call-audio.js && node test-kazee-call-janus.js && node test-kazee-call-webrtc.js && node test-kazee-call-speech.js && node test-kazee-call-manager.js && node test-kazee-call-session.js",
     "setup": "node setup.js",
     "start": "node bot.js",
-    "pretest": "node test-provider-fixture.js && node test-provider-core-prompt.js && node test-turn-observer.js && node test-provider-prompt-parity.js && node test-provider-env-isolation.js && node test-provider-resume-parity.js && node test-provider-bootstrap.js && node test-provider-registry.js && node test-provider-stream-decoder.js && node test-provider-events.js && node test-provider-claude.js && node test-provider-codex.js && node test-provider-runner.js && node test-provider-refusal-recovery.js && node test-provider-run-lifecycle.js && node test-provider-gateway.js && node test-provider-side-chat.js && node test-single-runtime.js && node test-provider-migration-backup.js && node test-provider-state-migration.js && node test-provider-session-history.js && node test-provider-session-commands.js && node test-provider-compaction.js && node test-provider-scheduler.js && node test-credential-capture.js && node test-cursor-removal.js && node test-utility-provider-policy.js && node test-provider-subagent.js && node test-provider-recall.js && node test-provider-pack-review.js && node test-memory-mutation-queue.js && node test-provider-dream.js && node test-provider-enforcer.js && node test-provider-tool-hooks.js && node test-provider-boot-matrix.js && node test-provider-capabilities.js && node test-provider-language.js && node test-provider-coupling-audit.js && node test-provider-parity-e2e.js && node test-kazee-channel-health.js && node test-kazee-media-caption.js && node test-prompt-budget.js && node test-agency-ledger.js && node test-agency-deliberate.js && node test-guardrail.js && node test-spaces-comment-content.js && node test-boot-health.js && node test-lexical-floor.js && node test-safe-mode.js && node test-logout.js",
+    "pretest": "node test-provider-fixture.js && node test-provider-core-prompt.js && node test-turn-observer.js && node test-provider-prompt-parity.js && node test-provider-env-isolation.js && node test-provider-resume-parity.js && node test-provider-bootstrap.js && node test-provider-registry.js && node test-provider-stream-decoder.js && node test-provider-events.js && node test-provider-claude.js && node test-provider-codex.js && node test-provider-runner.js && node test-provider-refusal-recovery.js && node test-provider-run-lifecycle.js && node test-provider-gateway.js && node test-provider-side-chat.js && node test-single-runtime.js && node test-provider-migration-backup.js && node test-provider-state-migration.js && node test-provider-session-history.js && node test-provider-session-commands.js && node test-provider-compaction.js && node test-provider-scheduler.js && node test-credential-capture.js && node test-cursor-removal.js && node test-utility-provider-policy.js && node test-provider-subagent.js && node test-provider-recall.js && node test-provider-pack-review.js && node test-memory-mutation-queue.js && node test-provider-dream.js && node test-provider-enforcer.js && node test-provider-tool-hooks.js && node test-provider-boot-matrix.js && node test-provider-capabilities.js && node test-provider-language.js && node test-provider-coupling-audit.js && node test-provider-parity-e2e.js && node test-kazee-channel-health.js && node test-kazee-media-caption.js && node test-prompt-budget.js && node test-agency-ledger.js && node test-agency-deliberate.js && node test-guardrail.js && node test-spaces-comment-content.js && node test-boot-health.js && node test-lexical-floor.js && node test-safe-mode.js && node test-logout.js && node test-kazee-call-audio.js && node test-kazee-call-janus.js && node test-kazee-call-webrtc.js && node test-kazee-call-speech.js && node test-kazee-call-manager.js && node test-kazee-call-session.js",
     "test": "OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node -e \"require('./vault'); console.log('OK')\" && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-runner-watchdog-static.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-usage-accounting.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-recall-engine.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-recall-graph.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-recall-discoverer.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-recall-query.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-walker-score.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-score-gate.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-cokept-warming.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-project-transcripts-smoke.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-abilities.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-ability-extraction.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-ability-couse.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-ability-transfer.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-ability-tiers.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-ability-merge-guard.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-learning-e2e.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-pack-nesting.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-pack-search.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-extractive-injection.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-journal-dedupe.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-read-signal.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-tools.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-tool-graph.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-tool-guard.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-tooling-mode.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-tool-manifest.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-recall-evolution.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-approval-async.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-unified-identity.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-queue-routing.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-persona-packs.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-speaker-persona.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-persona-pipeline.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-recall-relationship-gate.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-relationship.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-enforcer.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-identity-prune.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-kazee-message-id.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-delivery-contract.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-run-lock.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-web-sessions.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-telegram-poll-recovery.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-telegram-409-grace.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-telegram-conflict-heal-guard.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-single-instance.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-streaming-split.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-spaces-autoenable.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-say-loopback.js"
   },
   "files": [
@@ -72,6 +72,12 @@
     "test-identity-prune.js",
     "test-kazee-message-id.js",
     "test-kazee-channel-health.js",
+    "test-kazee-call-audio.js",
+    "test-kazee-call-janus.js",
+    "test-kazee-call-webrtc.js",
+    "test-kazee-call-speech.js",
+    "test-kazee-call-manager.js",
+    "test-kazee-call-session.js",
     "test-prompt-budget.js",
     "test-agency-ledger.js",
     "test-agency-deliberate.js",

package/test-kazee-call-audio.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+"use strict";
+
+const assert = require("assert");
+const {
+  WEBRTC_SAMPLES,
+  OpusAudioCodec,
+  TurnDetector,
+  downsample48To16,
+  rmsDbfs,
+  upsampleTo48,
+} = require("./channels/kazee/call/audio");
+
+function tone({ rate = 48000, hz = 440, samples = WEBRTC_SAMPLES, amplitude = 12000 } = {}) {
+  const out = Buffer.alloc(samples * 2);
+  const view = new Int16Array(out.buffer, out.byteOffset, samples);
+  for (let i = 0; i < samples; i += 1) view[i] = Math.round(Math.sin(2 * Math.PI * hz * i / rate) * amplitude);
+  return out;
+}
+
+const codec = new OpusAudioCodec();
+const source = tone();
+const packet = codec.encode(source);
+const decoded = codec.decode(packet);
+assert.strictEqual(decoded.length, source.length, "Opus round trip preserves the 20ms frame size");
+assert(rmsDbfs(decoded) > -20, "decoded tone has useful signal energy");
+codec.close();
+
+const pcm16 = downsample48To16(source);
+assert.strictEqual(pcm16.length, 320 * 2, "48k→16k produces 320 samples for a 20ms frame");
+const pcm48 = upsampleTo48(pcm16, 16000);
+assert.strictEqual(pcm48.length, source.length, "16k→48k restores the WebRTC frame length");
+
+const detector = new TurnDetector({ thresholdDb: -35, onsetFrames: 2, silenceMs: 60 });
+const silence = Buffer.alloc(source.length);
+assert.strictEqual(detector.push(silence), null);
+assert.strictEqual(detector.push(source), null);
+assert.deepStrictEqual(detector.push(source), { type: "start" });
+assert.strictEqual(detector.push(silence), null);
+assert.strictEqual(detector.push(silence), null);
+assert.deepStrictEqual(detector.push(silence), { type: "commit", reason: "silence" });
+
+console.log("kazee call audio: ok");

package/test-kazee-call-janus.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+"use strict";
+
+const assert = require("assert");
+const { WebSocketServer } = require("ws");
+const { JanusClient } = require("./channels/kazee/call/janus-client");
+
+async function main() {
+  const server = new WebSocketServer({ port: 0, handleProtocols: (protocols) => protocols.has("janus-protocol") ? "janus-protocol" : false });
+  await new Promise((resolve) => server.once("listening", resolve));
+  const port = server.address().port;
+  const seen = [];
+
+  server.on("connection", (socket) => socket.on("message", (raw) => {
+    const frame = JSON.parse(raw.toString());
+    seen.push(frame.janus);
+    if (frame.janus === "create") {
+      socket.send(JSON.stringify({ janus: "success", transaction: frame.transaction, data: { id: 42 } }));
+    } else if (frame.janus === "attach") {
+      socket.send(JSON.stringify({ janus: "success", transaction: frame.transaction, session_id: 42, data: { id: 84 } }));
+    } else if (frame.janus === "message") {
+      socket.send(JSON.stringify({ janus: "ack", transaction: frame.transaction, session_id: 42 }));
+      setTimeout(() => socket.send(JSON.stringify({
+        janus: "event",
+        transaction: frame.transaction,
+        session_id: 42,
+        sender: 84,
+        plugindata: { plugin: "janus.plugin.videoroom", data: { videoroom: "joined", room: 7 } },
+      })), 5);
+    } else if (frame.janus === "destroy") {
+      socket.send(JSON.stringify({ janus: "success", transaction: frame.transaction, session_id: 42 }));
+    }
+  }));
+
+  const client = new JanusClient({ url: `ws://127.0.0.1:${port}`, keepaliveMs: 60000 });
+  await client.connect();
+  assert.strictEqual(client.sessionId, 42);
+  const handle = await client.attach();
+  assert.strictEqual(handle, 84);
+  let handleEvent = null;
+  client.onHandle(handle, (event) => { handleEvent = event; });
+  const joined = await client.message(handle, { request: "join", ptype: "publisher", room: 7 });
+  assert.strictEqual(joined.plugindata.data.videoroom, "joined", "ack is ignored until the plugin event arrives");
+  assert.strictEqual(handleEvent?.sender, 84, "plugin event is also delivered to the handle listener");
+  await client.close();
+  await new Promise((resolve) => server.close(resolve));
+  assert.deepStrictEqual(seen.slice(0, 4), ["create", "attach", "message", "destroy"]);
+  console.log("kazee call Janus control plane: ok");
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});

package/test-kazee-call-manager.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+"use strict";
+const assert = require("assert");
+const { KazeeCallManager } = require("./channels/kazee/call/manager");
+class FakeSession {
+  static instances = [];
+  constructor(options) { this.options = options; this.roomId = options.roomId; FakeSession.instances.push(this); }
+  async start() { this.started = true; }
+  async speak(text) { this.spoken = text; }
+  async close(reason) { this.closed = reason; this.options.onEnded(reason); }
+}
+function fixture() {
+  const events = [], inbound = [];
+  const socket = { on() {}, emit(name, payload) { events.push({ name, payload }); } };
+  const adapter = { ownerUserId: "owner-1", botUserId: "bot-1", _socket: socket, _emit(name, payload) { inbound.push({ name, payload }); } };
+  return { events, inbound, manager: new KazeeCallManager({ adapter, SessionImpl: FakeSession }) };
+}
+(async () => {
+  let f = fixture();
+  await f.manager.incoming({ fromUserId: "stranger", chatId: "chat", roomId: 10, callType: "audio" });
+  assert.strictEqual(f.events[0].payload.reason, "not_allowed");
+  assert.strictEqual(FakeSession.instances.length, 0);
+  f = fixture();
+  await f.manager.incoming({ fromUserId: "owner-1", chatId: "chat", roomId: 11, callType: "video" });
+  assert.strictEqual(f.events[0].payload.reason, "unsupported_media");
+  f = fixture();
+  await f.manager.incoming({ fromUserId: "owner-1", fromUserName: "Owner", chatId: "chat", roomId: 12, callType: "audio" });
+  assert.strictEqual(f.events[0].name, "call:accept");
+  f.manager.session.options.onTranscript("What is on my agenda?");
+  assert.strictEqual(f.inbound[0].payload.raw.ephemeralAudio, true);
+  await f.inbound[0].payload.adapter.send("chat", "Your agenda is clear.");
+  assert.strictEqual(f.manager.session.spoken, "Your agenda is clear.");
+  await f.manager.ended({ roomId: 12 });
+  assert.strictEqual(f.manager.session, null);
+  console.log("kazee call manager: ok");
+})().catch((error) => { console.error(error); process.exitCode = 1; });

package/test-kazee-call-session.js

@@ -0,0 +1,231 @@
+#!/usr/bin/env node
+"use strict";
+
+const assert = require("assert");
+const { KazeeCallSession } = require("./channels/kazee/call/session");
+const { KazeeCallManager } = require("./channels/kazee/call/manager");
+const { OpusAudioCodec, WEBRTC_SAMPLES } = require("./channels/kazee/call/audio");
+
+const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+class FakeJanus {
+  constructor() { this.handles = 0; }
+  async connect() {}
+  async attach() { this.handles += 1; return this.handles; }
+  onHandle() {}
+  async message() { return {}; }
+  async detach() {}
+  async close() {}
+}
+
+class FakePC {
+  constructor() { this.onTrack = { subscribe: () => {} }; }
+  addTrack() { return { codec: { payloadType: 111 } }; }
+  async createOffer() { return {}; }
+  async setLocalDescription() {}
+  async createAnswer() { return {}; }
+  async setRemoteDescription() {}
+  async close() {}
+}
+
+class FakeSpeechStream {
+  constructor({ onTranscript } = {}) {
+    this.onTranscript = onTranscript;
+    this.audioFrames = [];
+    this.commits = 0;
+    this.closedStream = false;
+  }
+  async connect() {}
+  async audio(buffer) { this.audioFrames.push(buffer); }
+  async commit() { this.commits += 1; }
+  close() { this.closedStream = true; }
+}
+
+function makeSession({ synthesize, maxCallMs, idleMs } = {}) {
+  const ended = [];
+  const transcripts = [];
+  const session = new KazeeCallSession({
+    roomId: 7, chatId: "chat", callerId: "owner", botUserId: "bot", janusUrl: "ws://test",
+    maxCallMs, idleMs,
+    synthesize: synthesize || (async () => ({ pcm: Buffer.alloc(WEBRTC_SAMPLES * 2 * 2), sampleRate: 48000 })),
+    onTranscript: (text, meta) => transcripts.push({ text, meta }),
+    onEnded: (reason) => ended.push(reason),
+    JanusClientImpl: FakeJanus, PeerConnectionImpl: FakePC, SpeechStreamImpl: FakeSpeechStream,
+  });
+  return { session, ended, transcripts };
+}
+
+function toneOpus(codec, amplitude) {
+  const pcm = Buffer.alloc(WEBRTC_SAMPLES * 2);
+  const view = new Int16Array(pcm.buffer, pcm.byteOffset, WEBRTC_SAMPLES);
+  for (let i = 0; i < view.length; i += 1) view[i] = Math.round(Math.sin(2 * Math.PI * 440 * i / 48000) * amplitude);
+  return codec.encode(pcm);
+}
+
+async function testSpeakSerialization() {
+  const writes = [];
+  const synthCalls = [];
+  let current = null;
+  const { session } = makeSession({
+    synthesize: async (text) => { synthCalls.push(text); current = text; return { pcm: Buffer.alloc(WEBRTC_SAMPLES * 2 * 3), sampleRate: 48000 }; },
+  });
+  session.publisher = { track: { writeRtp: () => writes.push(current) }, sender: { codec: { payloadType: 111 } } };
+  const [first, second] = await Promise.all([session.speak("one"), session.speak("two")]);
+  assert.strictEqual(first, true);
+  assert.strictEqual(second, true);
+  assert.deepStrictEqual(synthCalls, ["one", "two"], "synthesis is sequential");
+  assert.deepStrictEqual(writes, ["one", "one", "one", "two", "two", "two"], "utterances never interleave on the RTP stream");
+  await session.close();
+}
+
+async function testSpeakCancellation() {
+  let frames = 0;
+  const synthCalls = [];
+  const { session } = makeSession({
+    synthesize: async (text) => { synthCalls.push(text); return { pcm: Buffer.alloc(WEBRTC_SAMPLES * 2 * 50), sampleRate: 48000 }; },
+  });
+  session.publisher = { track: { writeRtp: () => { frames += 1; } }, sender: { codec: { payloadType: 111 } } };
+  const playing = session.speak("long");
+  const queued = session.speak("queued");
+  await wait(80);
+  session.cancelSpeech();
+  assert.strictEqual(await playing, false, "current utterance reports cancelled");
+  assert.strictEqual(await queued, false, "queued utterance cancelled");
+  assert(frames < 20, `playback stopped early (${frames} frames)`);
+  assert.deepStrictEqual(synthCalls, ["long"], "queued text never synthesized after cancel");
+  assert.strictEqual(session.speaking, false);
+  await session.close();
+}
+
+async function testEchoGateAndBargeIn() {
+  const { session } = makeSession({
+    synthesize: async () => ({ pcm: Buffer.alloc(WEBRTC_SAMPLES * 2 * 100), sampleRate: 48000 }),
+  });
+  await session._subscribe(101, "sumeet@kazee");
+  const sub = session.subscribers.get(101);
+  const gen = new OpusAudioCodec();
+  session.publisher = { track: { writeRtp: () => {} }, sender: { codec: { payloadType: 111 } } };
+  const playing = session.speak("long answer");
+  await wait(30);
+  assert.strictEqual(session.speaking, true);
+  for (let i = 0; i < 6; i += 1) session._onFeedRtp(101, { payload: toneOpus(gen, 1500) }); // ~-30dB: echo territory
+  assert.strictEqual(session.speaking, true, "echo-level audio does not interrupt TTS");
+  assert.strictEqual(sub.stt.audioFrames.length, 0, "echo-level audio is not streamed to STT");
+  for (let i = 0; i < 3; i += 1) session._onFeedRtp(101, { payload: toneOpus(gen, 12000) }); // ~-12dB: real speech
+  assert.strictEqual(await playing, false, "barge-in cancels TTS");
+  assert(sub.stt.audioFrames.length >= 3, "barge-in speech reaches STT");
+  gen.close();
+  await session.close();
+}
+
+async function testPrebufferAndCommit() {
+  const { session } = makeSession({});
+  await session._subscribe(101, "caller");
+  const sub = session.subscribers.get(101);
+  const gen = new OpusAudioCodec();
+  for (let i = 0; i < 5; i += 1) session._onFeedRtp(101, { payload: toneOpus(gen, 30) }); // near-silence
+  assert.strictEqual(sub.stt.audioFrames.length, 0, "silence stays out of STT");
+  for (let i = 0; i < 3; i += 1) session._onFeedRtp(101, { payload: toneOpus(gen, 12000) });
+  assert.strictEqual(sub.stt.audioFrames.length, 8, "onset flushes the prebuffer (5 quiet + 2 onset + current)");
+  for (let i = 0; i < 36; i += 1) session._onFeedRtp(101, { payload: toneOpus(gen, 30) });
+  assert.strictEqual(sub.stt.commits, 1, "turn commits after sustained silence");
+  gen.close();
+  await session.close();
+}
+
+async function testTranscriptAttribution() {
+  const { session, transcripts } = makeSession({});
+  await session._subscribe(101, "alice@kazee");
+  await session._subscribe(102, "bob@kazee");
+  session.subscribers.get(101).stt.onTranscript("hello there");
+  assert.deepStrictEqual(transcripts[0], {
+    text: "hello there",
+    meta: { feedId: 101, display: "alice@kazee", participants: 2 },
+  });
+  await session.close();
+
+  class FakeSession {
+    constructor(options) { this.options = options; this.roomId = options.roomId; }
+    async start() {}
+    async speak() {}
+    async close(reason) { this.options.onEnded(reason); }
+  }
+  const inbound = [];
+  const adapter = { ownerUserId: "owner-1", botUserId: "bot-1", _socket: { on() {}, emit() {} }, _emit: (name, payload) => inbound.push(payload) };
+  const manager = new KazeeCallManager({ adapter, SessionImpl: FakeSession });
+  await manager.incoming({ fromUserId: "owner-1", chatId: "c", roomId: 5, callType: "audio" });
+  manager.session.options.onTranscript("hi", { feedId: 1, display: "alice@kazee", participants: 2 });
+  assert.strictEqual(inbound[0].text, "alice@kazee: hi", "group transcripts are speaker-prefixed");
+  assert.strictEqual(inbound[0].raw.speaker, "alice@kazee");
+  manager.session.options.onTranscript("solo", { feedId: 1, display: "alice@kazee", participants: 1 });
+  assert.strictEqual(inbound[1].text, "solo", "1:1 transcripts stay unprefixed");
+  await manager.stop();
+}
+
+async function testIdleTimeout() {
+  const goodbyes = [];
+  const { session, ended } = makeSession({
+    idleMs: 50, maxCallMs: 60_000,
+    synthesize: async (text) => { goodbyes.push(text); return { pcm: Buffer.alloc(WEBRTC_SAMPLES * 2), sampleRate: 48000 }; },
+  });
+  session._startedAt = Date.now();
+  session._lastHeard = Date.now() - 1000;
+  session._lastSpokeAt = Date.now() - 1000;
+  await session._enforceLimits();
+  assert.strictEqual(ended[0], "idle-timeout");
+  assert.strictEqual(goodbyes.length, 1, "idle hangup says goodbye first");
+  assert(goodbyes[0].toLowerCase().includes("hang up"));
+}
+
+async function testIdleBargeInKeepsCall() {
+  let sess = null;
+  const { session, ended } = makeSession({
+    idleMs: 50, maxCallMs: 60_000,
+    synthesize: async () => { sess._lastHeard = Date.now(); return { pcm: Buffer.alloc(WEBRTC_SAMPLES * 2), sampleRate: 48000 }; },
+  });
+  sess = session;
+  session._startedAt = Date.now();
+  session._lastHeard = Date.now() - 1000;
+  session._lastSpokeAt = Date.now() - 1000;
+  await session._enforceLimits();
+  assert.strictEqual(ended.length, 0, "call stays up when the caller speaks during the goodbye");
+  assert.strictEqual(session._ending, false);
+  await session.close();
+}
+
+async function testMaxDuration() {
+  const { session, ended } = makeSession({ idleMs: 60_000, maxCallMs: 50 });
+  session._startedAt = Date.now() - 1000;
+  session._lastHeard = Date.now();
+  session._lastSpokeAt = Date.now();
+  await session._enforceLimits();
+  assert.strictEqual(ended[0], "max-duration", "cap closes the call even mid-conversation");
+}
+
+async function testCloseResolvesSpeech() {
+  const { session } = makeSession({
+    synthesize: async () => ({ pcm: Buffer.alloc(WEBRTC_SAMPLES * 2 * 100), sampleRate: 48000 }),
+  });
+  await session._subscribe(101, "x");
+  const sub = session.subscribers.get(101);
+  const playing = session.speak("very long");
+  await wait(40);
+  await session.close("ended");
+  assert.strictEqual(await playing, false, "in-flight speak resolves on close");
+  assert.strictEqual(sub.stt.closedStream, true, "per-feed STT closed with the call");
+  assert.strictEqual(session.subscribers.size, 0);
+  assert.strictEqual(await session.speak("after"), false, "speak after close is a no-op");
+}
+
+(async () => {
+  await testSpeakSerialization();
+  await testSpeakCancellation();
+  await testEchoGateAndBargeIn();
+  await testPrebufferAndCommit();
+  await testTranscriptAttribution();
+  await testIdleTimeout();
+  await testIdleBargeInKeepsCall();
+  await testMaxDuration();
+  await testCloseResolvesSpeech();
+  console.log("kazee call session: ok");
+})().catch((error) => { console.error(error); process.exitCode = 1; });

package/test-kazee-call-speech.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+"use strict";
+const assert = require("assert");
+const { EventEmitter } = require("events");
+const { SpeechStream, synthesizePcm } = require("./channels/kazee/call/speech-client");
+class FakeWebSocket extends EventEmitter {
+  static OPEN = 1;
+  constructor(url, options) { super(); this.url = url; this.options = options; this.readyState = 1; this.sent = []; queueMicrotask(() => this.emit("open")); }
+  send(value) { this.sent.push(value); }
+  close() { this.readyState = 3; this.emit("close"); }
+}
+(async () => {
+  let transcript;
+  const stream = new SpeechStream({ baseUrl: "https://speech.example", token: "secret", WebSocketImpl: FakeWebSocket, onTranscript: (t) => { transcript = t; } });
+  await stream.connect();
+  assert.strictEqual(stream.socket.url, "wss://speech.example/v1/audio/transcriptions/stream");
+  assert.deepStrictEqual(JSON.parse(stream.socket.sent[0]), { sample_rate: 16000, language: "en" });
+  await stream.audio(Buffer.from([1, 2]));
+  await stream.commit();
+  assert(Buffer.isBuffer(stream.socket.sent[1]));
+  stream.socket.emit("message", Buffer.from(JSON.stringify({ type: "final", text: "hello" })));
+  assert.strictEqual(transcript, "hello");
+  let request;
+  const pcm = await synthesizePcm("Hello", { baseUrl: "https://speech.example", token: "secret", fetchImpl: async (url, options) => {
+    request = { url, options }; return {
+      ok: true,
+      headers: { get: () => "audio/pcm;rate=24000;encoding=signed-integer;bits=16" },
+      arrayBuffer: async () => Uint8Array.from([1, 2, 3]).buffer,
+    };
+  } });
+  assert.strictEqual(JSON.parse(request.options.body).response_format, "pcm");
+  assert.strictEqual(pcm.sampleRate, 24000);
+  assert.deepStrictEqual([...pcm.pcm], [1, 2, 3]);
+  stream.close();
+  console.log("kazee call speech: ok");
+})().catch((error) => { console.error(error); process.exitCode = 1; });

package/test-kazee-call-webrtc.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+"use strict";
+
+const assert = require("assert");
+const { MediaStreamTrack, RTCPeerConnection, RtpHeader, RtpPacket } = require("werift");
+const { OpusAudioCodec, WEBRTC_SAMPLES } = require("./channels/kazee/call/audio");
+
+const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+async function main() {
+  const publisher = new RTCPeerConnection();
+  const subscriber = new RTCPeerConnection();
+  const outgoing = new MediaStreamTrack({ kind: "audio" });
+  const sender = publisher.addTrack(outgoing);
+  let resolvePacket;
+  const received = new Promise((resolve) => { resolvePacket = resolve; });
+  subscriber.onTrack.subscribe((track) => track.onReceiveRtp.subscribe(resolvePacket));
+
+  const offer = await publisher.createOffer();
+  await publisher.setLocalDescription(offer);
+  await subscriber.setRemoteDescription(publisher.localDescription);
+  const answer = await subscriber.createAnswer();
+  await subscriber.setLocalDescription(answer);
+  await publisher.setRemoteDescription(subscriber.localDescription);
+
+  for (let attempt = 0; attempt < 100 && publisher.connectionState !== "connected"; attempt += 1) await wait(20);
+  assert.strictEqual(publisher.connectionState, "connected", "local WebRTC peers connect");
+
+  const pcm = Buffer.alloc(WEBRTC_SAMPLES * 2);
+  const samples = new Int16Array(pcm.buffer, pcm.byteOffset, WEBRTC_SAMPLES);
+  for (let i = 0; i < samples.length; i += 1) samples[i] = Math.round(Math.sin(2 * Math.PI * 440 * i / 48000) * 12000);
+  const codec = new OpusAudioCodec();
+  const opus = codec.encode(pcm);
+  outgoing.writeRtp(new RtpPacket(new RtpHeader({
+    payloadType: sender.codec?.payloadType || 111,
+    sequenceNumber: 1,
+    timestamp: WEBRTC_SAMPLES,
+    ssrc: 0x0c1a0d10,
+  }), opus));
+
+  const packet = await Promise.race([received, wait(3000).then(() => null)]);
+  assert(packet, "encrypted WebRTC path delivers an RTP packet");
+  assert.deepStrictEqual(packet.payload, opus, "Opus payload survives ICE/DTLS/SRTP transport");
+  assert.strictEqual(codec.decode(packet.payload).length, pcm.length, "received Opus decodes to a 20ms PCM frame");
+
+  codec.close();
+  await publisher.close();
+  await subscriber.close();
+  console.log("kazee call WebRTC loopback: ok");
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});

package/test-provider-enforcer.js

@@ -95,7 +95,10 @@ async function providerProbe(kind) {
   const service = enforcer.createEnforcerService({
     spawnUtilityAgent: utility.spawnUtilityAgent,
     audit,
-    timeoutMs: 2000,
+    // Generous: children answer in ms, so the green path never waits this out.
+    // The deadline exists only as the fail-closed backstop, and 2000ms was
+    // missed by child boot on a loaded CI runner (pipeline 10445 flake).
+    timeoutMs: 8000,
   });
   const speaker = { name: "External Fixture", relationship: "external", mandate: "May discuss invoice status only." };
   const secret = ["sk", "proj", "guard", "fixture", "private"].join("-");
@@ -106,9 +109,10 @@ async function providerProbe(kind) {
   const timeoutService = enforcer.createEnforcerService({
     spawnUtilityAgent: utility.spawnUtilityAgent,
     audit,
-    // 2500ms so the hung child boots on a loaded CI runner (writing capture #5
-    // and arming its SIGTERM recorder) before the deadline fires.
-    timeoutMs: 2500,
+    // Bounded (this deadline MUST fire — the child hangs by design), but with
+    // enough headroom for the hung child to boot on a loaded CI runner (write
+    // capture #5, arm its SIGTERM recorder) before the deadline kills it.
+    timeoutMs: 5000,
   });
   const timedOut = await timeoutService.vetReply(speaker, "timeout verdict fixture");
 

package/test-provider-language.js

@@ -207,7 +207,22 @@ assert.match(pkg.description, /provider-agnostic coding-agent harness/i);
 // 3.1.13 approved by Sumeet 2026-07-22 ("work through till all your plan is
 // completed"): owner-only incoming Kazee audio calls bridge Janus VideoRoom
 // RTP to hosted streaming STT, the normal agent turn, and streamed Pocket TTS.
-assert.strictEqual(pkg.version, "3.1.13", "release version must remain unchanged without explicit approval");
+// 3.1.14 approved by Sumeet 2026-07-22 (calls deep-dive: "you're welcome to go
+// ahead and work through all the way until everything's deployed"): call bridge
+// production hardening — serialized TTS with barge-in cancellation, echo gate,
+// per-feed STT with group speaker attribution, duration/idle limits with a
+// spoken goodbye, and the call tests wired into the main npm test chain.
+// 3.1.15 approved by Sumeet 2026-07-22 ("if replying in voice it needs to be
+// summaries etc but not just conversions directly"): voice-note replies now
+// speak a provider-written conversational <voice-script> summary (stripped from
+// the chat text) instead of a verbatim TTS of the formatted answer, with a
+// sanitizing speechFallback when the script is missing.
+// 3.1.16 approved by Sumeet 2026-07-22 (same calls-directive authority; re-cut
+// of the never-published 3.1.15 after two loaded-runner CI flakes): test-only
+// deflake — heal-guard test stubs its live api.telegram.org probe and isolates
+// CONFIG_DIR; enforcer probe deadlines raised to CI-safe values (2000→8000ms
+// backstop, 2500→5000ms deliberate-timeout boot headroom). No runtime changes.
+assert.strictEqual(pkg.version, "3.1.16", "release version must remain unchanged without explicit approval");
 for (const keyword of ["claude", "codex", "coding-agent", "provider-agnostic"]) {
   assert.ok(pkg.keywords.includes(keyword), `package keyword missing: ${keyword}`);
 }