macro-agent 0.1.8 → 0.1.11

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

@@ -0,0 +1,376 @@
+/**
+ * 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/self-driving-v3.e2e.test.ts

@@ -0,0 +1,197 @@
+/**
+ * Self-driving team V3 end-to-end test.
+ *
+ * Exercises the complete path from a real team YAML on disk:
+ *   .multiagent/teams/self-driving/team.yaml
+ *   → TeamManagerV2.startTeam("self-driving")
+ *   → extracts macro_agent.workspace block
+ *   → constructs YamlDrivenTopology, installs on AgentManager
+ *   → onTeamStart creates the team root stream
+ *   → agents spawn with the correct V3 WorkspaceDecision per role
+ *
+ * Uses mocked acp-factory to avoid spawning real Claude Code — the purpose
+ * here is verifying the wiring, not agent behavior.
+ *
+ * REQUIRES: RUN_E2E_TESTS=true
+ */
+
+import {
+  describe,
+  it,
+  expect,
+  beforeEach,
+  afterEach,
+  vi,
+} from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { execSync } from 'child_process';
+import { bootV2, type MacroAgentSystemV2 } from '../../boot-v2.js';
+import { GitCascadeAdapter } from '../../workspace/git-cascade-adapter.js';
+import {
+  DefaultWorkspaceManager,
+  createWorkspaceManagerWithAdapter,
+} from '../../workspace/workspace-manager.js';
+import { TeamManagerV2 } from '../../teams/team-manager-v2.js';
+
+const RUN_E2E = !!process.env.RUN_E2E_TESTS;
+const describeFn = RUN_E2E ? describe : describe.skip;
+
+// Mock acp-factory so we don't spawn real Claude Code
+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' }),
+  })),
+}));
+
+describeFn('Self-driving team V3 auto-wire', () => {
+  let system: MacroAgentSystemV2;
+  let testDir: string;
+  let repoPath: string;
+  let adapter: GitCascadeAdapter;
+  let workspaceManager: DefaultWorkspaceManager;
+  let teamManager: TeamManagerV2;
+  const projectRoot = process.cwd();
+
+  beforeEach(async () => {
+    testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'self-driving-e2e-'));
+    repoPath = path.join(testDir, 'repo');
+    fs.mkdirSync(repoPath);
+
+    execSync('git init -b main', { cwd: repoPath, stdio: 'pipe' });
+    execSync('git config user.email "t@t.com"', { cwd: repoPath, stdio: 'pipe' });
+    execSync('git config user.name "T"', { cwd: repoPath, stdio: 'pipe' });
+    fs.writeFileSync(path.join(repoPath, 'README.md'), '# test');
+    execSync('git add .', { cwd: repoPath, stdio: 'pipe' });
+    execSync('git commit -m "init"', { cwd: repoPath, stdio: 'pipe' });
+
+    adapter = new GitCascadeAdapter({
+      enabled: true,
+      repoPath,
+      dbPath: path.join(testDir, 'gc.db'),
+      skipRecovery: true,
+    });
+    workspaceManager = createWorkspaceManagerWithAdapter(adapter, {
+      worktreeBaseDir: path.join(repoPath, '.worktrees'),
+    }) as DefaultWorkspaceManager;
+
+    system = await bootV2({
+      cwd: repoPath,
+      baseDir: testDir,
+      inbox: { socketPath: path.join(testDir, 'inbox.sock') },
+      workspaceManager,
+    });
+
+    teamManager = new TeamManagerV2({
+      agentManager: system.agentManager,
+      inboxAdapter: system.inboxAdapter,
+      tasksAdapter: system.tasksAdapter,
+      workspaceManager,
+    });
+    teamManager.install();
+  });
+
+  afterEach(async () => {
+    if (system) await system.shutdown();
+    if (workspaceManager) workspaceManager.close();
+    if (adapter) adapter.close();
+    if (fs.existsSync(testDir)) fs.rmSync(testDir, { recursive: true, force: true });
+  });
+
+  it('startTeam auto-wires YamlDrivenTopology from macro_agent.workspace', async () => {
+    // Start the real self-driving team template from .multiagent/teams/
+    await teamManager.startTeam('self-driving', projectRoot);
+
+    // Team root stream should have been created by onTeamStart
+    const streams = workspaceManager.listStreams();
+    const teamRoot = streams.find((s) => s.agentId === 'team:self-driving');
+    expect(teamRoot).toBeDefined();
+    expect(teamRoot!.name).toBe('self-driving');
+  });
+
+  it('spawning a grinder via the V3 path forks a stream off team root', async () => {
+    await teamManager.startTeam('self-driving', projectRoot);
+
+    const teamStreams = workspaceManager.listStreams();
+    const teamRoot = teamStreams.find((s) => s.agentId === 'team:self-driving');
+    expect(teamRoot).toBeDefined();
+
+    const grinder = await system.agentManager.spawn({
+      role: 'grinder',
+      task: 'do a thing',
+    });
+
+    const record = system.agentStore.getAgent(grinder.id);
+    expect(record?.workspace_path).toBeDefined();
+    expect(fs.existsSync(record!.workspace_path!)).toBe(true);
+
+    const grinderStream = workspaceManager
+      .listStreams()
+      .find((s) => s.agentId === grinder.id);
+    expect(grinderStream).toBeDefined();
+    expect(grinderStream?.parentStream).toBe(teamRoot!.id);
+  });
+
+  it('judge spawn returns workspace: none (no worktree allocated)', async () => {
+    await teamManager.startTeam('self-driving', projectRoot);
+
+    const judge = await system.agentManager.spawn({
+      role: 'judge',
+      task: 'review',
+    });
+
+    const record = system.agentStore.getAgent(judge.id);
+    // workspace: none → no workspace_path assigned
+    expect(record?.workspace_path).toBeFalsy();
+  });
+
+  it('planner attaches to team root stream (not a new fork)', async () => {
+    // Note: self-driving's topology already bootstraps the planner as the
+    // root agent; we spawn explicitly to verify the decision path.
+    await teamManager.startTeam('self-driving', projectRoot);
+
+    const plannerBeforeBootstrap = system.agentStore.listAgents({
+      state: 'running',
+    });
+
+    // The bootstrap planner is the "root" — already spawned.
+    const rootPlanner = plannerBeforeBootstrap.find((a) => a.role === 'planner');
+    expect(rootPlanner).toBeDefined();
+
+    // Verify its workspace_path (if allocated) is on the team root branch
+    if (rootPlanner?.workspace_path) {
+      expect(fs.existsSync(rootPlanner.workspace_path)).toBe(true);
+    }
+
+    // The team_root stream should still be the only top-level stream
+    // (planner did not fork a new stream — it attached)
+    const topLevelStreams = workspaceManager
+      .listStreams()
+      .filter((s) => !s.parentStream);
+    expect(topLevelStreams.length).toBe(1);
+  });
+});