@polderlabs/bizar 6.2.5 → 6.3.0

package/plugins/bizar/tests/event-stream.test.ts

@@ -1,409 +0,0 @@
-/**
- * EventStream tests.
- *
- * Tests: connect/disconnect, one global subscription (not per-instance),
- * EventSessionIdle → done, EventSessionError → failed, EventMessagePartUpdated
- * for toolCallCount and threshold-12 loop guard capture (HIGH-5, HIGH-12,
- * MEDIUM-8, HIGH-17), SSE reconnect with backoff, dispose closes stream.
- *
- * Uses fake SSE event emission; no real network calls.
- */
-
-import { describe, it, expect } from "bun:test";
-
-// ---------------------------------------------------------------------------
-// Types mirroring the expected event shapes from §1.6 / §4
-// ---------------------------------------------------------------------------
-
-type BackgroundStatus = "pending" | "running" | "done" | "failed" | "killed" | "timed_out";
-
-interface BackgroundState {
-  instanceId: string;
-  sessionId: string;
-  status: BackgroundStatus;
-  toolCallCount: number;
-  loopGuardTool?: string;
-  error?: string;
-  completedAt?: number;
-}
-
-interface EventBase {
-  type: string;
-  sessionID?: string;
-}
-
-interface EventSessionIdle extends EventBase {
-  type: "session.idle";
-  sessionID: string;
-}
-
-interface EventSessionError extends EventBase {
-  type: "session.error";
-  sessionID: string;
-  error?: string;
-}
-
-interface EventMessagePartUpdated extends EventBase {
-  type: "message.part.updated";
-  sessionID: string;
-  part: {
-    type: "tool";
-    state?: {
-      status?: string;
-      error?: string;
-    };
-    toolName?: string;
-  };
-}
-
-type Event = EventSessionIdle | EventSessionError | EventMessagePartUpdated;
-
-// ---------------------------------------------------------------------------
-// Fake EventStream matching the expected interface
-// ---------------------------------------------------------------------------
-
-class FakeEventStream {
-  private handlers = new Map<string, Array<(event: Event) => void>>();
-  private sessions = new Map<string, string>(); // instanceId → sessionId
-  public instances = new Map<string, BackgroundState>();
-  private closed = false;
-
-  /** Register an instance's sessionId for event routing */
-  register(instanceId: string, sessionId: string) {
-    this.sessions.set(instanceId, sessionId);
-  }
-
-  /** Subscribe to events */
-  onSessionEvent(handler: (instanceId: string, event: Event) => void) {
-    const wrapper = (ev: Event) => {
-      if (this.closed) return;
-      // Route event to the correct instance based on sessionID
-      for (const [instanceId, sessionId] of this.sessions) {
-        if (sessionId === ev.sessionID) {
-          handler(instanceId, ev);
-        }
-      }
-    };
-    return wrapper;
-  }
-
-  /** Apply event to instance state */
-  applyEvent(instanceId: string, event: Event): void {
-    const inst = this.instances.get(instanceId);
-    if (!inst) return;
-
-    switch (event.type) {
-      case "session.idle":
-        inst.status = "done";
-        inst.completedAt = Date.now();
-        break;
-
-      case "session.error":
-        inst.status = "failed";
-        inst.error = event.error ?? "session error";
-        inst.completedAt = Date.now();
-        break;
-
-      case "message.part.updated": {
-        if (event.part.type !== "tool") break;
-        inst.toolCallCount = (inst.toolCallCount ?? 0) + 1;
-
-        // Threshold-12 loop guard capture (HIGH-17)
-        const partError = event.part.state?.error;
-        if (typeof partError === "string") {
-          const m = partError.match(/Loop protection: 12 identical calls to (\S+)/);
-          if (m) {
-            inst.loopGuardTool = m[1];
-            inst.error = `Loop protection: 12 identical calls to ${m[1]}`;
-            inst.status = "failed";
-            inst.completedAt = Date.now();
-          }
-        }
-        break;
-      }
-    }
-  }
-
-  /** Set instance state for testing */
-  setInstance(inst: BackgroundState) {
-    this.instances.set(inst.instanceId, { ...inst });
-  }
-
-  /** Close the stream */
-  close() {
-    this.closed = true;
-    this.sessions.clear();
-  }
-
-  get isClosed(): boolean {
-    return this.closed;
-  }
-}
-
-// ---------------------------------------------------------------------------
-// One global subscription, not per-instance (HIGH-5, HIGH-12)
-// ---------------------------------------------------------------------------
-
-describe("one global SSE subscription", () => {
-  it("opens exactly one EventSource for the plugin process (HIGH-5)", () => {
-    const stream = new FakeEventStream();
-    // The plugin opens ONE stream on init, not one per instance
-    // This is a structural test: the EventStream class has a single .connect()
-    expect(typeof stream.onSessionEvent).toBe("function");
-  });
-
-  it("events are filtered by sessionID to the correct instance", () => {
-    const stream = new FakeEventStream();
-    stream.register("bgr_1", "sess_1");
-    stream.register("bgr_2", "sess_2");
-
-    stream.setInstance({ instanceId: "bgr_1", sessionId: "sess_1", status: "running", toolCallCount: 0 });
-    stream.setInstance({ instanceId: "bgr_2", sessionId: "sess_2", status: "running", toolCallCount: 0 });
-
-    const handler = stream.onSessionEvent((instanceId, event) => {
-      stream.applyEvent(instanceId, event);
-    });
-
-    // Fire event for sess_1 only
-    const idleEvent: EventSessionIdle = { type: "session.idle", sessionID: "sess_1" };
-    handler(idleEvent);
-
-    expect(stream.instances.get("bgr_1")!.status).toBe("done");
-    expect(stream.instances.get("bgr_2")!.status).toBe("running"); // unaffected
-  });
-});
-
-// ---------------------------------------------------------------------------
-// EventSessionIdle → done (HIGH-5)
-// ---------------------------------------------------------------------------
-
-describe("EventSessionIdle → done", () => {
-  it("EventSessionIdle marks instance as done", () => {
-    const stream = new FakeEventStream();
-    stream.setInstance({ instanceId: "bgr_done", sessionId: "sess_done", status: "running", toolCallCount: 0 });
-    stream.register("bgr_done", "sess_done");
-
-    const handler = stream.onSessionEvent((instanceId, event) => stream.applyEvent(instanceId, event));
-    handler({ type: "session.idle", sessionID: "sess_done" });
-
-    expect(stream.instances.get("bgr_done")!.status).toBe("done");
-    expect(stream.instances.get("bgr_done")!.completedAt).toBeDefined();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// EventSessionError → failed (HIGH-5)
-// ---------------------------------------------------------------------------
-
-describe("EventSessionError → failed", () => {
-  it("EventSessionError marks instance as failed", () => {
-    const stream = new FakeEventStream();
-    stream.setInstance({ instanceId: "bgr_err", sessionId: "sess_err", status: "running", toolCallCount: 0 });
-    stream.register("bgr_err", "sess_err");
-
-    const handler = stream.onSessionEvent((instanceId, event) => stream.applyEvent(instanceId, event));
-    handler({ type: "session.error", sessionID: "sess_err", error: "something went wrong" });
-
-    expect(stream.instances.get("bgr_err")!.status).toBe("failed");
-    expect(stream.instances.get("bgr_err")!.error).toBe("something went wrong");
-  });
-
-  it("EventSessionError with no error defaults to 'session error'", () => {
-    const stream = new FakeEventStream();
-    stream.setInstance({ instanceId: "bgr_err2", sessionId: "sess_err2", status: "running", toolCallCount: 0 });
-    stream.register("bgr_err2", "sess_err2");
-
-    const handler = stream.onSessionEvent((instanceId, event) => stream.applyEvent(instanceId, event));
-    handler({ type: "session.error", sessionID: "sess_err2" });
-
-    expect(stream.instances.get("bgr_err2")!.status).toBe("failed");
-    expect(stream.instances.get("bgr_err2")!.error).toBe("session error");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// EventMessagePartUpdated: toolCallCount (HIGH-12)
-// ---------------------------------------------------------------------------
-
-describe("EventMessagePartUpdated — toolCallCount", () => {
-  it("increments toolCallCount for each tool part (HIGH-12)", () => {
-    const stream = new FakeEventStream();
-    stream.setInstance({ instanceId: "bgr_tool", sessionId: "sess_tool", status: "running", toolCallCount: 0 });
-    stream.register("bgr_tool", "sess_tool");
-
-    const handler = stream.onSessionEvent((instanceId, event) => stream.applyEvent(instanceId, event));
-
-    handler({
-      type: "message.part.updated",
-      sessionID: "sess_tool",
-      part: { type: "tool", state: { status: "ok" } },
-    });
-    handler({
-      type: "message.part.updated",
-      sessionID: "sess_tool",
-      part: { type: "tool", state: { status: "ok" } },
-    });
-
-    expect(stream.instances.get("bgr_tool")!.toolCallCount).toBe(2);
-  });
-
-  it("non-tool parts do not increment toolCallCount", () => {
-    const stream = new FakeEventStream();
-    stream.setInstance({ instanceId: "bgr_text", sessionId: "sess_text", status: "running", toolCallCount: 0 });
-    stream.register("bgr_text", "sess_text");
-
-    const handler = stream.onSessionEvent((instanceId, event) => stream.applyEvent(instanceId, event));
-    handler({
-      type: "message.part.updated",
-      sessionID: "sess_text",
-      part: { type: "text", text: "hello" } as unknown as EventMessagePartUpdated["part"],
-    });
-
-    expect(stream.instances.get("bgr_text")!.toolCallCount).toBe(0);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Threshold-12 loop guard capture (HIGH-17)
-// ---------------------------------------------------------------------------
-
-describe("threshold-12 loop guard capture (HIGH-17)", () => {
-  it("captures loopGuardTool and error on threshold-12 throw", () => {
-    const stream = new FakeEventStream();
-    stream.setInstance({ instanceId: "bgr_loop", sessionId: "sess_loop", status: "running", toolCallCount: 0 });
-    stream.register("bgr_loop", "sess_loop");
-
-    const handler = stream.onSessionEvent((instanceId, event) => stream.applyEvent(instanceId, event));
-    handler({
-      type: "message.part.updated",
-      sessionID: "sess_loop",
-      part: {
-        type: "tool",
-        state: {
-          status: "error",
-          error: "Loop protection: 12 identical calls to read",
-        },
-      },
-    });
-
-    const inst = stream.instances.get("bgr_loop")!;
-    expect(inst.loopGuardTool).toBe("read");
-    expect(inst.error).toBe("Loop protection: 12 identical calls to read");
-    expect(inst.status).toBe("failed");
-  });
-
-  it("loopGuardTool is captured once even if multiple threshold-12 events arrive", () => {
-    const stream = new FakeEventStream();
-    stream.setInstance({ instanceId: "bgr_loop2", sessionId: "sess_loop2", status: "running", toolCallCount: 0 });
-    stream.register("bgr_loop2", "sess_loop2");
-
-    const handler = stream.onSessionEvent((instanceId, event) => stream.applyEvent(instanceId, event));
-    handler({
-      type: "message.part.updated",
-      sessionID: "sess_loop2",
-      part: {
-        type: "tool",
-        state: { status: "error", error: "Loop protection: 12 identical calls to read" },
-      },
-    });
-
-    // Second event — should not overwrite
-    handler({
-      type: "message.part.updated",
-      sessionID: "sess_loop2",
-      part: {
-        type: "tool",
-        state: { status: "error", error: "Loop protection: 12 identical calls to read" },
-      },
-    });
-
-    expect(stream.instances.get("bgr_loop2")!.loopGuardTool).toBe("read");
-    expect(stream.instances.get("bgr_loop2")!.toolCallCount).toBe(2); // count still increments
-  });
-
-  it("threshold-5/8 do NOT set loopGuardTool (only threshold-12 triggers it)", () => {
-    const stream = new FakeEventStream();
-    stream.setInstance({ instanceId: "bgr_warn", sessionId: "sess_warn", status: "running", toolCallCount: 0 });
-    stream.register("bgr_warn", "sess_warn");
-
-    const handler = stream.onSessionEvent((instanceId, event) => stream.applyEvent(instanceId, event));
-    handler({
-      type: "message.part.updated",
-      sessionID: "sess_warn",
-      part: {
-        type: "tool",
-        state: { status: "warn" }, // threshold 5 or 8 doesn't have the same error string
-      },
-    });
-
-    expect(stream.instances.get("bgr_warn")!.loopGuardTool).toBeUndefined();
-    expect(stream.instances.get("bgr_warn")!.status).toBe("running");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// SSE reconnect with backoff
-// ---------------------------------------------------------------------------
-
-describe("SSE reconnect with backoff", () => {
-  it("reconnects with exponential backoff: 1s, 2s, 4s, max 30s", () => {
-    const delays: number[] = [];
-    let attempt = 0;
-    const maxDelay = 30_000;
-
-    while (attempt < 5) {
-      const delay = Math.min(1000 * Math.pow(2, attempt), maxDelay);
-      delays.push(delay);
-      attempt++;
-    }
-
-    expect(delays).toEqual([1000, 2000, 4000, 8000, 16000]);
-  });
-
-  it("max backoff is 30 seconds", () => {
-    const maxDelay = 30_000;
-    const delay = Math.min(1000 * Math.pow(2, 10), maxDelay);
-    expect(delay).toBe(30_000);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// dispose closes the SSE stream
-// ---------------------------------------------------------------------------
-
-describe("dispose closes SSE stream", () => {
-  it("close() marks stream as closed and clears sessions", () => {
-    const stream = new FakeEventStream();
-    stream.register("bgr_1", "sess_1");
-    stream.register("bgr_2", "sess_2");
-
-    expect(stream.isClosed).toBe(false);
-    stream.close();
-    expect(stream.isClosed).toBe(true);
-  });
-
-  it("events after close are ignored", () => {
-    const stream = new FakeEventStream();
-    stream.setInstance({ instanceId: "bgr_close", sessionId: "sess_close", status: "running", toolCallCount: 0 });
-    stream.register("bgr_close", "sess_close");
-    stream.close();
-
-    const handler = stream.onSessionEvent((instanceId, event) => stream.applyEvent(instanceId, event));
-    handler({ type: "session.idle", sessionID: "sess_close" });
-
-    // Status should still be running because event was ignored after close
-    expect(stream.instances.get("bgr_close")!.status).toBe("running");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// EventStream interface contract
-// ---------------------------------------------------------------------------
-
-describe("EventStream interface contract", () => {
-  it("has connect, disconnect, onSessionEvent methods", () => {
-    const stream = new FakeEventStream();
-    expect(typeof stream.onSessionEvent).toBe("function");
-    expect(typeof stream.close).toBe("function");
-  });
-});

package/plugins/bizar/tests/event.test.ts

@@ -1,262 +0,0 @@
-/**
- * event.test.ts
- *
- * Tests for the canonical session lifecycle per §4.5.1 (v0.3.1 N4 fix).
- *
- * Verifies:
- * 1. session.created does NOT create the state file — only updates in-memory seen-message set
- * 2. Duplicate session.created events are a no-op (no extra file, no error)
- * 3. First chat.message per session creates the state file with §4.7 schema
- * 4. First tool.execute.before (subagent-only lazy fallback) creates the state file with
- *    parentAgent: null when chat.message has not yet fired
- *
- * Per MEDIUM finding 28 / v0.3.1 §12.1.
- */
-
-import { describe, test, expect, beforeEach, afterEach } from "bun:test";
-import { mkdirSync, rmSync, existsSync, readFileSync } from "node:fs";
-import path from "node:path";
-import os from "node:os";
-
-// ── Minimal interfaces that mirror what index.ts will define ────────────────
-
-/** In-memory seen-message set maintained by the plugin per session */
-const seenMessageIds = new Map<string, Set<string>>();
-
-/** Tracks whether the state file has been created for a session */
-const stateFileCreated = new Map<string, boolean>();
-
-/**
- * Minimal mock of the plugin's session state — simulates the event hook
- * behavior described in §4.5.1 without requiring the full index.ts.
- */
-class MockPlugin {
-  private stateDir: string;
-  private seenMessages: Map<string, Set<string>>;
-
-  constructor(stateDir: string) {
-    this.stateDir = stateDir;
-    this.seenMessages = seenMessageIds;
-  }
-
-  /** session.created — does NOT create state file; only updates in-memory set */
-  onSessionCreated(sessionId: string): void {
-    if (!this.seenMessages.has(sessionId)) {
-      this.seenMessages.set(sessionId, new Set());
-    }
-    // Does NOT call createStateFile
-  }
-
-  /** chat.message — first message per session creates state file with §4.7 schema */
-  onChatMessage(sessionId: string, messageId: string, sender: string): void {
-    if (!this.seenMessages.has(sessionId)) {
-      this.seenMessages.set(sessionId, new Set());
-    }
-    const seen = this.seenMessages.get(sessionId)!;
-    if (seen.has(messageId)) return; // duplicate — no-op
-    seen.add(messageId);
-
-    // First message for this session → create state file
-    if (seen.size === 1) {
-      this.createStateFile(sessionId, sender);
-    }
-  }
-
-  /**
-   * tool.execute.before — subagent-only lazy fallback.
-   * Creates state file with parentAgent: null if chat.message has not fired yet.
-   */
-  onToolExecuteBefore(sessionId: string): void {
-    const seen = this.seenMessages.get(sessionId);
-    if (!seen || seen.size === 0) {
-      // chat.message hasn't fired → lazy fallback with parentAgent: null
-      this.createStateFile(sessionId, null);
-    }
-  }
-
-  /** session.deleted — removes state file */
-  onSessionDeleted(sessionId: string): void {
-    this.seenMessages.delete(sessionId);
-    const filePath = path.join(this.stateDir, `${sessionId}.json`);
-    try {
-      const { unlinkSync } = require("node:fs");
-      unlinkSync(filePath);
-    } catch {
-      // non-fatal if already gone
-    }
-  }
-
-  /** Unknown event type — no-op */
-  onUnknownEvent(): void {
-    // no state file created, no error
-  }
-
-  private createStateFile(sessionId: string, parentAgent: string | null): void {
-    const filePath = path.join(this.stateDir, `${sessionId}.json`);
-    const state = {
-      sessionId,
-      parentAgent,
-      startedAt: parentAgent !== null ? Date.now() : 0,
-      lastActivityAt: parentAgent !== null ? Date.now() : 0,
-      turnCount: 0,
-      toolCalls: [],
-      warningsIssued: 0,
-      blocksTriggered: 0,
-    };
-    const { writeFileSync } = require("node:fs");
-    writeFileSync(filePath, JSON.stringify(state), "utf8");
-    stateFileCreated.set(sessionId, true);
-  }
-
-  getSeenMessages(sessionId: string): Set<string> {
-    return this.seenMessages.get(sessionId) ?? new Set();
-  }
-
-  stateFileExists(sessionId: string): boolean {
-    return existsSync(path.join(this.stateDir, `${sessionId}.json`));
-  }
-
-  readStateFile(sessionId: string): ReturnType<typeof readFileSync> | null {
-    const filePath = path.join(this.stateDir, `${sessionId}.json`);
-    if (!existsSync(filePath)) return null;
-    return readFileSync(filePath, "utf8");
-  }
-}
-
-// ── Test setup ───────────────────────────────────────────────────────────────
-
-const TEST_DIR = path.join(os.tmpdir(), "bizar-event-test");
-const TEST_SESSION = "session-evt-001";
-const TEST_SESSION_2 = "session-evt-002";
-
-describe("event.test.ts — canonical session lifecycle", () => {
-  let plugin: MockPlugin;
-
-  beforeEach(() => {
-    try { rmSync(TEST_DIR, { recursive: true, force: true }); } catch { /* ok */ }
-    mkdirSync(TEST_DIR, { recursive: true });
-    plugin = new MockPlugin(TEST_DIR);
-    seenMessageIds.clear();
-    stateFileCreated.clear();
-  });
-
-  afterEach(() => {
-    try { rmSync(TEST_DIR, { recursive: true, force: true }); } catch { /* ok */ }
-  });
-
-  // ── §4.5.1 / v0.3.1 N4 fix ────────────────────────────────────────────────
-
-  test("session.created does NOT create the state file", () => {
-    plugin.onSessionCreated(TEST_SESSION);
-    expect(plugin.stateFileExists(TEST_SESSION)).toBe(false);
-  });
-
-  test("session.created only updates the in-memory seen-message set", () => {
-    plugin.onSessionCreated(TEST_SESSION);
-    expect(plugin.getSeenMessages(TEST_SESSION).size).toBe(0); // empty set created
-    expect(plugin.stateFileExists(TEST_SESSION)).toBe(false);
-  });
-
-  test("duplicate session.created events are a no-op — no extra file, no error", () => {
-    plugin.onSessionCreated(TEST_SESSION);
-    plugin.onSessionCreated(TEST_SESSION);
-    plugin.onSessionCreated(TEST_SESSION);
-    expect(plugin.stateFileExists(TEST_SESSION)).toBe(false);
-    // Should not throw
-  });
-
-  test("first chat.message per session creates the state file with §4.7 schema", () => {
-    plugin.onChatMessage(TEST_SESSION, "msg-001", "odin");
-
-    expect(plugin.stateFileExists(TEST_SESSION)).toBe(true);
-
-    const raw = plugin.readStateFile(TEST_SESSION);
-    expect(raw).not.toBeNull();
-    const state = JSON.parse(raw!.toString());
-
-    expect(state.sessionId).toBe(TEST_SESSION);
-    expect(state.parentAgent).toBe("odin");
-    expect(state.startedAt).toBeGreaterThan(0);
-    expect(state.lastActivityAt).toBeGreaterThan(0);
-    expect(state.turnCount).toBe(0);
-    expect(state.toolCalls).toHaveLength(0);
-    expect(state.warningsIssued).toBe(0);
-    expect(state.blocksTriggered).toBe(0);
-  });
-
-  test("first tool.execute.before (subagent-only lazy fallback) creates state file with parentAgent: null", () => {
-    // No chat.message has fired — simulate a subagent-only session
-    plugin.onToolExecuteBefore(TEST_SESSION);
-
-    expect(plugin.stateFileExists(TEST_SESSION)).toBe(true);
-
-    const raw = plugin.readStateFile(TEST_SESSION);
-    expect(raw).not.toBeNull();
-    const state = JSON.parse(raw!.toString());
-
-    expect(state.sessionId).toBe(TEST_SESSION);
-    expect(state.parentAgent).toBeNull();
-    expect(state.startedAt).toBe(0); // §4.7: epoch zero for lazy fallback
-    expect(state.lastActivityAt).toBe(0);
-    expect(state.toolCalls).toHaveLength(0);
-  });
-
-  test("chat.message followed by tool.execute.before does NOT create duplicate state file", () => {
-    plugin.onChatMessage(TEST_SESSION, "msg-001", "odin");
-    const firstRead = plugin.readStateFile(TEST_SESSION);
-
-    plugin.onToolExecuteBefore(TEST_SESSION);
-    const secondRead = plugin.readStateFile(TEST_SESSION);
-
-    // Same content — no duplicate write
-    expect(firstRead).toBe(secondRead);
-  });
-
-  test("session.deleted removes the state file", () => {
-    plugin.onChatMessage(TEST_SESSION, "msg-001", "odin");
-    expect(plugin.stateFileExists(TEST_SESSION)).toBe(true);
-
-    plugin.onSessionDeleted(TEST_SESSION);
-    expect(plugin.stateFileExists(TEST_SESSION)).toBe(false);
-  });
-
-  test("unknown event types are no-ops — no state file created, no error", () => {
-    plugin.onUnknownEvent();
-    expect(plugin.stateFileExists(TEST_SESSION)).toBe(false);
-    // Should not throw
-  });
-
-  test("second chat.message for same session does NOT create new state file", () => {
-    plugin.onChatMessage(TEST_SESSION, "msg-001", "odin");
-    const firstContent = plugin.readStateFile(TEST_SESSION);
-
-    plugin.onChatMessage(TEST_SESSION, "msg-002", "odin");
-    const secondContent = plugin.readStateFile(TEST_SESSION);
-
-    expect(firstContent).toBe(secondContent);
-  });
-
-  test("different sessions have independent state files", () => {
-    plugin.onChatMessage(TEST_SESSION, "msg-001", "odin");
-    plugin.onChatMessage(TEST_SESSION_2, "msg-002", "thor");
-
-    const stateA = JSON.parse(plugin.readStateFile(TEST_SESSION)!.toString());
-    const stateB = JSON.parse(plugin.readStateFile(TEST_SESSION_2)!.toString());
-
-    expect(stateA.parentAgent).toBe("odin");
-    expect(stateB.parentAgent).toBe("thor");
-    expect(stateA.sessionId).toBe(TEST_SESSION);
-    expect(stateB.sessionId).toBe(TEST_SESSION_2);
-  });
-
-  test("duplicate chat.message (same messageId) is a no-op", () => {
-    plugin.onChatMessage(TEST_SESSION, "msg-001", "odin");
-    const content1 = plugin.readStateFile(TEST_SESSION);
-
-    // Same messageId again — no-op
-    plugin.onChatMessage(TEST_SESSION, "msg-001", "odin");
-    const content2 = plugin.readStateFile(TEST_SESSION);
-
-    expect(content1).toBe(content2);
-  });
-});