@inetafrica/open-claudia 3.4.13 → 3.4.15

package/test-call-speech.js

@@ -0,0 +1,237 @@
+#!/usr/bin/env node
+"use strict";
+
+const assert = require("assert");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const http = require("http");
+const { spawn } = require("child_process");
+
+function cli(env, args, input = "") {
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [path.join(__dirname, "bin/cli.js"), "call-say", ...args],
+      { env, stdio: ["pipe", "pipe", "pipe"] });
+    let stdout = "", stderr = "";
+    child.stdout.on("data", data => { stdout += data; });
+    child.stderr.on("data", data => { stderr += data; });
+    child.on("error", reject);
+    child.on("close", code => resolve({ code, stdout, stderr }));
+    child.stdin.end(input);
+  });
+}
+
+// Real provider child -> real CLI child -> HTTP -> call adapter, with no
+// model, speech service, or real recipient. Emit a terminal result only AFTER
+// the first sentence has been acknowledged as completely spoken.
+if (process.env.OC_CALL_SPEECH_FIXTURE === "1") {
+  (async () => {
+    const hasPermission = !!process.env.OC_CALL_SPEECH_TOKEN;
+    if (hasPermission) {
+      const result = await cli(process.env, ["--id", "first", "The first result is ready."]);
+      assert.strictEqual(result.code, 0, result.stderr);
+    }
+    process.stdout.write(JSON.stringify({ type: "result", subtype: "success", is_error: false,
+      result: hasPermission ? "The first result is ready. The second result is ready." : "No call speech permission." }) + "\n");
+  })().catch(error => { console.error(error.message); process.exitCode = 1; });
+} else {
+  process.env.OPEN_CLAUDIA_TEST = "1";
+  process.env.OPEN_CLAUDIA_CONFIG_DIR = fs.mkdtempSync(path.join(os.tmpdir(), "oc-call-speech-"));
+  process.env.WORKSPACE = process.env.OPEN_CLAUDIA_CONFIG_DIR;
+  const loopback = require("./core/loopback");
+  const speech = require("./core/call-speech");
+  const relationship = require("./core/relationship");
+  const enforcer = require("./core/enforcer");
+  const context = require("./core/context");
+  const { registerSecrets } = require("./core/redact");
+  const leases = [];
+  const deferred = () => { let resolve; const promise = new Promise(r => { resolve = r; }); return { promise, resolve }; };
+  let sequence = 0;
+  function fixture() {
+    const controller = new AbortController();
+    const spoken = [];
+    let active = true, cancelled = 0;
+    const adapter = { id: "kazee-test", type: "kazee", liveCall: true,
+      callTurn: { signal: controller.signal },
+      isCallTurnActive: () => active,
+      speakSentence: async text => { spoken.push(text); return true; },
+      cancelCallSpeech: () => { cancelled++; },
+    };
+    const store = { adapter, channelId: "call-room", userId: "caller", canonicalUserId: "kazee:caller", transport: "kazee" };
+    const run = { liveCall: true, purpose: "foreground", runId: `run-${++sequence}`, timeoutMs: 5000 };
+    const lease = speech.prepare(store, run);
+    leases.push(lease);
+    const payload = { adapter: adapter.id, channelId: store.channelId, userId: store.userId,
+      canonicalUserId: store.canonicalUserId, originRunId: run.runId,
+      callSpeechToken: lease.token, requestId: "sentence", text: "The result is ready." };
+    return { adapter, store, run, lease, payload, spoken, controller,
+      mute() { active = false; }, get cancelled() { return cancelled; } };
+  }
+  function post(info, payload, token = info.token) {
+    return new Promise((resolve, reject) => {
+      const data = JSON.stringify(payload);
+      const req = http.request(`${info.url}/call-say`, { method: "POST", headers: {
+        Authorization: `Bearer ${token}`, "Content-Type": "application/json", "Content-Length": Buffer.byteLength(data),
+      } }, res => {
+        let body = "";
+        res.on("data", chunk => { body += chunk; });
+        res.on("end", () => resolve({ status: res.statusCode, body: JSON.parse(body) }));
+      });
+      req.on("error", reject); req.end(data);
+    });
+  }
+  const rejectsStatus = (promise, status) => assert.rejects(promise, error => error.status === status);
+  async function main() {
+    relationship.isCurrentSpeakerGuarded = () => false;
+    const info = await loopback.start({ findAdapter: id => id === "kazee-test" ? { type: "kazee" } : null });
+    let f = fixture();
+    assert.strictEqual(speech.prepare(f.store, { ...f.run, liveCall: false }), null);
+    assert.strictEqual(speech.prepare(f.store, { ...f.run, purpose: "silent" }), null);
+    await rejectsStatus(speech.speak(f.payload), 409); // prepared but no provider yet
+    f.lease.activate(); f.lease.activate();
+    assert.strictEqual((await post(info, f.payload, "wrong-token")).status, 401);
+    for (const field of ["adapter", "channelId", "userId", "canonicalUserId", "originRunId", "callSpeechToken"]) {
+      await rejectsStatus(speech.speak({ ...f.payload, [field]: "other" }), 409);
+    }
+    assert.strictEqual(f.spoken.length, 0);
+    const env = { PATH: process.env.PATH, HOME: process.env.OPEN_CLAUDIA_CONFIG_DIR,
+      OPEN_CLAUDIA_CONFIG_DIR: process.env.OPEN_CLAUDIA_CONFIG_DIR,
+      OC_SEND_URL: info.url, OC_SEND_TOKEN: info.token, OC_CHANNEL_ADAPTER: f.adapter.id,
+      OC_CHANNEL_ID: f.store.channelId, OC_CHANNEL_USER_ID: f.store.userId,
+      OC_CANONICAL_USER_ID: f.store.canonicalUserId, OC_RUN_ID: f.run.runId, OC_CALL_SPEECH_TOKEN: f.lease.token };
+    const text = "A quoted `name` and $(text) are spoken literally.";
+    assert.strictEqual((await cli(env, ["--id", "stdin", "--stdin"], text)).code, 0);
+    assert.deepStrictEqual(f.spoken, [text]);
+    const duplicate = await cli(env, ["--id", "stdin", "--stdin"], text);
+    assert.strictEqual(duplicate.code, 0);
+    assert.match(duplicate.stdout, /Already spoken/);
+    assert.strictEqual(f.spoken.length, 1);
+    assert.strictEqual((await cli(env, ["--id", "stdin", "Different text."])).code, 1);
+    assert.strictEqual((await cli({ ...env, OC_CALL_SPEECH_TOKEN: "" }, ["A sentence."])).code, 1);
+    assert.strictEqual((await post(info, { ...f.payload, text: "x".repeat(451) })).status, 400);
+    registerSecrets(["synthetic-speech-secret"]);
+    await speech.speak({ ...f.payload, requestId: "redacted", text: "Value synthetic-speech-secret." });
+    assert.strictEqual(f.spoken.at(-1), "Value [REDACTED_SECRET].");
+    f.lease.close();
+    await rejectsStatus(speech.speak(f.payload), 409);
+
+    // Recipient classification and the actual outbound guard run inside the
+    // captured caller context, not the HTTP client's supplied identity.
+    f = fixture(); f.lease.activate();
+    relationship.isCurrentSpeakerGuarded = () => {
+      assert.strictEqual(context.currentUserId(), "caller"); return true;
+    };
+    enforcer.guardOutboundReply = async () => ({ allow: false });
+    await rejectsStatus(speech.speak(f.payload), 403);
+    enforcer.guardOutboundReply = async () => { throw new Error("guard unavailable"); };
+    await rejectsStatus(speech.speak({ ...f.payload, requestId: "guard-error" }), 403);
+    relationship.isCurrentSpeakerGuarded = () => { throw new Error("classification unavailable"); };
+    await rejectsStatus(speech.speak({ ...f.payload, requestId: "class-error" }), 403);
+    assert.strictEqual(f.spoken.length, 0);
+    relationship.isCurrentSpeakerGuarded = () => true;
+    enforcer.guardOutboundReply = async text => {
+      assert.strictEqual(context.currentCanonicalUserId(), "kazee:caller");
+      assert.strictEqual(text, f.payload.text);
+      return { allow: true };
+    };
+    assert.strictEqual((await speech.speak({ ...f.payload, requestId: "approved" })).spoken, true);
+    enforcer.guardOutboundReply = async text => {
+      assert.strictEqual(text, `${f.payload.text} Follow-up result.`);
+      return { allow: false };
+    };
+    await rejectsStatus(speech.speak({ ...f.payload, requestId: "cumulative", text: "Follow-up result." }), 403);
+    assert.strictEqual(f.spoken.length, 1, "guard sees the combined spoken answer, not an isolated follow-up");
+
+    f = fixture(); f.lease.activate();
+    relationship.isCurrentSpeakerGuarded = () => true;
+    const checking = deferred(), releaseCheck = deferred();
+    enforcer.guardOutboundReply = async () => { checking.resolve(); await releaseCheck.promise; return { allow: true }; };
+    const guarded = rejectsStatus(speech.speak(f.payload), 409);
+    await checking.promise; f.mute(); releaseCheck.resolve(); await guarded;
+    assert.strictEqual(f.spoken.length, 0, "speech resumed while reply guard was checking");
+
+    relationship.isCurrentSpeakerGuarded = () => false;
+    f = fixture(); f.lease.activate();
+    const playback = deferred(), playing = deferred();
+    f.adapter.speakSentence = async () => { playing.resolve(); return playback.promise; };
+    const first = speech.speak(f.payload);
+    const firstRejected = rejectsStatus(first, 409);
+    await playing.promise;
+    const retryRejected = rejectsStatus(speech.speak(f.payload), 409);
+    await rejectsStatus(speech.speak({ ...f.payload, requestId: "overlap" }), 429);
+    f.controller.abort(); playback.resolve(false);
+    await Promise.all([firstRejected, retryRejected]);
+    assert.strictEqual(f.cancelled, 1, "abort cancels current playback once");
+    await rejectsStatus(speech.speak(f.payload), 409);
+
+    f = fixture(); f.lease.activate();
+    for (let n = 0; n < 8; n++) await speech.speak({ ...f.payload, requestId: `bounded-${n}` });
+    await rejectsStatus(speech.speak({ ...f.payload, requestId: "ninth" }), 429);
+    assert.strictEqual(speech.unspokenSuffix("One. Two. Three.", ["One.", "Two."]), "Three.");
+    assert.strictEqual(speech.unspokenSuffix("One. Two.", ["One.", "Two."]), "");
+    assert.strictEqual(speech.unspokenSuffix("Correction: One is wrong.", ["One."]), "Correction: One is wrong.");
+    f = fixture(); f.lease.activate();
+    const expired = deferred(); f.adapter.speakSentence = () => expired.promise;
+    const expiring = rejectsStatus(speech.speak(f.payload), 409);
+    f.lease.close(); expired.resolve(false); await expiring;
+    assert.strictEqual(f.cancelled, 1);
+
+    await runnerIntegration(info);
+    console.log("call speech lease, guard, CLI and runner integration OK");
+  }
+
+  async function runnerIntegration(info) {
+    // Replace only model/prompt/observer dependencies; use the production
+    // foreground factory, invocation decorator, subprocess lifecycle and HTTP.
+    const providers = require("./core/providers");
+    const { createClaudeProvider } = require("./core/providers/claude");
+    const provider = createClaudeProvider({ hookTransport: false,
+      resolveExecutable: () => process.execPath, defaultModel: "fixture-model",
+      getAuthStatus: () => ({ state: "authenticated", reason: null }),
+      buildEnv: () => ({ PATH: process.env.PATH, HOME: process.env.OPEN_CLAUDIA_CONFIG_DIR,
+        OPEN_CLAUDIA_CONFIG_DIR: process.env.OPEN_CLAUDIA_CONFIG_DIR, OC_CALL_SPEECH_FIXTURE: "1" }),
+    });
+    const build = provider.buildMainInvocation.bind(provider);
+    provider.buildMainInvocation = input => { const result = build(input); return { ...result, args: [__filename, ...result.args] }; };
+    providers.resolveProviderForRun = () => provider;
+    require("./core/system-prompt").buildTurnPrompt = async prompt => ({
+      coreInstructions: "Fixture", dynamicContext: "", userPrompt: prompt, transcriptPaths: {}, recallMetadata: {},
+    });
+    require("./core/turn-observer").createTurnObserver = () => ({ onRecallSurfaced() {}, onToolStart() {} });
+    delete require.cache[require.resolve("./core/runner")];
+    const { createForegroundService } = require("./core/runner");
+    let lastLease;
+    const prepare = speech.prepare;
+    speech.prepare = (...args) => { lastLease = prepare(...args); if (lastLease) leases.push(lastLease); return lastLease; };
+    const f = fixture();
+    const state = { userId: "kazee:caller", currentSession: { name: "call-fixture", dir: process.env.WORKSPACE },
+      settings: { backend: "claude", model: "fixture-model", permissionMode: "default" },
+      providerSettings: { claude: { model: "fixture-model" } }, activeSessions: {}, messageQueue: [] };
+    const spoken = [];
+    f.adapter.suppressStreamPreview = true; f.adapter.suppressChatVisibility = true;
+    f.adapter.speakSentence = async text => {
+      assert.ok(state.runningProcess, "sentence is spoken before provider completion");
+      spoken.push(text); return true;
+    };
+    f.adapter.send = async (_channel, text) => {
+      await rejectsStatus(speech.speak({ ...f.payload, callSpeechToken: lastLease?.token }), 409);
+      spoken.push(speech.unspokenSuffix(text, spoken)); return true;
+    };
+    f.adapter.typing = async () => {};
+    const service = createForegroundService({ state, store: f.store, stopTyping() {}, capture: false, ownsAdmissionLock: false });
+    const result = await context.runInChat(f.store, () => service.runAgent("Give two results.", process.env.WORKSPACE, null));
+    assert.strictEqual(result.ok, true, JSON.stringify(result.error));
+    assert.deepStrictEqual(spoken, ["The first result is ready.", "The second result is ready."]);
+    const token = lastLease.token;
+    assert.strictEqual((await post(info, { ...f.payload, callSpeechToken: token, originRunId: result.runId })).status, 409);
+    assert.strictEqual(state.runningProcess, null);
+    const capturedService = createForegroundService({ state, store: f.store, stopTyping() {}, capture: true, ownsAdmissionLock: false, persistCapture: false });
+    const captured = await context.runInChat(f.store, () => capturedService.runAgentCapture("Capture only.", process.env.WORKSPACE));
+    assert.strictEqual(captured.ok, true, JSON.stringify(captured.error));
+    assert.strictEqual(captured.text, "No call speech permission.");
+    speech.prepare = prepare;
+  }
+  main().then(() => { for (const lease of leases) lease.close(); loopback.stop(); process.exit(0); }, error => {
+    console.error(error); for (const lease of leases) lease.close(); loopback.stop(); process.exit(1);
+  });
+}

package/test-kazee-call-manager.js

@@ -6,7 +6,7 @@ class FakeSession {
   static instances = [];
   constructor(options) { this.options = options; this.roomId = options.roomId; FakeSession.instances.push(this); }
   async start() { this.started = true; }
-  async speak(text) { this.spoken = text; }
+  async speak(text) { this.spoken = text; (this.spokenChunks ||= []).push(text); }
   async close(reason) { this.closed = reason; this.options.onEnded(reason); }
 }
 function fixture() {
@@ -37,8 +37,63 @@ function fixture() {
   assert.strictEqual(f.inbound[0].payload.adapter.liveCall, true);
   await f.inbound[0].payload.adapter.send("chat", "Your agenda is clear.");
   assert.strictEqual(f.manager.session.spoken, "Your agenda is clear.");
-  await f.manager.ended({ roomId: 12 });
+  const firstCallSession = f.manager.session;
+  const firstReply = f.inbound[0].payload.adapter;
+  firstCallSession.options.onSpeechStart();
+  await firstReply.send("chat", "An obsolete reply.");
+  assert.strictEqual(firstCallSession.spoken, "Your agenda is clear.", "resuming speech suppresses the old reply before a new final exists");
+  firstCallSession.options.onTranscript("Actually, what is tomorrow's agenda?");
+  assert.strictEqual(firstReply.callTurn.signal.aborted, true, "new complete utterance cancels obsolete queued work");
+  const secondReply = f.inbound[1].payload.adapter;
+  assert.ok(secondReply.callHistory.some(entry => entry.text === "What is on my agenda?"), "coalescing retains the earlier question as context");
+  assert.strictEqual(secondReply.callTurn.signal.aborted, false);
+  await secondReply.send("chat", "Tomorrow is free.");
+  assert.strictEqual(firstCallSession.spoken, "Tomorrow is free.");
+  let releaseClose;
+  const closeGate = new Promise(resolve => { releaseClose = resolve; });
+  firstCallSession.close = async reason => { await closeGate; firstCallSession.closed = reason; firstCallSession.options.onEnded(reason); };
+  const ending = f.manager.ended({ roomId: 12 });
+  assert.strictEqual(secondReply.callTurn.signal.aborted, true, "hangup invalidates queued work before slow media cleanup finishes");
+  releaseClose();
+  await ending;
   assert.strictEqual(f.manager.session, null);
+  assert.strictEqual(secondReply.callTurn.signal.aborted, true, "hangup cancels queued work even after manager clears its session pointer");
+  await secondReply.send("chat", "Reply after hangup.");
+  assert.strictEqual(firstCallSession.spoken, "Tomorrow is free.");
+  await f.manager.incoming({ fromUserId: "owner-1", chatId: "chat", roomId: 13, callType: "audio" });
+  firstCallSession.options.onTranscript("Late transcript from old call.");
+  assert.strictEqual(f.inbound.length, 2, "old-session transcript cannot enter a replacement call");
+  for (let i = 0; i < 15; i++) f.manager.session.options.onTranscript(`${i} ${"a".repeat(2500)}`);
+  const history = f.inbound.at(-1).payload.adapter.callHistory;
+  assert.ok(history.length <= 8 && history.reduce((n, entry) => n + entry.text.length, 0) <= 12000, "voice history has an explicit bound");
+  await f.manager.stop();
+
+  // Explicitly streamed sentences enter history only when completely spoken;
+  // the settled final removes their exact prefix and preserves corrections.
+  f = fixture();
+  await f.manager.incoming({ fromUserId: "owner-1", chatId: "speech", roomId: 14, callType: "audio" });
+  const streamedSession = f.manager.session;
+  streamedSession.options.onTranscript("Give me both results.");
+  const streamed = f.inbound[0].payload.adapter;
+  assert.strictEqual(await streamed.speakSentence("First result."), true);
+  assert.strictEqual(await streamed.speakSentence("Second result."), true);
+  await streamed.send("speech", "First result. Second result. Third result.");
+  assert.deepStrictEqual(streamedSession.spokenChunks, ["First result.", "Second result.", "Third result."]);
+  await streamed.send("speech", "Correction: the first result changed.");
+  assert.strictEqual(streamedSession.spokenChunks.at(-1), "Correction: the first result changed.");
+  const beforeMute = streamedSession.spokenChunks.length;
+  streamedSession.options.onSpeechStart();
+  assert.strictEqual(await streamed.speakSentence("Stale sentence."), false);
+  assert.strictEqual(streamedSession.spokenChunks.length, beforeMute);
+  streamedSession.options.onTranscript("Now another question.");
+  const nextSpeech = f.inbound.at(-1).payload.adapter;
+  assert.ok(nextSpeech.callHistory.some(entry => entry.text.startsWith("First result. Second result.")));
+  assert.ok(nextSpeech.callHistory.some(entry => entry.text === "Give me both results."), "speech chunks keep the question in bounded history");
+  streamedSession.speak = async () => false;
+  assert.strictEqual(await nextSpeech.speakSentence("Interrupted sentence."), false);
+  assert.ok(!streamedSession._voiceHistory.some(entry => entry.text === "Interrupted sentence."));
+  await f.manager.stop();
+  assert.strictEqual(await nextSpeech.speakSentence("After hangup."), false);
 
   // Outbound: session starts in caller mode, invite goes out, answer clears the ring timer.
   f = fixture();

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();
@@ -462,10 +602,11 @@ async function testManagedRoomCredentials() {
   assert.strictEqual(session.janus.options.token, "root-token");
   assert.strictEqual(session.janus.calls[0].token, "publisher-token");
   await session._consumePublisherFrame({ plugindata: { data: { publishers: [{ id: 41, display: 'canonical-bot@calling.invalid' }, { id: 42, display: 'open-claudia:legacy-bot' }] } } });
-  assert.strictEqual(session.subscribers.size, 0, 'own joined publisher ID is excluded independently of canonical display; legacy bot exclusion remains');
+  assert.strictEqual(session.subscribers.size, 0, 'own joined publisher ID and unclassified managed feeds are excluded independently of display');
 
   session.roomTokenExpiresAt = Date.now() - 1;
-  await Promise.all([session._subscribe(17, "owner"), session._subscribe(18, "other")]);
+  const userMetadata = { kazee: { version: 1, userId: 'a'.repeat(24), principalKind: 'User' } };
+  await Promise.all([session._subscribe(17, "owner", userMetadata), session._subscribe(18, "other", userMetadata)]);
   const subJoin = session.janus.calls.find(body => body.ptype === "subscriber");
   assert.strictEqual(subJoin.token, "subscriber-token");
   assert.strictEqual(subJoin.private_id, 999);
@@ -484,6 +625,66 @@ async function testManagedRoomCredentials() {
   assert.ok(!session.janus.calls.some(body => ["create", "destroy"].includes(body.request)), "server allocated room ownership never transfers to the bot");
 }
 
+async function testTrustedPublisherMetadata() {
+  const botId = 'b'.repeat(24), userId = 'a'.repeat(24);
+  const metadata = (principalKind, id = userId) => ({ kazee: { version: 1, userId: id, principalKind } });
+  const publisher = (id, meta, display = 'speaker@calling.invalid') => ({ id, display, metadata: meta });
+  let initial = [];
+  class MetadataJanus extends FakeJanus {
+    constructor() { super(); this.calls = []; this.listeners = new Map(); }
+    onHandle(handle, listener) { this.listeners.set(handle, listener); }
+    async message(handle, body) {
+      this.calls.push({ handle, ...body });
+      if (body.request === 'join' && body.ptype === 'publisher') return { plugindata: { data: { videoroom: 'joined', id: 41, private_id: 999, publishers: initial } } };
+      if (body.request === 'configure') return { jsep: { type: 'answer', sdp: 'fixture' } };
+      if (body.request === 'join' && body.ptype === 'subscriber') return { plugindata: { data: { videoroom: 'attached' } }, jsep: { type: 'offer', sdp: 'fixture' } };
+      return {};
+    }
+  }
+  const make = managedRoom => new KazeeCallSession({ roomId: 7, chatId: 'chat', callerId: userId, botUserId: botId, managedRoom,
+    roomToken: 'fixture', roomTokenExpiresAt: Date.now() + 300000,
+    iceServers: [{ urls: 'turn:relay:3478', username: 'fixture', credential: 'fixture' }], iceCredentialsExpiresAt: Date.now() + 3600000,
+    JanusClientImpl: MetadataJanus, PeerConnectionImpl: FakePC, SpeechStreamImpl: FakeSpeechStream });
+  const invalid = [undefined, null, {}, { kazee: null }, { kazee: [] },
+    { kazee: { version: 2, userId, principalKind: 'User' } }, { kazee: { version: '1', userId, principalKind: 'User' } },
+    metadata('Human'), metadata('bot'), metadata(undefined), metadata('User', 'invalid'), { kazee: { version: 1, principalKind: 'User' } },
+    { kazee: { version: 1, userId: { $ne: null }, principalKind: 'User' } }];
+  initial = [publisher(41, metadata('User')), publisher(42, metadata('Bot', 'c'.repeat(24)), 'other-bot@calling.invalid'),
+    publisher(43, metadata('User')), publisher(44, metadata('User', botId.toUpperCase())),
+    ...invalid.map((meta, i) => publisher(100 + i, meta))];
+  const managed = make(true);
+  try {
+    await managed.start();
+    assert.deepStrictEqual([...managed.subscribers.keys()], [43], 'initial join reaches real subscription only for a classified human, never self/bot/unknown');
+    assert.strictEqual(managed.subscribers.get(43).started, true, 'authorized human reaches the actual subscriber offer/answer path');
+    const emit = publishers => managed.janus.listeners.get(managed.publisherHandle)({ janus: 'event', plugindata: { data: { publishers } } });
+    await emit([publisher(50, metadata('Bot', 'd'.repeat(24)), 'another-bot@calling.invalid'),
+      publisher(51, metadata('User'), 'open-claudia:display-is-not-managed-authority'),
+      ...invalid.map((meta, i) => publisher(200 + i, meta))]);
+    assert.deepStrictEqual([...managed.subscribers.keys()], [43, 51], 'live publisher metadata survives forwarding; managed classification never falls back to display prefix');
+    assert.strictEqual(managed.subscribers.get(51).display, 'open-claudia:display-is-not-managed-authority', 'presentation remains unchanged');
+    const handles = managed.janus.handles;
+    await managed._subscribe(60, 'unclassified@calling.invalid');
+    await managed._subscribe(61, 'bot@calling.invalid', metadata('Bot'));
+    await managed._subscribe(41, 'own@calling.invalid', metadata('User'));
+    assert.strictEqual(managed.janus.handles, handles, 'the subscription method itself fails closed before creating handles or speech streams');
+    assert.deepStrictEqual(managed.janus.calls.filter(body => body.ptype === 'subscriber').map(body => body.feed), [43, 51]);
+  } finally { await managed.close(); }
+
+  initial = [publisher(41, metadata('User')), publisher(42, metadata('User'), 'open-claudia:legacy-bot'),
+    publisher(43, metadata('Bot'), 'human@calling.invalid')];
+  const legacy = make(false);
+  try {
+    await legacy.start();
+    assert.deepStrictEqual([...legacy.subscribers.keys()], [43], 'legacy metadata cannot hide a human or impersonate one for a prefixed bot; own numeric feed remains excluded');
+    await legacy.janus.listeners.get(legacy.publisherHandle)({ janus: 'event', plugindata: { data: { publishers: [
+      publisher(50, metadata('Bot'), 'untrusted-kind@calling.invalid'), publisher(51, metadata('User'), 'open-claudia:other-bot'),
+      publisher(52, undefined, 'older-client@calling.invalid'),
+    ] } } });
+    assert.deepStrictEqual([...legacy.subscribers.keys()], [43, 50, 52], 'legacy live publishers keep display-prefix behavior regardless of spoofed or absent metadata');
+  } finally { await legacy.close(); }
+}
+
 async function testAssignedRelayTransportLifetime() {
   const { RTCPeerConnection } = require('werift');
   const originalExpiry = Date.now() + 3600000;
@@ -538,6 +739,7 @@ async function testAssignedRelayTransportLifetime() {
 }
 
 (async () => {
+  await testTrustedPublisherMetadata();
   await testAssignedRelayTransportLifetime();
   await testManagedRoomCredentials();
   await testSpeakSerialization();
@@ -549,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();
@@ -560,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; });