macro-agent 0.1.7 → 0.1.10

package/src/workspace/merge-queue/merge-queue.ts

@@ -4,6 +4,13 @@
  * Coordinates merging of parallel worker branches into the integration branch.
  * Workers submit completed work; Integrator processes sequentially.
  *
+ * @deprecated Since v3 workspace redesign. Duplicates git-cascade's built-in
+ *   `mergeQueue` module. New code uses `GitCascadeAdapter.addToMergeQueue`
+ *   via `LandingStrategy` ("queue-to-branch"). Kept to preserve the legacy
+ *   role-name dispatch path until teams migrate to `macro_agent.workspace`
+ *   YAML. Scheduled for removal; see `docs/workspace-redesign-plan.md`
+ *   Phases 6/8/9.
+ *
  * @module workspace/merge-queue/merge-queue
  * @implements [[s-bcqm]] Merge Queue section
  */
@@ -99,6 +106,9 @@ export interface MergeQueueConfig {
  * MergeQueue implementation.
  *
  * Manages merge requests for coordinating parallel worker merges.
+ *
+ * @deprecated Use git-cascade's built-in queue via
+ *   `GitCascadeAdapter.addToMergeQueue` / `getNextToMerge`. See module doc.
  */
 export class MergeQueue implements MergeQueueInterface {
   private readonly db: Database.Database;

package/src/workspace/merge-queue/types.ts

@@ -3,6 +3,15 @@
  *
  * Types for the merge queue layer that coordinates parallel worker merges.
  *
+ * @deprecated Since v3 workspace redesign. This module duplicates git-cascade's
+ *   built-in `mergeQueue` (see `GitCascadeAdapter.addToMergeQueue`,
+ *   `getNextToMerge`, etc.). New code should use `LandingStrategy`
+ *   ("queue-to-branch") + git-cascade's queue directly. Kept in place to
+ *   preserve the legacy role-name dispatch path (coordinator/worker/integrator)
+ *   until teams migrate to `macro_agent.workspace` YAML. Scheduled for
+ *   removal once self-driving is migrated. See `docs/workspace-redesign-plan.md`
+ *   Phases 6/8/9.
+ *
  * @module workspace/merge-queue/types
  * @implements [[s-bcqm]] Merge Queue Schema section
  */
@@ -36,7 +45,7 @@ export interface MergeRequest {
   /** Stream (integration branch) this MR targets */
   streamId: string;
 
-  /** Dataplane task ID this MR completes */
+  /** git-cascade task ID this MR completes */
   taskId: string;
 
   /** Git branch containing the worker's changes */
@@ -83,7 +92,7 @@ export interface SubmitMergeRequestOptions {
   /** Stream (integration branch) to merge into */
   streamId: string;
 
-  /** Dataplane task ID this completes */
+  /** git-cascade task ID this completes */
   taskId: string;
 
   /** Git branch containing the worker's changes */
@@ -141,6 +150,11 @@ export type MergeQueueEventCallback = (event: MergeQueueEvent) => void;
  * Coordinates merging of parallel worker branches into the integration branch.
  * Workers submit completed work; Integrator processes sequentially.
  */
+/**
+ * @deprecated Use git-cascade's built-in merge queue via
+ *   `GitCascadeAdapter.addToMergeQueue` / `getNextToMerge` etc. See module
+ *   doc for migration guidance.
+ */
 export interface MergeQueueInterface {
   // ─────────────────────────────────────────────────────────────────────────────
   // Submit

package/src/workspace/pool/__tests__/worktree-pool.integration.test.ts

@@ -18,7 +18,7 @@ import { execSync } from 'child_process';
 import Database from 'better-sqlite3';
 import { WorktreePool } from '../worktree-pool.js';
 import { createWorkspaceManager, DefaultWorkspaceManager } from '../../workspace-manager.js';
-import { createDataplaneAdapter, DataplaneAdapter } from '../../dataplane-adapter.js';
+import { createGitCascadeAdapter, GitCascadeAdapter } from '../../git-cascade-adapter.js';
 import type { PoolEvent, PoolStats } from '../types.js';
 import type { WorkerWorkspace, IntegratorWorkspace, CoordinatorWorkspace } from '../../types.js';
 
@@ -694,12 +694,12 @@ describe('WorktreePool Integration', () => {
 
   describe('WorkspaceManager integration', () => {
     let db: Database.Database;
-    let adapter: DataplaneAdapter;
+    let adapter: GitCascadeAdapter;
     let manager: DefaultWorkspaceManager;
 
     beforeEach(() => {
       db = new Database(dbPath);
-      adapter = createDataplaneAdapter({
+      adapter = createGitCascadeAdapter({
         enabled: true,
         repoPath,
         db,
@@ -944,12 +944,12 @@ describe('WorktreePool Integration', () => {
 
   describe('full lifecycle with pool', () => {
     let db: Database.Database;
-    let adapter: DataplaneAdapter;
+    let adapter: GitCascadeAdapter;
     let manager: DefaultWorkspaceManager;
 
     beforeEach(() => {
       db = new Database(dbPath);
-      adapter = createDataplaneAdapter({
+      adapter = createGitCascadeAdapter({
         enabled: true,
         repoPath,
         db,

package/src/workspace/pool/types.ts

@@ -147,6 +147,7 @@ export interface PoolStats {
     worker: number;
     integrator: number;
     coordinator: number;
+    v3: number;
   };
 }
 

package/src/workspace/pool/worktree-pool.ts

@@ -484,6 +484,7 @@ export class WorktreePool implements WorktreePoolInterface {
         worker: 0,
         integrator: 0,
         coordinator: 0,
+        v3: 0,
       },
     };
 

package/src/workspace/recovery/__tests__/auto-resolve-integration.test.ts

@@ -0,0 +1,127 @@
+/**
+ * AutoResolveStrategy integration tests.
+ *
+ * Creates a real merge conflict in a temp git repo and verifies the strategy
+ * replays the merge with `ours`/`theirs` and commits the resolution.
+ */
+
+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 { AutoResolveStrategy } from '../auto-resolve.js';
+import type { WorkspaceManager } from '../../types.js';
+import type { ConflictContext } from '../types.js';
+
+function mockWorkspaceManager(): WorkspaceManager {
+  return {
+    resolveConflict: vi.fn(),
+  } as unknown as WorkspaceManager;
+}
+
+function sh(cmd: string, cwd: string): string {
+  return execSync(cmd, { cwd, stdio: ['pipe', 'pipe', 'pipe'], encoding: 'utf-8' }).trim();
+}
+
+describe('AutoResolveStrategy (real git)', () => {
+  let tempDir: string;
+  let repoPath: string;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'auto-resolve-'));
+    repoPath = path.join(tempDir, 'repo');
+    fs.mkdirSync(repoPath);
+
+    sh('git init -b main', repoPath);
+    sh('git config user.email "t@t.com"', repoPath);
+    sh('git config user.name "T"', repoPath);
+
+    // Base commit
+    fs.writeFileSync(path.join(repoPath, 'f.txt'), 'base\n');
+    sh('git add .', repoPath);
+    sh('git commit -m "base"', repoPath);
+
+    // Branch A (main) with change
+    fs.writeFileSync(path.join(repoPath, 'f.txt'), 'main-change\n');
+    sh('git add .', repoPath);
+    sh('git commit -m "main change"', repoPath);
+
+    // Branch B with conflicting change
+    sh('git checkout -b feature HEAD~1', repoPath);
+    fs.writeFileSync(path.join(repoPath, 'f.txt'), 'feature-change\n');
+    sh('git add .', repoPath);
+    sh('git commit -m "feature change"', repoPath);
+
+    // Checkout main + attempt merge (conflicts)
+    sh('git checkout main', repoPath);
+    try {
+      sh('git merge feature --no-edit', repoPath);
+    } catch {
+      // Expected — creates the conflict state
+    }
+    // Abort so AutoResolve starts from a clean state; it will re-trigger
+    // the merge via `git merge -X <strategy>`.
+    sh('git merge --abort', repoPath);
+  });
+
+  afterEach(() => {
+    if (fs.existsSync(tempDir)) {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+
+  it('resolves with -X ours — keeps main-change', async () => {
+    const strat = new AutoResolveStrategy();
+    const ws = mockWorkspaceManager();
+
+    const ctx: ConflictContext = {
+      conflictId: 'c-test',
+      streamId: 's-1',
+      paths: ['f.txt'],
+      operation: 'merge',
+      worktree: repoPath,
+      sourceCommit: 'feature',
+      recoveryDepth: 0,
+      strategyConfig: { strategy: 'ours' },
+      workspaceManager: ws,
+    };
+
+    const result = await strat.recover(ctx);
+
+    expect(result.kind).toBe('resolved');
+    if (result.kind === 'resolved') {
+      expect(result.resolutionCommit).toMatch(/^[0-9a-f]+$/);
+    }
+
+    // Verify file has the 'ours' version
+    expect(fs.readFileSync(path.join(repoPath, 'f.txt'), 'utf-8')).toBe('main-change\n');
+
+    // WorkspaceManager.resolveConflict was notified
+    expect(ws.resolveConflict).toHaveBeenCalledWith(
+      expect.objectContaining({ conflictId: 'c-test' })
+    );
+  });
+
+  it('resolves with -X theirs — keeps feature-change', async () => {
+    const strat = new AutoResolveStrategy();
+    const ws = mockWorkspaceManager();
+
+    const ctx: ConflictContext = {
+      conflictId: 'c-test',
+      streamId: 's-1',
+      paths: ['f.txt'],
+      operation: 'merge',
+      worktree: repoPath,
+      sourceCommit: 'feature',
+      recoveryDepth: 0,
+      strategyConfig: { strategy: 'theirs' },
+      workspaceManager: ws,
+    };
+
+    const result = await strat.recover(ctx);
+
+    expect(result.kind).toBe('resolved');
+    expect(fs.readFileSync(path.join(repoPath, 'f.txt'), 'utf-8')).toBe('feature-change\n');
+  });
+});

package/src/workspace/recovery/__tests__/spawn-resolver.test.ts

@@ -0,0 +1,139 @@
+/**
+ * SpawnResolverStrategy tests (Phase 7b).
+ */
+
+import { describe, it, expect, vi } from 'vitest';
+import {
+  SpawnResolverStrategy,
+  createSpawnResolverStrategy,
+} from '../spawn-resolver.js';
+import type { ConflictContext } from '../types.js';
+import type { WorkspaceManager } from '../../types.js';
+import type { AgentManager } from '../../../agent/agent-manager.js';
+
+type EventListener = (event: { type: string; data: Record<string, unknown> }) => void;
+
+function mockManagers(): {
+  ws: WorkspaceManager;
+  am: AgentManager;
+  triggerResolved: (conflictId: string, commit: string) => void;
+} {
+  const listeners = new Set<EventListener>();
+
+  const ws = {
+    onEvent: vi.fn((cb: EventListener) => {
+      listeners.add(cb);
+      return () => listeners.delete(cb);
+    }),
+  } as unknown as WorkspaceManager;
+
+  const am = {
+    spawn: vi.fn().mockResolvedValue({ id: 'resolver-agent-1' }),
+  } as unknown as AgentManager;
+
+  const triggerResolved = (conflictId: string, commit: string) => {
+    for (const listener of listeners) {
+      listener({
+        type: 'conflict:resolved',
+        data: { conflictId, resolutionCommit: commit },
+      });
+    }
+  };
+
+  return { ws, am, triggerResolved };
+}
+
+function mockContext(ws: WorkspaceManager, overrides: Partial<ConflictContext> = {}): ConflictContext {
+  return {
+    conflictId: 'c-1',
+    streamId: 'stream-1',
+    paths: ['a.ts'],
+    operation: 'merge',
+    recoveryDepth: 0,
+    workspaceManager: ws,
+    ...overrides,
+  };
+}
+
+describe('SpawnResolverStrategy', () => {
+  it('spawns a resolver with the configured role and awaits resolve', async () => {
+    const { ws, am, triggerResolved } = mockManagers();
+    const strat = createSpawnResolverStrategy({ agentManager: am });
+
+    const ctx = mockContext(ws, {
+      strategyConfig: { role: 'resolver', timeout_ms: 5000 },
+    });
+
+    const recoveryPromise = strat.recover(ctx);
+
+    // Allow spawn + onEvent registration to complete
+    await new Promise((r) => setTimeout(r, 10));
+
+    expect(am.spawn).toHaveBeenCalledWith(
+      expect.objectContaining({
+        role: 'resolver',
+        capabilities: expect.arrayContaining(['workspace.resolve']),
+      })
+    );
+
+    // Simulate resolver agent calling resolve_conflict
+    triggerResolved('c-1', 'abc123');
+
+    const resolution = await recoveryPromise;
+    expect(resolution.kind).toBe('resolved');
+    if (resolution.kind === 'resolved') {
+      expect(resolution.resolutionCommit).toBe('abc123');
+    }
+  });
+
+  it('escalates on timeout', async () => {
+    const { ws, am } = mockManagers();
+    const strat = createSpawnResolverStrategy({
+      agentManager: am,
+      defaultTimeoutMs: 50, // short timeout for test
+    });
+
+    const ctx = mockContext(ws);
+    const resolution = await strat.recover(ctx);
+
+    expect(resolution.kind).toBe('escalated');
+    if (resolution.kind === 'escalated') {
+      expect(resolution.escalatedTo).toBe('human');
+    }
+  });
+
+  it('returns retry-after when max_concurrent exceeded', async () => {
+    const { ws, am, triggerResolved } = mockManagers();
+    const strat = createSpawnResolverStrategy({
+      agentManager: am,
+      defaultMaxConcurrent: 1,
+      defaultTimeoutMs: 5000,
+    });
+
+    // First resolver is still pending
+    const first = strat.recover(mockContext(ws));
+    await new Promise((r) => setTimeout(r, 10));
+
+    // Second try — exceeds max
+    const second = await strat.recover(mockContext(ws));
+    expect(second.kind).toBe('retry-after');
+
+    // Resolve the first so it cleans up
+    triggerResolved('c-1', 'commit');
+    await first;
+  });
+
+  it('returns failed when spawn itself fails', async () => {
+    const { ws } = mockManagers();
+    const am = {
+      spawn: vi.fn().mockRejectedValue(new Error('spawn boom')),
+    } as unknown as AgentManager;
+    const strat = new SpawnResolverStrategy({ agentManager: am });
+
+    const resolution = await strat.recover(mockContext(ws));
+    expect(resolution.kind).toBe('failed');
+    if (resolution.kind === 'failed') {
+      expect(resolution.error).toMatch(/spawn boom/);
+    }
+  });
+});

package/src/workspace/recovery/__tests__/strategies.test.ts

@@ -0,0 +1,145 @@
+/**
+ * Conflict recovery strategy tests (Phase 7).
+ */
+
+import { describe, it, expect, vi } from 'vitest';
+import {
+  DeferStrategy,
+  AbandonStrategy,
+  EscalateStrategy,
+  AutoResolveStrategy,
+  buildBuiltinRecoveryRegistry,
+} from '../index.js';
+import type { ConflictContext } from '../types.js';
+import type { WorkspaceManager } from '../../types.js';
+
+function mockContext(overrides: Partial<ConflictContext> = {}): ConflictContext {
+  const ws = {
+    abandonStream: vi.fn(),
+    pauseStream: vi.fn(),
+  } as unknown as WorkspaceManager;
+  return {
+    conflictId: 'c-1',
+    streamId: 'stream-1',
+    paths: ['a.ts'],
+    operation: 'merge',
+    recoveryDepth: 0,
+    workspaceManager: ws,
+    ...overrides,
+  };
+}
+
+describe('conflict recovery strategies', () => {
+  describe('DeferStrategy', () => {
+    it('returns { kind: deferred }', async () => {
+      const strat = new DeferStrategy();
+      const res = await strat.recover(mockContext());
+      expect(res.kind).toBe('deferred');
+    });
+  });
+
+  describe('AbandonStrategy', () => {
+    it('abandons the stream and returns { kind: abandoned }', async () => {
+      const strat = new AbandonStrategy();
+      const ctx = mockContext();
+      const res = await strat.recover(ctx);
+      expect(res.kind).toBe('abandoned');
+      expect(ctx.workspaceManager.abandonStream).toHaveBeenCalledWith(
+        'stream-1',
+        expect.objectContaining({ reason: expect.stringContaining('c-1') })
+      );
+    });
+
+    it('returns { kind: failed } on abandon error', async () => {
+      const strat = new AbandonStrategy();
+      const ctx = mockContext();
+      (ctx.workspaceManager.abandonStream as any) = vi.fn(() => {
+        throw new Error('boom');
+      });
+      const res = await strat.recover(ctx);
+      expect(res.kind).toBe('failed');
+      if (res.kind === 'failed') {
+        expect(res.error).toContain('boom');
+      }
+    });
+  });
+
+  describe('EscalateStrategy', () => {
+    it('pauses the stream and returns { kind: escalated }', async () => {
+      const strat = new EscalateStrategy();
+      const ctx = mockContext();
+      const res = await strat.recover(ctx);
+      expect(res.kind).toBe('escalated');
+      expect(ctx.workspaceManager.pauseStream).toHaveBeenCalledWith(
+        'stream-1',
+        expect.any(String)
+      );
+    });
+
+    it('uses notify config when provided', async () => {
+      const strat = new EscalateStrategy();
+      const ctx = mockContext({
+        strategyConfig: { notify: 'team:alpha' },
+      });
+      const res = await strat.recover(ctx);
+      expect(res.kind).toBe('escalated');
+      if (res.kind === 'escalated') {
+        expect(res.escalatedTo).toBe('team:alpha');
+      }
+    });
+  });
+
+  describe('AutoResolveStrategy', () => {
+    it('canHandle requires merge operation + worktree', () => {
+      const strat = new AutoResolveStrategy();
+      expect(
+        strat.canHandle!(mockContext({ operation: 'merge', worktree: '/tmp/wt' }))
+      ).toBe(true);
+      expect(strat.canHandle!(mockContext({ operation: 'merge' }))).toBe(false);
+      expect(
+        strat.canHandle!(mockContext({ operation: 'rebase', worktree: '/tmp/wt' }))
+      ).toBe(false);
+    });
+
+    it('returns failed for non-merge operations', async () => {
+      const strat = new AutoResolveStrategy();
+      const res = await strat.recover(mockContext({ operation: 'rebase' }));
+      expect(res.kind).toBe('failed');
+    });
+
+    it('returns failed without worktree', async () => {
+      const strat = new AutoResolveStrategy();
+      const res = await strat.recover(mockContext({ operation: 'merge' }));
+      expect(res.kind).toBe('failed');
+      if (res.kind === 'failed') {
+        expect(res.error).toMatch(/worktree/);
+      }
+    });
+
+    it('rejects unsupported strategies', async () => {
+      const strat = new AutoResolveStrategy();
+      const res = await strat.recover(
+        mockContext({
+          operation: 'merge',
+          worktree: '/tmp/wt',
+          strategyConfig: { strategy: 'bogus' },
+        })
+      );
+      expect(res.kind).toBe('failed');
+      if (res.kind === 'failed') {
+        expect(res.error).toMatch(/unsupported strategy/);
+      }
+    });
+  });
+
+  describe('buildBuiltinRecoveryRegistry', () => {
+    it('includes 4 built-in strategies', () => {
+      const registry = buildBuiltinRecoveryRegistry();
+      expect(registry.has('defer')).toBe(true);
+      expect(registry.has('abandon')).toBe(true);
+      expect(registry.has('escalate')).toBe(true);
+      expect(registry.has('auto-resolve')).toBe(true);
+      expect(registry.has('spawn-resolver')).toBe(false); // Phase 7b
+    });
+  });
+});

package/src/workspace/recovery/abandon.ts

@@ -0,0 +1,51 @@
+/**
+ * `abandon` conflict recovery strategy.
+ *
+ * Abandons the conflicted stream. Throwaway-exploration teams; CI-driven
+ * flows where broken work is discarded rather than resolved.
+ *
+ * @module workspace/recovery/abandon
+ */
+
+import type {
+  ConflictContext,
+  ConflictRecoveryStrategy,
+  ConflictResolution,
+} from './types.js';
+
+export class AbandonStrategy implements ConflictRecoveryStrategy {
+  readonly name = 'abandon';
+  readonly mode = 'sync' as const;
+
+  async recover(ctx: ConflictContext): Promise<ConflictResolution> {
+    try {
+      // Mark the conflict resolved (method='abandoned') so the OpenHive hub
+      // moves cascade_conflicts.status from pending → resolved instead of
+      // showing it stuck pending forever.
+      try {
+        ctx.workspaceManager.resolveConflict({
+          conflictId: ctx.conflictId,
+          resolvedBy: 'system:abandon',
+          method: 'abandoned',
+          summary: `stream abandoned: ${ctx.streamId}`,
+        });
+      } catch {
+        // Non-fatal — abandonStream below still runs
+      }
+
+      ctx.workspaceManager.abandonStream(ctx.streamId, {
+        reason: `abandon strategy: conflict ${ctx.conflictId}`,
+      });
+      return {
+        kind: 'abandoned',
+        streamId: ctx.streamId,
+        reason: `conflict ${ctx.conflictId}`,
+      };
+    } catch (err) {
+      return {
+        kind: 'failed',
+        error: err instanceof Error ? err.message : String(err),
+      };
+    }
+  }
+}