@inetafrica/open-claudia 3.2.0 → 3.2.1

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## v3.2.1 — Speech as a general capability, sockets that survive rejection, and calls that greet back
+
+- **A rejected handshake no longer strands a bot forever.** socket.io-client permanently stops reconnecting when the *server* rejects a handshake (auth middleware `next(new Error())`): `connect_error` fires with `socket.active === false` and the manager never dials again. During the 2026-08-08 outage chat-central booted before Central's MongoDB and rejected every handshake for a few minutes — terminally stranding the whole bot fleet, pods "Running" but deaf until manually restarted. New `core/socket-reconnect.js` `wireTerminalReconnect()` watches for exactly that terminal state and drives a manual `connect()` with 2s→30s capped backoff; transport-level failures (where the manager retries on its own, `socket.active === true`) are left alone. A deliberate client-side `disconnect()` is intercepted — a wedged socket emits no event for it — and cancels retries until `connect()` re-arms them. Wired into both the kazee and spaces sockets; `test-socket-reconnect.js` joins the pretest chain.
+- **The bot can now place calls, both directions get a greeting, and the media leg works behind NAT.** Call-platform batch in the kazee channel, live-tested end to end on 2026-08-08:
+  - ICE servers now come from chat-central's `GET /webrtc/config` instead of a hardcoded STUN list, filtered to `stun:`/`turn:` URLs without `transport=tcp` (werift's ICE is UDP-only), falling back to defaults if the fetch fails. This fixes the zero-RTP calls where STUN alone couldn't punch through (diagnosed 2026-07-30).
+  - `outgoing({ chatId, toUserId })` places a bot-initiated call: the caller side owns room lifecycle, so the session creates the Janus room itself (mirroring the web client's params, tolerating 427 already-exists) and destroys it on close; `call:invite` goes out with a 60s ring timer — FCM's TTL is 60s and chat-central keeps ringing calls fresh for 90s, while the mobile app auto-ends its ring UI at 30s.
+  - That 30s device auto-end fires `call:end`, which previously tore down the room while a human was still walking to the phone — a late answer (44s in the live test) then joined a destroyed room and hung on "Connecting". `ended()` now ignores end events while the call is still ringing; the ring timer and `call:rejected` own that phase.
+  - Callers heard silence until they spoke first and read the call as dead. The session now speaks a greeting exactly once, when the first remote feed comes up — both directions ("Hey, it's Claudia…").
+  - Double-subscribe race fixed: the join response and the async publishers event both list the same feed, and while `attach()` was in flight the second frame passed the `has()` check and subscribed the feed twice, orphaning a PeerConnection (diagnosed 2026-07-30). The slot is now reserved before the first await.
+  - `call:accepted`/`call:rejected` are handled, and both call-test harnesses grew coverage (+45/+47 lines) for the outgoing flow, ring timeout, ignore-while-ringing, and greeting.
+- **Received videos and mobile uploads no longer save as `.bin`.** Telegram messages without a fileName (videos especially) and Kazee Media docs from mobile uploads (which often carry no fileName at all) fell through to the `.bin` fallback, so an mp4 landed on disk unplayable. Extension derivation is now tiered: fileName ext → transport hint (Telegram's `file_path`, which carries the real extension; Kazee's blob-URL pathname) → mimeType map (16 common types) → per-media-type default (video→.mp4, audio→.m4a/.ogg) → `.bin` only as the true last resort. Kazee documents that keep their original name get the derived extension appended when the name has none.
+- **TTS and STT become first-class agent capabilities, not just the voice-note reply path.** Fleet agents asked to produce a voice-over or transcribe a sent recording had nothing to reach for: they probed `open-claudia say --help` (which would have *spoken* "--help"), then tried direct gateway/vendor API calls and concluded "the key is missing" — correctly, because the provider subprocess is credential-stripped by design. Two new loopback verbs run in the credentialed bot process: `tts` (`open-claudia tts "<text>" --out <path> [--voice <id>]` — synthesize to a FILE without any chat send; extension picks the container, .ogg native / .mp3 / .wav transcoded; voice override reaches the gateway for cloned voices) and `transcribe` (`open-claudia transcribe <file>` — prints the transcript of any audio OR video file; `transcribeMedia` ffmpeg-normalizes to 16kHz mono wav first, which extracts video audio tracks and shrinks the gateway upload, then falls through the existing gateway → local-Whisper chain). No guardrail on `tts` because the artifact stays on local disk — the send verbs that could ship it carry their own R8 guard. A new "Speech services (TTS / STT)" system-prompt block — gated on real capability (`canSpeak()` / new `canTranscribe()`) — documents both plus `say`, and tells agents explicitly to never call the gateway or vendor APIs directly. `say`/`tts`/`transcribe` all answer `--help` now instead of synthesizing the flag. Regression chain: `test-speech-loopback.js` pins the loopback contract (empty text 400, no route 503, synth failure 500, relative/missing transcribe paths 400, empty transcript is a valid 200, auth 401) and the media mechanics (copy vs transcode by extension, mkdir -p, voice override in the gateway body, temp-wav cleanup, prompt-block presence). Verified live: a real gateway round-trip synthesized a sentence to mp3 and transcribed it back byte-identical.
+
 ## v3.2.0 — The employee batch: memory hygiene at write time, prospective memory, earned trust, and learning from the owner's judgment calls
 
 Three approved plans land together — memory adoption A1-A4 (from the TencentDB-Agent-Memory review), codegraph Phase 1, and employee capabilities C1-C6 — plus the Kazee group speaker-identity fix. Two rules hold throughout: **report-only where trust is involved** (nothing here grants, acts, or loosens an approval rule by itself), and **no new standing context cost** (everything injects only when already-matched content fires, or lands in the nightly dream summary).

package/bin/cli.js

@@ -278,6 +278,11 @@ switch (command) {
   }
 
   case "say": {
+    // Agents probe with --help before speaking; don't synthesize the flag.
+    if (args[1] === "--help" || args[1] === "-h") {
+      console.log('Usage: open-claudia say "<text>"\nSynthesize the text (TTS) and send it as a voice note to the current chat.\nTo synthesize to a file instead (voice-overs), use: open-claudia tts "<text>" --out <path>');
+      process.exit(0);
+    }
     const text = args.slice(1).join(" ").trim();
     if (!text) {
       console.error('Usage: open-claudia say "<text>"');
@@ -299,6 +304,90 @@ switch (command) {
     break;
   }
 
+  case "tts": {
+    if (args[1] === "--help" || args[1] === "-h") {
+      console.log('Usage: open-claudia tts "<text>" [--out <path>.ogg|.mp3|.wav] [--voice <id>]\nSynthesize speech to a FILE without sending it to chat (voice-overs, narration).\nThe extension picks the container; prints the final path. Omit --out for a temp .ogg.');
+      process.exit(0);
+    }
+    const rest = args.slice(1);
+    let out = null;
+    let voice = null;
+    const textParts = [];
+    for (let i = 0; i < rest.length; i++) {
+      if (rest[i] === "--out") out = rest[++i];
+      else if (rest[i] === "--voice") voice = rest[++i];
+      else textParts.push(rest[i]);
+    }
+    const text = textParts.join(" ").trim();
+    if (!text) {
+      console.error('Usage: open-claudia tts "<text>" [--out <path>.ogg|.mp3|.wav] [--voice <id>]');
+      process.exit(2);
+    }
+    (async () => {
+      // Like `say`, synthesis happens in the credentialed bot process — this CLI
+      // has no speech token. The bot writes the file and returns its path.
+      const { postJson } = require("./loopback-client");
+      try {
+        const res = await postJson("tts", {
+          text,
+          out: out ? path.resolve(out) : undefined,
+          voice: voice || undefined,
+        });
+        console.log(res.path);
+        process.exit(0);
+      } catch (e) {
+        console.error(e.message);
+        process.exit(1);
+      }
+    })();
+    break;
+  }
+
+  case "transcribe": {
+    if (args[1] === "--help" || args[1] === "-h") {
+      console.log("Usage: open-claudia transcribe <audio-or-video-file>\nSpeech-to-text: prints the transcript. Accepts audio (ogg/mp3/m4a/wav) and video\n(mp4/mkv — the audio track is extracted automatically).");
+      process.exit(0);
+    }
+    const filePath = String(args[1] || "").trim();
+    if (!filePath) {
+      console.error("Usage: open-claudia transcribe <audio-or-video-file>");
+      process.exit(2);
+    }
+    const abs = path.resolve(filePath);
+    if (!fs.existsSync(abs)) {
+      console.error(`File not found: ${abs}`);
+      process.exit(2);
+    }
+    (async () => {
+      const { postJson } = require("./loopback-client");
+      try {
+        const res = await postJson("transcribe", { path: abs });
+        console.log(res.text || "");
+        process.exit(0);
+      } catch (e) {
+        console.error(e.message);
+        process.exit(1);
+      }
+    })();
+    break;
+  }
+
+  case "call": {
+    (async () => {
+      const { postJson } = require("./loopback-client");
+      try {
+        const toUserId = String(args[1] || "").trim();
+        const res = await postJson("call", toUserId ? { toUserId } : {});
+        console.log(`Calling: room=${res.roomId} chat=${res.chatId} to=${res.toUserId}`);
+        process.exit(0);
+      } catch (e) {
+        console.error(e.message);
+        process.exit(1);
+      }
+    })();
+    break;
+  }
+
   case "tw":
   case "transcript-window": {
     require("./transcript-window").run(args.slice(1));
@@ -474,6 +563,10 @@ Send tools (only work inside an active bot-spawned task):
   open-claudia send-photo <path> [caption]
   open-claudia send-voice <path>
   open-claudia say "<text>"          Synthesize the text (TTS) and send it as a voice note
+  open-claudia tts "<text>" --out <path>     Synthesize to a FILE without sending (voice-overs,
+                                             narration; ext picks format; --voice <id> optional)
+  open-claudia transcribe <file>     Speech-to-text: print the transcript of an audio/video file
+  open-claudia call [toUserId]       Place a live voice call on the current channel (kazee; owner-only)
 
 Memory tools:
   open-claudia transcript-search <query>     Ranked FTS5 search over indexed transcripts

package/channels/kazee/adapter.js

@@ -23,6 +23,28 @@ const CONTEXT_MAX_MESSAGES = 40;
 const CONTEXT_BODY_LIMIT = 280;
 const COLD_START_WINDOW = 15;
 
+// Kazee Media docs from mobile uploads often carry no fileName, so the saved
+// extension must come from the mimeType (or the blob URL) — otherwise every
+// video/document lands on disk as ".bin".
+const MIME_EXT = {
+  "video/mp4": ".mp4",
+  "video/quicktime": ".mov",
+  "video/webm": ".webm",
+  "video/x-matroska": ".mkv",
+  "audio/mpeg": ".mp3",
+  "audio/mp4": ".m4a",
+  "audio/x-m4a": ".m4a",
+  "audio/aac": ".aac",
+  "audio/ogg": ".ogg",
+  "audio/wav": ".wav",
+  "image/jpeg": ".jpg",
+  "image/png": ".png",
+  "image/gif": ".gif",
+  "image/webp": ".webp",
+  "application/pdf": ".pdf",
+  "application/zip": ".zip",
+};
+
 class KazeeAdapter {
   constructor({ id = "kazee", url, token, ownerUserId, botUserId }) {
     this.id = id;
@@ -600,10 +622,22 @@ class KazeeAdapter {
   async downloadMedia(media) {
     if (!media || !media.fileId) return null;
     const url = media.fileId; // Kazee passes the cloud URL through fileId.
-    const ext = path.extname(media.fileName || "") || (media.type === "voice" ? ".ogg" : media.type === "photo" ? ".jpg" : ".bin");
+    let urlExt = "";
+    try { urlExt = path.extname(new URL(url).pathname); } catch (e) {}
+    const mime = (media.mimeType || "").toLowerCase().split(";")[0].trim();
+    const ext = path.extname(media.fileName || "")
+      || urlExt
+      || MIME_EXT[mime]
+      || (media.type === "voice" ? ".ogg"
+        : media.type === "photo" ? ".jpg"
+        : media.type === "video" ? ".mp4"
+        : media.type === "audio" ? ".m4a"
+        : ".bin");
     const baseDir = media.type === "document" ? FILES_DIR : TEMP_DIR;
-    const localPath = media.type === "document" && media.fileName
-      ? path.join(baseDir, media.fileName)
+    const keepName = media.type === "document" && media.fileName;
+    const nameSuffix = keepName && !path.extname(media.fileName) && ext !== ".bin" ? ext : "";
+    const localPath = keepName
+      ? path.join(baseDir, media.fileName + nameSuffix)
       : path.join(baseDir, `kz-${Date.now()}${ext}`);
     await this._downloadUrl(url, localPath);
     return localPath;

package/channels/kazee/call/manager.js

@@ -8,6 +8,16 @@ const DEFAULT_ICE_SERVERS = [
   { urls: "stun:coturn.kazee.africa:3478" },
   { urls: "stun:stun.l.google.com:19302" },
 ];
+// FCM push TTL is 60s and chat-central treats ringing logs as fresh for 90s.
+// Must comfortably outlast the mobile client's own 30s ring timeout: a callee
+// device auto-ends at 30s, the human then answers late, and chat-central
+// revives the CallLog — the room has to still exist when that answer lands
+// (first live outbound test 2026-08-08: end at 30s, real answer at 44s).
+const RING_TIMEOUT_MS = 60_000;
+const OUTGOING_GREETING = "Hey, it's Claudia. Can you hear me okay?";
+// Inbound must greet too: callers get silence until they speak first, which
+// reads as a dead call (live test 2026-08-08 — media was up, caller hung up).
+const INCOMING_GREETING = "Hey, it's Claudia — you're through. Can you hear me?";
 
 class KazeeCallManager {
   constructor({ adapter, SessionImpl = KazeeCallSession, janusUrl = process.env.KAZEE_JANUS_URL || DEFAULT_JANUS_URL,
@@ -17,12 +27,45 @@ class KazeeCallManager {
     this.janusUrl = janusUrl;
     this.iceServers = iceServers;
     this.session = null;
+    this._ringTimer = null;
   }
 
   wire(socket) {
     socket.on("call:incoming", (payload) => this.incoming(payload));
     socket.on("call:ended", (payload) => this.ended(payload));
-    socket.on("call:rejected", (payload) => this.ended(payload));
+    socket.on("call:rejected", (payload) => this.rejected(payload));
+    socket.on("call:accepted", (payload) => this.accepted(payload));
+    socket.on("call:ringing", (payload) => {
+      if (this.session) console.log(`Kazee call ringing: chat=${String(payload?.chatId || "")}`);
+    });
+  }
+
+  // Janus signalling always worked; the media leg never did — the hardcoded
+  // default is STUN-only, and behind NAT only a TURN relay yields a workable
+  // candidate pair (zero RTP ever arrived, 2026-07-30). chat-central mints
+  // TURN credentials at /webrtc/config — the same endpoint the web and mobile
+  // clients use. werift's ICE stack is UDP-only, so tcp/tls variants are
+  // filtered out before they can break candidate gathering.
+  async _fetchIceServers() {
+    if (typeof this.adapter?._request !== "function") return this.iceServers;
+    try {
+      const res = await this.adapter._request("GET", "/webrtc/config");
+      const fetched = Array.isArray(res?.config?.iceServers) ? res.config.iceServers : [];
+      const usable = fetched.filter((server) => {
+        const url = String(Array.isArray(server.urls) ? server.urls[0] : server.urls || "");
+        if (url.startsWith("stun:")) return true;
+        return url.startsWith("turn:") && !url.includes("transport=tcp");
+      });
+      const turns = usable.filter((s) => String(Array.isArray(s.urls) ? s.urls[0] : s.urls).startsWith("turn:")).length;
+      if (turns > 0) {
+        console.log(`Kazee call ICE config: ${usable.length} servers (${turns} TURN) from /webrtc/config`);
+        return usable;
+      }
+      console.warn("Kazee call ICE config: /webrtc/config returned no usable TURN entry, using defaults");
+    } catch (error) {
+      console.error(`Kazee call ICE config fetch failed, using defaults: ${error.message}`);
+    }
+    return this.iceServers;
   }
 
   async incoming(payload = {}) {
@@ -44,9 +87,10 @@ class KazeeCallManager {
     if (callType !== "audio") return reject("unsupported_media");
     if (this.session) return reject("busy");
 
+    const iceServers = await this._fetchIceServers();
     const session = new this.SessionImpl({
       roomId, chatId, callerId, botUserId: this.adapter.botUserId,
-      janusUrl: this.janusUrl, iceServers: this.iceServers,
+      janusUrl: this.janusUrl, iceServers, greeting: INCOMING_GREETING,
       onTranscript: (text, meta) => this._transcript(text, payload, meta),
       onEnded: () => { if (this.session === session) this.session = null; },
     });
@@ -65,6 +109,70 @@ class KazeeCallManager {
     }
   }
 
+  // Bot-initiated call. Mirrors what a human caller's client does: create the
+  // Janus room, publish into it, then emit call:invite so chat-central rings
+  // the callee (socket + FCM/VoIP push). The callee's publisher appearing in
+  // the room is what completes the media leg — the existing auto-subscribe in
+  // the session handles that, so acceptance needs no extra media work here.
+  async outgoing({ chatId, toUserId } = {}) {
+    const target = String(toUserId || this.adapter.ownerUserId || "");
+    const chat = String(chatId || "");
+    if (!target || !chat) throw new Error("missing chatId/toUserId");
+    if (this.session) throw new Error("busy: a call session is already active");
+    if (!this.adapter._socket?.connected) throw new Error("kazee socket is not connected");
+    const roomId = Math.floor(Math.random() * 1e9);
+    const iceServers = await this._fetchIceServers();
+    // _transcript() reads chatId/fromUserId/roomId off the inbound invite
+    // payload; for outbound the remote human is the "from" side.
+    const remote = { chatId: chat, fromUserId: target, roomId, fromUserName: "" };
+    const session = new this.SessionImpl({
+      roomId, chatId: chat, callerId: target, botUserId: this.adapter.botUserId,
+      janusUrl: this.janusUrl, iceServers, asCaller: true, greeting: OUTGOING_GREETING,
+      onTranscript: (text, meta) => this._transcript(text, remote, meta),
+      onEnded: () => {
+        this._clearRingTimer();
+        if (this.session === session) this.session = null;
+      },
+    });
+    this.session = session;
+    try {
+      await session.start();
+    } catch (error) {
+      this.session = null;
+      await session.close("connect-failed").catch(() => {});
+      throw error;
+    }
+    console.log(`Kazee call outgoing: room=${roomId} chat=${chat} to=${target}`);
+    this.adapter._socket.emit("call:invite", { toUserId: target, callType: "audio", chatId: chat, roomId });
+    this._ringTimer = setTimeout(() => {
+      this._ringTimer = null;
+      this._ringTimeout(target, chat, roomId).catch((error) => console.error("Kazee call ring timeout:", error.message));
+    }, RING_TIMEOUT_MS);
+    if (typeof this._ringTimer.unref === "function") this._ringTimer.unref();
+    return { roomId, chatId: chat, toUserId: target };
+  }
+
+  accepted(payload = {}) {
+    if (!this.session || !this._ringTimer) return;
+    console.log(`Kazee call answered: room=${this.session.roomId} chat=${String(payload.chatId || "")}`);
+    this._clearRingTimer();
+  }
+
+  async _ringTimeout(toUserId, chatId, roomId) {
+    const session = this.session;
+    if (!session || session.roomId !== roomId) return;
+    console.log(`Kazee call unanswered: room=${roomId} to=${toUserId}`);
+    // Caller hanging up while ringing: chat-central finalizes the CallLog as
+    // missed and dismisses the callee's ringing UI/push.
+    this.adapter._socket?.emit("call:end", { toUserId, chatId });
+    this.session = null;
+    await session.close("no-answer").catch(() => {});
+  }
+
+  _clearRingTimer() {
+    if (this._ringTimer) { clearTimeout(this._ringTimer); this._ringTimer = null; }
+  }
+
   _transcript(text, incoming, meta = {}) {
     const session = this.session;
     if (!session || !text) return;
@@ -106,11 +214,29 @@ class KazeeCallManager {
   async ended(payload = {}) {
     if (!this.session) return;
     if (payload.roomId != null && Number(payload.roomId) !== this.session.roomId) return;
+    // While our outbound ring is live, a call:ended is usually a callee DEVICE
+    // giving up (mobile auto-ends its ring at 30s), not the human declining.
+    // chat-central revives the CallLog if they answer late, so the caller must
+    // keep the room alive until its own ring timeout — tearing down here left
+    // the late answer joining a destroyed room, stuck on "Connecting" (2026-08-08).
+    // A deliberate decline arrives as call:rejected and still closes.
+    if (this._ringTimer) {
+      console.log(`Kazee call ignoring ended-while-ringing: room=${this.session.roomId}`);
+      return;
+    }
     const session = this.session;
     this.session = null;
     await session.close("remote-ended");
   }
 
+  async rejected(payload = {}) {
+    if (!this.session) return;
+    if (payload.roomId != null && Number(payload.roomId) !== this.session.roomId) return;
+    const session = this.session;
+    this.session = null;
+    await session.close("remote-rejected");
+  }
+
   async stop() {
     if (!this.session) return;
     const session = this.session;

package/channels/kazee/call/session.js

@@ -55,12 +55,16 @@ const THINK_TICK_PCM48 = tonePcm48([{ freq: 520, ms: 90 }], 0.045);
 
 class KazeeCallSession {
   constructor({ roomId, chatId, callerId, botUserId, janusUrl, iceServers = [], onTranscript, onEnded,
-    maxCallMs, idleMs, synthesize = synthesizePcm,
+    maxCallMs, idleMs, synthesize = synthesizePcm, asCaller = false, greeting = null,
     JanusClientImpl = JanusClient, PeerConnectionImpl = RTCPeerConnection, SpeechStreamImpl = SpeechStream } = {}) {
     this.roomId = Number(roomId);
     this.chatId = String(chatId);
     this.callerId = String(callerId);
     this.botUserId = String(botUserId);
+    this.asCaller = !!asCaller;
+    this.greeting = greeting ? String(greeting) : null;
+    this._greeted = false;
+    this._createdRoom = false;
     this.janus = new JanusClientImpl({ url: janusUrl });
     this.PeerConnectionImpl = PeerConnectionImpl;
     this.SpeechStreamImpl = SpeechStreamImpl;
@@ -97,6 +101,21 @@ class KazeeCallSession {
     await this.janus.connect();
     this.publisherHandle = await this.janus.attach();
     this.janus.onHandle(this.publisherHandle, (frame) => this._onPublisherEvent(frame));
+    if (this.asCaller) {
+      // Outbound: the caller side owns room lifecycle, mirroring the web
+      // client's create params (audio-only, so no videocodec).
+      const created = await this.janus.message(this.publisherHandle, {
+        request: "create", room: this.roomId, publishers: 6, audiocodec: "opus",
+        description: `Call room ${this.roomId}`, permanent: false,
+      });
+      const cdata = created?.plugindata?.data || {};
+      const exists = Number(cdata.error_code) === 427 || /already exists/i.test(String(cdata.error || ""));
+      if (cdata.videoroom !== "created" && !exists) {
+        throw new Error(cdata.error || "Janus room create failed");
+      }
+      this._createdRoom = true;
+      clog(`Kazee call room created: room=${this.roomId}`);
+    }
     // The caller creates the Janus room during its own call setup, which can
     // land a beat after the invite reaches us — and a bot answers faster than
     // any human. Poll join through transient 426 "No such room" like the web
@@ -163,31 +182,47 @@ class KazeeCallSession {
   }
 
   async _subscribe(feedId, display) {
+    if (this.subscribers.has(feedId)) return;
+    // Reserve the slot before the first await: the join response and the async
+    // publishers event both list the same feed, and while attach() is in
+    // flight the second frame passes the caller's has() check and subscribes
+    // this feed twice, orphaning a PeerConnection (diagnosed 2026-07-30).
+    this.subscribers.set(feedId, null);
     clog(`Kazee call subscribing: feed=${feedId} display=${String(display || "")}`);
-    const handle = await this.janus.attach();
-    const pc = new this.PeerConnectionImpl({ iceServers: this.iceServers });
-    pc.iceConnectionStateChange?.subscribe?.((state) => clog(`Kazee call subscriber ICE: ${state} feed=${feedId}`));
-    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._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().then(
-      () => clog(`Kazee call STT connected: feed=${feedId}`),
-      (error) => console.error("Kazee call STT connect:", error.message),
-    );
+    try {
+      const handle = await this.janus.attach();
+      const pc = new this.PeerConnectionImpl({ iceServers: this.iceServers });
+      pc.iceConnectionStateChange?.subscribe?.((state) => clog(`Kazee call subscriber ICE: ${state} feed=${feedId}`));
+      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._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().then(
+        () => clog(`Kazee call STT connected: feed=${feedId}`),
+        (error) => console.error("Kazee call STT connect:", error.message),
+      );
+      // First remote feed up = both media legs established; greet exactly once.
+      if (this.greeting && !this._greeted) {
+        this._greeted = true;
+        this.speak(this.greeting).catch((error) => console.error("Kazee call greeting:", error.message));
+      }
+    } catch (error) {
+      if (this.subscribers.get(feedId) === null) this.subscribers.delete(feedId);
+      throw error;
+    }
   }
 
   async _onSubscriberEvent(feedId, frame) {
@@ -403,6 +438,9 @@ class KazeeCallSession {
     this._stopThinking();
     this.cancelSpeech();
     for (const feed of [...this.subscribers.keys()]) await this._removeSubscriber(feed);
+    if (this._createdRoom) {
+      try { await this.janus.message(this.publisherHandle, { request: "destroy", room: this.roomId }); } catch (_) {}
+    }
     try { await this.publisher?.pc?.close(); } catch (_) {}
     try { await this.janus.detach(this.publisherHandle); } catch (_) {}
     try { await this.janus.close(); } catch (_) {}

package/channels/kazee/socket.js

@@ -5,6 +5,8 @@ let io;
 try { io = require("socket.io-client").io; }
 catch (e) { io = null; }
 
+const { wireTerminalReconnect } = require("../../core/socket-reconnect");
+
 function createKazeeSocket({ url, token, userId, onConnect, onDisconnect, onError }) {
   if (!io) {
     throw new Error("socket.io-client is not installed. Run `npm install` to install dependencies.");
@@ -22,6 +24,7 @@ function createKazeeSocket({ url, token, userId, onConnect, onDisconnect, onErro
   socket.on("connect", () => { if (onConnect) onConnect(socket); });
   socket.on("disconnect", (reason) => { if (onDisconnect) onDisconnect(reason); });
   socket.on("connect_error", (err) => { if (onError) onError(err); });
+  wireTerminalReconnect(socket, { label: `kazee socket (${url})` });
   return socket;
 }
 

package/channels/spaces/socket.js

@@ -14,6 +14,8 @@ let io;
 try { io = require("socket.io-client").io; }
 catch (e) { io = null; }
 
+const { wireTerminalReconnect } = require("../../core/socket-reconnect");
+
 function createSpacesSocket({ url, token, onNotification, onConnect, onDisconnect, onError }) {
   if (!io) {
     throw new Error("socket.io-client is not installed. Run `npm install` to install dependencies.");
@@ -34,6 +36,7 @@ function createSpacesSocket({ url, token, onNotification, onConnect, onDisconnec
       catch (e) { console.error("spaces notification handler:", e.message); }
     }
   });
+  wireTerminalReconnect(socket, { label: `spaces socket (${url})` });
   return socket;
 }
 

package/channels/telegram/adapter.js

@@ -672,11 +672,15 @@ class TelegramAdapter {
     if (!media || !media.fileId) return null;
     const file = await this.bot.getFile(media.fileId);
     const fileUrl = `https://api.telegram.org/file/bot${this.token}/${file.file_path}`;
-    const ext = media.fileName ? path.extname(media.fileName) || ".bin"
-      : media.type === "voice" ? ".ogg"
-      : media.type === "audio" ? path.extname(media.fileName || "") || ".ogg"
-      : media.type === "photo" ? ".jpg"
-      : ".bin";
+    // Telegram's file_path carries the real extension even when the message
+    // has no fileName (e.g. videos), so prefer it over the .bin fallback.
+    const ext = path.extname(media.fileName || "")
+      || path.extname(file.file_path || "")
+      || (media.type === "voice" ? ".ogg"
+        : media.type === "audio" ? ".ogg"
+        : media.type === "photo" ? ".jpg"
+        : media.type === "video" ? ".mp4"
+        : ".bin");
     const baseDir = media.type === "document" ? FILES_DIR : TEMP_DIR;
     const localPath = media.type === "document" && media.fileName
       ? path.join(baseDir, media.fileName)

package/core/loopback.js

@@ -82,7 +82,7 @@ const JSON_KINDS = new Set([
   "relay-send", "recent-fetch", "audit-tail",
   "auth-list", "auth-revoke",
   "approval-request",
-  "say",
+  "say", "call", "tts", "transcribe",
 ]);
 
 function callerIsOwner(payload) {
@@ -200,6 +200,56 @@ async function handleJson(req, res, url, kind) {
     return reply(res, ok ? 200 : 500, { ok });
   }
 
+  if (kind === "tts") {
+    // Synthesis-to-FILE: no chat egress, so no guardrail — the artifact stays on
+    // local disk until some send verb (with its own guard) ships it. Runs here
+    // because only the bot process holds the speech token.
+    const text = String(payload.text || "").trim();
+    if (!text) return reply(res, 400, { error: "missing text" });
+    try {
+      const { textToVoiceFile } = require("./media");
+      const outPath = await textToVoiceFile(text, {
+        voice: payload.voice ? String(payload.voice) : undefined,
+        out: payload.out ? String(payload.out) : undefined,
+      });
+      if (!outPath) return reply(res, 503, { error: "no TTS route available" });
+      return reply(res, 200, { ok: true, path: outPath });
+    } catch (e) {
+      return reply(res, 500, { error: `synthesis failed: ${e.message}` });
+    }
+  }
+
+  if (kind === "transcribe") {
+    const filePath = String(payload.path || "").trim();
+    if (!filePath) return reply(res, 400, { error: "missing path" });
+    if (!path.isAbsolute(filePath)) return reply(res, 400, { error: "path must be absolute (the bot process has its own cwd)" });
+    if (!fs.existsSync(filePath)) return reply(res, 400, { error: `file not found: ${filePath}` });
+    try {
+      const { transcribeMedia } = require("./media");
+      const text = await transcribeMedia(filePath);
+      if (text == null) return reply(res, 503, { error: "no STT route available" });
+      return reply(res, 200, { ok: true, text });
+    } catch (e) {
+      return reply(res, 500, { error: `transcription failed: ${e.message}` });
+    }
+  }
+
+  if (kind === "call") {
+    // Placing a live voice call is owner-only: it rings a phone on the bot's
+    // behalf, so nothing guarded/external may trigger it.
+    if (!callerIsOwner(payload)) return reply(res, 403, { error: "only the owner can place a call" });
+    const manager = adapter._callManager;
+    if (!manager || typeof manager.outgoing !== "function") {
+      return reply(res, 501, { error: `adapter ${adapterId} does not support outgoing calls` });
+    }
+    try {
+      const result = await manager.outgoing({ chatId: channelId, toUserId: payload.toUserId || undefined });
+      return reply(res, 200, { ok: true, ...result });
+    } catch (e) {
+      return reply(res, 500, { error: e.message });
+    }
+  }
+
   if (kind === "schedule-wakeup") {
     const fireAt = Number(payload.fireAt);
     if (!Number.isFinite(fireAt) || fireAt <= 0) return reply(res, 400, { error: "missing/invalid fireAt" });

package/core/media.js

@@ -101,7 +101,7 @@ async function elevenLabsToVoice(clean) {
 
 // Pocket TTS through the Agent Space speech gateway. The gateway returns WAV;
 // Telegram and voice transports receive a compact Ogg/Opus file.
-async function pocketToVoice(clean) {
+async function pocketToVoice(clean, voiceOverride) {
   const token = speechBearerToken();
   if (TTS_PROVIDER === "elevenlabs" || !token || !SPEECH_SERVICE_URL || !FFMPEG) return null;
   let wavPath = null;
@@ -109,7 +109,7 @@ async function pocketToVoice(clean) {
     const res = await fetch(`${SPEECH_SERVICE_URL.replace(/\/$/, "")}/v1/audio/speech`, {
       method: "POST",
       headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
-      body: JSON.stringify({ input: clean, voice: ttsVoice.getVoice(), response_format: "wav" }),
+      body: JSON.stringify({ input: clean, voice: voiceOverride || ttsVoice.getVoice(), response_format: "wav" }),
       signal: AbortSignal.timeout(60000),
     });
     if (!res.ok) {
@@ -186,16 +186,69 @@ function canSpeak() {
 }
 
 // Natural voice via ElevenLabs, falling back to macOS `say` only on no-key/error.
-async function textToVoice(text) {
+// opts.voice overrides the gateway voice id (e.g. a cloned voice) for the pocket
+// route only — ElevenLabs/say fallbacks keep their configured voices.
+async function textToVoice(text, opts = {}) {
   const clean = cleanForTTS(text);
   if (!clean) return null;
-  const pocket = await pocketToVoice(clean);
+  const pocket = await pocketToVoice(clean, opts.voice);
   if (pocket) return pocket;
   const eleven = await elevenLabsToVoice(clean);
   if (eleven) return eleven;
   return sayToVoice(clean);
 }
 
+// Synthesize to a caller-chosen FILE (voice-overs, video narration) instead of a
+// chat send. `out` picks the container by extension (.ogg is native; anything
+// else transcodes). Returns the final path, or null when no TTS route exists.
+async function textToVoiceFile(text, { voice, out } = {}) {
+  const oggPath = await textToVoice(text, { voice });
+  if (!oggPath) return null;
+  if (!out || path.resolve(out) === path.resolve(oggPath)) return oggPath;
+  fs.mkdirSync(path.dirname(out), { recursive: true });
+  if (path.extname(out).toLowerCase() === path.extname(oggPath).toLowerCase()) {
+    fs.copyFileSync(oggPath, out);
+  } else {
+    if (!FFMPEG) throw new Error(`ffmpeg unavailable to convert to ${path.extname(out) || "the requested format"}`);
+    execSync(`"${FFMPEG}" -i "${oggPath}" -y "${out}" 2>/dev/null`, { timeout: 60000 });
+  }
+  try { fs.unlinkSync(oggPath); } catch (e) {}
+  return out;
+}
+
+// True when at least one transcribeAudio route can produce text.
+function canTranscribe() {
+  if (SPEECH_SERVICE_URL && speechBearerToken()) return true;
+  return Boolean(WHISPER_CLI && FFMPEG);
+}
+
+// Transcribe ANY audio/video file (mp3, m4a, wav, ogg, mp4, mkv...): normalize
+// to 16kHz mono wav first when ffmpeg is available — that extracts the audio
+// track from video containers and shrinks the gateway upload. Returns the
+// transcript string, or null when no STT route exists.
+async function transcribeMedia(filePath) {
+  if (!canTranscribe()) return null;
+  let wavPath = null;
+  let sendPath = filePath;
+  if (FFMPEG && !/\.wav$/i.test(filePath)) {
+    try {
+      wavPath = path.join(TEMP_DIR, `stt-${Date.now()}-${Math.random().toString(36).slice(2, 6)}.wav`);
+      execSync(`"${FFMPEG}" -i "${filePath}" -vn -ar 16000 -ac 1 -y "${wavPath}" 2>/dev/null`, { timeout: 300000 });
+      sendPath = wavPath;
+    } catch (e) {
+      console.error("STT transcode error:", e.message);
+      try { if (wavPath) fs.unlinkSync(wavPath); } catch (_) {}
+      wavPath = null;
+      sendPath = filePath;
+    }
+  }
+  try {
+    return await transcribeAudio(sendPath);
+  } finally {
+    if (wavPath) { try { fs.unlinkSync(wavPath); } catch (e) {} }
+  }
+}
+
 // Split a reply into sentence-sized chunks for streamed TTS. Tiny fragments are
 // merged into the next chunk so we don't fire a TTS call per "Hi." and end up
 // with choppy playback. Returns cleaned, non-empty chunks.
@@ -250,4 +303,4 @@ async function synthSentenceMp3(text) {
   }
 }
 
-module.exports = { transcribeAudio, transcribeAudioLocal, textToVoice, splitSentences, synthSentenceMp3, pocketToVoice, cloneVoiceFromClip, speechBearerToken, canSpeak, TTS_CMD };
+module.exports = { transcribeAudio, transcribeAudioLocal, transcribeMedia, canTranscribe, textToVoice, textToVoiceFile, splitSentences, synthSentenceMp3, pocketToVoice, cloneVoiceFromClip, speechBearerToken, canSpeak, TTS_CMD };

package/core/socket-reconnect.js

@@ -0,0 +1,71 @@
+"use strict";
+
+// socket.io-client permanently stops reconnecting when the server REJECTS a
+// handshake (auth middleware next(new Error())): connect_error fires with
+// socket.active === false and the manager never dials again. During the
+// 2026-08-08 outage chat-central booted before Central's MongoDB and rejected
+// every handshake for a few minutes, terminally stranding the whole bot fleet.
+// This wires a manual connect() retry with capped backoff so a rejected
+// handshake is never terminal. A deliberate client-side disconnect() cancels
+// any pending retry and stays final until connect() is called again.
+
+const DEFAULT_INITIAL_DELAY_MS = 2000;
+const DEFAULT_MAX_DELAY_MS = 30000;
+
+function wireTerminalReconnect(socket, opts = {}) {
+  const label = opts.label || "socket";
+  const log = opts.log || ((msg) => console.error(msg));
+  const initialDelay = opts.initialDelayMs || DEFAULT_INITIAL_DELAY_MS;
+  const maxDelay = opts.maxDelayMs || DEFAULT_MAX_DELAY_MS;
+
+  let attempts = 0;
+  let timer = null;
+  let stopped = false;
+
+  const cancel = () => {
+    if (timer) { clearTimeout(timer); timer = null; }
+  };
+
+  const schedule = (why) => {
+    if (stopped || timer) return;
+    const delay = Math.min(initialDelay * 2 ** attempts, maxDelay);
+    attempts += 1;
+    log(`${label}: ${why} — socket.io will not retry on its own; manual connect() in ${Math.ceil(delay / 1000)}s (attempt ${attempts})`);
+    timer = setTimeout(() => {
+      timer = null;
+      if (stopped || socket.connected || socket.active) return;
+      try { socket.connect(); }
+      catch (e) { schedule(`reconnect attempt threw (${e.message})`); }
+    }, delay);
+    if (typeof timer.unref === "function") timer.unref();
+  };
+
+  socket.on("connect", () => { attempts = 0; cancel(); });
+  socket.on("connect_error", (err) => {
+    if (socket.active) return; // transport failure: the manager auto-retries
+    schedule(`handshake rejected (${err && err.message ? err.message : err})`);
+  });
+  socket.on("disconnect", (reason) => {
+    if (reason === "io client disconnect") { cancel(); return; }
+    if (socket.active) return; // the manager auto-reconnects
+    schedule(`disconnected (${reason})`);
+  });
+
+  // disconnect() while wedged emits no event, so intercept the call itself;
+  // connect() re-arms retries for the adapter-restart path.
+  const origDisconnect = socket.disconnect;
+  socket.disconnect = function (...args) {
+    stopped = true;
+    cancel();
+    return origDisconnect.apply(this, args);
+  };
+  const origConnect = socket.connect;
+  socket.connect = function (...args) {
+    stopped = false;
+    return origConnect.apply(this, args);
+  };
+
+  return socket;
+}
+
+module.exports = { wireTerminalReconnect, DEFAULT_INITIAL_DELAY_MS, DEFAULT_MAX_DELAY_MS };

package/core/system-prompt.js

@@ -4,7 +4,7 @@
 const fs = require("fs");
 const path = require("path");
 const { SOUL_FILE, CRONS_FILE, VAULT_FILE, FILES_DIR, BOT_DIR, config } = require("./config");
-const { canSpeak } = require("./media");
+const { canSpeak, canTranscribe } = require("./media");
 const CONFIG_DIR = require("../config-dir");
 const { currentState, getProjectKey, getProviderSession } = require("./state");
 const { currentAdapter, currentChannelId, currentUserId, currentSpeakerName } = require("./context");
@@ -202,6 +202,7 @@ function buildCoreInstructionsUncached() {
   // Gate on actual TTS capability, not local Whisper: hosted pods hear and
   // speak through the speech gateway with no whisper binary installed.
   const hasVoice = canSpeak();
+  const hasEars = canTranscribe();
   return `
 ${soul}
 ${buildPersonaBlock()}
@@ -235,6 +236,13 @@ Reply normally in your final answer. To send a file, image, or voice clip back t
 - \`open-claudia send-voice <path>\` — ogg/opus voice note
 - \`open-claudia say "<text>"\` — synthesize the text and send it as a voice note (use this when asked for a voice reply)
 Never print or embed bot tokens in prompts, commands, logs, or messages.
+${hasVoice || hasEars ? `
+## Speech services (TTS / STT)
+Text-to-speech and speech-to-text are general capabilities, not just the voice-note reply path. Synthesis and transcription run inside the credentialed bot process — your own shell holds NO speech token or vendor key, so never call the speech gateway or TTS/STT vendor APIs directly and never conclude "the key is missing"; use these commands (they work from inside any bot-spawned task):
+${hasVoice ? `- \`open-claudia tts "<text>" --out <path>.mp3\` — synthesize narration to a FILE without sending it to chat: video voice-overs, explainer narration, IVR prompts, any audio artifact. The extension picks the container (.ogg native, .mp3/.wav transcoded); prints the final path. \`--voice <id>\` selects a specific gateway voice (e.g. a cloned voice).
+- \`open-claudia say "<text>"\` — synthesize AND send as a voice note to the current chat (listed under Delivery above).` : ""}
+${hasEars ? `- \`open-claudia transcribe <file>\` — speech-to-text: prints the transcript of an audio OR video file (voice notes, meeting recordings, mp3/m4a/wav/ogg, mp4/mkv — the audio track is extracted automatically). Use it whenever the user sends a recording and wants its contents.` : ""}
+For long narration, synthesize per-paragraph with \`tts\` and assemble with ffmpeg.` : ""}
 
 ## Background work
 You can persist work across turns and wake yourself up later. These survive bot restarts.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "3.2.0",
+  "version": "3.2.1",
   "description": "An always-on, provider-agnostic coding-agent harness for Claude Code and OpenAI Codex via chat",
   "main": "bot.js",
   "bin": {
@@ -10,7 +10,7 @@
     "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 && 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",
+    "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-socket-reconnect.js && node test-speech-loopback.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-mandate-hygiene.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-external-rule-scopes.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-cards.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-kazee-group-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-kazee-group-context.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-people-owner-seed.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 && 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-union.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-subst-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-section-budgets.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-dedup-adjudicator.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-prospective.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-regressions.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-cost-report.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-context.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-mining.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-certification.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-apprenticeship.js"
   },
   "files": [

package/test-fixtures/fake-agent-cli.js

@@ -487,8 +487,12 @@ async function main() {
     throw new Error("FAKE_AGENT_KIND must be claude or codex");
   }
   if (handleCompatibilityCommand()) return;
-  captureInvocation();
+  // Arm signal handlers BEFORE writing the boot capture: the capture is the
+  // parent's green light to send SIGTERM, and on a loaded machine the child
+  // can be preempted between these calls — a TERM then hits node's default
+  // disposition and kills the process before the signal capture ever writes.
   installSignalControls();
+  captureInvocation();
   spawnDescendantFixture();
   const stdin = await readStdin();
   captureStdin(stdin);

package/test-kazee-call-manager.js

@@ -11,7 +11,7 @@ class FakeSession {
 }
 function fixture() {
   const events = [], inbound = [];
-  const socket = { on() {}, emit(name, payload) { events.push({ name, payload }); } };
+  const socket = { connected: true, 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 }) };
 }
@@ -36,5 +36,48 @@ function fixture() {
   assert.strictEqual(f.manager.session.spoken, "Your agenda is clear.");
   await f.manager.ended({ roomId: 12 });
   assert.strictEqual(f.manager.session, null);
+
+  // Outbound: session starts in caller mode, invite goes out, answer clears the ring timer.
+  f = fixture();
+  const res = await f.manager.outgoing({ chatId: "chat-2" });
+  assert.strictEqual(res.toUserId, "owner-1");
+  const outSession = f.manager.session;
+  assert.strictEqual(outSession.options.asCaller, true);
+  assert.ok(outSession.options.greeting);
+  assert.strictEqual(outSession.started, true);
+  const invite = f.events.find((e) => e.name === "call:invite");
+  assert.deepStrictEqual(invite.payload, { toUserId: "owner-1", callType: "audio", chatId: "chat-2", roomId: res.roomId });
+  assert.ok(f.manager._ringTimer);
+  // A callee device auto-ending its ring must NOT tear down the outbound call —
+  // chat-central revives the CallLog if the human answers late.
+  await f.manager.ended({ chatId: "chat-2" });
+  assert.ok(f.manager.session, "ended-while-ringing is ignored");
+  f.manager.accepted({ chatId: "chat-2" });
+  assert.strictEqual(f.manager._ringTimer, null);
+  // Outbound transcripts dispatch with the remote human as the "from" side.
+  outSession.options.onTranscript("Hello there");
+  assert.strictEqual(f.inbound[0].payload.channelId, "chat-2");
+  assert.strictEqual(f.inbound[0].payload.userId, "owner-1");
+  assert.strictEqual(f.inbound[0].payload.raw.ephemeralAudio, true);
+  await assert.rejects(() => f.manager.outgoing({ chatId: "chat-2" }), /busy/);
+  await f.manager.ended({ roomId: res.roomId });
+  assert.strictEqual(f.manager.session, null);
+
+  // A deliberate decline (call:rejected) still tears down mid-ring.
+  f = fixture();
+  await f.manager.outgoing({ chatId: "chat-4" });
+  assert.ok(f.manager._ringTimer);
+  await f.manager.rejected({ chatId: "chat-4" });
+  assert.strictEqual(f.manager.session, null, "reject-while-ringing closes the call");
+  assert.strictEqual(f.manager._ringTimer, null);
+
+  // Unanswered: ring timeout tells the server to finalize as missed and hangs up.
+  f = fixture();
+  const res2 = await f.manager.outgoing({ chatId: "chat-3", toUserId: "owner-1" });
+  f.manager._clearRingTimer();
+  await f.manager._ringTimeout("owner-1", "chat-3", res2.roomId);
+  const end = f.events.find((e) => e.name === "call:end");
+  assert.deepStrictEqual(end.payload, { toUserId: "owner-1", chatId: "chat-3" });
+  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

@@ -41,12 +41,12 @@ class FakeSpeechStream {
   close() { this.closedStream = true; }
 }
 
-function makeSession({ synthesize, maxCallMs, idleMs } = {}) {
+function makeSession({ synthesize, maxCallMs, idleMs, asCaller, greeting } = {}) {
   const ended = [];
   const transcripts = [];
   const session = new KazeeCallSession({
     roomId: 7, chatId: "chat", callerId: "owner", botUserId: "bot", janusUrl: "ws://test",
-    maxCallMs, idleMs,
+    maxCallMs, idleMs, asCaller, greeting,
     synthesize: synthesize || (async () => ({ pcm: Buffer.alloc(WEBRTC_SAMPLES * 2 * 2), sampleRate: 48000 })),
     onTranscript: (text, meta) => transcripts.push({ text, meta }),
     onEnded: (reason) => ended.push(reason),
@@ -228,6 +228,47 @@ async function testJoinGivesUpAfterRetries() {
   await session.close();
 }
 
+async function testCallerModeRoomLifecycle() {
+  const { session } = makeSession({ asCaller: true, greeting: "hi there" });
+  const messages = [];
+  session.janus.message = async (_handle, body) => {
+    messages.push(body);
+    if (body?.request === "create") return { plugindata: { data: { videoroom: "created", room: 7 } } };
+    return {};
+  };
+  await session.start();
+  assert.strictEqual(messages[0].request, "create", "caller creates the room before joining");
+  assert.strictEqual(messages[0].room, 7);
+  assert.strictEqual(messages[0].audiocodec, "opus");
+  assert.strictEqual(messages[1].request, "join");
+  assert.strictEqual(session._createdRoom, true);
+  const spoken = [];
+  session.speak = async (text) => { spoken.push(text); return true; };
+  await session._subscribe(101, "sumeet@kazee");
+  await session._subscribe(102, "second@kazee");
+  assert.deepStrictEqual(spoken, ["hi there"], "greeting speaks exactly once, on first remote feed");
+  await session.close();
+  const destroy = messages.find((m) => m?.request === "destroy");
+  assert.ok(destroy && destroy.room === 7, "created room is destroyed on close");
+}
+
+async function testCallerModeRoomExistsAndFailure() {
+  const { session } = makeSession({ asCaller: true });
+  session.janus.message = async (_handle, body) => body?.request === "create"
+    ? { plugindata: { data: { videoroom: "event", error_code: 427, error: "Room 7 already exists" } } }
+    : {};
+  await session.start();
+  assert.strictEqual(session._createdRoom, true, "already-exists (427) counts as created");
+  await session.close();
+
+  const bad = makeSession({ asCaller: true }).session;
+  bad.janus.message = async (_handle, body) => body?.request === "create"
+    ? { plugindata: { data: { videoroom: "event", error_code: 499, error: "boom" } } }
+    : {};
+  await assert.rejects(() => bad.start(), /boom/, "hard create failure fails the call");
+  await bad.close();
+}
+
 async function testThinkingCues() {
   const { session } = makeSession({
     synthesize: async () => ({ pcm: Buffer.alloc(WEBRTC_SAMPLES * 2 * 3), sampleRate: 48000 }),
@@ -300,6 +341,8 @@ async function testCloseResolvesSpeech() {
   await testMaxDuration();
   await testJoinRetriesNoSuchRoom();
   await testJoinGivesUpAfterRetries();
+  await testCallerModeRoomLifecycle();
+  await testCallerModeRoomExistsAndFailure();
   await testThinkingCues();
   await testCloseResolvesSpeech();
   console.log("kazee call session: ok");

package/test-provider-language.js

@@ -346,7 +346,12 @@ assert.match(pkg.description, /provider-agnostic coding-agent harness/i);
 // into a new version work through till the end and deploy out a new version"):
 // the employee batch — memory adoption A1-A4, the codegraph reusable tool,
 // employee capabilities C1-C6, and the Kazee group speaker-identity fix.
-assert.strictEqual(pkg.version, "3.2.0", "release version must remain unchanged without explicit approval");
+// 3.2.1 approved by Sumeet 2026-08-08 ("Push it", answering "Your go on the
+// v3.2.1 cut → commit, tag, CI image, fleet roll"): terminal socket-reconnect
+// fix from the chat-central outage, the call-platform batch (outgoing calls,
+// greetings, TURN via /webrtc/config, ring-phase teardown fixes), the
+// received-media .bin extension fix, and the tts/transcribe agent verbs.
+assert.strictEqual(pkg.version, "3.2.1", "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}`);
 }