macro-agent 0.1.7 → 0.1.10

package/src/__tests__/e2e/spawn-resolver.e2e.test.ts

@@ -0,0 +1,200 @@
+/**
+ * SpawnResolverStrategy real-spawn e2e.
+ *
+ * Exercises the full conflict recovery flow:
+ *   1. Set up a real conflict (two streams with conflicting changes)
+ *   2. SpawnResolverStrategy.recover() actually spawns a resolver agent
+ *      via AgentManager (mocked Claude Code)
+ *   3. The resolver calls workspaceManager.resolveConflict() which emits
+ *      conflict:resolved
+ *   4. The awaiting recover() Promise resolves
+ *
+ * Uses mocked acp-factory — focus is on the orchestration, not on an LLM
+ * actually resolving conflicts.
+ *
+ * REQUIRES: RUN_E2E_TESTS=true
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } 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 { GitCascadeAdapter } from '../../workspace/git-cascade-adapter.js';
+import {
+  DefaultWorkspaceManager,
+  createWorkspaceManagerWithAdapter,
+} from '../../workspace/workspace-manager.js';
+import { createSpawnResolverStrategy } from '../../workspace/recovery/spawn-resolver.js';
+import type { ConflictContext } from '../../workspace/recovery/types.js';
+
+const RUN_E2E = !!process.env.RUN_E2E_TESTS;
+const describeFn = RUN_E2E ? describe : describe.skip;
+
+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('SpawnResolver real-spawn e2e', () => {
+  let system: MacroAgentSystemV2;
+  let testDir: string;
+  let repoPath: string;
+  let adapter: GitCascadeAdapter;
+  let workspaceManager: DefaultWorkspaceManager;
+
+  beforeEach(async () => {
+    testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'spawn-resolver-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,
+    });
+  });
+
+  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('spawns a real resolver agent and resolves via workspaceManager.resolveConflict', async () => {
+    // Set up: conflicted stream
+    const streamId = workspaceManager.createStreamV3({
+      name: 'conflicted-feature',
+      ownerId: 'team:test',
+      forkFrom: 'main',
+    });
+    const conflictId = adapter.createConflict({
+      streamId,
+      conflictingCommit: '0'.repeat(40),
+      targetCommit: '0'.repeat(40),
+      conflictedFiles: ['auth.ts'],
+    });
+
+    // Construct the strategy with AgentManager injection
+    const strategy = createSpawnResolverStrategy({
+      agentManager: system.agentManager,
+      defaultRole: 'worker', // using built-in worker role (has spawn capability)
+      defaultTimeoutMs: 10_000,
+    });
+
+    const ctx: ConflictContext = {
+      conflictId,
+      streamId,
+      paths: ['auth.ts'],
+      operation: 'merge',
+      recoveryDepth: 0,
+      workspaceManager,
+      strategyConfig: { role: 'worker', timeout_ms: 10_000 },
+    };
+
+    // Kick off recovery. Strategy spawns a resolver agent, then awaits
+    // conflict:resolved. We simulate the resolver's tool call by invoking
+    // workspaceManager.resolveConflict directly after a small delay.
+    const recoveryPromise = strategy.recover(ctx);
+
+    // Give the strategy time to spawn + subscribe
+    await new Promise((r) => setTimeout(r, 100));
+
+    // Simulate resolver finishing its work
+    workspaceManager.resolveConflict({
+      conflictId,
+      resolvedBy: 'agent_resolver_stub',
+      resolutionCommit: 'abc123def456',
+    });
+
+    const resolution = await recoveryPromise;
+    expect(resolution.kind).toBe('resolved');
+    if (resolution.kind === 'resolved') {
+      expect(resolution.resolutionCommit).toBe('abc123def456');
+    }
+
+    // A resolver agent should have actually been spawned by AgentManager
+    const agents = system.agentStore.listAgents({});
+    const resolverAgents = agents.filter((a) => a.role === 'worker');
+    expect(resolverAgents.length).toBeGreaterThan(0);
+  });
+
+  it('escalates to human on timeout (no resolve_conflict call)', async () => {
+    const streamId = workspaceManager.createStreamV3({
+      name: 'timeout-feature',
+      ownerId: 'team:test',
+      forkFrom: 'main',
+    });
+    const conflictId = adapter.createConflict({
+      streamId,
+      conflictingCommit: '0'.repeat(40),
+      targetCommit: '0'.repeat(40),
+      conflictedFiles: ['x.ts'],
+    });
+
+    const strategy = createSpawnResolverStrategy({
+      agentManager: system.agentManager,
+      defaultRole: 'worker',
+      defaultTimeoutMs: 200, // short timeout to force escalation
+    });
+
+    const resolution = await strategy.recover({
+      conflictId,
+      streamId,
+      paths: ['x.ts'],
+      operation: 'merge',
+      recoveryDepth: 0,
+      workspaceManager,
+      strategyConfig: { role: 'worker' },
+    });
+
+    expect(resolution.kind).toBe('escalated');
+    if (resolution.kind === 'escalated') {
+      expect(resolution.escalatedTo).toBe('human');
+    }
+  });
+});

package/src/__tests__/e2e/workspace-lifecycle.e2e.test.ts

@@ -1,17 +1,25 @@
 /**
- * Workspace Lifecycle E2E Tests
+ * Workspace Lifecycle E2E Tests — LEGACY capability-dispatch path.
  *
- * Tests workspace isolation infrastructure through the V2 stack:
+ * These tests exercise the programmatic/capability-based spawn flow:
+ * callers pass `capabilities: ["workspace.worktree"|"workspace.stream"|
+ * "workspace.integrate"]` + `streamId`/`streamConfig` to `agentManager.spawn`,
+ * and AgentManagerV2's `legacyCapabilityDispatch` allocates workspaces via
+ * `WorkspaceManager.createWorkerWorkspace` / `createIntegratorWorkspace` /
+ * `createCoordinatorWorkspace`.
+ *
+ * This path remains supported for programmatic callers that don't use team
+ * YAML (e.g., tools, libraries). The V3 YAML-driven path is covered by
+ * `workspace-v3.e2e.test.ts`.
+ *
+ * Scenarios verified:
  * - Boot with WorkspaceManager wired correctly
- * - Worker spawn creates worktree
- * - Worker terminate submits merge request
- * - Cascade terminate cleans up worktrees
- * - Coordinator creates integration stream
+ * - Worker spawn creates worktree (capability-based)
+ * - Worker terminate submits merge request to (legacy) MergeQueue
+ * - Cascade terminate cleans up child worktrees
+ * - Coordinator creates integration stream via `workspace.stream` capability
  *
  * REQUIRES: RUN_E2E_TESTS=true (no real Claude Code agents)
- *
- * Run with:
- *   RUN_E2E_TESTS=true npx vitest run --config vitest.e2e.config.ts src/__tests__/e2e/workspace-lifecycle.e2e.test.ts
  */
 
 import {
@@ -27,7 +35,7 @@ import * as os from "os";
 import * as fs from "fs";
 import { execSync } from "child_process";
 import { bootV2, type MacroAgentSystemV2 } from "../../boot-v2.js";
-import { DataplaneAdapter } from "../../workspace/dataplane-adapter.js";
+import { GitCascadeAdapter } from "../../workspace/git-cascade-adapter.js";
 import {
   DefaultWorkspaceManager,
   createWorkspaceManagerWithAdapter,
@@ -121,17 +129,17 @@ describeFn("Workspace Lifecycle E2E", () => {
   let system: MacroAgentSystemV2;
   let testDir: string;
   let repoPath: string;
-  let adapter: DataplaneAdapter;
+  let adapter: GitCascadeAdapter;
   let workspaceManager: DefaultWorkspaceManager;
 
   beforeEach(async () => {
     testDir = createTestDir();
     repoPath = createGitRepo(testDir);
 
-    const dbPath = path.join(testDir, "dataplane.db");
+    const dbPath = path.join(testDir, "git-cascade.db");
 
-    // Create DataplaneAdapter and WorkspaceManager
-    adapter = new DataplaneAdapter({
+    // Create GitCascadeAdapter and WorkspaceManager
+    adapter = new GitCascadeAdapter({
       enabled: true,
       repoPath,
       dbPath,
@@ -191,17 +199,17 @@ describeFn("Workspace Lifecycle E2E", () => {
       });
       expect(streamId).toBeDefined();
 
-      // Pre-create a dataplane task so the claimTask call can find it
+      // Pre-create a git-cascade task so the claimTask call can find it
       const dpTaskId = workspaceManager.createTask(streamId, {
         title: "Implement feature",
       });
 
-      // Spawn a worker with the streamId and dataplaneTaskId
+      // Spawn a worker with the streamId and gitCascadeTaskId
       const worker = await system.agentManager.spawn({
         task: "Implement feature",
         role: "worker",
         streamId,
-        dataplaneTaskId: dpTaskId,
+        gitCascadeTaskId: dpTaskId,
         capabilities: ["workspace.worktree"],
       });
 
@@ -234,7 +242,7 @@ describeFn("Workspace Lifecycle E2E", () => {
         name: "merge-feature",
       });
 
-      // Pre-create dataplane task
+      // Pre-create git-cascade task
       const dpTaskId = workspaceManager.createTask(streamId, {
         title: "Do work for merge",
       });
@@ -244,7 +252,7 @@ describeFn("Workspace Lifecycle E2E", () => {
         task: "Do work for merge",
         role: "worker",
         streamId,
-        dataplaneTaskId: dpTaskId,
+        gitCascadeTaskId: dpTaskId,
         capabilities: ["workspace.worktree"],
       });
 
@@ -294,7 +302,7 @@ describeFn("Workspace Lifecycle E2E", () => {
         { name: "cascade-feature" }
       );
 
-      // Pre-create dataplane tasks
+      // Pre-create git-cascade tasks
       const dpTaskId1 = workspaceManager.createTask(streamId, {
         title: "Child 1",
       });
@@ -308,7 +316,7 @@ describeFn("Workspace Lifecycle E2E", () => {
         role: "worker",
         parent: coordinator.id,
         streamId,
-        dataplaneTaskId: dpTaskId1,
+        gitCascadeTaskId: dpTaskId1,
         capabilities: ["workspace.worktree"],
       });
       const child2 = await system.agentManager.spawn({
@@ -316,7 +324,7 @@ describeFn("Workspace Lifecycle E2E", () => {
         role: "worker",
         parent: coordinator.id,
         streamId,
-        dataplaneTaskId: dpTaskId2,
+        gitCascadeTaskId: dpTaskId2,
         capabilities: ["workspace.worktree"],
       });