@creativeintelligence/abbie 0.1.3 → 0.1.5

package/src/cli/commands/__tests__/annotations.test.ts

@@ -1,704 +0,0 @@
-import { existsSync, mkdirSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import {
-  type AfsAnnotation,
-  AnnotationStore,
-  type EventEnvelope,
-} from "../../../lib/annotations.js";
-
-const TEST_DIR = join(tmpdir(), `abbie-annotations-test-${process.pid}`);
-const PREVIEW_ID = "preview-test-001";
-
-describe("AnnotationStore – AFS interoperability", () => {
-  let store: AnnotationStore;
-
-  beforeEach(() => {
-    if (existsSync(TEST_DIR)) {
-      rmSync(TEST_DIR, { recursive: true });
-    }
-    mkdirSync(TEST_DIR, { recursive: true });
-    store = new AnnotationStore(TEST_DIR);
-  });
-
-  afterEach(() => {
-    if (existsSync(TEST_DIR)) {
-      rmSync(TEST_DIR, { recursive: true });
-    }
-  });
-
-  // ==========================================================================
-  // AFS → internal → AFS roundtrip (lossless for core/recommended fields)
-  // ==========================================================================
-
-  describe("AFS roundtrip", () => {
-    it("roundtrips core fields losslessly", () => {
-      const original: AfsAnnotation = {
-        id: "ann_roundtrip_1",
-        comment: "Button clipped on mobile",
-        elementPath: "body > main > .hero > button.cta",
-        timestamp: 1_705_694_400_000,
-        x: 45.5,
-        y: 480,
-        element: "button",
-        url: "http://localhost:3000/landing",
-        intent: "fix",
-        severity: "blocking",
-        status: "pending",
-        boundingBox: { x: 40, y: 470, width: 120, height: 44 },
-        reactComponents: "HeroButton",
-        cssClasses: "cta primary",
-        computedStyles: "font-size:16px",
-        accessibility: "role=button",
-        nearbyText: "Get started",
-        selectedText: "Start",
-        thread: [
-          { id: "thr_1", role: "human", content: "Make it 48px", timestamp: 1_705_694_401_000 },
-          { id: "thr_2", role: "agent", content: "Fixed to 48px", timestamp: 1_705_694_402_000 },
-        ],
-      };
-
-      store.createFromAfs({ previewId: PREVIEW_ID, annotation: original });
-      const exported = store.exportAfs(PREVIEW_ID, original.id);
-      expect(exported).not.toBeNull();
-
-      // Core fields
-      expect(exported!.id).toBe(original.id);
-      expect(exported!.comment).toBe(original.comment);
-      expect(exported!.elementPath).toBe(original.elementPath);
-      expect(exported!.timestamp).toBe(original.timestamp);
-      expect(exported!.x).toBe(original.x);
-      expect(exported!.y).toBe(original.y);
-      expect(exported!.element).toBe(original.element);
-      expect(exported!.url).toBe(original.url);
-      expect(exported!.status).toBe(original.status);
-
-      // Intent/severity roundtrip through mapping
-      expect(exported!.intent).toBe("fix"); // bug → fix
-      expect(exported!.severity).toBe("blocking"); // critical → blocking
-
-      // Recommended fields preserved via metadata.afs
-      expect(exported!.boundingBox).toEqual(original.boundingBox);
-      expect(exported!.reactComponents).toBe(original.reactComponents);
-      expect(exported!.cssClasses).toBe(original.cssClasses);
-      expect(exported!.computedStyles).toBe(original.computedStyles);
-      expect(exported!.accessibility).toBe(original.accessibility);
-      expect(exported!.nearbyText).toBe(original.nearbyText);
-      expect(exported!.selectedText).toBe(original.selectedText);
-
-      // Thread roundtrip
-      expect(exported!.thread).toHaveLength(2);
-      expect(exported!.thread![0].id).toBe("thr_1");
-      expect(exported!.thread![0].role).toBe("human");
-      expect(exported!.thread![0].content).toBe("Make it 48px");
-      expect(exported!.thread![1].role).toBe("agent");
-    });
-
-    it("roundtrips batch import then export", () => {
-      const batch: AfsAnnotation[] = [
-        {
-          id: "ann_batch_1",
-          comment: "First",
-          elementPath: "body",
-          timestamp: 1000,
-          x: 10,
-          y: 20,
-          element: "div",
-          intent: "change",
-          severity: "suggestion",
-        },
-        {
-          id: "ann_batch_2",
-          comment: "Second",
-          elementPath: "body > main",
-          timestamp: 2000,
-          x: 30,
-          y: 40,
-          element: "main",
-          intent: "question",
-          severity: "important",
-        },
-      ];
-
-      const imported = store.importAfsBatch({ previewId: PREVIEW_ID, annotations: batch });
-      expect(imported).toHaveLength(2);
-      expect(imported[0].id).toBe("ann_batch_1");
-      expect(imported[1].id).toBe("ann_batch_2");
-
-      const exported = store.exportAfsBatch(PREVIEW_ID);
-      expect(exported).toHaveLength(2);
-      expect(exported[0].id).toBe("ann_batch_1");
-      expect(exported[0].comment).toBe("First");
-      expect(exported[1].id).toBe("ann_batch_2");
-      expect(exported[1].comment).toBe("Second");
-    });
-
-    it("preserves status across roundtrip", () => {
-      const afs: AfsAnnotation = {
-        id: "ann_status",
-        comment: "Status test",
-        elementPath: "body",
-        timestamp: 1000,
-        x: 0,
-        y: 0,
-        element: "div",
-        status: "acknowledged",
-      };
-
-      store.createFromAfs({ previewId: PREVIEW_ID, annotation: afs });
-      const exported = store.exportAfs(PREVIEW_ID, "ann_status");
-      expect(exported!.status).toBe("acknowledged");
-    });
-  });
-
-  // ==========================================================================
-  // Event ordering / replay
-  // ==========================================================================
-
-  describe("event ordering and replay", () => {
-    it("records events in monotonically increasing sequence", () => {
-      const a = store.create({ previewId: PREVIEW_ID, body: "Test annotation" });
-      store.acknowledge(PREVIEW_ID, a.id);
-      store.reply(PREVIEW_ID, a.id, "claude", "Looking into it");
-      store.resolve(PREVIEW_ID, a.id);
-
-      const events = store.events(PREVIEW_ID);
-      expect(events).toHaveLength(4);
-
-      // Sequence must be strictly increasing
-      for (let i = 1; i < events.length; i++) {
-        expect(events[i].seq).toBeGreaterThan(events[i - 1].seq);
-      }
-
-      // Types in expected order
-      expect(events.map((e) => e.type)).toEqual([
-        "annotation.created",
-        "status.changed",
-        "thread.message",
-        "status.changed",
-      ]);
-    });
-
-    it("records delete events", () => {
-      const a = store.create({ previewId: PREVIEW_ID, body: "To be deleted" });
-      const deleted = store.delete(PREVIEW_ID, a.id);
-
-      expect(deleted).not.toBeNull();
-      expect(deleted!.id).toBe(a.id);
-
-      const events = store.events(PREVIEW_ID);
-      expect(events).toHaveLength(2);
-      expect(events[1].type).toBe("annotation.deleted");
-      expect(events[1].data.body).toBe("To be deleted");
-    });
-
-    it("replays AFS import events with correct types", () => {
-      const afs: AfsAnnotation = {
-        id: "ann_import_evt",
-        comment: "Imported annotation",
-        elementPath: "body",
-        timestamp: 1000,
-        x: 0,
-        y: 0,
-        element: "div",
-      };
-
-      store.createFromAfs({ previewId: PREVIEW_ID, annotation: afs });
-
-      // Update via upsert
-      store.createFromAfs({
-        previewId: PREVIEW_ID,
-        annotation: { ...afs, comment: "Updated annotation", status: "acknowledged" },
-      });
-
-      const events = store.events(PREVIEW_ID);
-      expect(events).toHaveLength(2);
-      expect(events[0].type).toBe("annotation.created");
-      expect(events[0].data.source).toBe("afs");
-      expect(events[1].type).toBe("annotation.updated");
-      expect(events[1].data.source).toBe("afs");
-    });
-
-    it("maintains correct event seq across multiple annotations", () => {
-      store.create({ previewId: PREVIEW_ID, body: "First" });
-      store.create({ previewId: PREVIEW_ID, body: "Second" });
-      store.create({ previewId: PREVIEW_ID, body: "Third" });
-
-      const events = store.events(PREVIEW_ID);
-      expect(events).toHaveLength(3);
-      expect(events.map((e) => e.seq)).toEqual([1, 2, 3]);
-    });
-  });
-
-  // ==========================================================================
-  // Event envelopes
-  // ==========================================================================
-
-  describe("event envelopes", () => {
-    it("wraps events with preview context", () => {
-      store.create({ previewId: PREVIEW_ID, body: "Test" });
-
-      const envelopes = store.exportEvents(PREVIEW_ID);
-      expect(envelopes).toHaveLength(1);
-      expect(envelopes[0].version).toBe("1.0");
-      expect(envelopes[0].previewId).toBe(PREVIEW_ID);
-      expect(envelopes[0].event.type).toBe("annotation.created");
-    });
-
-    it("includes linkedSessionId in envelope", () => {
-      const a = store.create({ previewId: PREVIEW_ID, body: "Linked" });
-      store.linkSession(PREVIEW_ID, a.id, "sess_abc");
-
-      const envelopes = store.exportEvents(PREVIEW_ID);
-      expect(envelopes[0].sessionId).toBe("sess_abc");
-    });
-
-    it("allows sessionId override", () => {
-      store.create({ previewId: PREVIEW_ID, body: "Override" });
-
-      const envelopes = store.exportEvents(PREVIEW_ID, {
-        sessionId: "sess_override",
-      });
-      expect(envelopes[0].sessionId).toBe("sess_override");
-    });
-
-    it("produces valid EventEnvelope shape", () => {
-      const a = store.create({ previewId: PREVIEW_ID, body: "Shape test" });
-      store.acknowledge(PREVIEW_ID, a.id);
-
-      const envelopes: EventEnvelope[] = store.exportEvents(PREVIEW_ID);
-
-      for (const env of envelopes) {
-        expect(env).toHaveProperty("version", "1.0");
-        expect(env).toHaveProperty("previewId", PREVIEW_ID);
-        expect(env.event).toHaveProperty("type");
-        expect(env.event).toHaveProperty("annotationId");
-        expect(env.event).toHaveProperty("seq");
-        expect(env.event).toHaveProperty("timestamp");
-        expect(env.event).toHaveProperty("data");
-      }
-    });
-  });
-
-  // ==========================================================================
-  // Preview linkage integration
-  // ==========================================================================
-
-  describe("preview linkage", () => {
-    it("annotations are scoped to preview IDs", () => {
-      store.create({ previewId: "preview-A", body: "In A" });
-      store.create({ previewId: "preview-B", body: "In B" });
-
-      expect(store.list("preview-A")).toHaveLength(1);
-      expect(store.list("preview-B")).toHaveLength(1);
-      expect(store.list("preview-A")[0].body).toBe("In A");
-      expect(store.list("preview-B")[0].body).toBe("In B");
-    });
-
-    it("events are scoped to preview IDs", () => {
-      store.create({ previewId: "preview-A", body: "Event in A" });
-      store.create({ previewId: "preview-B", body: "Event in B" });
-
-      expect(store.events("preview-A")).toHaveLength(1);
-      expect(store.events("preview-B")).toHaveLength(1);
-    });
-
-    it("links annotations to sessions and includes in AFS export", () => {
-      const a = store.create({
-        previewId: PREVIEW_ID,
-        body: "Needs agent fix",
-        intent: "blocker",
-      });
-      store.linkSession(PREVIEW_ID, a.id, "abbie-20260220-fix-xyz");
-
-      const linked = store.get(PREVIEW_ID, a.id);
-      expect(linked!.linkedSessionId).toBe("abbie-20260220-fix-xyz");
-
-      // Session linkage appears in event envelopes
-      const envelopes = store.exportEvents(PREVIEW_ID);
-      expect(envelopes[0].sessionId).toBe("abbie-20260220-fix-xyz");
-    });
-
-    it("supports full lifecycle: import → transition → thread → export", () => {
-      const afs: AfsAnnotation = {
-        id: "ann_lifecycle",
-        comment: "Button broken on mobile",
-        elementPath: "body > .hero > button",
-        timestamp: 1_705_694_400_000,
-        x: 50,
-        y: 300,
-        element: "button",
-        url: "/landing",
-        intent: "fix",
-        severity: "blocking",
-      };
-
-      // Import
-      store.createFromAfs({ previewId: PREVIEW_ID, annotation: afs });
-
-      // Link to session
-      store.linkSession(PREVIEW_ID, afs.id, "sess_fix_123");
-
-      // Acknowledge
-      store.acknowledge(PREVIEW_ID, afs.id);
-
-      // Thread conversation
-      store.reply(PREVIEW_ID, afs.id, "agent", "Fixing button height");
-      store.reply(PREVIEW_ID, afs.id, "human", "Looks good now");
-
-      // Resolve
-      store.resolve(PREVIEW_ID, afs.id);
-
-      // Verify final state
-      const final = store.get(PREVIEW_ID, afs.id);
-      expect(final!.status).toBe("resolved");
-      expect(final!.linkedSessionId).toBe("sess_fix_123");
-      expect(final!.thread).toHaveLength(2);
-
-      // Verify events capture full lifecycle
-      const events = store.events(PREVIEW_ID);
-      expect(events.map((e) => e.type)).toEqual([
-        "annotation.created",
-        "status.changed", // → acknowledged
-        "thread.message", // agent reply
-        "thread.message", // human reply
-        "status.changed", // → resolved
-      ]);
-
-      // Export back to AFS
-      const exported = store.exportAfs(PREVIEW_ID, afs.id);
-      expect(exported!.comment).toBe(afs.comment);
-      expect(exported!.status).toBe("resolved");
-      expect(exported!.thread).toHaveLength(2);
-
-      // Event envelopes include session
-      const envelopes = store.exportEvents(PREVIEW_ID);
-      expect(envelopes.every((e) => e.previewId === PREVIEW_ID)).toBe(true);
-      expect(envelopes.every((e) => e.sessionId === "sess_fix_123")).toBe(true);
-    });
-  });
-
-  // ==========================================================================
-  // Status transitions
-  // ==========================================================================
-
-  describe("status transitions", () => {
-    it("pending → acknowledged → resolved", () => {
-      const a = store.create({ previewId: PREVIEW_ID, body: "Test" });
-      expect(a.status).toBe("pending");
-
-      const acked = store.acknowledge(PREVIEW_ID, a.id);
-      expect(acked!.status).toBe("acknowledged");
-
-      const resolved = store.resolve(PREVIEW_ID, a.id);
-      expect(resolved!.status).toBe("resolved");
-    });
-
-    it("pending → acknowledged → dismissed", () => {
-      const a = store.create({ previewId: PREVIEW_ID, body: "Test" });
-      store.acknowledge(PREVIEW_ID, a.id);
-
-      const dismissed = store.dismiss(PREVIEW_ID, a.id);
-      expect(dismissed!.status).toBe("dismissed");
-    });
-
-    it("preserves thread continuity across transitions", () => {
-      const a = store.create({ previewId: PREVIEW_ID, body: "Thread test" });
-      store.reply(PREVIEW_ID, a.id, "human", "Before ack");
-      store.acknowledge(PREVIEW_ID, a.id);
-      store.reply(PREVIEW_ID, a.id, "agent", "After ack");
-      store.resolve(PREVIEW_ID, a.id);
-
-      const final = store.get(PREVIEW_ID, a.id);
-      expect(final!.thread).toHaveLength(2);
-      expect(final!.thread[0].body).toBe("Before ack");
-      expect(final!.thread[1].body).toBe("After ack");
-      expect(final!.status).toBe("resolved");
-    });
-  });
-
-  // ==========================================================================
-  // AFS event ingestion pipeline
-  // ==========================================================================
-
-  describe("AFS event ingestion", () => {
-    it("ingests annotation.created events", () => {
-      const events = [
-        {
-          type: "annotation.created" as const,
-          annotationId: "ann_ingest_1",
-          timestamp: 1000,
-          data: {
-            annotation: {
-              id: "ann_ingest_1",
-              comment: "Button broken",
-              elementPath: "body > button",
-              timestamp: 1000,
-              x: 10,
-              y: 20,
-              element: "button",
-              intent: "fix" as const,
-              severity: "blocking" as const,
-            },
-          },
-        },
-      ];
-
-      const result = store.ingestAfsEvents({ previewId: PREVIEW_ID, events });
-      expect(result.ingested).toBe(1);
-      expect(result.annotations).toHaveLength(1);
-      expect(result.annotations[0].id).toBe("ann_ingest_1");
-      expect(result.annotations[0].severity).toBe("critical");
-      expect(result.annotations[0].intent).toBe("bug");
-    });
-
-    it("ingests annotation.updated events as upserts", () => {
-      const events = [
-        {
-          type: "annotation.created" as const,
-          annotationId: "ann_up_1",
-          timestamp: 1000,
-          data: {
-            annotation: {
-              id: "ann_up_1",
-              comment: "Initial",
-              elementPath: "body",
-              timestamp: 1000,
-              x: 0,
-              y: 0,
-              element: "div",
-            },
-          },
-        },
-        {
-          type: "annotation.updated" as const,
-          annotationId: "ann_up_1",
-          timestamp: 2000,
-          data: {
-            annotation: {
-              id: "ann_up_1",
-              comment: "Updated text",
-              elementPath: "body > main",
-              timestamp: 2000,
-              x: 5,
-              y: 10,
-              element: "main",
-              status: "acknowledged" as const,
-            },
-          },
-        },
-      ];
-
-      const result = store.ingestAfsEvents({ previewId: PREVIEW_ID, events });
-      expect(result.ingested).toBe(2);
-      expect(result.annotations).toHaveLength(1);
-      expect(result.annotations[0].body).toBe("Updated text");
-      expect(result.annotations[0].status).toBe("acknowledged");
-    });
-
-    it("ingests annotation.resolved events", () => {
-      // Create first
-      store.create({ previewId: PREVIEW_ID, body: "To resolve" });
-      const annotations = store.list(PREVIEW_ID);
-      const id = annotations[0].id;
-
-      const events = [
-        {
-          type: "annotation.resolved" as const,
-          annotationId: id,
-          timestamp: 3000,
-          data: { resolvedBy: "agent" as const },
-        },
-      ];
-
-      const result = store.ingestAfsEvents({ previewId: PREVIEW_ID, events });
-      expect(result.ingested).toBe(1);
-      const resolved = store.get(PREVIEW_ID, id);
-      expect(resolved!.status).toBe("resolved");
-      expect((resolved!.metadata?.afs as Record<string, unknown>)?.resolvedBy).toBe("agent");
-    });
-
-    it("ingests annotation.deleted events", () => {
-      const a = store.create({ previewId: PREVIEW_ID, body: "To delete" });
-      const events = [
-        {
-          type: "annotation.deleted" as const,
-          annotationId: a.id,
-          timestamp: 4000,
-          data: {},
-        },
-      ];
-
-      const result = store.ingestAfsEvents({ previewId: PREVIEW_ID, events });
-      expect(result.ingested).toBe(1);
-      expect(store.list(PREVIEW_ID)).toHaveLength(0);
-    });
-
-    it("ingests thread.message events", () => {
-      const a = store.create({ previewId: PREVIEW_ID, body: "Thread target" });
-      const events = [
-        {
-          type: "thread.message" as const,
-          annotationId: a.id,
-          timestamp: 5000,
-          data: {
-            message: {
-              id: "msg_1",
-              role: "agent" as const,
-              content: "Working on it",
-              timestamp: 5000,
-            },
-          },
-        },
-      ];
-
-      const result = store.ingestAfsEvents({ previewId: PREVIEW_ID, events });
-      expect(result.ingested).toBe(1);
-      const updated = store.get(PREVIEW_ID, a.id);
-      expect(updated!.thread).toHaveLength(1);
-      expect(updated!.thread[0].body).toBe("Working on it");
-    });
-
-    it("processes mixed event stream in order", () => {
-      const events = [
-        {
-          type: "annotation.created" as const,
-          annotationId: "ann_mix_1",
-          timestamp: 1000,
-          data: {
-            annotation: {
-              id: "ann_mix_1",
-              comment: "Bug report",
-              elementPath: "body",
-              timestamp: 1000,
-              x: 0,
-              y: 0,
-              element: "div",
-              severity: "blocking" as const,
-            },
-          },
-        },
-        {
-          type: "thread.message" as const,
-          annotationId: "ann_mix_1",
-          timestamp: 2000,
-          data: {
-            message: {
-              id: "msg_1",
-              role: "agent" as const,
-              content: "Investigating",
-              timestamp: 2000,
-            },
-          },
-        },
-        {
-          type: "annotation.resolved" as const,
-          annotationId: "ann_mix_1",
-          timestamp: 3000,
-          data: { resolvedBy: "agent" as const },
-        },
-      ];
-
-      const result = store.ingestAfsEvents({ previewId: PREVIEW_ID, events });
-      expect(result.ingested).toBe(3);
-
-      const final = store.get(PREVIEW_ID, "ann_mix_1");
-      expect(final!.status).toBe("resolved");
-      expect(final!.thread).toHaveLength(1);
-
-      // Internal events should reflect the full lifecycle
-      const internalEvents = store.events(PREVIEW_ID);
-      expect(internalEvents.length).toBeGreaterThanOrEqual(3);
-    });
-
-    it("skips events with missing data gracefully", () => {
-      const events = [
-        {
-          type: "annotation.created" as const,
-          annotationId: "ann_skip",
-          timestamp: 1000,
-          data: {}, // Missing annotation
-        },
-        {
-          type: "thread.message" as const,
-          annotationId: "nonexistent",
-          timestamp: 2000,
-          data: {}, // Missing message
-        },
-      ];
-
-      const result = store.ingestAfsEvents({ previewId: PREVIEW_ID, events });
-      expect(result.ingested).toBe(0);
-      expect(result.annotations).toHaveLength(0);
-    });
-  });
-
-  // ==========================================================================
-  // Session routing
-  // ==========================================================================
-
-  describe("session routing", () => {
-    it("getActionable returns blocking/critical unresolved annotations", () => {
-      store.create({ previewId: PREVIEW_ID, body: "Info note", severity: "info" });
-      store.create({ previewId: PREVIEW_ID, body: "Critical bug", severity: "critical" });
-      store.create({ previewId: PREVIEW_ID, body: "Error issue", severity: "error" });
-      store.create({ previewId: PREVIEW_ID, body: "Blocker", intent: "blocker" });
-
-      const actionable = store.getActionable(PREVIEW_ID);
-      expect(actionable).toHaveLength(3);
-      expect(actionable.map((a) => a.body).sort()).toEqual(
-        ["Blocker", "Critical bug", "Error issue"].sort()
-      );
-    });
-
-    it("getActionable excludes resolved and dismissed", () => {
-      const a1 = store.create({ previewId: PREVIEW_ID, body: "Resolved", severity: "critical" });
-      store.create({ previewId: PREVIEW_ID, body: "Still open", severity: "critical" });
-      const a3 = store.create({ previewId: PREVIEW_ID, body: "Dismissed", severity: "error" });
-
-      store.resolve(PREVIEW_ID, a1.id);
-      store.dismiss(PREVIEW_ID, a3.id);
-
-      const actionable = store.getActionable(PREVIEW_ID);
-      expect(actionable).toHaveLength(1);
-      expect(actionable[0].body).toBe("Still open");
-    });
-
-    it("routeBlockingToSession links unlinked blocking annotations", () => {
-      store.create({ previewId: PREVIEW_ID, body: "Critical 1", severity: "critical" });
-      store.create({ previewId: PREVIEW_ID, body: "Critical 2", severity: "critical" });
-      store.create({ previewId: PREVIEW_ID, body: "Info (skip)", severity: "info" });
-
-      const routed = store.routeBlockingToSession(PREVIEW_ID, "sess_fix_001");
-      expect(routed).toHaveLength(2);
-      expect(routed.every((a) => a.linkedSessionId === "sess_fix_001")).toBe(true);
-    });
-
-    it("routeBlockingToSession skips already-linked annotations", () => {
-      const a1 = store.create({
-        previewId: PREVIEW_ID,
-        body: "Already linked",
-        severity: "critical",
-      });
-      store.linkSession(PREVIEW_ID, a1.id, "sess_existing");
-      store.create({ previewId: PREVIEW_ID, body: "Unlinked", severity: "critical" });
-
-      const routed = store.routeBlockingToSession(PREVIEW_ID, "sess_new");
-      expect(routed).toHaveLength(1);
-      expect(routed[0].body).toBe("Unlinked");
-
-      // Original link unchanged
-      const original = store.get(PREVIEW_ID, a1.id);
-      expect(original!.linkedSessionId).toBe("sess_existing");
-    });
-
-    it("routeBlockingToSession returns empty when no actionable annotations", () => {
-      store.create({ previewId: PREVIEW_ID, body: "Info", severity: "info" });
-      store.create({ previewId: PREVIEW_ID, body: "Warning", severity: "warning" });
-
-      const routed = store.routeBlockingToSession(PREVIEW_ID, "sess_empty");
-      expect(routed).toHaveLength(0);
-    });
-  });
-});