macro-agent 0.1.7 → 0.1.10

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

@@ -0,0 +1,413 @@
+/**
+ * Workspace V3 End-to-End Tests (Phase 4/5/7 integration gate)
+ *
+ * Exercises the full stream-first path:
+ *   YAML → parseTeamWorkspaceConfig → YamlDrivenTopology → AgentManagerV2.spawn
+ *   → executeWorkspaceDecision → WorkspaceManager V3 → real git-cascade + git
+ *
+ * These tests prevent the silent-failure class that mocked unit tests miss.
+ *
+ * REQUIRES: RUN_E2E_TESTS=true
+ *
+ * Run with:
+ *   RUN_E2E_TESTS=true npx vitest run --config vitest.e2e.config.ts \
+ *     src/__tests__/e2e/workspace-v3.e2e.test.ts
+ */
+
+import {
+  describe,
+  it,
+  expect,
+  beforeEach,
+  afterEach,
+  vi,
+} from 'vitest';
+import * as path from 'path';
+import * as os from 'os';
+import * as fs from 'fs';
+import { execSync } from 'child_process';
+import { bootV2, type MacroAgentSystemV2 } from '../../boot-v2.js';
+import { GitCascadeAdapter } from '../../workspace/git-cascade-adapter.js';
+import {
+  DefaultWorkspaceManager,
+  createWorkspaceManagerWithAdapter,
+} from '../../workspace/workspace-manager.js';
+import { YamlDrivenTopology } from '../../workspace/topology/yaml-driven.js';
+import {
+  parseTeamWorkspaceConfig,
+  type TeamWorkspaceConfig,
+} from '../../workspace/yaml-schema.js';
+import {
+  registerBuiltinLandingStrategies,
+  MergeToParentStrategy,
+} from '../../workspace/landing/index.js';
+import {
+  DeferStrategy,
+  AbandonStrategy,
+  buildBuiltinRecoveryRegistry,
+} from '../../workspace/recovery/index.js';
+
+// ─────────────────────────────────────────────────────────────────
+// Harness
+// ─────────────────────────────────────────────────────────────────
+
+const RUN_E2E = !!process.env.RUN_E2E_TESTS;
+const describeFn = RUN_E2E ? describe : describe.skip;
+
+// Mock acp-factory — no real Claude Code sessions
+vi.mock('acp-factory', () => ({
+  AgentFactory: {
+    spawn: vi.fn().mockResolvedValue({
+      createSession: vi.fn().mockResolvedValue({
+        id: `session-${Date.now()}`,
+        prompt: vi.fn().mockReturnValue({
+          [Symbol.asyncIterator]: () => ({
+            next: () => Promise.resolve({ done: true, value: undefined }),
+          }),
+        }),
+        forkWithFlush: vi.fn().mockResolvedValue({ id: `forked-${Date.now()}` }),
+      }),
+      loadSession: vi.fn().mockResolvedValue({ id: `loaded-${Date.now()}` }),
+      close: vi.fn().mockResolvedValue(undefined),
+      isRunning: vi.fn().mockReturnValue(true),
+    }),
+  },
+}));
+
+vi.mock('opentasks', () => ({
+  OpenTasksClient: vi.fn().mockImplementation(() => ({
+    connect: vi.fn().mockRejectedValue(new Error('No daemon')),
+    disconnect: vi.fn(),
+    query: vi.fn().mockResolvedValue({ items: [] }),
+    link: vi.fn().mockResolvedValue({ success: true }),
+    task: vi.fn().mockResolvedValue({ id: 't-1' }),
+  })),
+}));
+
+function createTestDir(): string {
+  const dir = path.join(
+    os.tmpdir(),
+    `ws-v3-e2e-${Date.now()}-${Math.random().toString(36).slice(2)}`
+  );
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+function createGitRepo(baseDir: string): string {
+  const repoPath = path.join(baseDir, 'repo');
+  fs.mkdirSync(repoPath, { recursive: true });
+  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\n');
+  execSync('git add .', { cwd: repoPath, stdio: 'pipe' });
+  execSync('git commit -m "init"', { cwd: repoPath, stdio: 'pipe' });
+  return repoPath;
+}
+
+// ─────────────────────────────────────────────────────────────────
+// Tests
+// ─────────────────────────────────────────────────────────────────
+
+describeFn('Workspace V3 E2E', () => {
+  let system: MacroAgentSystemV2;
+  let testDir: string;
+  let repoPath: string;
+  let adapter: GitCascadeAdapter;
+  let workspaceManager: DefaultWorkspaceManager;
+
+  beforeEach(async () => {
+    testDir = createTestDir();
+    repoPath = createGitRepo(testDir);
+    const dbPath = path.join(testDir, 'git-cascade.db');
+
+    adapter = new GitCascadeAdapter({
+      enabled: true,
+      repoPath,
+      dbPath,
+    });
+    workspaceManager = createWorkspaceManagerWithAdapter(adapter, {
+      worktreeBaseDir: path.join(repoPath, '.worktrees'),
+    }) as DefaultWorkspaceManager;
+
+    // Register built-in landing strategies
+    registerBuiltinLandingStrategies(workspaceManager);
+
+    system = await bootV2({
+      cwd: repoPath,
+      baseDir: testDir,
+      inbox: { socketPath: path.join(testDir, 'inbox.sock') },
+      workspaceManager,
+    });
+  });
+
+  afterEach(async () => {
+    if (system) await system.shutdown();
+    if (workspaceManager) workspaceManager.close();
+    if (adapter) adapter.close();
+    if (fs.existsSync(testDir)) fs.rmSync(testDir, { recursive: true, force: true });
+  });
+
+  // ═══════════════════════════════════════════════════════════════
+  // TEST 1: Peer swarm — YAML → Topology → Spawn → V3 allocation
+  // ═══════════════════════════════════════════════════════════════
+
+  describe('peer swarm (V3)', () => {
+    let topology: YamlDrivenTopology;
+    let config: TeamWorkspaceConfig;
+
+    beforeEach(async () => {
+      const parsed = parseTeamWorkspaceConfig({
+        roles: {
+          orchestrator: { workspace: 'none' },
+          peer: {
+            workspace: 'new_stream',
+            stream_lineage: 'fork_from_team_root',
+            landing: 'merge_to_parent_stream',
+            capabilities: ['workspace.commit', 'workspace.land'],
+          },
+        },
+      });
+      if (!parsed) throw new Error('config should parse');
+      config = parsed;
+      topology = new YamlDrivenTopology(config);
+      system.agentManager.setTopologyPolicy(topology);
+
+      // Simulate team start (TeamManager would do this; we call manually)
+      await topology.onTeamStart({
+        teamName: 'peer-swarm-test',
+        teamInstanceId: 'ps-1',
+        workspaceConfig: config,
+        workspaceManager,
+      });
+    });
+
+    it('creates a team root stream at onTeamStart', () => {
+      const streams = workspaceManager.listStreams();
+      const teamRoot = streams.find((s) => s.agentId === 'team:peer-swarm-test');
+      expect(teamRoot).toBeDefined();
+      expect(teamRoot?.name).toBe('peer-swarm-test');
+    });
+
+    it('spawns orchestrator with no workspace (workspace: none)', async () => {
+      const orch = await system.agentManager.spawn({
+        role: 'orchestrator',
+        task: 'coordinate',
+      });
+      const record = system.agentStore.getAgent(orch.id);
+      // workspace: none → no workspace_path assigned
+      expect(record?.workspace_path).toBeFalsy();
+    });
+
+    it('spawns peer with a new stream forked off team root', async () => {
+      const peer = await system.agentManager.spawn({
+        role: 'peer',
+        task: 'investigate',
+      });
+      const record = system.agentStore.getAgent(peer.id);
+
+      expect(record?.workspace_path).toBeDefined();
+      expect(fs.existsSync(record!.workspace_path!)).toBe(true);
+
+      const streams = workspaceManager.listStreams();
+      const teamRoot = streams.find((s) => s.agentId === 'team:peer-swarm-test');
+      const peerStream = streams.find((s) => s.agentId === peer.id);
+
+      expect(peerStream).toBeDefined();
+      expect(peerStream?.parentStream).toBe(teamRoot?.id);
+    });
+
+    it('emits stream:created and worktree:allocated events on peer spawn', async () => {
+      const events: string[] = [];
+      workspaceManager.onEvent((e) => events.push(e.type));
+
+      await system.agentManager.spawn({ role: 'peer', task: 'investigate' });
+
+      expect(events).toContain('stream:forked');
+      expect(events).toContain('worktree:allocated');
+    });
+  });
+
+  // ═══════════════════════════════════════════════════════════════
+  // TEST 2: Landing — real merge-to-parent through a real merge
+  // ═══════════════════════════════════════════════════════════════
+
+  describe('merge-to-parent landing (V3)', () => {
+    it('merges a child stream into its parent via the strategy', async () => {
+      // Team root owned by a pseudo-principal
+      const parentStreamId = workspaceManager.createStreamV3({
+        name: 'parent',
+        ownerId: 'team:landing-test',
+        forkFrom: 'main',
+      });
+
+      // Agent owns a child forked off parent
+      const childStreamId = workspaceManager.forkStream({
+        parentStreamId,
+        name: 'child',
+        ownerId: 'agent-auth',
+      });
+
+      // Allocate worktree for the agent on the child branch
+      const worktree = workspaceManager.allocateWorktree({
+        agentId: 'agent-auth',
+        streamId: childStreamId,
+      });
+
+      // Make a real commit via commitChanges (Change-Id tracked)
+      fs.writeFileSync(path.join(worktree.path, 'auth.ts'), 'export const X = 1;');
+      const { commit, changeId } = workspaceManager.commitChanges({
+        agentId: 'agent-auth',
+        streamId: childStreamId,
+        worktree: worktree.path,
+        message: 'feat: add auth module',
+      });
+
+      expect(commit).toMatch(/^[0-9a-f]+$/);
+      expect(changeId).toMatch(/^c-/);
+
+      // Invoke the landing strategy directly
+      const strategy = new MergeToParentStrategy();
+      const result = await strategy.land({
+        agentId: 'agent-auth',
+        streamId: childStreamId,
+        sourceWorktree: worktree.path,
+        workspaceManager,
+      });
+
+      expect(result.success).toBe(true);
+
+      // Verify parent stream advanced
+      const parent = workspaceManager.listStreams().find((s) => s.id === parentStreamId);
+      expect(parent?.status).toBe('active');
+
+      // Verify the Change-Id is tracked and findable
+      const change = workspaceManager.getChange(changeId);
+      expect(change).not.toBeNull();
+    });
+
+    it('fails gracefully when source has no parent', async () => {
+      // Orphan stream (no parent)
+      const streamId = workspaceManager.createStreamV3({
+        name: 'orphan',
+        ownerId: 'agent-x',
+        forkFrom: 'main',
+      });
+      const worktree = workspaceManager.allocateWorktree({
+        agentId: 'agent-x',
+        streamId,
+      });
+
+      const strategy = new MergeToParentStrategy();
+      const result = await strategy.land({
+        agentId: 'agent-x',
+        streamId,
+        sourceWorktree: worktree.path,
+        workspaceManager,
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.error).toMatch(/no target stream/);
+    });
+  });
+
+  // ═══════════════════════════════════════════════════════════════
+  // TEST 3: Conflict recovery — real conflict → real abandon
+  // ═══════════════════════════════════════════════════════════════
+
+  describe('conflict recovery dispatch (V3)', () => {
+    it('routes through buildBuiltinRecoveryRegistry to the abandon strategy', async () => {
+      // Create a stream so abandon has something to act on
+      const streamId = workspaceManager.createStreamV3({
+        name: 'doomed',
+        ownerId: 'agent-1',
+        forkFrom: 'main',
+      });
+
+      // Simulate a conflict record created by git-cascade
+      const conflictId = adapter.createConflict({
+        streamId,
+        conflictingCommit: '0'.repeat(40),
+        targetCommit: '0'.repeat(40),
+        conflictedFiles: ['conflict.ts'],
+      });
+
+      const registry = buildBuiltinRecoveryRegistry();
+      const abandon = registry.get('abandon');
+      expect(abandon).toBeDefined();
+
+      const resolution = await abandon!.recover({
+        conflictId,
+        streamId,
+        paths: ['conflict.ts'],
+        operation: 'merge',
+        recoveryDepth: 0,
+        workspaceManager,
+      });
+
+      expect(resolution.kind).toBe('abandoned');
+      // Verify the stream is actually abandoned in git-cascade
+      const stream = workspaceManager.listStreams().find((s) => s.id === streamId);
+      expect(stream?.status).toBe('abandoned');
+    });
+
+    it('defer leaves the conflict record in place', async () => {
+      const streamId = workspaceManager.createStreamV3({
+        name: 'deferred',
+        ownerId: 'agent-1',
+        forkFrom: 'main',
+      });
+      const conflictId = adapter.createConflict({
+        streamId,
+        conflictingCommit: '0'.repeat(40),
+        targetCommit: '0'.repeat(40),
+        conflictedFiles: ['x.ts'],
+      });
+
+      const defer = new DeferStrategy();
+      const resolution = await defer.recover({
+        conflictId,
+        streamId,
+        paths: ['x.ts'],
+        operation: 'merge',
+        recoveryDepth: 0,
+        workspaceManager,
+      });
+
+      expect(resolution.kind).toBe('deferred');
+      // Stream is untouched (still active; conflict record still exists)
+      const stream = workspaceManager.listStreams().find((s) => s.id === streamId);
+      expect(stream?.status).toBe('active');
+      const conflict = adapter.getConflict(conflictId);
+      expect(conflict).not.toBeNull();
+    });
+  });
+
+  // ═══════════════════════════════════════════════════════════════
+  // TEST 4: Regression — legacy path still works unchanged
+  // ═══════════════════════════════════════════════════════════════
+
+  describe('regression: legacy path (no TopologyPolicy set)', () => {
+    it('still allocates workspace via role-name dispatch', async () => {
+      // Do NOT set a topology policy; ensure legacy path is active
+      const streamId = workspaceManager.createIntegrationStream('coord-legacy', {
+        name: 'legacy-feature',
+      });
+      const taskId = workspaceManager.createTask(streamId, {
+        title: 'legacy task',
+      });
+
+      const worker = await system.agentManager.spawn({
+        role: 'worker',
+        task: 'do work',
+        streamId,
+        gitCascadeTaskId: taskId,
+        capabilities: ['workspace.worktree'],
+      });
+
+      const record = system.agentStore.getAgent(worker.id);
+      expect(record?.workspace_path).toBeDefined();
+      expect(fs.existsSync(record!.workspace_path!)).toBe(true);
+    });
+  });
+});

package/src/acp/__tests__/claude-code-replay.test.ts

@@ -0,0 +1,225 @@
+/**
+ * Tests for the Claude Code JSONL → ACP SessionUpdate converter.
+ *
+ * Verifies that the replay fallback correctly parses real-world Claude Code
+ * transcript entries and emits the right sessionUpdate events in order.
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import * as os from "node:os";
+import { randomBytes } from "node:crypto";
+import { replayClaudeCodeTranscript } from "../claude-code-replay.js";
+
+function jsonl(obj: unknown): string {
+  return JSON.stringify(obj) + "\n";
+}
+
+async function collectUpdates(sessionId: string): Promise<any[]> {
+  const updates: any[] = [];
+  for await (const u of replayClaudeCodeTranscript(sessionId)) {
+    updates.push(u);
+  }
+  return updates;
+}
+
+describe("replayClaudeCodeTranscript", () => {
+  const testProjectDir = `-test-replay-${randomBytes(4).toString("hex")}`;
+  const claudeProjectsRoot = path.join(os.homedir(), ".claude", "projects");
+  const fixtureDir = path.join(claudeProjectsRoot, testProjectDir);
+  const nonExistentSessionId = "00000000-0000-0000-0000-000000000000";
+
+  beforeAll(async () => {
+    await fs.mkdir(fixtureDir, { recursive: true });
+  });
+
+  afterAll(async () => {
+    await fs.rm(fixtureDir, { recursive: true, force: true });
+  });
+
+  it("returns no updates when transcript file doesn't exist", async () => {
+    const updates = await collectUpdates(nonExistentSessionId);
+    expect(updates).toEqual([]);
+  });
+
+  it("converts a simple user/assistant exchange", async () => {
+    const sessionId = `sess-simple-${randomBytes(4).toString("hex")}`;
+    const transcript =
+      jsonl({ type: "queue-operation", operation: "enqueue" }) +  // skip
+      jsonl({
+        type: "user",
+        isMeta: false,
+        message: { role: "user", content: [{ type: "text", text: "hello" }] },
+      }) +
+      jsonl({
+        type: "assistant",
+        message: {
+          role: "assistant",
+          content: [{ type: "text", text: "hi there" }],
+        },
+      });
+    await fs.writeFile(path.join(fixtureDir, `${sessionId}.jsonl`), transcript);
+
+    const updates = await collectUpdates(sessionId);
+    expect(updates).toHaveLength(2);
+    expect(updates[0]).toEqual({
+      sessionUpdate: "user_message_chunk",
+      content: { type: "text", text: "hello" },
+    });
+    expect(updates[1]).toEqual({
+      sessionUpdate: "agent_message_chunk",
+      content: { type: "text", text: "hi there" },
+    });
+  });
+
+  it("skips meta messages and internal commands", async () => {
+    const sessionId = `sess-meta-${randomBytes(4).toString("hex")}`;
+    const transcript =
+      jsonl({
+        type: "user",
+        isMeta: true,   // should skip
+        message: { role: "user", content: "system context" },
+      }) +
+      jsonl({
+        type: "user",
+        message: { role: "user", content: "<command-name>/model</command-name>" },
+      }) +  // string starting with <command- → skip
+      jsonl({
+        type: "user",
+        message: { role: "user", content: "<local-command-stdout>ok</local-command-stdout>" },
+      }) +  // skip
+      jsonl({
+        type: "user",
+        message: { role: "user", content: [{ type: "text", text: "real message" }] },
+      });
+    await fs.writeFile(path.join(fixtureDir, `${sessionId}.jsonl`), transcript);
+
+    const updates = await collectUpdates(sessionId);
+    expect(updates).toHaveLength(1);
+    expect(updates[0]).toMatchObject({
+      sessionUpdate: "user_message_chunk",
+      content: { type: "text", text: "real message" },
+    });
+  });
+
+  it("converts tool_use and tool_result blocks", async () => {
+    const sessionId = `sess-tools-${randomBytes(4).toString("hex")}`;
+    const transcript =
+      jsonl({
+        type: "assistant",
+        message: {
+          role: "assistant",
+          content: [
+            { type: "text", text: "Let me check." },
+            {
+              type: "tool_use",
+              id: "tc_1",
+              name: "Read",
+              input: { path: "/tmp/foo" },
+            },
+          ],
+        },
+      }) +
+      jsonl({
+        type: "user",
+        message: {
+          role: "user",
+          content: [
+            {
+              type: "tool_result",
+              tool_use_id: "tc_1",
+              content: "file contents",
+            },
+          ],
+        },
+      });
+    await fs.writeFile(path.join(fixtureDir, `${sessionId}.jsonl`), transcript);
+
+    const updates = await collectUpdates(sessionId);
+    expect(updates).toHaveLength(3);
+    expect(updates[0]).toMatchObject({
+      sessionUpdate: "agent_message_chunk",
+      content: { type: "text", text: "Let me check." },
+    });
+    expect(updates[1]).toMatchObject({
+      sessionUpdate: "tool_call",
+      toolCallId: "tc_1",
+      title: "Read",
+      rawInput: { path: "/tmp/foo" },
+    });
+    expect(updates[2]).toMatchObject({
+      sessionUpdate: "tool_call_update",
+      toolCallId: "tc_1",
+      output: "file contents",
+      status: "completed",
+    });
+  });
+
+  it("handles assistant thinking blocks", async () => {
+    const sessionId = `sess-think-${randomBytes(4).toString("hex")}`;
+    const transcript = jsonl({
+      type: "assistant",
+      message: {
+        role: "assistant",
+        content: [
+          { type: "thinking", thinking: "Let me reason about this..." },
+          { type: "text", text: "Here's my answer." },
+        ],
+      },
+    });
+    await fs.writeFile(path.join(fixtureDir, `${sessionId}.jsonl`), transcript);
+
+    const updates = await collectUpdates(sessionId);
+    expect(updates).toHaveLength(2);
+    expect(updates[0]).toMatchObject({
+      sessionUpdate: "agent_thought_chunk",
+      content: { type: "text", text: "Let me reason about this..." },
+    });
+    expect(updates[1]).toMatchObject({
+      sessionUpdate: "agent_message_chunk",
+    });
+  });
+
+  it("ignores malformed JSONL lines and continues", async () => {
+    const sessionId = `sess-bad-${randomBytes(4).toString("hex")}`;
+    const transcript =
+      "not-json\n" +
+      "{\n" +  // incomplete
+      jsonl({
+        type: "user",
+        message: { role: "user", content: [{ type: "text", text: "after garbage" }] },
+      }) +
+      "\n";  // blank line
+    await fs.writeFile(path.join(fixtureDir, `${sessionId}.jsonl`), transcript);
+
+    const updates = await collectUpdates(sessionId);
+    expect(updates).toHaveLength(1);
+    expect(updates[0]).toMatchObject({
+      content: { type: "text", text: "after garbage" },
+    });
+  });
+
+  it("produces events in chronological (file) order", async () => {
+    const sessionId = `sess-order-${randomBytes(4).toString("hex")}`;
+    const transcript = Array.from({ length: 5 }, (_, i) =>
+      jsonl({
+        type: i % 2 === 0 ? "user" : "assistant",
+        message: {
+          role: i % 2 === 0 ? "user" : "assistant",
+          content: [{ type: "text", text: `msg-${i}` }],
+        },
+      }),
+    ).join("");
+    await fs.writeFile(path.join(fixtureDir, `${sessionId}.jsonl`), transcript);
+
+    const updates = await collectUpdates(sessionId);
+    expect(updates.map((u) => u.content?.text)).toEqual([
+      "msg-0",
+      "msg-1",
+      "msg-2",
+      "msg-3",
+      "msg-4",
+    ]);
+  });
+});

package/src/acp/__tests__/macro-agent.test.ts

@@ -141,7 +141,7 @@ describe("createMacroAgent", () => {
   // ── newSession ──────────────────────────────────────────────
 
   describe("newSession", () => {
-    it("should create head manager and return session ID", async () => {
+    it("should create head manager and return session ID (cwd fallback)", async () => {
       const agent = createAgent();
       const result = await agent.newSession({
         cwd: "/tmp/test",
@@ -153,6 +153,44 @@ describe("createMacroAgent", () => {
         cwd: "/tmp/test",
       });
     });
+
+    it("binds the session to initConfig.targetAgentId when provided (skips cwd lookup)", async () => {
+      // Stub getActiveAgentSession on the mock system
+      system.agentManager.getActiveAgentSession = vi.fn().mockReturnValue({
+        id: "worker-7",
+        session_id: "worker-7-session",
+        agent: { id: "worker-7", role: "worker", state: "running" },
+        session: {},
+      });
+
+      // Bind this MacroAgent to a specific (non-coordinator) agent
+      const agent = createMacroAgent(connection, {
+        system,
+        initConfig: { targetAgentId: "worker-7" },
+      });
+      await agent.newSession({ cwd: "/tmp/whatever", mcpServers: [] });
+
+      expect(system.agentManager.getActiveAgentSession).toHaveBeenCalledWith("worker-7");
+      // cwd-based lookup must NOT run when a target is bound
+      expect(system.agentManager.getOrCreateHeadManager).not.toHaveBeenCalled();
+    });
+
+    it("throws AGENT_NOT_FOUND when targetAgentId has no live session", async () => {
+      system.agentManager.getActiveAgentSession = vi.fn().mockReturnValue(null);
+
+      const agent = createMacroAgent(connection, {
+        system,
+        initConfig: { targetAgentId: "ghost-agent" },
+      });
+
+      await expect(
+        agent.newSession({ cwd: "/tmp/test", mcpServers: [] }),
+      ).rejects.toMatchObject({
+        name: "ACPError",
+        code: "AGENT_NOT_FOUND",
+      });
+      expect(system.agentManager.getOrCreateHeadManager).not.toHaveBeenCalled();
+    });
   });
 
   // ── prompt ──────────────────────────────────────────────────