@inetafrica/open-claudia 3.5.47 → 3.5.58

package/core/runner.js

@@ -20,6 +20,7 @@ const {
   resolveProviderSettings, getProjectSessions,
 } = require("./state");
 const { chatContext, currentChannelId, currentAdapter, currentThreadId } = require("./context");
+const { isCallLaneKey } = require("./identity");
 const { buildTurnPrompt } = require("./system-prompt");
 const turnJournal = require("./turn-journal");
 const usageLimits = require("./usage-limits");
@@ -413,6 +414,11 @@ async function executeProviderInvocation(options = {}) {
       terminalSeen = true;
       if (event.sessionId) sessionId = event.sessionId;
       if (typeof event.text === "string" && event.text) resultText = event.text;
+      // The answer as it will be delivered (finalAnswerText, else the
+      // result's own text), known now: a live call speaks it before the
+      // process has exited (earlyCallAnswer below).
+      const segments = textSegments.map((blocks) => blocks.join("")).filter((t) => t.trim());
+      event.answerText = redactSensitive(String(segments.at(-1) || resultText || "").trim());
     } else if (event.type === "error") {
       terminalSeen = true;
       rawErrors.push(event);
@@ -1490,6 +1496,7 @@ function deriveCompactionRunContext(base, overrides = {}) {
     admittedSessionId: overrides.sessionId ?? null,
     previousSessionId: overrides.previousSessionId ?? base.sessionId ?? null,
     resumeSessionId: overrides.resumeSessionId ?? null,
+    forkSession: overrides.forkSession === true,
     continueSession: false,
     fresh: !!overrides.fresh,
     recallQuery: overrides.recallQuery ?? null,
@@ -1580,6 +1587,11 @@ function createCompactionService(dependencies = {}) {
       sessionId: oldSessionId,
       resumeSessionId: oldSessionId,
       previousSessionId: oldSessionId,
+      // Read the live conversation through a fork (Claude --fork-session): the
+      // summarize prompt and its brief must never land in the live session. A
+      // summary that fails (an OAuth refresh error, a timeout) would leave the
+      // prompt there, and the next turn answers it into the chat (12 Oct).
+      forkSession: true,
       fresh: false,
     });
     const operationId = opts.operationId || (typeof crypto.randomUUID === "function" ? crypto.randomUUID() : `compact-${Date.now()}`);
@@ -1851,6 +1863,11 @@ function providerRunDiagnostic(result, runContext) {
 async function persistForegroundTranscript(result, runContext, state = currentState()) {
   const view = capturedStateView(state, runContext);
   const session = () => result.sessionId || runContext.sessionId || null;
+  // A run stopped on purpose did not fail: /stop, or a call job the quick
+  // voice answered itself or the caller replaced (stopCallRunWhenDropped).
+  // Its words are kept; a "run failed: exited with code 143" note is not
+  // (11 Oct: five such notes in one call's transcript).
+  const stopped = !result.ok && (result.error?.code === "RUN_CANCELLED" || cancelTargets(laneForRun(state, runContext).cancelRequested, runContext));
   appendProjectTranscript(
     runContext.transcriptRole || "user",
     stripTranscriptPointerForStorage(runContext.userPrompt),
@@ -1865,6 +1882,7 @@ async function persistForegroundTranscript(result, runContext, state = currentSt
     session,
     { strict: true },
   );
+  if (stopped) return;
   const role = result.ok ? "assistant" : "system-note";
   const text = result.ok
     ? (result.text || "(no output)")
@@ -2452,9 +2470,12 @@ function createForegroundService({ state, store, lane, stopTyping, capture, owns
   // another run then claimed) must not touch that lane's run slot.
   const holds = () => (holdsLane ? holdsLane() : ownsAdmissionLock);
   const callSpeechLeases = new Map();
+  const callStopListeners = new Map();
   const callStage = (stage, runContext) => {
     if (capture || runContext?.liveCall !== true) return;
     console.log(`${new Date().toISOString()} Kazee call provider: stage=${stage} run=${runContext.runId} elapsed=${Math.max(0, Date.now() - runContext.admittedAt)}ms`);
+    // The call's job board: this job is now the one being worked on.
+    try { store?.adapter?.onCallStage?.(stage); } catch (_) {}
   };
   const persistEffects = !capture || persistCapture;
   // The run's lane: given by executeAdmittedRun, else the captured run's own.
@@ -2502,6 +2523,10 @@ function createForegroundService({ state, store, lane, stopTyping, capture, owns
       if (ownsAdmissionLock) onOwnSpawn?.(proc);
       if (ownsAdmissionLock || !runLane.runningProcess) runLane.runningProcess = proc;
       if (ownsAdmissionLock) runLane.preparingRun = false;
+      if (!capture && ownsAdmissionLock) {
+        const remove = stopCallRunWhenDropped(store, runLane, proc, runContext);
+        if (remove) callStopListeners.set(runContext.runId, remove);
+      }
     },
     shouldAbort(runContext, { capture: isCapture } = {}) {
       if (isCapture || !ownsAdmissionLock) return false;
@@ -2535,6 +2560,23 @@ function createForegroundService({ state, store, lane, stopTyping, capture, owns
       if (observer && event.type === "tool_start" && runContext.purpose === "foreground") {
         try { observer.onToolStart(event.name, event.detail); } catch (_) {}
       }
+      // A live call's job board hears what the full agent is doing (tool
+      // steps), so the quick voice can answer "what's the status?".
+      if (!capture && runContext?.liveCall === true && event.type === "tool_start") {
+        try { store?.adapter?.onCallActivity?.(event); } catch (_) {}
+      }
+      // A live call hears the answer once it is written, not once the CLI has
+      // exited: its end-of-turn work took ~0.8 s on both answers of the 11 Oct
+      // 18:57 call. The normal delivery still runs after; the call skips the
+      // words it was already handed. Never for a guarded speaker (their reply
+      // goes through the outbound guard first).
+      if (!capture && runContext?.liveCall === true && event.type === "result" && event.answerText && !PLACEHOLDER_REPLY.test(event.answerText)) {
+        let guarded = true;
+        try { guarded = require("./relationship").isCurrentSpeakerGuarded(); } catch (_) {}
+        if (!guarded) {
+          try { Promise.resolve(store?.adapter?.earlyCallAnswer?.(event.answerText)).catch(() => {}); } catch (_) {}
+        }
+      }
       if (preview && event.type === "text_final" && typeof event.text === "string" && event.text) {
         preview.append(event.text, runContext);
       }
@@ -2552,6 +2594,8 @@ function createForegroundService({ state, store, lane, stopTyping, capture, owns
       try { require("./speaker-attest").endRun(runContext.runId); } catch (_) {}
       callSpeechLeases.get(runContext.runId)?.close();
       callSpeechLeases.delete(runContext.runId);
+      callStopListeners.get(runContext.runId)?.();
+      callStopListeners.delete(runContext.runId);
       const runLane = laneOf(runContext);
       if (runLane.runningProcess === proc) runLane.runningProcess = null;
       // Keep the lane's lock armed while transcript/usage/session persistence
@@ -2637,6 +2681,29 @@ function obsoleteCallTurn(store) {
   return store?.adapter?.liveCall === true && store.adapter.callTurn?.signal.aborted === true;
 }
 
+// A live-call turn the call dropped while its provider runs: the caller
+// changed their mind ("replaced"), the quick voice handled it alone ("self"),
+// or (with no quick voice) a newer utterance took over ("superseded"). Stop
+// it the way /stop does (named cancel flag, then the process tree), so it
+// neither holds the call's lane nor speaks. A turn whose call ENDED keeps
+// running, so "do X" said just before hanging up still gets done. Ported from
+// the 4 Oct calls build. Returns the listener's remover, or null.
+const STOPPED_CALL_TURN_REASONS = new Set(["superseded", "cancelled", "replaced", "self"]);
+function stopCallRunWhenDropped(store, lane, proc, runContext) {
+  const signal = runContext?.liveCall === true ? store?.adapter?.callTurn?.signal : null;
+  if (!signal || !proc?.pid) return null;
+  const stop = () => {
+    if (!STOPPED_CALL_TURN_REASONS.has(signal.reason) || lane.runningProcess !== proc) return;
+    lane.cancelRequested = runContext.runId || true;
+    console.log(`${new Date().toISOString()} Kazee call provider: stage=${signal.reason} run=${runContext.runId} elapsed=${Math.max(0, Date.now() - runContext.admittedAt)}ms`);
+    killProcessTree(proc.pid, "SIGTERM");
+    setTimeout(() => killProcessTree(proc.pid, "SIGKILL"), 3000).unref?.();
+  };
+  if (signal.aborted) { stop(); return null; }
+  signal.addEventListener("abort", stop, { once: true });
+  return () => signal.removeEventListener("abort", stop);
+}
+
 function cancelledCallRunResult(runContext) {
   return cancelledRunResult(runContext, { id: runContext.provider, label: runContext.provider }, "Call turn superseded or ended before execution");
 }
@@ -2669,7 +2736,7 @@ function cancelQueuedCallOnAbort(lane, item) {
 function drainQueuedMessages(_state) {
   for (const { state, lane } of waitingLanes()) {
     if (laneBusy(lane) || !lane.messageQueue.length) continue;
-    if (slotBlocker(state)) { lane.waitingForSlot = true; continue; }
+    if (!isCallLaneKey(lane.key) && slotBlocker(state)) { lane.waitingForSlot = true; continue; }
     const batch = takeQueueBatch(lane);
     const item = batch.length > 1 ? mergeQueueBatch(lane, batch) : batch[0];
     item.disposeCallListener?.();
@@ -3302,6 +3369,8 @@ function runAgentSilent(prompt, cwd, label, opts = {}) {
 }
 
 module.exports = {
+  stopCallRunWhenDropped,
+  persistForegroundTranscript,
   queuedNotice,
   handleQueueRemove,
   takeQueueBatch,

package/core/state.js

@@ -20,6 +20,7 @@ const {
   channelKey,
   identities,
   parseConversationKey,
+  isCallLaneKey,
 } = require("./identity");
 const { currentChannelId, currentCanonicalUserId, currentConversationKey, currentRoomKey } = require("./context");
 const { atomicWriteFileSync, readJsonWithFallback } = require("./fsutil");
@@ -1005,7 +1006,10 @@ function slotBlocker(state) {
 function admitLane(state = currentState(), laneKey = null) {
   const lane = laneFor(state, laneKey);
   if (laneBusy(lane)) return { ok: false, reason: "busy", lane };
-  const blocker = slotBlocker(state);
+  // A live call is real time: its turns never wait for a free slot (one call
+  // at a time, so at most one run over the caps).
+  const realtime = isCallLaneKey(lane.key);
+  const blocker = realtime ? null : slotBlocker(state);
   if (lane.messageQueue.length) return { ok: false, reason: "waiting", lane, running: blocker?.running || 0 };
   if (blocker) {
     lane.waitingForSlot = true;
@@ -1013,7 +1017,7 @@ function admitLane(state = currentState(), laneKey = null) {
   }
   // A freed slot goes to the lanes already waiting for one, oldest first: a
   // newcomer queues behind them (the runner then admits in order).
-  if (waitingLanes().some((waiting) => waiting.lane !== lane && !slotBlocker(waiting.state))) {
+  if (!realtime && waitingLanes().some((waiting) => waiting.lane !== lane && !slotBlocker(waiting.state))) {
     lane.waitingForSlot = true;
     return { ok: false, reason: "cap", lane, running: runningLanes(state).length, scope: "queue" };
   }

package/core/switchboard/brain-link.js

@@ -0,0 +1,161 @@
+// The brain's end of the switchboard link (only when OC_SWITCHBOARD started
+// this process as the switchboard's child). The call room lives in the
+// switchboard; a call job arrives here and becomes an ordinary call turn: a
+// per-job adapter made from the real Kazee adapter, as the call manager
+// always made it, whose speech and answer go back over the link.
+
+const { Link } = require("./ipc");
+const { isSwitchboardChild } = require("./handoff");
+
+let link = null;
+let goneHandled = false;
+// The channel also closes as this process exits on its own; not news then.
+let exiting = false;
+process.once("exit", () => { exiting = true; });
+let options = {};
+const jobs = new Map();
+
+function findAdapter(adapterId) {
+  if (options.findAdapter) return options.findAdapter(adapterId);
+  return require("../adapter-registry").findAdapter(adapterId);
+}
+
+// channel/findAdapter/onGone are test seams; the brain uses its own process.
+function connect({ channel = null, findAdapter: find = null, onGone = null } = {}) {
+  if (link) return link;
+  if (!channel && !isSwitchboardChild()) return null;
+  options = { findAdapter: find, onGone };
+  link = new Link(channel || process, { label: "switchboard" });
+  link.on("call.job", (payload) => {
+    try { startJob(payload); } catch (error) { console.error(`Switchboard call job failed to start: ${error.message}`); }
+  });
+  link.on("call.job.mirror", ({ id, mirror } = {}) => {
+    const job = jobs.get(id);
+    if (job && mirror) job.mirror = mirror;
+  });
+  link.on("call.job.abort", ({ id, reason } = {}) => {
+    const job = jobs.get(id);
+    if (job && !job.controller.signal.aborted) job.controller.abort(reason || "aborted");
+  });
+  link.on("call.job.forget", ({ id } = {}) => { jobs.delete(id); });
+  link.handle("call.carryOn", (payload) => carryOn(payload));
+  link.handle("call.greetingContext", (payload) => greetingContext(payload));
+  // The switchboard is gone (it crashed or was killed): this brain must go
+  // too, so the switchboard launchd or the pod starts next gets a free lock.
+  link.on("close", () => {
+    if (goneHandled || exiting) return;
+    goneHandled = true;
+    if (options.onGone) { options.onGone(); return; }
+    console.error("Switchboard link closed: shutting the brain down");
+    try { process.kill(process.pid, "SIGTERM"); } catch (_) {}
+  });
+  return link;
+}
+
+function hello() {
+  const l = connect();
+  if (!l) return false;
+  let version = null;
+  try { version = require("../../package.json").version; } catch (_) {}
+  return l.notify("brain.hello", { pid: process.pid, version });
+}
+
+// Said before a planned exit (restart, upgrade, shutdown): the call hears
+// "I'm restarting" instead of an unexplained gap.
+function notifyExiting(reason) {
+  exiting = true;
+  const l = link || connect();
+  return l ? l.notify("brain.exiting", { reason: String(reason || "restart") }) : false;
+}
+
+function configChanged(what) {
+  const l = link || connect();
+  return l ? l.notify("config.changed", { what }) : false;
+}
+
+function call(id, name, args) {
+  const l = connect();
+  if (!l) return Promise.reject(new Error("switchboard not connected"));
+  return l.request("call.job.fn", { id, name, args }, { timeoutMs: 0 });
+}
+
+function startJob({ id, adapterId, envelope, fields = {}, mirror = {}, resent = false } = {}) {
+  const base = findAdapter(adapterId);
+  if (!base || typeof base._emit !== "function") throw new Error(`no adapter ${adapterId}`);
+  const controller = new AbortController();
+  const job = { id, controller, mirror };
+  jobs.set(id, job);
+  const callAdapter = Object.create(base);
+  Object.assign(callAdapter, fields);
+  callAdapter.callTurn = { signal: controller.signal };
+  callAdapter.liveCallHistory = () => (job.mirror.history || []).map((entry) => ({ ...entry }));
+  callAdapter.liveCallCamera = () => {
+    const camera = job.mirror.camera;
+    if (!camera?.path) return null;
+    return { path: camera.path, ageMs: Math.max(0, Date.now() - (Number(camera.at) || Date.now())), receiving: camera.receiving !== false };
+  };
+  callAdapter.isCallTurnActive = () => !controller.signal.aborted && !!job.mirror.active;
+  callAdapter.cancelCallSpeech = () => { call(id, "cancelCallSpeech", []).catch(() => {}); };
+  callAdapter.onCallStage = (stage) => { call(id, "onCallStage", [stage]).catch(() => {}); };
+  callAdapter.onCallActivity = (event) => {
+    call(id, "onCallActivity", [{ type: event?.type, name: event?.name, detail: event?.detail }]).catch(() => {});
+  };
+  callAdapter.speakSentence = async (text) => {
+    try { return !!(await call(id, "speakSentence", [String(text ?? "")])); } catch (_) { return false; }
+  };
+  callAdapter.send = async (channelId, text) => {
+    try { return (await call(id, "send", [String(channelId), String(text ?? "")])) !== false; } catch (_) { return false; }
+  };
+  callAdapter.earlyCallAnswer = async (text) => {
+    try { return (await call(id, "earlyCallAnswer", [String(text ?? "")])) !== false; } catch (_) { return false; }
+  };
+  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;
+  };
+  if (resent) console.log(`Switchboard call job ${id} asked again after a brain restart`);
+  base._emit("message", { ...envelope, adapter: callAdapter });
+  return callAdapter;
+}
+
+function carryOn({ adapterId, chatId, userId, prompt, threadId = null } = {}) {
+  const adapter = findAdapter(adapterId) || { id: adapterId, type: "kazee" };
+  const job = require("../../channels/kazee/call/manager").carryOnInChat({ adapter, chatId, userId, prompt, threadId });
+  return { id: job?.id || null };
+}
+
+function greetingContext({ adapterId, chatId, userId, threadId = null } = {}) {
+  const adapter = findAdapter(adapterId) || { id: adapterId, type: "kazee" };
+  return require("../../channels/kazee/call/manager").greetingContext({ adapter, chatId, userId, ...(threadId ? { threadId } : {}) });
+}
+
+// The brain's stand-in for a Kazee adapter's call manager: calls are the
+// switchboard's, so the brain's socket ignores call events, stopping the
+// brain never ends a call, and `open-claudia call` is passed across.
+function callManagerProxy(adapter) {
+  return {
+    session: null,
+    switchboard: true,
+    wire() {},
+    async stop() {},
+    async outgoing(args = {}) {
+      const l = connect();
+      if (!l) throw new Error("switchboard not connected");
+      return l.request("call.outgoing", { adapterId: adapter.id, args }, { timeoutMs: 90000 });
+    },
+  };
+}
+
+function _resetForTests() {
+  goneHandled = true;
+  link?.close();
+  link = null;
+  options = {};
+  goneHandled = false;
+  exiting = false;
+  jobs.clear();
+}
+
+module.exports = { connect, hello, notifyExiting, configChanged, startJob, callManagerProxy, carryOn, greetingContext, jobs, _resetForTests };

package/core/switchboard/call-host.js

@@ -0,0 +1,298 @@
+// The live call room, held by the switchboard so a brain restart doesn't drop
+// it. Each Kazee channel gets the same KazeeCallManager the bot always ran,
+// on the switchboard's own chat-central socket. What the manager used to hand
+// straight to the bot's router (a full-agent job) goes to the brain over the
+// link instead. While the brain is away, new jobs wait, the call stays up and
+// the caller hears why; when it is back, the waiting jobs go out.
+
+const { KazeeAdapter } = require("../../channels/kazee/adapter");
+const { KazeeCallManager, greetingContext } = require("../../channels/kazee/call/manager");
+
+// Plain values of the per-job call adapter the brain needs as they are.
+const JOB_FIELDS = ["callHistory", "quickVoice", "quickRelay", "liveCall", "suppressStreamPreview", "suppressChatVisibility", "liveCallThreadNote"];
+// What the brain may call back on a job.
+const JOB_FUNCTIONS = new Set(["speakSentence", "send", "earlyCallAnswer", "cancelCallSpeech", "onCallStage", "onCallActivity"]);
+
+const LINES = {
+  restarting: "I'm restarting. Back in a few seconds.",
+  crashed: "Sorry, something went wrong on my side. Give me a few seconds.",
+  back: "I'm back.",
+};
+
+const DEFAULT_TIMING = {
+  // How often a job's live view (call so far, camera, still on the board)
+  // is re-checked and sent to the brain when it changed.
+  mirrorMs: 250,
+  // A finished job is kept this long: a carried-on answer can come late.
+  jobKeepMs: 30 * 60 * 1000,
+  greetingAskMs: 1500,
+  // A thread call reads the thread first (its title from the server).
+  threadGreetingAskMs: 3000,
+};
+
+function defaultLog(message) {
+  console.log(`${new Date().toISOString()} Switchboard: ${message}`);
+}
+
+function abortReason(signal) {
+  const reason = signal?.reason;
+  if (typeof reason === "string") return reason;
+  return String(reason?.message || reason?.name || "aborted");
+}
+
+// What the brain's prompt builder reads from a job while its run starts.
+function mirrorOf(callAdapter, now = Date.now()) {
+  let history = [];
+  let camera = null;
+  let active = false;
+  try { history = callAdapter.liveCallHistory?.() || []; } catch (_) {}
+  try {
+    const still = callAdapter.liveCallCamera?.();
+    if (still?.path) camera = { path: still.path, at: now - (Number(still.ageMs) || 0), receiving: still.receiving !== false };
+  } catch (_) {}
+  try { active = !!callAdapter.isCallTurnActive?.(); } catch (_) {}
+  return { history, camera, active };
+}
+
+class CallHost {
+  constructor({ specs = [], AdapterImpl = KazeeAdapter, ManagerImpl = KazeeCallManager, managerOptions = {},
+    timing = {}, log = defaultLog } = {}) {
+    this.specs = specs;
+    this.AdapterImpl = AdapterImpl;
+    this.ManagerImpl = ManagerImpl;
+    this.managerOptions = managerOptions;
+    this.timing = { ...DEFAULT_TIMING, ...timing };
+    this.log = log;
+    this.adapters = [];
+    this.jobs = new Map();
+    this.link = null;
+    this.brainReady = false;
+    this.stopping = false;
+    this._seq = 0;
+    this._carryOns = [];
+    this._away = new Set();
+    this._told = new WeakSet();
+    this._idleListeners = [];
+    this._wasLive = false;
+  }
+
+  async start() {
+    for (const spec of this.specs) {
+      const adapter = new this.AdapterImpl({
+        id: spec.id, ...spec.opts,
+        callManager: (owner) => new this.ManagerImpl({
+          adapter: owner,
+          resolveGreetingContext: (target) => this._greetingContext(target),
+          ...this.managerOptions,
+          dispatchJob: (envelope, job) => this._dispatch(owner, envelope, job),
+          carryOn: (args) => this._carryOn(owner, args),
+        }),
+      });
+      this.adapters.push(adapter);
+      await adapter.startCalls();
+    }
+    this._pump = setInterval(() => this._tick(), this.timing.mirrorMs);
+    this._pump.unref?.();
+  }
+
+  onIdle(fn) { this._idleListeners.push(fn); }
+
+  liveCall() {
+    return this.adapters.some((adapter) => {
+      const manager = adapter._callManager;
+      return !!(manager?._pending || (manager?.session && !manager.session.closed));
+    });
+  }
+
+  _liveSessions() {
+    return this.adapters.map((adapter) => ({ manager: adapter._callManager, session: adapter._callManager?.session }))
+      .filter(({ session }) => session && !session.closed);
+  }
+
+  _say(manager, session, line) {
+    try { manager._rememberSpeech?.(session, "assistant", line); } catch (_) {}
+    Promise.resolve(session.speak(line)).catch(() => {});
+  }
+
+  // ── The brain ────────────────────────────────────────────────────
+
+  attachBrain(link) {
+    this.link = link;
+    this.brainReady = false;
+    link.handle("call.job.fn", (payload) => this._jobFn(payload));
+    link.handle("call.outgoing", (payload) => this._outgoing(payload));
+    link.on("brain.hello", (info) => this._brainHello(info));
+    link.on("brain.exiting", (payload) => this._brainLeaving(payload?.reason));
+    link.on("config.changed", (payload) => {
+      if (payload?.what === "voice") { try { require("../tts-voice")._resetCache(); } catch (_) {} }
+    });
+  }
+
+  // The brain said it is about to exit on purpose (restart, upgrade).
+  _brainLeaving(reason) {
+    this._leaving = String(reason || "restart");
+    if (this.stopping) return;
+    for (const { manager, session } of this._liveSessions()) {
+      if (this._told.has(session)) continue;
+      this._told.add(session);
+      this._away.add(session);
+      this._say(manager, session, LINES.restarting);
+    }
+  }
+
+  brainGone({ planned = false, reason = "" } = {}) {
+    this.link = null;
+    this.brainReady = false;
+    const leaving = this._leaving;
+    this._leaving = null;
+    if (this.stopping) return;
+    const live = this._liveSessions();
+    for (const { manager, session } of live) {
+      this._away.add(session);
+      if (this._told.has(session)) continue;
+      this._told.add(session);
+      this._say(manager, session, planned || leaving ? LINES.restarting : LINES.crashed);
+    }
+    // Jobs the brain had and never answered. After a planned exit they end
+    // (the exit was likely what they asked for); after a crash each is asked
+    // again once, when the brain is back.
+    for (const job of this.jobs.values()) {
+      if (!job.sent || job.answered || job.signal?.aborted) continue;
+      job.sent = false;
+      if (!planned && !leaving && !job.resent) { job.resent = true; continue; }
+      this._drop(job, "restart");
+    }
+    if (live.length) this.log(`brain gone (${planned || leaving ? "planned" : "unplanned"}: ${reason || leaving}); call kept`);
+  }
+
+  _brainHello(info = {}) {
+    this.brainReady = true;
+    const away = this._liveSessions().filter(({ session }) => this._away.has(session));
+    for (const { manager, session } of away) this._say(manager, session, LINES.back);
+    if (away.length) this.log(`brain back pid=${info.pid || "?"} v${info.version || "?"}; call went on`);
+    this._away.clear();
+    this._told = new WeakSet();
+    for (const job of this.jobs.values()) {
+      if (!job.sent && !job.answered && !job.signal?.aborted) this._send(job);
+    }
+    for (const carry of this._carryOns.splice(0)) this._sendCarryOn(carry);
+  }
+
+  // ── Jobs ─────────────────────────────────────────────────────────
+
+  _dispatch(adapter, envelope, { turn = null, session = null } = {}) {
+    const { adapter: callAdapter, ...rest } = envelope;
+    const signal = callAdapter?.callTurn?.signal || null;
+    const job = {
+      id: `${adapter.id}:${++this._seq}`, adapterId: adapter.id, manager: adapter._callManager,
+      callAdapter, envelope: rest, signal, turn, session,
+      sent: false, resent: false, answered: false, lastMirror: "", inactiveAt: 0,
+    };
+    this.jobs.set(job.id, job);
+    signal?.addEventListener("abort", () => {
+      if (job.sent) this.link?.notify("call.job.abort", { id: job.id, reason: abortReason(signal) });
+    }, { once: true });
+    if (!this._send(job)) this.log(`job ${job.id} waits for the brain`);
+    return job;
+  }
+
+  _send(job) {
+    if (!this.link || !this.brainReady) return false;
+    const fields = {};
+    for (const key of JOB_FIELDS) if (job.callAdapter[key] !== undefined) fields[key] = job.callAdapter[key];
+    const mirror = mirrorOf(job.callAdapter);
+    job.lastMirror = JSON.stringify(mirror);
+    job.sent = this.link.notify("call.job", {
+      id: job.id, adapterId: job.adapterId, envelope: job.envelope, fields, mirror, resent: job.resent,
+    });
+    return job.sent;
+  }
+
+  _drop(job, reason) {
+    if (job.turn && job.session && typeof job.manager?._dropJob === "function") {
+      try { job.manager._dropJob(job.session, job.turn, reason); return; } catch (_) {}
+    }
+    try { job.turn?.controller?.abort(reason); } catch (_) {}
+  }
+
+  async _jobFn({ id, name, args } = {}) {
+    const job = this.jobs.get(id);
+    if (!job) throw new Error("call job gone");
+    if (!JOB_FUNCTIONS.has(name) || typeof job.callAdapter[name] !== "function") throw new Error(`not a call job function: ${name}`);
+    if (name === "send") job.answered = true;
+    const value = await job.callAdapter[name](...(Array.isArray(args) ? args : []));
+    return value === undefined ? null : value;
+  }
+
+  _tick() {
+    const now = Date.now();
+    for (const job of this.jobs.values()) {
+      if (job.inactiveAt && now - job.inactiveAt > this.timing.jobKeepMs) {
+        this.jobs.delete(job.id);
+        this.link?.notify("call.job.forget", { id: job.id });
+        continue;
+      }
+      if (job.inactiveAt) continue;
+      const mirror = mirrorOf(job.callAdapter, now);
+      if (!mirror.active) job.inactiveAt = now;
+      if (!job.sent || !this.link) continue;
+      const text = JSON.stringify(mirror);
+      if (text === job.lastMirror) continue;
+      job.lastMirror = text;
+      this.link.notify("call.job.mirror", { id: job.id, mirror });
+    }
+    const live = this.liveCall();
+    if (this._wasLive && !live) for (const fn of this._idleListeners) { try { fn(); } catch (_) {} }
+    this._wasLive = live;
+  }
+
+  // ── Other things the call asks of the brain ──────────────────────
+
+  async _outgoing({ adapterId, args } = {}) {
+    const adapter = this.adapters.find((candidate) => candidate.id === adapterId) || this.adapters[0];
+    if (!adapter) throw new Error("No Kazee channel holds calls here");
+    return adapter._callManager.outgoing(args || {});
+  }
+
+  // The opening line reads the end of the chat. The brain knows which
+  // project the chat is on now; ask it, else read the files here.
+  async _greetingContext(target) {
+    if (this.link && this.brainReady) {
+      try {
+        return await this.link.request("call.greetingContext", {
+          adapterId: target.adapter?.id, chatId: String(target.chatId), userId: String(target.userId),
+          ...(target.threadId ? { threadId: String(target.threadId) } : {}),
+        }, { timeoutMs: target.threadId ? this.timing.threadGreetingAskMs : this.timing.greetingAskMs });
+      } catch (_) {}
+    }
+    return greetingContext(target);
+  }
+
+  _carryOn(adapter, { chatId, userId, prompt, threadId = null } = {}) {
+    const carry = { adapterId: adapter.id, chatId: String(chatId), userId: String(userId), prompt: String(prompt || ""), ...(threadId ? { threadId: String(threadId) } : {}) };
+    if (this.link && this.brainReady) this._sendCarryOn(carry);
+    else this._carryOns.push(carry);
+  }
+
+  _sendCarryOn(carry) {
+    const link = this.link;
+    if (!link || !this.brainReady) { this._carryOns.push(carry); return; }
+    link.request("call.carryOn", carry).catch((error) => {
+      this.log(`carry-on not handed over (${error.message}); kept for the brain`);
+      this._carryOns.push(carry);
+    });
+  }
+
+  // A full stop (pod going away, launchd stop): end calls properly so the
+  // caller's app hangs up now, not after chat-central's 20 s grace.
+  async stop(reason = "stop") {
+    this.stopping = true;
+    clearInterval(this._pump);
+    for (const adapter of this.adapters) {
+      try { await adapter._callManager.shutdown?.(`switchboard-${String(reason).toLowerCase().replace(/[^a-z0-9]+/g, "-")}`); } catch (_) {}
+      try { adapter.stopCalls?.(); } catch (_) {}
+    }
+  }
+}
+
+module.exports = { CallHost, LINES, JOB_FIELDS, JOB_FUNCTIONS, mirrorOf };