macro-agent 0.1.8 → 0.1.11

package/src/workspace/__tests__/{dataplane-adapter.test.ts → git-cascade-adapter.test.ts}

@@ -1,7 +1,7 @@
 /**
- * DataplaneAdapter Tests
+ * GitCascadeAdapter Tests
  *
- * Tests for the dataplane integration adapter.
+ * Tests for the git-cascade integration adapter.
  */
 
 import { describe, it, expect, beforeEach, afterEach } from 'vitest';
@@ -9,17 +9,17 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
 import { execSync } from 'child_process';
-import { DataplaneAdapter, createDataplaneAdapter } from '../dataplane-adapter.js';
+import { GitCascadeAdapter, createGitCascadeAdapter } from '../git-cascade-adapter.js';
 
-describe('DataplaneAdapter', () => {
+describe('GitCascadeAdapter', () => {
   let tempDir: string;
   let repoPath: string;
   let dbPath: string;
-  let adapter: DataplaneAdapter | null = null;
+  let adapter: GitCascadeAdapter | null = null;
 
   beforeEach(() => {
     // Create temp directory
-    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'dataplane-test-'));
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'git-cascade-test-'));
     repoPath = path.join(tempDir, 'repo');
     dbPath = path.join(tempDir, 'test.db');
     fs.mkdirSync(repoPath);
@@ -50,7 +50,7 @@ describe('DataplaneAdapter', () => {
 
   describe('initialization', () => {
     it('should create adapter with default config', () => {
-      adapter = createDataplaneAdapter({
+      adapter = createGitCascadeAdapter({
         enabled: true,
         repoPath,
         dbPath,
@@ -61,7 +61,7 @@ describe('DataplaneAdapter', () => {
     });
 
     it('should create adapter with custom table prefix', () => {
-      adapter = createDataplaneAdapter({
+      adapter = createGitCascadeAdapter({
         enabled: true,
         repoPath,
         dbPath,
@@ -73,7 +73,7 @@ describe('DataplaneAdapter', () => {
 
     it('should use provided database path', () => {
       const dbPath = path.join(tempDir, 'custom.db');
-      adapter = createDataplaneAdapter({
+      adapter = createGitCascadeAdapter({
         enabled: true,
         repoPath,
         dbPath,
@@ -85,7 +85,7 @@ describe('DataplaneAdapter', () => {
 
   describe('stream operations', () => {
     beforeEach(() => {
-      adapter = createDataplaneAdapter({
+      adapter = createGitCascadeAdapter({
         enabled: true,
         repoPath,
         dbPath,
@@ -138,7 +138,7 @@ describe('DataplaneAdapter', () => {
     let streamId: string;
 
     beforeEach(() => {
-      adapter = createDataplaneAdapter({
+      adapter = createGitCascadeAdapter({
         enabled: true,
         repoPath,
         dbPath,
@@ -197,7 +197,7 @@ describe('DataplaneAdapter', () => {
 
   describe('health check', () => {
     beforeEach(() => {
-      adapter = createDataplaneAdapter({
+      adapter = createGitCascadeAdapter({
         enabled: true,
         repoPath,
         dbPath,
@@ -217,7 +217,7 @@ describe('DataplaneAdapter', () => {
 
   describe('event subscription', () => {
     beforeEach(() => {
-      adapter = createDataplaneAdapter({
+      adapter = createGitCascadeAdapter({
         enabled: true,
         repoPath,
         dbPath,
@@ -252,7 +252,7 @@ describe('DataplaneAdapter', () => {
     let worktreePath: string;
 
     beforeEach(() => {
-      adapter = createDataplaneAdapter({
+      adapter = createGitCascadeAdapter({
         enabled: true,
         repoPath,
         dbPath,
@@ -365,4 +365,199 @@ describe('DataplaneAdapter', () => {
       expect(checkpoints.length).toBeGreaterThanOrEqual(2);
     });
   });
+
+  // ───────────────────────────────────────────────────────────────────
+  // Phase 0 additive expansion — new surface coverage
+  // ───────────────────────────────────────────────────────────────────
+
+  describe('stream stacking (Phase 0)', () => {
+    beforeEach(() => {
+      adapter = createGitCascadeAdapter({
+        enabled: true,
+        repoPath,
+        dbPath,
+        skipRecovery: true,
+      });
+    });
+
+    it('forks a child stream off a parent', () => {
+      const parent = adapter!.createStream({ name: 'parent', agentId: 'agent-1' });
+      const child = adapter!.forkStream({
+        parentStreamId: parent,
+        name: 'child',
+        agentId: 'agent-2',
+      });
+
+      const childStream = adapter!.getStream(child);
+      expect(childStream?.parentStream).toBe(parent);
+    });
+
+    it('emits stream:forked on forkStream', () => {
+      const parent = adapter!.createStream({ name: 'parent', agentId: 'agent-1' });
+      const events: Array<{ type: string }> = [];
+      adapter!.onEvent((e) => events.push(e));
+
+      adapter!.forkStream({ parentStreamId: parent, name: 'child', agentId: 'agent-2' });
+
+      expect(events.some((e) => e.type === 'stream:forked')).toBe(true);
+    });
+
+    it('pauses and resumes a stream', () => {
+      const streamId = adapter!.createStream({ name: 'feat', agentId: 'a' });
+      adapter!.pauseStream(streamId, 'manual pause');
+      expect(adapter!.getStream(streamId)?.status).toBe('paused');
+      adapter!.resumeStream(streamId);
+      expect(adapter!.getStream(streamId)?.status).toBe('active');
+    });
+
+    it('tracks stream dependencies', () => {
+      const a = adapter!.createStream({ name: 'a', agentId: 'agent-1' });
+      const b = adapter!.createStream({ name: 'b', agentId: 'agent-1' });
+      adapter!.addDependency(b, a); // b depends on a
+
+      expect(adapter!.getDependencies(b)).toContain(a);
+      expect(adapter!.getDependents(a)).toContain(b);
+
+      adapter!.removeDependency(b, a);
+      expect(adapter!.getDependencies(b)).not.toContain(a);
+    });
+
+    it('returns stream hierarchy as tree', () => {
+      const root = adapter!.createStream({ name: 'root', agentId: 'a' });
+      const child = adapter!.forkStream({ parentStreamId: root, name: 'child', agentId: 'a' });
+
+      const hier = adapter!.getStreamHierarchy(root);
+      // Single root → StreamNode
+      const node = Array.isArray(hier) ? hier[0] : hier;
+      expect(node.stream.id).toBe(root);
+      expect(node.children.some((c) => c.stream.id === child)).toBe(true);
+    });
+  });
+
+  describe('merge queue (Phase 0, delegates to git-cascade built-in)', () => {
+    let streamId: string;
+    beforeEach(() => {
+      adapter = createGitCascadeAdapter({
+        enabled: true,
+        repoPath,
+        dbPath,
+        skipRecovery: true,
+      });
+      streamId = adapter!.createStream({ name: 'feat-q', agentId: 'agent-1' });
+    });
+
+    it('adds a stream to the queue and assigns a position', () => {
+      const entryId = adapter!.addToMergeQueue({ streamId, targetBranch: 'main', agentId: 'agent-1' });
+      expect(entryId).toBeDefined();
+
+      const pos = adapter!.getMergeQueuePosition(streamId, 'main');
+      expect(pos).not.toBeNull();
+
+      const entry = adapter!.getMergeQueueEntry(entryId);
+      expect(entry?.streamId).toBe(streamId);
+    });
+
+    it('lists entries filtered by status', () => {
+      adapter!.addToMergeQueue({ streamId, targetBranch: 'main', agentId: 'agent-1' });
+      const pending = adapter!.listMergeQueue({ targetBranch: 'main', status: 'pending' });
+      expect(pending.length).toBeGreaterThan(0);
+    });
+
+    it('marks an entry ready and cancels it', () => {
+      const entryId = adapter!.addToMergeQueue({ streamId, targetBranch: 'main', agentId: 'agent-1' });
+      adapter!.markMergeQueueReady(entryId);
+      expect(adapter!.getMergeQueueEntry(entryId)?.status).toBe('ready');
+
+      adapter!.cancelMergeQueueEntry(entryId);
+      expect(adapter!.getMergeQueueEntry(entryId)?.status).toBe('cancelled');
+    });
+
+    it('emits mergeQueue:added / :ready / :cancelled events', () => {
+      const seen: string[] = [];
+      adapter!.onEvent((e) => seen.push(e.type));
+
+      const entryId = adapter!.addToMergeQueue({ streamId, targetBranch: 'main', agentId: 'agent-1' });
+      adapter!.markMergeQueueReady(entryId);
+      adapter!.cancelMergeQueueEntry(entryId);
+
+      expect(seen).toContain('mergeQueue:added');
+      expect(seen).toContain('mergeQueue:ready');
+      expect(seen).toContain('mergeQueue:cancelled');
+    });
+  });
+
+  describe('conflicts (Phase 0)', () => {
+    let streamId: string;
+    beforeEach(() => {
+      adapter = createGitCascadeAdapter({
+        enabled: true,
+        repoPath,
+        dbPath,
+        skipRecovery: true,
+      });
+      streamId = adapter!.createStream({ name: 'feat-c', agentId: 'agent-1' });
+    });
+
+    const dummyCommit = '0000000000000000000000000000000000000000';
+
+    it('creates and retrieves a conflict record', () => {
+      const id = adapter!.createConflict({
+        streamId,
+        conflictingCommit: dummyCommit,
+        targetCommit: dummyCommit,
+        conflictedFiles: ['a.ts', 'b.ts'],
+      });
+      const record = adapter!.getConflict(id);
+      expect(record?.streamId).toBe(streamId);
+      expect(record?.conflictedFiles).toEqual(['a.ts', 'b.ts']);
+    });
+
+    it('gets the active conflict for a stream', () => {
+      adapter!.createConflict({
+        streamId,
+        conflictingCommit: dummyCommit,
+        targetCommit: dummyCommit,
+        conflictedFiles: ['x.ts'],
+      });
+      const record = adapter!.getConflictForStream(streamId);
+      expect(record).not.toBeNull();
+    });
+
+    it('emits conflict:created event', () => {
+      const events: Array<{ type: string }> = [];
+      adapter!.onEvent((e) => events.push(e));
+      adapter!.createConflict({
+        streamId,
+        conflictingCommit: dummyCommit,
+        targetCommit: dummyCommit,
+        conflictedFiles: ['x.ts'],
+      });
+      expect(events.some((e) => e.type === 'conflict:created')).toBe(true);
+    });
+  });
+
+  describe('reconcile (Phase 0)', () => {
+    beforeEach(() => {
+      adapter = createGitCascadeAdapter({
+        enabled: true,
+        repoPath,
+        dbPath,
+        skipRecovery: true,
+      });
+    });
+
+    it('checkStreamSync reports in-sync for a just-created stream', () => {
+      const streamId = adapter!.createStream({ name: 'feat-s', agentId: 'a' });
+      const status = adapter!.checkStreamSync(streamId);
+      expect(status).toBeDefined();
+      // Fresh stream should be in sync (no divergence yet)
+      expect(status.inSync).toBe(true);
+    });
+
+    it('reconcile runs without error on a healthy db', () => {
+      adapter!.createStream({ name: 'feat-r', agentId: 'a' });
+      const result = adapter!.reconcile({ dryRun: true });
+      expect(result).toBeDefined();
+    });
+  });
 });

package/src/workspace/__tests__/land-dispatch.test.ts

@@ -0,0 +1,214 @@
+/**
+ * WorkspaceManager.land() dispatcher tests (A2 follow-up).
+ *
+ * Closes the gap where `registerLandingStrategy` existed but no caller
+ * invoked `.land(ctx)` at `done()` time. Verifies the dispatcher:
+ *   - resolves strategy by name (internal or YAML form)
+ *   - respects `strategyName: 'none'` (short-circuits to success)
+ *   - errors out on unknown names
+ *   - fills in `ctx.workspaceManager` before invoking the strategy
+ *   - rejects when `canLand` returns false
+ *
+ * Unit-only — doesn't spin up git. The end-to-end path (strategy fires
+ * tracker events → hub projects) is covered by OpenHive's
+ * live-emission-e2e.test.ts.
+ */
+
+import { describe, it, expect, vi } from 'vitest';
+import type { GitCascadeAdapter } from '../git-cascade-adapter.js';
+import { DefaultWorkspaceManager, resolveLandingStrategyName } from '../workspace-manager.js';
+import type { LandingStrategy, LandingContext } from '../types-v3.js';
+
+// A no-op adapter stub that satisfies the DefaultWorkspaceManager constructor
+// without touching git. Every method the dispatcher path might hit throws so
+// accidental delegation is loud.
+function stubAdapter(): GitCascadeAdapter {
+  const throwing = (name: string) => () => {
+    throw new Error(`stub adapter: ${name} should not be called in this test`);
+  };
+  return {
+    close: vi.fn(),
+    reconcile: throwing('reconcile'),
+    listWorktrees: vi.fn(() => []),
+    getWorktree: vi.fn(() => null),
+  } as unknown as GitCascadeAdapter;
+}
+
+function makeTestStrategy(
+  name: string,
+  impl: (ctx: LandingContext) => ReturnType<LandingStrategy['land']>,
+  canLand?: (ctx: LandingContext) => boolean,
+): LandingStrategy {
+  return { name, land: impl, canLand };
+}
+
+describe('WorkspaceManager.land() dispatcher', () => {
+  it('dispatches to an internal-named strategy', async () => {
+    const wm = new DefaultWorkspaceManager(stubAdapter());
+    const land = vi.fn(async () => ({ success: true, newHead: 'abc' } as never));
+    wm.registerLandingStrategy(makeTestStrategy('merge-to-parent', land));
+
+    const result = await wm.land({
+      agentId: 'a1',
+      streamId: 's1',
+      sourceWorktree: '/tmp/wt',
+      strategyName: 'merge-to-parent',
+      workspaceManager: wm,
+    });
+
+    expect(result.success).toBe(true);
+    expect(land).toHaveBeenCalledOnce();
+  });
+
+  it('accepts YAML-style strategy names and maps them', async () => {
+    const wm = new DefaultWorkspaceManager(stubAdapter());
+    const land = vi.fn(async () => ({ success: true } as never));
+    wm.registerLandingStrategy(makeTestStrategy('queue-to-branch', land));
+
+    await wm.land({
+      agentId: 'a1',
+      streamId: 's1',
+      sourceWorktree: '/tmp/wt',
+      strategyName: 'queue_to_branch', // YAML form
+      workspaceManager: wm,
+    });
+
+    expect(land).toHaveBeenCalledOnce();
+  });
+
+  it('defaults to merge-to-parent when strategyName is unset', async () => {
+    const wm = new DefaultWorkspaceManager(stubAdapter());
+    const land = vi.fn(async () => ({ success: true } as never));
+    wm.registerLandingStrategy(makeTestStrategy('merge-to-parent', land));
+
+    await wm.land({
+      agentId: 'a1',
+      streamId: 's1',
+      sourceWorktree: '/tmp/wt',
+      workspaceManager: wm,
+    });
+
+    expect(land).toHaveBeenCalledOnce();
+  });
+
+  it('short-circuits on strategyName: "none" without invoking any strategy', async () => {
+    const wm = new DefaultWorkspaceManager(stubAdapter());
+    const land = vi.fn(async () => ({ success: false } as never));
+    wm.registerLandingStrategy(makeTestStrategy('merge-to-parent', land));
+
+    const result = await wm.land({
+      agentId: 'a1',
+      streamId: 's1',
+      sourceWorktree: '/tmp/wt',
+      strategyName: 'none',
+      workspaceManager: wm,
+    });
+
+    expect(result.success).toBe(true);
+    expect(land).not.toHaveBeenCalled();
+  });
+
+  it('throws on an unknown strategy name', async () => {
+    const wm = new DefaultWorkspaceManager(stubAdapter());
+    await expect(
+      wm.land({
+        agentId: 'a1',
+        streamId: 's1',
+        sourceWorktree: '/tmp/wt',
+        strategyName: 'nonexistent-strategy',
+        workspaceManager: wm,
+      }),
+    ).rejects.toThrow(/No landing strategy registered/);
+  });
+
+  it('fills ctx.workspaceManager with the dispatcher instance', async () => {
+    const wm = new DefaultWorkspaceManager(stubAdapter());
+    let seenManager: unknown = null;
+    wm.registerLandingStrategy(
+      makeTestStrategy('merge-to-parent', async (ctx) => {
+        seenManager = ctx.workspaceManager;
+        return { success: true } as never;
+      }),
+    );
+
+    await wm.land({
+      agentId: 'a1',
+      streamId: 's1',
+      sourceWorktree: '/tmp/wt',
+      // Deliberately pass a non-matching value to prove the dispatcher overrides.
+      workspaceManager: { bogus: true },
+    });
+
+    expect(seenManager).toBe(wm);
+  });
+
+  it('rejects when strategy.canLand(ctx) returns false', async () => {
+    const wm = new DefaultWorkspaceManager(stubAdapter());
+    wm.registerLandingStrategy(
+      makeTestStrategy(
+        'merge-to-parent',
+        async () => ({ success: true } as never),
+        () => false,
+      ),
+    );
+
+    await expect(
+      wm.land({
+        agentId: 'a1',
+        streamId: 's1',
+        sourceWorktree: '/tmp/wt',
+        workspaceManager: wm,
+      }),
+    ).rejects.toThrow(/rejected context/);
+  });
+
+  it('propagates strategy return values including conflicts', async () => {
+    const wm = new DefaultWorkspaceManager(stubAdapter());
+    wm.registerLandingStrategy(
+      makeTestStrategy(
+        'merge-to-parent',
+        async () => ({
+          success: false,
+          conflicts: ['foo.ts'],
+        } as never),
+      ),
+    );
+
+    const result = await wm.land({
+      agentId: 'a1',
+      streamId: 's1',
+      sourceWorktree: '/tmp/wt',
+      workspaceManager: wm,
+    });
+
+    expect(result.success).toBe(false);
+    expect((result as { conflicts?: string[] }).conflicts).toEqual(['foo.ts']);
+  });
+});
+
+describe('resolveLandingStrategyName()', () => {
+  it('maps every YAML name to its internal counterpart', () => {
+    expect(resolveLandingStrategyName('merge_to_parent_stream')).toBe('merge-to-parent');
+    expect(resolveLandingStrategyName('queue_to_branch')).toBe('queue-to-branch');
+    expect(resolveLandingStrategyName('direct_push')).toBe('direct-push');
+    expect(resolveLandingStrategyName('optimistic_push')).toBe('optimistic-push');
+    expect(resolveLandingStrategyName('cherry_pick_stack')).toBe('cherry-pick-stack');
+  });
+
+  it('passes internal names through unchanged', () => {
+    expect(resolveLandingStrategyName('merge-to-parent')).toBe('merge-to-parent');
+    expect(resolveLandingStrategyName('queue-to-branch')).toBe('queue-to-branch');
+  });
+
+  it('passes unknown names through (lets the dispatcher throw with a useful message)', () => {
+    expect(resolveLandingStrategyName('my-custom-strategy')).toBe('my-custom-strategy');
+  });
+
+  it('defaults to merge-to-parent on undefined', () => {
+    expect(resolveLandingStrategyName(undefined)).toBe('merge-to-parent');
+  });
+
+  it('preserves "none" so the dispatcher can short-circuit', () => {
+    expect(resolveLandingStrategyName('none')).toBe('none');
+  });
+});

package/src/workspace/__tests__/self-driving-yaml.test.ts

@@ -0,0 +1,114 @@
+/**
+ * Regression test: self-driving team.yaml parses cleanly under the V3
+ * workspace schema.
+ *
+ * Guards against YAML drift — if someone edits the team config in a way
+ * that breaks schema validation, this test fails loudly.
+ */
+
+import { describe, it, expect } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as yaml from 'js-yaml';
+import {
+  parseTeamWorkspaceConfig,
+  extractWorkspaceConfig,
+} from '../yaml-schema.js';
+import { YamlDrivenTopology } from '../topology/yaml-driven.js';
+import type { WorkspaceManager } from '../types.js';
+import { vi } from 'vitest';
+
+describe('self-driving team YAML (V3 migration)', () => {
+  const yamlPath = path.join(
+    process.cwd(),
+    '.multiagent/teams/self-driving/team.yaml'
+  );
+
+  it('exists on disk', () => {
+    expect(fs.existsSync(yamlPath)).toBe(true);
+  });
+
+  it('parses and validates against TeamWorkspaceConfigSchema', () => {
+    const raw = fs.readFileSync(yamlPath, 'utf-8');
+    const manifest = yaml.load(raw) as { macro_agent?: Record<string, unknown> };
+    const config = extractWorkspaceConfig(manifest);
+
+    expect(config).not.toBeNull();
+    expect(config!.roles.planner).toBeDefined();
+    expect(config!.roles.grinder).toBeDefined();
+    expect(config!.roles.judge).toBeDefined();
+  });
+
+  it('planner role maps to attach_to_team_root', () => {
+    const raw = fs.readFileSync(yamlPath, 'utf-8');
+    const manifest = yaml.load(raw) as { macro_agent?: Record<string, unknown> };
+    const config = extractWorkspaceConfig(manifest)!;
+
+    expect(config.roles.planner.workspace).toBe('attach_to_team_root');
+  });
+
+  it('grinder forks from team root with direct_push landing', () => {
+    const raw = fs.readFileSync(yamlPath, 'utf-8');
+    const manifest = yaml.load(raw) as { macro_agent?: Record<string, unknown> };
+    const config = extractWorkspaceConfig(manifest)!;
+
+    expect(config.roles.grinder.workspace).toBe('new_stream');
+    expect(config.roles.grinder.stream_lineage).toBe('fork_from_team_root');
+    expect(config.roles.grinder.landing).toBe('direct_push');
+  });
+
+  it('judge has no workspace (read-only role)', () => {
+    const raw = fs.readFileSync(yamlPath, 'utf-8');
+    const manifest = yaml.load(raw) as { macro_agent?: Record<string, unknown> };
+    const config = extractWorkspaceConfig(manifest)!;
+
+    expect(config.roles.judge.workspace).toBe('none');
+  });
+
+  it('YamlDrivenTopology compiles the config into valid spawn decisions', async () => {
+    const raw = fs.readFileSync(yamlPath, 'utf-8');
+    const manifest = yaml.load(raw) as { macro_agent?: Record<string, unknown> };
+    const config = extractWorkspaceConfig(manifest)!;
+
+    const topology = new YamlDrivenTopology(config);
+    const mockWs = {
+      createStreamV3: vi.fn(() => 'team-stream-1'),
+    } as unknown as WorkspaceManager;
+
+    // Team start should create a team root (planner attaches to it)
+    await topology.onTeamStart({
+      teamName: 'self-driving',
+      teamInstanceId: 'sd-1',
+      workspaceConfig: config,
+      workspaceManager: mockWs,
+    });
+    expect(mockWs.createStreamV3).toHaveBeenCalled();
+
+    // Planner → attach-to-stream
+    const plannerDecision = await topology.onAgentSpawn({
+      agentId: 'agent-planner',
+      role: 'planner',
+      workspaceManager: mockWs,
+    });
+    expect(plannerDecision.kind).toBe('attach-to-stream');
+
+    // Grinder → new-stream (forked from team root)
+    const grinderDecision = await topology.onAgentSpawn({
+      agentId: 'agent-grinder-1',
+      role: 'grinder',
+      workspaceManager: mockWs,
+    });
+    expect(grinderDecision.kind).toBe('new-stream');
+    if (grinderDecision.kind === 'new-stream') {
+      expect(grinderDecision.streamSpec.parent).toBe('team-stream-1');
+    }
+
+    // Judge → none
+    const judgeDecision = await topology.onAgentSpawn({
+      agentId: 'agent-judge',
+      role: 'judge',
+      workspaceManager: mockWs,
+    });
+    expect(judgeDecision.kind).toBe('none');
+  });
+});