macro-agent 0.1.8 → 0.1.11

package/src/workspace/__tests__/shared-worktree-refcount.test.ts

@@ -0,0 +1,154 @@
+/**
+ * Shared worktree ref-counting tests (Gap 3 fix).
+ *
+ * Verifies the fixed deallocateWorkspace behavior for shared worktrees:
+ *  - Sharer deallocation decrements ref-count without tearing down the worktree.
+ *  - Owner deallocation with active sharers defers teardown (ownerDeparted flag).
+ *  - Teardown fires when the last sharer leaves after owner departed.
+ *  - Normal (non-shared) teardown is unchanged.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { execSync } from 'child_process';
+import { createGitCascadeAdapter, type GitCascadeAdapter } from '../git-cascade-adapter.js';
+import {
+  DefaultWorkspaceManager,
+  createWorkspaceManagerWithAdapter,
+} from '../workspace-manager.js';
+
+describe('shared worktree ref-counting', () => {
+  let tempDir: string;
+  let repoPath: string;
+  let adapter: GitCascadeAdapter;
+  let manager: DefaultWorkspaceManager;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'refcount-'));
+    repoPath = path.join(tempDir, '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 = createGitCascadeAdapter({
+      enabled: true,
+      repoPath,
+      dbPath: path.join(tempDir, 'db.sqlite'),
+      skipRecovery: true,
+    });
+    manager = createWorkspaceManagerWithAdapter(adapter, {
+      worktreeBaseDir: path.join(tempDir, 'worktrees'),
+    }) as DefaultWorkspaceManager;
+  });
+
+  afterEach(() => {
+    manager.close();
+    adapter.close();
+    if (fs.existsSync(tempDir)) fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('sharer deallocation decrements refs without touching the worktree', () => {
+    const streamId = manager.createStreamV3({ name: 's1', ownerId: 'owner-A' });
+    const owner = manager.allocateWorktree({ agentId: 'owner-A', streamId });
+    manager.allocateWorktree({ agentId: 'sharer-B', sharedWithAgent: 'owner-A' });
+    manager.allocateWorktree({ agentId: 'sharer-C', sharedWithAgent: 'owner-A' });
+
+    // Owner's worktree exists on disk
+    expect(fs.existsSync(owner.path)).toBe(true);
+
+    // Deallocate one sharer
+    manager.deallocateWorkspace('sharer-B');
+    expect(fs.existsSync(owner.path)).toBe(true);
+
+    // Owner's adapter record untouched
+    expect(adapter.getWorktree('owner-A')).not.toBeNull();
+  });
+
+  it('owner deallocation with active sharers defers teardown', () => {
+    const streamId = manager.createStreamV3({ name: 's1', ownerId: 'owner-A' });
+    const owner = manager.allocateWorktree({ agentId: 'owner-A', streamId });
+    manager.allocateWorktree({ agentId: 'sharer-B', sharedWithAgent: 'owner-A' });
+
+    const events: Array<{ type: string }> = [];
+    manager.onEvent((e) => events.push(e));
+
+    manager.deallocateWorkspace('owner-A');
+
+    // Path still exists — teardown deferred
+    expect(fs.existsSync(owner.path)).toBe(true);
+    // git-cascade still thinks owner-A has a worktree (deferred state)
+    expect(adapter.getWorktree('owner-A')).not.toBeNull();
+
+    // Released event fired with kind=owner-departed
+    const released = events.find((e) => e.type === 'worktree:released');
+    expect(released).toBeDefined();
+    expect((released as { data?: { kind?: string } }).data?.kind).toBe('owner-departed');
+  });
+
+  it('last sharer leaving after owner departed finalizes teardown', () => {
+    const streamId = manager.createStreamV3({ name: 's1', ownerId: 'owner-A' });
+    const owner = manager.allocateWorktree({ agentId: 'owner-A', streamId });
+    manager.allocateWorktree({ agentId: 'sharer-B', sharedWithAgent: 'owner-A' });
+
+    manager.deallocateWorkspace('owner-A');
+    // Still deferred
+    expect(fs.existsSync(owner.path)).toBe(true);
+
+    manager.deallocateWorkspace('sharer-B');
+    // Now actually torn down
+    expect(fs.existsSync(owner.path)).toBe(false);
+    expect(adapter.getWorktree('owner-A')).toBeNull();
+  });
+
+  it('rejects allocation after owner departed with no sharers', () => {
+    const streamId = manager.createStreamV3({ name: 's1', ownerId: 'owner-A' });
+    manager.allocateWorktree({ agentId: 'owner-A', streamId });
+    manager.allocateWorktree({ agentId: 'sharer-B', sharedWithAgent: 'owner-A' });
+
+    manager.deallocateWorkspace('owner-A'); // owner departs (sharer-B still alive)
+    manager.deallocateWorkspace('sharer-B'); // last sharer leaves — torn down
+
+    // Now try to share again — owner is gone
+    expect(() =>
+      manager.allocateWorktree({ agentId: 'late-C', sharedWithAgent: 'owner-A' })
+    ).toThrow();
+  });
+
+  it('non-shared worktree teardown is unchanged', () => {
+    const streamId = manager.createStreamV3({ name: 's1', ownerId: 'lone-A' });
+    const wt = manager.allocateWorktree({ agentId: 'lone-A', streamId });
+    expect(fs.existsSync(wt.path)).toBe(true);
+
+    manager.deallocateWorkspace('lone-A');
+    expect(fs.existsSync(wt.path)).toBe(false);
+    expect(adapter.getWorktree('lone-A')).toBeNull();
+  });
+
+  it('multiple sharers coexist; dealloc order does not matter', () => {
+    const streamId = manager.createStreamV3({ name: 's1', ownerId: 'owner-A' });
+    const owner = manager.allocateWorktree({ agentId: 'owner-A', streamId });
+    manager.allocateWorktree({ agentId: 'sharer-B', sharedWithAgent: 'owner-A' });
+    manager.allocateWorktree({ agentId: 'sharer-C', sharedWithAgent: 'owner-A' });
+    manager.allocateWorktree({ agentId: 'sharer-D', sharedWithAgent: 'owner-A' });
+
+    // Dealloc in a scrambled order: owner first, then sharers
+    manager.deallocateWorkspace('owner-A');
+    expect(fs.existsSync(owner.path)).toBe(true);
+
+    manager.deallocateWorkspace('sharer-C');
+    expect(fs.existsSync(owner.path)).toBe(true);
+
+    manager.deallocateWorkspace('sharer-D');
+    expect(fs.existsSync(owner.path)).toBe(true);
+
+    manager.deallocateWorkspace('sharer-B'); // last sharer
+    expect(fs.existsSync(owner.path)).toBe(false);
+  });
+});

package/src/workspace/__tests__/standalone-mode.test.ts

@@ -0,0 +1,118 @@
+/**
+ * Standalone-mode regression test (G11).
+ *
+ * Asserts that GitCascadeAdapter (and the cascade event flow it drives)
+ * works correctly when no MAP sidecar / cascade bridge is configured —
+ * i.e., macro-agent runs without an OpenHive hub.
+ *
+ * The contract: cascade emits its own structured event stream regardless,
+ * and operations succeed without any hub roundtrip. If a future change
+ * accidentally introduces a hard dependency on the bridge or sidecar
+ * (e.g., awaiting a hub call inside cascade), this test catches it.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { execSync } from "child_process";
+import { GitCascadeAdapter } from "../git-cascade-adapter.js";
+import type { GitCascadeEvent } from "../git-cascade-adapter.js";
+
+function mkTempRepo(): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "macro-standalone-"));
+  execSync("git init", { cwd: dir, stdio: "pipe" });
+  execSync('git config user.email "test@test.com"', { cwd: dir, stdio: "pipe" });
+  execSync('git config user.name "Test"', { cwd: dir, stdio: "pipe" });
+  fs.writeFileSync(path.join(dir, ".gitignore"), ".git-cascade/\n");
+  fs.writeFileSync(path.join(dir, "README.md"), "# test\n");
+  execSync("git add .", { cwd: dir, stdio: "pipe" });
+  execSync('git commit -m "init"', { cwd: dir, stdio: "pipe" });
+  fs.mkdirSync(path.join(dir, ".git-cascade"), { recursive: true });
+  return dir;
+}
+
+describe("standalone mode: GitCascadeAdapter without sidecar/bridge", () => {
+  let repoPath: string;
+  let adapter: GitCascadeAdapter;
+
+  beforeEach(() => {
+    repoPath = mkTempRepo();
+    // Construct the adapter with no MAP sidecar — same shape as boot-v2 when
+    // `config.map?.enabled !== true`. No CascadeBridge is ever wired.
+    adapter = new GitCascadeAdapter({ repoPath });
+  });
+
+  afterEach(() => {
+    fs.rmSync(repoPath, { recursive: true, force: true });
+  });
+
+  it("runs full stream lifecycle without errors and produces local events", () => {
+    const events: GitCascadeEvent[] = [];
+    adapter.onEvent((e) => events.push(e));
+
+    // Open a stream
+    const streamId = adapter.createStream({
+      name: "standalone-feat",
+      agentId: "a1",
+    });
+    expect(streamId).toBeTruthy();
+
+    // Create worktree + commit through tracker
+    const wt = path.join(repoPath, ".worktrees", "a1");
+    adapter.createWorktree({
+      agentId: "a1",
+      path: wt,
+      branch: `stream/${streamId}`,
+    });
+    fs.writeFileSync(path.join(wt, "x.txt"), "hi\n");
+    execSync("git add .", { cwd: wt, stdio: "pipe" });
+    const result = adapter.commitChanges({
+      streamId,
+      agentId: "a1",
+      worktree: wt,
+      message: "feat: add x",
+      metadata: { task_ref: { resource_id: "r", node_id: "n" } },
+    });
+    expect(result.commit).toBeTruthy();
+    expect(result.changeId).toBeTruthy();
+
+    // Abandon
+    adapter.abandonStream(streamId, { reason: "test" });
+
+    // Verify expected events fired locally (no hub involved)
+    const types = events.map((e) => e.type);
+    expect(types).toContain("stream:created");
+    expect(types).toContain("stream:committed");
+    expect(types).toContain("stream:abandoned");
+  });
+
+  it("does not throw when no event listener is attached", () => {
+    // No onEvent subscribers — adapter must not assume any.
+    const streamId = adapter.createStream({ name: "lonely", agentId: "a" });
+    expect(streamId).toBeTruthy();
+    adapter.abandonStream(streamId, { reason: "test" });
+  });
+
+  it("preserves Change-Id even with no hub forwarding", () => {
+    // Confirms the tracker's emit hook works locally even when nothing
+    // forwards events — the Change-Id is computed by git-cascade itself, not
+    // by the bridge.
+    const streamId = adapter.createStream({ name: "chgid", agentId: "a" });
+    const wt = path.join(repoPath, ".worktrees", "a");
+    adapter.createWorktree({
+      agentId: "a",
+      path: wt,
+      branch: `stream/${streamId}`,
+    });
+    fs.writeFileSync(path.join(wt, "y.txt"), "y\n");
+    execSync("git add .", { cwd: wt, stdio: "pipe" });
+    const { changeId } = adapter.commitChanges({
+      streamId,
+      agentId: "a",
+      worktree: wt,
+      message: "test",
+    });
+    expect(changeId).toMatch(/^c-/);
+  });
+});

package/src/workspace/__tests__/workspace-manager-v3.test.ts

@@ -0,0 +1,245 @@
+/**
+ * WorkspaceManager V3 surface tests (Phase 1).
+ *
+ * Covers the stream-first methods added alongside the legacy role-shaped API.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { execSync } from 'child_process';
+import { createGitCascadeAdapter, type GitCascadeAdapter } from '../git-cascade-adapter.js';
+import {
+  DefaultWorkspaceManager,
+  createWorkspaceManagerWithAdapter,
+} from '../workspace-manager.js';
+
+describe('WorkspaceManager V3 surface', () => {
+  let tempDir: string;
+  let repoPath: string;
+  let dbPath: string;
+  let adapter: GitCascadeAdapter;
+  let manager: DefaultWorkspaceManager;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ws-v3-test-'));
+    repoPath = path.join(tempDir, 'repo');
+    dbPath = path.join(tempDir, 'test.db');
+    fs.mkdirSync(repoPath);
+
+    execSync('git init -b main', { 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');
+    execSync('git add .', { cwd: repoPath, stdio: 'pipe' });
+    execSync('git commit -m "init"', { cwd: repoPath, stdio: 'pipe' });
+
+    adapter = createGitCascadeAdapter({
+      enabled: true,
+      repoPath,
+      dbPath,
+      skipRecovery: true,
+    });
+    manager = createWorkspaceManagerWithAdapter(adapter, {
+      worktreeBaseDir: path.join(tempDir, 'worktrees'),
+    }) as DefaultWorkspaceManager;
+  });
+
+  afterEach(() => {
+    manager.close();
+    adapter.close();
+    if (tempDir && fs.existsSync(tempDir)) {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+
+  describe('streams', () => {
+    it('creates a stream with a pseudo-principal owner', () => {
+      const streamId = manager.createStreamV3({
+        name: 'team-root',
+        ownerId: 'team:peer-swarm',
+        forkFrom: 'main',
+      });
+      expect(streamId).toBeDefined();
+    });
+
+    it('forks a child stream off a parent', () => {
+      const parent = manager.createStreamV3({
+        name: 'parent',
+        ownerId: 'team:solo-stack',
+      });
+      const child = manager.forkStream({
+        parentStreamId: parent,
+        name: 'child',
+        ownerId: 'agent-1',
+      });
+      const childStream = adapter.getStream(child);
+      expect(childStream?.parentStream).toBe(parent);
+    });
+
+    it('emits stream:created and stream:forked events', () => {
+      const events: string[] = [];
+      manager.onEvent((e) => events.push(e.type));
+
+      const parent = manager.createStreamV3({ name: 'parent', ownerId: 'team:x' });
+      manager.forkStream({ parentStreamId: parent, name: 'child', ownerId: 'agent-1' });
+
+      expect(events).toContain('stream:created');
+      expect(events).toContain('stream:forked');
+    });
+
+    it('pauses and resumes a stream with events', () => {
+      const streamId = manager.createStreamV3({ name: 'x', ownerId: 'agent-1' });
+      const events: string[] = [];
+      manager.onEvent((e) => events.push(e.type));
+
+      manager.pauseStream(streamId, 'manual');
+      expect(adapter.getStream(streamId)?.status).toBe('paused');
+      expect(events).toContain('stream:paused');
+
+      manager.resumeStream(streamId);
+      expect(adapter.getStream(streamId)?.status).toBe('active');
+      expect(events).toContain('stream:resumed');
+    });
+
+    it('lists streams by owner', () => {
+      manager.createStreamV3({ name: 'a', ownerId: 'agent-1' });
+      manager.createStreamV3({ name: 'b', ownerId: 'agent-2' });
+      const owned = manager.listStreams({ ownerId: 'agent-1' });
+      expect(owned.length).toBe(1);
+      expect(owned[0].name).toBe('a');
+    });
+  });
+
+  describe('worktree allocation', () => {
+    it('allocates a worktree attached to a stream', () => {
+      const streamId = manager.createStreamV3({ name: 'feat', ownerId: 'agent-1' });
+      const wt = manager.allocateWorktree({
+        agentId: 'agent-1',
+        streamId,
+      });
+      expect(wt.path).toContain('agent-1');
+      expect(wt.agentId).toBe('agent-1');
+    });
+
+    it('shares a worktree between two agents (ref-counted)', () => {
+      const streamId = manager.createStreamV3({ name: 'feat', ownerId: 'agent-1' });
+      const primary = manager.allocateWorktree({ agentId: 'agent-1', streamId });
+
+      const shared = manager.allocateWorktree({
+        agentId: 'agent-2',
+        sharedWithAgent: 'agent-1',
+      });
+
+      expect(shared.path).toBe(primary.path);
+    });
+
+    it('throws when sharing from an unallocated agent', () => {
+      expect(() =>
+        manager.allocateWorktree({ agentId: 'agent-x', sharedWithAgent: 'nonexistent' })
+      ).toThrow(/has no allocated worktree/);
+    });
+
+    it('emits worktree:allocated and worktree:shared events', () => {
+      const streamId = manager.createStreamV3({ name: 'feat', ownerId: 'agent-1' });
+      const events: string[] = [];
+      manager.onEvent((e) => events.push(e.type));
+
+      manager.allocateWorktree({ agentId: 'agent-1', streamId });
+      manager.allocateWorktree({ agentId: 'agent-2', sharedWithAgent: 'agent-1' });
+
+      expect(events).toContain('worktree:allocated');
+      expect(events).toContain('worktree:shared');
+    });
+  });
+
+  describe('changes (Change-Id tracking)', () => {
+    it('commits via commitChanges and assigns a Change-Id', () => {
+      const streamId = manager.createStreamV3({ name: 'feat', ownerId: 'agent-1' });
+      const wt = manager.allocateWorktree({ agentId: 'agent-1', streamId });
+
+      fs.writeFileSync(path.join(wt.path, 'hello.txt'), 'hi');
+
+      const result = manager.commitChanges({
+        agentId: 'agent-1',
+        streamId,
+        worktree: wt.path,
+        message: 'add hello',
+      });
+
+      expect(result.commit).toBeDefined();
+      expect(result.changeId).toBeDefined();
+      expect(result.changeId.startsWith('c-')).toBe(true);
+
+      const change = manager.getChangeByCommit(result.commit);
+      expect(change?.id).toBe(result.changeId);
+    });
+
+    it('emits stream:committed event on commit', () => {
+      const streamId = manager.createStreamV3({ name: 'feat', ownerId: 'agent-1' });
+      const wt = manager.allocateWorktree({ agentId: 'agent-1', streamId });
+
+      fs.writeFileSync(path.join(wt.path, 'x.txt'), 'x');
+
+      const events: Array<{ type: string; data: Record<string, unknown> }> = [];
+      manager.onEvent((e) => events.push(e));
+
+      manager.commitChanges({
+        agentId: 'agent-1',
+        streamId,
+        worktree: wt.path,
+        message: 'x',
+      });
+
+      const committed = events.find((e) => e.type === 'stream:committed');
+      expect(committed).toBeDefined();
+      expect(committed?.data.streamId).toBe(streamId);
+    });
+
+    it('marks changes merged and emits events', () => {
+      const streamId = manager.createStreamV3({ name: 'feat', ownerId: 'agent-1' });
+      const wt = manager.allocateWorktree({ agentId: 'agent-1', streamId });
+      fs.writeFileSync(path.join(wt.path, 'x.txt'), 'x');
+      const { changeId } = manager.commitChanges({
+        agentId: 'agent-1',
+        streamId,
+        worktree: wt.path,
+        message: 'x',
+      });
+
+      const events: string[] = [];
+      manager.onEvent((e) => events.push(e.type));
+
+      manager.markChangesMerged([changeId]);
+      expect(events).toContain('change:merged');
+    });
+  });
+
+  describe('landing strategy registry', () => {
+    it('registers landing strategies', () => {
+      const mockStrategy = {
+        name: 'test-strategy',
+        async land() {
+          return { success: true };
+        },
+      };
+      manager.registerLandingStrategy(mockStrategy);
+      // Registration is internal; successful if no throw. Full integration
+      // covered in Phase 5.
+      expect(true).toBe(true);
+    });
+  });
+
+  describe('reconcileV3', () => {
+    it('returns a MacroReconcileResult with zero issues on a clean db', () => {
+      manager.createStreamV3({ name: 'a', ownerId: 'agent-1' });
+      const result = manager.reconcileV3();
+
+      expect(result).toBeDefined();
+      expect(result.errors.length).toBe(0);
+      // Fresh streams are in sync → no fixes needed
+      expect(result.worktreesOrphaned).toBe(0);
+    });
+  });
+});