@kuralle-syrinx/core 4.2.0 → 4.4.0

package/src/interaction-coordinator.test.ts

@@ -1,425 +0,0 @@
-// 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();
-  });
-});

package/src/iu-ledger.test.ts

@@ -1,276 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-import { describe, expect, it, vi } from "vitest";
-import type { IncrementalUnit, IncrementalUnitId } from "./incremental-unit.js";
-import { InMemoryIuLedger, type IuLedgerAnomaly } from "./iu-ledger.js";
-
-function makeId(contextId: string, iuId: string, epoch = 1): IncrementalUnitId {
-  return { contextId, iuId, epoch };
-}
-
-function makeIu(
-  contextId: string,
-  iuId: string,
-  kind: IncrementalUnit["kind"],
-  epoch = 1,
-): IncrementalUnit {
-  return {
-    id: makeId(contextId, iuId, epoch),
-    kind,
-    state: "hypothesized",
-  };
-}
-
-function seedContexts(ledger: InMemoryIuLedger, count: number): IncrementalUnitId {
-  const target = makeId("ctx-target", "iu-target");
-  for (let i = 0; i < count; i++) {
-    ledger.add(makeIu(`ctx-${i}`, `iu-${i}`, "user_turn", i));
-  }
-  ledger.add(makeIu(target.contextId, target.iuId, "user_turn", target.epoch));
-  return target;
-}
-
-describe("InMemoryIuLedger", () => {
-  describe("add", () => {
-    it("registers a hypothesized IU (happy path)", () => {
-      const ledger = new InMemoryIuLedger();
-      const iu = makeIu("ctx-a", "iu-1", "user_turn");
-      ledger.add(iu);
-      expect(ledger.get(iu.id)?.state).toBe("hypothesized");
-    });
-
-    it("overwrites an existing iuId with the latest add (failure path: stale hypothesis replaced)", () => {
-      const ledger = new InMemoryIuLedger();
-      const first = makeIu("ctx-a", "iu-1", "user_turn", 1);
-      const second = makeIu("ctx-a", "iu-1", "assistant_response", 2);
-      ledger.add(first);
-      ledger.add(second);
-      expect(ledger.get(first.id)?.kind).toBe("assistant_response");
-      expect(ledger.get(first.id)?.id.epoch).toBe(2);
-    });
-  });
-
-  describe("commit", () => {
-    it("transitions hypothesized → committed (happy path)", () => {
-      const ledger = new InMemoryIuLedger();
-      const iu = makeIu("ctx-a", "iu-1", "assistant_response");
-      ledger.add(iu);
-      ledger.commit(iu.id);
-      expect(ledger.get(iu.id)?.state).toBe("committed");
-    });
-
-    it("records committedPrefix when provided (happy path)", () => {
-      const ledger = new InMemoryIuLedger();
-      const iu = makeIu("ctx-a", "iu-1", "tts_segment");
-      ledger.add(iu);
-      ledger.commit(iu.id, { ms: 800, chars: 40 });
-      expect(ledger.get(iu.id)?.committedPrefix).toEqual({ ms: 800, chars: 40 });
-    });
-
-    it("is a no-op on an already-committed IU and fires terminal_op (failure path)", () => {
-      const onEvent = vi.fn<(a: IuLedgerAnomaly) => void>();
-      const ledger = new InMemoryIuLedger(onEvent);
-      const iu = makeIu("ctx-a", "iu-1", "user_turn");
-      ledger.add(iu);
-      ledger.commit(iu.id);
-      ledger.commit(iu.id);
-      expect(ledger.get(iu.id)?.state).toBe("committed");
-      expect(onEvent).toHaveBeenCalledOnce();
-      expect(onEvent).toHaveBeenCalledWith({
-        kind: "terminal_op",
-        op: "commit",
-        id: iu.id,
-        state: "committed",
-      });
-    });
-
-    it("does not un-commit: revoke after commit is a no-op with terminal_op (failure path)", () => {
-      const onEvent = vi.fn<(a: IuLedgerAnomaly) => void>();
-      const ledger = new InMemoryIuLedger(onEvent);
-      const iu = makeIu("ctx-a", "iu-1", "user_turn");
-      ledger.add(iu);
-      ledger.commit(iu.id);
-      ledger.revoke(iu.id);
-      expect(ledger.get(iu.id)?.state).toBe("committed");
-      expect(onEvent).toHaveBeenCalledOnce();
-      expect(onEvent).toHaveBeenCalledWith({
-        kind: "terminal_op",
-        op: "revoke",
-        id: iu.id,
-        state: "committed",
-      });
-    });
-
-    it("fail-open on unknown iuId: no throw, unknown_iu anomaly (failure path)", () => {
-      const onEvent = vi.fn<(a: IuLedgerAnomaly) => void>();
-      const ledger = new InMemoryIuLedger(onEvent);
-      const id = makeId("missing", "iu-1");
-      expect(() => ledger.commit(id)).not.toThrow();
-      expect(onEvent).toHaveBeenCalledWith({ kind: "unknown_iu", op: "commit", id });
-    });
-  });
-
-  describe("revoke", () => {
-    it("transitions hypothesized → revoked (happy path)", () => {
-      const ledger = new InMemoryIuLedger();
-      const iu = makeIu("ctx-a", "iu-1", "user_turn");
-      ledger.add(iu);
-      ledger.revoke(iu.id);
-      expect(ledger.get(iu.id)?.state).toBe("revoked");
-    });
-
-    it("is a no-op on an already-revoked IU and fires terminal_op (failure path)", () => {
-      const onEvent = vi.fn<(a: IuLedgerAnomaly) => void>();
-      const ledger = new InMemoryIuLedger(onEvent);
-      const iu = makeIu("ctx-a", "iu-1", "user_turn");
-      ledger.add(iu);
-      ledger.revoke(iu.id);
-      ledger.revoke(iu.id);
-      expect(ledger.get(iu.id)?.state).toBe("revoked");
-      expect(onEvent).toHaveBeenCalledOnce();
-      expect(onEvent).toHaveBeenCalledWith({
-        kind: "terminal_op",
-        op: "revoke",
-        id: iu.id,
-        state: "revoked",
-      });
-    });
-
-    it("fail-open on unknown iuId: no throw, unknown_iu anomaly (failure path)", () => {
-      const onEvent = vi.fn<(a: IuLedgerAnomaly) => void>();
-      const ledger = new InMemoryIuLedger(onEvent);
-      const id = makeId("missing", "iu-1");
-      expect(() => ledger.revoke(id)).not.toThrow();
-      expect(onEvent).toHaveBeenCalledWith({ kind: "unknown_iu", op: "revoke", id });
-    });
-  });
-
-  describe("get", () => {
-    it("returns the registered IU (happy path)", () => {
-      const ledger = new InMemoryIuLedger();
-      const iu = makeIu("ctx-a", "iu-1", "user_turn");
-      ledger.add(iu);
-      expect(ledger.get(iu.id)).toBe(iu);
-    });
-
-    it("returns undefined for an unknown id without throwing (failure path)", () => {
-      const ledger = new InMemoryIuLedger();
-      expect(ledger.get(makeId("missing", "iu-1"))).toBeUndefined();
-    });
-  });
-
-  describe("latest", () => {
-    it("returns the most recently added IU of the requested kind (happy path)", () => {
-      const ledger = new InMemoryIuLedger();
-      ledger.add(makeIu("ctx-a", "iu-1", "user_turn"));
-      ledger.add(makeIu("ctx-a", "iu-2", "assistant_response"));
-      ledger.add(makeIu("ctx-a", "iu-3", "user_turn"));
-      const latest = ledger.latest("ctx-a", "user_turn");
-      expect(latest?.id.iuId).toBe("iu-3");
-    });
-
-    it("returns undefined when no IU of that kind exists (failure path)", () => {
-      const ledger = new InMemoryIuLedger();
-      ledger.add(makeIu("ctx-a", "iu-1", "user_turn"));
-      expect(ledger.latest("ctx-a", "tts_segment")).toBeUndefined();
-      expect(ledger.latest("missing", "user_turn")).toBeUndefined();
-    });
-  });
-
-  describe("clear", () => {
-    it("removes only the requested context (happy path)", () => {
-      const ledger = new InMemoryIuLedger();
-      const a = makeIu("ctx-a", "iu-1", "user_turn");
-      const b = makeIu("ctx-b", "iu-1", "user_turn");
-      ledger.add(a);
-      ledger.add(b);
-      ledger.clear("ctx-a");
-      expect(ledger.get(a.id)).toBeUndefined();
-      expect(ledger.get(b.id)?.state).toBe("hypothesized");
-    });
-
-    it("is a no-op for an unknown context without affecting others (failure path)", () => {
-      const ledger = new InMemoryIuLedger();
-      const b = makeIu("ctx-b", "iu-1", "user_turn");
-      ledger.add(b);
-      ledger.clear("ctx-missing");
-      expect(ledger.get(b.id)?.state).toBe("hypothesized");
-    });
-  });
-
-  describe("monotonic state machine", () => {
-    it("follows hypothesized → committed and hypothesized → revoked only", () => {
-      const ledger = new InMemoryIuLedger();
-      const committed = makeIu("ctx-a", "iu-commit", "user_turn");
-      const revoked = makeIu("ctx-a", "iu-revoke", "user_turn");
-      ledger.add(committed);
-      ledger.add(revoked);
-      ledger.commit(committed.id);
-      ledger.revoke(revoked.id);
-      expect(ledger.get(committed.id)?.state).toBe("committed");
-      expect(ledger.get(revoked.id)?.state).toBe("revoked");
-    });
-  });
-
-  describe("maxContexts bound", () => {
-    it("evicts the oldest context when a new context exceeds the cap (FIFO)", () => {
-      const ledger = new InMemoryIuLedger(() => {}, 3);
-      const a = makeIu("a", "iu-1", "user_turn");
-      const b = makeIu("b", "iu-1", "user_turn");
-      const c = makeIu("c", "iu-1", "user_turn");
-      const d = makeIu("d", "iu-1", "user_turn");
-      ledger.add(a);
-      ledger.add(b);
-      ledger.add(c);
-      ledger.add(d);
-      expect(ledger.get(a.id)).toBeUndefined();
-      expect(ledger.get(b.id)?.state).toBe("hypothesized");
-      expect(ledger.get(c.id)?.state).toBe("hypothesized");
-      expect(ledger.get(d.id)?.state).toBe("hypothesized");
-    });
-
-    it("does not evict when adding another IU to an existing context", () => {
-      const ledger = new InMemoryIuLedger(() => {}, 3);
-      const a1 = makeIu("a", "iu-1", "user_turn");
-      const a2 = makeIu("a", "iu-2", "assistant_response");
-      const b = makeIu("b", "iu-1", "user_turn");
-      const c = makeIu("c", "iu-1", "user_turn");
-      ledger.add(a1);
-      ledger.add(b);
-      ledger.add(c);
-      ledger.add(a2);
-      expect(ledger.get(a1.id)?.state).toBe("hypothesized");
-      expect(ledger.get(a2.id)?.state).toBe("hypothesized");
-      expect(ledger.get(b.id)?.state).toBe("hypothesized");
-      expect(ledger.get(c.id)?.state).toBe("hypothesized");
-    });
-  });
-
-  describe("O(1) per-op (structural)", () => {
-    it("commit/get touch only the target ctx bucket regardless of total ctx count", () => {
-      // Map.get/set/delete are O(1); each hot-path op does at most one outer + one inner lookup.
-      const ledgerSmall = new InMemoryIuLedger();
-      const ledgerLarge = new InMemoryIuLedger();
-      const targetSmall = seedContexts(ledgerSmall, 10);
-      const targetLarge = seedContexts(ledgerLarge, 1000);
-
-      ledgerSmall.commit(targetSmall);
-      ledgerLarge.commit(targetLarge);
-
-      expect(ledgerSmall.get(targetSmall)?.state).toBe("committed");
-      expect(ledgerLarge.get(targetLarge)?.state).toBe("committed");
-
-      const timeOp = (ledger: InMemoryIuLedger, id: IncrementalUnitId) => {
-        const start = performance.now();
-        for (let i = 0; i < 5000; i++) {
-          ledger.get(id);
-        }
-        return performance.now() - start;
-      };
-
-      const tSmall = timeOp(ledgerSmall, targetSmall);
-      const tLarge = timeOp(ledgerLarge, targetLarge);
-      expect(tLarge).toBeLessThan(Math.max(tSmall * 20, 1));
-    });
-  });
-});