@inetafrica/open-claudia 3.4.14 → 3.4.16

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

@@ -6,58 +6,104 @@ const { speechBearerToken } = require("../../../core/media");
 const ttsVoice = require("../../../core/tts-voice");
 
 class SpeechStream {
-  constructor({ baseUrl = SPEECH_SERVICE_URL, token = speechBearerToken(), WebSocketImpl = WebSocket, onTranscript, onPartial } = {}) {
+  constructor({ baseUrl = SPEECH_SERVICE_URL, token = speechBearerToken(), WebSocketImpl = WebSocket, onTranscript, onPartial, onDisconnect } = {}) {
     this.baseUrl = String(baseUrl || "").replace(/\/$/, "");
     this.token = token;
     this.WebSocketImpl = WebSocketImpl;
     this.onTranscript = onTranscript || (() => {});
     this.onPartial = onPartial || (() => {});
+    this.onDisconnect = onDisconnect || (() => {});
     this.socket = null;
     this.ready = null;
+    this.protocol = 1;
+    this._protocolCommitted = false;
+    this.segmentId = 1;
+    this.streamId = 0;
+    this.closed = false;
   }
 
   async connect() {
+    if (this.closed) throw new Error("Speech stream is closed");
     if (this.ready) return this.ready;
     if (!this.baseUrl || !this.token) throw new Error("Hosted speech service is not configured");
     const url = this.baseUrl.replace(/^http/, "ws") + "/v1/audio/transcriptions/stream";
     this.ready = new Promise((resolve, reject) => {
       const ws = new this.WebSocketImpl(url, { headers: { Authorization: `Bearer ${this.token}` } });
       this.socket = ws;
+      this.segmentId = 1;
+      this.protocol = 1;
+      this._protocolCommitted = false;
+      const streamId = ++this.streamId;
       ws.once("open", () => {
-        ws.send(JSON.stringify({ sample_rate: 16000, language: "en" }));
+        if (this.closed || this.socket !== ws) return reject(new Error("Speech stream is closed"));
+        ws.send(JSON.stringify({ sample_rate: 16000, language: "en", protocol: 2 }));
         resolve();
       });
       ws.once("error", reject);
-      ws.on("message", (raw) => this._onMessage(raw));
-      ws.on("close", () => { this.socket = null; this.ready = null; });
+      ws.on("message", (raw) => { if (this.socket === ws && !this.closed) this._onMessage(raw, streamId); });
+      ws.on("close", () => {
+        reject(new Error("Speech stream disconnected"));
+        if (this.socket !== ws) return;
+        this.socket = null;
+        this.ready = null;
+        this.protocol = 1;
+        this._protocolCommitted = false;
+        this.onDisconnect({ streamId });
+      });
     });
     return this.ready;
   }
 
   async audio(pcm16k) {
-    await this.connect();
-    if (this.socket?.readyState === this.WebSocketImpl.OPEN) this.socket.send(pcm16k);
+    const pending = this.connect();
+    const socket = this.socket;
+    await pending;
+    if (this.closed || this.socket !== socket) return;
+    if (socket?.readyState === this.WebSocketImpl.OPEN) socket.send(pcm16k);
   }
 
-  async commit() {
-    await this.connect();
-    this.socket.send(JSON.stringify({ type: "commit" }));
+  commitTurn() {
+    const connected = this.connect();
+    const streamId = this.streamId;
+    const segmentId = this.segmentId++;
+    // The session has already selected bookkeeping for this protocol. Pin it
+    // for this socket before any asynchronous send or delayed ready frame.
+    // V2 servers accept V1 commits too, so an early turn can safely retain
+    // legacy behavior until reconnect; it cannot switch final-routing mid-turn.
+    this._protocolCommitted = true;
+    const protocol = this.protocol;
+    const pending = connected.then(() => {
+      if (this.closed || streamId !== this.streamId || !this.socket) throw new Error("Speech stream disconnected before commit");
+      this.socket.send(JSON.stringify({ type: "commit", ...(protocol === 2 ? { segment_id: segmentId } : {}) }));
+    });
+    return { streamId, segmentId, pending };
   }
 
-  _onMessage(raw) {
+  commit() { return this.commitTurn().pending; }
+
+  _onMessage(raw, streamId = this.streamId) {
     let message;
     try { message = JSON.parse(raw.toString()); } catch (_) { return; }
+    if (!message || typeof message !== "object" || Array.isArray(message)) return;
+    if (message.type === "ready" && message.protocol === 2 && message.segment_id === 1) {
+      if (!this._protocolCommitted) this.protocol = 2;
+      return;
+    }
+    const meta = { streamId, segmentId: message.segment_id, protocol: this.protocol };
+    if (this.protocol === 2 && (!Number.isSafeInteger(meta.segmentId) || meta.segmentId < 1)) return;
     const text = String(message.text || message.transcript || "").trim();
-    if (!text) return;
     if (message.final === true || message.type === "final" || message.type === "transcription") {
-      Promise.resolve(this.onTranscript(text)).catch((error) => console.error("Kazee call transcript:", error.message));
-    } else {
+      // Empty finals are meaningful: they close that segment without reusing
+      // an earlier partial. The session owns exactly-once dispatch.
+      Promise.resolve(this.onTranscript(text, meta)).catch((error) => console.error("Kazee call transcript:", error.message));
+    } else if (text && message.type === "partial") {
       // Interims drive word-based turn-end detection; they were previously discarded.
-      Promise.resolve(this.onPartial(text)).catch((error) => console.error("Kazee call partial:", error.message));
+      Promise.resolve(this.onPartial(text, meta)).catch((error) => console.error("Kazee call partial:", error.message));
     }
   }
 
   close() {
+    this.closed = true;
     const ws = this.socket;
     this.socket = null;
     this.ready = null;
@@ -66,13 +112,13 @@ class SpeechStream {
   }
 }
 
-async function synthesizePcm(text, { baseUrl = SPEECH_SERVICE_URL, token = speechBearerToken(), fetchImpl = fetch } = {}) {
+async function synthesizePcm(text, { baseUrl = SPEECH_SERVICE_URL, token = speechBearerToken(), fetchImpl = fetch, signal } = {}) {
   if (!baseUrl || !token) throw new Error("Hosted speech service is not configured");
   const response = await fetchImpl(`${String(baseUrl).replace(/\/$/, "")}/v1/audio/speech`, {
     method: "POST",
     headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
     body: JSON.stringify({ input: text, voice: ttsVoice.getVoice(), response_format: "pcm" }),
-    signal: AbortSignal.timeout(60000),
+    signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(60000)]) : AbortSignal.timeout(60000),
   });
   if (!response.ok) throw new Error(`Hosted TTS failed: HTTP ${response.status}`);
   const contentType = response.headers?.get?.("content-type") || "";
@@ -83,13 +129,13 @@ async function synthesizePcm(text, { baseUrl = SPEECH_SERVICE_URL, token = speec
 
 // Same endpoint as synthesizePcm, but yields PCM chunks as they arrive so
 // playback can start on the first byte instead of after the full download.
-async function synthesizeStream(text, { baseUrl = SPEECH_SERVICE_URL, token = speechBearerToken(), fetchImpl = fetch } = {}) {
+async function synthesizeStream(text, { baseUrl = SPEECH_SERVICE_URL, token = speechBearerToken(), fetchImpl = fetch, signal } = {}) {
   if (!baseUrl || !token) throw new Error("Hosted speech service is not configured");
   const response = await fetchImpl(`${String(baseUrl).replace(/\/$/, "")}/v1/audio/speech`, {
     method: "POST",
     headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
     body: JSON.stringify({ input: text, voice: ttsVoice.getVoice(), response_format: "pcm" }),
-    signal: AbortSignal.timeout(90000),
+    signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(90000)]) : AbortSignal.timeout(90000),
   });
   if (!response.ok) throw new Error(`Hosted TTS failed: HTTP ${response.status}`);
   const contentType = response.headers?.get?.("content-type") || "";
@@ -111,4 +157,35 @@ async function synthesizeStream(text, { baseUrl = SPEECH_SERVICE_URL, token = sp
   return { sampleRate: rate, chunks: chunks() };
 }
 
-module.exports = { SpeechStream, synthesizePcm, synthesizeStream };
+const CUE_PHRASES = Object.freeze({ none: "", acknowledge: "Mhm.", wait: "One moment.", working: "I'm checking that." });
+
+async function controllerRequest(path, body, { baseUrl = SPEECH_SERVICE_URL, token = speechBearerToken(), fetchImpl = fetch, signal, binary = false } = {}) {
+  if (!baseUrl || !token) throw new Error("Hosted speech controller is not configured");
+  const response = await fetchImpl(`${String(baseUrl).replace(/\/$/, "")}/v1/audio/${path}`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${token}`, "Content-Type": binary ? "application/octet-stream" : "application/json" },
+    body: binary ? body : JSON.stringify(body),
+    signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(1800)]) : AbortSignal.timeout(1800),
+  });
+  if (!response.ok) throw new Error("Hosted speech controller unavailable");
+  const result = await response.json();
+  if (!result || typeof result !== "object" || Array.isArray(result)) throw new Error("Invalid controller response");
+  return result;
+}
+
+async function detectTurn(pcm16, options = {}) {
+  const result = await controllerRequest("turn", pcm16, { ...options, binary: true });
+  if (typeof result.complete !== "boolean" || typeof result.probability !== "number" ||
+      !Number.isFinite(result.probability) || result.probability < 0 || result.probability > 1) throw new Error("Invalid turn decision");
+  return { complete: result.complete, probability: result.probability };
+}
+
+async function selectAcknowledgement(text, state = "waiting", options = {}) {
+  const allowed = { listening: ["none", "acknowledge"], waiting: ["none", "wait"], working: ["none", "working"] }[state];
+  if (!allowed) return "";
+  const result = await controllerRequest("acknowledgement", { text: String(text).slice(-1000), state }, options);
+  // Never speak remote free text. A cue is selected from our fixed dictionary.
+  return allowed.includes(result.choice) ? CUE_PHRASES[result.choice] : "";
+}
+
+module.exports = { SpeechStream, synthesizePcm, synthesizeStream, detectTurn, selectAcknowledgement, CUE_PHRASES };

package/channels/kazee/call/turn-gate.js

@@ -0,0 +1,62 @@
+"use strict";
+
+// Acoustic silence proposes a boundary; the remote audio model may confirm it.
+// Keep ingesting while it decides. Resumed speech fences every old decision.
+class SpeechTurnGate {
+  constructor({ decide, commit, holdMs = 1300, maxBytes = 256000 } = {}) {
+    this.decide = decide;
+    this.commit = commit;
+    this.holdMs = holdMs;
+    this.maxBytes = maxBytes;
+    this.frames = [];
+    this.bytes = 0;
+    this.pending = null;
+    this.closed = false;
+  }
+
+  audio(frame) {
+    if (this.closed) return;
+    this.frames.push(Buffer.from(frame));
+    this.bytes += frame.length;
+    while (this.bytes > this.maxBytes && this.frames.length > 1) this.bytes -= this.frames.shift().length;
+  }
+
+  resume() { this._cancel(); }
+
+  candidate(reason) {
+    if (this.closed || this.pending) return;
+    if (reason === "max-duration") return this._finish(reason);
+    const candidate = { controller: new AbortController(), timer: null };
+    this.pending = candidate;
+    // Acoustic VAD already waited 700ms. Model uncertainty/service failure
+    // extends that to two seconds, while resumed speech keeps the same turn.
+    candidate.timer = setTimeout(() => {
+      if (this.pending === candidate) this._finish("silence-deadline");
+    }, this.holdMs);
+    candidate.timer.unref?.();
+    const audio = Buffer.concat(this.frames).subarray(-this.maxBytes);
+    Promise.resolve().then(() => this.decide(audio, { signal: candidate.controller.signal })).then(result => {
+      if (this.closed || this.pending !== candidate) return;
+      if (result?.complete === true) this._finish("semantic-complete");
+    }).catch(() => {}); // The bounded acoustic fallback remains armed.
+  }
+
+  _finish(reason) {
+    this._cancel();
+    this.frames = [];
+    this.bytes = 0;
+    this.commit(reason);
+  }
+
+  _cancel() {
+    if (!this.pending) return;
+    clearTimeout(this.pending.timer);
+    this.pending.controller.abort();
+    this.pending = null;
+  }
+
+  reset() { this._cancel(); this.frames = []; this.bytes = 0; }
+  close() { this.closed = true; this.reset(); }
+}
+
+module.exports = { SpeechTurnGate };

package/core/call-speech.js

@@ -0,0 +1,111 @@
+"use strict";
+
+// Explicit user-facing speech, never provider previews or reasoning. Leases
+// are memory-only, activated at spawn and revoked when that run/turn ends.
+const crypto = require("crypto");
+const { runInChat } = require("./context");
+const { redactSensitive, stripTerminalControls } = require("./redact");
+const leases = new Map();
+
+function failure(status, message) {
+  return Object.assign(new Error(message), { status });
+}
+
+function prepare(store, runContext) {
+  const adapter = store?.adapter;
+  if (!runContext.liveCall || runContext.purpose !== "foreground" ||
+      typeof adapter?.speakSentence !== "function" ||
+      typeof adapter?.isCallTurnActive !== "function" || !adapter.callTurn?.signal) return null;
+  const context = { ...store };
+  const token = crypto.randomBytes(32).toString("hex");
+  const origin = {
+    adapter: String(store.adapter.id || ""), channelId: String(store.channelId || ""),
+    userId: String(store.userId || ""), canonicalUserId: String(store.canonicalUserId || ""),
+    originRunId: String(runContext.runId || ""),
+  };
+  const requests = new Map();
+  const completedText = [];
+  let active = false, closed = false, busy = false, timer = null;
+  const signal = adapter.callTurn.signal;
+  const valid = () => active && !closed && !signal.aborted && adapter.isCallTurnActive();
+  const close = () => {
+    closed = true;
+    active = false;
+    clearTimeout(timer);
+    signal.removeEventListener("abort", close);
+    leases.delete(token);
+    if (busy) adapter.cancelCallSpeech?.();
+  };
+  const lease = {
+    token,
+    activate() {
+      if (active || closed || signal.aborted || !adapter.isCallTurnActive()) return;
+      if (leases.size >= 64) return;
+      active = true;
+      leases.set(token, lease);
+      signal.addEventListener("abort", close, { once: true });
+      timer = setTimeout(close, Math.min(runContext.timeoutMs || 1800000, 1800000));
+      timer.unref?.();
+    },
+    close,
+    async speak(payload) {
+      if (!valid() || Object.entries(origin).some(([key, value]) => String(payload[key] || "") !== value)) {
+        throw failure(409, "Call speech request is stale or belongs to another turn");
+      }
+      const rawText = typeof payload.text === "string" ? payload.text.trim() : "";
+      const id = payload.requestId;
+      if (!rawText || rawText.length > 450 || typeof id !== "string" || !/^[A-Za-z0-9_-]{1,80}$/.test(id)) {
+        throw failure(400, "Provide a request ID and 1–450 characters of spoken text");
+      }
+      const text = redactSensitive(stripTerminalControls(rawText)).trim();
+      if (!text) throw failure(400, "Spoken text is empty after sanitizing");
+      const previous = requests.get(id);
+      if (previous) {
+        if (previous.text !== text) throw failure(409, "Speech request ID already used for different text");
+        return { ...await previous.promise, duplicate: true };
+      }
+      if (busy || requests.size >= 8) throw failure(429, "Call speech is busy or this turn reached its limit");
+      busy = true;
+      const promise = runInChat(context, async () => {
+        try {
+          let guarded;
+          try { guarded = require("./relationship").isCurrentSpeakerGuarded(); }
+          catch (_) { throw failure(403, "Unable to verify the speech recipient"); }
+          if (guarded) {
+            let result;
+            try { result = await require("./enforcer").guardOutboundReply([...completedText, text].join(" ")); }
+            catch (_) { throw failure(403, "Unable to verify the spoken reply"); }
+            if (!result?.allow) throw failure(403, "Spoken reply held by the reply guard");
+          }
+          if (!valid()) throw failure(409, "Call speech request was cancelled");
+          const spoken = await adapter.speakSentence(text);
+          if (!valid() || spoken !== true) throw failure(409, "Call speech was interrupted");
+          completedText.push(text);
+          return { ok: true, spoken: true, duplicate: false };
+        } finally { busy = false; }
+      });
+      requests.set(id, { text, promise });
+      return promise;
+    },
+  };
+  return lease;
+}
+
+async function speak(payload) {
+  const lease = leases.get(payload.callSpeechToken);
+  if (!lease) throw failure(409, "No active speech permission for this call turn");
+  return lease.speak(payload);
+}
+
+function unspokenSuffix(text, spoken) {
+  let rest = String(text).trim().replace(/\s+/g, " ");
+  for (const piece of spoken) {
+    const prefix = piece.trim().replace(/\s+/g, " ");
+    if (rest === prefix) return "";
+    if (!rest.startsWith(prefix + " ")) break;
+    rest = rest.slice(prefix.length).trimStart();
+  }
+  return rest;
+}
+
+module.exports = { prepare, speak, unspokenSuffix };

package/core/loopback.js

@@ -83,7 +83,7 @@ const JSON_KINDS = new Set([
   "relay-send", "recent-fetch", "audit-tail",
   "auth-list", "auth-revoke",
   "approval-request",
-  "say", "call", "tts", "transcribe",
+  "say", "call-say", "call", "tts", "transcribe",
 ]);
 
 // Owner gate for identity-sensitive kinds. The claimed canonicalUserId comes
@@ -171,6 +171,15 @@ async function handleJson(req, res, url, kind) {
   const adapter = registry.findAdapter(adapterId);
   if (!adapter) return reply(res, 400, { error: `unknown adapter ${adapterId}` });
 
+  if (kind === "call-say") {
+    try {
+      const result = await require("./call-speech").speak({ ...payload, channelId, userId, adapter: adapterId });
+      return reply(res, 200, result);
+    } catch (error) {
+      return reply(res, error.status || 503, { error: error.status ? error.message : "Call speech unavailable" });
+    }
+  }
+
   if (kind === "say") {
     const text = String(payload.text || "").trim();
     if (!text) return reply(res, 400, { error: "missing text" });

package/core/providers/env.js

@@ -51,6 +51,7 @@ const CONTROL_PLANE_KEYS = Object.freeze([
   "KAZEE_BOT_TOKEN",
   "BOT_CONTROL_TOKEN",
   "OC_SEND_TOKEN",
+  "OC_CALL_SPEECH_TOKEN",
   "VOICE_BRIDGE_TOKEN",
   "ELEVENLABS_API_KEY",
   "SPEECH_API_KEY",

package/core/run-context.js

@@ -97,8 +97,12 @@ function captureRunContext({
     throw error;
   }
   const project = projectSnapshot(state, cwd, opts.project);
+  // A phone turn carries the mandatory core/rules, selective recall and an
+  // explicit bounded call transcript. Never resume or replace the long coding
+  // session associated with the same chat room.
+  const liveCall = store?.adapter?.liveCall === true;
   const activeSessionId = state.activeSessions?.[project.name]?.[provider] || null;
-  const requestedSessionId = opts.fresh
+  const requestedSessionId = opts.fresh || liveCall
     ? null
     : (opts.resumeSessionId || activeSessionId || null);
   // A quarantined session's provider-side context tripped a safety refusal;
@@ -141,17 +145,20 @@ function captureRunContext({
     cwd: cwd || project.dir || null,
     replyToMsgId: replyToMsgId == null ? null : String(replyToMsgId),
     userPrompt: prompt,
-    fresh: !!opts.fresh || quarantinedResume,
-    continueSession: quarantinedResume ? false : !!opts.continueSession,
-    resumeSessionId: quarantinedResume ? null : (opts.resumeSessionId || null),
+    fresh: !!opts.fresh || liveCall || quarantinedResume,
+    continueSession: quarantinedResume || liveCall ? false : !!opts.continueSession,
+    resumeSessionId: quarantinedResume || liveCall ? null : (opts.resumeSessionId || null),
     quarantinedResume,
-    skipAutoCompact: !!opts.skipAutoCompact,
+    skipAutoCompact: liveCall || !!opts.skipAutoCompact,
     timeoutMs: Number.isFinite(opts.timeoutMs) ? opts.timeoutMs : null,
     maxTurns: Number.isFinite(opts.maxTurns) ? opts.maxTurns : null,
     imagePaths: cloneSerializable(opts.imagePaths || opts.images || [], "image paths"),
     attachments: cloneSerializable(opts.attachments || [], "attachments"),
     lastInputWasVoice: !!state.lastInputWasVoice,
     voiceStream: !!opts.voiceStream || (!!state.lastInputWasVoice && origin.transport === "voice"),
+    liveCall,
+    callHistory: liveCall
+      ? cloneSerializable(store.adapter.callHistory || [], "call history") : [],
     readOnly: opts.readOnly === true,
     permissionMode: opts.permissionMode || null,
     transcriptRole: opts.transcriptRole || null,
@@ -159,7 +166,7 @@ function captureRunContext({
     toolHookSettings: opts.toolHookSettings || null,
     allowReadOnlyWithoutToolHook: opts.allowReadOnlyWithoutToolHook === true,
     requiredDelivery: opts.requiredDelivery !== false,
-    attachSession: opts.attachSession !== false,
+    attachSession: !liveCall && opts.attachSession !== false,
     occurrenceId: opts.occurrenceId || null,
     scheduledJobId: opts.scheduledJobId || null,
     originRunId: opts.originRunId || null,

package/core/runner.js

@@ -706,10 +706,10 @@ function preflightFailureResult(runContext, provider, failure) {
   };
 }
 
-function cancelledRunResult(runContext, provider) {
+function cancelledRunResult(runContext, provider, message = "Cancelled by /stop before the provider started") {
   const result = preflightFailureResult(runContext, provider, {
     code: "RUN_CANCELLED",
-    message: "Cancelled by /stop before the provider started",
+    message,
   });
   result.status = "cancelled";
   return result;
@@ -783,6 +783,9 @@ function createRunnerService(dependencies = {}) {
       dependencies,
       capture,
     );
+    if (!capture && dependencies.isObsolete?.()) {
+      return settleImmediateRunResult(cancelledCallRunResult(runContext), runContext, dependencies, capture);
+    }
     let provider;
     try {
       provider = resolveProvider(runContext.provider);
@@ -833,6 +836,9 @@ function createRunnerService(dependencies = {}) {
     // after the slow prompt build and before anything spawns. Persistence
     // still settles (the transcript records the cancelled turn); delivery is
     // suppressed downstream via the RUN_CANCELLED code.
+    if (!capture && dependencies.isObsolete?.()) {
+      return settleImmediateRunResult(cancelledCallRunResult(runContext), runContext, dependencies, capture);
+    }
     if (dependencies.shouldAbort && dependencies.shouldAbort(runContext, { capture })) {
       return settleImmediateRunResult(cancelledRunResult(runContext, provider), runContext, dependencies, capture);
     }
@@ -1766,6 +1772,7 @@ async function deliverForegroundResult(result, runContext, state = currentState(
 
 function decorateForegroundInvocation(invocation, runContext, bundle) {
   const env = { ...invocation.env };
+  delete env.OC_CALL_SPEECH_TOKEN;
   const lb = loopback.info();
   const compactionStage = runContext.purpose === "compact-summary" || runContext.purpose === "compact-seed";
   if (!compactionStage) {
@@ -1928,6 +1935,11 @@ function createStreamPreview({ state, store }) {
 }
 
 function createForegroundService({ state, store, stopTyping, capture, ownsAdmissionLock, persistCapture = true }) {
+  const callSpeechLeases = 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`);
+  };
   const persistEffects = !capture || persistCapture;
   const preview = capture ? null : createStreamPreview({ state, store });
   // Chat-visibility + learning-signal layer (skill/pack/tool announcements,
@@ -1936,20 +1948,36 @@ function createForegroundService({ state, store, stopTyping, capture, ownsAdmiss
   const service = createRunnerService({
     getState: () => state,
     getStore: () => store,
+    isObsolete: () => obsoleteCallTurn(store),
     resolveProvider: resolveForegroundProvider,
-    buildTurnPrompt,
+    buildTurnPrompt(prompt, opts) {
+      callStage("preparing", opts.runContext);
+      return buildTurnPrompt(prompt, opts);
+    },
     buildInvocation(provider, context) {
       if (context.purpose === "compact-seed" && typeof provider.buildCompactionInvocation === "function") {
         return provider.buildCompactionInvocation(context);
       }
       return provider.buildMainInvocation(context);
     },
-    decorateInvocation: decorateForegroundInvocation,
+    decorateInvocation(invocation, runContext, bundle) {
+      const decorated = decorateForegroundInvocation(invocation, runContext, bundle);
+      if (!capture) {
+        const lease = require("./call-speech").prepare(store, runContext);
+        if (lease) {
+          callSpeechLeases.set(runContext.runId, lease);
+          decorated.env.OC_CALL_SPEECH_TOKEN = lease.token;
+        }
+      }
+      return decorated;
+    },
     persistTranscript: persistEffects ? ((result, runContext) => persistForegroundTranscript(result, runContext, state)) : null,
     persistUsage: persistEffects ? ((result, runContext) => persistForegroundUsage(result, runContext, state, store)) : null,
     persistSession: persistEffects ? ((result, runContext) => persistForegroundSession(result, runContext, state)) : null,
     deliver: capture ? null : (result, runContext) => deliverForegroundResult(result, runContext, state),
-    onSpawn(proc) {
+    onSpawn(proc, runContext) {
+      callStage("started", runContext);
+      callSpeechLeases.get(runContext.runId)?.activate();
       state.runningProcess = proc;
       if (ownsAdmissionLock) state.preparingRun = false;
     },
@@ -1960,10 +1988,13 @@ function createForegroundService({ state, store, stopTyping, capture, ownsAdmiss
       return true;
     },
     onPromptBundle(bundle, runContext) {
+      callStage("prompt-ready", runContext);
       if (!observer || runContext.purpose !== "foreground") return;
       observer.onRecallSurfaced(bundle.recallMetadata);
     },
     onEvent(event, runContext) {
+      if (event.type === "result" || event.type === "error") callStage("finished", runContext);
+      if (event.type === "result" || event.type === "error") callSpeechLeases.get(runContext.runId)?.close();
       // Streaming text reads as "typing"; tool work re-enters "thinking" so
       // the chip doesn't decay to a stale "typing" through long tool stretches.
       const phaseBefore = state.thinkingPhase;
@@ -1991,7 +2022,9 @@ function createForegroundService({ state, store, stopTyping, capture, ownsAdmiss
       return send(`⚠️ ${warning.message}`);
     },
     onStderr(chunk) { console.error("PROVIDER STDERR:", redactSensitive(chunk)); },
-    cleanup: async (proc) => {
+    cleanup: async (proc, _details, runContext) => {
+      callSpeechLeases.get(runContext.runId)?.close();
+      callSpeechLeases.delete(runContext.runId);
       if (state.runningProcess === proc) state.runningProcess = null;
       // Keep the single-flight lock armed while transcript/usage/session
       // persistence and required delivery settle after child close.
@@ -2052,9 +2085,34 @@ function deferredRunResult() {
   return { promise, resolve, reject };
 }
 
+function obsoleteCallTurn(store) {
+  return store?.adapter?.liveCall === true && store.adapter.callTurn?.signal.aborted === true;
+}
+
+function cancelledCallRunResult(runContext) {
+  return cancelledRunResult(runContext, { id: runContext.provider, label: runContext.provider }, "Call turn superseded or ended before execution");
+}
+
+function cancelQueuedCallOnAbort(state, item) {
+  if (item.store?.adapter?.liveCall !== true) return;
+  const signal = item.store.adapter.callTurn?.signal;
+  if (!signal) return;
+  const cancel = () => {
+    const index = state.messageQueue.indexOf(item);
+    if (index < 0) return; // Already admitted: pre-spawn checks and speech fences take over.
+    state.messageQueue.splice(index, 1);
+    item.disposeCallListener?.();
+    item.deferred.resolve(cancelledCallRunResult(item.runContext));
+  };
+  item.disposeCallListener = () => signal.removeEventListener("abort", cancel);
+  signal.addEventListener("abort", cancel, { once: true });
+  if (signal.aborted) cancel();
+}
+
 function drainQueuedMessages(state) {
   if (!Array.isArray(state.messageQueue) || !state.messageQueue.length || state.runningProcess || state.preparingRun) return Promise.resolve();
   const item = state.messageQueue.shift();
+  item.disposeCallListener?.();
   state.preparingRun = true;
   setImmediate(() => {
     const execute = () => executeAdmittedRun(item.runContext, state, item.store, false, true);
@@ -2177,7 +2235,7 @@ async function executeAdmittedRun(runContext, state, store, capture, ownsAdmissi
       result.diagnostic = providerRunDiagnostic(result, runContext) || result.error.message;
     }
   }
-  if (!capture && result.ok && state.messageQueue.length === 0 && sameCapturedProject(state, runContext) && shouldAutoCompact(state)) {
+  if (!capture && !runContext.skipAutoCompact && result.ok && state.messageQueue.length === 0 && sameCapturedProject(state, runContext) && shouldAutoCompact(state)) {
     try { await compactActiveSession(runContext.project.dir, { notify: false }); }
     catch (error) { console.warn(`[proactive-compact] failed: ${redactSensitive(error.message)}`); }
   }
@@ -2219,6 +2277,7 @@ function runAgent(prompt, cwd, replyToMsgId, opts = {}) {
     voiceStream: opts.voiceStream !== undefined ? opts.voiceStream : admitted.voiceStream,
   });
 
+  if (obsoleteCallTurn(store)) return Promise.resolve(cancelledCallRunResult(runContext));
   if (!acquireRunLock(state)) {
     if (shouldStartSideChat(state, runContext, opts, sideChatCoordinator)) {
       return sideChatCoordinator.respond({
@@ -2229,6 +2288,7 @@ function runAgent(prompt, cwd, replyToMsgId, opts = {}) {
     }
     const deferred = deferredRunResult();
     state.messageQueue.push({ runContext, store, deferred, queuedAt: Date.now() });
+    cancelQueuedCallOnAbort(state, state.messageQueue.at(-1));
     // Transient queue/compaction acks are a chat-UX affordance (Telegram/Kazee).
     // On a Spaces task thread they'd post a throwaway "Queued." comment on the
     // task — noise. On a live call, send() is the TTS line: "Queued." would be
@@ -2243,6 +2303,7 @@ function runAgent(prompt, cwd, replyToMsgId, opts = {}) {
 
 function shouldStartSideChat(state, runContext, opts = {}, coordinator = sideChatCoordinator) {
   return !!state?.runningProcess
+    && !runContext?.liveCall
     && opts.sideChat !== false
     && runContext?.purpose === "foreground"
     && coordinator.enabled();
@@ -2332,6 +2393,7 @@ module.exports = {
   capturedTranscriptMetadata,
   decorateForegroundInvocation,
   createRunnerService,
+  createForegroundService,
   createSideChatService,
   createSideChatQueueItem,
   finalizeSideChatQueueItem,