@kuralle-syrinx/core 4.1.0 → 4.2.0

package/README.md

@@ -4,6 +4,10 @@ The Syrinx Kernel v2 — the framework-agnostic core of the voice engine: the `P
 
 This README documents the **`Reasoner` seam** added for the Reasoner-bridge generalization; the rest of the kernel surface is in `src/index.ts`.
 
+## Incremental-Unit ledger (dormant)
+
+The IU substrate (`IncrementalUnit`, `InMemoryIuLedger`) models speculative voice work as **hypothesize → ground → discard**: `add` registers a hypothesis, `commit` grounds it (optionally with a heard prefix in chars/ms), and `revoke` discards it. State is monotonic (`hypothesized` → `committed` or `revoked`; terminal ops are idempotent). The ledger is **dormant** in Sprint 0 — no pipeline consumer is wired yet; C2+ will re-express speculative generation, barge-in truncation, and poison-set bookkeeping on this primitive.
+
 ## The Reasoner seam
 
 A normalized pull-stream that lets one bridge ([`ReasoningBridge`](../aisdk/README.md)) drive **any** reasoning backend (Vercel AI SDK `ToolLoopAgent`/`streamText`, Mastra `Agent`, …) without changing the pipeline primitive. Defined in `src/reasoner.ts`:

package/package.json

@@ -1,9 +1,28 @@
 {
   "name": "@kuralle-syrinx/core",
-  "version": "4.1.0",
+  "version": "4.2.0",
   "private": false,
-  "type": "module",
+  "description": "Voice pipeline kernel for Syrinx — pipeline bus, turn arbitration, playout clock, packets, and the framework-agnostic Reasoner seam",
+  "keywords": [
+    "voice",
+    "voice-agent",
+    "speech",
+    "syrinx",
+    "voice-pipeline",
+    "barge-in",
+    "turn-taking"
+  ],
   "license": "MIT",
+  "homepage": "https://github.com/kuralle/syrinx#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kuralle/syrinx.git",
+    "directory": "packages/core"
+  },
+  "bugs": {
+    "url": "https://github.com/kuralle/syrinx/issues"
+  },
+  "type": "module",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
   "exports": {

package/src/confidence-to-wait.test.ts

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: MIT
+
+import { describe, expect, it } from "vitest";
+
+import { confidenceToWaitMs } from "./confidence-to-wait.js";
+
+describe("confidenceToWaitMs", () => {
+  it("maps high confidence to 150ms and low confidence to 2000ms", () => {
+    expect(confidenceToWaitMs(1)).toBe(150);
+    expect(confidenceToWaitMs(0)).toBe(2000);
+    expect(confidenceToWaitMs(2)).toBe(150);
+    expect(confidenceToWaitMs(-1)).toBe(2000);
+  });
+
+  it("is monotonic and supports a bounded custom range", () => {
+    const waits = [0, 0.25, 0.5, 0.75, 1].map((confidence) => confidenceToWaitMs(confidence));
+    expect(waits).toEqual([...waits].sort((a, b) => b - a));
+    expect(confidenceToWaitMs(0.5, { minWaitMs: 100, maxWaitMs: 1100 })).toBe(600);
+    expect(() => confidenceToWaitMs(0.5, { minWaitMs: 500, maxWaitMs: 100 })).toThrow(/must be >=/);
+  });
+});

package/src/confidence-to-wait.ts

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: MIT
+
+export interface ConfidenceToWaitConfig {
+  /** Wait at confidence = 1.0 (high EOT certainty). Default: 150 ms. */
+  readonly minWaitMs?: number;
+  /** Wait at confidence = 0.0 (low EOT certainty). Default: 2000 ms. */
+  readonly maxWaitMs?: number;
+}
+
+const DEFAULT_MIN_WAIT_MS = 150;
+const DEFAULT_MAX_WAIT_MS = 2000;
+
+/**
+ * Maps an end-of-turn confidence score to a bounded finalize wait (LiveKit-style).
+ * Higher confidence → shorter wait. Monotonic, clamped, deterministic.
+ */
+export function confidenceToWaitMs(
+  confidence: number,
+  config: ConfidenceToWaitConfig = {},
+): number {
+  const minWaitMs = config.minWaitMs ?? DEFAULT_MIN_WAIT_MS;
+  const maxWaitMs = config.maxWaitMs ?? DEFAULT_MAX_WAIT_MS;
+  if (maxWaitMs < minWaitMs) {
+    throw new Error(`maxWaitMs (${String(maxWaitMs)}) must be >= minWaitMs (${String(minWaitMs)})`);
+  }
+
+  const clamped = Math.min(1, Math.max(0, confidence));
+  const span = maxWaitMs - minWaitMs;
+  return Math.round(maxWaitMs - clamped * span);
+}

package/src/hedge-throwing-backend.test.ts

@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: MIT
+// Regression guard (RL-WBS-1): a backend whose next() REJECTS (throws) — e.g. an adapter that
+// throws AbortError on barge-in — must NOT hang the hedge race; it fails over / surfaces an error.
+import { describe, expect, it } from "vitest";
+import { HedgedReasoner } from "./reasoner-hedge.js";
+import type { Reasoner, ReasonerTurn, ReasoningPart } from "./reasoner.js";
+import type { Scheduler } from "./scheduler.js";
+
+class ThrowingReasoner implements Reasoner {
+  async *stream(_turn: ReasonerTurn): AsyncGenerator<ReasoningPart> {
+    throw new Error("backend boom"); // rejects on first next()
+  }
+}
+class GoodReasoner implements Reasoner {
+  async *stream(_turn: ReasonerTurn): AsyncGenerator<ReasoningPart> {
+    yield { type: "text-delta", text: "backup ok" };
+    yield { type: "finish", reason: "stop", text: "backup ok" };
+  }
+}
+// scheduler that fires immediately so backup is available
+const eagerScheduler: Scheduler = { schedule: (_k, _ms, cb) => cb(), cancel: () => {} };
+
+function turn(): ReasonerTurn {
+  return { userText: "hi", messages: [], signal: new AbortController().signal };
+}
+
+describe("hedge reject repro", () => {
+  it("does not hang when the primary backend THROWS (rejects next())", async () => {
+    const hedged = new HedgedReasoner({
+      primary: new ThrowingReasoner(),
+      backup: new GoodReasoner(),
+      hedgeAfterMs: 0,
+      scheduler: eagerScheduler,
+    });
+    const parts: string[] = [];
+    const collect = (async () => {
+      for await (const p of hedged.stream(turn())) {
+        if (p.type === "text-delta") parts.push(p.text);
+      }
+    })();
+    const timeout = new Promise((_r, rej) => setTimeout(() => rej(new Error("HUNG: HedgedReasoner never completed")), 3000));
+    await Promise.race([collect, timeout]);
+    // If it doesn't hang, it should have failed over to the backup.
+    expect(parts).toContain("backup ok");
+  });
+});

package/src/incremental-unit.ts

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MIT
+//
+// Syrinx Kernel v2 — Incremental-Unit identity + state (IU substrate, RFC incremental-unit-substrate)
+
+export type IuState = "hypothesized" | "committed" | "revoked";
+
+export interface IncrementalUnitId {
+  readonly contextId: string;
+  readonly iuId: string;
+  readonly epoch: number;
+}
+
+export interface IncrementalUnit {
+  readonly id: IncrementalUnitId;
+  readonly kind: "user_turn" | "assistant_response" | "tts_segment";
+  state: IuState;
+  /** For assistant/tts IUs: the committed character/ms prefix (heard). */
+  committedPrefix?: { chars?: number; ms?: number };
+}

package/src/index.ts

@@ -30,6 +30,7 @@ export {
   type VadSpeechActivityPacket,
   type SpeechToTextAudioPacket,
   type SttInterimPacket,
+  type SttPartialPacket,
   type SttResultPacket,
   type FinalizeSttPacket,
   type SttErrorPacket,
@@ -78,6 +79,18 @@ export {
   type ReasonerSessionStore,
 } from "./reasoner-session-store.js";
 
+// Incremental-Unit ledger (IU substrate — dormant until C2)
+export {
+  type IuState,
+  type IncrementalUnitId,
+  type IncrementalUnit,
+} from "./incremental-unit.js";
+export {
+  type IuLedger,
+  type IuLedgerAnomaly,
+  InMemoryIuLedger,
+} from "./iu-ledger.js";
+
 // Pipeline packets — TTS
 export {
   type TextToSpeechTextPacket,
@@ -187,6 +200,23 @@ export {
   type SyrinxAudioEnvelopeHeader,
 } from "./audio-envelope.js";
 
+export { StreamingPcm16Resampler } from "./audio/index.js";
+
+// Interaction policy seam (IP-C1)
+export {
+  type InteractionPolicy,
+  type LifecycleInteractionPolicy,
+  isLifecycleInteractionPolicy,
+  type InteractionObservation,
+  type InteractionDecision,
+  type WordTiming,
+} from "./interaction-policy.js";
+export { confidenceToWaitMs, type ConfidenceToWaitConfig } from "./confidence-to-wait.js";
+export { RuleBasedInteractionPolicy } from "./policies/rule-based.js";
+export { DeferInteractionPolicy } from "./policies/defer.js";
+export { InteractionCoordinator, type InteractionCaps } from "./interaction-coordinator.js";
+export { type InteractionBackchannelPacket } from "./packets.js";
+
 // VoiceAgentSession
 export { VoiceAgentSession, type VoiceAgentSessionConfig, type VoiceAgentSessionEvents } from "./voice-agent-session.js";
 
@@ -228,3 +258,13 @@ export {
   type ReasonerMessage,
   type ReasoningPart,
 } from "./reasoner.js";
+
+// Hedged reasoner (Lever C — reasoner-latency RFC)
+export { HedgedReasoner, type HedgedReasonerOptions } from "./reasoner-hedge.js";
+
+// Routing reasoner (Lever B — reasoner-latency RFC)
+export {
+  RoutingReasoner,
+  type RoutingReasonerOptions,
+  type ReasonerRoute,
+} from "./reasoner-route.js";

package/src/interaction-coordinator.test.ts

@@ -0,0 +1,425 @@
+// SPDX-License-Identifier: MIT
+
+import { describe, it, expect, vi } from "vitest";
+import { PipelineBusImpl, Route } from "./pipeline-bus.js";
+import { InteractionCoordinator } from "./interaction-coordinator.js";
+import type { InteractionDecision, InteractionObservation, InteractionPolicy } from "./interaction-policy.js";
+import { TurnArbiter } from "./turn-arbiter.js";
+import { PrimarySpeakerGate } from "./primary-speaker-gate.js";
+import { TtsPlayoutClock } from "./tts-playout-clock.js";
+import { TimerScheduler } from "./scheduler.js";
+import type { EndOfSpeechPacket, InteractionBackchannelPacket, InterruptionDetectedPacket } from "./packets.js";
+
+class StubPolicy implements InteractionPolicy {
+  constructor(private readonly decisions: InteractionDecision[]) {}
+
+  observe(_obs: InteractionObservation): readonly InteractionDecision[] {
+    return this.decisions;
+  }
+
+  reset(): void {}
+}
+
+class StatefulPolicy implements InteractionPolicy {
+  private step = 0;
+
+  constructor(private readonly steps: Array<readonly InteractionDecision[]>) {}
+
+  observe(_obs: InteractionObservation): readonly InteractionDecision[] {
+    const out = this.steps[this.step] ?? [];
+    this.step += 1;
+    return out;
+  }
+
+  reset(): void {
+    this.step = 0;
+  }
+}
+
+async function createCoordinator(
+  decisions: InteractionDecision[],
+  options: {
+    emitsBackchannel?: boolean;
+    isUserSpeaking?: () => boolean;
+    isTtsActive?: () => boolean;
+    hasCueAsset?: (cueId: string) => boolean;
+  } = {},
+) {
+  const bus = new PipelineBusImpl();
+  void bus.start();
+  const ttsPlayout = new TtsPlayoutClock();
+  const executor = new TurnArbiter({
+    bus,
+    primarySpeakerGate: new PrimarySpeakerGate(),
+    ttsPlayout,
+    minInterruptionMs: 280,
+  });
+  const coordinator = new InteractionCoordinator({
+    bus,
+    policy: new StubPolicy(decisions),
+    executor,
+    scheduler: new TimerScheduler(),
+    caps: { emitsBackchannel: options.emitsBackchannel },
+    isUserSpeaking: options.isUserSpeaking,
+    isTtsActive: options.isTtsActive,
+    hasCueAsset: options.hasCueAsset,
+  });
+  coordinator.initialize();
+  return { bus, coordinator, executor };
+}
+
+async function drainBus(): Promise<void> {
+  await new Promise((resolve) => setTimeout(resolve, 0));
+}
+
+function metricNames(bus: PipelineBusImpl): string[] {
+  const names: string[] = [];
+  bus.on("metric.conversation", (pkt) => {
+    names.push((pkt as unknown as { name: string }).name);
+  });
+  return names;
+}
+
+describe("InteractionCoordinator", () => {
+  it("maps interrupt decision to executor.emitInterruptDetected", async () => {
+    const { bus, coordinator, executor } = await createCoordinator([
+      { kind: "interrupt", interruptedContextId: "assistant-turn" },
+    ]);
+    const interrupts: InterruptionDetectedPacket[] = [];
+    bus.on("interrupt.detected", (pkt) => {
+      interrupts.push(pkt as InterruptionDetectedPacket);
+    });
+    const emitSpy = vi.spyOn(executor, "emitInterruptDetected");
+
+    coordinator.observe({
+      kind: "vad_speech_activity",
+      contextId: "user",
+      timestampMs: 1000,
+    });
+    await drainBus();
+
+    expect(emitSpy).toHaveBeenCalledOnce();
+    expect(emitSpy).toHaveBeenCalledWith("assistant-turn");
+    expect(interrupts).toHaveLength(1);
+    expect(interrupts[0]!.contextId).toBe("assistant-turn");
+  });
+
+  it("emits interaction.backchannel for a backchannel decision", async () => {
+    const { bus, coordinator } = await createCoordinator([{ kind: "backchannel", cue: "mm_hmm" }]);
+    const packets: InteractionBackchannelPacket[] = [];
+    const metrics = metricNames(bus);
+    bus.on("interaction.backchannel", (pkt) => {
+      packets.push(pkt as InteractionBackchannelPacket);
+    });
+
+    coordinator.observe({
+      kind: "delegate_state",
+      contextId: "turn-1",
+      timestampMs: 2000,
+      toolCallPhase: "delayed",
+    });
+    await drainBus();
+
+    expect(packets).toHaveLength(1);
+    expect(packets[0]).toMatchObject({ contextId: "turn-1", cue: "mm_hmm" });
+    expect(metrics).toContain("backchannel.candidate");
+    expect(metrics).toContain("backchannel.emitted");
+  });
+
+  it("suppresses backchannel when caps.emitsBackchannel is true", async () => {
+    const { bus, coordinator } = await createCoordinator(
+      [{ kind: "backchannel", cue: "mm_hmm" }],
+      { emitsBackchannel: true },
+    );
+    const packets: InteractionBackchannelPacket[] = [];
+    const metrics = metricNames(bus);
+    bus.on("interaction.backchannel", (pkt) => {
+      packets.push(pkt as InteractionBackchannelPacket);
+    });
+
+    coordinator.observe({
+      kind: "delegate_state",
+      contextId: "turn-1",
+      timestampMs: 2000,
+      toolCallPhase: "delayed",
+    });
+    await drainBus();
+
+    expect(packets).toEqual([]);
+    expect(metrics).toContain("backchannel.suppressed_caps");
+  });
+
+  it("suppresses backchannel when TTS is active", async () => {
+    const { bus, coordinator } = await createCoordinator(
+      [{ kind: "backchannel", cue: "mm_hmm" }],
+      { isTtsActive: () => true },
+    );
+    const metrics = metricNames(bus);
+
+    coordinator.observe({
+      kind: "delegate_state",
+      contextId: "turn-1",
+      timestampMs: 2000,
+      toolCallPhase: "delayed",
+    });
+    await drainBus();
+
+    expect(metrics).toContain("backchannel.suppressed_tts_active");
+  });
+
+  it("suppresses backchannel when the user is speaking", async () => {
+    const { bus, coordinator } = await createCoordinator(
+      [{ kind: "backchannel", cue: "mm_hmm" }],
+      { isUserSpeaking: () => true },
+    );
+    const metrics = metricNames(bus);
+
+    coordinator.observe({
+      kind: "delegate_state",
+      contextId: "turn-1",
+      timestampMs: 2000,
+      toolCallPhase: "delayed",
+    });
+    await drainBus();
+
+    expect(metrics).toContain("backchannel.suppressed_user_speaking");
+  });
+
+  it("suppresses backchannel when the cue asset is missing", async () => {
+    const { bus, coordinator } = await createCoordinator(
+      [{ kind: "backchannel", cue: "mm_hmm" }],
+      { hasCueAsset: () => false },
+    );
+    const metrics = metricNames(bus);
+
+    coordinator.observe({
+      kind: "delegate_state",
+      contextId: "turn-1",
+      timestampMs: 2000,
+      toolCallPhase: "delayed",
+    });
+    await drainBus();
+
+    expect(metrics).toContain("backchannel.suppressed_missing_asset");
+  });
+
+  it("maps take_turn to stt.finalize and a delayed eos.turn_complete", async () => {
+    vi.useFakeTimers();
+    const { bus, coordinator } = await createCoordinator([{ kind: "take_turn", confidence: 1 }]);
+    const finalizeRequests: string[] = [];
+    const completions: Array<{ contextId: string; text: string }> = [];
+    bus.on("stt.finalize", (pkt) => {
+      finalizeRequests.push(pkt.contextId);
+    });
+    bus.on("eos.turn_complete", (pkt) => {
+      const eos = pkt as EndOfSpeechPacket;
+      completions.push({ contextId: eos.contextId, text: eos.text });
+    });
+
+    coordinator.observe({
+      kind: "vad_speech_ended",
+      contextId: "turn-1",
+      timestampMs: 1000,
+      hasActiveTts: false,
+    });
+    bus.push(Route.Main, {
+      kind: "stt.result",
+      contextId: "turn-1",
+      timestampMs: 1100,
+      text: "hello there",
+      confidence: 0.95,
+      language: "en-US",
+    });
+    await vi.advanceTimersByTimeAsync(0);
+    expect(finalizeRequests).toEqual(["turn-1"]);
+    expect(completions).toEqual([]);
+
+    await vi.advanceTimersByTimeAsync(149);
+    expect(completions).toEqual([]);
+
+    await vi.advanceTimersByTimeAsync(1);
+    expect(completions).toEqual([{ contextId: "turn-1", text: "hello there" }]);
+    vi.useRealTimers();
+  });
+
+  it("uses a transcript that arrived before take_turn and requests STT finalization only once", async () => {
+    vi.useFakeTimers();
+    const { bus, coordinator } = await createCoordinator([{ kind: "take_turn", confidence: 1 }]);
+    const finalizeRequests: string[] = [];
+    const completions: EndOfSpeechPacket[] = [];
+    bus.on("stt.finalize", (pkt) => {
+      finalizeRequests.push(pkt.contextId);
+    });
+    bus.on("eos.turn_complete", (pkt) => {
+      completions.push(pkt as EndOfSpeechPacket);
+    });
+
+    bus.push(Route.Main, {
+      kind: "stt.result",
+      contextId: "turn-cached",
+      timestampMs: 900,
+      text: "already final",
+      confidence: 0.95,
+      language: "en-US",
+    });
+    await vi.advanceTimersByTimeAsync(0);
+    const observation = {
+      kind: "audio_frame" as const,
+      contextId: "turn-cached",
+      timestampMs: 1000,
+      audio: new Int16Array(320),
+    };
+    coordinator.observe(observation);
+    coordinator.observe(observation);
+
+    await vi.advanceTimersByTimeAsync(0);
+    expect(finalizeRequests).toEqual(["turn-cached"]);
+    await vi.advanceTimersByTimeAsync(150);
+    expect(completions).toEqual([
+      expect.objectContaining({ contextId: "turn-cached", text: "already final" }),
+    ]);
+    vi.useRealTimers();
+  });
+
+  it("completes a committed take_turn from the latest interim when no final STT ever arrives", async () => {
+    vi.useFakeTimers();
+    const { bus, coordinator } = await createCoordinator([{ kind: "take_turn", confidence: 1 }]);
+    const finalizeRequests: string[] = [];
+    const completions: EndOfSpeechPacket[] = [];
+    bus.on("stt.finalize", (pkt) => {
+      finalizeRequests.push(pkt.contextId);
+    });
+    bus.on("eos.turn_complete", (pkt) => {
+      completions.push(pkt as EndOfSpeechPacket);
+    });
+
+    coordinator.observe({
+      kind: "vad_speech_ended",
+      contextId: "turn-interim",
+      timestampMs: 1000,
+      hasActiveTts: false,
+    });
+    // Only an interim arrives — the provider never emits a final stt.result.
+    bus.push(Route.Main, {
+      kind: "stt.interim",
+      contextId: "turn-interim",
+      timestampMs: 1100,
+      text: "i wanted to ask",
+    });
+    await vi.advanceTimersByTimeAsync(0);
+    expect(finalizeRequests).toEqual(["turn-interim"]);
+    expect(completions).toEqual([]);
+
+    // High confidence → 150ms wait; the committed turn must NOT be dropped.
+    await vi.advanceTimersByTimeAsync(150);
+    expect(completions).toHaveLength(1);
+    expect(completions[0]).toMatchObject({ contextId: "turn-interim", text: "i wanted to ask" });
+    expect(completions[0]!.transcripts).toHaveLength(1);
+    vi.useRealTimers();
+  });
+
+  it("does not complete a take_turn when neither a final nor an interim ever arrives", async () => {
+    vi.useFakeTimers();
+    const { bus, coordinator } = await createCoordinator([{ kind: "take_turn", confidence: 1 }]);
+    const completions: string[] = [];
+    bus.on("eos.turn_complete", (pkt) => {
+      completions.push(pkt.contextId);
+    });
+
+    coordinator.observe({
+      kind: "vad_speech_ended",
+      contextId: "turn-empty",
+      timestampMs: 1000,
+      hasActiveTts: false,
+    });
+    await vi.advanceTimersByTimeAsync(5000);
+    expect(completions).toEqual([]);
+    vi.useRealTimers();
+  });
+
+  it("revokes a pending take_turn on hold", async () => {
+    vi.useFakeTimers();
+    const bus = new PipelineBusImpl();
+    void bus.start();
+    const coordinator = new InteractionCoordinator({
+      bus,
+      policy: new StatefulPolicy([
+        [{ kind: "take_turn", confidence: 0.2 }],
+        [{ kind: "hold" }],
+      ]),
+      executor: new TurnArbiter({
+        bus,
+        primarySpeakerGate: new PrimarySpeakerGate(),
+        ttsPlayout: new TtsPlayoutClock(),
+        minInterruptionMs: 280,
+      }),
+      scheduler: new TimerScheduler(),
+      caps: {},
+    });
+    coordinator.initialize();
+
+    const completions: string[] = [];
+    bus.on("eos.turn_complete", (pkt) => {
+      completions.push(pkt.contextId);
+    });
+
+    coordinator.observe({
+      kind: "vad_speech_ended",
+      contextId: "turn-hold",
+      timestampMs: 1000,
+      hasActiveTts: false,
+    });
+    bus.push(Route.Main, {
+      kind: "stt.result",
+      contextId: "turn-hold",
+      timestampMs: 1100,
+      text: "wait",
+      confidence: 0.9,
+      language: "en-US",
+    });
+    await vi.advanceTimersByTimeAsync(0);
+    coordinator.observe({
+      kind: "vad_speech_activity",
+      contextId: "turn-hold",
+      timestampMs: 1200,
+    });
+
+    await vi.advanceTimersByTimeAsync(5000);
+    expect(completions).toEqual([]);
+    vi.useRealTimers();
+  });
+
+  it("revokes a pending take_turn when speech resumes", async () => {
+    vi.useFakeTimers();
+    const { bus, coordinator } = await createCoordinator([{ kind: "take_turn", confidence: 0.5 }]);
+    const completions: string[] = [];
+    bus.on("eos.turn_complete", (pkt) => {
+      completions.push(pkt.contextId);
+    });
+
+    coordinator.observe({
+      kind: "vad_speech_ended",
+      contextId: "turn-resume",
+      timestampMs: 1000,
+      hasActiveTts: false,
+    });
+    bus.push(Route.Main, {
+      kind: "stt.result",
+      contextId: "turn-resume",
+      timestampMs: 1100,
+      text: "partial",
+      confidence: 0.9,
+      language: "en-US",
+    });
+    await vi.advanceTimersByTimeAsync(0);
+    bus.push(Route.Main, {
+      kind: "vad.speech_started",
+      contextId: "turn-resume",
+      timestampMs: 1200,
+      confidence: 0.9,
+    });
+    await vi.advanceTimersByTimeAsync(5000);
+    expect(completions).toEqual([]);
+    vi.useRealTimers();
+  });
+});