macro-agent 0.2.5 → 0.2.6

package/src/__tests__/e2e/dispatch.e2e.test.ts

@@ -1,376 +0,0 @@
-/**
- * Task Dispatch E2E Tests (mocked agents)
- *
- * Tests dispatch boot wiring, configuration, and basic dispatch flow
- * using mocked acp-factory and opentasks (no real agents or daemon).
- *
- * REQUIRES: RUN_E2E_TESTS=true
- *
- * Run with:
- *   RUN_E2E_TESTS=true npx vitest run --config vitest.e2e.config.ts src/__tests__/e2e/dispatch.e2e.test.ts
- */
-
-import {
-  describe,
-  it,
-  expect,
-  beforeEach,
-  afterEach,
-  vi,
-} from "vitest";
-import * as path from "path";
-import * as os from "os";
-import * as fs from "fs";
-import { bootV2, type MacroAgentSystemV2 } from "../../boot-v2.js";
-
-// ─────────────────────────────────────────────────────────────────
-// Configuration
-// ─────────────────────────────────────────────────────────────────
-
-const RUN_E2E = !!process.env.RUN_E2E_TESTS;
-const describeFn = RUN_E2E ? describe : describe.skip;
-
-// ─────────────────────────────────────────────────────────────────
-// Mocks
-// ─────────────────────────────────────────────────────────────────
-
-vi.mock("acp-factory", () => ({
-  AgentFactory: {
-    spawn: vi.fn().mockResolvedValue({
-      createSession: vi.fn().mockResolvedValue({
-        id: `session-${Date.now()}`,
-        prompt: vi.fn().mockReturnValue({
-          [Symbol.asyncIterator]: () => ({
-            next: () => Promise.resolve({ done: true, value: undefined }),
-          }),
-        }),
-        forkWithFlush: vi.fn().mockResolvedValue({ id: `forked-${Date.now()}` }),
-      }),
-      loadSession: vi.fn().mockResolvedValue({ id: `loaded-${Date.now()}` }),
-      close: vi.fn().mockResolvedValue(undefined),
-      isRunning: vi.fn().mockReturnValue(true),
-    }),
-  },
-}));
-
-vi.mock("opentasks", () => ({
-  OpenTasksClient: vi.fn().mockImplementation(() => ({
-    connect: vi.fn().mockRejectedValue(new Error("No daemon")),
-    disconnect: vi.fn(),
-    query: vi.fn().mockResolvedValue({ items: [] }),
-    link: vi.fn().mockResolvedValue({ success: true }),
-    task: vi.fn().mockResolvedValue({ id: "t-1" }),
-  })),
-}));
-
-// ─────────────────────────────────────────────────────────────────
-// Helpers
-// ─────────────────────────────────────────────────────────────────
-
-function createTestDir(): string {
-  const dir = path.join(
-    os.tmpdir(),
-    `dispatch-e2e-${Date.now()}-${Math.random().toString(36).slice(2)}`
-  );
-  fs.mkdirSync(dir, { recursive: true });
-  return dir;
-}
-
-// ─────────────────────────────────────────────────────────────────
-// Tests
-// ─────────────────────────────────────────────────────────────────
-
-describeFn("Task Dispatch E2E", () => {
-  let system: MacroAgentSystemV2;
-  let testDir: string;
-
-  beforeEach(async () => {
-    testDir = createTestDir();
-  });
-
-  afterEach(async () => {
-    if (system) {
-      try {
-        const running = system.agentManager.list({ state: "running" } as any);
-        for (const agent of running) {
-          await system.agentManager.terminate(agent.id, "cancelled");
-        }
-      } catch { /* best effort */ }
-      await system.shutdown();
-    }
-    if (fs.existsSync(testDir)) {
-      fs.rmSync(testDir, { recursive: true, force: true });
-    }
-  });
-
-  // ── Boot with dispatch enabled ─────────────────────────────
-
-  describe("Boot", () => {
-    it("boots successfully with dispatch enabled", async () => {
-      system = await bootV2({
-        cwd: testDir,
-        baseDir: testDir,
-        inbox: { socketPath: path.join(testDir, "inbox.sock") },
-        dispatch: {
-          enabled: true,
-          pollIntervalMs: 60_000,
-          maxConcurrent: 3,
-          defaultRole: "worker",
-        },
-      });
-
-      expect(system).toBeDefined();
-      expect(system.taskDispatcher).toBeDefined();
-      expect(system.taskDispatcher!.running).toBe(true);
-    });
-
-    it("boots successfully with dispatch and reconcile enabled", async () => {
-      system = await bootV2({
-        cwd: testDir,
-        baseDir: testDir,
-        inbox: { socketPath: path.join(testDir, "inbox.sock") },
-        dispatch: {
-          enabled: true,
-          pollIntervalMs: 60_000,
-          maxConcurrent: 3,
-          reconcile: { enabled: true, intervalMs: 120_000 },
-        },
-      });
-
-      expect(system.taskDispatcher).toBeDefined();
-      expect(system.taskDispatcher!.running).toBe(true);
-    });
-
-    it("boots without dispatch when not enabled", async () => {
-      system = await bootV2({
-        cwd: testDir,
-        baseDir: testDir,
-        inbox: { socketPath: path.join(testDir, "inbox.sock") },
-      });
-
-      expect(system.taskDispatcher).toBeUndefined();
-    });
-
-    it("exposes tracker for observability", async () => {
-      system = await bootV2({
-        cwd: testDir,
-        baseDir: testDir,
-        inbox: { socketPath: path.join(testDir, "inbox.sock") },
-        dispatch: {
-          enabled: true,
-          pollIntervalMs: 60_000,
-          maxConcurrent: 3,
-        },
-      });
-
-      expect(system.taskDispatcher!.tracker).toBeDefined();
-      expect(system.taskDispatcher!.tracker.activeCount()).toBe(0);
-      expect(system.taskDispatcher!.tracker.listRetries()).toHaveLength(0);
-    });
-  });
-
-  // ── Dispatch via dispatchNow ───────────────────────────────
-
-  describe("Dispatch", () => {
-    it("dispatchNow triggers a dispatch cycle", async () => {
-      system = await bootV2({
-        cwd: testDir,
-        baseDir: testDir,
-        inbox: { socketPath: path.join(testDir, "inbox.sock") },
-        dispatch: {
-          enabled: true,
-          pollIntervalMs: 600_000,
-          maxConcurrent: 5,
-        },
-      });
-
-      // dispatchNow should not throw even with no ready tasks
-      await system.taskDispatcher!.dispatchNow();
-      expect(system.taskDispatcher!.tracker.activeCount()).toBe(0);
-    });
-
-    it("reconcileNow triggers a reconciliation cycle", async () => {
-      system = await bootV2({
-        cwd: testDir,
-        baseDir: testDir,
-        inbox: { socketPath: path.join(testDir, "inbox.sock") },
-        dispatch: {
-          enabled: true,
-          pollIntervalMs: 600_000,
-          maxConcurrent: 3,
-          reconcile: { enabled: true, intervalMs: 600_000 },
-        },
-      });
-
-      // reconcileNow should not throw with no active dispatches
-      await system.taskDispatcher!.reconcileNow();
-    });
-  });
-
-  // ── Event subscription ─────────────────────────────────────
-
-  describe("Events", () => {
-    it("emits poll events via onEvent", async () => {
-      system = await bootV2({
-        cwd: testDir,
-        baseDir: testDir,
-        inbox: { socketPath: path.join(testDir, "inbox.sock") },
-        dispatch: {
-          enabled: true,
-          pollIntervalMs: 600_000,
-        },
-      });
-
-      const events: any[] = [];
-      system.taskDispatcher!.onEvent((e) => events.push(e));
-
-      await system.taskDispatcher!.dispatchNow();
-
-      const poll = events.find((e) => e.type === "poll");
-      expect(poll).toBeDefined();
-      expect(poll.dispatched).toBe(0);
-      expect(poll.active).toBe(0);
-    });
-  });
-
-  // ── Shutdown ───────────────────────────────────────────────
-
-  describe("Shutdown", () => {
-    it("shuts down cleanly with dispatch enabled", async () => {
-      system = await bootV2({
-        cwd: testDir,
-        baseDir: testDir,
-        inbox: { socketPath: path.join(testDir, "inbox.sock") },
-        dispatch: {
-          enabled: true,
-          pollIntervalMs: 60_000,
-          maxConcurrent: 3,
-          reconcile: { enabled: true, intervalMs: 120_000 },
-        },
-      });
-
-      await system.shutdown();
-      system = undefined as any;
-    });
-  });
-
-  // ── Config Variations ──────────────────────────────────────
-
-  describe("Configuration", () => {
-    it("applies custom config values", async () => {
-      system = await bootV2({
-        cwd: testDir,
-        baseDir: testDir,
-        inbox: { socketPath: path.join(testDir, "inbox.sock") },
-        dispatch: {
-          enabled: true,
-          pollIntervalMs: 5_000,
-          maxConcurrent: 10,
-          defaultRole: "security-auditor",
-          tags: ["security", "audit"],
-          maxRetries: 5,
-          retryBaseDelayMs: 5_000,
-          retryMaxDelayMs: 120_000,
-          reconcile: { enabled: true, intervalMs: 30_000 },
-          eligibility: {
-            minPriority: 3,
-            excludeTags: ["wip"],
-            minScore: 0.5,
-          },
-        },
-      });
-
-      expect(system.taskDispatcher).toBeDefined();
-      expect(system.taskDispatcher!.running).toBe(true);
-    });
-
-    it("boots without reconcile when reconcile.enabled is false", async () => {
-      system = await bootV2({
-        cwd: testDir,
-        baseDir: testDir,
-        inbox: { socketPath: path.join(testDir, "inbox.sock") },
-        dispatch: {
-          enabled: true,
-          pollIntervalMs: 60_000,
-          reconcile: { enabled: false },
-        },
-      });
-
-      // Dispatcher should still work — just no reconcile timer
-      expect(system.taskDispatcher).toBeDefined();
-      expect(system.taskDispatcher!.running).toBe(true);
-    });
-  });
-
-  // ── MAP Event Bridge ───────────────────────────────────────
-
-  describe("MAP Event Bridge", () => {
-    it("dispatcher works without MAP sidecar", async () => {
-      // No MAP config → no sidecar → dispatch should still work
-      system = await bootV2({
-        cwd: testDir,
-        baseDir: testDir,
-        inbox: { socketPath: path.join(testDir, "inbox.sock") },
-        dispatch: {
-          enabled: true,
-          pollIntervalMs: 60_000,
-        },
-        // No map config
-      });
-
-      expect(system.taskDispatcher).toBeDefined();
-      expect(system.taskDispatcher!.running).toBe(true);
-
-      // dispatchNow should work without MAP bridge
-      await system.taskDispatcher!.dispatchNow();
-    });
-
-    it("onEvent subscription works independently of MAP", async () => {
-      system = await bootV2({
-        cwd: testDir,
-        baseDir: testDir,
-        inbox: { socketPath: path.join(testDir, "inbox.sock") },
-        dispatch: {
-          enabled: true,
-          pollIntervalMs: 60_000,
-        },
-      });
-
-      const events: any[] = [];
-      const unsub = system.taskDispatcher!.onEvent((e) => events.push(e));
-
-      await system.taskDispatcher!.dispatchNow();
-
-      expect(events.some((e) => e.type === "poll")).toBe(true);
-
-      // Unsubscribe stops events
-      const countBefore = events.length;
-      unsub();
-      await system.taskDispatcher!.dispatchNow();
-      expect(events.length).toBe(countBefore);
-    });
-
-    it("MAP sidecar with unreachable server does not break dispatch", async () => {
-      system = await bootV2({
-        cwd: testDir,
-        baseDir: testDir,
-        inbox: { socketPath: path.join(testDir, "inbox.sock") },
-        dispatch: {
-          enabled: true,
-          pollIntervalMs: 60_000,
-        },
-        map: {
-          enabled: true,
-          server: "ws://127.0.0.1:1", // Unreachable
-          scope: "swarm:test",
-        },
-      });
-
-      // Dispatch should work even though MAP sidecar failed to connect
-      expect(system.taskDispatcher).toBeDefined();
-      expect(system.taskDispatcher!.running).toBe(true);
-
-      await system.taskDispatcher!.dispatchNow();
-    });
-  });
-});

package/src/__tests__/e2e/done-scenarios.e2e.test.ts

@@ -1,322 +0,0 @@
-/**
- * Done Scenarios E2E Tests (V2)
- *
- * Tests that verify done() tool behavior in various scenarios:
- * - done(status="blocked") keeps agent alive and notifies parent
- * - promptUntilDone follow-up prompting
- *
- * REQUIRES: RUN_FULL_AGENT_TESTS=true
- *
- * Run with:
- *   RUN_FULL_AGENT_TESTS=true npx vitest run --config vitest.e2e.config.ts src/__tests__/e2e/done-scenarios.e2e.test.ts
- */
-
-import {
-  describe,
-  it,
-  expect,
-  beforeEach,
-  afterEach,
-} from "vitest";
-import * as path from "path";
-import * as os from "os";
-import * as fs from "fs";
-import { execSync } from "child_process";
-import { bootV2, type MacroAgentSystemV2 } from "../../boot-v2.js";
-
-// ─────────────────────────────────────────────────────────────────
-// Configuration
-// ─────────────────────────────────────────────────────────────────
-
-const RUN_FULL_AGENT = !!process.env.RUN_FULL_AGENT_TESTS;
-const describeFn = RUN_FULL_AGENT ? describe : describe.skip;
-
-const TIMEOUT = {
-  SPAWN: 60_000,
-  PROMPT: 90_000,
-  MULTI: 180_000,
-};
-
-// ─────────────────────────────────────────────────────────────────
-// Helpers
-// ─────────────────────────────────────────────────────────────────
-
-function createTestRepo(prefix: string): { path: string; cleanup: () => void } {
-  const tmpDir = fs.mkdtempSync(
-    path.join(os.tmpdir(), `done-scenarios-${prefix}-`)
-  );
-  const repoPath = path.join(tmpDir, "test-repo");
-  fs.mkdirSync(repoPath);
-  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"), "# Test Repo\n");
-  execSync("git add -A", { cwd: repoPath, stdio: "pipe" });
-  execSync('git commit -m "Initial commit"', { cwd: repoPath, stdio: "pipe" });
-
-  return {
-    path: repoPath,
-    cleanup: () => fs.rmSync(tmpDir, { recursive: true, force: true }),
-  };
-}
-
-function log(msg: string): void {
-  console.log(`[DONE-E2E] ${msg}`);
-}
-
-function getTextContent(updates: any[]): string {
-  const parts: string[] = [];
-  for (const u of updates) {
-    const uAny = u as any;
-    if (uAny.sessionUpdate === "agent_message_chunk" && uAny.content?.text) {
-      parts.push(uAny.content.text);
-    }
-  }
-  return parts.join("");
-}
-
-function findToolCalls(updates: any[]): { name: string; fullTitle: string; input: any }[] {
-  const calls: { name: string; fullTitle: string; input: any }[] = [];
-  for (const u of updates) {
-    const uAny = u as any;
-
-    if (
-      (uAny.sessionUpdate === "tool_call" || uAny.sessionUpdate === "tool_call_update") &&
-      uAny.title
-    ) {
-      const fullTitle = uAny.title as string;
-      const parts = fullTitle.split("__");
-      const shortName = parts[parts.length - 1];
-
-      if (!calls.some(c => c.fullTitle === fullTitle)) {
-        calls.push({
-          name: shortName,
-          fullTitle,
-          input: uAny.rawInput ?? uAny.input,
-        });
-      }
-    }
-
-    if (uAny.content?.type === "tool_use") {
-      const name = uAny.content.name;
-      if (!calls.some(c => c.name === name)) {
-        calls.push({ name, fullTitle: name, input: uAny.content.input });
-      }
-    }
-  }
-  return calls;
-}
-
-// ─────────────────────────────────────────────────────────────────
-// Tests
-// ─────────────────────────────────────────────────────────────────
-
-describeFn("Done Scenarios E2E (V2)", () => {
-  let system: MacroAgentSystemV2;
-  let testRepo: { path: string; cleanup: () => void };
-  let baseDir: string;
-
-  beforeEach(async () => {
-    testRepo = createTestRepo("v2");
-    baseDir = path.join(testRepo.path, ".macro-agent");
-    fs.mkdirSync(baseDir, { recursive: true });
-
-    system = await bootV2({
-      cwd: testRepo.path,
-      baseDir,
-      defaultPermissionMode: "auto-approve",
-      inbox: {
-        socketPath: path.join(baseDir, "inbox.sock"),
-      },
-    });
-    log("System booted");
-  });
-
-  afterEach(async () => {
-    if (system) {
-      try {
-        const running = system.agentManager.list({ state: "running" });
-        for (const agent of running) {
-          try {
-            await system.agentManager.terminate(agent.id, "cancelled");
-          } catch {
-            // Best effort
-          }
-        }
-        await system.shutdown();
-      } catch {
-        // Best effort
-      }
-    }
-    testRepo?.cleanup();
-    log("Cleanup complete");
-  });
-
-  // ── Done with blocked keeps agent alive ───────────────────────
-
-  it(
-    "should keep agent alive when done is called with blocked status",
-    async () => {
-      log("Spawning coordinator...");
-      const coordinator = await system.agentManager.spawn({
-        task: "You coordinate workers. Monitor their status.",
-        role: "coordinator",
-        cwd: testRepo.path,
-      });
-
-      log("Spawning worker under coordinator...");
-      const worker = await system.agentManager.spawn({
-        task: "You are a worker that needs database credentials to proceed.",
-        role: "worker",
-        parent: coordinator.id,
-        cwd: testRepo.path,
-      });
-
-      log(`Coordinator: ${coordinator.id}, Worker: ${worker.id}`);
-
-      // Prompt the worker to call done with blocked status
-      log("Prompting worker to call done(blocked)...");
-      const result = await system.agentManager.promptUntilDone(
-        worker.id,
-        'You are blocked and cannot proceed. Call the "done" MCP tool with status="blocked" and summary="Need database credentials to continue". Do this immediately.',
-        {
-          maxFollowUps: 2,
-          onUpdate: (update: any) => {
-            if (update.sessionUpdate === "tool_call") {
-              log(`  [tool_call] ${update.title ?? "unknown"}`);
-            }
-          },
-        }
-      );
-
-      log(`promptUntilDone result: doneCalled=${result.doneCalled}, doneStatus=${result.doneStatus}`);
-
-      // Wait for lifecycle signals to propagate
-      await new Promise((r) => setTimeout(r, 3000));
-
-      if (result.doneCalled) {
-        log("done() was called!");
-
-        // The key assertion for blocked: agent session should still be active
-        // because handleWorkerDone returns shouldTerminate=false for blocked status
-        const workerRecord = system.agentStore.getAgent(worker.id)!;
-        log(`Worker state: ${workerRecord.state}`);
-
-        // Check if parent received HELP_NEEDED signal in inbox
-        const coordInbox = await system.inboxAdapter.checkInbox(coordinator.id);
-        log(`Coordinator inbox: ${coordInbox.length} messages`);
-
-        const helpNeeded = coordInbox.find(
-          (m) =>
-            m.content?.type === "event" &&
-            m.content?.event === "HELP_NEEDED"
-        );
-
-        const agentStopped = coordInbox.find(
-          (m) =>
-            m.content?.type === "event" &&
-            m.content?.event === "agent_stopped" &&
-            m.content?.data?.agentId === worker.id
-        );
-
-        if (helpNeeded) {
-          log("HELP_NEEDED signal found in coordinator inbox!");
-          expect(helpNeeded.content.data.agentId).toBe(worker.id);
-        }
-
-        // Log all lifecycle messages for debugging
-        const lifecycleMsgs = coordInbox.filter(
-          (m) => m.content?.type === "event"
-        );
-        for (const msg of lifecycleMsgs) {
-          log(`  event=${msg.content.event}, from=${msg.sender_id}, data=${JSON.stringify(msg.content.data).slice(0, 100)}`);
-        }
-
-        // If the worker was blocked, it should either:
-        // 1. Still be running (blocked handler returns shouldTerminate=false), or
-        // 2. Have HELP_NEEDED in parent inbox
-        if (workerRecord.state === "running") {
-          log("Worker still running after blocked done() -- correct behavior!");
-          expect(system.agentManager.hasActiveSession(worker.id)).toBe(true);
-        } else if (helpNeeded || agentStopped) {
-          log("Worker was terminated but parent received lifecycle notification");
-          expect(lifecycleMsgs.length).toBeGreaterThanOrEqual(1);
-        }
-      } else {
-        // Agent did not call done -- log what happened
-        const text = getTextContent(result.updates);
-        log(`Worker didn't call done(). Response: ${text.slice(0, 300)}`);
-        const allToolCalls = findToolCalls(result.updates);
-        log(`Tool calls: ${allToolCalls.map(t => t.name).join(", ") || "none"}`);
-      }
-
-      log("Test complete");
-    },
-    TIMEOUT.MULTI
-  );
-
-  // ── promptUntilDone follow-up ─────────────────────────────────
-
-  it(
-    "should follow up with the agent until done is called via promptUntilDone",
-    async () => {
-      log("Spawning worker...");
-      const worker = await system.agentManager.spawn({
-        task: "You are a worker. When instructed, create files and then call done().",
-        role: "worker",
-        cwd: testRepo.path,
-      });
-
-      log(`Worker: ${worker.id}`);
-
-      // Use promptUntilDone with a task that may not immediately call done()
-      // The follow-up mechanism should remind the agent to call done()
-      log("Using promptUntilDone with maxFollowUps=2...");
-      const result = await system.agentManager.promptUntilDone(
-        worker.id,
-        `Create a file at ${testRepo.path}/test.txt with content "hello". After creating the file, call the "done" MCP tool with status="completed" and summary="Created test.txt".`,
-        {
-          maxFollowUps: 2,
-          onUpdate: (update: any) => {
-            if (update.sessionUpdate === "tool_call") {
-              log(`  [tool_call] ${update.title ?? "unknown"}`);
-            }
-          },
-        }
-      );
-
-      log(`promptUntilDone: doneCalled=${result.doneCalled}, doneStatus=${result.doneStatus}, totalUpdates=${result.updates.length}`);
-
-      // Check if the file was created (verifies agent did real work)
-      const filePath = path.join(testRepo.path, "test.txt");
-      const fileCreated = fs.existsSync(filePath);
-      log(`File created: ${fileCreated}`);
-      if (fileCreated) {
-        const content = fs.readFileSync(filePath, "utf-8");
-        log(`File content: "${content.trim()}"`);
-      }
-
-      // Check all tool calls made during the interaction
-      const toolCalls = findToolCalls(result.updates);
-      log(`All tool calls: ${toolCalls.map(t => t.name).join(", ") || "none"}`);
-
-      if (result.doneCalled) {
-        log(`done() called with status=${result.doneStatus}`);
-        // Verify the agent did call done eventually (possibly after follow-up)
-        expect(result.doneCalled).toBe(true);
-      } else {
-        // Even if done wasn't called, the follow-up mechanism should have tried
-        const text = getTextContent(result.updates);
-        log(`Agent response: ${text.slice(0, 300)}`);
-        log("Note: Agent may not have called done despite follow-ups (model discretion)");
-      }
-
-      // Verify the agent is still in a valid state
-      const workerRecord = system.agentStore.getAgent(worker.id)!;
-      log(`Worker final state: ${workerRecord.state}`);
-
-      log("Test complete");
-    },
-    TIMEOUT.MULTI
-  );
-});