@inetafrica/open-claudia 3.4.14 → 3.4.16

package/test-kazee-call-session.js

@@ -2,7 +2,9 @@
 "use strict";
 
 const assert = require("assert");
+const { EventEmitter } = require("events");
 const { KazeeCallSession } = require("./channels/kazee/call/session");
+const { SpeechStream } = require("./channels/kazee/call/speech-client");
 const { KazeeCallManager } = require("./channels/kazee/call/manager");
 const { OpusAudioCodec, WEBRTC_SAMPLES } = require("./channels/kazee/call/audio");
 
@@ -63,6 +65,46 @@ function toneOpus(codec, amplitude) {
   return codec.encode(pcm);
 }
 
+async function testDelayedSpeechProtocolReady() {
+  class DelayedWebSocket extends EventEmitter {
+    static OPEN = 1;
+    constructor() {
+      super(); this.readyState = 1; this.sent = [];
+      queueMicrotask(() => this.emit("open"));
+    }
+    send(value) { this.sent.push(value); }
+    close() { this.readyState = 3; this.emit("close"); }
+  }
+  const { session, transcripts } = makeSession();
+  await session._subscribe(901, "peer");
+  const sub = session.subscribers.get(901);
+  sub.stt.close();
+  sub.stt = new SpeechStream({
+    baseUrl: "https://speech.example", token: "fixture", WebSocketImpl: DelayedWebSocket,
+    onTranscript: (text, meta) => session._onFeedFinal(901, text, meta),
+  });
+  try {
+    await sub.stt.connect();
+    session._commitTurn(901, "silence");
+    await wait(0);
+    const socket = sub.stt.socket;
+    // The caller finished before the gateway delivered its protocol greeting.
+    socket.emit("message", JSON.stringify({ type: "ready", protocol: 2, segment_id: 1 }));
+    socket.emit("message", JSON.stringify({ type: "final", segment_id: 1, text: "The complete question." }));
+    await Promise.resolve();
+    assert.deepStrictEqual(transcripts.map(t => t.text), ["The complete question."],
+      "late protocol negotiation must not orphan a committed final");
+    assert.strictEqual(sub.finalTimer, null, "a delivered final cancels the fallback");
+    session._commitTurn(901, "silence");
+    await wait(0);
+    socket.emit("message", JSON.stringify({ type: "final", segment_id: 2, text: "The next question." }));
+    await Promise.resolve();
+    assert.deepStrictEqual(transcripts.map(t => t.text), ["The complete question.", "The next question."]);
+    assert.deepStrictEqual(socket.sent.slice(1).map(JSON.parse), [{ type: "commit" }, { type: "commit" }],
+      "the connection keeps the same compatible commit format after its first turn");
+  } finally { await session.close(); }
+}
+
 async function testSpeakSerialization() {
   const writes = [];
   const synthCalls = [];
@@ -169,7 +211,7 @@ async function testHoldForWords() {
   sub.stt.onPartial("hello there");
   assert.strictEqual(sub.stt.commits, 1, "first words release the held commit");
   assert.strictEqual(sub.awaitingWordsSince, 0);
-  assert(session._thinkTimer, "released commit acks and thinks like a normal turn");
+  assert.strictEqual(session._thinkTimer, null, "an unfinished transcript is not acknowledged");
   gen.close();
   await session.close();
 }
@@ -242,6 +284,106 @@ async function testTrickleBuffering() {
   await session.close();
 }
 
+async function testNoiseAfterFallbackCannotReplayPreviousUtterance() {
+  const { session, transcripts } = makeSession({ finalWaitMs: 30 });
+  await session._subscribe(101, "caller");
+  const sub = session.subscribers.get(101);
+  sub.stt.onPartial("I can hear you");
+  session._commitTurn(101, "silence");
+  await wait(60);
+  sub.noiseCommit = true;
+  session._commitTurn(101, "no-words");
+  await wait(60);
+  assert.deepStrictEqual(transcripts.map(t => t.text), ["I can hear you"], "a following noise turn cannot replay a consumed partial");
+  await session.close();
+}
+
+async function testVersionedFinalsBelongToTheirCommittedSegment() {
+  const { session, transcripts } = makeSession({ finalWaitMs: 30 });
+  await session._subscribe(101, "caller");
+  const sub = session.subscribers.get(101);
+  Object.assign(sub.stt, { protocol: 2, streamId: 1, segmentId: 1 });
+  sub.stt.commitTurn = () => ({ streamId: 1, segmentId: sub.stt.segmentId++, pending: Promise.resolve() });
+  session._onFeedPartial(101, "only the start", { protocol: 2, streamId: 1, segmentId: 1 });
+  session._commitTurn(101, "silence");
+  await wait(60);
+  assert.strictEqual(transcripts.length, 0, "versioned service must complete the segment rather than dispatch an unfinished partial");
+  session._onFeedPartial(101, "another thought", { protocol: 2, streamId: 1, segmentId: 2 });
+  session._commitTurn(101, "silence");
+  session._onFeedFinal(101, "the whole first thought", { protocol: 2, streamId: 1, segmentId: 1 });
+  session._onFeedFinal(101, "duplicate", { protocol: 2, streamId: 1, segmentId: 1 });
+  session._onFeedFinal(101, "", { protocol: 2, streamId: 1, segmentId: 2 });
+  assert.deepStrictEqual(transcripts.map(t => t.text), ["the whole first thought"]);
+  assert.strictEqual(transcripts[0].meta.utteranceId, "1:1");
+  await session.close();
+}
+
+async function testSemanticPauseResumesWithoutSplittingAudio() {
+  const { session } = makeSession();
+  const decisions = [];
+  session.turnDecision = (audio, { signal }) => new Promise(resolve => decisions.push({ resolve, signal, bytes: audio.length }));
+  await session._subscribe(101, "caller");
+  const sub = session.subscribers.get(101);
+  Object.assign(sub.stt, { protocol: 2, streamId: 1, segmentId: 1 });
+  sub.stt.commitTurn = () => {
+    sub.stt.commits++;
+    return { streamId: 1, segmentId: sub.stt.segmentId++, pending: Promise.resolve() };
+  };
+  const codec = new OpusAudioCodec();
+  const speech = () => { for (let i = 0; i < 3; i++) session._onFeedRtp(101, { payload: toneOpus(codec, 12000) }); };
+  const silence = () => { for (let i = 0; i < 36; i++) session._onFeedRtp(101, { payload: toneOpus(codec, 30) }); };
+  speech(); silence();
+  await wait(1);
+  assert.strictEqual(decisions.length, 1);
+  const captured = sub.stt.audioFrames.length;
+  speech();
+  assert(decisions[0].signal.aborted, "resumed speech cancels the old remote decision");
+  decisions[0].resolve({ complete: true });
+  await wait(1);
+  assert.strictEqual(sub.stt.commits, 0, "a late decision cannot split resumed speech");
+  assert(sub.stt.audioFrames.length > captured, "ingestion continues while the boundary is tentative");
+  silence();
+  await wait(1);
+  assert.strictEqual(decisions.length, 2);
+  assert(decisions[1].bytes > decisions[0].bytes, "the resumed thought retains its previous audio context");
+  decisions[1].resolve({ complete: true });
+  await wait(1);
+  assert.strictEqual(sub.stt.commits, 1);
+  assert.strictEqual(sub.stt.segmentId, 2);
+  codec.close();
+  await session.close();
+}
+
+async function testTurnModelFailureAndCloseAreBounded() {
+  const { SpeechTurnGate } = require("./channels/kazee/call/turn-gate");
+  const commits = [];
+  const gate = new SpeechTurnGate({ decide: async () => { throw new Error("unavailable"); }, commit: reason => commits.push(reason), holdMs: 20 });
+  gate.audio(Buffer.alloc(640));
+  gate.candidate("silence");
+  await wait(40);
+  assert.deepStrictEqual(commits, ["silence-deadline"], "model failure falls back after a bounded pause");
+  gate.audio(Buffer.alloc(640));
+  gate.candidate("silence");
+  gate.close();
+  await wait(40);
+  assert.strictEqual(commits.length, 1, "closing prevents pending model/fallback work committing");
+}
+
+async function testCancelStopsPendingTtsRequest() {
+  const { session } = makeSession();
+  let signal;
+  session.synthesizeStream = (_text, options) => new Promise((resolve, reject) => {
+    signal = options.signal;
+    signal.addEventListener("abort", () => reject(new Error("aborted")), { once: true });
+  });
+  const speaking = session.speak("answer pending first audio");
+  assert(signal && !signal.aborted);
+  session.cancelSpeech();
+  assert(signal.aborted, "barge-in aborts the HTTP request before audio arrives");
+  assert.strictEqual(await speaking, false);
+  await session.close();
+}
+
 async function testTranscriptAttribution() {
   const { session, transcripts } = makeSession({});
   await session._subscribe(101, "alice@kazee");
@@ -391,16 +533,14 @@ async function testThinkingCues() {
   const sub = session.subscribers.get(101);
   const gen = new OpusAudioCodec();
 
-  // Caller finishes a sentence: speech then sustained silence commits the turn,
-  // plays an audible "heard you" chime, and starts ticking right away — STT
-  // finalization takes seconds and must not sound like a dead line.
+  // A proposed boundary alone must not beep or claim to have heard a turn.
   for (let i = 0; i < 3; i += 1) session._onFeedRtp(101, { payload: toneOpus(gen, 12000) });
   sub.stt.onPartial("what is the status");
   for (let i = 0; i < 36; i += 1) session._onFeedRtp(101, { payload: toneOpus(gen, 30) });
   assert.strictEqual(sub.stt.commits, 1);
   await wait(60);
-  assert(frames > 0, "commit plays the ack chime");
-  assert(session._thinkTimer, "thinking loop starts at commit, before the transcript");
+  assert.strictEqual(frames, 0, "turn commit does not beep");
+  assert.strictEqual(session._thinkTimer, null, "no cue before recognized words are final");
 
   // A noise commit finalizes to empty text: nothing dispatches, so the ticks
   // stop rather than promising an answer that will never come.
@@ -421,7 +561,7 @@ async function testThinkingCues() {
   assert.strictEqual(session._thinkTimer, null, "answer playback stops the thinking loop");
 
   // A fresh thinking loop stops the moment the caller starts talking again.
-  session._startThinking();
+  session._startThinking("another question");
   for (let i = 0; i < 3; i += 1) session._onFeedRtp(101, { payload: toneOpus(gen, 12000) });
   assert.strictEqual(session._thinkTimer, null, "caller speech stops the thinking loop");
   gen.close();
@@ -611,7 +751,12 @@ async function testAssignedRelayTransportLifetime() {
   await testHoldTimeoutDropsNoiseTurn();
   await testWordStallRescue();
   await testInterimFallbackAndLateFinal();
+  await testNoiseAfterFallbackCannotReplayPreviousUtterance();
+  await testVersionedFinalsBelongToTheirCommittedSegment();
   await testTrickleBuffering();
+  await testSemanticPauseResumesWithoutSplittingAudio();
+  await testTurnModelFailureAndCloseAreBounded();
+  await testCancelStopsPendingTtsRequest();
   await testTranscriptAttribution();
   await testIdleTimeout();
   await testIdleBargeInKeepsCall();
@@ -622,5 +767,6 @@ async function testAssignedRelayTransportLifetime() {
   await testCallerModeRoomExistsAndFailure();
   await testThinkingCues();
   await testCloseResolvesSpeech();
+  await testDelayedSpeechProtocolReady();
   console.log("kazee call session: ok");
 })().catch((error) => { console.error(error); process.exitCode = 1; });

package/test-kazee-call-speech.js

@@ -2,7 +2,7 @@
 "use strict";
 const assert = require("assert");
 const { EventEmitter } = require("events");
-const { SpeechStream, synthesizePcm } = require("./channels/kazee/call/speech-client");
+const { SpeechStream, synthesizePcm, detectTurn, selectAcknowledgement } = require("./channels/kazee/call/speech-client");
 class FakeWebSocket extends EventEmitter {
   static OPEN = 1;
   constructor(url, options) { super(); this.url = url; this.options = options; this.readyState = 1; this.sent = []; queueMicrotask(() => this.emit("open")); }
@@ -14,12 +14,32 @@ class FakeWebSocket extends EventEmitter {
   const stream = new SpeechStream({ baseUrl: "https://speech.example", token: "secret", WebSocketImpl: FakeWebSocket, onTranscript: (t) => { transcript = t; } });
   await stream.connect();
   assert.strictEqual(stream.socket.url, "wss://speech.example/v1/audio/transcriptions/stream");
-  assert.deepStrictEqual(JSON.parse(stream.socket.sent[0]), { sample_rate: 16000, language: "en" });
+  assert.deepStrictEqual(JSON.parse(stream.socket.sent[0]), { sample_rate: 16000, language: "en", protocol: 2 });
   await stream.audio(Buffer.from([1, 2]));
   await stream.commit();
   assert(Buffer.isBuffer(stream.socket.sent[1]));
   stream.socket.emit("message", Buffer.from(JSON.stringify({ type: "final", text: "hello" })));
   assert.strictEqual(transcript, "hello");
+  const finals = [], partials = [];
+  const versioned = new SpeechStream({ baseUrl: "https://speech.example", token: "secret", WebSocketImpl: FakeWebSocket,
+    onTranscript: (text, meta) => finals.push({ text, meta }), onPartial: (text, meta) => partials.push({ text, meta }) });
+  await versioned.connect();
+  const oldSocket = versioned.socket;
+  oldSocket.emit("message", Buffer.from(JSON.stringify({ type: "ready", protocol: 2, segment_id: 1 })));
+  const first = versioned.commitTurn(), second = versioned.commitTurn();
+  await Promise.all([first.pending, second.pending]);
+  assert.deepStrictEqual(oldSocket.sent.slice(1).map(JSON.parse), [{ type: "commit", segment_id: 1 }, { type: "commit", segment_id: 2 }]);
+  oldSocket.emit("message", Buffer.from(JSON.stringify({ type: "final", segment_id: 1, text: "" })));
+  assert.strictEqual(finals.length, 1, "empty final is forwarded to clear the committed turn");
+  assert.strictEqual(finals[0].meta.segmentId, 1);
+  oldSocket.close();
+  assert.strictEqual(versioned.protocol, 1, "disconnect resets protocol before a new turn can commit");
+  await versioned.connect();
+  oldSocket.emit("message", Buffer.from(JSON.stringify({ type: "final", segment_id: 2, text: "stale" })));
+  assert.strictEqual(finals.length, 1, "an old socket cannot deliver into a new stream");
+  assert.strictEqual(versioned.segmentId, 1);
+  versioned.close();
+  await assert.rejects(versioned.audio(Buffer.alloc(2)), /closed/, "terminal close cannot reopen a speech connection");
   let request;
   const pcm = await synthesizePcm("Hello", { baseUrl: "https://speech.example", token: "secret", fetchImpl: async (url, options) => {
     request = { url, options }; return {
@@ -31,6 +51,22 @@ class FakeWebSocket extends EventEmitter {
   assert.strictEqual(JSON.parse(request.options.body).response_format, "pcm");
   assert.strictEqual(pcm.sampleRate, 24000);
   assert.deepStrictEqual([...pcm.pcm], [1, 2, 3]);
+  const controller = { baseUrl: "https://speech.example", token: "fixture", fetchImpl: async (_url, options) => {
+    assert.strictEqual(JSON.parse(options.body).state, "waiting");
+    return { ok: true, json: async () => ({ choice: "wait", text: "Invented answer must never be spoken" }) };
+  } };
+  assert.strictEqual(await selectAcknowledgement("A complete question", "waiting", controller), "One moment.");
+  assert.strictEqual(await selectAcknowledgement("hello", "working", { ...controller,
+    fetchImpl: async () => ({ ok: true, json: async () => ({ choice: "acknowledge", text: "Mhm." }) }),
+  }), "", "wrong-state cue is omitted");
+  await assert.rejects(detectTurn(Buffer.alloc(640), { ...controller,
+    fetchImpl: async () => ({ ok: true, json: async () => ({ complete: true, probability: 3 }) }),
+  }), /Invalid turn decision/);
+  const abort = new AbortController();
+  abort.abort();
+  await assert.rejects(synthesizePcm("cancelled", { baseUrl: "https://speech.example", token: "fixture", signal: abort.signal,
+    fetchImpl: async (_url, options) => { assert(options.signal.aborted); throw new Error("aborted"); },
+  }), /aborted/, "TTS request inherits call cancellation");
   stream.close();
   console.log("kazee call speech: ok");
 })().catch((error) => { console.error(error); process.exitCode = 1; });

package/test-provider-env-isolation.js

@@ -85,6 +85,11 @@ assert.throws(
 );
 
 const base = baseAgentEnv(source);
+for (const builder of [baseAgentEnv, claudeAgentEnv, codexAgentEnv]) {
+  assert.strictEqual(builder({ ...source, OC_CALL_SPEECH_TOKEN: "stale-call-capability",
+    AGENT_ENV_PASSTHROUGH: "OC_CALL_SPEECH_TOKEN" }).OC_CALL_SPEECH_TOKEN, undefined,
+  "a call speech capability never passes through a generic provider environment");
+}
 assert.strictEqual(base.PROJECT_REGION, "fixture-region", "explicit project passthrough survives");
 assert.deepStrictEqual(presence(base), Object.fromEntries(baseline.environment.keys.map((key) => [key, false])));
 

package/test-provider-gateway.js

@@ -382,7 +382,7 @@ async function schedulerProbe() {
   console.log("provider gateway scheduler OK");
 }
 
-function queueProbe() {
+async function queueProbe() {
   const projectA = path.join(process.env.WORKSPACE, "project-a");
   const projectB = path.join(process.env.WORKSPACE, "project-b");
   fs.mkdirSync(projectA, { recursive: true });
@@ -455,6 +455,20 @@ function queueProbe() {
   assert.strictEqual(queued.runContext.project.dir, projectA);
   assert.strictEqual(queued.runContext.providerSettings.model, "claude-fixture");
   assert.strictEqual(queued.runContext.sessionId, "claude-queued-session");
+  const obsoleteCall = new AbortController();
+  store.adapter.liveCall = true;
+  store.adapter.callTurn = { signal: obsoleteCall.signal };
+  const callPending = runAgent("obsolete call question", projectA, null, { runId: "obsolete-call" });
+  assert.strictEqual(state.messageQueue.length, 2);
+  obsoleteCall.abort();
+  assert.strictEqual(state.messageQueue.length, 1, "superseded call entry is removed immediately, ordinary queued work is preserved");
+  assert.strictEqual((await callPending).status, "cancelled");
+  assert.strictEqual(state.messageQueue[0], queued);
+  const alreadyEnded = await runAgent("late call dispatch", projectA, null, { runId: "late-call" });
+  assert.strictEqual(alreadyEnded.status, "cancelled");
+  assert.strictEqual(state.messageQueue.length, 1, "an already-ended call never joins the queue");
+  delete store.adapter.callTurn;
+  delete store.adapter.liveCall;
   console.log("provider gateway immutable queue OK");
 }
 

package/test-provider-language.js

@@ -467,7 +467,9 @@ assert.match(pkg.description, /provider-agnostic coding-agent harness/i);
 // 3.4.14: bot managed-call consumer (subscribe only to gateway-authenticated User publishers) — part of the Janus calling plan Sumeet approved on 2026-09-05.
 // 3.4.13: Codex usage accounting fix — Sumeet approved the three-bug fix on 2026-09-05 ("Yes");
 // prepared 2026-09-06 for his release go. Rollout-based Codex context, per-turn ledger, sub-agent + quota accounting.
-assert.strictEqual(pkg.version, "3.4.14", "release version must remain unchanged without explicit approval");
+// 3.4.15: conversation flow and checked sentence speech; authorized calling rollout, 2026-09-05/06.
+// 3.4.16: remove the auxiliary recall-model delay from live replies; Sumeet's approved calling rollout, 2026-09-05/06.
+assert.strictEqual(pkg.version, "3.4.16", "release version must remain unchanged without explicit approval");
 for (const keyword of ["claude", "codex", "coding-agent", "provider-agnostic"]) {
   assert.ok(pkg.keywords.includes(keyword), `package keyword missing: ${keyword}`);
 }

package/test-provider-prompt-parity.js

@@ -30,7 +30,17 @@ async function probe() {
       origin: { transport: "telegram", channelId: "parity-channel" },
     },
   });
-  process.stdout.write(`${JSON.stringify({ bundle })}\n`);
+  const { chatContext } = require("./core/context");
+  const voiceBundle = await chatContext.run({ adapter: { type: "kazee", liveCall: true }, channelId: "parity-channel", canonicalUserId: state.userId }, () => buildTurnPrompt("Explain that beep.", {
+    provider: getProvider("codex"),
+    runContext: {
+      canonicalUserId: state.userId, project: { ...state.currentSession }, provider: "codex",
+      providerSettings: { ...state.settings }, sessionId: null, fresh: true, liveCall: true,
+      channelId: "parity-channel", origin: { transport: "kazee", channelId: "parity-channel" },
+      callHistory: [{ role: "user", text: "I heard a beep before you answered." }],
+    },
+  }));
+  process.stdout.write(`${JSON.stringify({ bundle, voiceBundle })}\n`);
 }
 
 if (process.argv[2] === "--probe") {
@@ -77,6 +87,11 @@ if (process.argv[2] === "--probe") {
     assert.ok(observed.bundle.dynamicContext.includes("## Project Transcript Memory"));
     assert.ok(observed.bundle.dynamicContext.includes("Codex exposes its native exec tools"));
     assert.ok(observed.bundle.recallMetadata);
+    assert.strictEqual(observed.voiceBundle.coreInstructions, observed.bundle.coreInstructions, "bounded call conversation keeps the complete core policy");
+    assert.ok(observed.voiceBundle.dynamicContext.includes("LIVE VOICE CALL"));
+    assert.ok(observed.voiceBundle.dynamicContext.includes("I heard a beep before you answered."));
+    assert.ok(observed.voiceBundle.dynamicContext.includes("Do not claim an earlier request was acted on without tool evidence."));
+    assert.strictEqual(observed.voiceBundle.userPrompt, "Explain that beep.");
     assert.notStrictEqual(
       `${observed.bundle.dynamicContext}\n\n${observed.bundle.userPrompt}`,
       baseline.prompt.sentinel,

package/test-provider-recall.js

@@ -253,6 +253,52 @@ async function main() {
   recall.getEngine = originalGetEngine;
   assert.strictEqual(admittedProvider, "codex");
 
+  // Real call prompt -> classic matcher -> relevance filter. A second model
+  // must not hold a live reply; context-only hits still require a judge and
+  // cannot be promoted just because calls use the local keyword baseline.
+  const packsLib = require("./core/packs");
+  const entitiesLib = require("./core/entities");
+  const transcriptsLib = require("./core/transcripts");
+  const filterLib = require("./core/recall-filter");
+  const saved = { matchPacks: packsLib.matchPacks, matchEntities: entitiesLib.matchEntities,
+    recentTranscriptText: transcriptsLib.recentTranscriptText, judgeRelevance: filterLib.judgeRelevance };
+  const { chatContext } = require("./core/context");
+  let judgeCalls = 0;
+  try {
+    packsLib.matchPacks = text => [{ dir: text === "Current deployment" ? "current-topic" : "stale-chat-topic", score: 10 }];
+    entitiesLib.matchEntities = () => [];
+    transcriptsLib.recentTranscriptText = () => "Earlier unrelated chat discussion";
+    filterLib.judgeRelevance = async () => { judgeCalls++; return new Set(["pack:current-topic", "pack:stale-chat-topic"]); };
+    for (const recallEngine of ["discoverer", "classic"]) {
+      const callRecall = await chatContext.run({ adapter: { type: "kazee", liveCall: true } }, () =>
+        systemPrompt.buildOptionalRecallContext("Current deployment", {
+          state: { ...mutableState, settings: { backend: "codex", recallEngine } },
+          runContext: { provider: "codex", liveCall: true, purpose: "foreground", project: { name: "project-a", dir: root }, runId: `call-${recallEngine}` },
+        }));
+      assert.strictEqual(judgeCalls, 0, "live call must reach answer generation without a second model for recall");
+      assert.deepStrictEqual(callRecall.metadata.packDirs, ["current-topic"], "retain current-topic keyword memory, exclude stale context-only matches");
+    }
+    const ordinaryRecall = await chatContext.run({ adapter: { type: "kazee" } }, () =>
+      systemPrompt.buildOptionalRecallContext("Current deployment", {
+        state: { ...mutableState, settings: { backend: "codex", recallEngine: "classic" } },
+        runContext: { provider: "codex", purpose: "foreground", project: { name: "project-a", dir: root }, runId: "ordinary-classic" },
+      }));
+    assert.strictEqual(judgeCalls, 1, "ordinary chat retains its model-based relevance filter");
+    assert.deepStrictEqual(ordinaryRecall.metadata.packDirs, ["current-topic", "stale-chat-topic"]);
+    const askRecall = await chatContext.run({ adapter: { type: "kazee", liveCall: true } }, () =>
+      systemPrompt.buildOptionalRecallContext("Current deployment", {
+        state: { ...mutableState, settings: { backend: "codex", recallEngine: "ask" } },
+        runContext: { provider: "codex", liveCall: true, purpose: "foreground", project: { name: "project-a", dir: root }, runId: "call-ask" },
+      }));
+    assert.strictEqual(askRecall.metadata.engine, "ask", "explicit on-demand recall remains on-demand during calls");
+    assert.strictEqual(judgeCalls, 1);
+  } finally {
+    packsLib.matchPacks = saved.matchPacks;
+    entitiesLib.matchEntities = saved.matchEntities;
+    transcriptsLib.recentTranscriptText = saved.recentTranscriptText;
+    filterLib.judgeRelevance = saved.judgeRelevance;
+  }
+
   // ── compaction recall policy: the summary meta-turn skips recall entirely;
   //    the seed turn matches on the runner-supplied recallQuery (condensed
   //    brief + task titles), never the seed prompt's boilerplate ──

package/test-provider-runner.js

@@ -132,6 +132,40 @@ async function main() {
     codex: path.join(root, "codex-capture.json"),
   };
   const providers = makeProviders(captures);
+  const voiceStore = { adapter: { liveCall: true, callHistory: [{ role: "user", text: "What about the beeping?" }] } };
+  mutable.activeSessions["project-a"].claude = "long-coding-session";
+  const voiceContext = captureRunContext({ state: mutable, store: voiceStore, prompt: "What does it mean?", cwd: projectA,
+    opts: { resumeSessionId: "long-coding-session", continueSession: true } });
+  assert.strictEqual(voiceContext.sessionId, null, "call must not resume the room's coding conversation");
+  assert.strictEqual(voiceContext.resumeSessionId, null);
+  assert.strictEqual(voiceContext.continueSession, false);
+  assert.strictEqual(voiceContext.fresh, true);
+  assert.strictEqual(voiceContext.attachSession, false, "call completion must not replace the coding session");
+  assert.strictEqual(voiceContext.skipAutoCompact, true, "call cannot compact the room's coding session");
+  voiceStore.adapter.callHistory[0].text = "later mutation";
+  assert.strictEqual(voiceContext.callHistory[0].text, "What about the beeping?", "queued history is immutable");
+  assert.ok(Object.isFrozen(voiceContext.callHistory[0]));
+  delete mutable.activeSessions["project-a"].claude;
+
+  let callObsolete = false;
+  let callBuilds = 0;
+  let callSpawns = 0;
+  const callGate = deferred();
+  const cancellableCall = createRunnerService({
+    getState: () => mutable,
+    getStore: () => voiceStore,
+    resolveProvider: id => providers[id],
+    isObsolete: () => callObsolete,
+    async buildTurnPrompt(prompt, opts) { callBuilds++; await callGate.promise; return simpleBundle(prompt, opts); },
+    spawnProcess() { callSpawns++; throw new Error("obsolete call must never spawn"); },
+  });
+  const preparingCall = cancellableCall.runAgent("old question", projectA, null);
+  callObsolete = true;
+  callGate.resolve();
+  assert.strictEqual((await preparingCall).status, "cancelled", "hangup during recall prevents provider execution");
+  assert.strictEqual(callSpawns, 0);
+  assert.strictEqual((await cancellableCall.runAgent("late dispatch", projectA, null)).status, "cancelled");
+  assert.strictEqual(callBuilds, 1, "obsolete call avoids even a prompt/recall build");
   const persisted = [];
   const delivered = [];
   const service = createRunnerService({

package/test-tool-manifest.js

@@ -16,6 +16,9 @@ process.env.APPROVALS_DIR = path.join(tmp, "approvals");
 const tools = require("./core/tools");
 const repo = require("./core/tool-repo");
 const approvals = require("./core/approvals");
+// The runner may itself be an approved composing tool. These fixtures model
+// top-level calls; keep process.env intact and inject each scenario explicitly.
+const topLevelEnv = {};
 
 (async () => {
   // ── scaffold with --verbs → manifest header lines, dispatcher, TOOL.md block ──
@@ -39,32 +42,32 @@ const approvals = require("./core/approvals");
   assert.ok(/list\)/.test(t.content) && /purge\)/.test(t.content), "bash dispatcher has a case per verb");
 
   // ── per-verb gate: tier comes from the invoked verb, not the tool tier ──
-  assert.strictEqual(tools.runGate(t, ["list"]).ok, true, "read-only verb runs unflagged");
-  assert.strictEqual(tools.runGate(t, ["list"]).tier, "read-only");
-  assert.strictEqual(tools.runGate(t, ["restart", "n1"]).ok, false, "write verb demands --yes");
-  assert.strictEqual(tools.runGate(t, ["restart", "n1", "--yes"]).ok, true);
-  assert.strictEqual(tools.runGate(t, ["purge", "n1", "--yes"]).ok, false, "--yes cannot approve a destructive verb");
-  const purgeGate = tools.runGate(t, ["purge", "n1"]);
+  assert.strictEqual(tools.runGate(t, ["list"], topLevelEnv).ok, true, "read-only verb runs unflagged");
+  assert.strictEqual(tools.runGate(t, ["list"], topLevelEnv).tier, "read-only");
+  assert.strictEqual(tools.runGate(t, ["restart", "n1"], topLevelEnv).ok, false, "write verb demands --yes");
+  assert.strictEqual(tools.runGate(t, ["restart", "n1", "--yes"], topLevelEnv).ok, true);
+  assert.strictEqual(tools.runGate(t, ["purge", "n1", "--yes"], topLevelEnv).ok, false, "--yes cannot approve a destructive verb");
+  const purgeGate = tools.runGate(t, ["purge", "n1"], topLevelEnv);
   assert.strictEqual(purgeGate.tier, "destructive", "failed gate reports the resolved tier for the approval fallback");
-  assert.strictEqual(tools.runGate(t, ["purge", "n1", "--yes-destructive"]).ok, true);
+  assert.strictEqual(tools.runGate(t, ["purge", "n1", "--yes-destructive"], topLevelEnv).ok, true);
 
   // ── undeclared verb on a manifest tool is refused regardless of flags ──
-  const un = tools.runGate(t, ["obliterate", "--yes-destructive"]);
+  const un = tools.runGate(t, ["obliterate", "--yes-destructive"], topLevelEnv);
   assert.strictEqual(un.ok, false, "undeclared verb refused");
   assert.strictEqual(un.undeclared, true);
   assert.ok(/no declared verb "obliterate"/.test(un.message));
 
   // ── help / no verb = read-only ──
-  assert.strictEqual(tools.runGate(t, []).ok, true, "no verb (help) runs unflagged");
-  assert.strictEqual(tools.runGate(t, ["help"]).tier, "read-only");
+  assert.strictEqual(tools.runGate(t, [], topLevelEnv).ok, true, "no verb (help) runs unflagged");
+  assert.strictEqual(tools.runGate(t, ["help"], topLevelEnv).tier, "read-only");
 
   // ── manifest-less tools keep the old whole-tool gate (backward compatible) ──
   const legacySrc = path.join(tmp, "old.sh");
   fs.writeFileSync(legacySrc, "#!/usr/bin/env bash\necho old\n");
   const legacy = tools.addTool(legacySrc, { name: "old", description: "legacy", risk: "write" });
   assert.strictEqual(legacy.manifest.length, 0);
-  assert.strictEqual(tools.runGate(legacy, ["anything"]).ok, false, "manifest-less write tool still needs --yes");
-  assert.strictEqual(tools.runGate(legacy, ["anything", "--yes"]).ok, true, "…and any verb is allowed with it");
+  assert.strictEqual(tools.runGate(legacy, ["anything"], topLevelEnv).ok, false, "manifest-less write tool still needs --yes");
+  assert.strictEqual(tools.runGate(legacy, ["anything", "--yes"], topLevelEnv).ok, true, "…and any verb is allowed with it");
 
   // ── nested composition still gates on the inherited tier, per verb ──
   const env = { OPEN_CLAUDIA_TOOL_STACK: "outer", OPEN_CLAUDIA_APPROVED_TIER: "write" };
@@ -119,6 +122,12 @@ const approvals = require("./core/approvals");
   approvals.decide(b10rec.id, "approved", "c1");
   const errs = [];
   const realErr = console.error;
+  // This integration fixture redeems a top-level approval against the isolated
+  // tools/keyring above. A nested tool must refuse redemption, so temporarily
+  // model the top-level CLI environment and restore the launcher's context.
+  const approvalKeys = ["OPEN_CLAUDIA_TOOL_STACK", "OPEN_CLAUDIA_APPROVED_TIER"];
+  const savedApprovalEnv = Object.fromEntries(approvalKeys.map((key) => [key, process.env[key]]));
+  for (const key of approvalKeys) delete process.env[key];
   console.error = (...a) => errs.push(a.join(" "));
   try {
     process.exitCode = 0;
@@ -134,6 +143,10 @@ const approvals = require("./core/approvals");
     assert.strictEqual(process.exitCode, 0, "the same token redeems once the key exists");
     assert.ok(approvals.read(b10rec.id).consumedAt, "token consumed exactly by the real run");
   } finally {
+    for (const key of approvalKeys) {
+      if (savedApprovalEnv[key] === undefined) delete process.env[key];
+      else process.env[key] = savedApprovalEnv[key];
+    }
     console.error = realErr;
     process.exitCode = 0;
   }

package/test-tools.js

@@ -250,14 +250,18 @@ assert.strictEqual(tools.findTool("hello").createdAt, bornHello, "createdAt is i
 
 // ── runGate: read-only runs freely; write demands --yes; destructive demands
 //    --yes-destructive (a plain --yes must NOT unlock it); undeclared → write ──
-assert.ok(tools.runGate({ name: "t", risk: "read-only" }, []).ok, "read-only runs without flags");
-assert.ok(!tools.runGate({ name: "t", risk: "write" }, []).ok, "write without --yes is refused");
-assert.ok(tools.runGate({ name: "t", risk: "write" }, ["--yes"]).ok, "write with --yes runs");
-assert.ok(!tools.runGate({ name: "t", risk: "destructive" }, ["--yes"]).ok, "plain --yes does not unlock destructive");
-assert.ok(tools.runGate({ name: "t", risk: "destructive" }, ["--yes-destructive"]).ok, "destructive with --yes-destructive runs");
-const undeclared = tools.runGate({ name: "t", risk: "" }, []);
+// These fixtures model top-level invocations even when npm test is launched
+// through an approved tool. Keep the real process approval environment intact;
+// nested composition is exercised with explicit environments below.
+const topLevelEnv = {};
+assert.ok(tools.runGate({ name: "t", risk: "read-only" }, [], topLevelEnv).ok, "read-only runs without flags");
+assert.ok(!tools.runGate({ name: "t", risk: "write" }, [], topLevelEnv).ok, "write without --yes is refused");
+assert.ok(tools.runGate({ name: "t", risk: "write" }, ["--yes"], topLevelEnv).ok, "write with --yes runs");
+assert.ok(!tools.runGate({ name: "t", risk: "destructive" }, ["--yes"], topLevelEnv).ok, "plain --yes does not unlock destructive");
+assert.ok(tools.runGate({ name: "t", risk: "destructive" }, ["--yes-destructive"], topLevelEnv).ok, "destructive with --yes-destructive runs");
+const undeclared = tools.runGate({ name: "t", risk: "" }, [], topLevelEnv);
 assert.ok(!undeclared.ok && undeclared.tier === "write", "undeclared tier is treated as write (fail-safe)");
-assert.ok(/destructive/i.test(tools.runGate({ name: "t", risk: "destructive" }, []).message), "destructive refusal spells out the warning");
+assert.ok(/destructive/i.test(tools.runGate({ name: "t", risk: "destructive" }, [], topLevelEnv).message), "destructive refusal spells out the warning");
 
 // ── scaffold: creates dir + stub + TOOL.md, registered and runnable ──
 const sc = repo.scaffoldTool("kwidget", { description: "widget system CLI", risk: "read-only", pack: "widgets", usage: "kwidget <verb>" });