macro-agent 0.1.1 → 0.1.3

package/src/acp/__tests__/macro-agent.test.ts

@@ -1,1060 +1,349 @@
 /**
- * MacroAgent tests
+ * Tests for macro-agent ACP handler.
  *
- * Tests for the ACP-compliant MacroAgent class and its extension methods.
+ * Uses mocked V2 services to verify that ACP methods
+ * correctly dispatch to agentManager, inboxAdapter, tasksAdapter.
  */
 
 import { describe, it, expect, beforeEach, vi } from "vitest";
-import { MacroAgent } from "../macro-agent.js";
-import { SessionMapper } from "../session-mapper.js";
-import { ACPError } from "../types.js";
-import type { MacroAgentInitConfig, SubAgentConfig } from "../types.js";
+import { createMacroAgent } from "../macro-agent.js";
+import type { MacroAgentConfig } from "../macro-agent.js";
 import type { AgentSideConnection } from "@agentclientprotocol/sdk";
-import type { AgentManager } from "../../agent/agent-manager.js";
-import type { EventStore } from "../../store/event-store.js";
-import type { TaskManager } from "../../task/task-manager.js";
-import type { Agent, Task } from "../../store/types/index.js";
+import type { MacroAgentSystemV2 } from "../../boot-v2.js";
+import { ACPError } from "../types.js";
 
 // ─────────────────────────────────────────────────────────────────
-// Mock Setup
+// Mock Helpers
 // ─────────────────────────────────────────────────────────────────
 
-function createMockAgent(overrides: Partial<Agent> = {}): Agent {
-  return {
-    id: "agent-1",
-    session_id: "session-1",
-    state: "running",
-    task: "Test task",
-    task_id: "task-1",
-    parent: null,
-    lineage: [],
-    config: {},
-    cwd: "/test/working/dir",
-    created_at: Date.now(),
-    started_at: Date.now(),
-    ...overrides,
-  };
-}
-
-function createMockTask(overrides: Partial<Task> = {}): Task {
+function createMockSystem(): MacroAgentSystemV2 {
   return {
-    id: "task-1",
-    description: "Test task",
-    status: "in_progress",
-    created_by: "agent-1",
-    created_at: Date.now(),
-    ...overrides,
+    agentManager: {
+      getOrCreateHeadManager: vi.fn().mockResolvedValue({
+        id: "head-1",
+        session_id: "acp-session-1",
+        agent: { id: "head-1", role: "coordinator", state: "running" },
+        session: {},
+      }),
+      spawn: vi.fn().mockResolvedValue({
+        id: "worker-1",
+        session_id: "worker-session-1",
+        agent: { id: "worker-1", role: "worker", state: "running" },
+        session: {},
+      }),
+      get: vi.fn().mockReturnValue({
+        id: "agent-1",
+        role: "worker",
+        state: "running",
+      }),
+      prompt: vi.fn().mockReturnValue(
+        (async function* () {
+          yield {
+            sessionUpdate: "agent_message_chunk",
+            text: "Hello",
+            messageId: "msg-1",
+          };
+          yield {
+            sessionUpdate: "agent_message_chunk",
+            text: " World",
+            messageId: "msg-1",
+          };
+        })(),
+      ),
+      terminate: vi.fn().mockResolvedValue(undefined),
+      getHierarchy: vi.fn().mockReturnValue({
+        root: {
+          agent: { id: "head-1", role: "coordinator" },
+          children: [],
+        },
+        depth: 1,
+        totalAgents: 1,
+      }),
+      forkAgent: vi.fn().mockResolvedValue({
+        id: "fork-1",
+        session_id: "fork-session-1",
+        agent: { id: "fork-1", role: "worker", state: "running" },
+      }),
+      resume: vi.fn().mockResolvedValue({
+        id: "resumed-1",
+        session_id: "resumed-session-1",
+        agent: { id: "resumed-1", role: "worker", state: "running" },
+      }),
+      respondToPermission: vi.fn().mockReturnValue(true),
+      cancelPermission: vi.fn().mockReturnValue(true),
+      setPermissionMode: vi.fn().mockReturnValue(true),
+    } as any,
+    agentStore: {} as any,
+    inboxAdapter: {
+      checkInbox: vi.fn().mockResolvedValue([
+        { id: "msg-1", content: "Hello", from: "agent-1" },
+      ]),
+      readThread: vi.fn().mockResolvedValue([
+        { id: "msg-1", content: "Thread msg" },
+      ]),
+    } as any,
+    tasksAdapter: {
+      getTask: vi.fn().mockResolvedValue({
+        id: "task-1",
+        title: "Test task",
+        status: "open",
+      }),
+    } as any,
+    triggerSystem: {} as any,
+    controlServer: {} as any,
+    roleRegistry: {} as any,
+    controlSocketPath: "/tmp/test.sock",
+    shutdown: vi.fn(),
   };
 }
 
 function createMockConnection(): AgentSideConnection {
   return {
     sessionUpdate: vi.fn().mockResolvedValue(undefined),
-    requestPermission: vi.fn().mockResolvedValue({ outcome: "allow_once" }),
-    closed: Promise.resolve(),
-  } as unknown as AgentSideConnection;
-}
-
-function createMockAgentManager(): AgentManager {
-  const mockAgent = createMockAgent();
-
-  return {
-    spawn: vi.fn().mockResolvedValue({
-      id: "agent-new",
-      session_id: "session-new",
-      agent: createMockAgent({ id: "agent-new", session_id: "session-new" }),
-      session: {},
-    }),
-    get: vi.fn().mockReturnValue(mockAgent),
-    list: vi.fn().mockReturnValue([mockAgent]),
-    listHeadManagers: vi.fn().mockReturnValue([mockAgent]),
-    getChildren: vi.fn().mockReturnValue([]),
-    getHierarchy: vi.fn().mockReturnValue({
-      root: { agent: mockAgent, children: [] },
-      depth: 1,
-      totalAgents: 1,
-    }),
-    getOrCreateHeadManager: vi.fn().mockResolvedValue({
-      id: "head-manager",
-      session_id: "hm-session",
-      agent: createMockAgent({ id: "head-manager" }),
-      session: {},
-    }),
-    hasActiveSession: vi.fn().mockReturnValue(true),
-    resume: vi.fn().mockResolvedValue({
-      id: "agent-1",
-      session_id: "session-1",
-      agent: mockAgent,
-      session: {},
-    }),
-    terminate: vi.fn().mockResolvedValue(undefined),
-    prompt: vi.fn().mockReturnValue({
-      [Symbol.asyncIterator]: async function* () {
-        yield { sessionUpdate: "agent_message_chunk", textChunk: "Hello" };
-      },
-    }),
-    getSession: vi.fn().mockReturnValue(null),
-    onLifecycleEvent: vi.fn().mockReturnValue(() => {}),
-    close: vi.fn().mockResolvedValue(undefined),
-    respondToPermission: vi.fn().mockReturnValue(true),
-    cancelPermission: vi.fn().mockReturnValue(true),
-    forkAgent: vi.fn().mockResolvedValue({
-      id: "agent-forked",
-      session_id: "session-forked",
-      agent: createMockAgent({ id: "agent-forked", session_id: "session-forked" }),
-      session: { id: "provider-session-forked" },
-    }),
-  } as unknown as AgentManager;
-}
-
-function createMockEventStore(): EventStore {
-  return {
-    getAgent: vi.fn().mockReturnValue(createMockAgent()),
-    getTask: vi.fn().mockReturnValue(createMockTask()),
-    close: vi.fn().mockResolvedValue(undefined),
-  } as unknown as EventStore;
-}
-
-function createMockTaskManager(): TaskManager {
-  return {
-    get: vi.fn().mockReturnValue(createMockTask()),
-    list: vi.fn().mockReturnValue([createMockTask()]),
-    create: vi.fn().mockReturnValue(createMockTask()),
-  } as unknown as TaskManager;
+    signal: new AbortController().signal,
+  } as any;
 }
 
 // ─────────────────────────────────────────────────────────────────
 // Tests
 // ─────────────────────────────────────────────────────────────────
 
-describe("MacroAgent", () => {
-  let macroAgent: MacroAgent;
-  let mockConnection: AgentSideConnection;
-  let mockAgentManager: AgentManager;
-  let mockEventStore: EventStore;
-  let mockTaskManager: TaskManager;
+describe("createMacroAgent", () => {
+  let system: MacroAgentSystemV2;
+  let connection: AgentSideConnection;
+  let config: MacroAgentConfig;
 
   beforeEach(() => {
-    mockConnection = createMockConnection();
-    mockAgentManager = createMockAgentManager();
-    mockEventStore = createMockEventStore();
-    mockTaskManager = createMockTaskManager();
-
-    macroAgent = new MacroAgent(mockConnection, {
-      agentManager: mockAgentManager,
-      eventStore: mockEventStore,
-      taskManager: mockTaskManager,
-      defaultCwd: "/test/cwd",
-    });
+    system = createMockSystem();
+    connection = createMockConnection();
+    config = { system };
   });
 
-  describe("initialize", () => {
-    it("should return protocol version and capabilities", async () => {
-      const response = await macroAgent.initialize({
-        protocolVersion: 1,
-        clientCapabilities: {},
-      });
-
-      expect(response.protocolVersion).toBe(1);
-      expect(response.agentCapabilities?.loadSession).toBe(true);
-      expect(response.agentCapabilities?._meta?.extensions).toContain(
-        "_macro/spawnAgent"
-      );
-      expect(response.agentCapabilities?._meta?.extensions).toContain(
-        "_macro/resume"
-      );
-      expect(response.agentCapabilities?._meta?.agentType).toBe("macro-agent");
-    });
-
-    it("should read macroConfig from _meta", async () => {
-      const initConfig: MacroAgentInitConfig = {
-        defaultCwd: "/custom/cwd",
-        defaultSubAgentConfig: {
-          model: "claude-opus-4-20250514",
-          permissionMode: "auto-approve",
-        },
-      };
-
-      const response = await macroAgent.initialize({
-        protocolVersion: 1,
-        clientCapabilities: {},
-        _meta: { macroConfig: initConfig },
-      });
-
-      // Config should be echoed back in response
-      expect(response.agentCapabilities?._meta?.appliedConfig).toEqual(initConfig);
-
-      // Config should be stored
-      expect(macroAgent.getInitConfig()).toEqual(initConfig);
-    });
-
-    it("should apply defaultCwd from init config", async () => {
-      await macroAgent.initialize({
-        protocolVersion: 1,
-        clientCapabilities: {},
-        _meta: {
-          macroConfig: {
-            defaultCwd: "/init/config/cwd",
-          },
-        },
-      });
+  function createAgent() {
+    return createMacroAgent(connection, config);
+  }
 
-      // Now newSession should use the init config cwd
-      await macroAgent.newSession({});
-
-      expect(mockAgentManager.getOrCreateHeadManager).toHaveBeenCalledWith(
-        expect.objectContaining({
-          cwd: "/init/config/cwd",
-        })
-      );
-    });
+  // ── initialize ──────────────────────────────────────────────
 
-    it("should work without macroConfig", async () => {
-      const response = await macroAgent.initialize({
+  describe("initialize", () => {
+    it("should return protocol version and agent info", async () => {
+      const agent = createAgent();
+      const result = await agent.initialize({
         protocolVersion: 1,
-        clientCapabilities: {},
       });
 
-      expect(macroAgent.getInitConfig()).toEqual({});
-      expect(response.agentCapabilities?._meta?.appliedConfig).toEqual({});
+      expect(result.protocolVersion).toBe(1);
+      expect(result.agentInfo?.name).toBe("macro-agent");
+      expect(result.agentCapabilities?.loadSession).toBe(true);
     });
   });
 
+  // ── newSession ──────────────────────────────────────────────
+
   describe("newSession", () => {
-    it("should create a new session and map it", async () => {
-      const response = await macroAgent.newSession({
-        cwd: "/test/project",
+    it("should create head manager and return session ID", async () => {
+      const agent = createAgent();
+      const result = await agent.newSession({
+        cwd: "/tmp/test",
+        mcpServers: [],
       });
 
-      expect(response.sessionId).toBeDefined();
-      expect(mockAgentManager.getOrCreateHeadManager).toHaveBeenCalledWith(
-        expect.objectContaining({
-          cwd: "/test/project",
-          forceNew: true,
-        })
-      );
-    });
-
-    it("should use default cwd if not provided", async () => {
-      await macroAgent.newSession({});
-
-      expect(mockAgentManager.getOrCreateHeadManager).toHaveBeenCalledWith(
-        expect.objectContaining({
-          cwd: "/test/cwd",
-          forceNew: true,
-        })
-      );
-    });
-
-    it("should apply permissionMode from init config", async () => {
-      await macroAgent.initialize({
-        protocolVersion: 1,
-        clientCapabilities: {},
-        _meta: {
-          macroConfig: {
-            defaultSubAgentConfig: {
-              permissionMode: "auto-approve",
-            },
-          },
-        },
+      expect(result.sessionId).toBe("acp-session-1");
+      expect(system.agentManager.getOrCreateHeadManager).toHaveBeenCalledWith({
+        cwd: "/tmp/test",
       });
-
-      await macroAgent.newSession({});
-
-      expect(mockAgentManager.getOrCreateHeadManager).toHaveBeenCalledWith(
-        expect.objectContaining({
-          permissionMode: "auto-approve",
-        })
-      );
     });
+  });
 
-    it("should build system prompt from prefix and suffix", async () => {
-      await macroAgent.initialize({
-        protocolVersion: 1,
-        clientCapabilities: {},
-        _meta: {
-          macroConfig: {
-            systemPromptPrefix: "You are a specialized agent.",
-            systemPromptSuffix: "Always be helpful.",
-          },
-        },
-      });
+  // ── prompt ──────────────────────────────────────────────────
 
-      await macroAgent.newSession({});
+  describe("prompt", () => {
+    it("should stream updates from agentManager.prompt()", async () => {
+      const agent = createAgent();
 
-      expect(mockAgentManager.getOrCreateHeadManager).toHaveBeenCalledWith(
-        expect.objectContaining({
-          systemPrompt: "You are a specialized agent.\n\nAlways be helpful.",
-        })
-      );
-    });
+      // Create a session first
+      await agent.newSession({ cwd: "/tmp/test", mcpServers: [] });
 
-    it("should not set systemPrompt if no prefix/suffix configured", async () => {
-      await macroAgent.newSession({});
+      const result = await agent.prompt({
+        sessionId: "acp-session-1",
+        prompt: [{ type: "text", text: "Hello" } as any],
+      });
 
-      expect(mockAgentManager.getOrCreateHeadManager).toHaveBeenCalledWith(
-        expect.objectContaining({
-          systemPrompt: undefined,
-        })
+      expect(result.stopReason).toBe("end_turn");
+      expect(system.agentManager.prompt).toHaveBeenCalledWith(
+        "head-1",
+        "Hello",
       );
+      // sessionUpdate should be called for each yielded update
+      expect(connection.sessionUpdate).toHaveBeenCalledTimes(2);
     });
-  });
 
-  describe("authenticate", () => {
-    it("should return empty response (no auth required)", async () => {
-      const response = await macroAgent.authenticate({
-        methodId: "none",
-      });
+    it("should throw for unknown session", async () => {
+      const agent = createAgent();
 
-      expect(response).toEqual({});
-    });
-  });
-
-  describe("extMethod routing", () => {
-    it("should throw for unknown extension method", async () => {
       await expect(
-        macroAgent.extMethod("unknown/method", {})
-      ).rejects.toThrow(ACPError);
+        agent.prompt({
+          sessionId: "nonexistent",
+          prompt: [{ type: "text", text: "Hello" } as any],
+        }),
+      ).rejects.toThrow();
     });
   });
 
-  describe("_macro/spawnAgent", () => {
-    it("should spawn a new agent", async () => {
-      const response = await macroAgent.extMethod("macro/spawnAgent", {
-        task_description: "Test task",
-      });
-
-      expect(response).toHaveProperty("agentId");
-      expect(response).toHaveProperty("taskId");
-      expect(response).toHaveProperty("sessionId");
-      expect(mockAgentManager.spawn).toHaveBeenCalled();
-    });
+  // ── cancel ──────────────────────────────────────────────────
 
-    it("should use provided parentId", async () => {
-      await macroAgent.extMethod("macro/spawnAgent", {
-        task_description: "Test task",
-        parentId: "parent-agent",
-      });
-
-      expect(mockAgentManager.spawn).toHaveBeenCalledWith(
-        expect.objectContaining({
-          parent: "parent-agent",
-        })
-      );
-    });
-
-    it("should pass options through", async () => {
-      await macroAgent.extMethod("macro/spawnAgent", {
-        task_description: "Test task",
-        options: {
-          cwd: "/custom/cwd",
-          subscribeParent: false,
-          topics: ["topic1"],
-        },
-      });
-
-      expect(mockAgentManager.spawn).toHaveBeenCalledWith(
-        expect.objectContaining({
-          cwd: "/custom/cwd",
-          subscribeParent: false,
-          topics: ["topic1"],
-        })
-      );
-    });
-
-    it("should apply default config from init", async () => {
-      await macroAgent.initialize({
-        protocolVersion: 1,
-        clientCapabilities: {},
-        _meta: {
-          macroConfig: {
-            defaultSubAgentConfig: {
-              model: "claude-opus-4-20250514",
-              permissionMode: "auto-approve",
-              env: { DEBUG: "true" },
-            },
-          },
-        },
-      });
+  describe("cancel", () => {
+    it("should terminate the agent for the session", async () => {
+      const agent = createAgent();
+      await agent.newSession({ cwd: "/tmp/test", mcpServers: [] });
 
-      await macroAgent.extMethod("macro/spawnAgent", {
-        task_description: "Test task",
-      });
+      await agent.cancel({ sessionId: "acp-session-1" });
 
-      expect(mockAgentManager.spawn).toHaveBeenCalledWith(
-        expect.objectContaining({
-          permissionMode: "auto-approve",
-          config: expect.objectContaining({
-            model: "claude-opus-4-20250514",
-            env: { DEBUG: "true" },
-          }),
-        })
+      expect(system.agentManager.terminate).toHaveBeenCalledWith(
+        "head-1",
+        "cancelled",
       );
     });
+  });
 
-    it("should merge per-spawn config with defaults", async () => {
-      await macroAgent.initialize({
-        protocolVersion: 1,
-        clientCapabilities: {},
-        _meta: {
-          macroConfig: {
-            defaultSubAgentConfig: {
-              model: "claude-sonnet-4-20250514",
-              temperature: 0.7,
-              env: { DEBUG: "true", LOG_LEVEL: "info" },
-            },
-          },
-        },
-      });
+  // ── extMethod: _macro/spawnAgent ────────────────────────────
 
-      await macroAgent.extMethod("macro/spawnAgent", {
-        task_description: "Test task",
-        config: {
-          model: "claude-opus-4-20250514", // Override model
-          env: { LOG_LEVEL: "debug" }, // Override LOG_LEVEL, keep DEBUG
-        },
+  describe("extMethod: _macro/spawnAgent", () => {
+    it("should call agentManager.spawn with params", async () => {
+      const agent = createAgent();
+      const result = await agent.extMethod!("_macro/spawnAgent", {
+        task: "Do work",
+        role: "worker",
       });
 
-      expect(mockAgentManager.spawn).toHaveBeenCalledWith(
-        expect.objectContaining({
-          config: expect.objectContaining({
-            model: "claude-opus-4-20250514", // Overridden
-            temperature: 0.7, // From defaults
-            env: { DEBUG: "true", LOG_LEVEL: "debug" }, // Merged
-          }),
-        })
-      );
+      expect(result.agentId).toBe("worker-1");
+      expect(system.agentManager.spawn).toHaveBeenCalled();
     });
+  });
 
-    it("should concatenate MCP servers from defaults and override", async () => {
-      await macroAgent.initialize({
-        protocolVersion: 1,
-        clientCapabilities: {},
-        _meta: {
-          macroConfig: {
-            defaultSubAgentConfig: {
-              mcpServers: [
-                { name: "default-server", command: "npx", args: ["default"] },
-              ],
-            },
-          },
-        },
-      });
+  // ── extMethod: _macro/getHierarchy ──────────────────────────
 
-      await macroAgent.extMethod("macro/spawnAgent", {
-        task_description: "Test task",
-        config: {
-          mcpServers: [
-            { name: "custom-server", command: "npx", args: ["custom"] },
-          ],
-        },
+  describe("extMethod: _macro/getHierarchy", () => {
+    it("should return agent hierarchy", async () => {
+      const agent = createAgent();
+      const result = await agent.extMethod!("_macro/getHierarchy", {
+        agentId: "head-1",
       });
 
-      expect(mockAgentManager.spawn).toHaveBeenCalledWith(
-        expect.objectContaining({
-          config: expect.objectContaining({
-            mcpServers: [
-              { name: "default-server", command: "npx", args: ["default"] },
-              { name: "custom-server", command: "npx", args: ["custom"] },
-            ],
-          }),
-        })
+      expect(result.hierarchy).toBeDefined();
+      expect(system.agentManager.getHierarchy).toHaveBeenCalledWith(
+        "head-1",
+        { depth: undefined },
       );
     });
+  });
 
-    it("should pass agentType from config", async () => {
-      await macroAgent.extMethod("macro/spawnAgent", {
-        task_description: "Test task",
-        config: {
-          agentType: "custom-agent",
-        },
-      });
+  // ── extMethod: _macro/mountAgent ────────────────────────────
 
-      expect(mockAgentManager.spawn).toHaveBeenCalledWith(
-        expect.objectContaining({
-          agentType: "custom-agent",
-        })
-      );
-    });
+  describe("extMethod: _macro/mountAgent", () => {
+    it("should switch session to a different agent", async () => {
+      const agent = createAgent();
+      await agent.newSession({ cwd: "/tmp/test", mcpServers: [] });
 
-    it("should work with no config at all", async () => {
-      await macroAgent.extMethod("macro/spawnAgent", {
-        task_description: "Test task",
+      const result = await agent.extMethod!("_macro/mountAgent", {
+        sessionId: "acp-session-1",
+        agentId: "agent-1",
       });
 
-      expect(mockAgentManager.spawn).toHaveBeenCalledWith(
-        expect.objectContaining({
-          task: "Test task",
-          config: undefined,
-          permissionMode: undefined,
-          agentType: undefined,
-        })
-      );
+      expect(result.mounted).toBe(true);
+      expect(result.agentId).toBe("agent-1");
+      expect(result.previousAgentId).toBe("head-1");
     });
   });
 
-  describe("_macro/getHierarchy", () => {
-    it("should return hierarchy for default root", async () => {
-      const response = await macroAgent.extMethod("macro/getHierarchy", {});
+  // ── extMethod: _macro/forkAgent ─────────────────────────────
 
-      expect(response).toHaveProperty("hierarchy");
-      expect(response).toHaveProperty("totalAgents");
-      expect(response).toHaveProperty("depth");
-    });
-
-    it("should return hierarchy for specific agent", async () => {
-      await macroAgent.extMethod("macro/getHierarchy", {
-        rootAgentId: "agent-1",
+  describe("extMethod: _macro/forkAgent", () => {
+    it("should create a forked agent", async () => {
+      const agent = createAgent();
+      const result = await agent.extMethod!("_macro/forkAgent", {
+        sourceAgentId: "head-1",
       });
 
-      expect(mockAgentManager.getHierarchy).toHaveBeenCalledWith("agent-1");
-    });
-
-    it("should throw for non-existent agent", async () => {
-      vi.mocked(mockAgentManager.getHierarchy).mockReturnValue(null);
-
-      await expect(
-        macroAgent.extMethod("macro/getHierarchy", {
-          rootAgentId: "non-existent",
-        })
-      ).rejects.toThrow(ACPError);
-    });
-
-    it("should return empty hierarchy when no agents exist", async () => {
-      vi.mocked(mockAgentManager.listHeadManagers).mockReturnValue([]);
-
-      const response = await macroAgent.extMethod("macro/getHierarchy", {});
-
-      expect(response.totalAgents).toBe(0);
-      expect(response.depth).toBe(0);
-    });
-  });
-
-  describe("_macro/getTask", () => {
-    it("should return task details", async () => {
-      const response = await macroAgent.extMethod("macro/getTask", {
-        taskId: "task-1",
+      expect(result.agentId).toBe("fork-1");
+      expect(system.agentManager.forkAgent).toHaveBeenCalledWith("head-1", {
+        name: undefined,
+        prompt: undefined,
+        cwd: undefined,
       });
-
-      expect(response).toHaveProperty("task");
-      expect(mockTaskManager.get).toHaveBeenCalledWith("task-1");
-    });
-
-    it("should throw for non-existent task", async () => {
-      vi.mocked(mockTaskManager.get).mockReturnValue(null);
-
-      await expect(
-        macroAgent.extMethod("macro/getTask", {
-          taskId: "non-existent",
-        })
-      ).rejects.toThrow(ACPError);
     });
   });
 
-  describe("_macro/mountAgent", () => {
-    beforeEach(async () => {
-      // Create a session first
-      await macroAgent.newSession({ cwd: "/test" });
-    });
-
-    it("should mount to an existing agent", async () => {
-      // Get the session ID from the mapper
-      const sessionMapper = macroAgent.getSessionMapper();
-      const mappings = sessionMapper.getAllMappings();
-      const sessionId = mappings[0]?.acpSessionId;
+  // ── extMethod: _macro/getTask ───────────────────────────────
 
-      const response = await macroAgent.extMethod("macro/mountAgent", {
-        sessionId,
-        agentId: "agent-1",
+  describe("extMethod: _macro/getTask", () => {
+    it("should return task from tasks adapter", async () => {
+      const agent = createAgent();
+      const result = await agent.extMethod!("_macro/getTask", {
+        taskId: "task-1",
       });
 
-      expect(response).toHaveProperty("sessionId", sessionId);
-      expect(response).toHaveProperty("agent");
-      expect(response).toHaveProperty("previousAgentId");
-    });
-
-    it("should throw for non-existent agent", async () => {
-      vi.mocked(mockAgentManager.get).mockReturnValue(null);
-
-      const sessionMapper = macroAgent.getSessionMapper();
-      const mappings = sessionMapper.getAllMappings();
-      const sessionId = mappings[0]?.acpSessionId;
-
-      await expect(
-        macroAgent.extMethod("macro/mountAgent", {
-          sessionId,
-          agentId: "non-existent",
-        })
-      ).rejects.toThrow(ACPError);
-    });
-
-    it("should throw for non-existent session", async () => {
-      await expect(
-        macroAgent.extMethod("macro/mountAgent", {
-          sessionId: "non-existent-session",
-          agentId: "agent-1",
-        })
-      ).rejects.toThrow(ACPError);
-    });
-
-    it("should update session mapping", async () => {
-      const sessionMapper = macroAgent.getSessionMapper();
-      const mappings = sessionMapper.getAllMappings();
-      const sessionId = mappings[0]?.acpSessionId;
-
-      await macroAgent.extMethod("macro/mountAgent", {
-        sessionId,
-        agentId: "agent-1",
+      expect(result.task).toEqual({
+        id: "task-1",
+        title: "Test task",
+        status: "open",
       });
-
-      expect(sessionMapper.getAgentId(sessionId)).toBe("agent-1");
-      expect(sessionMapper.isMounted(sessionId)).toBe(true);
     });
   });
 
-  describe("_macro/forkAgent", () => {
-    it("should fork an existing agent", async () => {
-      const response = await macroAgent.extMethod("macro/forkAgent", {
-        agentId: "agent-1",
-      });
-
-      expect(response).toHaveProperty("newAgentId", "agent-forked");
-      expect(response).toHaveProperty("newSessionId", "session-forked");
-      expect(response).toHaveProperty("originalAgentId", "agent-1");
-      expect(response).toHaveProperty("providerSessionId", "provider-session-forked");
-      expect(mockAgentManager.forkAgent).toHaveBeenCalledWith("agent-1", expect.any(Object));
-    });
-
-    it("should pass custom name to forkAgent", async () => {
-      await macroAgent.extMethod("macro/forkAgent", {
-        agentId: "agent-1",
-        name: "Custom fork name",
-      });
-
-      expect(mockAgentManager.forkAgent).toHaveBeenCalledWith(
-        "agent-1",
-        expect.objectContaining({
-          name: "Custom fork name",
-        })
-      );
-    });
+  // ── extMethod: peer methods → NO_PEER_MANAGER ──────────────
 
-    it("should throw for non-existent agent", async () => {
-      vi.mocked(mockAgentManager.get).mockReturnValue(null);
+  describe("extMethod: peer methods", () => {
+    it("should throw NO_PEER_MANAGER for stubbed peer methods", async () => {
+      const agent = createAgent();
 
       await expect(
-        macroAgent.extMethod("macro/forkAgent", {
-          agentId: "non-existent",
-        })
+        agent.extMethod!("_macro/listPeers", {}),
       ).rejects.toThrow(ACPError);
-    });
-
-    it("should throw if agent has no active session and no provider_session_id", async () => {
-      vi.mocked(mockAgentManager.hasActiveSession).mockReturnValue(false);
-      // Default mock agent has no provider_session_id
 
-      await expect(
-        macroAgent.extMethod("macro/forkAgent", {
-          agentId: "agent-1",
-        })
-      ).rejects.toThrow(ACPError);
-    });
-  });
-
-  // ─────────────────────────────────────────────────────────────────
-  // Peer Communication Extension Tests
-  // ─────────────────────────────────────────────────────────────────
-
-  describe("_macro/sendPeerMessage", () => {
-    it("should throw when no PeerManager configured", async () => {
-      // macroAgent doesn't have a PeerManager configured
-      await expect(
-        macroAgent.extMethod("macro/sendPeerMessage", {
-          to: "other-peer",
-          type: "greeting",
-          payload: { text: "hello" },
-        })
-      ).rejects.toThrow(ACPError);
+      try {
+        await agent.extMethod!("_macro/listPeers", {});
+      } catch (err) {
+        expect((err as ACPError).code).toBe("NO_PEER_MANAGER");
+      }
     });
   });
 
-  describe("_macro/sendPeerRequest", () => {
-    it("should throw when no PeerManager configured", async () => {
-      await expect(
-        macroAgent.extMethod("macro/sendPeerRequest", {
-          to: "other-peer",
-          method: "calculate",
-          params: { x: 1 },
-        })
-      ).rejects.toThrow(ACPError);
-    });
-  });
+  // ── extMethod: unknown extension ────────────────────────────
 
-  describe("_macro/deliverPeerMessage", () => {
-    it("should throw when no PeerManager configured", async () => {
-      await expect(
-        macroAgent.extMethod("macro/deliverPeerMessage", {
-          from: "other-peer",
-          type: "notification",
-          payload: { data: "test" },
-        })
-      ).rejects.toThrow(ACPError);
-    });
-  });
+  describe("extMethod: unknown extension", () => {
+    it("should throw INVALID_EXTENSION for unknown methods", async () => {
+      const agent = createAgent();
 
-  describe("_macro/deliverPeerRequest", () => {
-    it("should throw when no PeerManager configured", async () => {
       await expect(
-        macroAgent.extMethod("macro/deliverPeerRequest", {
-          from: "other-peer",
-          method: "compute",
-          params: {},
-        })
+        agent.extMethod!("_macro/nonexistent", {}),
       ).rejects.toThrow(ACPError);
-    });
-  });
 
-  describe("getSessionMapper", () => {
-    it("should return the session mapper", () => {
-      const mapper = macroAgent.getSessionMapper();
-      expect(mapper).toBeInstanceOf(SessionMapper);
+      try {
+        await agent.extMethod!("_macro/nonexistent", {});
+      } catch (err) {
+        expect((err as ACPError).code).toBe("INVALID_EXTENSION");
+      }
     });
   });
 
-  describe("getMappedAgentId", () => {
-    it("should return undefined for non-existent session", () => {
-      const agentId = macroAgent.getMappedAgentId("non-existent");
-      expect(agentId).toBeUndefined();
-    });
-
-    it("should return agent ID for existing session", async () => {
-      await macroAgent.newSession({ cwd: "/test" });
-      const mapper = macroAgent.getSessionMapper();
-      const mappings = mapper.getAllMappings();
-      const sessionId = mappings[0]?.acpSessionId;
+  // ── extMethod: _macro/respondToPermission ───────────────────
 
-      const agentId = macroAgent.getMappedAgentId(sessionId);
-      expect(agentId).toBeDefined();
-    });
-  });
-
-  describe("getInitConfig", () => {
-    it("should return empty config by default", () => {
-      const config = macroAgent.getInitConfig();
-      expect(config).toEqual({});
-    });
-
-    it("should return stored config after initialize", async () => {
-      const initConfig: MacroAgentInitConfig = {
-        defaultCwd: "/custom/path",
-        systemPromptPrefix: "Test prefix",
-        defaultSubAgentConfig: {
-          model: "claude-opus-4-20250514",
-          permissionMode: "auto-approve",
-          mcpServers: [{ name: "test", command: "test-cmd" }],
-        },
-      };
-
-      await macroAgent.initialize({
-        protocolVersion: 1,
-        clientCapabilities: {},
-        _meta: { macroConfig: initConfig },
-      });
-
-      const config = macroAgent.getInitConfig();
-      expect(config).toEqual(initConfig);
-    });
-  });
-
-  // ─────────────────────────────────────────────────────────────────
-  // Permission Extension Tests
-  // ─────────────────────────────────────────────────────────────────
-
-  describe("_macro/respondToPermission", () => {
-    it("should respond to permission via AgentManager", async () => {
-      // Create a session first to map sessionId to agentId
-      await macroAgent.newSession({ cwd: "/test" });
-      const mapper = macroAgent.getSessionMapper();
-      const mappings = mapper.getAllMappings();
-      const sessionId = mappings[0]?.acpSessionId;
-
-      const response = await macroAgent.extMethod("macro/respondToPermission", {
-        sessionId,
-        requestId: "perm-req-123",
-        optionId: "allow_once",
-      });
-
-      expect(response).toEqual({ success: true });
-      expect(mockAgentManager.respondToPermission).toHaveBeenCalledWith(
-        expect.any(String), // agentId
-        "perm-req-123",
-        "allow_once"
-      );
-    });
-
-    it("should return error when no agent found for session", async () => {
-      const response = await macroAgent.extMethod("macro/respondToPermission", {
-        sessionId: "non-existent-session",
-        requestId: "perm-req-123",
-        optionId: "allow_once",
-      });
-
-      expect(response).toEqual({
-        success: false,
-        error: expect.stringContaining("No agent found for session"),
-      });
-    });
-
-    it("should return error when permission response fails", async () => {
-      // Create a session first
-      await macroAgent.newSession({ cwd: "/test" });
-      const mapper = macroAgent.getSessionMapper();
-      const mappings = mapper.getAllMappings();
-      const sessionId = mappings[0]?.acpSessionId;
-
-      // Make respondToPermission return false
-      vi.mocked(mockAgentManager.respondToPermission).mockReturnValue(false);
-
-      const response = await macroAgent.extMethod("macro/respondToPermission", {
-        sessionId,
-        requestId: "invalid-req",
+  describe("extMethod: _macro/respondToPermission", () => {
+    it("should call agentManager.respondToPermission", async () => {
+      const agent = createAgent();
+      const result = await agent.extMethod!("_macro/respondToPermission", {
+        agentId: "agent-1",
+        requestId: "req-1",
         optionId: "allow_once",
       });
 
-      expect(response).toEqual({
-        success: false,
-        error: expect.stringContaining("Failed to respond to permission"),
-      });
-    });
-  });
-
-  describe("_macro/cancelPermission", () => {
-    it("should cancel permission via AgentManager", async () => {
-      // Create a session first to map sessionId to agentId
-      await macroAgent.newSession({ cwd: "/test" });
-      const mapper = macroAgent.getSessionMapper();
-      const mappings = mapper.getAllMappings();
-      const sessionId = mappings[0]?.acpSessionId;
-
-      const response = await macroAgent.extMethod("macro/cancelPermission", {
-        sessionId,
-        requestId: "perm-req-123",
-      });
-
-      expect(response).toEqual({ success: true });
-      expect(mockAgentManager.cancelPermission).toHaveBeenCalledWith(
-        expect.any(String), // agentId
-        "perm-req-123"
-      );
-    });
-
-    it("should return error when no agent found for session", async () => {
-      const response = await macroAgent.extMethod("macro/cancelPermission", {
-        sessionId: "non-existent-session",
-        requestId: "perm-req-123",
-      });
-
-      expect(response).toEqual({
-        success: false,
-        error: expect.stringContaining("No agent found for session"),
-      });
-    });
-
-    it("should return error when permission cancellation fails", async () => {
-      // Create a session first
-      await macroAgent.newSession({ cwd: "/test" });
-      const mapper = macroAgent.getSessionMapper();
-      const mappings = mapper.getAllMappings();
-      const sessionId = mappings[0]?.acpSessionId;
-
-      // Make cancelPermission return false
-      vi.mocked(mockAgentManager.cancelPermission).mockReturnValue(false);
-
-      const response = await macroAgent.extMethod("macro/cancelPermission", {
-        sessionId,
-        requestId: "invalid-req",
-      });
-
-      expect(response).toEqual({
-        success: false,
-        error: expect.stringContaining("Failed to cancel permission"),
-      });
-    });
-  });
-
-  // ─────────────────────────────────────────────────────────────────
-  // _macro/resume Tests
-  // ─────────────────────────────────────────────────────────────────
-
-  describe("_macro/resume", () => {
-    it("should resume a stopped agent", async () => {
-      const stoppedAgent = createMockAgent({
-        id: "agent-stopped",
-        state: "stopped",
-        session_id: "session-stopped",
-      });
-      vi.mocked(mockEventStore.getAgent).mockReturnValue(stoppedAgent);
-      vi.mocked(mockAgentManager.resume).mockResolvedValue({
-        id: "agent-stopped",
-        session_id: "session-stopped",
-        agent: stoppedAgent,
-        session: {},
-      } as any);
-
-      const result = await macroAgent.extMethod("_macro/resume", {
-        agentId: "agent-stopped",
-      });
-
-      expect(mockAgentManager.resume).toHaveBeenCalledWith("agent-stopped");
-      expect(result).toEqual({
-        success: true,
-        agentId: "agent-stopped",
-        sessionId: "session-stopped",
-      });
-    });
-
-    it("should resume a failed agent", async () => {
-      const failedAgent = createMockAgent({
-        id: "agent-failed",
-        state: "failed",
-        session_id: "session-failed",
-      });
-      vi.mocked(mockEventStore.getAgent).mockReturnValue(failedAgent);
-      vi.mocked(mockAgentManager.resume).mockResolvedValue({
-        id: "agent-failed",
-        session_id: "session-failed",
-        agent: failedAgent,
-        session: {},
-      } as any);
-
-      const result = await macroAgent.extMethod("_macro/resume", {
-        agentId: "agent-failed",
-      });
-
-      expect(mockAgentManager.resume).toHaveBeenCalledWith("agent-failed");
-      expect(result).toHaveProperty("success", true);
-    });
-
-    it("should throw for missing agentId", async () => {
-      await expect(
-        macroAgent.extMethod("_macro/resume", {})
-      ).rejects.toThrow("agentId is required");
-    });
-
-    it("should throw for non-existent agent", async () => {
-      vi.mocked(mockEventStore.getAgent).mockReturnValue(undefined as any);
-
-      await expect(
-        macroAgent.extMethod("_macro/resume", { agentId: "missing" })
-      ).rejects.toThrow("Agent not found");
-    });
-
-    it("should throw for running agent", async () => {
-      const runningAgent = createMockAgent({
-        id: "agent-running",
-        state: "running",
-      });
-      vi.mocked(mockEventStore.getAgent).mockReturnValue(runningAgent);
-
-      await expect(
-        macroAgent.extMethod("_macro/resume", { agentId: "agent-running" })
-      ).rejects.toThrow("only stopped or failed");
-    });
-
-    it("should throw for sleeping agent", async () => {
-      const sleepingAgent = createMockAgent({
-        id: "agent-sleeping",
-        state: "sleeping",
-      });
-      vi.mocked(mockEventStore.getAgent).mockReturnValue(sleepingAgent);
-
-      await expect(
-        macroAgent.extMethod("_macro/resume", { agentId: "agent-sleeping" })
-      ).rejects.toThrow("only stopped or failed");
-    });
-  });
-
-  // ─────────────────────────────────────────────────────────────────
-  // Cancel Tests
-  // ─────────────────────────────────────────────────────────────────
-
-  describe("cancel", () => {
-    it("should abort cancellation controller and terminate agent", async () => {
-      // Create a session first
-      await macroAgent.newSession({ cwd: "/test" });
-      const mapper = macroAgent.getSessionMapper();
-      const mappings = mapper.getAllMappings();
-      const sessionId = mappings[0]?.acpSessionId;
-
-      // Cancel the session
-      await macroAgent.cancel({ sessionId });
-
-      // Verify agentManager.terminate was called with correct args
-      expect(mockAgentManager.terminate).toHaveBeenCalledWith(
-        expect.any(String), // agentId
-        "cancelled"
-      );
-    });
-
-    it("should clean up session mapping after cancel", async () => {
-      // Create a session first
-      await macroAgent.newSession({ cwd: "/test" });
-      const mapper = macroAgent.getSessionMapper();
-      const mappings = mapper.getAllMappings();
-      const sessionId = mappings[0]?.acpSessionId;
-
-      // Verify mapping exists
-      expect(mapper.getAgentId(sessionId)).toBeDefined();
-
-      // Cancel the session
-      await macroAgent.cancel({ sessionId });
-
-      // Verify mapping was removed
-      expect(mapper.getAgentId(sessionId)).toBeUndefined();
-    });
-
-    it("should handle cancel when no agent is mapped", async () => {
-      // Cancel with non-existent session - should not throw
-      await expect(
-        macroAgent.cancel({ sessionId: "non-existent-session" })
-      ).resolves.not.toThrow();
-
-      // terminate should not have been called
-      expect(mockAgentManager.terminate).not.toHaveBeenCalled();
-    });
-
-    it("should handle terminate errors gracefully", async () => {
-      // Create a session first
-      await macroAgent.newSession({ cwd: "/test" });
-      const mapper = macroAgent.getSessionMapper();
-      const mappings = mapper.getAllMappings();
-      const sessionId = mappings[0]?.acpSessionId;
-
-      // Make terminate throw an error (e.g., agent already stopped)
-      vi.mocked(mockAgentManager.terminate).mockRejectedValueOnce(
-        new Error("Agent not found")
+      expect(result.success).toBe(true);
+      expect(system.agentManager.respondToPermission).toHaveBeenCalledWith(
+        "agent-1",
+        "req-1",
+        "allow_once",
       );
-
-      // Cancel should not throw even if terminate fails
-      await expect(macroAgent.cancel({ sessionId })).resolves.not.toThrow();
-
-      // Mapping should still be cleaned up
-      expect(mapper.getAgentId(sessionId)).toBeUndefined();
-    });
-
-    it("should abort the cancellation controller signal", async () => {
-      // Create a session first
-      await macroAgent.newSession({ cwd: "/test" });
-      const mapper = macroAgent.getSessionMapper();
-      const mappings = mapper.getAllMappings();
-      const sessionId = mappings[0]?.acpSessionId;
-
-      // Get access to cancellation controllers (private but we can test behavior)
-      // Cancel the session
-      await macroAgent.cancel({ sessionId });
-
-      // The agent manager terminate should be called, which proves the flow worked
-      expect(mockAgentManager.terminate).toHaveBeenCalled();
     });
   });
 });