macro-agent 0.1.8 → 0.1.10

package/src/teams/team-runtime-v2.ts

@@ -506,12 +506,12 @@ export class TeamRuntimeV2 {
       const capabilities = resolved.capabilities;
       let streamId = options.streamId;
       let streamConfig = options.streamConfig;
-      let dataplaneTaskId = options.dataplaneTaskId;
+      let gitCascadeTaskId = options.gitCascadeTaskId;
 
       if (this.teamStreamId && capabilities) {
         if (capabilities.includes(WORKSPACE_CAPABILITIES.WORKTREE)) {
           streamId = streamId ?? this.teamStreamId;
-          dataplaneTaskId = dataplaneTaskId ?? `worker-${Date.now()}`;
+          gitCascadeTaskId = gitCascadeTaskId ?? `worker-${Date.now()}`;
         } else if (capabilities.includes(WORKSPACE_CAPABILITIES.INTEGRATE)) {
           streamId = streamId ?? this.teamStreamId;
         }
@@ -521,7 +521,7 @@ export class TeamRuntimeV2 {
         ...options,
         streamId,
         streamConfig,
-        dataplaneTaskId,
+        gitCascadeTaskId,
         capabilities: capabilities ?? options.capabilities,
         // Set team scope on all team agents
         team_instance: options.team_instance ?? this.manifest.name,
@@ -846,6 +846,26 @@ Focus on correctness — your changes go live immediately.`);
     const { workspaceManager } = this.services;
     if (!workspaceManager || !this.integrationStrategy) return;
 
+    // V3 coexistence: if TeamManagerV2 has already wired a YamlDrivenTopology
+    // from `macro_agent.workspace`, that policy owns the team root stream.
+    // Don't create a second one via the legacy createIntegrationStream.
+    const hasV3Topology =
+      typeof (
+        this.services.agentManager as {
+          getTopologyPolicy?: () => unknown;
+        }
+      ).getTopologyPolicy === 'function';
+    // AgentManager doesn't expose a getter today, so detect indirectly: a
+    // V3-wired team has already created a stream owned by `team:<name>`.
+    const existingTeamRoot = workspaceManager
+      .listStreams({ ownerId: `team:${this.manifest.name}` } as never)
+      .find((s: { name: string }) => s.name === this.manifest.name);
+
+    if (existingTeamRoot) {
+      this.teamStreamId = existingTeamRoot.id;
+      return;
+    }
+
     try {
       this.teamStreamId = workspaceManager.createIntegrationStream(
         rootAgentId,

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__/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');
+  });
+});

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);
+  });
+});