macro-agent 0.1.1 → 0.1.3

package/src/mcp/__tests__/mcp-server.test.ts

@@ -1,1002 +0,0 @@
-/**
- * MCP Server tests
- *
- * Tests the MCP tool handlers with mocked services.
- */
-
-import { describe, it, expect, beforeEach, vi } from "vitest";
-import { createMCPServer, type MCPServices } from "../mcp-server.js";
-import type { ToolContext } from "../types.js";
-import type { EventStore } from "../../store/event-store.js";
-import type { AgentManager } from "../../agent/agent-manager.js";
-import type { TaskManager } from "../../task/task-manager.js";
-import type { MessageRouter } from "../../router/message-router.js";
-import type { Agent, Task } from "../../store/types/index.js";
-
-// ─────────────────────────────────────────────────────────────────
-// Mock Factories
-// ─────────────────────────────────────────────────────────────────
-
-function createMockAgent(overrides: Partial<Agent> = {}): Agent {
-  return {
-    id: "agent_test123",
-    name: "swift-falcon",
-    session_id: "sess_test123",
-    parent: null,
-    lineage: [],
-    state: "running",
-    task: "Test task",
-    task_id: "task_test123",
-    config: {},
-    cwd: "/test/working/dir",
-    created_at: Date.now(),
-    started_at: Date.now(),
-    ...overrides,
-  };
-}
-
-function createMockTask(overrides: Partial<Task> = {}): Task {
-  return {
-    id: "task_test123",
-    description: "Test task",
-    status: "pending",
-    created_at: Date.now(),
-    created_by: "agent_test123",
-    ...overrides,
-  };
-}
-
-function createMockEventStore(): EventStore {
-  const events: any[] = [];
-
-  return {
-    emit: vi.fn((input) => {
-      const event = {
-        id: `evt_${Date.now()}`,
-        version: 1,
-        timestamp: Date.now(),
-        ...input,
-      };
-      events.push(event);
-      return event;
-    }),
-    query: vi.fn(() => []),
-    getAgent: vi.fn(() => null),
-    listAgents: vi.fn(() => []),
-    getTask: vi.fn(() => null),
-    listTasks: vi.fn(() => []),
-    getMessages: vi.fn(() => []),
-    getFullMessage: vi.fn(() => null),
-    addSubscription: vi.fn(),
-    removeSubscription: vi.fn(),
-    getSubscriptions: vi.fn(() => []),
-    getSubscribers: vi.fn(() => []),
-    onAgentChange: vi.fn(() => () => {}),
-    onTaskChange: vi.fn(() => () => {}),
-    onMessageChange: vi.fn(() => () => {}),
-    persist: vi.fn(async () => {}),
-    close: vi.fn(async () => {}),
-  };
-}
-
-function createMockAgentManager(): AgentManager {
-  return {
-    spawn: vi.fn(async (options) => ({
-      id: "agent_spawned123",
-      session_id: "sess_spawned123",
-      agent: createMockAgent({ id: "agent_spawned123", name: "brave-tiger", task: options.task, task_id: "task_spawned123" }),
-      session: {} as any,
-    })),
-    terminate: vi.fn(async () => {}),
-    resume: vi.fn(async () => ({} as any)),
-    get: vi.fn(() => null),
-    list: vi.fn(() => []),
-    getChildren: vi.fn(() => []),
-    getHierarchy: vi.fn(() => null),
-    getOrCreateHeadManager: vi.fn(async () => ({} as any)),
-    listHeadManagers: vi.fn(() => []),
-    prompt: vi.fn(),
-    getSession: vi.fn(() => null),
-    hasActiveSession: vi.fn(() => false),
-    onLifecycleEvent: vi.fn(() => () => {}),
-    close: vi.fn(async () => {}),
-  };
-}
-
-function createMockTaskManager(): TaskManager {
-  return {
-    create: vi.fn((options) =>
-      createMockTask({
-        id: "task_created123",
-        description: options.description,
-        created_by: options.created_by,
-      })
-    ),
-    createSubtask: vi.fn(),
-    get: vi.fn(() => null),
-    list: vi.fn(() => []),
-    getSubtasks: vi.fn(() => []),
-    getSubtaskStatus: vi.fn(() => ({
-      total: 0,
-      pending: 0,
-      assigned: 0,
-      in_progress: 0,
-      completed: 0,
-      failed: 0,
-      allCompleted: false,
-      anyFailed: false,
-    })),
-    assign: vi.fn(),
-    unassign: vi.fn(),
-    updateStatus: vi.fn(),
-    update: vi.fn(),
-  };
-}
-
-function createMockMessageRouter(): MessageRouter {
-  return {
-    send: vi.fn(async (request) => ({
-      id: "msg_test123",
-      from: request.from,
-      to: request.to,
-      content: request.content,
-      timestamp: Date.now(),
-      correlation_id: request.correlation_id,
-    })),
-    sendToAddress: vi.fn(async (request) => ({
-      id: "msg_test123",
-      from: request.from,
-      to: request.to,
-      content: request.content,
-      timestamp: Date.now(),
-      delivered: [],
-      correlationId: request.options?.correlationId,
-    })),
-    emitStatus: vi.fn(),
-    getMessages: vi.fn(() => []),
-    getFullMessage: vi.fn(() => null),
-    acknowledgeMessage: vi.fn(),
-    acknowledgeMessages: vi.fn(),
-    subscribe: vi.fn(),
-    unsubscribe: vi.fn(),
-    getSubscriptions: vi.fn(() => []),
-    getSubscribers: vi.fn(() => []),
-    setupDefaultSubscriptions: vi.fn(),
-  };
-}
-
-function createTestContext(overrides: Partial<ToolContext> = {}): ToolContext {
-  return {
-    agent_id: "agent_caller123",
-    session_id: "sess_caller123",
-    task_id: "task_caller123",
-    lineage: [],
-    cwd: "/test/working/dir",
-    ...overrides,
-  };
-}
-
-// ─────────────────────────────────────────────────────────────────
-// Test Suite
-// ─────────────────────────────────────────────────────────────────
-
-describe("MCP Server", () => {
-  let eventStore: EventStore;
-  let agentManager: AgentManager;
-  let taskManager: TaskManager;
-  let messageRouter: MessageRouter;
-  let services: MCPServices;
-  let context: ToolContext;
-
-  beforeEach(() => {
-    eventStore = createMockEventStore();
-    agentManager = createMockAgentManager();
-    taskManager = createMockTaskManager();
-    messageRouter = createMockMessageRouter();
-    services = { eventStore, agentManager, taskManager, messageRouter };
-    context = createTestContext();
-  });
-
-  describe("createMCPServer", () => {
-    it("should create an MCP server instance", () => {
-      const mcpServer = createMCPServer(context, services);
-      expect(mcpServer).toBeDefined();
-      expect(mcpServer.server).toBeDefined();
-      expect(mcpServer.start).toBeDefined();
-      expect(mcpServer.close).toBeDefined();
-    });
-
-    it("should use custom config", () => {
-      const mcpServer = createMCPServer(context, services, {
-        name: "test-server",
-        version: "2.0.0",
-      });
-      expect(mcpServer).toBeDefined();
-    });
-  });
-
-  describe("spawn_agent tool", () => {
-    it("should spawn a child agent", async () => {
-      // Create MCP server (tools are registered on creation)
-      createMCPServer(context, services);
-
-      // Access the tool handler directly through the server's internal registry
-      // For testing, we'll verify the agentManager.spawn was called correctly
-      await (agentManager.spawn as ReturnType<typeof vi.fn>)({
-        task: "Child task",
-        parent: context.agent_id,
-        subscribeParent: true,
-        topics: [],
-        config: undefined,
-      });
-
-      expect(agentManager.spawn).toHaveBeenCalledWith({
-        task: "Child task",
-        parent: context.agent_id,
-        subscribeParent: true,
-        topics: [],
-        config: undefined,
-      });
-    });
-
-    it("should include name in spawn result", async () => {
-      createMCPServer(context, services);
-
-      const result = await (agentManager.spawn as ReturnType<typeof vi.fn>)({
-        task: "Named task",
-        parent: context.agent_id,
-        subscribeParent: true,
-        topics: [],
-        config: undefined,
-      });
-
-      expect(result.agent.name).toBe("brave-tiger");
-      expect(result.id).toBe("agent_spawned123");
-    });
-
-    it("should pass config options to spawn", async () => {
-      const config = { model: "claude-opus-4-20250514" };
-
-      await (agentManager.spawn as ReturnType<typeof vi.fn>)({
-        task: "Complex task",
-        parent: context.agent_id,
-        subscribeParent: false,
-        topics: ["research"],
-        config,
-      });
-
-      expect(agentManager.spawn).toHaveBeenCalledWith({
-        task: "Complex task",
-        parent: context.agent_id,
-        subscribeParent: false,
-        topics: ["research"],
-        config,
-      });
-    });
-  });
-
-  describe("emit_status tool", () => {
-    it("should emit status event", () => {
-      createMCPServer(context, services);
-
-      eventStore.emit({
-        type: "status",
-        source: { agent_id: context.agent_id },
-        payload: {
-          status_type: "checkpoint",
-          summary: "50% complete",
-          details: { progress: "50%" },
-        },
-      });
-
-      expect(eventStore.emit).toHaveBeenCalledWith({
-        type: "status",
-        source: { agent_id: context.agent_id },
-        payload: {
-          status_type: "checkpoint",
-          summary: "50% complete",
-          details: { progress: "50%" },
-        },
-      });
-    });
-
-    it("should update task status when complete_task is true", () => {
-      const contextWithTask = createTestContext({ task_id: "task_abc123" });
-      createMCPServer(contextWithTask, services);
-
-      // When emit_status is called with complete_task=true and status_type=completed
-      // it should call taskManager.updateStatus
-      taskManager.updateStatus("task_abc123", "completed");
-
-      expect(taskManager.updateStatus).toHaveBeenCalledWith("task_abc123", "completed");
-    });
-  });
-
-  describe("send_message tool", () => {
-    it("should send message to agent via sendToAddress", async () => {
-      createMCPServer(context, services);
-
-      await messageRouter.sendToAddress({
-        from: context.agent_id,
-        to: { agent: "agent_target123" },
-        content: "Hello!",
-      });
-
-      expect(messageRouter.sendToAddress).toHaveBeenCalledWith({
-        from: context.agent_id,
-        to: { agent: "agent_target123" },
-        content: "Hello!",
-      });
-    });
-
-    it("should send message to scope via sendToAddress", async () => {
-      createMCPServer(context, services);
-
-      await messageRouter.sendToAddress({
-        from: context.agent_id,
-        to: { scope: "discoveries" },
-        content: "Found something!",
-      });
-
-      expect(messageRouter.sendToAddress).toHaveBeenCalledWith({
-        from: context.agent_id,
-        to: { scope: "discoveries" },
-        content: "Found something!",
-      });
-    });
-
-    it("should include correlationId for replies", async () => {
-      createMCPServer(context, services);
-
-      await messageRouter.sendToAddress({
-        from: context.agent_id,
-        to: { agent: "agent_sender123" },
-        content: "Reply",
-        options: { correlationId: "msg_original123" },
-      });
-
-      expect(messageRouter.sendToAddress).toHaveBeenCalledWith(
-        expect.objectContaining({
-          options: expect.objectContaining({
-            correlationId: "msg_original123",
-          }),
-        })
-      );
-    });
-  });
-
-  describe("check_messages tool", () => {
-    it("should get pending messages", () => {
-      const mockMessages = [
-        {
-          id: "msg_1",
-          from: { agent_id: "agent_sender1" },
-          content: "Message 1",
-          timestamp: Date.now(),
-          truncated: false,
-        },
-        {
-          id: "msg_2",
-          from: { agent_id: "agent_sender2" },
-          content: "Message 2",
-          timestamp: Date.now(),
-          truncated: false,
-        },
-      ];
-
-      (messageRouter.getMessages as ReturnType<typeof vi.fn>).mockReturnValue(mockMessages);
-
-      createMCPServer(context, services);
-
-      const messages = messageRouter.getMessages(context.agent_id, { limit: 10, includeAcknowledged: false });
-
-      expect(messages).toHaveLength(2);
-      expect(messageRouter.getMessages).toHaveBeenCalledWith(context.agent_id, {
-        limit: 10,
-        includeAcknowledged: false,
-      });
-    });
-
-    it("should respect limit option", () => {
-      createMCPServer(context, services);
-
-      messageRouter.getMessages(context.agent_id, { limit: 5, includeAcknowledged: false });
-
-      expect(messageRouter.getMessages).toHaveBeenCalledWith(context.agent_id, {
-        limit: 5,
-        includeAcknowledged: false,
-      });
-    });
-
-    it("should resolve sender name from agent manager", () => {
-      const senderAgent = createMockAgent({ id: "agent_sender1", name: "wise-owl" });
-
-      (agentManager.get as ReturnType<typeof vi.fn>).mockImplementation((id: string) => {
-        if (id === "agent_sender1") return senderAgent;
-        return null;
-      });
-
-      createMCPServer(context, services);
-
-      // Verify agent name can be resolved for message senders
-      const resolved = agentManager.get("agent_sender1");
-      expect(resolved?.name).toBe("wise-owl");
-    });
-  });
-
-  describe("query_index tool", () => {
-    it("should query agents by state", () => {
-      const runningAgents = [
-        createMockAgent({ id: "agent_1", state: "running" }),
-        createMockAgent({ id: "agent_2", state: "running" }),
-      ];
-
-      (agentManager.list as ReturnType<typeof vi.fn>).mockReturnValue(runningAgents);
-
-      createMCPServer(context, services);
-
-      const agents = agentManager.list();
-      const filtered = agents.filter((a: Agent) => a.state === "running");
-
-      expect(filtered).toHaveLength(2);
-    });
-
-    it("should query tasks by status", () => {
-      const inProgressTasks = [
-        createMockTask({ id: "task_1", status: "in_progress" }),
-        createMockTask({ id: "task_2", status: "in_progress" }),
-      ];
-
-      (taskManager.list as ReturnType<typeof vi.fn>).mockReturnValue(inProgressTasks);
-
-      createMCPServer(context, services);
-
-      const tasks = taskManager.list();
-      const filtered = tasks.filter((t: Task) => t.status === "in_progress");
-
-      expect(filtered).toHaveLength(2);
-    });
-
-    it("should search by text", () => {
-      const agents = [
-        createMockAgent({ id: "agent_1", task: "Implement authentication" }),
-        createMockAgent({ id: "agent_2", task: "Add logging" }),
-      ];
-
-      (agentManager.list as ReturnType<typeof vi.fn>).mockReturnValue(agents);
-
-      createMCPServer(context, services);
-
-      const allAgents = agentManager.list();
-      const filtered = allAgents.filter((a: Agent) =>
-        a.task?.toLowerCase().includes("auth")
-      );
-
-      expect(filtered).toHaveLength(1);
-      expect(filtered[0].id).toBe("agent_1");
-    });
-
-    it("should search by agent name", () => {
-      const agents = [
-        createMockAgent({ id: "agent_1", name: "brave-tiger", task: "Implement auth" }),
-        createMockAgent({ id: "agent_2", name: "calm-dolphin", task: "Add logging" }),
-      ];
-
-      (agentManager.list as ReturnType<typeof vi.fn>).mockReturnValue(agents);
-
-      createMCPServer(context, services);
-
-      const allAgents = agentManager.list();
-      const search = "tiger";
-      const filtered = allAgents.filter(
-        (a: Agent) =>
-          a.id.toLowerCase().includes(search) ||
-          a.name?.toLowerCase().includes(search) ||
-          a.task?.toLowerCase().includes(search)
-      );
-
-      expect(filtered).toHaveLength(1);
-      expect(filtered[0].id).toBe("agent_1");
-      expect(filtered[0].name).toBe("brave-tiger");
-    });
-
-    it("should include name in agent entries", () => {
-      const agents = [
-        createMockAgent({ id: "agent_1", name: "brave-tiger" }),
-      ];
-
-      (agentManager.list as ReturnType<typeof vi.fn>).mockReturnValue(agents);
-
-      createMCPServer(context, services);
-
-      const allAgents = agentManager.list();
-      expect(allAgents[0].name).toBe("brave-tiger");
-    });
-  });
-
-  describe("get_hierarchy tool", () => {
-    it("should get agent hierarchy", () => {
-      const hierarchy = {
-        root: {
-          agent: createMockAgent({ id: "agent_root" }),
-          children: [
-            {
-              agent: createMockAgent({ id: "agent_child1", parent: "agent_root" }),
-              children: [],
-            },
-          ],
-        },
-        depth: 2,
-        totalAgents: 2,
-      };
-
-      (agentManager.getHierarchy as ReturnType<typeof vi.fn>).mockReturnValue(hierarchy);
-
-      createMCPServer(context, services);
-
-      const result = agentManager.getHierarchy("agent_root");
-
-      expect(result).toBeDefined();
-      expect(result!.totalAgents).toBe(2);
-      expect(result!.depth).toBe(2);
-    });
-
-    it("should include name in hierarchy nodes", () => {
-      const hierarchy = {
-        root: {
-          agent: createMockAgent({ id: "agent_root", name: "bold-eagle" }),
-          children: [
-            {
-              agent: createMockAgent({ id: "agent_child1", name: "calm-dolphin", parent: "agent_root" }),
-              children: [],
-            },
-          ],
-        },
-        depth: 2,
-        totalAgents: 2,
-      };
-
-      (agentManager.getHierarchy as ReturnType<typeof vi.fn>).mockReturnValue(hierarchy);
-
-      createMCPServer(context, services);
-
-      const result = agentManager.getHierarchy("agent_root");
-
-      expect(result!.root.agent.name).toBe("bold-eagle");
-      expect(result!.root.children[0].agent.name).toBe("calm-dolphin");
-    });
-
-    it("should return null for non-existent agent", () => {
-      (agentManager.getHierarchy as ReturnType<typeof vi.fn>).mockReturnValue(null);
-
-      createMCPServer(context, services);
-
-      const result = agentManager.getHierarchy("agent_nonexistent");
-
-      expect(result).toBeNull();
-    });
-  });
-
-  describe("get_agent_summary tool", () => {
-    it("should get agent details", () => {
-      const agent = createMockAgent({
-        id: "agent_detail123",
-        name: "fierce-lion",
-        task: "Important task",
-        state: "running",
-        parent: "agent_parent123",
-      });
-
-      (agentManager.get as ReturnType<typeof vi.fn>).mockReturnValue(agent);
-      (agentManager.getChildren as ReturnType<typeof vi.fn>).mockReturnValue([
-        createMockAgent({ id: "child_1" }),
-        createMockAgent({ id: "child_2" }),
-      ]);
-
-      createMCPServer(context, services);
-
-      const result = agentManager.get("agent_detail123");
-      const children = agentManager.getChildren("agent_detail123");
-
-      expect(result).toBeDefined();
-      expect(result!.task).toBe("Important task");
-      expect(result!.name).toBe("fierce-lion");
-      expect(children).toHaveLength(2);
-    });
-
-    it("should return null for non-existent agent", () => {
-      (agentManager.get as ReturnType<typeof vi.fn>).mockReturnValue(null);
-
-      createMCPServer(context, services);
-
-      const result = agentManager.get("agent_nonexistent");
-
-      expect(result).toBeNull();
-    });
-  });
-
-  describe("stop_agent tool", () => {
-    it("should stop agent in subtree", async () => {
-      const targetAgent = createMockAgent({
-        id: "agent_target123",
-        name: "quick-fox",
-        lineage: [context.agent_id], // Target has caller in lineage
-      });
-
-      (agentManager.get as ReturnType<typeof vi.fn>).mockReturnValue(targetAgent);
-      (agentManager.getChildren as ReturnType<typeof vi.fn>).mockReturnValue([]);
-
-      createMCPServer(context, services);
-
-      // Verify subtree check passes
-      expect(targetAgent.lineage.includes(context.agent_id)).toBe(true);
-
-      // Name should be available for inclusion in stop response
-      expect(targetAgent.name).toBe("quick-fox");
-
-      // Terminate should be called
-      await agentManager.terminate("agent_target123", "cancelled");
-
-      expect(agentManager.terminate).toHaveBeenCalledWith("agent_target123", "cancelled");
-    });
-
-    it("should reject stopping agent outside subtree", () => {
-      const outsideAgent = createMockAgent({
-        id: "agent_outside123",
-        lineage: ["agent_other_parent"], // Caller not in lineage
-      });
-
-      (agentManager.get as ReturnType<typeof vi.fn>).mockReturnValue(outsideAgent);
-
-      createMCPServer(context, services);
-
-      // Verify subtree check fails
-      const isInSubtree = outsideAgent.lineage.includes(context.agent_id);
-      expect(isInSubtree).toBe(false);
-    });
-
-    it("should allow stopping self", async () => {
-      const selfAgent = createMockAgent({
-        id: context.agent_id,
-        lineage: [],
-      });
-
-      (agentManager.get as ReturnType<typeof vi.fn>).mockReturnValue(selfAgent);
-      (agentManager.getChildren as ReturnType<typeof vi.fn>).mockReturnValue([]);
-
-      createMCPServer(context, services);
-
-      // Stopping self should be allowed
-      await agentManager.terminate(context.agent_id, "completed");
-
-      expect(agentManager.terminate).toHaveBeenCalledWith(context.agent_id, "completed");
-    });
-  });
-
-  describe("create_task tool", () => {
-    it("should create a new task", () => {
-      createMCPServer(context, services);
-
-      const task = taskManager.create({
-        description: "New task",
-        created_by: context.agent_id,
-      });
-
-      expect(task.id).toBe("task_created123");
-      expect(taskManager.create).toHaveBeenCalledWith({
-        description: "New task",
-        created_by: context.agent_id,
-      });
-    });
-
-    it("should create subtask with parent", () => {
-      createMCPServer(context, services);
-
-      taskManager.create({
-        description: "Subtask",
-        created_by: context.agent_id,
-        parent_task: "task_parent123",
-      });
-
-      expect(taskManager.create).toHaveBeenCalledWith({
-        description: "Subtask",
-        created_by: context.agent_id,
-        parent_task: "task_parent123",
-      });
-    });
-
-    it("should include inputs", () => {
-      createMCPServer(context, services);
-
-      taskManager.create({
-        description: "Task with inputs",
-        created_by: context.agent_id,
-        inputs: { key: "value" },
-      });
-
-      expect(taskManager.create).toHaveBeenCalledWith({
-        description: "Task with inputs",
-        created_by: context.agent_id,
-        inputs: { key: "value" },
-      });
-    });
-  });
-
-  describe("get_task tool", () => {
-    it("should get task details", () => {
-      const task = createMockTask({
-        id: "task_detail123",
-        description: "Detailed task",
-        status: "in_progress",
-        assigned_agent: "agent_worker123",
-        subtasks: ["subtask_1", "subtask_2"],
-      });
-
-      (taskManager.get as ReturnType<typeof vi.fn>).mockReturnValue(task);
-
-      createMCPServer(context, services);
-
-      const result = taskManager.get("task_detail123");
-
-      expect(result).toBeDefined();
-      expect(result!.description).toBe("Detailed task");
-      expect(result!.subtasks).toHaveLength(2);
-    });
-
-    it("should return null for non-existent task", () => {
-      (taskManager.get as ReturnType<typeof vi.fn>).mockReturnValue(null);
-
-      createMCPServer(context, services);
-
-      const result = taskManager.get("task_nonexistent");
-
-      expect(result).toBeNull();
-    });
-  });
-});
-
-describe("Tool Context", () => {
-  it("should inject agent_id into tool calls", () => {
-    const context = createTestContext({ agent_id: "agent_special123" });
-    const eventStore = createMockEventStore();
-    const agentManager = createMockAgentManager();
-    const taskManager = createMockTaskManager();
-    const messageRouter = createMockMessageRouter();
-
-    createMCPServer(
-      context,
-      { eventStore, agentManager, taskManager, messageRouter }
-    );
-
-    // The context should be used when emitting events
-    eventStore.emit({
-      type: "status",
-      source: { agent_id: context.agent_id },
-      payload: { status_type: "started", summary: "Test" },
-    });
-
-    expect(eventStore.emit).toHaveBeenCalledWith(
-      expect.objectContaining({
-        source: { agent_id: "agent_special123" },
-      })
-    );
-  });
-
-  it("should use lineage for subtree checks", () => {
-    const context = createTestContext({
-      agent_id: "agent_parent123",
-      lineage: ["agent_grandparent123"],
-    });
-
-    const agentManager = createMockAgentManager();
-    const childAgent = createMockAgent({
-      id: "agent_child123",
-      lineage: ["agent_grandparent123", "agent_parent123"],
-    });
-
-    (agentManager.get as ReturnType<typeof vi.fn>).mockReturnValue(childAgent);
-
-    createMCPServer(
-      context,
-      {
-        eventStore: createMockEventStore(),
-        agentManager,
-        taskManager: createMockTaskManager(),
-        messageRouter: createMockMessageRouter(),
-      }
-    );
-
-    // Child has parent in lineage, so parent can stop child
-    expect(childAgent.lineage.includes(context.agent_id)).toBe(true);
-  });
-});
-
-// ─────────────────────────────────────────────────────────────────
-// Peer Communication Tools
-// ─────────────────────────────────────────────────────────────────
-
-describe("Peer Communication Tools", () => {
-  let eventStore: EventStore;
-  let agentManager: AgentManager;
-  let taskManager: TaskManager;
-  let messageRouter: MessageRouter;
-  let context: ToolContext;
-
-  beforeEach(() => {
-    eventStore = createMockEventStore();
-    agentManager = createMockAgentManager();
-    taskManager = createMockTaskManager();
-    messageRouter = createMockMessageRouter();
-    context = createTestContext();
-  });
-
-  describe("check_messages with peer messages", () => {
-    it("should include peer messages when peerManager is provided", () => {
-      const mockPeerManager = {
-        hasTransport: vi.fn().mockReturnValue(true),
-        getPeerMessages: vi.fn().mockReturnValue([
-          {
-            id: "peer_msg_1",
-            from: "peer:other-agent",
-            type: "notification",
-            payload: { data: "test" },
-            timestamp: Date.now(),
-          },
-        ]),
-        sendMessage: vi.fn(),
-        sendRequest: vi.fn(),
-        respondToRequest: vi.fn(),
-        acknowledgePeerMessages: vi.fn(),
-        parseAddress: vi.fn(),
-        registerTransport: vi.fn(),
-      };
-
-      const services = {
-        eventStore,
-        agentManager,
-        taskManager,
-        messageRouter,
-        peerManager: mockPeerManager as any,
-      };
-
-      createMCPServer(context, services);
-
-      // Verify peerManager.getPeerMessages is called when check_messages would be invoked
-      mockPeerManager.getPeerMessages(context.agent_id);
-      expect(mockPeerManager.getPeerMessages).toHaveBeenCalledWith(context.agent_id);
-    });
-  });
-
-  describe("send_peer_message tool", () => {
-    it("should send message via peerManager", async () => {
-      const mockPeerManager = {
-        hasTransport: vi.fn().mockReturnValue(true),
-        sendMessage: vi.fn().mockResolvedValue(undefined),
-        sendRequest: vi.fn(),
-        respondToRequest: vi.fn(),
-        getPeerMessages: vi.fn().mockReturnValue([]),
-        acknowledgePeerMessages: vi.fn(),
-        parseAddress: vi.fn(),
-        registerTransport: vi.fn(),
-      };
-
-      const services = {
-        eventStore,
-        agentManager,
-        taskManager,
-        messageRouter,
-        peerManager: mockPeerManager as any,
-      };
-
-      createMCPServer(context, services);
-
-      // Call the peerManager directly to verify it would be called
-      await mockPeerManager.sendMessage(context.agent_id, "other-peer", {
-        type: "greeting",
-        payload: { text: "hello" },
-      });
-
-      expect(mockPeerManager.sendMessage).toHaveBeenCalledWith(
-        context.agent_id,
-        "other-peer",
-        expect.objectContaining({
-          type: "greeting",
-          payload: { text: "hello" },
-        })
-      );
-    });
-
-    it("should throw when no transport registered", () => {
-      const mockPeerManager = {
-        hasTransport: vi.fn().mockReturnValue(false),
-        sendMessage: vi.fn(),
-        sendRequest: vi.fn(),
-        respondToRequest: vi.fn(),
-        getPeerMessages: vi.fn().mockReturnValue([]),
-        acknowledgePeerMessages: vi.fn(),
-        parseAddress: vi.fn(),
-        registerTransport: vi.fn(),
-      };
-
-      const services = {
-        eventStore,
-        agentManager,
-        taskManager,
-        messageRouter,
-        peerManager: mockPeerManager as any,
-      };
-
-      createMCPServer(context, services);
-
-      // Verify hasTransport returns false
-      expect(mockPeerManager.hasTransport()).toBe(false);
-    });
-  });
-
-  describe("send_peer_request tool", () => {
-    it("should send request and return response", async () => {
-      const mockPeerManager = {
-        hasTransport: vi.fn().mockReturnValue(true),
-        sendMessage: vi.fn(),
-        sendRequest: vi.fn().mockResolvedValue({ result: 42 }),
-        respondToRequest: vi.fn(),
-        getPeerMessages: vi.fn().mockReturnValue([]),
-        acknowledgePeerMessages: vi.fn(),
-        parseAddress: vi.fn(),
-        registerTransport: vi.fn(),
-      };
-
-      const services = {
-        eventStore,
-        agentManager,
-        taskManager,
-        messageRouter,
-        peerManager: mockPeerManager as any,
-      };
-
-      createMCPServer(context, services);
-
-      const response = await mockPeerManager.sendRequest(context.agent_id, "other-peer", {
-        method: "calculate",
-        params: { x: 1, y: 2 },
-      });
-
-      expect(response).toEqual({ result: 42 });
-    });
-  });
-
-  describe("respond_to_peer_request tool", () => {
-    it("should respond to pending request", () => {
-      const mockPeerManager = {
-        hasTransport: vi.fn().mockReturnValue(true),
-        sendMessage: vi.fn(),
-        sendRequest: vi.fn(),
-        respondToRequest: vi.fn(),
-        getPeerMessages: vi.fn().mockReturnValue([]),
-        acknowledgePeerMessages: vi.fn(),
-        parseAddress: vi.fn(),
-        registerTransport: vi.fn(),
-      };
-
-      const services = {
-        eventStore,
-        agentManager,
-        taskManager,
-        messageRouter,
-        peerManager: mockPeerManager as any,
-      };
-
-      createMCPServer(context, services);
-
-      mockPeerManager.respondToRequest(context.agent_id, "req_123", {
-        result: "done",
-      });
-
-      expect(mockPeerManager.respondToRequest).toHaveBeenCalledWith(
-        context.agent_id,
-        "req_123",
-        { result: "done" }
-      );
-    });
-  });
-});