@inetafrica/open-claudia 3.5.33 → 3.5.58

package/CHANGELOG.md

@@ -1,12 +1,72 @@
 # Changelog
 
-## 3.5.33
+## 3.5.58
 
-Quiet chats by default (Sumeet, 11 Oct 08:51 EAT, on Kazee unread counts: one voice note brought a "Heard:" echo, a progress message and "Recalled my notes" lines before the answer, each a new unread and often a push; 09:16 EAT "Yes" to turning them off by default on every bot). Built on 3.5.24, the fleet's version: the Browser canaries (3.5.25, 3.5.26, 3.5.28) and the call builds on Sumeet's own bot (3.5.27 and later) are not in it.
+The call work from the owner's own bot (local builds 3.5.34-3.5.57), released for every bot (Sumeet, 13 Oct 11:53 EAT, canary pod first). Also carries 3.5.33's quiet chats and 3.5.47's guard fix.
 
-- **One message in, one answer out.** By default a turn now shows "typing" while it works and sends only its answer: no "Heard: …" echo of a voice note or audio file, no live progress message, and no "📖 Recalled my notes on …", "✏️ Updating my notes on …", new pack, entity, skill or "🧩 Reused" lines. Recall-failure alerts, /recall, /tooltrace, wake-up notices and limit warnings are unchanged.
-- **Each comes back with its own command** (`core/chatter.js`): `/heard`, `/notes` and `/progress` (on, off, or no argument for the current value and buttons), saved per person like /verbose. `/verbose` streams thinking into the progress message, so it turns the progress message on too: anyone with /verbose on keeps it until they turn /verbose off.
-- **Tests:** `test-quiet-defaults.js` (new, in `npm test`), `test-thread-lanes.js` (its live-preview check turns /progress on).
+- **Quick voice on by default, on Opus 5.5.** A warm second voice runs the conversation: it greets, answers check-ins itself, hands real work to the full agent, says the full agent's answers, and decides whether new words add to, replace or ignore the work in flight. `KAZEE_CALL_QUICK_VOICE=off` brings back the full agent alone; `KAZEE_CALL_QUICK_MODEL` picks another model.
+- **Calls in threads.** A call placed in a thread with the bot loads that thread's title, brief and last messages, opens on its topic, and carries work on in the thread after the goodbye.
+- **Hearing and hanging up.** Interrupts on words, not sounds; a reply cut off by a sound is kept and said after; no asking twice; "are you still there?" after 10 s with no words, then goodbye; hangs up right after "bye" and carries promised work on in the chat; a soft line hum between lines, and a caller who mutes or holds is not taken for a dropped line.
+- **Seeing.** A caller's camera, also when switched on mid-call, gives stills the full agent can look at.
+- **Logs for every call:** each segment's loudness, every quick-voice decision, what was sent, and at the close how loud the caller came in (`Kazee call heard:`).
+- **Switchboard (owner's Mac, `OC_SWITCHBOARD=on`):** calls survive a restart of the bot. Off by default.
+- **/voice** lists only the speech server's own voices; a voice it can't make falls back instead of silencing a call.
+- **Kazee:** messages that came in while the bot restarted are caught up.
+- **Compaction:** the summary stage forks the live session, so a failed compaction never leaks its brief into the chat.
+- **Guard (from 3.5.47):** credentials stay blocked; infrastructure and customer data follow the owner's channel rules and mandates.
+
+## 3.5.32
+
+- **Call logs show every quick-voice decision:** jobs the quick voice hands to the full agent now log `route: JOB ... heard= line=` like SELF does (the 10:48 EAT call's "Let me just try changing a voice" and "I can't hear anything" left no route line).
+- **/voice lists only voices the speech server can speak in.** The picker offered seven fixed voices, six of them hf:// clips the server (no voice cloning) could not render; on the 10:48 EAT call one silenced every line. It now asks the server (`GET /v1/voices`, speech-service b244cd6) for its voices and whether it can clone: buttons for those names, two to a row, "Clone from a clip" only when it can clone, and a typed or stale choice it can't make is refused with the list. If the server can't answer, the picker says so instead of guessing. Tests: `test-speech-voices.js` (new), `test-tts-voice.js` (now in `npm test`).
+- A voice the speech server can't make (the 10:48 call went silent after /voice Expresso) is fixed on the speech server, not here: Sumeet, 11 Oct 11:18 EAT, "we build for the correct environment" (bots run on pods; the server serves them all).
+
+## 3.5.31
+
+Fixes from the 10:10 EAT test call on 3.5.30 (7 minutes; every decision routed in 0.8-1.7 s, nothing dropped). Local build for the owner's own bot first; the fleet waits for his OK.
+
+- **Lead-ins.** When an answer comes after the talk moved on, it opens with a few words naming its topic: "Back to the mail backup.", "On your voice question." (Sumeet on the call: after "I'll look into that too" the mail backup numbers came straight in, then "Yes, you can" for the voice question, with no sign of which was which.) The quick voice writes the lead-in while the line before it plays (0.8-1.7 s with Haiku 4.5); not ready in 1.5 s: "On your earlier question.". Words that already name their topic get none, and the full agent's call guidance now says to open each part of a reply that answers several questions with its topic.
+- **Requests to do something always reach the full agent.** "Alright, change the voice. Try saying something" and then "What's going on? You're taking long" were answered by the quick voice alone (SELF), so nothing was done and the caller waited. The quick prompt now sends anything to be done, changed or tried, and "you're slow / did you do it?" with nothing running, to Claudia. Real Haiku bench, 31 utterances: the old prompt failed all 4 such cases (once claiming "Yeah, just tried the new voice"), the new one passes them; 28-30 of 31 overall vs 27-28. The lead-in rule rides in its own message: as a "no tag" rule in the system prompt it made a cold "Hello?" lose its tag.
+- **A queued question starts as soon as the one before it is answered**, not once that answer has finished playing: the call's answer no longer holds the lane while it is spoken (a question asked during a long answer waited 27 s before its run began). Answers still play in order, and the next job's prompt hears the previous answer.
+- **No "run failed" notes for stopped jobs.** A job the quick voice answered itself, or the caller replaced (and /stop), left "Provider process exited with code 143" in the transcript; the words are kept, the note is not.
+- **Call logs name each decision:** `route:` lines now carry what was heard and the line said, and lead-ins are logged, so a call can be reviewed afterwards.
+- **Tests:** `test-call-quick-voice.js` (lead-ins written once and spoken before held answers, the late fallback, topic-named words, send not waiting for playback, the new prompt rules), `test-call-stopped-transcript.js` (new, in `npm test`).
+
+## 3.5.30
+
+The quick voice runs the conversation; the full agent works in the background (Sumeet, 11 Oct 09:44 EAT: "it essentially acts as the conversation… it doesn't need to get blocked by background work… bring it back and merge it with what we have, not necessarily replace"; 09:48: the small model decides whether to interrupt). A merge of the 4 Oct calls build into 3.5.29. Local build for the owner's own bot first; the fleet waits for his OK.
+
+- **Every word no longer throws the last answer away.** Before, each new utterance aborted the running call turn, but its provider kept running (20-30 s, holding the call's lane, so the next request waited 9-12 s behind it) and its answer was then discarded: on the 09:39 call "That's fine" and "Is still there" lost two answers in a row.
+- **The quick voice decides.** Each reply opens with a tag. With nothing running: SELF (a greeting, "are you there?", thanks, what we were on: it answers and the full agent's job is dropped) or JOB (anything else). While work runs: IGNORE (not meant for Claudia), ANSWER (a check-in or status, answered from the job board, the work carries on), ADD (another request, run after the current one) or REPLACE (a change of mind or "stop": only then is the work stopped). No tag in 3.5 s: ADD, so a guess never stops work. Measured on 22 utterances with Haiku 4.5: all routed right (it sometimes says SELF for ANSWER or ADD for JOB, which mean the same here), median 0.85 s.
+- **A job board.** The runner now tells the call when the full agent starts on a job and each tool it uses (`onCallStage`, `onCallActivity`), turned into plain words ("checking email", "reading files"; the 4 Oct mapping). The quick voice gets the job, how long, its steps, what it has said, what waits after it, and what was answered earlier; "still on it" lines say real progress.
+- **Nothing said is dropped.** A job's words are held while the caller talks and go out once the quick voice has answered (or straight away after noise); a finished answer still waiting is never retold by the quick voice. call-say no longer reports a held turn as stale.
+- **Stopped means stopped.** A job dropped by REPLACE or SELF has its provider killed the way /stop does (named cancel flag, then the process tree; `stopCallRunWhenDropped`, ported from 4 Oct). A call that ends keeps its run, so "do X" said just before hanging up still gets done.
+- **A queued job hears the one before it.** The call history goes into a job's prompt when the job starts, not when it was queued.
+- **Tests:** `test-call-quick-voice.js` (each decision, held answers, the board, queued jobs, the slow-decision fallback), `test-call-run-stop.js` (new, in `npm test`), `test-kazee-call-manager.js` (held, not refused, while the caller talks).
+
+## 3.5.29
+
+Calls I place open from the chat too (Sumeet, 11 Oct 09:26 EAT: "Just be calling me when you are ready to test things"). Built on 3.5.28 and the quiet-by-default chat change. A local build for the owner's own bot first; the fleet waits for his OK.
+
+- **A greeting for outgoing calls.** When the bot rings someone, the quick voice writes the opening line while the phone rings, from the end of the chat and, when given, the reason for the call: `open-claudia call --about "testing barge-in"` opens with "Hey Sumeet, calling to test the barge-in feature. Got a minute?". The line is spoken as soon as they pick up; the call rings at once and never waits for it. A reason alone is enough when the chat is old; no chat and no reason, or a line not ready in 3.5 s: the fixed greeting. Measured 1.6-2.7 s per line with Haiku 4.5, well inside the ringing.
+- **Tests:** `test-call-quick-voice.js` covers the outgoing note and line, and now fails if it ends early: the greeting deadline timer is unref'd, so a fake call waiting on it alone let node exit 0 before the file's later checks ran (true since 3.5.28).
+
+## 3.5.28
+
+Calls open with where we left off, and never wait behind the chat (Sumeet, 11 Oct 09:00 EAT, on a walk: "rather than just a sort of static greeting… while the call's ringing… a very quick review of the conversation… 'what's up, still working on blah blah'"). A local build for the owner's own bot first; the fleet waits for his OK.
+
+- **A greeting from the recent chat.** With the quick voice on, the moment a call comes in the quick voice reads the end of the call's chat (the last 6 messages, scrubbed, read from the transcript's tail without blocking) and writes the opening line: "Hey Sumeet, back to the Maya restart? What's up?". The call is answered once that line is ready, so the caller hears ringing rather than silence while it is written: measured 1.7-2.1 s from the call coming in with Haiku 4.5, about 1.3 s more ringing than before. Not ready in 3.5 s, nothing in the chat for 6 hours, or any failure: the fixed greeting, at once. The line also goes into the call's history, so the full agent knows how the call opened. The chat is read from the transcript chat turns actually write (the conversation's own project, `<hash>-kazee-<chat>.jsonl`), and wakeups and watches filed as the caller's turns are left out.
+- **A call never waits behind the chat.** A call's turns used to queue in the lane of the chat they came from, so while a long turn ran there (09:00 EAT: building this greeting), the full agent never started on any of his call turns and only the quick voice spoke. Live-call turns now run in a lane of their own beside the chat's (`<chat>#call`), and that lane never waits for a free slot under `OC_MAX_PARALLEL_TURNS` or `_GLOBAL` (one call at a time, so at most one run over the caps). /stop in the chat no longer reaches a call; hanging up still cancels its work.
+- **Tests:** `test-run-lock.js`, `test-provider-runner.js`, `test-call-greeting-context.js` (new, in `npm test`), `test-call-quick-voice.js`, `test-kazee-call-session.js`; the call tests no longer read a developer's own `.env` (a local `KAZEE_CALL_QUICK_VOICE=on` made one fail and another start a real CLI).
+
+## 3.5.27
+
+Calls answer in about two seconds again, and say something while they work (Sumeet, 11 Oct 08:24 EAT on a walk, after a call where "hello" took 8.5 s and a 79 s lookup was never heard: "Yeah, let's give it a shot"). A canary build for the owner's own bot first. It builds on 3.5.24; the Browser canaries 3.5.25 and 3.5.26 are not in it yet.
+
+- **A quick voice says a fitting line right away** (`channels/kazee/call/quick-voice.js`). A kept-warm small model, one process per call through the provider's own utility invocation, hears each utterance and says one short line ("Sure, let me check the call logs.", "Yep, I'm here.") within about a second, then a brief "still on it" line whenever the full agent leaves the caller in 8 s of silence, at most 3 per turn. It never answers: every utterance still goes to the full agent. The line is dropped if it is not ready in 3.5 s, if the full agent already spoke, if the caller is talking, or once a newer utterance took over. Off unless `KAZEE_CALL_QUICK_VOICE=on`; `KAZEE_CALL_QUICK_MODEL` (default `claude-haiku-4-5`), `_EFFORT` (`low`) and `_THINKING` (off) tune it. Measured on 23 call lines with traps ("Did you hear me?", "Are you sure?"): Haiku 4.5 finished its line in 0.8-1.1 s with thinking off (2-3 s with it on), Sonnet 5 in 1.7-1.9 s, and both kept every rule.
+- **The full agent speaks first, then works.** The live-call guidance used to forbid "speculative progress", so a lookup went silent until it ended. Now the first action is a 3-12 word call-say ("Sure, let me check the call logs."), then a progress line about every ten seconds. Replayed on the four turns of the 11 Oct call, 3 times per effort level: the holding line came first 3 of 3 times at max, xhigh, high and medium (the old guidance: 1 of 3 at xhigh), simple replies unchanged. With the quick voice on, the agent skips its own acknowledgement and starts with substance.
+- **A sound with no words no longer silences the answer.** Speech start mutes the running call turn in case it is a new ask; when the recogniser found no words (wind, footsteps, a cough) the turn stayed muted for good, its call-say got 409 and its final answer was never spoken. The session now reports a noise-only turn and the turn gets its voice back, unless someone is still talking or another segment is pending.
+- **Tests:** `test-call-quick-voice.js` (new, in `npm test`), `test-kazee-call-manager.js`, `test-kazee-call-session.js`, `test-provider-prompt-parity.js`.
 
 ## 3.5.24
 

package/bin/cli.js

@@ -16,6 +16,8 @@ function getBotMode() {
 }
 
 function startBot(args) {
+  // OC_SWITCHBOARD=on: this process holds calls and runs the bot as a child.
+  if (require(path.join(botDir, "core", "switchboard", "handoff")).maybeRunSwitchboard()) return;
   // Start web UI alongside bot if WEB_UI=true or --web flag
   if (process.env.WEB_UI === "true" || args.includes("--web")) {
     const { startWebServer } = require(path.join(botDir, "web.js"));
@@ -227,6 +229,8 @@ switch (command) {
   }
 
   case "web": {
+    // OC_SWITCHBOARD=on: this process holds calls and runs `web` as a child.
+    if (require(path.join(botDir, "core", "switchboard", "handoff")).maybeRunSwitchboard()) break;
     // Web UI only (for initial setup or config management)
     const { startWebServer: startWeb, isConfigured } = require(path.join(botDir, "web.js"));
     startWeb();
@@ -420,8 +424,11 @@ switch (command) {
     (async () => {
       const { postJson } = require("./loopback-client");
       try {
-        const toUserId = String(args[1] || "").trim();
-        const res = await postJson("call", toUserId ? { toUserId } : {});
+        const rest = args.slice(1);
+        const aboutAt = rest.indexOf("--about");
+        const reason = aboutAt >= 0 ? String(rest[aboutAt + 1] || "").trim() : "";
+        const toUserId = String(rest.find((arg, i) => !arg.startsWith("--") && rest[i - 1] !== "--about") || "").trim();
+        const res = await postJson("call", { ...(toUserId ? { toUserId } : {}), ...(reason ? { reason } : {}) });
         console.log(`Calling: room=${res.roomId} chat=${res.chatId} to=${res.toUserId}`);
         process.exit(0);
       } catch (e) {
@@ -624,7 +631,7 @@ Send tools (only work inside an active bot-spawned task):
   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)
+  open-claudia call [toUserId] [--about "<why>"]  Place a live voice call on the current channel (kazee; owner-only); --about tells the opening line why
   open-claudia card send <spec|->    Send a Kazee Card (decision, choice, rating, slider, report); answers wake this conversation
   open-claudia card update <id> ...  Close/open a card you sent, add a note, or replace its spec (card example <kind> for specs)
   open-claudia decide "<q>" --option id="label" ...   Queue a decision card for the owner (one at a time; decide list|cancel)

package/bot.js

@@ -24,6 +24,13 @@ const {
 } = require("./core/config");
 ensureRuntimeDirectories();
 
+// OC_SWITCHBOARD=on: this process becomes the switchboard (it holds the live
+// call room) and runs the bot as its child, so a restart keeps calls up.
+if (require("./core/switchboard/handoff").maybeRunSwitchboard()) return;
+// The child end: open the link now, so a switchboard that dies takes this
+// brain down with it (core/switchboard/brain-link.js).
+require("./core/switchboard/brain-link").connect();
+
 // Refuse to double-boot: a second process on this CONFIG_DIR shares the same
 // channel tokens and 409-wars the running service (see core/single-instance).
 const { acquireSingleInstanceLock } = require("./core/single-instance");
@@ -122,6 +129,7 @@ function persist() {
 
 async function gracefulShutdown(signal) {
   console.log(`Received ${signal}, shutting down gracefully...`);
+  try { require("./core/switchboard/brain-link").notifyExiting(signal); } catch (e) {}
   try { stopScheduler(); } catch (e) {}
   // Save first: whoever sent SIGTERM kills the process soon after (bot pods
   // allow 15 s, launchd 20 s), and the drain below must not cost the save.
@@ -373,6 +381,9 @@ async function safeModeBoot() {
       console.error(`Adapter ${adapter.id} failed to start:`, e.message);
     }
   }
+  // Under a switchboard: ready for call jobs (a live call's waiting
+  // questions go out now and the caller hears "I'm back").
+  try { require("./core/switchboard/brain-link").hello(); } catch (e) { console.error("switchboard hello failed:", e.message); }
 
   // Turns cut short by the last restart resume (or are offered back), and
   // messages that were queued behind them are restored in order.

package/channels/kazee/adapter.js

@@ -21,6 +21,7 @@ const { createKazeeSocket } = require("./socket");
 const { normalize } = require("./format");
 const { KazeeCallManager } = require("./call/manager");
 const kazeeState = require("./state");
+const { KazeeIntake, catchUpEnabled, maxAgeMs: catchUpMaxAgeMs, SKIP_TYPES: CATCHUP_SKIP_TYPES } = require("./catch-up");
 const { createPassiveGate, quietCommand, CONTEXT_MESSAGES: PASSIVE_CONTEXT_MESSAGES, SNOOZE_MS: PASSIVE_SNOOZE_MS } = require("../../core/passive-replies");
 
 // Group catch-up context sizing: how many messages an engaged turn may carry,
@@ -39,6 +40,9 @@ const KAZEE_JOIN_ACK_TIMEOUT_MS = 5000;
 // many ids to remember: large enough to cover a burst, small enough to stay
 // trivial to scan.
 const INBOUND_DEDUP_MEMORY = 500;
+// Restart catch-up (./catch-up.js): how long reading one chat's missed
+// messages may take before that chat is left for the next connect.
+const CATCHUP_FETCH_TIMEOUT_MS = 15000;
 
 const CONTEXT_MAX_MESSAGES = 40;
 const CONTEXT_BODY_LIMIT = 280;
@@ -90,6 +94,11 @@ function senderIdOf(m) {
   return String(m?.sender?._id || m?.sender?.id || m?.senderId || (typeof m?.sender === "string" ? m.sender : "") || "");
 }
 
+function chatIdOf(m) {
+  const chat = m?.chat;
+  return String(m?.chatId || (typeof chat === "string" ? chat : (chat?._id || chat?.id)) || "");
+}
+
 // How a new thread starts. "hybrid" (the default): the root, the replies so
 // far and the main-timeline messages just before the root. "fresh": the root
 // and the replies only. "fork" (Claude): the runner resumes the chat's main
@@ -186,8 +195,15 @@ function publicOnlyLookup(hostname, options, callback) {
   });
 }
 
+function defaultCallManager(adapter) {
+  if (require("../../core/switchboard/handoff").isSwitchboardChild()) {
+    return require("../../core/switchboard/brain-link").callManagerProxy(adapter);
+  }
+  return new KazeeCallManager({ adapter });
+}
+
 class KazeeAdapter {
-  constructor({ id = "kazee", url, token, ownerUserId, botUserId, mediaHosts = "", passiveGate = null, spawnUtilityAgent = null }) {
+  constructor({ id = "kazee", url, token, ownerUserId, botUserId, mediaHosts = "", passiveGate = null, spawnUtilityAgent = null, callManager = null }) {
     this.id = id;
     this.type = "kazee";
     // KAZEE_URL is the root host (socket.io lives at /). REST routes are
@@ -219,7 +235,9 @@ class KazeeAdapter {
     // rootId -> time the bot was last found NOT in that thread (short cache).
     this._threadNotIn = new Map();
     this._typingThreadWarned = new Set();
-    this._callManager = new KazeeCallManager({ adapter: this });
+    // Calls: this process's own manager, or (OC_SWITCHBOARD) a stand-in,
+    // because the switchboard holds the call room (core/switchboard).
+    this._callManager = callManager ? callManager(this) : defaultCallManager(this);
     // Groups set to "When they can help" (core/passive-replies.js); made on
     // first use, so a bot in no passive group never builds one.
     this._passive = passiveGate;
@@ -229,6 +247,11 @@ class KazeeAdapter {
     this._sentTags = new Map();
     this._pauseNext = new Map();
     this._spawnUtility = spawnUtilityAgent;
+    // Restart catch-up (./catch-up.js): what this bot has taken in, per chat.
+    this._intake = new KazeeIntake({ adapterId: this.id, botUserId: this.botUserId });
+    this._catchUpRun = null;
+    this._catchUpAgain = false;
+    this._unhookJournal = null;
   }
 
   _passiveGate() {
@@ -292,11 +315,15 @@ class KazeeAdapter {
     return () => this._listeners[event].delete(fn);
   }
 
+  // Settles when every handler has (never rejects): the restart catch-up
+  // counts a message as taken once the router is done with it.
   _emit(event, envelope) {
+    const pending = [];
     for (const fn of this._listeners[event] || []) {
-      try { Promise.resolve(fn(envelope)).catch((e) => console.error(`kazee ${event} handler:`, e.message)); }
+      try { pending.push(Promise.resolve(fn(envelope)).catch((e) => console.error(`kazee ${event} handler:`, e.message))); }
       catch (e) { console.error(`kazee ${event} handler:`, e.message); }
     }
+    return Promise.all(pending);
   }
 
   async start() {
@@ -305,22 +332,18 @@ class KazeeAdapter {
     } else {
       console.error("Kazee adapter started without botUserId — set KAZEE_BOT_USER_ID. Slash commands and self-echo filtering will not work.");
     }
+    // 12 Oct: a message whose turn the turn journal holds is taken: the
+    // journal runs it again after a restart, so the catch-up must not.
+    if (!this._unhookJournal) {
+      this._unhookJournal = require("../../core/turn-journal").onHeld((held) => {
+        if (held.adapterId === this.id) this._takeInbound(held.channelId, held.messageId);
+      });
+    }
     this._socket = createKazeeSocket({
       url: this.url,
       token: this.token,
       userId: this.botUserId,
-      onConnect: (s) => {
-        console.log(`Kazee socket connected (${this.url})`);
-        // A reconnect is a NEW socket server-side with an empty joinedRooms,
-        // so anything we believed we had joined is stale.
-        this._joinedRooms.clear();
-        this._joinPending.clear();
-        if (this.botUserId) {
-          // Join the bot's personal room so the server can fan out
-          // message:action presses directly to us.
-          s.emit("user:join", { userId: this.botUserId });
-        }
-      },
+      onConnect: (s) => this._onSocketConnect(s),
       onDisconnect: (reason) => {
         console.log(`Kazee socket disconnected: ${reason}`);
         this._joinedRooms.clear();
@@ -331,10 +354,147 @@ class KazeeAdapter {
     this._wireSocket(this._socket);
   }
 
+  _onSocketConnect(s) {
+    console.log(`Kazee socket connected (${this.url})`);
+    // A reconnect is a NEW socket server-side with an empty joinedRooms,
+    // so anything we believed we had joined is stale.
+    this._joinedRooms.clear();
+    this._joinPending.clear();
+    if (this.botUserId) {
+      // Join the bot's personal room so the server can fan out
+      // message:action presses directly to us.
+      s.emit("user:join", { userId: this.botUserId });
+    }
+    // Messages that came while no socket was listening (a brain restart, a
+    // network drop): the server does not send them again.
+    this._startCatchUp();
+  }
+
   async stop() {
     await this._callManager.stop();
     try { this._socket?.disconnect?.(); } catch (e) {}
     this._socket = null;
+    try { this._unhookJournal?.(); } catch (e) {}
+    this._unhookJournal = null;
+  }
+
+  // One catch-up at a time; a connect while one runs asks for another pass
+  // after it (that pass finds what the first already took and skips it).
+  _startCatchUp() {
+    if (!catchUpEnabled() || !this.botUserId) return null;
+    if (this._catchUpRun) {
+      this._catchUpAgain = true;
+      return this._catchUpRun;
+    }
+    const run = (async () => {
+      try {
+        do {
+          this._catchUpAgain = false;
+          await this._catchUp();
+        } while (this._catchUpAgain);
+      } catch (e) {
+        console.error("Kazee catch-up failed:", e.message);
+      } finally {
+        if (this._catchUpRun === run) this._catchUpRun = null;
+      }
+    })();
+    this._catchUpRun = run;
+    return run;
+  }
+
+  // Restart catch-up (./catch-up.js): read each chat the bot has a record for
+  // from where it stopped taking messages in, and send what it never took
+  // through the live path (_handleInboundMessage: the same gate, media and
+  // thread handling, and the router's access rules), oldest first, across
+  // chats. Skipped: the bot's own messages, deleted ones, messages
+  // chat-central wrote itself (a call card), ones already taken or already
+  // being worked on in this process, and anything older than
+  // KAZEE_CATCHUP_MAX_AGE_MIN. A message that arrives live meanwhile is
+  // handled once: whichever copy comes second is a duplicate by id.
+  async _catchUp() {
+    const intake = this._intake;
+    const botId = String(this.botUserId);
+    const now = Date.now();
+    const maxAge = catchUpMaxAgeMs();
+    const due = [];
+    const read = [];
+    for (const chatId of intake.chats()) {
+      const sinceMs = intake.hold(chatId);
+      if (sinceMs == null) continue;
+      let messages;
+      try {
+        messages = await withTimeout(this._messagesAfter(chatId, new Date(sinceMs).toISOString()), CATCHUP_FETCH_TIMEOUT_MS, "Kazee catch-up read");
+      } catch (e) {
+        if (/not a participant|Chat not found/i.test(String(e.message || ""))) {
+          console.log(`Kazee catch-up: ${chatId} forgotten (the bot is no longer in it)`);
+          intake.forget(chatId);
+          continue;
+        }
+        console.error(`Kazee catch-up: ${chatId} read failed, trying again on the next connect: ${e.message}`);
+        continue;
+      }
+      read.push(chatId);
+      let stale = 0;
+      for (const m of messages) {
+        const id = String(m?._id || m?.id || "");
+        const at = Date.parse(m?.createdAt || "");
+        if (!id || !Number.isFinite(at) || at <= sinceMs) continue; // an edit or delete of an older message
+        if (chatIdOf(m) && chatIdOf(m) !== chatId) continue;
+        if (m.isDeleted || CATCHUP_SKIP_TYPES.has(m.type) || senderIdOf(m) === botId) continue;
+        if (intake.isTaken(chatId, id) || this._seenMessageIds.has(id)) continue;
+        if (now - at > maxAge) { stale++; continue; }
+        due.push({ chatId, id, at, msg: m });
+      }
+      if (stale) console.log(`Kazee catch-up: ${chatId} ${stale} message(s) older than ${Math.round(maxAge / 60000)} min left alone`);
+    }
+    due.sort((a, b) => a.at - b.at);
+    for (const { chatId, id, at, msg } of due) {
+      // Taken live (or by the journal) while the reads ran.
+      if (intake.isTaken(chatId, id) || this._seenMessageIds.has(id)) continue;
+      if (!intake.noteReplay(chatId, id, at)) {
+        console.log(`Kazee catch-up: ${chatId} ${id} left alone: replayed twice already and never finished`);
+        continue;
+      }
+      console.log(`Kazee catch-up: ${chatId} ${id} ${threadRootOf(msg) || "main"} age=${Math.round((Date.now() - at) / 1000)}s`);
+      try { await this._handleInboundMessage({ ...msg, chat: msg.chat || chatId }); }
+      catch (e) { console.error(`Kazee catch-up: ${chatId} ${id} failed:`, e.message); }
+    }
+    // Everything due is out (in flight, holding the cursor itself), so the
+    // chats read release their hold; a chat whose read failed keeps it.
+    for (const chatId of read) intake.release(chatId);
+  }
+
+  // Every message of a chat after `sinceIso`, thread replies included,
+  // oldest first (chat-central's since-sync, capped at 500 server-side). It
+  // also returns older messages edited or deleted since; the caller drops them.
+  async _messagesAfter(chatId, sinceIso) {
+    const route = `/messages/${encodeURIComponent(chatId)}/${encodeURIComponent(String(this.botUserId))}?since=${encodeURIComponent(sinceIso)}`;
+    const res = await this._request("GET", route);
+    const data = res?.data || res || {};
+    if (res?.error || data.error || res?.success === false) throw new Error(String(res?.error || data.error || "message read refused"));
+    return Array.isArray(data.messages) ? data.messages : [];
+  }
+
+  // The switchboard's use of this adapter: its own socket, carrying only the
+  // call events (chat messages stay with the brain's socket).
+  async startCalls() {
+    this._socket = createKazeeSocket({
+      url: this.url,
+      token: this.token,
+      userId: this.botUserId,
+      onConnect: (s) => {
+        console.log(`Switchboard: Kazee call socket connected (${this.url})`);
+        if (this.botUserId) s.emit("user:join", { userId: this.botUserId });
+      },
+      onDisconnect: (reason) => console.log(`Switchboard: Kazee call socket disconnected: ${reason}`),
+      onError: (err) => console.error("Switchboard: Kazee call socket error:", err.message),
+    });
+    this._callManager.wire(this._socket);
+  }
+
+  stopCalls() {
+    try { this._socket?.disconnect?.(); } catch (e) {}
+    this._socket = null;
   }
 
   _wireSocket(socket) {
@@ -646,21 +806,54 @@ class KazeeAdapter {
     }
   }
 
+  // Every chat message the bot gets: live off the socket, or replayed by the
+  // restart catch-up (_catchUp). 12 Oct: a message is "taken" (./catch-up.js)
+  // once the bot owns its outcome: when the router is done with it, or
+  // earlier, when the turn journal holds its turn (start()). Never merely on
+  // arrival: the 12 Oct voice note arrived and was dropped mid-transcription,
+  // before it was a turn the journal could resume.
   async _handleInboundMessage(msg) {
     if (!msg) return;
     if (this._isDuplicateInbound(msg)) return;
     const senderId = String(msg.sender?._id || msg.sender?.id || msg.senderId || "");
     if (this.botUserId && senderId === String(this.botUserId)) return; // ignore our own echoes
-    const chatField = msg.chat;
-    const channelId = String(
-      msg.chatId
-        || (typeof chatField === "string" ? chatField : (chatField?._id || chatField?.id))
-        || ""
-    );
+    const channelId = chatIdOf(msg);
     if (!channelId) {
       console.error("Kazee message:new missing chat id, ignoring:", JSON.stringify(msg).slice(0, 200));
       return;
     }
+    const messageId = String(msg._id || msg.id || "");
+    const tracked = !!messageId && catchUpEnabled();
+    if (tracked) {
+      try { this._intake.open(channelId, messageId, Date.parse(msg.createdAt || "")); }
+      catch (e) { console.error("Kazee catch-up: could not record a message:", e.message); }
+    }
+    // A slash command is taken as it goes out: /restart and /upgrade end this
+    // process before their dispatch settles, and one replayed after the
+    // restart would only restart it again.
+    if (tracked && String(msg.content || "").trim().startsWith("/")) this._takeInbound(channelId, messageId);
+    let routed = null;
+    try {
+      routed = await this._routeInbound(msg, channelId, senderId);
+    } finally {
+      if (tracked) {
+        const done = () => this._takeInbound(channelId, messageId);
+        if (routed && routed.emitted) routed.emitted.then(done, done);
+        else done();
+      }
+    }
+  }
+
+  // Bookkeeping only: it must never fail a dispatch.
+  _takeInbound(chatId, messageId) {
+    if (!catchUpEnabled()) return;
+    try { this._intake.taken(chatId, messageId); }
+    catch (e) { console.error("Kazee catch-up: could not record a taken message:", e.message); }
+  }
+
+  // The group gate, the envelope and the hand-off to the router. Returns
+  // { emitted } (settles when the router is done) when it went out.
+  async _routeInbound(msg, channelId, senderId) {
     const userId = senderId || channelId;
     const baseFrom = {
       id: userId,
@@ -847,7 +1040,7 @@ class KazeeAdapter {
       }
     }
 
-    this._emit("message", envelope);
+    return { emitted: this._emit("message", envelope) };
   }
 
   // Whether another bot's message answers one of this bot's tags: it replies
@@ -1017,7 +1210,11 @@ class KazeeAdapter {
 
   async _conversationContext(envelope) {
     if (!envelope || !this.botUserId) return null;
-    if (envelope.threadId) return this._threadContext(envelope);
+    // A live call's turns carry their thread from the call's own note, built
+    // once at call start (call/thread-context.js): a fetch per spoken turn
+    // would cost seconds and move the thread's watermark past replies its
+    // chat turns have not seen.
+    if (envelope.threadId) return this.liveCall === true ? null : this._threadContext(envelope);
     if (envelope.surface !== "group") return null;
     const chatId = String(envelope.channelId || "");
     if (!chatId) return null;