@inetafrica/open-claudia 3.1.10 → 3.1.13

package/.env.example

@@ -13,6 +13,8 @@ KAZEE_BOT_USER_ID=
 KAZEE_OWNER_USER_ID=
 # Set to 1 to log every inbound Kazee socket event (debug aid; noisy).
 KAZEE_DEBUG_EVENTS=
+# Optional override; Kazee calls default to the production Janus WebSocket.
+KAZEE_JANUS_URL=wss://janus.kazee.africa/ws
 
 WORKSPACE=/path/to/your/workspace
 # Both provider paths are optional. Leave blank to discover the CLI on PATH.

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 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.
+- Joins the existing Janus VideoRoom as a headless publisher/subscriber using pure-TypeScript WebRTC, decodes inbound Opus, commits VAD-delimited 16 kHz PCM to hosted streaming STT, and routes final utterances through the owner's normal Kazee identity and conversation.
+- Speaks only the settled, guardrail-vetted answer through hosted Pocket TTS PCM and Opus RTP. Provider narration and transient progress previews are suppressed in calls; audio is never persisted.
+- Adds deterministic audio, Janus transaction, WebRTC RTP, speech framing, owner gate, lifecycle, and AI-routing tests. Updates `ws` to the patched 8.21 line across direct and Socket.IO use.
+
 ## v3.1.10 — `say` synthesizes in the bot process, not the stripped subprocess
 
 - v3.1.9 carried this exact fix but its build never published: the version pin in `test-provider-language.js` still read `3.1.8`, so the guard failed and the docker stage was skipped. Re-cut as v3.1.10 per "never retag a failed version."

package/channels/kazee/adapter.js

@@ -13,6 +13,7 @@ const { canonicalForChannel } = require("../../core/identity");
 const { inlineKeyboardToPortable } = require("../types");
 const { createKazeeSocket } = require("./socket");
 const { normalize } = require("./format");
+const { KazeeCallManager } = require("./call/manager");
 
 class KazeeAdapter {
   constructor({ id = "kazee", url, token, ownerUserId, botUserId }) {
@@ -27,6 +28,7 @@ class KazeeAdapter {
     this.botUserId = botUserId || null;
     this._listeners = { message: new Set(), action: new Set() };
     this._socket = null;
+    this._callManager = new KazeeCallManager({ adapter: this });
   }
 
   on(event, fn) {
@@ -67,11 +69,13 @@ class KazeeAdapter {
   }
 
   async stop() {
+    await this._callManager.stop();
     try { this._socket?.disconnect?.(); } catch (e) {}
     this._socket = null;
   }
 
   _wireSocket(socket) {
+    this._callManager.wire(socket);
     if (process.env.KAZEE_DEBUG_EVENTS) {
       socket.onAny((event, ...args) => {
         try { console.log(`[kazee event] ${event}`, JSON.stringify(args).slice(0, 400)); }

package/channels/kazee/call/audio.js

@@ -0,0 +1,133 @@
+"use strict";
+
+const OpusScript = require("opusscript");
+
+const WEBRTC_RATE = 48000;
+const STT_RATE = 16000;
+const FRAME_MS = 20;
+const WEBRTC_SAMPLES = WEBRTC_RATE * FRAME_MS / 1000;
+
+class OpusAudioCodec {
+  constructor({ channels = 1 } = {}) {
+    this.channels = channels;
+    this.encoder = new OpusScript(WEBRTC_RATE, channels, OpusScript.Application.VOIP);
+    this.decoder = new OpusScript(WEBRTC_RATE, channels, OpusScript.Application.VOIP);
+  }
+
+  encode(pcm48k) {
+    if (!Buffer.isBuffer(pcm48k)) pcm48k = Buffer.from(pcm48k);
+    const samples = pcm48k.length / 2 / this.channels;
+    if (samples !== WEBRTC_SAMPLES) {
+      throw new Error(`Opus input must be exactly ${WEBRTC_SAMPLES} samples per channel (20ms)`);
+    }
+    return Buffer.from(this.encoder.encode(pcm48k, samples));
+  }
+
+  decode(opus) {
+    return Buffer.from(this.decoder.decode(Buffer.from(opus)));
+  }
+
+  close() {
+    this.encoder?.delete();
+    this.decoder?.delete();
+    this.encoder = null;
+    this.decoder = null;
+  }
+}
+
+// WebRTC Opus is 48 kHz. Faster Whisper's streaming endpoint accepts PCM at
+// any declared rate, but 16 kHz cuts bandwidth and inference conversion work.
+function downsample48To16(pcm48k) {
+  if (!Buffer.isBuffer(pcm48k)) pcm48k = Buffer.from(pcm48k);
+  const input = new Int16Array(pcm48k.buffer, pcm48k.byteOffset, Math.floor(pcm48k.length / 2));
+  const output = Buffer.allocUnsafe(Math.floor(input.length / 3) * 2);
+  const samples = new Int16Array(output.buffer, output.byteOffset, output.length / 2);
+  for (let i = 0, j = 0; j < samples.length; i += 3, j += 1) {
+    samples[j] = Math.round((input[i] + input[i + 1] + input[i + 2]) / 3);
+  }
+  return output;
+}
+
+function upsampleTo48(pcm, sourceRate) {
+  if (!Buffer.isBuffer(pcm)) pcm = Buffer.from(pcm);
+  if (sourceRate === WEBRTC_RATE) return Buffer.from(pcm);
+  if (!Number.isFinite(sourceRate) || sourceRate < 8000 || sourceRate > WEBRTC_RATE) {
+    throw new Error(`Unsupported PCM source rate: ${sourceRate}`);
+  }
+  const input = new Int16Array(pcm.buffer, pcm.byteOffset, Math.floor(pcm.length / 2));
+  const outputLength = Math.max(0, Math.round(input.length * WEBRTC_RATE / sourceRate));
+  const output = Buffer.allocUnsafe(outputLength * 2);
+  const samples = new Int16Array(output.buffer, output.byteOffset, outputLength);
+  const scale = sourceRate / WEBRTC_RATE;
+  for (let i = 0; i < outputLength; i += 1) {
+    const position = i * scale;
+    const left = Math.floor(position);
+    const right = Math.min(left + 1, input.length - 1);
+    const fraction = position - left;
+    samples[i] = Math.round(input[left] + (input[right] - input[left]) * fraction);
+  }
+  return output;
+}
+
+function rmsDbfs(pcm) {
+  if (!pcm?.length) return -Infinity;
+  const samples = new Int16Array(pcm.buffer, pcm.byteOffset, Math.floor(pcm.length / 2));
+  let sum = 0;
+  for (const sample of samples) {
+    const normalized = sample / 32768;
+    sum += normalized * normalized;
+  }
+  if (!sum) return -Infinity;
+  return 20 * Math.log10(Math.sqrt(sum / samples.length));
+}
+
+class TurnDetector {
+  constructor({ thresholdDb = -38, onsetFrames = 3, silenceMs = 700, maxTurnMs = 30000 } = {}) {
+    this.thresholdDb = thresholdDb;
+    this.onsetFrames = onsetFrames;
+    this.silenceFrames = Math.ceil(silenceMs / FRAME_MS);
+    this.maxFrames = Math.ceil(maxTurnMs / FRAME_MS);
+    this.reset();
+  }
+
+  reset() {
+    this.active = false;
+    this.loudFrames = 0;
+    this.quietFrames = 0;
+    this.turnFrames = 0;
+  }
+
+  push(pcm48k) {
+    const loud = rmsDbfs(pcm48k) >= this.thresholdDb;
+    if (!this.active) {
+      this.loudFrames = loud ? this.loudFrames + 1 : 0;
+      if (this.loudFrames >= this.onsetFrames) {
+        this.active = true;
+        this.quietFrames = 0;
+        this.turnFrames = this.loudFrames;
+        return { type: "start" };
+      }
+      return null;
+    }
+    this.turnFrames += 1;
+    this.quietFrames = loud ? 0 : this.quietFrames + 1;
+    if (this.quietFrames >= this.silenceFrames || this.turnFrames >= this.maxFrames) {
+      const reason = this.turnFrames >= this.maxFrames ? "max-duration" : "silence";
+      this.reset();
+      return { type: "commit", reason };
+    }
+    return null;
+  }
+}
+
+module.exports = {
+  FRAME_MS,
+  STT_RATE,
+  WEBRTC_RATE,
+  WEBRTC_SAMPLES,
+  OpusAudioCodec,
+  TurnDetector,
+  downsample48To16,
+  rmsDbfs,
+  upsampleTo48,
+};

package/channels/kazee/call/janus-client.js

@@ -0,0 +1,136 @@
+"use strict";
+
+const crypto = require("crypto");
+const WebSocket = require("ws");
+
+function transactionId() {
+  return crypto.randomBytes(8).toString("hex");
+}
+
+class JanusClient {
+  constructor({ url, WebSocketImpl = WebSocket, requestTimeoutMs = 10000, keepaliveMs = 25000 } = {}) {
+    if (!url) throw new Error("Janus URL is required");
+    this.url = url;
+    this.WebSocketImpl = WebSocketImpl;
+    this.requestTimeoutMs = requestTimeoutMs;
+    this.keepaliveMs = keepaliveMs;
+    this.socket = null;
+    this.sessionId = null;
+    this.pending = new Map();
+    this.handleListeners = new Map();
+    this.keepalive = null;
+  }
+
+  async connect() {
+    if (this.socket) return;
+    const socket = new this.WebSocketImpl(this.url, "janus-protocol");
+    this.socket = socket;
+    socket.on("message", (data) => this._onMessage(data));
+    socket.on("close", () => this._onClose(new Error("Janus socket closed")));
+    socket.on("error", (error) => this._onClose(error));
+    await new Promise((resolve, reject) => {
+      socket.once("open", resolve);
+      socket.once("error", reject);
+    });
+    const created = await this.request({ janus: "create" }, { withSession: false });
+    this.sessionId = created?.data?.id;
+    if (!this.sessionId) throw new Error("Janus create response did not include a session id");
+    this.keepalive = setInterval(() => {
+      this.request({ janus: "keepalive" }).catch((error) => console.error("Janus keepalive:", error.message));
+    }, this.keepaliveMs);
+    this.keepalive.unref?.();
+  }
+
+  async attach(plugin = "janus.plugin.videoroom") {
+    const response = await this.request({ janus: "attach", plugin });
+    const handleId = response?.data?.id;
+    if (!handleId) throw new Error("Janus attach response did not include a handle id");
+    return handleId;
+  }
+
+  onHandle(handleId, listener) {
+    const id = String(handleId);
+    if (!this.handleListeners.has(id)) this.handleListeners.set(id, new Set());
+    this.handleListeners.get(id).add(listener);
+    return () => this.handleListeners.get(id)?.delete(listener);
+  }
+
+  message(handleId, body, jsep) {
+    return this.request({ janus: "message", handle_id: handleId, body, ...(jsep ? { jsep } : {}) });
+  }
+
+  async detach(handleId) {
+    if (!handleId || !this.sessionId) return;
+    try { await this.request({ janus: "detach", handle_id: handleId }); }
+    finally { this.handleListeners.delete(String(handleId)); }
+  }
+
+  request(payload, { withSession = true } = {}) {
+    if (!this.socket || this.socket.readyState !== this.WebSocketImpl.OPEN) {
+      return Promise.reject(new Error("Janus socket is not open"));
+    }
+    const transaction = transactionId();
+    const frame = {
+      ...payload,
+      ...(withSession && this.sessionId ? { session_id: this.sessionId } : {}),
+      transaction,
+    };
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(transaction);
+        reject(new Error(`Janus ${payload.janus} timed out`));
+      }, this.requestTimeoutMs);
+      this.pending.set(transaction, { resolve, reject, timer });
+      this.socket.send(JSON.stringify(frame), (error) => {
+        if (!error) return;
+        clearTimeout(timer);
+        this.pending.delete(transaction);
+        reject(error);
+      });
+    });
+  }
+
+  async close() {
+    if (this.keepalive) clearInterval(this.keepalive);
+    this.keepalive = null;
+    if (this.sessionId && this.socket?.readyState === this.WebSocketImpl.OPEN) {
+      try { await this.request({ janus: "destroy" }); } catch (_) {}
+    }
+    this.sessionId = null;
+    const socket = this.socket;
+    this.socket = null;
+    if (socket && socket.readyState < this.WebSocketImpl.CLOSING) socket.close();
+    this._onClose(new Error("Janus client closed"));
+  }
+
+  _onMessage(raw) {
+    let frame;
+    try { frame = JSON.parse(raw.toString()); }
+    catch (_) { return; }
+    const pending = frame.transaction && this.pending.get(frame.transaction);
+    if (pending && frame.janus !== "ack") {
+      clearTimeout(pending.timer);
+      this.pending.delete(frame.transaction);
+      if (frame.janus === "error") pending.reject(new Error(frame.error?.reason || "Janus error"));
+      else pending.resolve(frame);
+    }
+    const sender = frame.sender != null ? String(frame.sender) : null;
+    if (sender) {
+      for (const listener of this.handleListeners.get(sender) || []) {
+        try { listener(frame); } catch (error) { console.error("Janus handle listener:", error.message); }
+      }
+    }
+  }
+
+  _onClose(error) {
+    if (this.keepalive) clearInterval(this.keepalive);
+    this.keepalive = null;
+    for (const pending of this.pending.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(error);
+    }
+    this.pending.clear();
+  }
+}
+
+module.exports = { JanusClient };

package/channels/kazee/call/manager.js

@@ -0,0 +1,109 @@
+"use strict";
+
+const { canonicalForChannel } = require("../../../core/identity");
+const { KazeeCallSession } = require("./session");
+
+const DEFAULT_JANUS_URL = "wss://janus.kazee.africa/ws";
+const DEFAULT_ICE_SERVERS = [
+  { urls: "stun:coturn.kazee.africa:3478" },
+  { urls: "stun:stun.l.google.com:19302" },
+];
+
+class KazeeCallManager {
+  constructor({ adapter, SessionImpl = KazeeCallSession, janusUrl = process.env.KAZEE_JANUS_URL || DEFAULT_JANUS_URL,
+    iceServers = DEFAULT_ICE_SERVERS } = {}) {
+    this.adapter = adapter;
+    this.SessionImpl = SessionImpl;
+    this.janusUrl = janusUrl;
+    this.iceServers = iceServers;
+    this.session = 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));
+  }
+
+  async incoming(payload = {}) {
+    const callerId = String(payload.fromUserId || "");
+    const chatId = String(payload.chatId || "");
+    const roomId = Number(payload.roomId);
+    const callType = String(payload.callType || "");
+    const owner = String(this.adapter.ownerUserId || "");
+    const reject = (reason) => this.adapter._socket?.emit("call:reject", {
+      toUserId: callerId, callType, chatId, roomId, reason,
+    });
+
+    if (!callerId || !chatId || !Number.isSafeInteger(roomId)) return reject("invalid_call");
+    if (callerId !== owner) return reject("not_allowed");
+    if (callType !== "audio") return reject("unsupported_media");
+    if (this.session) return reject("busy");
+
+    const session = new this.SessionImpl({
+      roomId, chatId, callerId, botUserId: this.adapter.botUserId,
+      janusUrl: this.janusUrl, iceServers: this.iceServers,
+      onTranscript: (text) => this._transcript(text, payload),
+      onEnded: () => { if (this.session === session) this.session = null; },
+    });
+    this.session = session;
+    try {
+      await session.start();
+      this.adapter._socket?.emit("call:accept", {
+        toUserId: callerId, callType: "audio", chatId, roomId,
+      });
+    } catch (error) {
+      console.error("Kazee call connect:", error.message);
+      this.session = null;
+      await session.close("connect-failed").catch(() => {});
+      reject("connection_failed");
+    }
+  }
+
+  _transcript(text, incoming) {
+    const session = this.session;
+    if (!session || !text) return;
+    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().
+    callAdapter.suppressStreamPreview = true;
+    callAdapter.send = async (_channelId, response) => {
+      await session.speak(response);
+      return true;
+    };
+    callAdapter.edit = async () => true;
+    callAdapter.typing = async () => {};
+    callAdapter.sendVoice = async (_channelId, voicePath) => {
+      console.warn(`Kazee call ignored file voice response ${voicePath}; streamed TTS is active`);
+      return true;
+    };
+    this.adapter._emit("message", {
+      adapter: callAdapter,
+      channelId: String(incoming.chatId),
+      canonicalUserId: canonicalForChannel("kazee", String(incoming.fromUserId)),
+      userId: String(incoming.fromUserId),
+      type: "text",
+      text,
+      messageId: `call-${incoming.roomId}-${Date.now()}`,
+      from: { id: String(incoming.fromUserId), name: incoming.fromUserName || "" },
+      raw: { ...incoming, source: "kazee-call", ephemeralAudio: true },
+    });
+  }
+
+  async ended(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-ended");
+  }
+
+  async stop() {
+    if (!this.session) return;
+    const session = this.session;
+    this.session = null;
+    await session.close("adapter-stopped");
+  }
+}
+
+module.exports = { KazeeCallManager, DEFAULT_ICE_SERVERS, DEFAULT_JANUS_URL };

package/channels/kazee/call/session.js

@@ -0,0 +1,158 @@
+"use strict";
+
+const { MediaStreamTrack, RTCPeerConnection, RtpHeader, RtpPacket } = require("werift");
+const { JanusClient } = require("./janus-client");
+const { OpusAudioCodec, TurnDetector, WEBRTC_SAMPLES, downsample48To16, upsampleTo48 } = require("./audio");
+const { SpeechStream, synthesizePcm } = require("./speech-client");
+
+const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+class KazeeCallSession {
+  constructor({ roomId, chatId, callerId, botUserId, janusUrl, iceServers = [], onTranscript, onEnded,
+    JanusClientImpl = JanusClient, PeerConnectionImpl = RTCPeerConnection, SpeechStreamImpl = SpeechStream } = {}) {
+    this.roomId = Number(roomId);
+    this.chatId = String(chatId);
+    this.callerId = String(callerId);
+    this.botUserId = String(botUserId);
+    this.janus = new JanusClientImpl({ url: janusUrl });
+    this.PeerConnectionImpl = PeerConnectionImpl;
+    this.SpeechStreamImpl = SpeechStreamImpl;
+    this.iceServers = iceServers;
+    this.onTranscript = onTranscript || (() => {});
+    this.onEnded = onEnded || (() => {});
+    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.sequence = Math.floor(Math.random() * 65535);
+    this.timestamp = Math.floor(Math.random() * 0xffffffff);
+    this.ssrc = Math.floor(Math.random() * 0xffffffff);
+  }
+
+  async start() {
+    await this.janus.connect();
+    this.publisherHandle = await this.janus.attach();
+    this.janus.onHandle(this.publisherHandle, (frame) => this._onPublisherEvent(frame));
+    const joined = await this.janus.message(this.publisherHandle, {
+      request: "join", ptype: "publisher", room: this.roomId, display: `open-claudia:${this.botUserId}`,
+    });
+    await this._consumePublisherFrame(joined);
+    await this.stt.connect();
+  }
+
+  async _onPublisherEvent(frame) {
+    try { await this._consumePublisherFrame(frame); }
+    catch (error) { console.error("Kazee call publisher:", error.message); await this.close("janus-error"); }
+  }
+
+  async _consumePublisherFrame(frame) {
+    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));
+      }
+    }
+    if (data.videoroom === "joined" && !this.publisher) await this._publish();
+    const gone = Number(data.leaving || data.unpublished || 0);
+    if (gone && this.subscribers.has(gone)) await this._removeSubscriber(gone);
+    if (data.videoroom === "destroyed") await this.close("room-destroyed");
+  }
+
+  async _publish() {
+    if (this.publisher) return;
+    const pc = new this.PeerConnectionImpl({ iceServers: this.iceServers });
+    const track = new MediaStreamTrack({ kind: "audio" });
+    const sender = pc.addTrack(track);
+    this.publisher = { pc, track, sender };
+    const offer = await pc.createOffer();
+    await pc.setLocalDescription(offer);
+    const configured = await this.janus.message(this.publisherHandle, { request: "configure", audio: true, video: false }, pc.localDescription);
+    const answer = configured?.jsep;
+    if (!answer) throw new Error("Janus publisher configure did not return SDP");
+    await pc.setRemoteDescription(answer);
+  }
+
+  async _subscribe(feedId) {
+    const handle = await this.janus.attach();
+    const pc = new this.PeerConnectionImpl({ iceServers: this.iceServers });
+    const sub = { handle, pc };
+    this.subscribers.set(feedId, sub);
+    pc.onTrack.subscribe((track) => {
+      if (track.kind === "audio") track.onReceiveRtp.subscribe((packet) => this._onIncomingRtp(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);
+  }
+
+  async _onSubscriberEvent(feedId, frame) {
+    try { await this._consumeSubscriberFrame(feedId, frame); }
+    catch (error) { console.error("Kazee call subscriber:", error.message); await this._removeSubscriber(feedId); }
+  }
+
+  async _consumeSubscriberFrame(feedId, frame) {
+    const sub = this.subscribers.get(feedId);
+    if (!sub) return;
+    const data = frame?.plugindata?.data || {};
+    if (data.error) throw new Error(data.error);
+    if (frame.jsep && !sub.started) {
+      sub.started = true;
+      await sub.pc.setRemoteDescription(frame.jsep);
+      const answer = await sub.pc.createAnswer();
+      await sub.pc.setLocalDescription(answer);
+      await this.janus.message(sub.handle, { request: "start", room: this.roomId }, sub.pc.localDescription);
+    }
+  }
+
+  _onIncomingRtp(packet) {
+    if (this.closed || !packet?.payload?.length) 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}`));
+  }
+
+  async speak(text) {
+    if (this.closed || !String(text || "").trim()) return;
+    const synthesized = await synthesizePcm(String(text));
+    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);
+    }
+  }
+
+  async _removeSubscriber(feedId) {
+    const sub = this.subscribers.get(feedId);
+    if (!sub) return;
+    this.subscribers.delete(feedId);
+    try { await sub.pc.close(); } catch (_) {}
+    try { await this.janus.detach(sub.handle); } catch (_) {}
+  }
+
+  async close(reason = "ended") {
+    if (this.closed) return;
+    this.closed = true;
+    this.stt.close();
+    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 (_) {}
+    try { await this.janus.close(); } catch (_) {}
+    this.codec.close();
+    this.onEnded(reason);
+  }
+}
+
+module.exports = { KazeeCallSession };

package/channels/kazee/call/speech-client.js

@@ -0,0 +1,79 @@
+"use strict";
+
+const WebSocket = require("ws");
+const { SPEECH_SERVICE_URL } = require("../../../core/config");
+const { speechBearerToken } = require("../../../core/media");
+const ttsVoice = require("../../../core/tts-voice");
+
+class SpeechStream {
+  constructor({ baseUrl = SPEECH_SERVICE_URL, token = speechBearerToken(), WebSocketImpl = WebSocket, onTranscript } = {}) {
+    this.baseUrl = String(baseUrl || "").replace(/\/$/, "");
+    this.token = token;
+    this.WebSocketImpl = WebSocketImpl;
+    this.onTranscript = onTranscript || (() => {});
+    this.socket = null;
+    this.ready = null;
+  }
+
+  async connect() {
+    if (this.ready) return this.ready;
+    if (!this.baseUrl || !this.token) throw new Error("Hosted speech service is not configured");
+    const url = this.baseUrl.replace(/^http/, "ws") + "/v1/audio/transcriptions/stream";
+    this.ready = new Promise((resolve, reject) => {
+      const ws = new this.WebSocketImpl(url, { headers: { Authorization: `Bearer ${this.token}` } });
+      this.socket = ws;
+      ws.once("open", () => {
+        ws.send(JSON.stringify({ sample_rate: 16000, language: "en" }));
+        resolve();
+      });
+      ws.once("error", reject);
+      ws.on("message", (raw) => this._onMessage(raw));
+      ws.on("close", () => { this.socket = null; this.ready = null; });
+    });
+    return this.ready;
+  }
+
+  async audio(pcm16k) {
+    await this.connect();
+    if (this.socket?.readyState === this.WebSocketImpl.OPEN) this.socket.send(pcm16k);
+  }
+
+  async commit() {
+    await this.connect();
+    this.socket.send(JSON.stringify({ type: "commit" }));
+  }
+
+  _onMessage(raw) {
+    let message;
+    try { message = JSON.parse(raw.toString()); } catch (_) { return; }
+    const text = String(message.text || message.transcript || "").trim();
+    if (text && (message.final === true || message.type === "final" || message.type === "transcription")) {
+      Promise.resolve(this.onTranscript(text)).catch((error) => console.error("Kazee call transcript:", error.message));
+    }
+  }
+
+  close() {
+    const ws = this.socket;
+    this.socket = null;
+    this.ready = null;
+    if (ws?.readyState === this.WebSocketImpl.OPEN) ws.send(JSON.stringify({ type: "close" }));
+    try { ws?.close(); } catch (_) {}
+  }
+}
+
+async function synthesizePcm(text, { baseUrl = SPEECH_SERVICE_URL, token = speechBearerToken(), fetchImpl = fetch } = {}) {
+  if (!baseUrl || !token) throw new Error("Hosted speech service is not configured");
+  const response = await fetchImpl(`${String(baseUrl).replace(/\/$/, "")}/v1/audio/speech`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+    body: JSON.stringify({ input: text, voice: ttsVoice.getVoice(), response_format: "pcm" }),
+    signal: AbortSignal.timeout(60000),
+  });
+  if (!response.ok) throw new Error(`Hosted TTS failed: HTTP ${response.status}`);
+  const contentType = response.headers?.get?.("content-type") || "";
+  const rate = Number(contentType.match(/(?:^|;)\s*rate=(\d+)/i)?.[1] || 24000);
+  if (!Number.isFinite(rate) || rate < 8000 || rate > 48000) throw new Error(`Hosted TTS returned invalid PCM rate: ${rate}`);
+  return { pcm: Buffer.from(await response.arrayBuffer()), sampleRate: rate };
+}
+
+module.exports = { SpeechStream, synthesizePcm };

package/core/actions.js

@@ -416,6 +416,27 @@ async function handleAction(envelope) {
     await send(`Tooling mode: ${m}${m === "relaxed" ? " ⚠️ deny-gate is log-only; ad-hoc scripting allowed" : " — tool-first enforced"}`);
     return;
   }
+  if (d.startsWith("vc:")) {
+    if (!isChatOwner(envelope.channelId)) return send("Owner only — the voice is shared across this bot.");
+    const ttsVoice = require("./tts-voice");
+    const rest = d.slice(3);
+    if (rest === "clone") {
+      state.pendingVoiceClone = { at: Date.now() };
+      return send("🎙️ Send me a voice note now — 5–15s of clear speech and I'll clone it as your voice. Send /voice to cancel.");
+    }
+    state.pendingVoiceClone = null;
+    if (rest === "default") {
+      ttsVoice.clearVoice();
+      return send(`🎙️ Voice reset to default (${ttsVoice.getVoiceLabel()}).`);
+    }
+    if (rest.startsWith("p:")) {
+      const preset = ttsVoice.presetByKey(rest.slice(2));
+      if (!preset) return send("That voice button is stale. Open /voice again.");
+      ttsVoice.setVoice(preset.id, preset.label);
+      return send(`🎙️ Voice set: ${preset.label}`);
+    }
+    return;
+  }
   if (d.startsWith("apr:")) {
     // Approval buttons. Owner-only: the exact payload was shown in the prompt;
     // decide() is idempotent so double-taps can't flip it. Two shapes share

package/core/handlers.js

@@ -1322,6 +1322,49 @@ register({
   },
 });
 
+register({
+  name: "voice", description: "Pick the Pocket TTS voice, or clone your own", args: "[<preset>|<hf://…>|clone|default]", ownerOnly: true,
+  handler: async (env, { tail }) => {
+    if (!authorized(env)) return;
+    const ttsVoice = require("./tts-voice");
+    const state = currentState();
+    const arg = (tail || "").trim();
+    if (arg) {
+      const low = arg.toLowerCase();
+      if (low === "clone") {
+        state.pendingVoiceClone = { at: Date.now() };
+        return send("🎙️ Send me a voice note now — 5–15s of clear speech and I'll clone it as your voice. Send /voice to cancel.");
+      }
+      state.pendingVoiceClone = null;
+      if (low === "default" || low === "reset") {
+        ttsVoice.clearVoice();
+        return send(`🎙️ Voice reset to default (${ttsVoice.getVoiceLabel()}).`);
+      }
+      const preset = ttsVoice.presetByKey(low);
+      if (preset) {
+        ttsVoice.setVoice(preset.id, preset.label);
+        return send(`🎙️ Voice set: ${preset.label}`);
+      }
+      // Anything else is treated as a raw voice reference pocket-tts understands:
+      // a built-in shorthand, an hf:// path, an http(s) URL, or a stored id.
+      ttsVoice.setVoice(arg, null);
+      return send(`🎙️ Voice set: ${arg}`);
+    }
+    state.pendingVoiceClone = null;
+    const rows = ttsVoice.presets().map((p) => [{ text: p.label, callback_data: `vc:p:${p.key}` }]);
+    rows.push([
+      { text: "🎙️ Clone from a clip", callback_data: "vc:clone" },
+      { text: "↩︎ Default", callback_data: "vc:default" },
+    ]);
+    send(
+      `🎙️ Voice: ${ttsVoice.getVoiceLabel()}\n\n` +
+      "Pick a voice — it takes effect immediately, no restart. Or tap Clone from a clip (or send /voice clone) to use your own recorded voice.\n\n" +
+      "For any other voice: /voice hf://kyutai/tts-voices/<folder>/<clip>.wav",
+      { keyboard: { inline_keyboard: rows } },
+    );
+  },
+});
+
 register({
   name: "budget", description: "Set max spend for next task", args: "[$N]",
   handler: async (env, { tail }) => {

package/core/media.js

@@ -4,7 +4,8 @@
 const fs = require("fs");
 const path = require("path");
 const { execSync } = require("child_process");
-const { WHISPER_CLI, WHISPER_MODEL, FFMPEG, TEMP_DIR, ELEVENLABS_API_KEY, ELEVENLABS_VOICE_ID, ELEVENLABS_MODEL, SPEECH_SERVICE_URL, SPEECH_API_KEY, AGENTSPACE_POD_TOKEN, POCKET_TTS_VOICE, TTS_PROVIDER } = require("./config");
+const { WHISPER_CLI, WHISPER_MODEL, FFMPEG, TEMP_DIR, ELEVENLABS_API_KEY, ELEVENLABS_VOICE_ID, ELEVENLABS_MODEL, SPEECH_SERVICE_URL, SPEECH_API_KEY, AGENTSPACE_POD_TOKEN, TTS_PROVIDER } = require("./config");
+const ttsVoice = require("./tts-voice");
 
 const TTS_CMD = process.platform === "darwin" ? "say" : null;
 
@@ -108,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: POCKET_TTS_VOICE, response_format: "wav" }),
+      body: JSON.stringify({ input: clean, voice: ttsVoice.getVoice(), response_format: "wav" }),
       signal: AbortSignal.timeout(60000),
     });
     if (!res.ok) {
@@ -129,6 +130,52 @@ async function pocketToVoice(clean) {
   }
 }
 
+// Upload a reference clip to the speech gateway for voice cloning. The gateway
+// stores the clip on the TTS pod's model-cache volume and returns a voice id
+// usable as the `voice` field on later /v1/audio/speech calls; pocket-tts clones
+// from it. Returns the id string, or null on any failure.
+async function cloneVoiceFromClip(clipPath) {
+  const token = speechBearerToken();
+  if (!SPEECH_SERVICE_URL || !token || !clipPath) return null;
+  // Telegram voice notes arrive as ogg/opus, which pocket-tts can't decode as a
+  // reference prompt — transcode to 24kHz mono wav (the model's native rate)
+  // first. Fall back to the raw clip only if ffmpeg is unavailable.
+  let wavPath = null;
+  let uploadPath = clipPath;
+  if (FFMPEG) {
+    try {
+      wavPath = path.join(TEMP_DIR, `voice-clone-${Date.now()}-${Math.random().toString(36).slice(2, 6)}.wav`);
+      execSync(`"${FFMPEG}" -i "${clipPath}" -ar 24000 -ac 1 -y "${wavPath}" 2>/dev/null`, { timeout: 30000 });
+      uploadPath = wavPath;
+    } catch (e) {
+      console.error("Voice clone transcode error:", e.message);
+      wavPath = null;
+      uploadPath = clipPath;
+    }
+  }
+  try {
+    const body = new FormData();
+    body.append("file", new Blob([fs.readFileSync(uploadPath)]), path.basename(uploadPath));
+    const res = await fetch(`${SPEECH_SERVICE_URL.replace(/\/$/, "")}/v1/voices`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${token}` },
+      body,
+      signal: AbortSignal.timeout(120000),
+    });
+    if (!res.ok) {
+      console.error(`Voice clone upload failed: HTTP ${res.status}`);
+      return null;
+    }
+    const payload = await res.json().catch(() => ({}));
+    return String(payload.voice_id || payload.id || "").trim() || null;
+  } catch (e) {
+    console.error("Voice clone error:", e.message);
+    return null;
+  } finally {
+    if (wavPath) { try { fs.unlinkSync(wavPath); } catch (e) {} }
+  }
+}
+
 // True when at least one textToVoice route can produce audio. Mirrors the
 // pocket -> ElevenLabs -> say fallback chain; local Whisper is deliberately
 // irrelevant here (hosted pods speak via the gateway without it).
@@ -203,4 +250,4 @@ async function synthSentenceMp3(text) {
   }
 }
 
-module.exports = { transcribeAudio, transcribeAudioLocal, textToVoice, splitSentences, synthSentenceMp3, pocketToVoice, speechBearerToken, canSpeak, TTS_CMD };
+module.exports = { transcribeAudio, transcribeAudioLocal, textToVoice, splitSentences, synthSentenceMp3, pocketToVoice, cloneVoiceFromClip, speechBearerToken, canSpeak, TTS_CMD };

package/core/router.js

@@ -13,7 +13,7 @@ const introFlow = require("./intro-flow");
 const { send, deleteMessage } = require("./io");
 const { currentState, saveState, autoLinkOwnerChannel } = require("./state");
 const { admitRunContext, runAgent } = require("./runner");
-const { transcribeAudio } = require("./media");
+const { transcribeAudio, cloneVoiceFromClip } = require("./media");
 const { vault } = require("./vault-store");
 const { isOnboarded, handleOnboarding } = require("./onboarding");
 const {
@@ -185,6 +185,13 @@ async function handleVoice(envelope) {
     if (media.size && media.size > MAX_VOICE_SIZE) {
       return send(`Voice note too large (${Math.round(media.size / 1024 / 1024)}MB). Max: ${MAX_VOICE_SIZE / 1024 / 1024}MB`);
     }
+    // /voice clone armed this channel: the next clip is a cloning sample, not a
+    // prompt. Consume the flag (fresh only) before the normal transcribe path.
+    if (state.pendingVoiceClone) {
+      const fresh = Date.now() - state.pendingVoiceClone.at < 5 * 60 * 1000;
+      state.pendingVoiceClone = null;
+      if (fresh) return captureVoiceClone(envelope, media);
+    }
     const runContext = admitRunContext("", state.currentSession.dir, envelope.messageId, {
       purpose: "foreground",
       attachments: [{ type: "voice", mimeType: media.mimeType || "audio/ogg", fileName: media.fileName || null }],
@@ -216,6 +223,11 @@ async function handleAudio(envelope) {
   try {
     const media = envelope.media?.[0];
     if (!media) return;
+    if (state.pendingVoiceClone) {
+      const fresh = Date.now() - state.pendingVoiceClone.at < 5 * 60 * 1000;
+      state.pendingVoiceClone = null;
+      if (fresh) return captureVoiceClone(envelope, media);
+    }
     const runContext = admitRunContext("", state.currentSession.dir, envelope.messageId, {
       purpose: "foreground",
       attachments: [{ type: "audio", mimeType: media.mimeType || null, fileName: media.fileName || null }],
@@ -233,6 +245,26 @@ async function handleAudio(envelope) {
   } catch (err) { await send(`Audio failed: ${err.message}`); }
 }
 
+// A clip the owner sent right after /voice clone. Upload it to the speech
+// gateway (which stores it on the TTS pod and returns a voice id), then set that
+// id as the active voice. Never transcribed or sent to the agent.
+async function captureVoiceClone(envelope, media) {
+  try {
+    envelope.adapter.typing(envelope.channelId).catch(() => {});
+    await send("🎙️ Got it — cloning your voice…");
+    const clipPath = await envelope.adapter.downloadMedia(media);
+    const voiceId = await cloneVoiceFromClip(clipPath);
+    try { fs.unlinkSync(clipPath); } catch (e) {}
+    if (!voiceId) {
+      return send("Couldn't process that clip for cloning. Send a clear 5–15s recording and try /voice clone again.");
+    }
+    require("./tts-voice").setVoice(voiceId, "your cloned voice");
+    return send("✅ Cloned. I'll speak in that voice from now on — change it anytime with /voice.");
+  } catch (err) {
+    await send(`Voice clone failed: ${err.message}`);
+  }
+}
+
 async function handlePhoto(envelope) {
   if (isDuplicate(envelope)) return;
   const state = currentState();

package/core/runner.js

@@ -1765,7 +1765,9 @@ const STREAM_PREVIEW_FOOTER = "\n\n⏳ working — /stop to cancel";
 // the narration as it happens instead of silence. finalizeStreamPreview
 // settles the message when the run ends.
 function createStreamPreview({ state, store }) {
-  let enabled = !!store && (store?.adapter?.type || "") !== "voice";
+  let enabled = !!store
+    && (store?.adapter?.type || "") !== "voice"
+    && store?.adapter?.suppressStreamPreview !== true;
   if (enabled) {
     // Interim text is NOT vetted by guardOutboundReply (only the final answer
     // is), so it must never reach a guarded external speaker. Fail closed if

package/core/tts-voice.js

@@ -0,0 +1,98 @@
+"use strict";
+
+// Live-read, persisted Pocket TTS voice selection.
+//
+// The active voice overrides the POCKET_TTS_VOICE env default and is read at
+// synth time (media.js), so /voice takes effect immediately with no restart.
+// The choice survives restarts via a small JSON file in the bot config dir;
+// env stays the deploy-time default/floor and is used only when no override is
+// set. A cloned-clip voice is just another voice string (a server-issued id).
+
+const fs = require("fs");
+const path = require("path");
+const { CONFIG_DIR, POCKET_TTS_VOICE } = require("./config");
+const { atomicWriteFileSync } = require("./fsutil");
+
+const STORE = path.join(CONFIG_DIR, "tts-voice.json");
+
+// Curated shortlist for the /voice picker. `id` is exactly what pocket-tts's
+// get_state_for_audio_prompt resolves: the built-in "alba" shorthand or an
+// hf:// reference into the kyutai/tts-voices repo. Every path here was verified
+// against that repo's file tree, so the buttons always resolve.
+const PRESETS = [
+  { key: "alba", label: "Alba (default)", id: "alba" },
+  { key: "announcer", label: "Alba · announcer", id: "hf://kyutai/tts-voices/alba-mackenna/announcer.wav" },
+  { key: "merchant", label: "Alba · merchant", id: "hf://kyutai/tts-voices/alba-mackenna/merchant.wav" },
+  { key: "expresso", label: "Expresso", id: "hf://kyutai/tts-voices/expresso/ex01-ex02_default_001_channel1_168s.wav" },
+  { key: "enunciated", label: "Expresso · clear", id: "hf://kyutai/tts-voices/expresso/ex01-ex02_enunciated_001_channel1_432s.wav" },
+  { key: "vctk-p225", label: "VCTK p225", id: "hf://kyutai/tts-voices/vctk/p225_023.wav" },
+  { key: "vctk-p226", label: "VCTK p226", id: "hf://kyutai/tts-voices/vctk/p226_023.wav" },
+];
+
+// undefined = not loaded yet; null = loaded, no override (use env default);
+// { voice, label } = an active override.
+let cache;
+
+function defaultVoice() {
+  return (POCKET_TTS_VOICE && String(POCKET_TTS_VOICE).trim()) || "alba";
+}
+
+function load() {
+  if (cache !== undefined) return cache;
+  try {
+    const raw = JSON.parse(fs.readFileSync(STORE, "utf-8"));
+    if (raw && typeof raw.voice === "string" && raw.voice.trim()) {
+      cache = { voice: raw.voice.trim(), label: typeof raw.label === "string" && raw.label ? raw.label : null };
+      return cache;
+    }
+  } catch (e) { /* no store yet, or malformed — fall back to default */ }
+  cache = null;
+  return cache;
+}
+
+// The active voice string handed to the speech gateway.
+function getVoice() {
+  const s = load();
+  return (s && s.voice) || defaultVoice();
+}
+
+// Human-friendly label for the active voice (preset label, custom note, or id).
+function getVoiceLabel() {
+  const s = load();
+  if (s) return s.label || s.voice;
+  const dv = defaultVoice();
+  const p = PRESETS.find((x) => x.id === dv || x.key === dv);
+  return p ? p.label : dv;
+}
+
+// True when the active voice is an explicit override (not the env default).
+function isOverridden() {
+  return !!load();
+}
+
+function setVoice(voice, label = null) {
+  const v = String(voice || "").trim();
+  if (!v) throw new Error("voice is required");
+  cache = { voice: v, label: label ? String(label).trim() : null };
+  atomicWriteFileSync(STORE, JSON.stringify(cache, null, 2), { backup: false, mode: 0o600 });
+  return cache;
+}
+
+// Drop the override and fall back to the env/config default.
+function clearVoice() {
+  cache = null;
+  try { fs.unlinkSync(STORE); } catch (e) { /* already absent */ }
+}
+
+function presets() { return PRESETS.slice(); }
+function presetByKey(key) { return PRESETS.find((p) => p.key === String(key || "").toLowerCase()) || null; }
+
+// Test seam: forget the in-memory cache so the next read re-consults disk.
+function _resetCache() { cache = undefined; }
+
+module.exports = {
+  getVoice, getVoiceLabel, isOverridden,
+  setVoice, clearVoice,
+  presets, presetByKey, defaultVoice,
+  STORE, _resetCache,
+};

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "3.1.10",
+  "version": "3.1.13",
   "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",
     "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",
@@ -134,10 +135,15 @@
   "engines": {
     "node": ">=24.0.0"
   },
+  "overrides": {
+    "ws": "^8.21.1"
+  },
   "dependencies": {
     "node-cron": "^4.2.1",
     "node-telegram-bot-api": "^0.67.0",
+    "opusscript": "^0.1.1",
     "socket.io-client": "^4.7.5",
-    "ws": "^8.18.0"
+    "werift": "^0.23.0",
+    "ws": "^8.21.1"
   }
 }

package/test-provider-language.js

@@ -195,7 +195,19 @@ assert.match(pkg.description, /provider-agnostic coding-agent harness/i);
 // bot process advertised voice as enabled. Synthesis moves into the credentialed
 // bot process behind a loopback "say" kind; the CLI now sends only text; the R8
 // external-contact egress guard is preserved. Plus this version-pin bump.
-assert.strictEqual(pkg.version, "3.1.10", "release version must remain unchanged without explicit approval");
+// 3.1.11 was cut for the /voice picker + voice cloning feature but its build
+// failed on this very version pin (still 3.1.10): the package.json bump landed
+// without the matching pin update, so the docker stage was skipped and no image
+// was published. Never retag a failed version — re-cut as +1.
+// 3.1.12 approved by Sumeet 2026-07-21: re-cut of 3.1.11. Owner-gated /voice
+// preset picker over the Pocket TTS catalog (live-read, persists across restart,
+// Custom hf:// escape hatch) plus voice cloning — send a clip and it's transcoded
+// (ogg->24kHz mono wav) and registered via the speech gateway /v1/voices as the
+// active stored:<digest> voice. Plus this version-pin bump.
+// 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");
 for (const keyword of ["claude", "codex", "coding-agent", "provider-agnostic"]) {
   assert.ok(pkg.keywords.includes(keyword), `package keyword missing: ${keyword}`);
 }