macro-agent 0.2.4 → 0.2.6

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

@@ -1,214 +0,0 @@
-/**
- * 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

@@ -1,122 +0,0 @@
-/**
- * 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)', () => {
-  // Resolve relative to this test file so the path is cwd-independent and
-  // points at the shipped package asset (not a user-runtime copy under
-  // <project>/.multiagent/ — that only exists after `seed-defaults` runs).
-  // `src/workspace/__tests__/` → `../../../` → package root.
-  const PACKAGE_ROOT = path.resolve(
-    path.dirname(new URL(import.meta.url).pathname),
-    '..', '..', '..'
-  );
-  const yamlPath = path.join(
-    PACKAGE_ROOT,
-    'templates/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

@@ -1,154 +0,0 @@
-/**
- * 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

@@ -1,118 +0,0 @@
-/**
- * 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-/);
-  });
-});