@inetafrica/open-claudia 3.5.47 → 3.5.58

package/channels/kazee/call/thread-context.js

@@ -0,0 +1,100 @@
+"use strict";
+
+// A call placed inside a chat thread works inside that thread (13 Oct 2026,
+// Sumeet: "a call about CRM and Books" should start from the CRM thread's
+// own context, not from the main chat). While the phone rings, the call
+// gathers once: the thread's title, where it stood at its last compaction
+// (the archived brief, core/runner.js archiveCompactionBrief) and its last
+// few turns. The quick voice opens with it, and every full-agent turn on the
+// call carries the same note (core/system-prompt.js voiceReplyGuidance), so
+// neither has to look the thread up mid-call.
+
+const fs = require("fs");
+const path = require("path");
+
+const THREAD_ENTRIES = 12;
+const BRIEF_QUICK_CHARS = 1500;
+const BRIEF_AGENT_CHARS = 6000;
+const TITLE_MAX_MS = 1000;
+
+function briefsDir() {
+  return path.join(require("../../../config-dir"), "briefs");
+}
+
+// The newest archived brief of one conversation: its files are named after
+// the conversation's transcript (`<transcript basename>-<ISO stamp>.md`), so a
+// thread's briefs never mix with its chat's or another thread's.
+function newestBrief(transcriptPath, dir = briefsDir()) {
+  if (!transcriptPath) return null;
+  const prefix = `${path.basename(String(transcriptPath), ".jsonl")}-`;
+  let names = [];
+  try { names = fs.readdirSync(dir); } catch (_) { return null; }
+  // A stamp right after the prefix: another conversation whose name merely
+  // starts the same way (a longer id) never matches.
+  const stamped = names.filter((name) => name.startsWith(prefix) && name.endsWith(".md") && /^\d{4}-\d{2}-\d{2}T/.test(name.slice(prefix.length)));
+  if (!stamped.length) return null;
+  stamped.sort();
+  const file = path.join(dir, stamped[stamped.length - 1]);
+  try {
+    const stat = fs.statSync(file);
+    return { path: file, text: fs.readFileSync(file, "utf8"), at: stat.mtimeMs };
+  } catch (_) { return null; }
+}
+
+// The head of a brief, without its archive header, cut at a line end. Briefs
+// lead with where things stand, so the head is the part a call needs.
+function briefHead(text, max) {
+  const lines = String(text || "").split("\n");
+  while (lines.length && (/^# Compaction brief\b/.test(lines[0]) || /^Project: /.test(lines[0]) || !lines[0].trim())) lines.shift();
+  const body = lines.join("\n").trim();
+  if (body.length <= max) return body;
+  const cut = body.slice(0, max);
+  const end = cut.lastIndexOf("\n");
+  return `${(end > max / 2 ? cut.slice(0, end) : cut).trimEnd()}\n…`;
+}
+
+function ago(ms, now = Date.now()) {
+  const minutes = Math.max(0, Math.round((now - ms) / 60000));
+  if (minutes < 1) return "just now";
+  if (minutes < 120) return `${minutes} minutes ago`;
+  const hours = Math.round(minutes / 60);
+  if (hours < 48) return `${hours} hours ago`;
+  return `${Math.round(hours / 24)} days ago`;
+}
+
+async function withTimeout(promise, ms) {
+  let timer = null;
+  try {
+    return await Promise.race([promise, new Promise((resolve) => { timer = setTimeout(() => resolve(null), ms); timer.unref?.(); })]);
+  } finally { clearTimeout(timer); }
+}
+
+// The thread's shared title (chat-central), else the start of its first
+// message. Best effort and short: a slow server leaves the call untitled.
+async function threadTitle(adapter, chatId, threadId, maxMs = TITLE_MAX_MS) {
+  if (typeof adapter?.threadTitleSource !== "function") return "";
+  try {
+    const source = await withTimeout(Promise.resolve(adapter.threadTitleSource(String(chatId), String(threadId))), maxMs);
+    const title = String(source?.title || "").trim() || String(source?.rootText || "").trim().split("\n")[0].slice(0, 80);
+    return title;
+  } catch (_) { return ""; }
+}
+
+// What every full-agent turn on a thread call is told about the thread.
+function agentNote({ title = "", brief = null, now = Date.now() } = {}) {
+  const named = title ? ` "${title}"` : "";
+  const parts = [
+    `Thread call: this call was placed inside the chat thread${named}. Work as you would in that thread: its topic is what the call is about, and anything you post goes there.`,
+  ];
+  if (brief?.text) {
+    parts.push(`Where the thread stood at its last summary (${ago(brief.at, now)}; the full brief is the file ${brief.path}):\n${briefHead(brief.text, BRIEF_AGENT_CHARS)}`);
+  } else {
+    parts.push("The thread has no summary yet; its recent turns are in your context.");
+  }
+  return parts.join("\n\n");
+}
+
+module.exports = {
+  THREAD_ENTRIES, BRIEF_QUICK_CHARS, BRIEF_AGENT_CHARS, TITLE_MAX_MS,
+  briefsDir, newestBrief, briefHead, ago, threadTitle, agentNote,
+};

package/channels/kazee/catch-up.js

@@ -0,0 +1,275 @@
+// Kazee restart catch-up: what the brain has taken in, per chat, so a message
+// that came while it was down is handled after it reconnects (12 Oct 2026).
+//
+// 12 Oct 2026, 04:09:09.429Z: Sumeet's 0:52 voice note landed in a thread of
+// his DM with the bot while the brain was stopping for the 3.5.50 upgrade. The
+// old brain got it off the socket and started on it (the voice file was saved
+// at 04:09:09.457Z), but it exited at .981Z, mid-transcription, before the
+// message became a turn the turn journal could resume. The new brain started
+// at 04:09:14Z and nothing ever looked again: socket.io does not replay events
+// a client missed, so the note was never answered.
+//
+// Now each chat keeps, in <config>/kazee-catchup.json:
+//   - takenAt: the createdAt of the newest message taken in;
+//   - holdAt: the oldest message still in flight (got but not yet taken) at
+//     the last write, so a newer message finishing first cannot move the
+//     cursor past an older one that is still being worked on;
+//   - ids: the recently taken message ids (bounded), so nothing is handled
+//     twice; floor: the newest time the ids can no longer vouch for (the
+//     chat's first record, or an id dropped off the end of the list).
+// "Taken" means the bot owns the message's outcome: the turn journal holds it
+// (it runs it again after a restart itself), or the bot finished with it (a
+// reply, a gate that stayed silent, a command). See KazeeAdapter.
+// When the socket connects, every chat with a record is read from the server
+// from that cursor on, and what was never taken goes through the live path
+// again, oldest first. Never further back than KAZEE_CATCHUP_MAX_AGE_MIN (15):
+// a long outage must not answer a pile of stale messages. A chat with no
+// record replays nothing, so the first start after this ships replays nothing.
+// KAZEE_CATCHUP=off switches it all off (nothing recorded, nothing replayed).
+
+const path = require("path");
+const { CONFIG_DIR } = require("../../core/config");
+const { atomicWriteFileSync, readJsonWithFallback } = require("../../core/fsutil");
+
+const DEFAULT_MAX_AGE_MIN = 15;
+// Taken ids remembered per chat: well over 15 minutes of a busy chat.
+const MAX_IDS = 300;
+// Chats remembered (least recently active dropped first), and how many of them
+// the catch-up reads on each connect (most recently active first).
+const MAX_CHATS = 200;
+const CATCHUP_CHATS = 50;
+// Read from a little before the cursor: two messages a moment apart can reach
+// the bot out of order. Anything already taken is skipped by id.
+const SLACK_MS = 5000;
+// A message replayed this often and still not taken may be what stops the
+// brain; it is left alone (the turn journal's MAX_ATTEMPTS rule).
+const MAX_REPLAYS = 2;
+const MAX_REPLAY_NOTES = 50;
+// Messages chat-central writes itself, not a person: never replayed. A call
+// card ("call") follows every call, and a restart often follows a call (the
+// switchboard picks up new code once the call ends); live, it only reaches the
+// bot when the bot happens to sit in the chat's room.
+const SKIP_TYPES = new Set(["call", "system", "notification", "deleted"]);
+
+function setting(name) {
+  let value = process.env[name];
+  try { value = require("../../core/config").config?.[name] ?? value; } catch (_) {}
+  return value;
+}
+
+function catchUpEnabled() {
+  return !/^(off|false|0|no)$/i.test(String(setting("KAZEE_CATCHUP") ?? "on").trim());
+}
+
+function maxAgeMs() {
+  const n = Number(setting("KAZEE_CATCHUP_MAX_AGE_MIN"));
+  return (Number.isFinite(n) && n > 0 ? n : DEFAULT_MAX_AGE_MIN) * 60000;
+}
+
+function stateFileFor(adapterId) {
+  const id = String(adapterId || "kazee");
+  return path.join(CONFIG_DIR, id === "kazee" ? "kazee-catchup.json" : `kazee-catchup-${id.replace(/[^A-Za-z0-9._-]/g, "_")}.json`);
+}
+
+// Drop ids off the front of a chat's list while `drop` says so. The floor
+// rises past each one: the list can no longer vouch it was taken.
+function dropOldest(rec, drop) {
+  while (rec.ids.length && drop(rec.ids[0])) {
+    const [, droppedMs] = rec.ids.shift();
+    if (Number.isFinite(droppedMs) && droppedMs > (msOf(rec.floor) ?? -Infinity)) rec.floor = isoOf(droppedMs);
+  }
+}
+
+const msOf = (iso) => {
+  const t = Date.parse(iso || "");
+  return Number.isFinite(t) ? t : null;
+};
+const isoOf = (ms) => new Date(ms).toISOString();
+
+class KazeeIntake {
+  constructor({ adapterId = "kazee", botUserId = null, file = null, now = Date.now } = {}) {
+    this.botUserId = botUserId ? String(botUserId) : "";
+    this.file = file || stateFileFor(adapterId);
+    this.now = now;
+    this._chats = null;
+    // chatId -> Map(messageId -> createdAt ms): got, not taken yet.
+    this._inflight = new Map();
+    // chatId -> cursor ms a catch-up has yet to read from (a running one, or
+    // the last process's in-flight messages, until caught up).
+    this._holds = new Map();
+  }
+
+  _load() {
+    if (this._chats) return this._chats;
+    const raw = readJsonWithFallback(this.file, null) || {};
+    // Another bot's record (a changed KAZEE_BOT_USER_ID) is not this bot's
+    // history: start again, replaying nothing.
+    const mine = raw.chats && typeof raw.chats === "object" && String(raw.botUserId || "") === this.botUserId;
+    this._chats = mine ? raw.chats : {};
+    // What the last process still had in flight holds each chat's cursor
+    // until this one has caught that chat up (release()): a write for another
+    // chat before then must not drop it.
+    for (const [chatId, rec] of Object.entries(this._chats)) {
+      const held = msOf(rec && rec.holdAt);
+      if (held != null) this._holds.set(chatId, held);
+    }
+    return this._chats;
+  }
+
+  _save() {
+    const chats = this._load();
+    // Ids older than twice the max age vouch for nothing a catch-up still
+    // reads (it never reads further back than the max age), so the file stays
+    // small however long the bot runs.
+    const keepFrom = this.now() - 2 * maxAgeMs();
+    for (const [chatId, rec] of Object.entries(chats)) {
+      const hold = this._holdMs(chatId);
+      if (hold == null) delete rec.holdAt;
+      else rec.holdAt = isoOf(hold);
+      if (Array.isArray(rec.ids)) dropOldest(rec, (pair) => rec.ids.length > MAX_IDS || !(pair[1] >= keepFrom));
+    }
+    const ids = Object.keys(chats);
+    if (ids.length > MAX_CHATS) {
+      ids.sort((a, b) => (Number(chats[a].at) || 0) - (Number(chats[b].at) || 0));
+      for (const old of ids.slice(0, ids.length - MAX_CHATS)) delete chats[old];
+    }
+    try { atomicWriteFileSync(this.file, JSON.stringify({ v: 1, botUserId: this.botUserId, chats })); }
+    catch (e) { console.error("kazee catch-up state save:", e.message); }
+  }
+
+  // The oldest message of this chat still in flight, or the point a catch-up
+  // has yet to read from, whichever is older; null when neither.
+  _holdMs(chatId) {
+    let hold = this._holds.has(chatId) ? this._holds.get(chatId) : null;
+    for (const ms of (this._inflight.get(chatId) || new Map()).values()) {
+      if (hold == null || ms < hold) hold = ms;
+    }
+    return hold;
+  }
+
+  record(chatId) {
+    return this._load()[String(chatId || "")] || null;
+  }
+
+  isTaken(chatId, messageId) {
+    const rec = this.record(chatId);
+    const id = String(messageId || "");
+    return !!(rec && id && (rec.ids || []).some((pair) => pair[0] === id));
+  }
+
+  // A message came in and is being worked on. A chat's first message makes
+  // its record (one write per new chat), so that even it is caught up if the
+  // brain stops before taking it.
+  open(chatId, messageId, createdAtMs) {
+    const chat = String(chatId || "");
+    const id = String(messageId || "");
+    if (!chat || !id) return;
+    const ms = Number.isFinite(createdAtMs) ? createdAtMs : this.now();
+    if (!this._inflight.has(chat)) this._inflight.set(chat, new Map());
+    this._inflight.get(chat).set(id, ms);
+    const chats = this._load();
+    if (!chats[chat]) {
+      chats[chat] = { takenAt: isoOf(ms - 1), floor: isoOf(ms - 1), ids: [], at: this.now() };
+      this._save();
+    }
+  }
+
+  // The bot owns this message's outcome now. Idempotent; a write only when
+  // something changed.
+  taken(chatId, messageId, createdAtMs = null) {
+    const chat = String(chatId || "");
+    const id = String(messageId || "");
+    if (!chat || !id) return;
+    const flying = this._inflight.get(chat);
+    const flyingMs = flying ? flying.get(id) : undefined;
+    if (flying) {
+      flying.delete(id);
+      if (!flying.size) this._inflight.delete(chat);
+    }
+    if (this.isTaken(chat, id)) return;
+    // Not seen in flight (a turn the journal resumed after a restart): the
+    // taking time stands in for its createdAt, which only ever keeps more.
+    const ms = Number.isFinite(createdAtMs) ? createdAtMs : (flyingMs !== undefined ? flyingMs : this.now());
+    const chats = this._load();
+    const rec = chats[chat] || (chats[chat] = { takenAt: isoOf(ms - 1), floor: isoOf(ms - 1), ids: [] });
+    rec.ids = Array.isArray(rec.ids) ? rec.ids : [];
+    rec.ids.push([id, ms]);
+    if (ms > (msOf(rec.takenAt) ?? -Infinity)) rec.takenAt = isoOf(ms);
+    if (rec.replays) delete rec.replays[id];
+    rec.at = this.now();
+    this._save();
+  }
+
+  // Chats to read on connect, most recently active first.
+  chats(limit = CATCHUP_CHATS) {
+    const chats = this._load();
+    return Object.keys(chats)
+      .sort((a, b) => (Number(chats[b].at) || 0) - (Number(chats[a].at) || 0))
+      .slice(0, limit);
+  }
+
+  // Start catching a chat up: where to read from (ms), held until release()
+  // so a live message taken meanwhile cannot move the saved cursor past what
+  // this catch-up has yet to read. null when the chat has no record.
+  hold(chatId) {
+    const chat = String(chatId || "");
+    const rec = this.record(chat);
+    if (!rec) return null;
+    const taken = msOf(rec.takenAt);
+    const held = this._holdMs(chat);
+    const cursor = Math.min(...[taken, held].filter((v) => v != null));
+    if (!Number.isFinite(cursor)) return null;
+    this._holds.set(chat, Math.min(cursor, this._holds.get(chat) ?? Infinity));
+    return Math.max(cursor - SLACK_MS, msOf(rec.floor) ?? -Infinity, this.now() - maxAgeMs());
+  }
+
+  // The chat was read and everything due went out: the hold ends. A failed
+  // read keeps it (the next connect tries again from the same point).
+  release(chatId) {
+    const chat = String(chatId || "");
+    if (!this._holds.delete(chat)) return;
+    const rec = this.record(chat);
+    const hold = this._holdMs(chat);
+    if (rec && (rec.holdAt || null) !== (hold == null ? null : isoOf(hold))) this._save();
+  }
+
+  // The bot left the chat (or it is gone): nothing more to catch up there.
+  forget(chatId) {
+    const chat = String(chatId || "");
+    const chats = this._load();
+    this._holds.delete(chat);
+    if (!chats[chat]) return;
+    delete chats[chat];
+    this._save();
+  }
+
+  // Count one more replay of a message; false when it was replayed
+  // MAX_REPLAYS times already (it is then taken, and left alone).
+  noteReplay(chatId, messageId, createdAtMs) {
+    const rec = this.record(chatId);
+    if (!rec) return true;
+    rec.replays = rec.replays && typeof rec.replays === "object" ? rec.replays : {};
+    const n = (Number(rec.replays[messageId]) || 0) + 1;
+    if (n > MAX_REPLAYS) {
+      this.taken(chatId, messageId, createdAtMs);
+      return false;
+    }
+    rec.replays[messageId] = n;
+    const notes = Object.keys(rec.replays);
+    for (const old of notes.slice(0, Math.max(0, notes.length - MAX_REPLAY_NOTES))) delete rec.replays[old];
+    this._save();
+    return true;
+  }
+}
+
+module.exports = {
+  KazeeIntake,
+  catchUpEnabled,
+  maxAgeMs,
+  stateFileFor,
+  SKIP_TYPES,
+  MAX_IDS,
+  MAX_REPLAYS,
+  SLACK_MS,
+  CATCHUP_CHATS,
+};

package/core/actions.js

@@ -493,7 +493,9 @@ async function handleAction(envelope) {
     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);
+    const catalog = await require("./media").voiceCatalog();
     if (rest === "clone") {
+      if (catalog?.cloning === false) return send("🎙️ The voice server can't copy voices yet, so cloning from a clip isn't available.");
       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.");
     }
@@ -503,10 +505,17 @@ async function handleAction(envelope) {
       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}`);
+      // A server voice name, or an older button's preset key.
+      const key = rest.slice(2);
+      const preset = catalog?.voices?.includes(key) ? null : ttsVoice.presetByKey(key);
+      const voice = preset ? preset.id : key;
+      if (!preset && !catalog) return send("No voice server is set up for this bot, so that voice can't be used.");
+      if (!preset && !catalog.voices.includes(key)) return send("That voice button is stale. Open /voice again.");
+      const refused = ttsVoice.checkChoice(catalog, voice);
+      if (refused) return send(refused);
+      const label = ttsVoice.voiceLabel(voice, catalog);
+      ttsVoice.setVoice(voice, label);
+      return send(`🎙️ Voice set: ${label}`);
     }
     return;
   }

package/core/handlers.js

@@ -1468,9 +1468,11 @@ register({
     const ttsVoice = require("./tts-voice");
     const state = currentState();
     const arg = (tail || "").trim();
+    const catalog = await require("./media").voiceCatalog();
     if (arg) {
       const low = arg.toLowerCase();
       if (low === "clone") {
+        if (catalog?.cloning === false) return send("🎙️ The voice server can't copy voices yet, so cloning from a clip isn't available. Pick one of its voices with /voice.");
         laneFor(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.");
       }
@@ -1479,27 +1481,23 @@ register({
         ttsVoice.clearVoice();
         return send(`🎙️ Voice reset to default (${ttsVoice.getVoiceLabel()}).`);
       }
+      // A server voice name, an older preset key, or a raw reference pocket-tts
+      // understands (an hf:// path, an http(s) URL, a stored id) when it can clone.
       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}`);
+      const voice = catalog?.voices?.includes(low) ? low : preset ? preset.id : arg;
+      const refused = ttsVoice.checkChoice(catalog, voice);
+      if (refused) return send(refused);
+      const label = ttsVoice.voiceLabel(voice, catalog);
+      ttsVoice.setVoice(voice, label);
+      return send(`🎙️ Voice set: ${label}`);
     }
     laneFor(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" },
-    ]);
+    if (!catalog) return send(`🎙️ Voice: ${ttsVoice.getVoiceLabel()}\n\nNo voice server is set up for this bot, so there are no voices to pick from.`);
     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 } },
+      "Pick a voice — it takes effect immediately, no restart." +
+      (catalog.cloning ? " Or tap Clone from a clip (or send /voice clone) to use your own recorded voice, or send /voice hf://kyutai/tts-voices/<folder>/<clip>.wav." : ""),
+      { keyboard: { inline_keyboard: ttsVoice.pickerRows(catalog) } },
     );
   },
 });

package/core/identity.js

@@ -40,8 +40,20 @@ function roomKeyFor(transport, channelId) {
 // Split a conversation key back into its parts. The channel id may itself
 // contain ':' (e.g. spaces "task:42"), so only the first ':' separates the
 // transport. Returns {transport, channelId, threadId|null, roomKey}.
-function parseConversationKey(key) {
+// A live call's turns run in a lane of their own beside the chat's, so a call
+// is never stuck behind work in that chat (11 Oct: the full agent never spoke
+// on a call while a long turn ran in the same chat; only the quick voice did).
+const CALL_LANE_SUFFIX = "#call";
+function callLaneKey(key) {
   const k = String(key || "");
+  return k.endsWith(CALL_LANE_SUFFIX) ? k : `${k}${CALL_LANE_SUFFIX}`;
+}
+function isCallLaneKey(key) {
+  return String(key || "").endsWith(CALL_LANE_SUFFIX);
+}
+
+function parseConversationKey(key) {
+  const k = String(key || "").replace(/#call$/, "");
   const i = k.indexOf(THREAD_SEP);
   const room = i >= 0 ? k.slice(0, i) : k;
   const threadId = i >= 0 ? k.slice(i + THREAD_SEP.length) || null : null;
@@ -226,6 +238,8 @@ module.exports = {
   conversationKeyFor,
   roomKeyFor,
   parseConversationKey,
+  callLaneKey,
+  isCallLaneKey,
   isConfiguredOwnerChannel,
   ownerCanonical,
   channelIsOwner,

package/core/loopback.js

@@ -518,7 +518,10 @@ async function handleJson(req, res, url, kind) {
       return reply(res, 501, { error: `adapter ${adapterId} does not support outgoing calls` });
     }
     try {
-      const result = await manager.outgoing({ chatId: channelId, toUserId: payload.toUserId || undefined });
+      // Placed from a thread turn: the call belongs to that thread (the run's
+      // own thread, never a payload's claim; threadForCaller).
+      const threadId = threadForCaller(callerOf(payload), channelId, payload.threadId);
+      const result = await manager.outgoing({ chatId: channelId, toUserId: payload.toUserId || undefined, reason: typeof payload.reason === "string" ? payload.reason.slice(0, 300) : undefined, ...(threadId ? { threadId } : {}) });
       return reply(res, 200, { ok: true, ...result });
     } catch (e) {
       return reply(res, 500, { error: e.message });

package/core/media.js

@@ -287,6 +287,44 @@ async function cloneVoiceFromClip(clipPath) {
   }
 }
 
+// What the speech server can speak in: { default, voices: [names], cloning }.
+// null when it can't say (unreachable, or an older server without the list).
+async function speechVoices({ fetchImpl = fetch, timeoutMs = 8000 } = {}) {
+  const token = speechBearerToken();
+  if (!SPEECH_SERVICE_URL || !token) return null;
+  try {
+    const res = await fetchImpl(`${SPEECH_SERVICE_URL.replace(/\/$/, "")}/v1/voices`, {
+      headers: { Authorization: `Bearer ${token}` },
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+    if (!res.ok) return null;
+    const body = await res.json();
+    return body && Array.isArray(body.voices) ? body : null;
+  } catch (e) {
+    return null;
+  }
+}
+
+// The list /voice shows and checks against. The server's list is kept for ten
+// minutes (a picker and its button tap are one fetch, not two). When the
+// server can't be asked, the last list it gave, else its built-in voices, so
+// the picker still offers voices it makes instead of nothing (12 Oct: the
+// 11 Oct picker offered hf:// clips the server can't make, and a call went
+// silent after one). null only when no speech server is configured.
+const VOICE_LIST_TTL_MS = 10 * 60 * 1000;
+let voiceList = null; // { at, catalog } from the server
+async function voiceCatalog({ fetchImpl = fetch, now = Date.now() } = {}) {
+  if (!SPEECH_SERVICE_URL || !speechBearerToken()) return null;
+  if (voiceList && now - voiceList.at < VOICE_LIST_TTL_MS) return voiceList.catalog;
+  const live = await speechVoices({ fetchImpl, timeoutMs: 3000 });
+  if (live) {
+    voiceList = { at: now, catalog: live };
+    return live;
+  }
+  return voiceList ? voiceList.catalog : ttsVoice.builtinCatalog();
+}
+function _resetVoiceCatalog() { voiceList = null; }
+
 // 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).
@@ -418,4 +456,4 @@ async function synthSentenceMp3(text) {
   }
 }
 
-module.exports = { transcribeAudio, transcribeAudioLocal, transcribeMedia, STT_TIMING, canTranscribe, textToVoice, textToVoiceFile, splitSentences, synthSentenceMp3, pocketToVoice, chunkForTTS, cloneVoiceFromClip, speechBearerToken, canSpeak, TTS_CMD };
+module.exports = { transcribeAudio, transcribeAudioLocal, transcribeMedia, STT_TIMING, canTranscribe, textToVoice, textToVoiceFile, splitSentences, synthSentenceMp3, pocketToVoice, chunkForTTS, cloneVoiceFromClip, speechBearerToken, speechVoices, voiceCatalog, _resetVoiceCatalog, canSpeak, TTS_CMD };

package/core/run-context.js

@@ -4,7 +4,7 @@ const crypto = require("crypto");
 const path = require("path");
 const { currentConversationKey, currentThreadId } = require("./context");
 const { resolveProviderSettings, peekLane } = require("./state");
-const { parseConversationKey } = require("./identity");
+const { parseConversationKey, callLaneKey } = require("./identity");
 
 function cloneSerializable(value, label = "run context value") {
   if (value === undefined) return undefined;
@@ -57,6 +57,26 @@ function projectSnapshot(state, cwd, requestedProject) {
 // whole main context in a session of its own. Default "fresh": a new thread
 // starts a new session, seeded only with the thread's own messages. Codex has
 // no fork, so it always starts fresh.
+// A live call answers in speech, so its turn may run a faster model and effort
+// than the room's chat turns: KAZEE_CALL_MODEL / KAZEE_CALL_EFFORT (Claude
+// only). Unset keeps the room's own settings; an unknown effort is ignored.
+const CALL_EFFORTS = new Set(["low", "medium", "high", "xhigh", "max"]);
+function callSetting(name) {
+  let value = process.env[name];
+  try { value = require("./config").config?.[name] ?? value; } catch (_) {}
+  return String(value || "").trim();
+}
+
+function callProviderOverrides(provider) {
+  if (provider !== "claude") return {};
+  const overrides = {};
+  const model = callSetting("KAZEE_CALL_MODEL");
+  const effort = callSetting("KAZEE_CALL_EFFORT").toLowerCase();
+  if (model) overrides.model = model;
+  if (CALL_EFFORTS.has(effort)) overrides.effort = effort;
+  return overrides;
+}
+
 function threadSeedMode() {
   let value = process.env.OC_THREAD_SEED;
   try { value = require("./config").config?.OC_THREAD_SEED ?? value; } catch (_) {}
@@ -127,8 +147,10 @@ function captureRunContext({
   const activeSessionId = state.activeSessions?.[project.name]?.[provider] || null;
   // The run's lane (its conversation: a thread is its own) and thread are
   // fixed here, at admission: queueing, /stop, preview, typing and delivery all
-  // follow the lane the message arrived in, never a later one.
-  const laneKey = String(opts.laneKey || currentConversationKey() || project.name || "Workspace");
+  // follow the lane the message arrived in, never a later one. A live call's
+  // turns get a lane of their own beside their chat's.
+  const conversationLane = String(opts.laneKey || currentConversationKey() || project.name || "Workspace");
+  const laneKey = liveCall ? callLaneKey(conversationLane) : conversationLane;
   const threadId = (store && store.threadId) || currentThreadId() || parseConversationKey(laneKey).threadId || null;
   const lane = peekLane(state, laneKey);
   const forkFromSessionId = threadForkSession(state, { provider, laneKey, threadId, activeSessionId, opts, liveCall });
@@ -154,6 +176,7 @@ function captureRunContext({
   // personal bucket, so non-room channels are unaffected.
   const providerSettings = cloneSerializable({
     ...(resolveProviderSettings(state, provider) || {}),
+    ...(liveCall ? callProviderOverrides(provider) : {}),
     ...(opts.providerSettings || {}),
   }, "provider settings");
   delete providerSettings.backend;
@@ -261,6 +284,7 @@ function bindRunInputs(runContext, inputs = {}) {
 }
 
 module.exports = {
+  projectSnapshot,
   captureRunContext,
   bindRunInputs,
   cloneSerializable,