macro-agent 0.2.5 → 0.2.6

package/src/__tests__/e2e/cascade-rebase.e2e.test.ts

@@ -1,254 +0,0 @@
-/**
- * Cascade rebase end-to-end via MergeToParentStrategy.
- *
- * Fixture: 3-level fork graph
- *   main → team_root → feat-A → feat-B → feat-C
- *
- * When we land feat-B into feat-A with `cascade: true`, feat-C is expected
- * to rebase onto the new feat-A HEAD.
- *
- * Verifies:
- *  - The worktree provider finds live agents' worktrees
- *  - Allocates ephemeral worktrees for streams that have no agent
- *  - Ephemeral worktrees are cleaned up after cascade completes
- *  - cascadeStrategy options route as expected
- *
- * REQUIRES: RUN_E2E_TESTS=true
- */
-
-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, createGitCascadeAdapter } from '../../workspace/git-cascade-adapter.js';
-import {
-  DefaultWorkspaceManager,
-  createWorkspaceManagerWithAdapter,
-} from '../../workspace/workspace-manager.js';
-import { MergeToParentStrategy } from '../../workspace/landing/merge-to-parent.js';
-
-const RUN_E2E = !!process.env.RUN_E2E_TESTS;
-const describeFn = RUN_E2E ? describe : describe.skip;
-
-describeFn('cascade rebase via merge-to-parent', () => {
-  let tempDir: string;
-  let repoPath: string;
-  let adapter: GitCascadeAdapter;
-  let manager: DefaultWorkspaceManager;
-
-  beforeEach(() => {
-    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cascade-e2e-'));
-    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\n');
-    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, 'gc.db'),
-      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('cascades through 3-level fork: main → A → B → C', async () => {
-    // Build the stream graph
-    const streamA = manager.createStreamV3({
-      name: 'feat-A',
-      ownerId: 'agent-A',
-      forkFrom: 'main',
-    });
-    const streamB = manager.createStreamV3({
-      name: 'feat-B',
-      ownerId: 'agent-B',
-      parent: streamA,
-    });
-    const streamC = manager.createStreamV3({
-      name: 'feat-C',
-      ownerId: 'agent-C',
-      parent: streamB,
-    });
-
-    // Allocate worktrees for A and C (live agents). B gets a worktree,
-    // makes commits, then we land it into A.
-    const wtA = manager.allocateWorktree({ agentId: 'agent-A', streamId: streamA });
-    const wtB = manager.allocateWorktree({ agentId: 'agent-B', streamId: streamB });
-    const wtC = manager.allocateWorktree({ agentId: 'agent-C', streamId: streamC });
-
-    // Make a commit in B
-    fs.writeFileSync(path.join(wtB.path, 'b.txt'), 'B change\n');
-    manager.commitChanges({
-      agentId: 'agent-B',
-      streamId: streamB,
-      worktree: wtB.path,
-      message: 'feat-B: add b.txt',
-    });
-
-    // Land B → A with cascade=true (C should rebase onto new A)
-    const strategy = new MergeToParentStrategy();
-    const result = await strategy.land({
-      agentId: 'agent-B',
-      streamId: streamB,
-      sourceWorktree: wtB.path,
-      targetStreamId: streamA,
-      strategyConfig: { cascade: true, cascadeStrategy: 'defer_conflicts' },
-      workspaceManager: manager,
-    });
-
-    expect(result.success).toBe(true);
-
-    // Verify A has B's file
-    expect(fs.existsSync(path.join(wtA.path, 'b.txt'))).toBe(true);
-
-    // Verify C got rebased onto new A (the file should now exist in C's
-    // worktree after a `git pull` or the cascade picks it up).
-    // git-cascade's cascadeRebase operates on the branch level — the worktree
-    // may need a refresh. The key check: the stream's baseCommit in the DB
-    // should have moved.
-    const updatedC = adapter.getStream(streamC);
-    expect(updatedC).toBeDefined();
-    // baseCommit should reflect the cascade update — if it didn't move,
-    // cascade was a no-op. (Exact commit comparison depends on git-cascade
-    // internals; we just check that the stream is still active.)
-    expect(updatedC?.status).toBe('active');
-  });
-
-  it('allocates ephemeral worktree for dependent stream without live agent', async () => {
-    const streamA = manager.createStreamV3({
-      name: 'feat-A',
-      ownerId: 'agent-A',
-      forkFrom: 'main',
-    });
-    const streamB = manager.createStreamV3({
-      name: 'feat-B',
-      ownerId: 'agent-B',
-      parent: streamA,
-    });
-    // stream-C has no agent allocated — cascade must create an ephemeral
-    const streamC = manager.createStreamV3({
-      name: 'feat-C',
-      ownerId: 'pseudo:C',
-      parent: streamB,
-    });
-
-    const wtA = manager.allocateWorktree({ agentId: 'agent-A', streamId: streamA });
-    const wtB = manager.allocateWorktree({ agentId: 'agent-B', streamId: streamB });
-
-    fs.writeFileSync(path.join(wtB.path, 'b.txt'), 'B\n');
-    manager.commitChanges({
-      agentId: 'agent-B',
-      streamId: streamB,
-      worktree: wtB.path,
-      message: 'feat-B',
-    });
-
-    const beforeWorktrees = adapter.listWorktrees().length;
-
-    const strategy = new MergeToParentStrategy();
-    await strategy.land({
-      agentId: 'agent-B',
-      streamId: streamB,
-      sourceWorktree: wtB.path,
-      targetStreamId: streamA,
-      strategyConfig: { cascade: true },
-      workspaceManager: manager,
-    });
-
-    // After cascade, ephemeral worktrees should have been cleaned up
-    const afterWorktrees = adapter.listWorktrees().length;
-    expect(afterWorktrees).toBeLessThanOrEqual(beforeWorktrees);
-  });
-
-  it('cascade is a no-op when strategyConfig.cascade is false', async () => {
-    const streamA = manager.createStreamV3({
-      name: 'feat-A',
-      ownerId: 'agent-A',
-      forkFrom: 'main',
-    });
-    const streamB = manager.createStreamV3({
-      name: 'feat-B',
-      ownerId: 'agent-B',
-      parent: streamA,
-    });
-
-    const wtA = manager.allocateWorktree({ agentId: 'agent-A', streamId: streamA });
-    const wtB = manager.allocateWorktree({ agentId: 'agent-B', streamId: streamB });
-
-    fs.writeFileSync(path.join(wtB.path, 'b.txt'), 'B\n');
-    manager.commitChanges({
-      agentId: 'agent-B',
-      streamId: streamB,
-      worktree: wtB.path,
-      message: 'feat-B',
-    });
-
-    const strategy = new MergeToParentStrategy();
-    const result = await strategy.land({
-      agentId: 'agent-B',
-      streamId: streamB,
-      sourceWorktree: wtB.path,
-      targetStreamId: streamA,
-      // No cascade config — should stop after mergeStream
-      workspaceManager: manager,
-    });
-
-    expect(result.success).toBe(true);
-  });
-
-  it('cleans up ephemeral worktrees even when cascade throws internally', async () => {
-    // Simulate a cascade scenario where provider-allocated worktrees must
-    // be cleaned up. We construct a minimal graph and verify the tracker
-    // doesn't accumulate ephemeral records.
-    const streamA = manager.createStreamV3({
-      name: 'feat-A',
-      ownerId: 'agent-A',
-      forkFrom: 'main',
-    });
-    const streamB = manager.createStreamV3({
-      name: 'feat-B',
-      ownerId: 'agent-B',
-      parent: streamA,
-    });
-
-    const wtA = manager.allocateWorktree({ agentId: 'agent-A', streamId: streamA });
-    const wtB = manager.allocateWorktree({ agentId: 'agent-B', streamId: streamB });
-    fs.writeFileSync(path.join(wtB.path, 'b.txt'), 'B\n');
-    manager.commitChanges({
-      agentId: 'agent-B',
-      streamId: streamB,
-      worktree: wtB.path,
-      message: 'feat-B',
-    });
-
-    const strategy = new MergeToParentStrategy();
-    await strategy.land({
-      agentId: 'agent-B',
-      streamId: streamB,
-      sourceWorktree: wtB.path,
-      targetStreamId: streamA,
-      strategyConfig: { cascade: true },
-      workspaceManager: manager,
-    });
-
-    // No worktree records should include the `system:cascade-*` pseudo-id
-    const cascadeEphemerals = adapter
-      .listWorktrees()
-      .filter((wt) => wt.agentId.startsWith('system:cascade-'));
-    expect(cascadeEphemerals.length).toBe(0);
-  });
-});

package/src/__tests__/e2e/cc-swarm-bridge.e2e.test.ts

@@ -1,253 +0,0 @@
-/**
- * cc-swarm Bridge E2E Test
- *
- * Verifies that when macro-agent spawns a Claude Code agent with cc-swarm
- * plugin hooks active, cc-swarm connects to macro-agent's local MAP server
- * and sends trajectory checkpoints.
- *
- * Flow:
- *   1. Boot macro-agent with MAP server enabled
- *   2. Spawn an agent (Claude Code with cc-swarm hooks)
- *   3. Agent's cc-swarm hooks detect SWARM_MAP_SERVER env var
- *   4. cc-swarm sidecar connects to macro-agent's MAP server
- *   5. Agent processes a prompt → cc-swarm sends trajectory/checkpoint
- *   6. MAP server's handler receives it and forwards to sidecar
- *
- * REQUIRES: RUN_FULL_AGENT_TESTS=true (spawns real Claude Code)
- * REQUIRES: cc-swarm plugin installed and enabled in Claude Code
- *
- * Run:
- *   RUN_FULL_AGENT_TESTS=true npx vitest run --config vitest.e2e.config.ts src/__tests__/e2e/cc-swarm-bridge.e2e.test.ts
- */
-
-import { describe, it, expect, beforeAll, afterAll } from "vitest";
-import * as fs from "fs";
-import * as path from "path";
-import * as os from "os";
-import { bootV2, type MacroAgentSystemV2 } from "../../boot-v2.js";
-import { ClientConnection } from "@multi-agent-protocol/sdk";
-
-const IS_LIVE = process.env.RUN_FULL_AGENT_TESTS === "true";
-const describeLive = IS_LIVE ? describe : describe.skip;
-
-const TEST_DIR = fs.mkdtempSync(
-  path.join(os.tmpdir(), "cc-swarm-bridge-e2e-"),
-);
-
-describeLive("cc-swarm Bridge: macro-agent → cc-swarm → MAP server", () => {
-  let system: MacroAgentSystemV2;
-  let mapUrl: string;
-  let mapClient: ClientConnection;
-
-  // Track trajectory checkpoints received by the MAP server
-  const receivedCheckpoints: any[] = [];
-
-  beforeAll(async () => {
-    system = await bootV2({
-      cwd: TEST_DIR,
-      baseDir: TEST_DIR,
-      defaultPermissionMode: "auto-approve",
-      inbox: {
-        socketPath: path.join(TEST_DIR, "inbox.sock"),
-      },
-      // Enable MAP server — cc-swarm agents will connect here
-      mapServer: {
-        enabled: true,
-        port: 0,
-        host: "127.0.0.1",
-      },
-    });
-
-    mapUrl = system.mapServerInstance!.getUrl();
-    console.log(`[cc-swarm-e2e] MAP server at ${mapUrl}`);
-
-    // Connect a MAP client to observe events
-    mapClient = await ClientConnection.connect(mapUrl, {
-      name: "cc-swarm Bridge E2E Observer",
-      capabilities: {
-        observation: { canObserve: true, canQuery: true },
-        messaging: { canSend: true, canReceive: true },
-        lifecycle: { canSpawn: true, canStop: true },
-      },
-    });
-  }, 30000);
-
-  afterAll(async () => {
-    try { await mapClient?.disconnect(); } catch { /* ignore */ }
-    try { await system?.shutdown(); } catch { /* ignore */ }
-    try { fs.rmSync(TEST_DIR, { recursive: true, force: true }); } catch { /* ignore */ }
-  });
-
-  it("spawns an agent with SWARM_MAP_SERVER env var set", async () => {
-    // Verify the MAP server URL is propagated to spawned agents
-    expect(mapUrl).toBeTruthy();
-
-    // Spawn an agent via the extension (this goes through AgentManager.spawn
-    // which injects SWARM_MAP_* env vars into the subprocess)
-    const result = (await mapClient.callExtension("_macro/spawnAgent", {
-      task: "cc-swarm bridge test",
-      role: "worker",
-    })) as { agent: { id: string; localId: string } };
-
-    expect(result.agent).toBeDefined();
-    expect(result.agent.id).toBeTruthy();
-    console.log(
-      `[cc-swarm-e2e] Spawned agent: mapId=${result.agent.id} localId=${result.agent.localId}`,
-    );
-
-    // The agent should appear in listAgents
-    await new Promise((r) => setTimeout(r, 500));
-    const agents = await mapClient.listAgents();
-    expect(agents.agents.length).toBeGreaterThan(0);
-    console.log(
-      `[cc-swarm-e2e] Agents: ${agents.agents.length}`,
-    );
-  }, 15000);
-
-  it("receives cc-swarm connection on MAP server", async () => {
-    // Wait for cc-swarm sidecar to connect.
-    // cc-swarm's SessionStart hook fires when the Claude Code session starts,
-    // which may take a few seconds. The sidecar then connects to
-    // SWARM_MAP_SERVER (our MAP server).
-    console.log("[cc-swarm-e2e] Waiting for cc-swarm sidecar connection...");
-
-    const connectionCountBefore = system.mapServerInstance!.getConnectionCount();
-
-    // Wait up to 15s for a new connection (cc-swarm sidecar)
-    let newConnection = false;
-    for (let i = 0; i < 30; i++) {
-      const count = system.mapServerInstance!.getConnectionCount();
-      // We already have 1 connection (our observer client)
-      if (count > connectionCountBefore) {
-        newConnection = true;
-        break;
-      }
-      await new Promise((r) => setTimeout(r, 500));
-    }
-
-    if (newConnection) {
-      console.log("[cc-swarm-e2e] cc-swarm sidecar connected to MAP server!");
-    } else {
-      // cc-swarm hooks may not fire for acp-factory spawned agents because:
-      // - Claude Code plugins load via CLI hook system
-      // - acp-factory spawns Claude Code headlessly without full plugin loading
-      // - The SWARM_MAP_* env vars ARE set (verified), but cc-swarm hooks
-      //   need to be triggered by Claude Code's hook infrastructure
-      //
-      // This is a known limitation: cc-swarm bridge works when agents are
-      // started via the Claude Code CLI (with hooks), not via acp-factory.
-      // For full bridge testing, agents need to be spawned with hook support.
-      console.log(
-        "[cc-swarm-e2e] cc-swarm sidecar did not connect.",
-      );
-      console.log(
-        "[cc-swarm-e2e] This is expected for acp-factory spawned agents — cc-swarm hooks",
-      );
-      console.log(
-        "[cc-swarm-e2e] require Claude Code's plugin system which may not load in headless mode.",
-      );
-    }
-
-    console.log(
-      `[cc-swarm-e2e] MAP server connections: ${system.mapServerInstance!.getConnectionCount()}`,
-    );
-  }, 20000);
-
-  it("prompts agent and observes session updates", async () => {
-    const { createACPStream } = await import("@multi-agent-protocol/sdk");
-
-    const agents = await mapClient.listAgents();
-    if (agents.agents.length === 0) {
-      console.log("[cc-swarm-e2e] No agents, skipping prompt");
-      return;
-    }
-
-    const targetAgent = agents.agents[0].id;
-    const updates: string[] = [];
-
-    const acpStream = createACPStream(mapClient, {
-      targetAgent,
-      timeout: 60000,
-      client: {
-        requestPermission: async () =>
-          ({ outcome: { outcome: "allow" } }) as any,
-        sessionUpdate: async (update: any) => {
-          const type = update?.update?.sessionUpdate;
-          if (type) updates.push(type);
-        },
-      },
-    });
-
-    // Pre-spawn head manager
-    await mapClient.callExtension("_macro/spawnAgent", {
-      task: "Head manager for cc-swarm test",
-      role: "coordinator",
-    });
-    await new Promise((r) => setTimeout(r, 2000));
-
-    await acpStream.initialize({
-      protocolVersion: 1,
-      clientInfo: { name: "cc-swarm E2E", version: "1.0.0" },
-    });
-
-    const session = await acpStream.newSession({
-      mcpServers: [],
-      cwd: TEST_DIR,
-    });
-
-    const sessionId = (session as any).sessionId;
-    console.log(`[cc-swarm-e2e] Session: ${sessionId}`);
-
-    // Prompt — this triggers tool use which cc-swarm observes
-    const result = await acpStream.prompt({
-      sessionId,
-      prompt: [
-        {
-          type: "text",
-          text: "What is 1+1? Reply with just the number.",
-        },
-      ],
-    });
-
-    console.log(
-      `[cc-swarm-e2e] Prompt: stopReason=${result.stopReason} updates=${updates.length}`,
-    );
-    console.log(
-      `[cc-swarm-e2e] Update types: ${[...new Set(updates)].join(", ")}`,
-    );
-
-    expect(result.stopReason).toBeTruthy();
-    expect(updates.length).toBeGreaterThan(0);
-
-    // After the prompt, cc-swarm's Stop hook should fire and send
-    // a trajectory checkpoint. Wait a moment for it.
-    await new Promise((r) => setTimeout(r, 3000));
-
-    // Check MAP server connections — cc-swarm may have connected
-    console.log(
-      `[cc-swarm-e2e] Final MAP server connections: ${system.mapServerInstance!.getConnectionCount()}`,
-    );
-
-    // Try calling trajectory/checkpoint directly to verify the handler works
-    const checkpointResult = await mapClient.callExtension(
-      "trajectory/checkpoint",
-      {
-        checkpoint: {
-          id: `test-${Date.now()}`,
-          session_id: sessionId,
-          agent: "cc-swarm-e2e-test",
-          branch: null,
-          files_touched: [],
-          checkpoints_count: 1,
-          metadata: { project: "cc-swarm-e2e" },
-        },
-      },
-    );
-    console.log(
-      `[cc-swarm-e2e] trajectory/checkpoint result: ${JSON.stringify(checkpointResult)}`,
-    );
-    expect((checkpointResult as any).ok).toBe(true);
-
-    await acpStream.close();
-  }, 120000);
-});

package/src/__tests__/e2e/cli-run.e2e.test.ts

@@ -1,167 +0,0 @@
-/**
- * `multiagent-cli run <team>` CLI e2e.
- *
- * Spawns the CLI as a real subprocess with a minimal team fixture (so we
- * don't need a full team YAML tree in the test repo). Verifies:
- *   - CLI boots successfully
- *   - Team starts (log output confirms)
- *   - SIGINT shutdown exits cleanly
- *
- * REQUIRES: RUN_E2E_TESTS=true
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-import { spawn, type ChildProcess } from 'child_process';
-
-const RUN_E2E = !!process.env.RUN_E2E_TESTS;
-const describeFn = RUN_E2E ? describe : describe.skip;
-
-describeFn('multiagent-cli run <team>', () => {
-  let testDir: string;
-  let cliProcess: ChildProcess | null = null;
-  const cliPath = path.resolve(process.cwd(), 'dist/cli/index.js');
-
-  beforeEach(() => {
-    testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cli-run-e2e-'));
-
-    // Minimal project scaffolding: a git repo + .multiagent/teams/<name>/
-    const repoPath = path.join(testDir, 'repo');
-    fs.mkdirSync(repoPath);
-    // initialize git so git-cascade can attach
-    const { execSync } = require('child_process');
-    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' });
-
-    // Minimal team template (no macro_agent.workspace — simplest path)
-    const teamDir = path.join(repoPath, '.multiagent/teams/minimal');
-    fs.mkdirSync(teamDir, { recursive: true });
-    fs.mkdirSync(path.join(teamDir, 'prompts'));
-    fs.writeFileSync(
-      path.join(teamDir, 'team.yaml'),
-      `name: minimal
-description: Minimal team for CLI e2e
-version: 1
-
-roles:
-  - worker
-
-topology:
-  root:
-    role: worker
-    prompt: prompts/worker.md
-
-communication:
-  enforcement: permissive
-`
-    );
-    fs.writeFileSync(path.join(teamDir, 'prompts/worker.md'), '# Worker\nDo work.\n');
-  });
-
-  afterEach(async () => {
-    if (cliProcess && !cliProcess.killed) {
-      cliProcess.kill('SIGINT');
-      await new Promise((resolve) => setTimeout(resolve, 500));
-      if (!cliProcess.killed) cliProcess.kill('SIGKILL');
-    }
-    cliProcess = null;
-    if (fs.existsSync(testDir)) {
-      fs.rmSync(testDir, { recursive: true, force: true });
-    }
-  });
-
-  it('boots, starts the team, and responds to SIGINT with clean shutdown', async () => {
-    const repoPath = path.join(testDir, 'repo');
-    const baseDir = path.join(testDir, 'state');
-    fs.mkdirSync(baseDir);
-
-    cliProcess = spawn(
-      'node',
-      [cliPath, 'run', 'minimal', '--cwd', repoPath, '--base-path', repoPath],
-      {
-        env: {
-          ...process.env,
-          MACRO_BASE_DIR: baseDir,
-        },
-        stdio: ['ignore', 'pipe', 'pipe'],
-      }
-    );
-
-    let stdout = '';
-    let stderr = '';
-    cliProcess.stdout?.on('data', (chunk: Buffer) => {
-      stdout += chunk.toString();
-    });
-    cliProcess.stderr?.on('data', (chunk: Buffer) => {
-      stderr += chunk.toString();
-    });
-
-    // Wait for the CLI to reach "Team started" or timeout
-    const booted = await new Promise<boolean>((resolve) => {
-      const timeout = setTimeout(() => resolve(false), 15_000);
-      const check = setInterval(() => {
-        if (stdout.includes('Team started') || stdout.includes('team started')) {
-          clearTimeout(timeout);
-          clearInterval(check);
-          resolve(true);
-        }
-      }, 100);
-    });
-
-    if (!booted) {
-      console.error('stdout:', stdout);
-      console.error('stderr:', stderr);
-    }
-    expect(booted).toBe(true);
-    expect(stdout).toContain('booted');
-
-    // Send SIGINT and verify clean exit
-    const exitPromise = new Promise<number | null>((resolve) => {
-      cliProcess!.once('exit', (code) => resolve(code));
-    });
-
-    cliProcess.kill('SIGINT');
-    const exitCode = await Promise.race([
-      exitPromise,
-      new Promise<number | null>((resolve) => setTimeout(() => resolve(-1), 5_000)),
-    ]);
-
-    expect(exitCode).toBe(0);
-  });
-
-  it('prints an error and exits non-zero when team does not exist', async () => {
-    const repoPath = path.join(testDir, 'repo');
-    const baseDir = path.join(testDir, 'state');
-    fs.mkdirSync(baseDir);
-
-    cliProcess = spawn(
-      'node',
-      [cliPath, 'run', 'no-such-team', '--cwd', repoPath, '--base-path', repoPath],
-      {
-        env: { ...process.env, MACRO_BASE_DIR: baseDir },
-        stdio: ['ignore', 'pipe', 'pipe'],
-      }
-    );
-
-    let stderr = '';
-    let stdout = '';
-    cliProcess.stderr?.on('data', (c: Buffer) => (stderr += c.toString()));
-    cliProcess.stdout?.on('data', (c: Buffer) => (stdout += c.toString()));
-
-    const exitCode: number | null = await new Promise((resolve) => {
-      cliProcess!.once('exit', (code) => resolve(code));
-      setTimeout(() => resolve(-1), 15_000);
-    });
-
-    expect(exitCode).not.toBe(0);
-    // Accept error text from either stdout (chalk.red) or stderr
-    const combined = stdout + stderr;
-    expect(combined.toLowerCase()).toMatch(/fail|error|no-such-team/);
-  });
-});