@inetafrica/open-claudia 3.5.47 → 3.5.59

package/test-kazee-call-session.js

@@ -3,7 +3,7 @@
 
 const assert = require("assert");
 const { EventEmitter } = require("events");
-const { KazeeCallSession } = require("./channels/kazee/call/session");
+const { KazeeCallSession, realWords, newHeard, noteHeard, heardSummary } = 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");
@@ -65,6 +65,43 @@ function toneOpus(codec, amplitude) {
   return codec.encode(pcm);
 }
 
+// 13 Oct: a call heard no words while packets arrived, and the log could not
+// say why. The close log now says how loud the caller came in, how many
+// packets failed to decode, and how often the voice gate opened.
+async function testHeardSummary() {
+  const empty = newHeard();
+  assert.strictEqual(heardSummary(empty, -50), "frames=0 decode-errors=0 p10=none p50=none p90=none max=none voice-starts=0 gate=-50dB");
+  const h = newHeard();
+  for (let i = 0; i < 9; i += 1) noteHeard(h, -70.4);
+  noteHeard(h, -20.6);
+  noteHeard(h, -Infinity);
+  assert.strictEqual(heardSummary(h, -47.6), "frames=11 decode-errors=0 p10=-70dB p50=-70dB p90=-70dB max=-21dB voice-starts=0 gate=-48dB");
+
+  const { session } = makeSession();
+  const logs = [];
+  const log = console.log;
+  console.log = (...args) => { logs.push(args.join(" ")); };
+  try {
+    await session._subscribe(902, "caller");
+    const codec = new OpusAudioCodec();
+    for (let i = 0; i < 20; i += 1) session._onFeedRtp(902, { payload: toneOpus(codec, 30) });
+    for (let i = 0; i < 10; i += 1) session._onFeedRtp(902, { payload: toneOpus(codec, 12000) });
+    session._onFeedRtp(902, { payload: Buffer.alloc(2000, 0xff) });
+    codec.close();
+    await session._removeSubscriber(902);
+  } finally {
+    console.log = log;
+    await session.close();
+  }
+  const line = logs.find((l) => l.includes("Kazee call heard: feed=902"));
+  assert.ok(line, "the close log says what was heard");
+  assert.match(line, /frames=30 decode-errors=1 /);
+  assert.match(line, /voice-starts=1 /, "the loud tone opened the voice gate once");
+  const max = Number(line.match(/max=(-?\d+)dB/)[1]);
+  const p10 = Number(line.match(/p10=(-?\d+)dB/)[1]);
+  assert.ok(max > -20 && p10 < -50, `quiet and loud frames both show (${line})`);
+}
+
 async function testDelayedSpeechProtocolReady() {
   class DelayedWebSocket extends EventEmitter {
     static OPEN = 1;
@@ -166,23 +203,89 @@ async function testEchoGateAndBargeIn() {
   const { session } = makeSession({
     synthesize: async () => ({ pcm: Buffer.alloc(WEBRTC_SAMPLES * 2 * 100), sampleRate: 48000 }),
   });
+  let starts = 0;
+  session.onSpeechStart = () => { starts += 1; };
   await session._subscribe(101, "sumeet@kazee");
   const sub = session.subscribers.get(101);
   const gen = new OpusAudioCodec();
   session.publisher = { track: { writeRtp: () => {} }, sender: { codec: { payloadType: 111 } } };
-  const playing = session.speak("long answer");
+  const line = "Here is the long answer about the mail queue backlog.";
+  const playing = session.speak(line, { resumable: true });
   await wait(30);
   assert.strictEqual(session.speaking, true);
   for (let i = 0; i < 6; i += 1) session._onFeedRtp(101, { payload: toneOpus(gen, 1500) }); // ~-30dB: echo territory
   assert.strictEqual(session.speaking, true, "echo-level audio does not interrupt TTS");
   assert.strictEqual(sub.stt.audioFrames.length, 0, "echo-level audio is not streamed to STT");
-  for (let i = 0; i < 3; i += 1) session._onFeedRtp(101, { payload: toneOpus(gen, 12000) }); // ~-12dB: real speech
-  assert.strictEqual(await playing, false, "barge-in cancels TTS");
-  assert(sub.stt.audioFrames.length >= 3, "barge-in speech reaches STT");
+  // 11 Oct 17:43: chewing stopped every reply. A loud sound is listened to,
+  // never obeyed: speech goes on until words come through.
+  for (let i = 0; i < 3; i += 1) session._onFeedRtp(101, { payload: toneOpus(gen, 12000) }); // ~-12dB: loud
+  assert(sub.stt.audioFrames.length >= 3, "the sound reaches STT");
+  assert.strictEqual(session.speaking, true, "a sound alone does not stop speech");
+  assert.strictEqual(session.callerTalking(), false, "a sound alone is not the caller talking");
+  sub.stt.onPartial("mm");
+  sub.stt.onPartial("mm hmm");
+  assert.strictEqual(session.speaking, true, "fillers do not stop speech");
+  sub.stt.onPartial("the long answer about");
+  assert.strictEqual(session.speaking, true, "our own line coming back does not stop speech");
+  assert.strictEqual(starts, 0, "nothing told the manager the caller started");
+  sub.stt.onPartial("the long answer about wait stop");
+  assert.strictEqual(await playing, false, "two real words stop speech");
+  assert.strictEqual(starts, 1, "the manager hears the caller started, once");
+  assert.strictEqual(session.callerTalking(), true);
+  assert.deepStrictEqual(session.cutSpeech(), { text: line, fromStart: true }, "the unheard line is kept");
+  // The rest of an answer the quick voice was still writing (manager.js
+  // _sayRelayed) goes behind the cut words; a held reply goes in front.
+  session.keepUnsaid("And the backlog is clearing.", { after: true });
+  assert.deepStrictEqual(session.cutSpeech(), { text: `${line} And the backlog is clearing.`, fromStart: true });
+  session.keepUnsaid("Still here.");
+  assert.strictEqual(session.cutSpeech().text, `Still here. ${line} And the backlog is clearing.`);
+  gen.close();
+  await session.close();
+}
+
+// Said over us, below the word gate ("yeah" while we talk): not a turn while
+// we are still talking; once quiet, a one-word answer goes through.
+async function testWordsUnderSpeechDropped() {
+  const { session, transcripts } = makeSession({
+    synthesize: async () => ({ pcm: Buffer.alloc(WEBRTC_SAMPLES * 2 * 200), sampleRate: 48000 }),
+  });
+  await session._subscribe(101, "caller");
+  const sub = session.subscribers.get(101);
+  const gen = new OpusAudioCodec();
+  session.publisher = { track: { writeRtp: () => {} }, sender: { codec: { payloadType: 111 } } };
+  const playing = session.speak("A long answer that keeps going for a while.");
+  await wait(30);
+  for (let i = 0; i < 3; i += 1) session._onFeedRtp(101, { payload: toneOpus(gen, 12000) });
+  sub.stt.onPartial("yeah");
+  for (let i = 0; i < 36; i += 1) session._onFeedRtp(101, { payload: toneOpus(gen, 30) });
+  assert.strictEqual(sub.stt.commits, 1);
+  sub.stt.onTranscript("Yeah.");
+  assert.strictEqual(transcripts.length, 0, "a 'yeah' under our speech is not a turn");
+  assert.strictEqual(session.speaking, true, "and speech carries on");
+  session.cancelSpeech();
+  await playing;
+  await wait(30);
+  for (let i = 0; i < 3; i += 1) session._onFeedRtp(101, { payload: toneOpus(gen, 12000) });
+  sub.stt.onPartial("yes");
+  assert.strictEqual(session.callerTalking(), true, "one real word when we are quiet is talking");
+  for (let i = 0; i < 36; i += 1) session._onFeedRtp(101, { payload: toneOpus(gen, 30) });
+  sub.stt.onTranscript("Yes.");
+  assert.deepStrictEqual(transcripts.map((item) => item.text), ["Yes."], "once quiet, a short answer goes through");
   gen.close();
   await session.close();
 }
 
+function testRealWords() {
+  assert.strictEqual(realWords("um uh mm hmm"), 0, "fillers");
+  assert.strictEqual(realWords("Oh, wait."), 1);
+  assert.strictEqual(realWords("wait stop that"), 3);
+  const ours = "The mail queue has forty messages waiting.";
+  assert.strictEqual(realWords("the mail queue has", ours), 0, "our own line coming back");
+  assert.strictEqual(realWords("what's in the mail queue", ours), 2, "a question about the same thing is the caller");
+  assert.strictEqual(realWords("the mail queue has wait stop", ours), 2, "the caller's words after our echo count");
+  assert.strictEqual(realWords("hang on", ours), 2);
+}
+
 async function testPrebufferAndCommit() {
   const { session } = makeSession({});
   await session._subscribe(101, "caller");
@@ -218,6 +321,8 @@ async function testHoldForWords() {
 
 async function testHoldTimeoutDropsNoiseTurn() {
   const { session, transcripts } = makeSession({});
+  const noise = [];
+  session.onSpeechNoise = (meta) => noise.push(meta);
   await session._subscribe(101, "caller");
   const sub = session.subscribers.get(101);
   const gen = new OpusAudioCodec();
@@ -230,6 +335,7 @@ async function testHoldTimeoutDropsNoiseTurn() {
   assert.strictEqual(session._thinkTimer, null, "noise commit stays silent — no ack, no ticking");
   sub.stt.onTranscript("uh"); // babble leaked a stray word into the transcript
   assert.strictEqual(transcripts.length, 0, "sub-threshold noise transcript never dispatches");
+  assert.deepStrictEqual(noise, [{ feedId: 101 }], "a turn with no words reports noise, so a muted answer can speak again");
   gen.close();
   await session.close();
 }
@@ -318,6 +424,38 @@ async function testVersionedFinalsBelongToTheirCommittedSegment() {
   await session.close();
 }
 
+// At a versioned commit the words heard so far go out at once, tagged with
+// the segment the final will carry (manager.js _earlyWords); a committed
+// segment that never reaches onTranscript is reported dropped.
+async function testEarlyWordsAtCommit() {
+  const { session, transcripts } = makeSession({ finalWaitMs: 30 });
+  const early = [];
+  const dropped = [];
+  session.onEarlyWords = (text, meta) => early.push({ text, meta });
+  session.onUtteranceDropped = (id) => dropped.push(id);
+  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, "check the deploy", { protocol: 2, streamId: 1, segmentId: 1 });
+  session._commitTurn(101, "silence");
+  assert.deepStrictEqual(early.map(e => [e.text, e.meta.utteranceId]), [["check the deploy", "1:1"]]);
+  assert.strictEqual(transcripts.length, 0, "the turn itself still waits for the final");
+  session._onFeedFinal(101, "Check the deploy.", { protocol: 2, streamId: 1, segmentId: 1 });
+  assert.strictEqual(transcripts[0].meta.utteranceId, "1:1");
+  // One word is not enough to start on.
+  session._onFeedPartial(101, "yeah", { protocol: 2, streamId: 1, segmentId: 2 });
+  session._commitTurn(101, "silence");
+  assert.strictEqual(early.length, 1);
+  // A noise commit: no early words; its empty final is reported dropped.
+  sub.noiseCommit = true;
+  session._commitTurn(101, "no-words");
+  assert.strictEqual(early.length, 1);
+  session._onFeedFinal(101, "", { protocol: 2, streamId: 1, segmentId: 3 });
+  assert.deepStrictEqual(dropped, ["1:3"]);
+  await session.close();
+}
+
 async function testSemanticPauseResumesWithoutSplittingAudio() {
   const { session } = makeSession();
   const decisions = [];
@@ -354,6 +492,52 @@ async function testSemanticPauseResumesWithoutSplittingAudio() {
   await session.close();
 }
 
+// The live speech service (protocol 2): chewing over our speech is a turn
+// with no words, and speech goes on; a "yeah" is dropped; real words stop it.
+async function testVersionedWordsNotSound() {
+  const { session, transcripts } = makeSession({
+    synthesize: async () => ({ pcm: Buffer.alloc(WEBRTC_SAMPLES * 2 * 400), sampleRate: 48000 }),
+  });
+  session.turnDecision = async () => ({ complete: true });
+  let starts = 0, noises = 0;
+  session.onSpeechStart = () => { starts += 1; };
+  session.onSpeechNoise = () => { noises += 1; };
+  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() }; };
+  session.publisher = { track: { writeRtp: () => {} }, sender: { codec: { payloadType: 111 } } };
+  const codec = new OpusAudioCodec();
+  const sound = () => { 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) }); };
+  const playing = session.speak("Here is the whole answer, which takes a few seconds to say.", { resumable: true });
+  await wait(30);
+  sound(); silence();
+  await wait(5);
+  assert.strictEqual(sub.stt.commits, 1, "chewing commits a turn");
+  session._onFeedFinal(101, "", { protocol: 2, streamId: 1, segmentId: 1 });
+  assert.strictEqual(session.speaking, true, "chewing does not stop speech");
+  assert.strictEqual(starts, 0);
+  sound();
+  session._onFeedPartial(101, "yeah", { protocol: 2, streamId: 1, segmentId: 2 });
+  silence();
+  await wait(5);
+  session._onFeedFinal(101, "Yeah.", { protocol: 2, streamId: 1, segmentId: 2 });
+  assert.strictEqual(transcripts.length, 0, "a 'yeah' under our speech is not a turn");
+  assert.strictEqual(session.speaking, true);
+  sound();
+  session._onFeedPartial(101, "hang on", { protocol: 2, streamId: 1, segmentId: 3 });
+  assert.strictEqual(await playing, false, "real words stop speech");
+  assert.strictEqual(starts, 1);
+  assert.strictEqual(session.callerTalking(), true);
+  silence();
+  await wait(5);
+  session._onFeedFinal(101, "Hang on a second.", { protocol: 2, streamId: 1, segmentId: 3 });
+  assert.deepStrictEqual(transcripts.map((t) => t.text), ["Hang on a second."]);
+  codec.close();
+  await session.close();
+}
+
 async function testTurnModelFailureAndCloseAreBounded() {
   const { SpeechTurnGate } = require("./channels/kazee/call/turn-gate");
   const commits = [];
@@ -403,7 +587,7 @@ async function testTranscriptAttribution() {
   }
   const inbound = [];
   const adapter = { ownerUserId: "owner-1", botUserId: "bot-1", _socket: { on() {}, emit() {} }, _emit: (name, payload) => inbound.push(payload) };
-  const manager = new KazeeCallManager({ adapter, SessionImpl: FakeSession });
+  const manager = new KazeeCallManager({ adapter, SessionImpl: FakeSession, quickSettings: () => ({ enabled: false }) });
   await manager.incoming({ fromUserId: "owner-1", chatId: "c", roomId: 5, callType: "audio" });
   manager.session.options.onTranscript("hi", { feedId: 1, display: "alice@kazee", participants: 2 });
   assert.strictEqual(inbound[0].text, "alice@kazee: hi", "group transcripts are speaker-prefixed");
@@ -506,6 +690,42 @@ async function testCallerModeRoomLifecycle() {
   assert.ok(destroy && destroy.room === 7, "created room is destroyed on close");
 }
 
+// A prepared opening line replaces the fixed greeting; an empty or failed one
+// falls back to it, and a call that closed first stays silent.
+async function testPreparedGreetingLine() {
+  for (const [line, expected] of [
+    [() => Promise.resolve("Hey Sumeet, still on the calls update? What's up?"), ["Hey Sumeet, still on the calls update? What's up?"]],
+    [() => Promise.resolve(""), ["fixed hello"]],
+    [() => Promise.reject(new Error("quick voice gone")), ["fixed hello"]],
+  ]) {
+    const { session } = makeSession({ greeting: "fixed hello" });
+    const spoken = [];
+    session.speak = async (text) => { spoken.push(text); return true; };
+    session.greetingLine = line();
+    session._publisherUp = true;
+    session.subscribers.set(101, {});
+    session._maybeGreet();
+    session._maybeGreet();
+    await new Promise((resolve) => setImmediate(resolve));
+    assert.deepStrictEqual(spoken, expected);
+    session.subscribers.clear();
+    await session.close();
+  }
+  const { session } = makeSession({ greeting: "fixed hello" });
+  const spoken = [];
+  session.speak = async (text) => { spoken.push(text); return true; };
+  let release;
+  session.greetingLine = new Promise((resolve) => { release = resolve; });
+  session._publisherUp = true;
+  session.subscribers.set(101, {});
+  session._maybeGreet();
+  session.subscribers.clear();
+  await session.close();
+  release("Hey Sumeet, what's up?");
+  await new Promise((resolve) => setImmediate(resolve));
+  assert.deepStrictEqual(spoken, [], "no greeting into a call that already ended");
+}
+
 async function testCallerModeRoomExistsAndFailure() {
   const { session } = makeSession({ asCaller: true });
   session.janus.message = async (_handle, body) => body?.request === "create"
@@ -560,10 +780,13 @@ async function testThinkingCues() {
   await session.speak("answer");
   assert.strictEqual(session._thinkTimer, null, "answer playback stops the thinking loop");
 
-  // A fresh thinking loop stops the moment the caller starts talking again.
+  // A fresh thinking loop stops the moment the caller starts talking again:
+  // on their words, not on a sound.
   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");
+  assert(session._thinkTimer, "a sound alone leaves the thinking loop");
+  sub.stt.onPartial("hold on");
+  assert.strictEqual(session._thinkTimer, null, "caller words stop the thinking loop");
   gen.close();
   await session.close();
 }
@@ -625,6 +848,113 @@ async function testManagedRoomCredentials() {
   assert.ok(!session.janus.calls.some(body => ["create", "destroy"].includes(body.request)), "server allocated room ownership never transfers to the bot");
 }
 
+// The caller's camera (camera.js): a feed's connection takes their video
+// with the orientation extension, a camera switched on mid-call is offered
+// again by Janus and answered, and a failed re-offer keeps the call's audio.
+async function testCallerCamera() {
+  const userId = 'a'.repeat(24);
+  const pcs = [];
+  class CameraPC extends FakePC {
+    constructor(options) {
+      super(options);
+      pcs.push(this);
+      this.remote = [];
+      this.trackListeners = [];
+      this.onTrack = { subscribe: (fn) => this.trackListeners.push(fn) };
+    }
+    async setRemoteDescription(description) {
+      if (this.failNext) { this.failNext = false; throw new Error('renegotiation unsupported'); }
+      this.remote.push(description);
+    }
+    async createAnswer() { return { type: 'answer', sdp: `answer-${this.remote.length}` }; }
+    async setLocalDescription(description) { this.localDescription = description; }
+    getTransceivers() { return this.transceivers || []; }
+  }
+  class CameraJanus extends FakeJanus {
+    constructor() { super(); this.calls = []; this.listeners = new Map(); }
+    onHandle(handle, listener) { this.listeners.set(handle, listener); }
+    async message(handle, body, jsep) {
+      this.calls.push({ handle, ...body, jsep });
+      if (body.request === 'join' && body.ptype === 'publisher') return { plugindata: { data: { videoroom: 'joined', id: 41, private_id: 9, publishers: [{ id: 43, display: 'caller@calling.invalid', metadata: { kazee: { version: 1, userId, principalKind: 'User' } } }] } } };
+      if (body.request === 'configure') return { jsep: { type: 'answer', sdp: 'fixture' } };
+      if (body.request === 'join' && body.ptype === 'subscriber') {
+        // Real Janus also sends the join's offer as a handle event.
+        const attached = { janus: 'event', plugindata: { data: { videoroom: 'attached', streams: [{ mindex: 0, mid: '0', type: 'audio', feed_id: 43, feed_mid: '0' }] } }, jsep: { type: 'offer', sdp: 'v=0\r\nm=audio 9 UDP/TLS/RTP/SAVPF 111\r\na=mid:0' } };
+        setImmediate(() => this.listeners.get(handle)?.(attached));
+        return attached;
+      }
+      // Asked for the caller's camera: Janus offers the feed again.
+      if (body.request === 'update') return { plugindata: { data: { videoroom: 'updated', streams: [
+        { mindex: 0, mid: '0', type: 'audio', feed_id: 43, feed_mid: '0' }, { mindex: 1, mid: '1', type: 'video', feed_id: 43, feed_mid: '1' }] } },
+        jsep: { type: 'offer', sdp: 'v=0\r\nm=audio 9 UDP/TLS/RTP/SAVPF 111\r\na=mid:0\r\nm=video 9 UDP/TLS/RTP/SAVPF 96\r\na=mid:1\r\na=extmap:5 urn:3gpp:video-orientation' } };
+      return {};
+    }
+  }
+  const session = new KazeeCallSession({ roomId: 8, chatId: 'chat', callerId: userId, botUserId: 'b'.repeat(24), managedRoom: true,
+    roomToken: 'fixture', roomTokenExpiresAt: Date.now() + 300000,
+    iceServers: [{ urls: 'turn:relay:3478', username: 'fixture', credential: 'fixture' }], iceCredentialsExpiresAt: Date.now() + 3600000,
+    JanusClientImpl: CameraJanus, PeerConnectionImpl: CameraPC, SpeechStreamImpl: FakeSpeechStream });
+  try {
+    await session.start();
+    const sub = session.subscribers.get(43);
+    assert.ok(sub?.started, 'the caller is subscribed');
+    const feedPc = sub.pc;
+    assert.deepStrictEqual(feedPc.options.headerExtensions.video.map((ext) => ext.uri), ['urn:3gpp:video-orientation'], 'the feed asks for the phone\'s orientation');
+    assert.strictEqual(pcs.find((pc) => pc !== feedPc && !pc.options.headerExtensions) != null, true, 'the bot\'s own connection is unchanged');
+    assert.strictEqual(session.cameraStill(), null, 'no still before any video');
+    await new Promise((resolve) => setImmediate(resolve));
+    assert.strictEqual(feedPc.remote.length, 1, 'the join\'s offer arriving twice is answered once');
+    assert.strictEqual(session.janus.calls.filter((call) => call.handle === sub.handle && call.request === 'start').length, 1, 'one start for the join');
+
+    // Camera switched on mid-call: Janus 1.4 tells only the publishers
+    // (11 Oct 17:04: the camera was on and no video reached the bot), so the
+    // bot asks for the new video with update.
+    const listener = session.janus.listeners.get(sub.handle);
+    const publishers = (streams) => session.janus.listeners.get(session.publisherHandle)({ janus: 'event', plugindata: { data: { videoroom: 'event', publishers: [{ id: 43, display: 'caller@calling.invalid', streams }] } } });
+    const updates = () => session.janus.calls.filter((call) => call.handle === sub.handle && call.request === 'update');
+    await publishers([{ type: 'audio', mid: '0' }, { type: 'video', mid: '1', disabled: true }]);
+    assert.strictEqual(updates().length, 0, 'a camera still off is not asked for');
+    await publishers([{ type: 'audio', mid: '0' }, { type: 'video', mid: '1' }]);
+    assert.deepStrictEqual(updates().map((call) => call.subscribe), [[{ feed: 43, mid: '1' }]], 'only the new video is asked for');
+    assert.strictEqual(feedPc.remote.length, 2, 'the new offer is applied');
+    const start = session.janus.calls.filter((call) => call.handle === sub.handle && call.request === 'start');
+    assert.strictEqual(start.length, 2, 'and answered with start');
+    assert.strictEqual(start[1].jsep.sdp, 'answer-2');
+    assert.strictEqual(sub.orientationId, 5);
+    assert.deepStrictEqual([...sub.receiving], ['0', '1']);
+    await publishers([{ type: 'audio', mid: '0' }, { type: 'video', mid: '1' }]);
+    assert.strictEqual(updates().length, 1, 'a video already coming in is not asked for again');
+
+    // Its video track starts stills, which learn the orientation id.
+    let rtp = null;
+    feedPc.trackListeners.forEach((fn) => fn({ kind: 'video', ssrc: 77, onReceiveRtp: { subscribe: (fn2) => { rtp = fn2; } } }));
+    assert.ok(sub.camera, 'stills are set up');
+    assert.strictEqual(sub.camera.orientationId, 5);
+    assert.strictEqual(typeof rtp, 'function', 'video packets go to the stills');
+
+    // A re-offer the connection cannot take (11 Oct 17:44, werift:
+    // "Transceiver with mid=1 not found"): the feed is joined again, once, so
+    // a fresh offer brings audio and camera; the caller is never dropped.
+    const detached = [];
+    session.janus.detach = async (handle) => { detached.push(handle); };
+    const joins = () => session.janus.calls.filter((call) => call.request === 'join' && call.ptype === 'subscriber' && call.feed === 43);
+    feedPc.failNext = true;
+    await listener({ janus: 'event', plugindata: { data: { videoroom: 'updated' } }, jsep: { type: 'offer', sdp: 'm=video 0' } });
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    assert.deepStrictEqual(detached, [sub.handle], 'the old feed connection is let go');
+    assert.strictEqual(joins().length, 2, 'the feed is joined again');
+    const fresh = session.subscribers.get(43);
+    assert.ok(fresh && fresh !== sub && fresh.started && fresh.rejoined, 'a fresh feed connection, started');
+    assert.strictEqual(fresh.display, 'caller@calling.invalid');
+    // Failing again: no loop of joins.
+    fresh.pc.failNext = true;
+    await session.janus.listeners.get(fresh.handle)({ janus: 'event', plugindata: { data: { videoroom: 'updated' } }, jsep: { type: 'offer', sdp: 'm=video 0\r\na=mid:1' } });
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    assert.strictEqual(joins().length, 2, 'joined again once only');
+    assert.strictEqual(session.subscribers.get(43), fresh, 'and the caller stays');
+  } finally { await session.close(); }
+}
+
 async function testTrustedPublisherMetadata() {
   const botId = 'b'.repeat(24), userId = 'a'.repeat(24);
   const metadata = (principalKind, id = userId) => ({ kazee: { version: 1, userId: id, principalKind } });
@@ -745,7 +1075,9 @@ async function testAssignedRelayTransportLifetime() {
   await testSpeakSerialization();
   await testSpeakCancellation();
   await testMeasuredMediaReady();
+  testRealWords();
   await testEchoGateAndBargeIn();
+  await testWordsUnderSpeechDropped();
   await testPrebufferAndCommit();
   await testHoldForWords();
   await testHoldTimeoutDropsNoiseTurn();
@@ -753,8 +1085,10 @@ async function testAssignedRelayTransportLifetime() {
   await testInterimFallbackAndLateFinal();
   await testNoiseAfterFallbackCannotReplayPreviousUtterance();
   await testVersionedFinalsBelongToTheirCommittedSegment();
+  await testEarlyWordsAtCommit();
   await testTrickleBuffering();
   await testSemanticPauseResumesWithoutSplittingAudio();
+  await testVersionedWordsNotSound();
   await testTurnModelFailureAndCloseAreBounded();
   await testCancelStopsPendingTtsRequest();
   await testTranscriptAttribution();
@@ -764,9 +1098,12 @@ async function testAssignedRelayTransportLifetime() {
   await testJoinRetriesNoSuchRoom();
   await testJoinGivesUpAfterRetries();
   await testCallerModeRoomLifecycle();
+  await testPreparedGreetingLine();
   await testCallerModeRoomExistsAndFailure();
   await testThinkingCues();
   await testCloseResolvesSpeech();
   await testDelayedSpeechProtocolReady();
+  await testCallerCamera();
+  await testHeardSummary();
   console.log("kazee call session: ok");
 })().catch((error) => { console.error(error); process.exitCode = 1; });

package/test-provider-compaction.js

@@ -126,6 +126,14 @@ async function immutableSuccessProbe() {
   assert.strictEqual(contexts[1].maxTurns, 1);
   assert.strictEqual(contexts[1].timeoutMs, contexts[0].timeoutMs);
   assert.strictEqual(contexts[0].purpose, "compact-summary");
+  // The summary stage reads the live conversation through a fork, so its
+  // "Summarize this conversation…" prompt is never written into the live
+  // session. On 12 Oct a cold-resume summary failed (OAuth refresh error) and
+  // left that prompt behind; the next turn answered it and the whole brief,
+  // seed and all, went to the chat as a reply.
+  assert.strictEqual(contexts[0].resumeSessionId, "old-claude");
+  assert.strictEqual(contexts[0].forkSession, true, "the summary stage forks the live session instead of writing into it");
+  assert.strictEqual(contexts[1].forkSession, false, "the seed starts a fresh session: nothing to fork");
   assert.strictEqual(contexts[0].recallQuery, null, "summary stage carries no recall query");
   // Claude runs the summary stage with --max-turns 1: a tool call (a transcript
   // search, a status check) uses up the one turn and ends it with no brief, so

package/test-provider-language.js

@@ -610,15 +610,25 @@ assert.match(pkg.description, /provider-agnostic coding-agent harness/i);
 // app's address bar, agent-browser's settings for the agent, and container mode for Agent
 // Space's browser container. A canary build for the Browser canary bot; the fleet waits
 // for his OK.
-// 3.5.33 approved by Sumeet 2026-10-11 09:16 EAT ("Yes" to: switch off the Heard echo,
-// the notes lines and the progress message by default, show typing, send one message,
-// roll it to every bot): quiet chats by default, /heard /notes /progress to opt in.
-// Built on 3.5.24 for the fleet; 3.5.25-3.5.32 (Browser and call canaries) are not in it.
-// 3.5.47 approved by Sumeet 2026-10-11 21:10 EAT ("proceed to fix", after "Shall I ship the
-// fix to the network bot first, tonight?"): the guard judge's floor keeps credentials
-// absolute but lets channel rules and mandates allow infrastructure and customer data.
-// Built on 3.5.33 (the fleet's version); a canary for the network bot first.
-assert.strictEqual(pkg.version, "3.5.47", "release version must remain unchanged without explicit approval");
+// 3.5.27 approved under Sumeet's 2026-10-11 08:24 EAT go-ahead ("Yeah, let's give it a
+// shot") to build the calls' quick voice and put it live with the speak-first guidance in
+// one restart: a canary build for his own bot; it builds on 3.5.24, without the Browser
+// canaries 3.5.25 and 3.5.26.
+// 3.5.37 under Sumeet's 2026-10-11 15:13 EAT call ("call me once you have the features ready"): camera stills on calls, after
+// 3.5.36 (same call: hang up at once, carry the work on in the chat), 3.5.35 (14:59 hang-up tags) and 3.5.34 (14:17 "do the
+// call's suggestions and tests"): local builds for his own bot; the fleet waits for his OK.
+// 3.5.32 under Sumeet's 2026-10-11 10:51 EAT question (the call went silent after /voice Expresso: voice fallback), after
+// 3.5.31 under Sumeet's 2026-10-11 10:14 EAT call note ("maybe we can get the main bot to look at that next": lead-ins), after
+// 3.5.30 under Sumeet's 2026-10-11 09:50 EAT "Let's work on it end to end and test" (the quick voice runs the call), after
+// 3.5.29 under Sumeet's 2026-10-11 09:26 EAT "Just be calling me when you are ready to test" (calls I place open from the chat too), after
+// 3.5.28 under Sumeet's 2026-10-11 09:00 EAT request for a greeting that picks up where
+// the chat left off, written while the call rings: a local build for his own bot (the
+// restart asked for separately); the fleet waits for his OK.
+// 3.5.58 under Sumeet's 2026-10-13 11:53 EAT "Yes" to rolling the call work and thread calls
+// out to the fleet, canary pod first (his 11:3x EAT "can we roll it out the rest of the fleet?").
+// 3.5.59 under Sumeet's 2026-10-13 16:39 EAT "fix the other bug also but approvals need to go to
+// the owners direct chat" (kazee-tickets-bot's Ops room): canary on that bot first.
+assert.strictEqual(pkg.version, "3.5.59", "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

@@ -91,6 +91,7 @@ if (process.argv[2] === "--probe") {
     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.ok(observed.voiceBundle.dynamicContext.includes("your FIRST action is a call-say"), "a live call speaks a short holding line before it works");
     assert.strictEqual(observed.voiceBundle.userPrompt, "Explain that beep.");
     assert.notStrictEqual(
       `${observed.bundle.dynamicContext}\n\n${observed.bundle.userPrompt}`,

package/test-provider-runner.js

@@ -142,6 +142,8 @@ async function main() {
   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");
+  assert.ok(voiceContext.laneKey.endsWith("#call"), "a call turn runs in its own lane, not behind the chat's");
+  assert.strictEqual(voiceContext.threadId, null);
   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]));

package/test-run-lock.js

@@ -180,4 +180,28 @@ releaseAll();
   assert.ok(long.includes(`"${"x".repeat(59)}…"`), "a long label is shortened to 60 characters");
 }
 
+// A live call's turns have a lane of their own beside their chat's, and never
+// wait for a slot: 11 Oct, a long turn in the main chat held every call turn
+// back, and only the quick voice spoke on the call.
+{
+  const { callLaneKey, isCallLaneKey, parseConversationKey } = require("./core/identity");
+  const CALL = callLaneKey(KAZEE);
+  assert.strictEqual(CALL, `${KAZEE}#call`);
+  assert.strictEqual(callLaneKey(CALL), CALL, "idempotent");
+  assert.ok(isCallLaneKey(CALL) && !isCallLaneKey(KAZEE));
+  assert.deepStrictEqual(parseConversationKey(CALL), parseConversationKey(KAZEE), "same chat, no thread");
+  assert.strictEqual(parseConversationKey(callLaneKey(THREAD)).threadId, "aaaaaaaaaaaaaaaaaaaaaaaa");
+
+  const s = fresh();
+  assert.ok(acquireRunLock(s, KAZEE), "a long turn runs in the chat");
+  assert.strictEqual(admitLane(s, KAZEE).reason, "busy");
+  assert.ok(admitLane(s, CALL).ok, "the call's turn starts beside it");
+  assert.strictEqual(admitLane(s, CALL).reason, "busy", "one call turn at a time in the call lane");
+  laneFor(s, CALL).preparingRun = false;
+  for (let i = 0; i < 6; i += 1) acquireRunLock(s, `kazee:busy-${i}`);
+  assert.strictEqual(admitLane(s, "kazee:another").reason, "cap", "a chat waits for a slot");
+  assert.ok(admitLane(s, CALL).ok, "a call never waits for a slot");
+  releaseAll();
+}
+
 console.log("run-lock OK");