macro-agent 0.1.0 → 0.1.2

package/src/__tests__/e2e/full-agent-conflict-resolution.e2e.test.ts

@@ -687,8 +687,8 @@ Commit "Resolve conflict".
         // The agents are terminated manually because they don't autonomously call done()
         const allEvents = eventStore.query({});
         const spawnCount = allEvents.filter((e) => e.type === "spawn").length;
-        const terminateCount = allEvents.filter((e) => e.type === "terminate").length;
-        log(`✓ Events: ${spawnCount} spawns, ${terminateCount} terminates`);
+        const terminateCount = allEvents.filter((e) => e.type === "stop").length;
+        log(`✓ Events: ${spawnCount} spawns, ${terminateCount} stops`);
 
         expect(spawnCount).toBeGreaterThanOrEqual(3); // w1, w2, resolver
         expect(terminateCount).toBeGreaterThanOrEqual(3); // w1, w2, resolver

package/src/__tests__/e2e/mcp-thin-client-bridge.e2e.test.ts

@@ -0,0 +1,304 @@
+/**
+ * E2E Integration tests for MCP Thin-Client Bridge
+ *
+ * Starts a real combined server with real services, then uses mapCall()
+ * over WebSocket to verify the complete round-trip through MCP bridge
+ * extension handlers.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { createEventStore, type EventStore } from "../../store/event-store.js";
+import { createAgentManager, type AgentManager } from "../../agent/agent-manager.js";
+import { createTaskManager, type TaskManager } from "../../task/task-manager.js";
+import { createMessageRouter, type MessageRouter } from "../../router/message-router.js";
+import {
+  createCombinedServer,
+  type CombinedServer,
+} from "../../server/combined-server.js";
+import { mapCall, MapCallError } from "../../mcp/map-client.js";
+
+// =============================================================================
+// Test Helpers
+// =============================================================================
+
+function getRandomPort(): number {
+  return 10000 + Math.floor(Math.random() * 50000);
+}
+
+/**
+ * Valid agent context for bridge calls.
+ * Must match an agent that exists in EventStore.
+ */
+function agentContext(agentId: string, taskId?: string) {
+  return {
+    agent_id: agentId,
+    session_id: "sess_test",
+    task_id: taskId ?? "task_test",
+    lineage: [],
+    cwd: "/test/cwd",
+  };
+}
+
+// =============================================================================
+// Tests
+// =============================================================================
+
+describe("MCP Thin-Client Bridge E2E", () => {
+  let eventStore: EventStore;
+  let agentManager: AgentManager;
+  let taskManager: TaskManager;
+  let messageRouter: MessageRouter;
+  let server: CombinedServer;
+  let port: number;
+  let serverUrl: string;
+
+  beforeEach(async () => {
+    port = getRandomPort();
+    serverUrl = `http://localhost:${port}`;
+
+    // Create real services with in-memory EventStore
+    eventStore = await createEventStore({ inMemory: true });
+    messageRouter = createMessageRouter(eventStore);
+    agentManager = createAgentManager(eventStore, messageRouter, {
+      defaultPermissionMode: "auto-approve",
+      defaultCwd: "/test/cwd",
+    });
+    taskManager = createTaskManager(eventStore);
+
+    // Create and start combined server (includes MCP bridge registration)
+    server = createCombinedServer(
+      { eventStore, agentManager, taskManager, messageRouter },
+      { port, host: "localhost" }
+    );
+
+    await server.start();
+  });
+
+  afterEach(async () => {
+    await server.stop();
+    await agentManager.close();
+    await eventStore.close();
+  });
+
+  // ─────────────────────────────────────────────────────────────────
+  // emit_status round-trip
+  // ─────────────────────────────────────────────────────────────────
+
+  describe("emit_status round-trip", () => {
+    it("emits a status event via bridge and verifies it in EventStore", async () => {
+      // Seed an agent in the EventStore
+      eventStore.emit({
+        type: "spawn",
+        source: { agent_id: "system" },
+        payload: {
+          agent_id: "agent_e2e",
+          session_id: "sess_e2e",
+          task: "E2E test task",
+          task_id: "task_e2e",
+          parent: null,
+          config: {},
+          cwd: "/test/cwd",
+        },
+      });
+
+      const result = await mapCall<{ event_id: string; task_updated: boolean }>(
+        serverUrl,
+        "_macro/mcp/emit_status",
+        {
+          context: agentContext("agent_e2e", "task_e2e"),
+          status_type: "checkpoint",
+          summary: "50% complete",
+        }
+      );
+
+      expect(result.event_id).toBeDefined();
+      expect(result.task_updated).toBe(false);
+
+      // Verify the event was actually stored
+      const events = eventStore.query({
+        type: "status",
+        source_agent_id: "agent_e2e",
+      });
+      expect(events.length).toBeGreaterThanOrEqual(1);
+      expect(events[0].payload.summary).toBe("50% complete");
+    });
+  });
+
+  // ─────────────────────────────────────────────────────────────────
+  // query_index round-trip
+  // ─────────────────────────────────────────────────────────────────
+
+  describe("query_index round-trip", () => {
+    it("queries agents via bridge after seeding data", async () => {
+      // Seed agents
+      eventStore.emit({
+        type: "spawn",
+        source: { agent_id: "system" },
+        payload: {
+          agent_id: "agent_1",
+          session_id: "sess_1",
+          task: "First task",
+          task_id: "task_1",
+          parent: null,
+          config: {},
+          cwd: "/test",
+        },
+      });
+      eventStore.emit({
+        type: "spawn",
+        source: { agent_id: "system" },
+        payload: {
+          agent_id: "agent_2",
+          session_id: "sess_2",
+          task: "Second task",
+          task_id: "task_2",
+          parent: null,
+          config: {},
+          cwd: "/test",
+        },
+      });
+
+      const result = await mapCall<{
+        entries: Array<{ type: string; id: string; summary: string }>;
+        total: number;
+        has_more: boolean;
+      }>(serverUrl, "_macro/mcp/query_index", {
+        context: agentContext("agent_1"),
+        type: "agents",
+      });
+
+      expect(result.entries.length).toBeGreaterThanOrEqual(2);
+      expect(result.entries.some((e) => e.id === "agent_1")).toBe(true);
+      expect(result.entries.some((e) => e.id === "agent_2")).toBe(true);
+    });
+
+    it("queries tasks via bridge", async () => {
+      // Create a task
+      taskManager.create({
+        description: "E2E test task",
+        created_by: "agent_test",
+      });
+
+      const result = await mapCall<{
+        entries: Array<{ type: string; id: string; summary: string }>;
+        total: number;
+      }>(serverUrl, "_macro/mcp/query_index", {
+        context: agentContext("agent_test"),
+        type: "tasks",
+      });
+
+      expect(result.entries.length).toBeGreaterThanOrEqual(1);
+      expect(result.entries[0].type).toBe("task");
+    });
+  });
+
+  // ─────────────────────────────────────────────────────────────────
+  // send_message + check_messages round-trip
+  // ─────────────────────────────────────────────────────────────────
+
+  describe("send_message + check_messages round-trip", () => {
+    it("sends and receives a message via bridge", async () => {
+      // Seed two agents
+      eventStore.emit({
+        type: "spawn",
+        source: { agent_id: "system" },
+        payload: {
+          agent_id: "agent_sender",
+          session_id: "sess_sender",
+          task: "Sender task",
+          task_id: "task_sender",
+          parent: null,
+          config: {},
+          cwd: "/test",
+        },
+      });
+      eventStore.emit({
+        type: "spawn",
+        source: { agent_id: "system" },
+        payload: {
+          agent_id: "agent_receiver",
+          session_id: "sess_receiver",
+          task: "Receiver task",
+          task_id: "task_receiver",
+          parent: null,
+          config: {},
+          cwd: "/test",
+        },
+      });
+
+      // Subscribe receiver to their own address
+      eventStore.addSubscription("agent_receiver", "agent:agent_receiver");
+
+      // Send message via bridge
+      const sendResult = await mapCall<{ message_id: string; delivered_to: number }>(
+        serverUrl,
+        "_macro/mcp/send_message",
+        {
+          context: agentContext("agent_sender"),
+          to: { agent_id: "agent_receiver" },
+          content: "Hello from E2E test",
+        }
+      );
+
+      expect(sendResult.message_id).toBeDefined();
+      expect(sendResult.delivered_to).toBeGreaterThanOrEqual(1);
+
+      // Check messages via bridge
+      const checkResult = await mapCall<{
+        messages: Array<{ id: string; content: string; from: string }>;
+        total_pending: number;
+      }>(serverUrl, "_macro/mcp/check_messages", {
+        context: agentContext("agent_receiver"),
+      });
+
+      expect(checkResult.messages.length).toBeGreaterThanOrEqual(1);
+      expect(checkResult.messages.some((m) => m.content === "Hello from E2E test")).toBe(true);
+    });
+  });
+
+  // ─────────────────────────────────────────────────────────────────
+  // Context validation over the wire
+  // ─────────────────────────────────────────────────────────────────
+
+  describe("context validation over the wire", () => {
+    it("rejects calls without context", async () => {
+      try {
+        await mapCall(serverUrl, "_macro/mcp/query_index", { type: "agents" });
+        expect.fail("Should have thrown");
+      } catch (err) {
+        expect(err).toBeInstanceOf(MapCallError);
+        expect((err as MapCallError).message).toContain("agent_id is required");
+      }
+    });
+  });
+
+  // ─────────────────────────────────────────────────────────────────
+  // Error propagation
+  // ─────────────────────────────────────────────────────────────────
+
+  describe("error propagation", () => {
+    it("returns error for non-existent agent in get_agent_summary", async () => {
+      try {
+        await mapCall(serverUrl, "_macro/mcp/get_agent_summary", {
+          context: agentContext("agent_test"),
+          agent_id: "nonexistent_agent",
+        });
+        expect.fail("Should have thrown");
+      } catch (err) {
+        expect(err).toBeInstanceOf(MapCallError);
+        expect((err as MapCallError).message).toContain("not found");
+      }
+    });
+
+    it("returns error for non-existent extension method", async () => {
+      try {
+        await mapCall(serverUrl, "_macro/mcp/nonexistent_method", {
+          context: agentContext("agent_test"),
+        });
+        expect.fail("Should have thrown");
+      } catch (err) {
+        expect(err).toBeInstanceOf(MapCallError);
+      }
+    });
+  });
+});

package/src/__tests__/e2e/mcp-tools-available.e2e.test.ts

@@ -0,0 +1,324 @@
+/**
+ * MCP Tools Availability E2E Test
+ *
+ * Verifies that agents spawned through acp-factory have access to the
+ * macro-agent MCP tools. This tests the full chain:
+ *   agent-manager → acp-factory → claude-code-acp → Claude Agent SDK → MCP subprocess
+ *
+ * REQUIRES: RUN_FULL_AGENT_TESTS=true environment variable
+ *
+ * Run with:
+ *   RUN_FULL_AGENT_TESTS=true npm run test:e2e -- src/__tests__/e2e/mcp-tools-available.e2e.test.ts
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { execSync } from "child_process";
+
+import { createEventStore, type EventStore } from "../../store/event-store.js";
+import {
+  createAgentManager,
+  type AgentManager,
+} from "../../agent/agent-manager.js";
+import {
+  createMessageRouter,
+  type MessageRouter,
+} from "../../router/message-router.js";
+
+// ─────────────────────────────────────────────────────────────────
+// Test Configuration
+// ─────────────────────────────────────────────────────────────────
+
+const RUN_FULL_AGENT = !!process.env.RUN_FULL_AGENT_TESTS;
+const testFn = RUN_FULL_AGENT ? it : it.skip;
+
+// MCP server name as configured in agent-manager.ts
+const MCP_SERVER_NAME = "macro-agent";
+
+// Core coordination tools always registered for any agent role
+const EXPECTED_CORE_TOOLS = [
+  "done",
+  "spawn_agent",
+  "emit_status",
+  "send_message",
+  "check_messages",
+  "get_hierarchy",
+  "get_agent_summary",
+  "query_index",
+  "inject_context",
+  "wait_for_activity",
+];
+
+// Peer communication tools (registered when PeerManager is available)
+const PEER_TOOLS = [
+  "send_peer_message",
+  "send_peer_request",
+  "respond_to_peer_request",
+];
+
+// Role-gated tools that may not be available to all roles
+const ROLE_GATED_TOOLS = [
+  "stop_agent", // requires agent.terminate capability
+];
+
+// Task backend tools (memory backend, push mode) — registered via taskToolProvider
+const TASK_BACKEND_TOOLS = [
+  "create_task",
+  "get_task",
+  "list_tasks",
+  "assign_task",
+];
+
+/**
+ * Build the full MCP tool name as it appears in Claude Code.
+ * Format: mcp__<server-name>__<tool-name>
+ */
+function mcpToolName(tool: string): string {
+  return `mcp__${MCP_SERVER_NAME}__${tool}`;
+}
+
+// ─────────────────────────────────────────────────────────────────
+// Helpers
+// ─────────────────────────────────────────────────────────────────
+
+interface ToolCallInfo {
+  toolName: string;
+  toolCallId: string;
+  status: string;
+}
+
+/**
+ * Extract tool_call events from session update stream.
+ *
+ * Claude Code reports MCP tool usage via session updates:
+ *   { sessionUpdate: "tool_call", _meta: { claudeCode: { toolName } }, toolCallId, status }
+ */
+function extractToolCalls(updates: Record<string, unknown>[]): ToolCallInfo[] {
+  const calls: ToolCallInfo[] = [];
+  for (const update of updates) {
+    if (update.sessionUpdate === "tool_call") {
+      const meta = update._meta as
+        | { claudeCode?: { toolName?: string } }
+        | undefined;
+      const toolName = meta?.claudeCode?.toolName ?? (update as { title?: string }).title ?? "unknown";
+      calls.push({
+        toolName,
+        toolCallId: (update.toolCallId as string) ?? "",
+        status: (update.status as string) ?? "",
+      });
+    }
+  }
+  return calls;
+}
+
+// ─────────────────────────────────────────────────────────────────
+// Tests
+// ─────────────────────────────────────────────────────────────────
+
+describe("MCP Tools Availability", () => {
+  let eventStore: EventStore;
+  let agentManager: AgentManager;
+  let messageRouter: MessageRouter;
+  let tmpDir: string;
+  let testRepoPath: string;
+
+  beforeEach(async () => {
+    if (!RUN_FULL_AGENT) return;
+
+    // File-based EventStore so MCP subprocess can access the same database
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "mcp-tools-e2e-"));
+    const instanceId = `test-mcp-tools-${Date.now()}`;
+
+    // Isolated git repo for agent cwd
+    testRepoPath = path.join(tmpDir, "test-repo");
+    fs.mkdirSync(testRepoPath);
+    execSync("git init", { cwd: testRepoPath });
+    execSync('git config user.email "test@test.com"', { cwd: testRepoPath });
+    execSync('git config user.name "Test User"', { cwd: testRepoPath });
+    fs.writeFileSync(path.join(testRepoPath, "README.md"), "# Test Repo\n");
+    execSync("git add -A", { cwd: testRepoPath });
+    execSync('git commit -m "Initial commit"', { cwd: testRepoPath });
+
+    eventStore = await createEventStore({ instanceId, baseDir: tmpDir });
+    messageRouter = createMessageRouter(eventStore);
+    agentManager = createAgentManager(eventStore, messageRouter, {
+      defaultPermissionMode: "auto-approve",
+      defaultCwd: testRepoPath,
+    });
+  });
+
+  afterEach(async () => {
+    if (!RUN_FULL_AGENT) return;
+
+    // Terminate all running agents
+    try {
+      for (const agent of agentManager.list()) {
+        if (agent.state === "running") {
+          await agentManager.terminate(agent.id, "cancelled");
+        }
+      }
+    } catch {
+      // Ignore cleanup errors
+    }
+
+    await agentManager?.close();
+    await eventStore?.close();
+
+    if (tmpDir) {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  testFn(
+    "spawned agent can use macro-agent MCP tools (emit_status, check_messages, done)",
+    async () => {
+      // Spawn a worker agent
+      const spawnResult = await agentManager.spawn({
+        task: "Use MCP tools as instructed.",
+        role: "worker",
+        cwd: testRepoPath,
+      });
+
+      // Prompt the agent to call several MCP tools so we can observe tool_call events
+      const allUpdates: Record<string, unknown>[] = [];
+
+      for await (const update of agentManager.prompt(
+        spawnResult.id,
+        `You have access to MCP tools from the "macro-agent" server. Please do the following steps IN ORDER:
+
+1. Call emit_status with status_type "checkpoint" and summary "mcp tool verification"
+2. Call check_messages to check your inbox
+3. Call done with status "completed" and summary "all tools verified"
+
+Do these steps now. Do NOT do any other work.`,
+      )) {
+        allUpdates.push(update as Record<string, unknown>);
+      }
+
+      // Extract tool calls from the update stream
+      const toolCalls = extractToolCalls(allUpdates);
+      const toolNames = toolCalls.map((tc) => tc.toolName);
+
+      // Log for diagnostics
+      console.log(`\n[MCP Tools E2E] Total session updates: ${allUpdates.length}`);
+      console.log(`[MCP Tools E2E] Tool calls observed: ${toolCalls.length}`);
+      for (const tc of toolCalls) {
+        console.log(`  - ${tc.toolName} (status: ${tc.status})`);
+      }
+
+      // ── Assertions ──────────────────────────────────────────────
+
+      // Agent should have made at least one tool call
+      expect(toolCalls.length).toBeGreaterThan(0);
+
+      // Verify the tools used were macro-agent MCP tools
+      const macroAgentCalls = toolNames.filter((n) =>
+        n.startsWith(`mcp__${MCP_SERVER_NAME}__`),
+      );
+      expect(
+        macroAgentCalls.length,
+        "Expected at least one macro-agent MCP tool call",
+      ).toBeGreaterThan(0);
+
+      // Verify done() was called via MCP
+      expect(toolNames).toContain(mcpToolName("done"));
+
+      // Verify EventStore received the done event from MCP subprocess
+      await eventStore.reload();
+      const statusEvents = eventStore.query({ type: "status" });
+      const doneEvent = statusEvents.find(
+        (e) =>
+          e.source?.agent_id === spawnResult.id &&
+          e.payload?.status_type === "completed",
+      );
+      expect(doneEvent).toBeDefined();
+
+      // Terminate agent (may already be stopped from done())
+      const agent = agentManager.get(spawnResult.id);
+      if (agent?.state === "running") {
+        await agentManager.terminate(spawnResult.id, "completed");
+      }
+    },
+    { timeout: 120_000 },
+  );
+
+  testFn(
+    "spawned agent has all expected MCP tools registered",
+    async () => {
+      // Spawn a worker and ask it to list all its MCP tools by trying to use them.
+      // We verify the tool set by asking the agent to describe its mcp__macro-agent__ tools.
+      const spawnResult = await agentManager.spawn({
+        task: "Report on your available MCP tools.",
+        role: "worker",
+        cwd: testRepoPath,
+      });
+
+      let responseText = "";
+      const allUpdates: Record<string, unknown>[] = [];
+
+      for await (const update of agentManager.prompt(
+        spawnResult.id,
+        `List ALL tools you have that start with "mcp__macro-agent__".
+Just list them by name, one per line. Be exhaustive - include every single one.
+After listing them, call done() with status "completed".`,
+      )) {
+        const updateObj = update as Record<string, unknown>;
+        allUpdates.push(updateObj);
+
+        // Collect text response
+        if (updateObj.sessionUpdate === "agent_message_chunk") {
+          const content = updateObj.content as { type?: string; text?: string } | undefined;
+          if (content?.type === "text" && content?.text) {
+            responseText += content.text;
+          }
+        }
+      }
+
+      const toolCalls = extractToolCalls(allUpdates);
+      const toolNames = toolCalls.map((tc) => tc.toolName);
+
+      console.log(`\n[MCP Tools E2E] Agent response about tools:\n${responseText}`);
+      console.log(`\n[MCP Tools E2E] Tool calls made: ${toolNames.join(", ")}`);
+
+      // The response should mention macro-agent MCP tools
+      const responseLower = responseText.toLowerCase();
+      expect(
+        responseLower.includes("mcp__macro-agent__") || responseLower.includes("done"),
+        "Agent should mention macro-agent MCP tools in response",
+      ).toBe(true);
+
+      // Verify the core tools are mentioned in the response.
+      const mentionedCoreTools = EXPECTED_CORE_TOOLS.filter(
+        (tool) =>
+          responseLower.includes(mcpToolName(tool)) ||
+          responseLower.includes(tool),
+      );
+
+      console.log(
+        `[MCP Tools E2E] Core tools mentioned: ${mentionedCoreTools.length}/${EXPECTED_CORE_TOOLS.length}`,
+      );
+      console.log(`  Mentioned: ${mentionedCoreTools.join(", ")}`);
+      const missingCoreTools = EXPECTED_CORE_TOOLS.filter(
+        (t) => !mentionedCoreTools.includes(t),
+      );
+      if (missingCoreTools.length > 0) {
+        console.log(`  Missing: ${missingCoreTools.join(", ")}`);
+      }
+
+      // All core tools should be mentioned
+      expect(mentionedCoreTools.length).toBe(EXPECTED_CORE_TOOLS.length);
+
+      // done() should have been called
+      expect(toolNames).toContain(mcpToolName("done"));
+
+      // Terminate
+      const agent = agentManager.get(spawnResult.id);
+      if (agent?.state === "running") {
+        await agentManager.terminate(spawnResult.id, "completed");
+      }
+    },
+    { timeout: 120_000 },
+  );
+});

package/src/__tests__/e2e/multi-agent.e2e.test.ts

@@ -542,10 +542,10 @@ describe("Part 1: Multi-Agent Lifecycle E2E", () => {
           `✓ Grandchild state: ${grandchildAgent?.state}, reason: ${grandchildAgent?.stop_reason}`,
         );
 
-        // Verify terminate events
-        const terminateEvents = eventStore.query({ type: "terminate" });
+        // Verify stop events
+        const terminateEvents = eventStore.query({ type: "stop" });
         expect(terminateEvents.length).toBeGreaterThanOrEqual(3);
-        log(`✓ Terminate events: ${terminateEvents.length}`);
+        log(`✓ Stop events: ${terminateEvents.length}`);
       },
       { timeout: TIMEOUT.HIERARCHY },
     );
@@ -961,8 +961,8 @@ describe("Part 3: Event Storage E2E", () => {
         // Terminate agent
         await agentManager.terminate(headId, "completed");
 
-        // Verify terminate event
-        const terminateEvents = eventStore.query({ type: "terminate" });
+        // Verify stop event
+        const terminateEvents = eventStore.query({ type: "stop" });
         expect(terminateEvents.length).toBeGreaterThanOrEqual(1);
         const termEvent = terminateEvents.find(
           (e) => e.payload.agent_id === headId,