macro-agent 0.1.1 → 0.1.3

package/src/mail/__tests__/mail-integration.test.ts

@@ -1,759 +0,0 @@
-/**
- * Mail Integration Tests
- *
- * Full pipeline integration tests verifying MailService, ConversationMap,
- * TurnRecorder, MessageRouter, and EventStore all work together with
- * real (in-memory) services.
- */
-
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { createEventStore, type EventStore } from "../../store/event-store.js";
-import { createMailService, type MailService } from "../mail-service.js";
-import { createConversationMap, type ConversationMap } from "../conversation-map.js";
-import { createTurnRecorder } from "../turn-recorder.js";
-import {
-  createMessageRouter,
-  type MessageRouter,
-} from "../../router/message-router.js";
-import type { AgentId } from "../../store/types/index.js";
-
-describe("Mail Integration - Full Pipeline", () => {
-  let eventStore: EventStore;
-  let messageRouter: MessageRouter;
-  let mailService: MailService;
-  let conversationMap: ConversationMap;
-
-  beforeEach(async () => {
-    eventStore = await createEventStore({ inMemory: true });
-    messageRouter = createMessageRouter(eventStore);
-    mailService = createMailService({ eventStore });
-    conversationMap = createConversationMap();
-
-    // Wire turn recorder into message router
-    const turnRecorder = createTurnRecorder({
-      mailService,
-      conversationMap,
-      eventStore,
-    });
-    messageRouter.setTurnRecorder(turnRecorder);
-  });
-
-  afterEach(async () => {
-    await eventStore.close();
-  });
-
-  // ─────────────────────────────────────────────────────────────────
-  // Helpers
-  // ─────────────────────────────────────────────────────────────────
-
-  function spawnAgent(agentId: string, parentId?: string, task?: string): void {
-    const lineage: string[] = [];
-    if (parentId) {
-      const parent = eventStore.getAgent(parentId as AgentId);
-      if (parent) {
-        lineage.push(...parent.lineage, parentId);
-      } else {
-        lineage.push(parentId);
-      }
-    }
-    eventStore.emit({
-      type: "spawn",
-      source: { agent_id: (parentId ?? agentId) as AgentId },
-      payload: {
-        agent_id: agentId,
-        session_id: `session-${agentId}`,
-        task: task ?? `Task for ${agentId}`,
-        parent: parentId ?? null,
-        lineage,
-        role: "worker",
-      },
-    });
-  }
-
-  function setupTaskConversation(agentId: string, parentId: string): string {
-    const parentConversationId =
-      conversationMap.getAgentConversation(parentId) ??
-      conversationMap.getSessionConversation(parentId);
-
-    const { conversationId } = mailService.createConversation({
-      type: "task",
-      subject: `Task conversation for ${agentId}`,
-      createdBy: parentId,
-      parentConversationId,
-    });
-    mailService.joinConversation({
-      conversationId,
-      participantId: parentId,
-      role: "initiator",
-    });
-    mailService.joinConversation({
-      conversationId,
-      participantId: agentId,
-      role: "worker",
-    });
-    conversationMap.setAgentConversation(agentId, conversationId);
-    return conversationId;
-  }
-
-  function setupSessionConversation(hmId: string): string {
-    const { conversationId } = mailService.createConversation({
-      type: "session",
-      subject: "User session",
-      createdBy: "user",
-    });
-    mailService.joinConversation({
-      conversationId,
-      participantId: hmId,
-      role: "worker",
-    });
-    conversationMap.setSessionConversation(hmId, conversationId);
-    return conversationId;
-  }
-
-  function subscribeAgent(agentId: string, parentId?: string): void {
-    messageRouter.setupDefaultSubscriptions({
-      agent_id: agentId as AgentId,
-      parent_id: parentId as AgentId | undefined,
-    });
-  }
-
-  // ─────────────────────────────────────────────────────────────────
-  // Full lifecycle
-  // ─────────────────────────────────────────────────────────────────
-
-  describe("Full lifecycle: spawn → messages → done → terminate", () => {
-    it("creates session conv, spawns worker, records turns via router, closes on done", async () => {
-      // 1. Setup head manager with session conversation
-      spawnAgent("hm-1");
-      subscribeAgent("hm-1");
-      const sessionConvId = setupSessionConversation("hm-1");
-
-      // 2. Record user message in session conversation
-      mailService.recordTurn({
-        conversationId: sessionConvId,
-        participant: "user",
-        contentType: "text",
-        content: "Please refactor the auth module",
-      });
-
-      // 3. Spawn worker, setup task conversation
-      spawnAgent("worker-1", "hm-1", "Refactor auth");
-      subscribeAgent("worker-1", "hm-1");
-      const taskConvId = setupTaskConversation("worker-1", "hm-1");
-
-      // 4. Head manager sends task instruction to worker via router
-      await messageRouter.sendToAddress({
-        from: "hm-1" as AgentId,
-        to: { agent: "worker-1" as AgentId },
-        content: "Refactor the auth module, focus on token storage",
-      });
-
-      // Verify: turn intercepted in worker's task conversation
-      let taskTurns = mailService.listTurns({ conversationId: taskConvId });
-      expect(taskTurns).toHaveLength(1);
-      expect(taskTurns[0].participant).toBe("hm-1");
-      expect(taskTurns[0].content).toBe("Refactor the auth module, focus on token storage");
-      expect(taskTurns[0].sourceType).toBe("intercepted");
-
-      // 5. Worker sends reply to head manager
-      await messageRouter.sendToAddress({
-        from: "worker-1" as AgentId,
-        to: { agent: "hm-1" as AgentId },
-        content: "Found 3 issues in auth module, proceeding with fix",
-      });
-
-      // Verify: 2 turns in task conversation (parent→child + child→parent)
-      taskTurns = mailService.listTurns({ conversationId: taskConvId });
-      expect(taskTurns).toHaveLength(2);
-      expect(taskTurns[0].participant).toBe("hm-1");
-      expect(taskTurns[1].participant).toBe("worker-1");
-
-      // 6. Simulate worker done() — record completion turn + close
-      mailService.recordTurn({
-        conversationId: taskConvId,
-        participant: "worker-1",
-        contentType: "event",
-        content: { event: "agent.completed", summary: "Auth refactored" },
-      });
-      mailService.closeConversation({
-        conversationId: taskConvId,
-        closedBy: "worker-1",
-        reason: "completed",
-      });
-      conversationMap.removeAgent("worker-1");
-
-      // 7. Head manager responds in session conversation
-      mailService.recordTurn({
-        conversationId: sessionConvId,
-        participant: "hm-1",
-        contentType: "text",
-        content: "Done. The auth module has been refactored.",
-      });
-
-      // Verify final state
-      const sessionConv = mailService.getConversation(sessionConvId);
-      expect(sessionConv!.status).toBe("active");
-      const sessionTurns = mailService.listTurns({ conversationId: sessionConvId });
-      expect(sessionTurns).toHaveLength(2); // user + assistant
-
-      const taskConv = mailService.getConversation(taskConvId);
-      expect(taskConv!.status).toBe("completed");
-      const finalTaskTurns = mailService.listTurns({ conversationId: taskConvId });
-      expect(finalTaskTurns).toHaveLength(3); // 2 intercepted + 1 event
-
-      // Verify total conversations
-      const allConvs = mailService.listConversations();
-      expect(allConvs).toHaveLength(2);
-    });
-  });
-
-  // ─────────────────────────────────────────────────────────────────
-  // Multi-level hierarchy
-  // ─────────────────────────────────────────────────────────────────
-
-  describe("Multi-level hierarchy", () => {
-    it("creates conversation tree with correct parentConversationId chain", () => {
-      // Setup 3-level hierarchy
-      spawnAgent("gp");
-      const sessionConvId = setupSessionConversation("gp");
-
-      spawnAgent("parent", "gp");
-      const parentTaskConvId = setupTaskConversation("parent", "gp");
-
-      spawnAgent("child", "parent");
-      const childTaskConvId = setupTaskConversation("child", "parent");
-
-      // Verify parentConversationId chain
-      const parentConv = mailService.getConversation(parentTaskConvId);
-      expect(parentConv!.parentConversationId).toBe(sessionConvId);
-
-      const childConv = mailService.getConversation(childTaskConvId);
-      expect(childConv!.parentConversationId).toBe(parentTaskConvId);
-
-      // Verify total: 1 session + 2 task
-      expect(mailService.listConversations()).toHaveLength(3);
-    });
-
-    it("routes messages correctly across three levels", async () => {
-      // Setup 3-level hierarchy with subscriptions
-      spawnAgent("gp");
-      subscribeAgent("gp");
-      setupSessionConversation("gp");
-
-      spawnAgent("parent", "gp");
-      subscribeAgent("parent", "gp");
-      const parentConvId = setupTaskConversation("parent", "gp");
-
-      spawnAgent("child", "parent");
-      subscribeAgent("child", "parent");
-      const childConvId = setupTaskConversation("child", "parent");
-
-      // gp → parent: turn in parent's task conversation
-      await messageRouter.sendToAddress({
-        from: "gp" as AgentId,
-        to: { agent: "parent" as AgentId },
-        content: "GP to parent",
-      });
-      expect(mailService.listTurns({ conversationId: parentConvId })).toHaveLength(1);
-      expect(mailService.listTurns({ conversationId: childConvId })).toHaveLength(0);
-
-      // parent → child: turn in child's task conversation
-      await messageRouter.sendToAddress({
-        from: "parent" as AgentId,
-        to: { agent: "child" as AgentId },
-        content: "Parent to child",
-      });
-      expect(mailService.listTurns({ conversationId: childConvId })).toHaveLength(1);
-
-      // child → parent: still in child's task conversation
-      await messageRouter.sendToAddress({
-        from: "child" as AgentId,
-        to: { agent: "parent" as AgentId },
-        content: "Child to parent",
-      });
-      expect(mailService.listTurns({ conversationId: childConvId })).toHaveLength(2);
-      expect(mailService.listTurns({ conversationId: parentConvId })).toHaveLength(1);
-
-      // parent → gp: in parent's task conversation
-      await messageRouter.sendToAddress({
-        from: "parent" as AgentId,
-        to: { agent: "gp" as AgentId },
-        content: "Parent to GP",
-      });
-      expect(mailService.listTurns({ conversationId: parentConvId })).toHaveLength(2);
-    });
-  });
-
-  // ─────────────────────────────────────────────────────────────────
-  // MessageRouter + TurnRecorder integration
-  // ─────────────────────────────────────────────────────────────────
-
-  describe("MessageRouter + TurnRecorder integration", () => {
-    it("records turns for agent address messages with correct metadata", async () => {
-      spawnAgent("parent");
-      subscribeAgent("parent");
-      spawnAgent("child", "parent");
-      subscribeAgent("child", "parent");
-      const taskConvId = setupTaskConversation("child", "parent");
-
-      await messageRouter.sendToAddress({
-        from: "parent" as AgentId,
-        to: { agent: "child" as AgentId },
-        content: "Hello child",
-      });
-
-      const turns = mailService.listTurns({ conversationId: taskConvId });
-      expect(turns).toHaveLength(1);
-      expect(turns[0].sourceType).toBe("intercepted");
-      expect(turns[0].sourceMessageId).toBeDefined();
-      expect(turns[0].participant).toBe("parent");
-      expect(turns[0].contentType).toBe("text");
-    });
-
-    it("records turns for task address messages", async () => {
-      spawnAgent("parent");
-      subscribeAgent("parent");
-      spawnAgent("child", "parent");
-      subscribeAgent("child", "parent");
-      const taskConvId = setupTaskConversation("child", "parent");
-
-      // Create a task assigned to child
-      eventStore.emit({
-        type: "task",
-        source: { agent_id: "parent" as AgentId },
-        payload: {
-          action: "created",
-          task_id: "task-1",
-          details: { description: "Test task" },
-        },
-      });
-      // Assign to child
-      eventStore.emit({
-        type: "task",
-        source: { agent_id: "parent" as AgentId },
-        payload: {
-          action: "assigned",
-          task_id: "task-1",
-          details: { agent_id: "child" },
-        },
-      });
-
-      await messageRouter.sendToAddress({
-        from: "parent" as AgentId,
-        to: { task: "task-1" as any },
-        content: "Task message",
-      });
-
-      const turns = mailService.listTurns({ conversationId: taskConvId });
-      expect(turns).toHaveLength(1);
-      expect(turns[0].content).toBe("Task message");
-    });
-
-    it("does NOT record turns for broadcast messages", async () => {
-      spawnAgent("broadcaster");
-      subscribeAgent("broadcaster");
-      spawnAgent("listener", "broadcaster");
-      subscribeAgent("listener", "broadcaster");
-      setupTaskConversation("listener", "broadcaster");
-
-      // Subscribe listener to broadcast channel
-      messageRouter.subscribe("listener" as AgentId, {
-        type: "broadcast",
-        name: "announcements",
-      });
-
-      await messageRouter.sendToAddress({
-        from: "broadcaster" as AgentId,
-        to: { broadcast: true },
-        content: "Broadcast announcement",
-      });
-
-      // No turns should be created anywhere
-      const allConvs = mailService.listConversations();
-      for (const conv of allConvs) {
-        const turns = mailService.listTurns({ conversationId: conv.id });
-        expect(turns).toHaveLength(0);
-      }
-    });
-  });
-
-  // ─────────────────────────────────────────────────────────────────
-  // Peer conversations
-  // ─────────────────────────────────────────────────────────────────
-
-  describe("Peer conversations", () => {
-    it("auto-creates peer conversation when siblings message via router", async () => {
-      spawnAgent("coordinator");
-      subscribeAgent("coordinator");
-      const coordConvId = setupSessionConversation("coordinator");
-
-      spawnAgent("worker-a", "coordinator");
-      subscribeAgent("worker-a", "coordinator");
-      setupTaskConversation("worker-a", "coordinator");
-
-      spawnAgent("worker-b", "coordinator");
-      subscribeAgent("worker-b", "coordinator");
-      setupTaskConversation("worker-b", "coordinator");
-
-      // Worker A sends to Worker B (peers, not parent-child)
-      await messageRouter.sendToAddress({
-        from: "worker-a" as AgentId,
-        to: { agent: "worker-b" as AgentId },
-        content: "Hey, here's the schema you need",
-      });
-
-      // Peer conversation should exist
-      const peerConvId = conversationMap.getPeerConversation("worker-a", "worker-b");
-      expect(peerConvId).toBeDefined();
-
-      const peerConv = mailService.getConversation(peerConvId!);
-      expect(peerConv!.type).toBe("peer");
-      // Nearest common ancestor is coordinator (session conv)
-      expect(peerConv!.parentConversationId).toBe(coordConvId);
-
-      // Verify participants
-      const participants = mailService.listParticipants(peerConvId!);
-      expect(participants).toHaveLength(2);
-
-      // Verify turn
-      const turns = mailService.listTurns({ conversationId: peerConvId! });
-      expect(turns).toHaveLength(1);
-      expect(turns[0].participant).toBe("worker-a");
-    });
-
-    it("reuses peer conversation for reply messages", async () => {
-      spawnAgent("parent");
-      subscribeAgent("parent");
-
-      spawnAgent("peer-a", "parent");
-      subscribeAgent("peer-a", "parent");
-
-      spawnAgent("peer-b", "parent");
-      subscribeAgent("peer-b", "parent");
-
-      // First message
-      await messageRouter.sendToAddress({
-        from: "peer-a" as AgentId,
-        to: { agent: "peer-b" as AgentId },
-        content: "First",
-      });
-
-      const convId = conversationMap.getPeerConversation("peer-a", "peer-b");
-
-      // Reply in reverse direction
-      await messageRouter.sendToAddress({
-        from: "peer-b" as AgentId,
-        to: { agent: "peer-a" as AgentId },
-        content: "Reply",
-      });
-
-      // Same conversation, 2 turns
-      expect(conversationMap.getPeerConversation("peer-a", "peer-b")).toBe(convId);
-      const turns = mailService.listTurns({ conversationId: convId! });
-      expect(turns).toHaveLength(2);
-      expect(turns[0].participant).toBe("peer-a");
-      expect(turns[1].participant).toBe("peer-b");
-    });
-
-    it("sets parentConversationId to nearest common ancestor for deep hierarchy", async () => {
-      // root → branch-a → leaf-a
-      // root → branch-b → leaf-b
-      spawnAgent("root");
-      subscribeAgent("root");
-      const rootConvId = setupSessionConversation("root");
-
-      spawnAgent("branch-a", "root");
-      subscribeAgent("branch-a", "root");
-      setupTaskConversation("branch-a", "root");
-
-      spawnAgent("branch-b", "root");
-      subscribeAgent("branch-b", "root");
-      setupTaskConversation("branch-b", "root");
-
-      spawnAgent("leaf-a", "branch-a");
-      subscribeAgent("leaf-a", "branch-a");
-
-      spawnAgent("leaf-b", "branch-b");
-      subscribeAgent("leaf-b", "branch-b");
-
-      // leaf-a messages leaf-b
-      await messageRouter.sendToAddress({
-        from: "leaf-a" as AgentId,
-        to: { agent: "leaf-b" as AgentId },
-        content: "Cross-branch message",
-      });
-
-      const peerConvId = conversationMap.getPeerConversation("leaf-a", "leaf-b");
-      const peerConv = mailService.getConversation(peerConvId!);
-
-      // Nearest common ancestor is root (session conv)
-      expect(peerConv!.parentConversationId).toBe(rootConvId);
-    });
-  });
-
-  // ─────────────────────────────────────────────────────────────────
-  // Cascade termination cleanup
-  // ─────────────────────────────────────────────────────────────────
-
-  describe("Cascade termination cleanup", () => {
-    it("closes child and peer conversations on terminate", async () => {
-      // Setup: coordinator → worker-a, worker-b, peer conv between workers
-      spawnAgent("coord");
-      subscribeAgent("coord");
-      setupSessionConversation("coord");
-
-      spawnAgent("wa", "coord");
-      subscribeAgent("wa", "coord");
-      const waConvId = setupTaskConversation("wa", "coord");
-
-      spawnAgent("wb", "coord");
-      subscribeAgent("wb", "coord");
-      const wbConvId = setupTaskConversation("wb", "coord");
-
-      // Create peer conversation
-      await messageRouter.sendToAddress({
-        from: "wa" as AgentId,
-        to: { agent: "wb" as AgentId },
-        content: "Peer msg",
-      });
-      const peerConvId = conversationMap.getPeerConversation("wa", "wb")!;
-
-      // Simulate terminate cascade (same sequence as agent-manager.ts:709-729)
-      // Terminate worker-a
-      const waConv = conversationMap.getAgentConversation("wa");
-      if (waConv) {
-        mailService.closeConversation({ conversationId: waConv, closedBy: "wa", reason: "completed" });
-      }
-      const waPeerConvIds = conversationMap.closePeerConversationsFor("wa");
-      for (const id of waPeerConvIds) {
-        mailService.closeConversation({ conversationId: id, closedBy: "wa", reason: "participant_left" });
-      }
-      conversationMap.removeAgent("wa");
-
-      // Terminate worker-b
-      const wbConv = conversationMap.getAgentConversation("wb");
-      if (wbConv) {
-        mailService.closeConversation({ conversationId: wbConv, closedBy: "wb", reason: "completed" });
-      }
-      conversationMap.closePeerConversationsFor("wb");
-      conversationMap.removeAgent("wb");
-
-      // Verify: all task + peer convs closed
-      expect(mailService.getConversation(waConvId)!.status).toBe("completed");
-      expect(mailService.getConversation(wbConvId)!.status).toBe("completed");
-      expect(mailService.getConversation(peerConvId)!.status).toBe("completed");
-
-      // Agents removed from map
-      expect(conversationMap.getAgentConversation("wa")).toBeUndefined();
-      expect(conversationMap.getAgentConversation("wb")).toBeUndefined();
-      expect(conversationMap.getPeerConversation("wa", "wb")).toBeUndefined();
-
-      // Session conversation stays active
-      const sessionConvId = conversationMap.getSessionConversation("coord");
-      expect(mailService.getConversation(sessionConvId!)!.status).toBe("active");
-    });
-  });
-
-  // ─────────────────────────────────────────────────────────────────
-  // listConversations filters
-  // ─────────────────────────────────────────────────────────────────
-
-  describe("listConversations filters", () => {
-    it("filters by type, status, and parentConversationId", () => {
-      // Create 1 session, 2 task, 1 peer
-      spawnAgent("root");
-      const sessionId = setupSessionConversation("root");
-
-      spawnAgent("child-1", "root");
-      const task1Id = setupTaskConversation("child-1", "root");
-
-      spawnAgent("child-2", "root");
-      setupTaskConversation("child-2", "root");
-
-      // Create peer
-      const { conversationId: peerId } = mailService.createConversation({
-        type: "peer",
-        subject: "Peer conv",
-        createdBy: "child-1",
-      });
-
-      // Close one task
-      mailService.closeConversation({
-        conversationId: task1Id,
-        closedBy: "child-1",
-        reason: "completed",
-      });
-
-      // Filter by type
-      expect(mailService.listConversations({ type: "session" })).toHaveLength(1);
-      expect(mailService.listConversations({ type: "task" })).toHaveLength(2);
-      expect(mailService.listConversations({ type: "peer" })).toHaveLength(1);
-
-      // Filter by status
-      expect(mailService.listConversations({ status: "active" })).toHaveLength(3);
-      expect(mailService.listConversations({ status: "completed" })).toHaveLength(1);
-
-      // Filter by parentConversationId
-      expect(
-        mailService.listConversations({ parentConversationId: sessionId })
-      ).toHaveLength(2); // both task convs have session as parent
-
-      // Total
-      expect(mailService.listConversations()).toHaveLength(4);
-    });
-  });
-
-  // ─────────────────────────────────────────────────────────────────
-  // Error paths and edge cases
-  // ─────────────────────────────────────────────────────────────────
-
-  describe("Error paths and edge cases", () => {
-    it("allows recording turns in a closed conversation (no validation at service layer)", () => {
-      spawnAgent("parent");
-      spawnAgent("child", "parent");
-      const convId = setupTaskConversation("child", "parent");
-
-      // Close the conversation
-      mailService.closeConversation({ conversationId: convId, closedBy: "child", reason: "completed" });
-      expect(mailService.getConversation(convId)!.status).toBe("completed");
-
-      // MailService does NOT validate — turn still records
-      const { turnId } = mailService.recordTurn({
-        conversationId: convId,
-        participant: "parent",
-        contentType: "text",
-        content: "Late message",
-      });
-      expect(turnId).toBeDefined();
-
-      const turns = mailService.listTurns({ conversationId: convId });
-      expect(turns).toHaveLength(1);
-      expect(turns[0].content).toBe("Late message");
-    });
-
-    it("allows double-closing a conversation (idempotent at service layer)", () => {
-      const { conversationId } = mailService.createConversation({
-        type: "session",
-        subject: "Double close",
-        createdBy: "user",
-      });
-
-      mailService.closeConversation({ conversationId, closedBy: "user", reason: "completed" });
-      expect(mailService.getConversation(conversationId)!.status).toBe("completed");
-
-      // Second close doesn't throw — just re-applies
-      mailService.closeConversation({ conversationId, closedBy: "user", reason: "failed" });
-      expect(mailService.getConversation(conversationId)!.status).toBe("failed");
-    });
-
-    it("TurnRecorder silently skips when child task conv doesn't exist", async () => {
-      spawnAgent("parent");
-      subscribeAgent("parent");
-      spawnAgent("child", "parent");
-      subscribeAgent("child", "parent");
-      // No task conversation set up for child
-
-      // Should not throw
-      await messageRouter.sendToAddress({
-        from: "parent" as AgentId,
-        to: { agent: "child" as AgentId },
-        content: "No conv",
-      });
-
-      // No conversations created
-      expect(mailService.listConversations()).toHaveLength(0);
-    });
-
-    it("handles messages between agents with no common ancestor gracefully", async () => {
-      spawnAgent("root-a");
-      subscribeAgent("root-a");
-      spawnAgent("root-b");
-      subscribeAgent("root-b");
-
-      // Peers with no common ancestor
-      await messageRouter.sendToAddress({
-        from: "root-a" as AgentId,
-        to: { agent: "root-b" as AgentId },
-        content: "No ancestor",
-      });
-
-      const peerConvId = conversationMap.getPeerConversation("root-a", "root-b");
-      expect(peerConvId).toBeDefined();
-
-      const conv = mailService.getConversation(peerConvId!);
-      expect(conv!.type).toBe("peer");
-      expect(conv!.parentConversationId).toBeUndefined();
-    });
-
-    it("turn-recorder does not fail message routing when recordTurn throws", async () => {
-      spawnAgent("parent");
-      subscribeAgent("parent");
-      spawnAgent("child", "parent");
-      subscribeAgent("child", "parent");
-
-      const taskConvId = setupTaskConversation("child", "parent");
-
-      // Sabotage the mailService.recordTurn to throw
-      const originalRecordTurn = mailService.recordTurn.bind(mailService);
-      mailService.recordTurn = () => {
-        throw new Error("Simulated store failure");
-      };
-
-      // Message routing should still succeed (no throw)
-      await expect(
-        messageRouter.sendToAddress({
-          from: "parent" as AgentId,
-          to: { agent: "child" as AgentId },
-          content: "Should still route",
-        })
-      ).resolves.not.toThrow();
-
-      // Restore original and send another message to verify routing still works
-      mailService.recordTurn = originalRecordTurn;
-      await messageRouter.sendToAddress({
-        from: "parent" as AgentId,
-        to: { agent: "child" as AgentId },
-        content: "After recovery",
-      });
-
-      // The recovered turn should be recorded
-      const turns = mailService.listTurns({ conversationId: taskConvId });
-      expect(turns.length).toBeGreaterThanOrEqual(1);
-      expect(turns.some((t) => t.content === "After recovery")).toBe(true);
-    });
-
-    it("does not create duplicate peer conversations for same pair", async () => {
-      spawnAgent("parent");
-      subscribeAgent("parent");
-      spawnAgent("a", "parent");
-      subscribeAgent("a", "parent");
-      spawnAgent("b", "parent");
-      subscribeAgent("b", "parent");
-
-      // Send multiple messages in both directions
-      await messageRouter.sendToAddress({
-        from: "a" as AgentId,
-        to: { agent: "b" as AgentId },
-        content: "msg-1",
-      });
-      await messageRouter.sendToAddress({
-        from: "b" as AgentId,
-        to: { agent: "a" as AgentId },
-        content: "msg-2",
-      });
-      await messageRouter.sendToAddress({
-        from: "a" as AgentId,
-        to: { agent: "b" as AgentId },
-        content: "msg-3",
-      });
-
-      // Only 1 peer conversation should exist
-      const peerConvs = mailService.listConversations({ type: "peer" });
-      expect(peerConvs).toHaveLength(1);
-
-      // All 3 turns in that single conversation
-      const turns = mailService.listTurns({ conversationId: peerConvs[0].id });
-      expect(turns).toHaveLength(3);
-    });
-  });
-});