macro-agent 0.2.5 → 0.2.6

package/src/__tests__/e2e/swarmkit-live.e2e.test.ts

@@ -1,1049 +0,0 @@
-/**
- * Swarmkit Live Agent E2E Tests
- *
- * Verifies swarmkit integrations end-to-end with REAL Claude Code agents:
- *   1. Trajectory checkpoints are enriched properly (fields, sync-level gating)
- *   2. Sync-level gating (lifecycle vs full)
- *   3. Context injection with live agents (system prompt sections)
- *   4. Tool call detection (files_touched tracking)
- *   5. Session end checkpoint (final checkpoint on terminate)
- *   6. Agent state transitions (busy during prompt, idle after)
- *
- * REQUIRES: RUN_FULL_AGENT_TESTS=true
- * REQUIRES: Claude Code CLI installed and API access configured
- *
- * Run:
- *   RUN_FULL_AGENT_TESTS=true npx vitest run --config vitest.e2e.config.ts src/__tests__/e2e/swarmkit-live.e2e.test.ts
- */
-
-import { describe, it, expect, beforeAll, afterAll } from "vitest";
-import * as fs from "fs";
-import * as path from "path";
-import * as os from "os";
-import { execSync } from "child_process";
-import { bootV2, type MacroAgentSystemV2 } from "../../boot-v2.js";
-import {
-  ClientConnection,
-  createACPStream,
-} from "@multi-agent-protocol/sdk";
-
-// =============================================================================
-// Configuration
-// =============================================================================
-
-const IS_LIVE = process.env.RUN_FULL_AGENT_TESTS === "true";
-const describeLive = IS_LIVE ? describe : describe.skip;
-
-const TIMEOUT = {
-  SETUP: 30_000,
-  PROMPT: 120_000,
-  SETTLE: 2_000,
-};
-
-function log(msg: string): void {
-  console.log(`[swarmkit-live] ${msg}`);
-}
-
-// =============================================================================
-// Helpers
-// =============================================================================
-
-/**
- * Create a temp directory with an initialized git repo (needed for branch
- * detection and sessionlog state paths).
- */
-function createTestRepo(prefix: string): string {
-  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), `swarmkit-live-${prefix}-`));
-  const repoPath = path.join(tmpDir, "test-repo");
-  fs.mkdirSync(repoPath, { recursive: true });
-  execSync("git init", { cwd: repoPath, stdio: "pipe" });
-  execSync('git config user.email "test@test.com"', { cwd: repoPath, stdio: "pipe" });
-  execSync('git config user.name "Test User"', { cwd: repoPath, stdio: "pipe" });
-  fs.writeFileSync(path.join(repoPath, "README.md"), "# Swarmkit Live Test\n");
-  execSync("git add -A", { cwd: repoPath, stdio: "pipe" });
-  execSync('git commit -m "Initial commit"', { cwd: repoPath, stdio: "pipe" });
-  return repoPath;
-}
-
-/** Wait for async operations to settle */
-const settle = (ms = TIMEOUT.SETTLE) => new Promise((r) => setTimeout(r, ms));
-
-/**
- * Create an ACP stream connected to the first available agent, pre-spawning
- * a head manager to avoid the 30s MAP send timeout on newSession().
- */
-async function setupACPStream(
-  client: ClientConnection,
-  testDir: string,
-  opts?: { timeout?: number },
-): Promise<{
-  acpStream: ReturnType<typeof createACPStream>;
-  sessionId: string;
-  sessionUpdates: any[];
-}> {
-  const sessionUpdates: any[] = [];
-
-  // Pre-spawn a head manager via extension (avoids MAP send timeout)
-  log("Pre-spawning head manager...");
-  await client.callExtension("_macro/spawnAgent", {
-    task: "Head manager for swarmkit test",
-    role: "coordinator",
-  });
-  await settle();
-
-  // Get target agent
-  const agents = await client.listAgents();
-  expect(agents.agents.length).toBeGreaterThan(0);
-  const targetAgent = agents.agents[0].id;
-  log(`Target agent: ${targetAgent}`);
-
-  const acpStream = createACPStream(client, {
-    targetAgent,
-    timeout: opts?.timeout ?? TIMEOUT.PROMPT,
-    client: {
-      requestPermission: async () =>
-        ({ outcome: { outcome: "allow" } }) as any,
-      sessionUpdate: async (update: any) => {
-        sessionUpdates.push(update);
-      },
-    },
-  });
-
-  // Initialize
-  const initResult = await acpStream.initialize({
-    protocolVersion: 1,
-    clientInfo: { name: "Swarmkit Live E2E", version: "1.0.0" },
-  });
-  expect(initResult).toBeDefined();
-
-  // Create session (reuses pre-spawned head manager)
-  const session = await acpStream.newSession({
-    mcpServers: [],
-    cwd: testDir,
-  });
-  expect(session).toBeDefined();
-  const sessionId = (session as any).sessionId;
-  expect(sessionId).toBeTruthy();
-  log(`Session created: ${sessionId}`);
-
-  return { acpStream, sessionId, sessionUpdates };
-}
-
-// =============================================================================
-// 1. Trajectory Checkpoints with Enriched Fields
-// =============================================================================
-
-const TRAJ_DIR = IS_LIVE ? createTestRepo("traj") : os.tmpdir();
-
-describeLive("Swarmkit Live: Trajectory checkpoint enrichment", () => {
-  let system: MacroAgentSystemV2;
-  let client: ClientConnection;
-  let mapUrl: string;
-
-  beforeAll(async () => {
-    system = await bootV2({
-      cwd: TRAJ_DIR,
-      baseDir: path.join(TRAJ_DIR, ".macro-agent"),
-      defaultPermissionMode: "auto-approve",
-      inbox: {
-        socketPath: path.join(TRAJ_DIR, ".macro-agent", "inbox.sock"),
-      },
-      mapServer: {
-        enabled: true,
-        port: 0,
-        host: "127.0.0.1",
-      },
-      // Sidecar to unreachable hub — tests graceful degradation
-      map: {
-        enabled: true,
-        server: "ws://127.0.0.1:1",
-        reconnection: { enabled: false },
-        reconnectIntervalMs: 999999,
-        trajectorySyncLevel: "full",
-      },
-      sessionlog: { enabled: true, sync: "full" },
-      minimem: { enabled: true },
-      skilltree: { enabled: true },
-    });
-
-    mapUrl = system.mapServerInstance!.getUrl();
-    log(`MAP server at ${mapUrl}`);
-
-    client = await ClientConnection.connect(mapUrl, {
-      name: "Swarmkit Trajectory E2E",
-      capabilities: {
-        observation: { canObserve: true, canQuery: true },
-        messaging: { canSend: true, canReceive: true },
-        lifecycle: { canSpawn: true, canStop: true },
-      },
-    });
-  }, TIMEOUT.SETUP);
-
-  afterAll(async () => {
-    try { await client?.disconnect(); } catch { /* ignore */ }
-    try { await system?.shutdown(); } catch { /* ignore */ }
-    try { fs.rmSync(TRAJ_DIR, { recursive: true, force: true }); } catch { /* ignore */ }
-  });
-
-  it("trajectory/checkpoint handler accepts fully enriched checkpoint", async () => {
-    const result = await client.callExtension("trajectory/checkpoint", {
-      checkpoint: {
-        id: "enriched-cp-1",
-        session_id: "sess-enriched",
-        agent: "test-agent",
-        branch: "main",
-        files_touched: ["/tmp/swarmkit-test.txt", "src/index.ts"],
-        checkpoints_count: 3,
-        token_usage: {
-          input_tokens: 5000,
-          output_tokens: 2500,
-          cache_creation_tokens: 100,
-          cache_read_tokens: 50,
-        },
-        metadata: {
-          project: "swarmkit-test",
-          startedAt: new Date().toISOString(),
-          label: "Step 3 (5 tool calls)",
-          toolCallCount: 5,
-          phase: "active",
-          firstPrompt: "Write hello to /tmp/swarmkit-test.txt",
-          duration_ms: 12345,
-          gitCommitHash: "abc123",
-        },
-      },
-    });
-
-    expect((result as any).ok).toBe(true);
-    log("Enriched checkpoint accepted");
-  });
-
-  it("prompt produces trajectory data with expected fields", async () => {
-    const { acpStream, sessionId, sessionUpdates } = await setupACPStream(client, TRAJ_DIR);
-
-    // Prompt with a task that uses tools (Write) for files_touched tracking
-    log("Sending prompt that triggers file write...");
-    const tmpFile = `/tmp/swarmkit-live-test-${Date.now()}.txt`;
-    const result = await acpStream.prompt({
-      sessionId,
-      prompt: [
-        {
-          type: "text",
-          text: `Write the text "hello from swarmkit live test" to the file ${tmpFile} using the Write tool. Then reply with "done".`,
-        },
-      ],
-    });
-
-    expect(result.stopReason).toBeTruthy();
-    log(`Prompt completed: stopReason=${result.stopReason}`);
-
-    // Wait for async checkpoint emission
-    await settle(1000);
-
-    // Verify session updates were received
-    expect(sessionUpdates.length).toBeGreaterThan(0);
-    log(`Received ${sessionUpdates.length} session updates`);
-
-    // Verify tool_call updates exist (proves the agent used tools)
-    const toolCallUpdates = sessionUpdates.filter(
-      (u: any) => u?.update?.sessionUpdate === "tool_call",
-    );
-    log(`Tool call updates: ${toolCallUpdates.length}`);
-    expect(toolCallUpdates.length).toBeGreaterThan(0);
-
-    // Now send a manual checkpoint that mimics what the ACP bridge would have sent,
-    // verifying that the trajectory/checkpoint handler accepts enriched data
-    const manualCheckpoint = await client.callExtension(
-      "trajectory/checkpoint",
-      {
-        checkpoint: {
-          id: `${sessionId}-step1`,
-          session_id: sessionId,
-          agent: "swarmkit-test-agent",
-          branch: "main",
-          files_touched: [tmpFile],
-          checkpoints_count: 1,
-          token_usage: {
-            input_tokens: 3000,
-            output_tokens: 1500,
-          },
-          metadata: {
-            project: TRAJ_DIR.split("/").pop() ?? "",
-            startedAt: new Date().toISOString(),
-            label: "Step 1 (1 tool calls)",
-            toolCallCount: 1,
-            phase: "active",
-            firstPrompt: `Write "hello" to ${tmpFile}`,
-          },
-        },
-      },
-    );
-
-    expect((manualCheckpoint as any).ok).toBe(true);
-    log("Manual checkpoint with enriched fields accepted");
-
-    // Verify the file was actually written (confirms tool execution)
-    if (fs.existsSync(tmpFile)) {
-      const content = fs.readFileSync(tmpFile, "utf-8");
-      expect(content).toContain("hello");
-      log(`File written: ${tmpFile} (${content.length} bytes)`);
-      // Clean up
-      try { fs.unlinkSync(tmpFile); } catch { /* ignore */ }
-    } else {
-      log("File not found at expected path (agent may have written elsewhere)");
-    }
-
-    await acpStream.close();
-  }, TIMEOUT.PROMPT);
-});
-
-// =============================================================================
-// 2. Sync-Level Gating
-// =============================================================================
-
-const GATE_LIFECYCLE_DIR = IS_LIVE ? createTestRepo("gate-lifecycle") : os.tmpdir();
-const GATE_FULL_DIR = IS_LIVE ? createTestRepo("gate-full") : os.tmpdir();
-
-describeLive("Swarmkit Live: Sync-level gating", () => {
-  it("lifecycle sync level produces minimal checkpoint fields", async () => {
-    // Use a short base dir — Unix sockets on macOS have 104-char path limit
-    const lcDir = createTestRepo("lc");
-    const lcBaseDir = path.join(os.tmpdir(), `ma-lc-${Date.now()}`);
-
-    const system = await bootV2({
-      cwd: lcDir,
-      baseDir: lcBaseDir,
-      defaultPermissionMode: "auto-approve",
-      inbox: {
-        socketPath: path.join(lcBaseDir, "inbox-lc.sock"),
-      },
-      mapServer: {
-        enabled: true,
-        port: 0,
-        host: "127.0.0.1",
-      },
-      map: {
-        enabled: true,
-        server: "ws://127.0.0.1:1",
-        reconnection: { enabled: false },
-        reconnectIntervalMs: 999999,
-        trajectorySyncLevel: "lifecycle",
-      },
-      sessionlog: { enabled: true, sync: "lifecycle" },
-    });
-
-    try {
-      // Verify the sync level is set on the system
-      expect(system._sessionlogSyncLevel).toBe("lifecycle");
-      log(`Lifecycle sync level confirmed: ${system._sessionlogSyncLevel}`);
-
-      const mapUrl = system.mapServerInstance!.getUrl();
-      const client = await ClientConnection.connect(mapUrl, {
-        name: "Sync Gate Lifecycle",
-        capabilities: {
-          observation: { canObserve: true, canQuery: true },
-          messaging: { canSend: true, canReceive: true },
-          lifecycle: { canSpawn: true, canStop: true },
-        },
-      });
-
-      try {
-        const { acpStream, sessionId, sessionUpdates } = await setupACPStream(
-          client,
-          lcDir,
-        );
-
-        // Prompt agent
-        log("Prompting agent with lifecycle sync level...");
-        const result = await acpStream.prompt({
-          sessionId,
-          prompt: [
-            {
-              type: "text",
-              text: 'Reply with exactly "lifecycle test complete" and nothing else.',
-            },
-          ],
-        });
-
-        expect(result.stopReason).toBeTruthy();
-        await settle(1000);
-        log(`Lifecycle prompt done, ${sessionUpdates.length} updates`);
-
-        // Verify the trajectory/checkpoint handler works with lifecycle-level data
-        // (minimal: no token_usage, no files_touched)
-        const lifecycleCheckpoint = await client.callExtension(
-          "trajectory/checkpoint",
-          {
-            checkpoint: {
-              id: `${sessionId}-lifecycle`,
-              session_id: sessionId,
-              agent: "lifecycle-agent",
-              branch: null,
-              files_touched: [],
-              checkpoints_count: 0,
-              // No token_usage — lifecycle level omits it
-              metadata: {
-                phase: "active",
-                startedAt: new Date().toISOString(),
-                label: "Step 1 (0 tool calls)",
-              },
-            },
-          },
-        );
-
-        expect((lifecycleCheckpoint as any).ok).toBe(true);
-        log("Lifecycle-level checkpoint accepted (no token_usage, no files_touched)");
-
-        await acpStream.close();
-      } finally {
-        try { await client.disconnect(); } catch { /* ignore */ }
-      }
-    } finally {
-      try { await system.shutdown(); } catch { /* ignore */ }
-    }
-  }, TIMEOUT.PROMPT);
-
-  it("full sync level produces complete checkpoint fields", async () => {
-    const system = await bootV2({
-      cwd: GATE_FULL_DIR,
-      baseDir: path.join(GATE_FULL_DIR, ".macro-agent"),
-      defaultPermissionMode: "auto-approve",
-      inbox: {
-        socketPath: path.join(GATE_FULL_DIR, ".macro-agent", "inbox-full.sock"),
-      },
-      mapServer: {
-        enabled: true,
-        port: 0,
-        host: "127.0.0.1",
-      },
-      map: {
-        enabled: true,
-        server: "ws://127.0.0.1:1",
-        reconnection: { enabled: false },
-        reconnectIntervalMs: 999999,
-        trajectorySyncLevel: "full",
-      },
-      sessionlog: { enabled: true, sync: "full" },
-    });
-
-    try {
-      expect(system._sessionlogSyncLevel).toBe("full");
-      log(`Full sync level confirmed: ${system._sessionlogSyncLevel}`);
-
-      const mapUrl = system.mapServerInstance!.getUrl();
-      const client = await ClientConnection.connect(mapUrl, {
-        name: "Sync Gate Full",
-        capabilities: {
-          observation: { canObserve: true, canQuery: true },
-          messaging: { canSend: true, canReceive: true },
-          lifecycle: { canSpawn: true, canStop: true },
-        },
-      });
-
-      try {
-        const { acpStream, sessionId, sessionUpdates } = await setupACPStream(
-          client,
-          GATE_FULL_DIR,
-        );
-
-        // Prompt with tool use for full enrichment
-        const tmpFile = `/tmp/swarmkit-full-gate-${Date.now()}.txt`;
-        log("Prompting agent with full sync level (tool use)...");
-        const result = await acpStream.prompt({
-          sessionId,
-          prompt: [
-            {
-              type: "text",
-              text: `Write "full sync test" to ${tmpFile} using the Write tool, then reply "done".`,
-            },
-          ],
-        });
-
-        expect(result.stopReason).toBeTruthy();
-        await settle(1000);
-        log(`Full sync prompt done, ${sessionUpdates.length} updates`);
-
-        // Verify full-level checkpoint with all fields
-        const fullCheckpoint = await client.callExtension(
-          "trajectory/checkpoint",
-          {
-            checkpoint: {
-              id: `${sessionId}-full`,
-              session_id: sessionId,
-              agent: "full-agent",
-              branch: "main",
-              files_touched: [tmpFile],
-              checkpoints_count: 1,
-              token_usage: {
-                input_tokens: 4000,
-                output_tokens: 2000,
-              },
-              metadata: {
-                project: "swarmkit-test",
-                startedAt: new Date().toISOString(),
-                label: "Step 1 (1 tool calls)",
-                toolCallCount: 1,
-                phase: "active",
-                firstPrompt: `Write "full sync test" to ${tmpFile}`,
-                duration_ms: 8000,
-                projectPath: GATE_FULL_DIR,
-              },
-            },
-          },
-        );
-
-        expect((fullCheckpoint as any).ok).toBe(true);
-        log("Full-level checkpoint accepted (all fields present)");
-
-        // Verify tool calls happened (indicates full tracking)
-        const toolCalls = sessionUpdates.filter(
-          (u: any) => u?.update?.sessionUpdate === "tool_call",
-        );
-        log(`Tool calls at full level: ${toolCalls.length}`);
-        expect(toolCalls.length).toBeGreaterThan(0);
-
-        // Clean up
-        try { fs.unlinkSync(tmpFile); } catch { /* ignore */ }
-        await acpStream.close();
-      } finally {
-        try { await client.disconnect(); } catch { /* ignore */ }
-      }
-    } finally {
-      try { await system.shutdown(); } catch { /* ignore */ }
-    }
-  }, TIMEOUT.PROMPT);
-});
-
-// =============================================================================
-// 3. Context Injection with Live Agent
-// =============================================================================
-
-const CTX_DIR = IS_LIVE ? createTestRepo("ctx") : os.tmpdir();
-
-describeLive("Swarmkit Live: Context injection", () => {
-  let system: MacroAgentSystemV2;
-  let client: ClientConnection;
-
-  beforeAll(async () => {
-    system = await bootV2({
-      cwd: CTX_DIR,
-      baseDir: path.join(CTX_DIR, ".macro-agent"),
-      defaultPermissionMode: "auto-approve",
-      inbox: {
-        socketPath: path.join(CTX_DIR, ".macro-agent", "inbox.sock"),
-      },
-      mapServer: {
-        enabled: true,
-        port: 0,
-        host: "127.0.0.1",
-      },
-      map: {
-        enabled: true,
-        server: "ws://127.0.0.1:1",
-        reconnection: { enabled: false },
-        reconnectIntervalMs: 999999,
-      },
-      minimem: { enabled: true },
-      skilltree: { enabled: true },
-      sessionlog: { enabled: true, sync: "full" },
-    });
-
-    const mapUrl = system.mapServerInstance!.getUrl();
-    client = await ClientConnection.connect(mapUrl, {
-      name: "Context Injection E2E",
-      capabilities: {
-        observation: { canObserve: true, canQuery: true },
-        messaging: { canSend: true, canReceive: true },
-        lifecycle: { canSpawn: true, canStop: true },
-      },
-    });
-  }, TIMEOUT.SETUP);
-
-  afterAll(async () => {
-    try { await client?.disconnect(); } catch { /* ignore */ }
-    try { await system?.shutdown(); } catch { /* ignore */ }
-    try { fs.rmSync(CTX_DIR, { recursive: true, force: true }); } catch { /* ignore */ }
-  });
-
-  it("spawned agent receives system prompt with all capability sections", async () => {
-    const { acpStream, sessionId, sessionUpdates } = await setupACPStream(
-      client,
-      CTX_DIR,
-    );
-
-    // Ask the agent to describe its own system prompt sections
-    log("Asking agent about its system prompt capabilities...");
-    const result = await acpStream.prompt({
-      sessionId,
-      prompt: [
-        {
-          type: "text",
-          text: 'Check your system prompt for sections containing "Swarm Capabilities", "Team Orchestration", "Task Management", "Communication", "Memory", "Per-Role Skills", and "External Observability". Reply with a JSON object like {"found": ["section1", "section2"]} listing which sections you found. Only output the JSON, nothing else.',
-        },
-      ],
-    });
-
-    expect(result.stopReason).toBeTruthy();
-    log(`Context injection prompt done, ${sessionUpdates.length} updates`);
-
-    // The agent should have received session updates
-    expect(sessionUpdates.length).toBeGreaterThan(0);
-
-    // Check that the assistant response mentions the expected sections.
-    // We look in session updates for an assistant message.
-    const assistantUpdates = sessionUpdates.filter(
-      (u: any) => u?.update?.sessionUpdate === "assistant",
-    );
-
-    if (assistantUpdates.length > 0) {
-      const lastAssistant = assistantUpdates[assistantUpdates.length - 1];
-      const text = (lastAssistant as any)?.update?.text ?? "";
-      log(`Agent response: ${text.slice(0, 300)}`);
-
-      // The agent should have found these core sections in its system prompt
-      const expectedSections = [
-        "Swarm Capabilities",
-        "Team Orchestration",
-        "Task Management",
-        "Communication",
-      ];
-
-      for (const section of expectedSections) {
-        // The agent's JSON response should mention these sections
-        // (either found them or at least they were in the prompt)
-        log(`Checking for section: ${section}`);
-      }
-    }
-
-    await acpStream.close();
-  }, TIMEOUT.PROMPT);
-});
-
-// =============================================================================
-// 4. Tool Call Detection (files_touched tracking)
-// =============================================================================
-
-const TOOL_DIR = IS_LIVE ? createTestRepo("tool") : os.tmpdir();
-
-describeLive("Swarmkit Live: Tool call detection", () => {
-  let system: MacroAgentSystemV2;
-  let client: ClientConnection;
-
-  beforeAll(async () => {
-    system = await bootV2({
-      cwd: TOOL_DIR,
-      baseDir: path.join(TOOL_DIR, ".macro-agent"),
-      defaultPermissionMode: "auto-approve",
-      inbox: {
-        socketPath: path.join(TOOL_DIR, ".macro-agent", "inbox.sock"),
-      },
-      mapServer: {
-        enabled: true,
-        port: 0,
-        host: "127.0.0.1",
-      },
-      map: {
-        enabled: true,
-        server: "ws://127.0.0.1:1",
-        reconnection: { enabled: false },
-        reconnectIntervalMs: 999999,
-        trajectorySyncLevel: "full",
-      },
-      sessionlog: { enabled: true, sync: "full" },
-    });
-
-    const mapUrl = system.mapServerInstance!.getUrl();
-    client = await ClientConnection.connect(mapUrl, {
-      name: "Tool Detection E2E",
-      capabilities: {
-        observation: { canObserve: true, canQuery: true },
-        messaging: { canSend: true, canReceive: true },
-        lifecycle: { canSpawn: true, canStop: true },
-      },
-    });
-  }, TIMEOUT.SETUP);
-
-  afterAll(async () => {
-    try { await client?.disconnect(); } catch { /* ignore */ }
-    try { await system?.shutdown(); } catch { /* ignore */ }
-    try { fs.rmSync(TOOL_DIR, { recursive: true, force: true }); } catch { /* ignore */ }
-  });
-
-  it("detects tool calls and tracks files_touched from Write tool", async () => {
-    const { acpStream, sessionId, sessionUpdates } = await setupACPStream(
-      client,
-      TOOL_DIR,
-    );
-
-    const tmpFile = `/tmp/swarmkit-tool-detect-${Date.now()}.txt`;
-
-    log("Prompting agent to use Write tool...");
-    const result = await acpStream.prompt({
-      sessionId,
-      prompt: [
-        {
-          type: "text",
-          text: `Write the text "tool detection test" to ${tmpFile} using the Write tool. Then reply "written".`,
-        },
-      ],
-    });
-
-    expect(result.stopReason).toBeTruthy();
-    await settle(500);
-
-    // Extract tool_call updates
-    const toolCallUpdates = sessionUpdates.filter(
-      (u: any) => u?.update?.sessionUpdate === "tool_call",
-    );
-    log(`Tool call updates detected: ${toolCallUpdates.length}`);
-    expect(toolCallUpdates.length).toBeGreaterThan(0);
-
-    // Check that at least one tool_call has a file path in rawInput
-    const writeToolCalls = toolCallUpdates.filter((u: any) => {
-      const title = u?.update?.title ?? "";
-      const input = u?.update?.rawInput ?? {};
-      return (
-        title.toLowerCase().includes("write") ||
-        input.file_path ||
-        input.filePath
-      );
-    });
-    log(`Write tool calls: ${writeToolCalls.length}`);
-
-    // Also check for tool_result updates
-    const toolResultUpdates = sessionUpdates.filter(
-      (u: any) => u?.update?.sessionUpdate === "tool_result",
-    );
-    log(`Tool result updates: ${toolResultUpdates.length}`);
-
-    // Verify the tool_call types are present in session updates
-    const updateTypes = [
-      ...new Set(sessionUpdates.map((u: any) => u?.update?.sessionUpdate)),
-    ];
-    log(`Update types seen: ${updateTypes.join(", ")}`);
-    expect(updateTypes).toContain("tool_call");
-
-    // Clean up
-    try { fs.unlinkSync(tmpFile); } catch { /* ignore */ }
-
-    await acpStream.close();
-  }, TIMEOUT.PROMPT);
-
-  it("detection code path handles non-file tools without crashing", async () => {
-    const { acpStream, sessionId, sessionUpdates } = await setupACPStream(
-      client,
-      TOOL_DIR,
-    );
-
-    // Prompt with a task that uses non-file tools (e.g., Bash for computation)
-    log("Prompting agent with non-file tool use...");
-    const result = await acpStream.prompt({
-      sessionId,
-      prompt: [
-        {
-          type: "text",
-          text: 'Run the command "echo hello-swarmkit" using the Bash tool. Reply with the output.',
-        },
-      ],
-    });
-
-    expect(result.stopReason).toBeTruthy();
-    await settle(500);
-
-    // Should complete without errors even for non-file tools
-    const toolCalls = sessionUpdates.filter(
-      (u: any) => u?.update?.sessionUpdate === "tool_call",
-    );
-    log(`Non-file tool calls: ${toolCalls.length}`);
-    expect(toolCalls.length).toBeGreaterThan(0);
-
-    await acpStream.close();
-  }, TIMEOUT.PROMPT);
-});
-
-// =============================================================================
-// 5. Session End Checkpoint
-// =============================================================================
-
-const END_DIR = IS_LIVE ? createTestRepo("end") : os.tmpdir();
-
-describeLive("Swarmkit Live: Session end checkpoint", () => {
-  let system: MacroAgentSystemV2;
-  let client: ClientConnection;
-
-  beforeAll(async () => {
-    system = await bootV2({
-      cwd: END_DIR,
-      baseDir: path.join(END_DIR, ".macro-agent"),
-      defaultPermissionMode: "auto-approve",
-      inbox: {
-        socketPath: path.join(END_DIR, ".macro-agent", "inbox.sock"),
-      },
-      mapServer: {
-        enabled: true,
-        port: 0,
-        host: "127.0.0.1",
-      },
-      map: {
-        enabled: true,
-        server: "ws://127.0.0.1:1",
-        reconnection: { enabled: false },
-        reconnectIntervalMs: 999999,
-        trajectorySyncLevel: "full",
-      },
-      sessionlog: { enabled: true, sync: "full" },
-    });
-
-    const mapUrl = system.mapServerInstance!.getUrl();
-    client = await ClientConnection.connect(mapUrl, {
-      name: "Session End E2E",
-      capabilities: {
-        observation: { canObserve: true, canQuery: true },
-        messaging: { canSend: true, canReceive: true },
-        lifecycle: { canSpawn: true, canStop: true },
-      },
-    });
-  }, TIMEOUT.SETUP);
-
-  afterAll(async () => {
-    try { await client?.disconnect(); } catch { /* ignore */ }
-    try { await system?.shutdown(); } catch { /* ignore */ }
-    try { fs.rmSync(END_DIR, { recursive: true, force: true }); } catch { /* ignore */ }
-  });
-
-  it("completes prompt then terminate produces consistent state", async () => {
-    const { acpStream, sessionId, sessionUpdates } = await setupACPStream(
-      client,
-      END_DIR,
-    );
-
-    // Prompt the agent
-    log("Prompting agent before terminate...");
-    const result = await acpStream.prompt({
-      sessionId,
-      prompt: [
-        {
-          type: "text",
-          text: 'Reply with exactly "pre-terminate checkpoint" and nothing else.',
-        },
-      ],
-    });
-
-    expect(result.stopReason).toBeTruthy();
-    await settle(1000);
-
-    // Verify a checkpoint can be sent for this session (simulating what
-    // the sidecar would do on session end)
-    const endCheckpoint = await client.callExtension(
-      "trajectory/checkpoint",
-      {
-        checkpoint: {
-          id: `${sessionId}-end`,
-          session_id: sessionId,
-          agent: "end-agent",
-          branch: null,
-          files_touched: [],
-          checkpoints_count: 1,
-          metadata: {
-            phase: "ended",
-            startedAt: new Date().toISOString(),
-            label: "Session complete",
-          },
-        },
-      },
-    );
-
-    expect((endCheckpoint as any).ok).toBe(true);
-    log("End-of-session checkpoint accepted");
-
-    // Close the ACP stream (equivalent to session teardown)
-    await acpStream.close();
-
-    // After close, verify the agents list still works
-    const agents = await client.listAgents();
-    log(`Agents after session close: ${agents.agents.length}`);
-    expect(agents.agents).toBeDefined();
-  }, TIMEOUT.PROMPT);
-});
-
-// =============================================================================
-// 6. Agent State Transitions
-// =============================================================================
-
-const STATE_DIR = IS_LIVE ? createTestRepo("state") : os.tmpdir();
-
-describeLive("Swarmkit Live: Agent state transitions", () => {
-  let system: MacroAgentSystemV2;
-  let client: ClientConnection;
-
-  beforeAll(async () => {
-    system = await bootV2({
-      cwd: STATE_DIR,
-      baseDir: path.join(STATE_DIR, ".macro-agent"),
-      defaultPermissionMode: "auto-approve",
-      inbox: {
-        socketPath: path.join(STATE_DIR, ".macro-agent", "inbox.sock"),
-      },
-      mapServer: {
-        enabled: true,
-        port: 0,
-        host: "127.0.0.1",
-      },
-      map: {
-        enabled: true,
-        server: "ws://127.0.0.1:1",
-        reconnection: { enabled: false },
-        reconnectIntervalMs: 999999,
-      },
-      sessionlog: { enabled: true, sync: "full" },
-    });
-
-    const mapUrl = system.mapServerInstance!.getUrl();
-    client = await ClientConnection.connect(mapUrl, {
-      name: "State Transitions E2E",
-      capabilities: {
-        observation: { canObserve: true, canQuery: true },
-        messaging: { canSend: true, canReceive: true },
-        lifecycle: { canSpawn: true, canStop: true },
-      },
-    });
-  }, TIMEOUT.SETUP);
-
-  afterAll(async () => {
-    try { await client?.disconnect(); } catch { /* ignore */ }
-    try { await system?.shutdown(); } catch { /* ignore */ }
-    try { fs.rmSync(STATE_DIR, { recursive: true, force: true }); } catch { /* ignore */ }
-  });
-
-  it("agent transitions: spawn -> idle, prompt -> busy -> idle", async () => {
-    // Spawn an agent via extension
-    log("Spawning agent...");
-    const spawnResult = (await client.callExtension("_macro/spawnAgent", {
-      task: "State transition test",
-      role: "worker",
-    })) as { agent: { id: string; localId: string } };
-
-    const agentMapId = spawnResult.agent.id;
-    log(`Spawned agent MAP ID: ${agentMapId}`);
-    await settle();
-
-    // After spawn, check agent state — should be idle or online
-    const agentsAfterSpawn = await client.listAgents();
-    const spawnedAgent = agentsAfterSpawn.agents.find(
-      (a: any) => a.id === agentMapId,
-    );
-    expect(spawnedAgent).toBeDefined();
-    log(`Agent state after spawn: ${spawnedAgent?.state ?? "unknown"}`);
-
-    // The agent should not be in a "busy" state before any prompt
-    if (spawnedAgent?.state) {
-      expect(spawnedAgent.state).not.toBe("busy");
-    }
-
-    // Set up ACP stream for prompting
-    const sessionUpdates: any[] = [];
-    const acpStream = createACPStream(client, {
-      targetAgent: agentMapId,
-      timeout: TIMEOUT.PROMPT,
-      client: {
-        requestPermission: async () =>
-          ({ outcome: { outcome: "allow" } }) as any,
-        sessionUpdate: async (update: any) => {
-          sessionUpdates.push(update);
-        },
-      },
-    });
-
-    // Pre-spawn another head manager for the ACP session
-    await client.callExtension("_macro/spawnAgent", {
-      task: "Head manager for state test",
-      role: "coordinator",
-    });
-    await settle();
-
-    await acpStream.initialize({
-      protocolVersion: 1,
-      clientInfo: { name: "State E2E", version: "1.0.0" },
-    });
-
-    const session = await acpStream.newSession({
-      mcpServers: [],
-      cwd: STATE_DIR,
-    });
-    const sessionId = (session as any).sessionId;
-
-    // During prompt, the agent state should transition to "busy".
-    // We start the prompt and check state concurrently.
-    log("Starting prompt (will check state during execution)...");
-
-    let busyStateObserved = false;
-    const promptPromise = acpStream.prompt({
-      sessionId,
-      prompt: [
-        {
-          type: "text",
-          text: 'Write "state test" to /tmp/swarmkit-state-test.txt using the Write tool. Then reply "state test done".',
-        },
-      ],
-    });
-
-    // Poll for busy state during prompt execution
-    // Use a short polling loop — the agent transitions to busy during prompt processing
-    const pollStart = Date.now();
-    while (Date.now() - pollStart < 10_000) {
-      try {
-        const during = await client.listAgents();
-        for (const a of during.agents) {
-          if ((a as any).state === "busy") {
-            busyStateObserved = true;
-            log(`Observed "busy" state on agent ${a.id}`);
-            break;
-          }
-        }
-        if (busyStateObserved) break;
-      } catch { /* ignore polling errors */ }
-      await new Promise((r) => setTimeout(r, 200));
-    }
-
-    // Wait for prompt to complete
-    const result = await promptPromise;
-    expect(result.stopReason).toBeTruthy();
-    log(`Prompt completed: ${result.stopReason}`);
-
-    // After prompt, state should return to idle
-    await settle(1000);
-    const agentsAfterPrompt = await client.listAgents();
-    const agentAfterPrompt = agentsAfterPrompt.agents.find(
-      (a: any) => a.id === agentMapId || (a as any).state === "idle",
-    );
-    if (agentAfterPrompt) {
-      log(`Agent state after prompt: ${(agentAfterPrompt as any).state ?? "unknown"}`);
-    }
-
-    if (busyStateObserved) {
-      log("Agent state transition verified: idle -> busy -> idle");
-    } else {
-      log(
-        "Busy state was not observed during polling (prompt may have completed too quickly). " +
-          "The state transition code path is architecturally correct.",
-      );
-    }
-
-    // Clean up
-    try { fs.unlinkSync("/tmp/swarmkit-state-test.txt"); } catch { /* ignore */ }
-    await acpStream.close();
-  }, TIMEOUT.PROMPT);
-
-  it("agent is listed after spawn and listAgents returns correct shape", async () => {
-    const agents = await client.listAgents();
-    expect(agents.agents).toBeDefined();
-    expect(Array.isArray(agents.agents)).toBe(true);
-    log(`Total agents: ${agents.agents.length}`);
-
-    // Each agent should have the expected MAP agent shape
-    for (const agent of agents.agents) {
-      expect(agent.id).toBeTruthy();
-      expect(agent.name).toBeTruthy();
-      log(`Agent: ${agent.name} (${agent.id}), state: ${(agent as any).state ?? "N/A"}`);
-    }
-  });
-});