@1agh/maude 1.0.11 → 1.2.0

package/apps/studio/test/_helpers.ts

@@ -1,108 +0,0 @@
-// Shared test scaffolding. Bun-test only.
-
-import { mkdirSync, mkdtempSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { type Subprocess, spawn } from 'bun';
-
-export interface Sandbox {
-  root: string;
-  designRoot: string;
-}
-
-export function makeSandbox(): Sandbox {
-  const root = mkdtempSync(join(tmpdir(), 'mdcc-test-'));
-  const designRoot = join(root, '.design');
-  mkdirSync(designRoot, { recursive: true });
-  writeFileSync(
-    join(designRoot, 'config.json'),
-    JSON.stringify(
-      {
-        name: 'test',
-        designRoot: '.design',
-        canvasGroups: [
-          { label: 'System', path: 'system' },
-          { label: 'UI', path: 'ui' },
-        ],
-      },
-      null,
-      2
-    )
-  );
-  mkdirSync(join(designRoot, 'ui'), { recursive: true });
-  writeFileSync(
-    join(designRoot, 'ui', 'fixture.html'),
-    '<!doctype html><html><head><title>fix</title></head><body><h1>fixture</h1></body></html>'
-  );
-  return { root, designRoot };
-}
-
-// Base is spread by pid, not a fixed literal — bun test runs different test
-// files as separate processes, each importing a fresh copy of this module, so
-// a fixed base (e.g. 4500 for everyone) reliably collides across files. The
-// pid spread doesn't guarantee uniqueness on its own — bootServer's pid check
-// below is the actual safety net — but it makes collisions rare in practice.
-let portCounter = 4500 + (process.pid % 4000);
-export function nextPort(): number {
-  // Bump on every call so parallel tests don't collide. Bun.serve will throw
-  // EADDRINUSE if the host happened to bind one — caller retries with nextPort().
-  portCounter += 1;
-  return portCounter;
-}
-
-export async function bootServer(
-  root: string,
-  port: number,
-  extraEnv?: Record<string, string>
-): Promise<Subprocess> {
-  const serverPath = join(import.meta.dir, '..', 'server.ts');
-  const proc = spawn({
-    cmd: ['bun', 'run', serverPath, '--port', String(port), '--root', root],
-    cwd: join(import.meta.dir, '..'),
-    env: { ...process.env, NO_OPEN: '1', NODE_ENV: 'test', ...extraEnv },
-    stdout: 'pipe',
-    stderr: 'pipe',
-  });
-  // Wait up to 10 s for the server to bind — the first spawn cold-compiles the
-  // whole studio TS, which under parallel test load regularly blows a 3 s
-  // budget (the flaky "server did not start" class of failure).
-  //
-  // THIS BUDGET IS ONLY REACHABLE BECAUSE THE SUITE RAISES THE PER-TEST TIMEOUT.
-  // bun's default is 5 s, so the TEST was killed while this loop still had half
-  // its patience left, and the failure never named a boot at all — it named
-  // whichever test happened to be booting when the machine was busiest, at
-  // exactly 5000ms, a different one every run. `test:dev-server` therefore
-  // passes `--timeout 20000` (bunfig's `[test] timeout` is NOT honored on bun
-  // 1.3.3 — measured, not assumed). Change one, change the other.
-  const start = Date.now();
-  while (Date.now() - start < 10000) {
-    try {
-      const r = await fetch(`http://localhost:${port}/_health`, {
-        signal: AbortSignal.timeout(200),
-      });
-      if (r.ok) {
-        const json = (await r.json()) as { pid?: number };
-        // A same-port collision with a concurrently-running test file's server
-        // (see the portCounter comment above) would otherwise look "ready" —
-        // /_health answers fine, just from someone else's sandbox — and every
-        // later request 404s against a designRoot that doesn't have our
-        // fixtures. Only trust the health check if it's actually our process.
-        if (json.pid === proc.pid) return proc;
-      }
-    } catch {
-      /* not up yet */
-    }
-    await Bun.sleep(50);
-  }
-  proc.kill();
-  throw new Error(`server did not start on port ${port} within 10 s`);
-}
-
-export async function killProc(proc: Subprocess) {
-  proc.kill();
-  try {
-    await proc.exited;
-  } catch {
-    /* ignore */
-  }
-}

package/apps/studio/test/acp-activity-endpoint.test.ts

@@ -1,183 +0,0 @@
-// feature-acp-turn-notifications Task 2/3 — the activity snapshot the native
-// shell's poller reads (notify.rs Task 5) to decide whether to fire an OS
-// notification for a project that isn't the visible one. Covers:
-//   • activitySnapshot() shape + monotonic seq (bumps only on real change).
-//   • AcpBridge.awaitingInputCount reflects pending permission requests.
-//   • The Acp manager's registered probe reports 'awaiting-input', not
-//     'running', for a chat blocked on a permission prompt — the ordering
-//     Task 2's gotcha calls out explicitly.
-//   • /_api/acp/activity is absent from both canvas-origin allowlists
-//     (Decision: NEITHER, like /_api/acp/running today).
-
-import { afterEach, describe, expect, test } from 'bun:test';
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
-
-import type { ServerWebSocket } from 'bun';
-
-import { AcpBridge } from '../acp/bridge.ts';
-import { createAcp } from '../acp/index.ts';
-import { activitySnapshot, registerActivityProbe } from '../acp/running.ts';
-import type { Context } from '../context.ts';
-import type { WsData } from '../ws.ts';
-
-const FIXTURE = join(import.meta.dir, 'fixtures', 'mock-acp-agent-permission.mjs');
-const TEST_ENV_KEYS = ['MAUDE_ACP_ADAPTER_ENTRY', 'MAUDE_ACP_RUNTIME', 'MAUDE_CLAUDE_BIN'];
-
-function useMockAgent() {
-  process.env.MAUDE_ACP_ADAPTER_ENTRY = FIXTURE;
-  process.env.MAUDE_ACP_RUNTIME = process.execPath;
-  process.env.MAUDE_CLAUDE_BIN = process.execPath;
-}
-
-afterEach(() => {
-  for (const key of TEST_ENV_KEYS) delete process.env[key];
-  // Restore a no-op probe so a later file's `registerRunningChatsProbe`-style
-  // module-level state doesn't leak a stale closure across test files.
-  registerActivityProbe(() => []);
-});
-
-async function until<T>(fn: () => T | undefined, timeoutMs = 12000): Promise<T> {
-  const start = performance.now();
-  for (;;) {
-    const v = fn();
-    if (v !== undefined) return v;
-    if (performance.now() - start > timeoutMs) throw new Error('timeout waiting for condition');
-    await new Promise((r) => setTimeout(r, 25));
-  }
-}
-
-function fakeWs(id: string) {
-  const frames: Array<Record<string, unknown>> = [];
-  const ws = {
-    data: { id } as WsData,
-    send: (raw: string) => {
-      frames.push(JSON.parse(raw));
-    },
-  } as unknown as ServerWebSocket<WsData>;
-  return { ws, frames };
-}
-
-describe('activitySnapshot (running.ts)', () => {
-  test('reflects the registered probe and never throws on a bad one', () => {
-    registerActivityProbe(() => [{ chatId: 'a', state: 'running' }]);
-    expect(activitySnapshot().chats).toEqual([{ chatId: 'a', state: 'running' }]);
-
-    registerActivityProbe(() => {
-      throw new Error('boom');
-    });
-    expect(activitySnapshot().chats).toEqual([]);
-  });
-
-  test('seq bumps only when the (chatId, state) set actually changes', () => {
-    registerActivityProbe(() => [{ chatId: 'a', state: 'idle' }]);
-    const first = activitySnapshot().seq;
-    const second = activitySnapshot().seq; // same state — no bump
-    expect(second).toBe(first);
-
-    registerActivityProbe(() => [{ chatId: 'a', state: 'running' }]);
-    const third = activitySnapshot().seq; // real transition — bumps
-    expect(third).toBe(first + 1);
-
-    // Enumeration-order shuffle with the SAME states must NOT bump.
-    registerActivityProbe(() => [
-      { chatId: 'b', state: 'idle' },
-      { chatId: 'a', state: 'running' },
-    ]);
-    activitySnapshot();
-    registerActivityProbe(() => [
-      { chatId: 'a', state: 'running' },
-      { chatId: 'b', state: 'idle' },
-    ]);
-    const fourth = activitySnapshot().seq;
-    const fifth = activitySnapshot().seq;
-    expect(fifth).toBe(fourth);
-  });
-});
-
-describe('AcpBridge.awaitingInputCount + the manager probe (Task 2 gotcha: awaiting-input wins over running)', () => {
-  test('a pending permission request reports awaiting-input, not running', async () => {
-    useMockAgent();
-    const ctx = {
-      paths: { repoRoot: process.cwd(), designRoot: '/tmp/does-not-matter-activity' },
-    } as unknown as Context;
-    const acp = createAcp(ctx);
-
-    const a = fakeWs('activity-ws-a');
-    try {
-      acp.onOpen(a.ws);
-      acp.onMessage(a.ws, JSON.stringify({ t: 'prompt', text: 'hi', chat: 'activity-chat' }));
-      const reqFrame = await until(() => a.frames.find((f) => f.t === 'permission-request'));
-
-      const snap = activitySnapshot();
-      expect(snap.chats).toContainEqual({ chatId: 'activity-chat', state: 'awaiting-input' });
-
-      acp.onMessage(
-        a.ws,
-        JSON.stringify({ t: 'permission-response', id: reqFrame.id, decision: 'allow-once' })
-      );
-      await until(() => a.frames.find((f) => f.t === 'turn-end'));
-
-      // Turn settled — no longer awaiting-input (running or idle, never stuck).
-      const after = activitySnapshot().chats.find((c) => c.chatId === 'activity-chat');
-      expect(after?.state).not.toBe('awaiting-input');
-    } finally {
-      acp.onClose(a.ws);
-      acp.stopAll();
-      await new Promise((r) => setTimeout(r, 50));
-    }
-  }, 20000);
-});
-
-describe('AcpBridge.awaitingInputCount — direct unit', () => {
-  test('starts at 0 and counts a pending permission before resolution', async () => {
-    useMockAgent();
-    const bridge = new AcpBridge({ repoRoot: process.cwd(), onUpdate: () => {} });
-    expect(bridge.awaitingInputCount).toBe(0);
-    try {
-      const promptPromise = bridge.prompt('hi', 'c1');
-      await until(() => (bridge.awaitingInputCount > 0 ? true : undefined));
-      expect(bridge.awaitingInputCount).toBe(1);
-      await bridge.cancel(); // denies the pending request rather than hanging
-      await promptPromise;
-      expect(bridge.awaitingInputCount).toBe(0);
-    } finally {
-      await bridge.stop();
-    }
-  }, 15000);
-});
-
-describe('/_api/acp/activity — NEITHER canvas-origin allowlist (Decision D + dual-allowlist rule)', () => {
-  const httpSrc = readFileSync(join(import.meta.dir, '..', 'http.ts'), 'utf8');
-  const serverSrc = readFileSync(join(import.meta.dir, '..', 'server.ts'), 'utf8');
-
-  test('the route exists on the main-origin route table', () => {
-    expect(httpSrc).toContain("'/_api/acp/activity'");
-  });
-
-  test('is absent from CANVAS_SAFE_API', () => {
-    const start = httpSrc.indexOf('CANVAS_SAFE_API = new Set([');
-    const end = httpSrc.indexOf(']);', start);
-    expect(start).toBeGreaterThan(-1);
-    const block = httpSrc.slice(start, end);
-    expect(block).not.toContain('/_api/acp/activity');
-  });
-
-  test("is absent from startCanvasServer's routes map", () => {
-    const start = serverSrc.indexOf('function startCanvasServer');
-    const routesEnd = serverSrc.indexOf('async fetch(req, srv)', start);
-    expect(start).toBeGreaterThan(-1);
-    const block = serverSrc.slice(start, routesEnd);
-    expect(block).not.toContain('/_api/acp/activity');
-  });
-
-  test('the payload never carries a chat title, message text, or transcript field name', () => {
-    // Grep the route handler body itself (not the whole file) for the fields
-    // Decision D forbids — a title/text field appearing HERE would mean
-    // someone widened the payload without reading the comment.
-    const start = httpSrc.indexOf("'/_api/acp/activity':");
-    const end = httpSrc.indexOf('},', start);
-    const block = httpSrc.slice(start, end);
-    expect(block).not.toMatch(/title|message|transcript|content/i);
-  });
-});

package/apps/studio/test/acp-activity.test.ts

@@ -1,154 +0,0 @@
-// RCA issue-acp-subagent-activity-invisible — the ACP chat "still working"
-// indicator must survive the premature turn-end that claude-agent-acp emits
-// while background subagents are still running (adapter settles the prompt at
-// the main agent's `result`, #773). These lock the pure activity reducer +
-// label so a background subagent stays visible instead of the panel looking idle.
-
-import { describe, expect, test } from 'bun:test';
-
-import {
-  activityLabel,
-  applyUpdate,
-  isSubagentTool,
-  reduceActivity,
-} from '../client/panels/acp-runtime.js';
-
-const call = (id: string, toolName?: string, over: Record<string, unknown> = {}) => ({
-  t: 'update' as const,
-  update: {
-    sessionUpdate: 'tool_call',
-    toolCallId: id,
-    title: over.title,
-    kind: over.kind,
-    ...(toolName ? { _meta: { claudeCode: { toolName } } } : {}),
-  },
-});
-const done = (id: string, status = 'completed') => ({
-  t: 'update' as const,
-  update: { sessionUpdate: 'tool_call_update', toolCallId: id, status },
-});
-
-describe('reduceActivity', () => {
-  test('a Task tool_call survives turn-end — the background subagent stays tracked', () => {
-    const m = new Map();
-    expect(
-      reduceActivity(m, call('t1', 'Task', { title: 'map the acp module', kind: 'think' }))
-    ).toBe(true);
-    expect(m.size).toBe(1);
-
-    // The regression this fix exists for: turn-end must NOT wipe the map.
-    expect(reduceActivity(m, { t: 'turn-end', stopReason: 'end_turn' })).toBe(false);
-    expect(m.size).toBe(1);
-
-    // …it drains on the subagent's OWN completed update, not on turn-end.
-    expect(reduceActivity(m, done('t1'))).toBe(true);
-    expect(m.size).toBe(0);
-  });
-
-  test('a hard error still wipes the map (teardown)', () => {
-    const m = new Map();
-    reduceActivity(m, call('t1', 'Read', { kind: 'read' }));
-    expect(reduceActivity(m, { t: 'error', message: 'boom' })).toBe(true);
-    expect(m.size).toBe(0);
-  });
-
-  test('captures the concrete tool name for subagent classification', () => {
-    const m = new Map();
-    reduceActivity(m, call('t1', 'Task', { title: 'x', kind: 'think' }));
-    reduceActivity(m, call('t2', 'Read', { title: 'foo.ts', kind: 'read' }));
-    const tools = [...m.values()];
-    expect(isSubagentTool(tools[0])).toBe(true);
-    expect(isSubagentTool(tools[1])).toBe(false);
-  });
-
-  test('failed updates remove the tool; unknown ids are a no-op', () => {
-    const m = new Map();
-    reduceActivity(m, call('t1', 'Bash', { kind: 'execute' }));
-    expect(reduceActivity(m, done('nope'))).toBe(false);
-    expect(reduceActivity(m, done('t1', 'failed'))).toBe(true);
-    expect(m.size).toBe(0);
-  });
-});
-
-describe('activityLabel', () => {
-  test('subagents get explicit, counted wording', () => {
-    expect(activityLabel([{ toolName: 'Task', title: 'a' }])).toBe('1 subagent running');
-    expect(activityLabel([{ toolName: 'Task' }, { toolName: 'Agent' }])).toBe(
-      '2 subagents running'
-    );
-  });
-
-  test('non-subagent tools fall back to title / count / Working…', () => {
-    expect(activityLabel([{ title: 'Edit foo.ts' }])).toBe('Edit foo.ts');
-    expect(activityLabel([{ title: 'a' }, { title: 'b' }])).toBe('2 tasks running');
-    expect(activityLabel([])).toBe('Working…');
-  });
-});
-
-// The F2 fix: the SAME reducer folds live-turn frames AND the post-turn-end
-// "background continuation" frames the client used to drop. If this drifts, the
-// dropped subagent results / consolidation render wrong (or not at all).
-describe('applyUpdate (shared part reducer)', () => {
-  const chunk = (text: string) => ({
-    sessionUpdate: 'agent_message_chunk',
-    content: { type: 'text', text },
-  });
-  const call = (id: string, title: string, kind: string, rawInput: unknown = {}) => ({
-    sessionUpdate: 'tool_call',
-    toolCallId: id,
-    title,
-    kind,
-    rawInput,
-  });
-  const upd = (id: string, status: string, rawOutput: unknown) => ({
-    sessionUpdate: 'tool_call_update',
-    toolCallId: id,
-    status,
-    rawOutput,
-  });
-
-  test('coalesces consecutive text chunks into one part', () => {
-    const parts: unknown[] = [];
-    const ti = new Map();
-    applyUpdate(parts, ti, chunk('Panel: '));
-    applyUpdate(parts, ti, chunk('9 blockers'));
-    expect(parts).toEqual([{ type: 'text', text: 'Panel: 9 blockers' }]);
-  });
-
-  test('tool_call adds a pending part; tool_call_update fills the result', () => {
-    const parts: Array<Record<string, unknown>> = [];
-    const ti = new Map();
-    applyUpdate(parts, ti, call('t1', 'Write critique/001.md', 'edit', { path: 'x' }));
-    expect(parts[0]).toMatchObject({ type: 'tool-call', toolName: 'Write critique/001.md' });
-    expect(parts[0].result).toBeUndefined();
-    applyUpdate(parts, ti, upd('t1', 'completed', { ok: true }));
-    expect(parts[0]).toMatchObject({ result: { ok: true }, isError: false });
-  });
-
-  test('failed update marks isError', () => {
-    const parts: Array<Record<string, unknown>> = [];
-    const ti = new Map();
-    applyUpdate(parts, ti, call('t1', 'Bash', 'execute'));
-    applyUpdate(parts, ti, upd('t1', 'failed', null));
-    expect(parts[0].isError).toBe(true);
-  });
-
-  test('thought → reasoning part; usage/plan ignored', () => {
-    const parts: unknown[] = [];
-    const ti = new Map();
-    applyUpdate(parts, ti, {
-      sessionUpdate: 'agent_thought_chunk',
-      content: { type: 'text', text: 'hmm' },
-    });
-    applyUpdate(parts, ti, { sessionUpdate: 'usage_update' });
-    applyUpdate(parts, ti, { sessionUpdate: 'plan' });
-    expect(parts).toEqual([{ type: 'reasoning', text: 'hmm' }]);
-  });
-
-  test('update for an unknown tool id is a no-op', () => {
-    const parts: unknown[] = [];
-    const ti = new Map();
-    applyUpdate(parts, ti, upd('nope', 'completed', {}));
-    expect(parts).toEqual([]);
-  });
-});

package/apps/studio/test/acp-ai-activity.test.ts

@@ -1,182 +0,0 @@
-// RC5 (rca/issue-canvas-hmr-optimistic-update-consistency) — the ACP chat agent
-// must raise the same "Claude is editing" ai-activity banner as /design:edit.
-// The tracker watches streamed tool_call / tool_call_update notifications for
-// edit-kind tools touching canvas files and drives start/heartbeat/end.
-
-import { describe, expect, test } from 'bun:test';
-import { join } from 'node:path';
-
-import type { SessionUpdate } from '@agentclientprotocol/sdk';
-
-import { createAgentActivityTracker } from '../acp/index.ts';
-import type { AiActivity, AiActivityEntry } from '../collab/ai-activity.ts';
-import { type Context, createBus } from '../context.ts';
-
-const ROOT = join('/tmp', 'acp-ai-root');
-const DESIGN = join(ROOT, '.design');
-
-function mkCtx(): Context {
-  return {
-    cfg: {} as Context['cfg'],
-    projectLabel: 'test',
-    bus: createBus(),
-    paths: {
-      repoRoot: ROOT,
-      designRel: '.design',
-      designRoot: DESIGN,
-      serverInfoFile: join(DESIGN, '_server.json'),
-      activeFile: join(DESIGN, '_active.json'),
-      commentsDir: join(DESIGN, '_comments'),
-      canvasStateDir: join(DESIGN, '_canvas-state'),
-      historyDir: join(DESIGN, '_history'),
-      tokensUrlRel: '',
-      systemDirRel: 'system',
-    },
-  };
-}
-
-function mkAi(): { ai: AiActivity; calls: string[] } {
-  const calls: string[] = [];
-  const entry = (file: string): AiActivityEntry => ({
-    file,
-    author: 'x',
-    startedAt: 0,
-    lastHeartbeat: 0,
-  });
-  const ai: AiActivity = {
-    start(file, author) {
-      calls.push(`start:${file}:${author}`);
-      return entry(file);
-    },
-    heartbeat(file) {
-      calls.push(`beat:${file}`);
-      return entry(file);
-    },
-    end(file) {
-      calls.push(`end:${file}`);
-      return true;
-    },
-    list: () => [],
-    get: () => null,
-    stop: () => {},
-  };
-  return { ai, calls };
-}
-
-const upd = (u: Record<string, unknown>): SessionUpdate => u as unknown as SessionUpdate;
-
-describe('acp / agent activity tracker', () => {
-  test('edit tool_call on a canvas starts ai-activity with the designRel key', () => {
-    const { ai, calls } = mkAi();
-    const t = createAgentActivityTracker(mkCtx(), ai);
-    t.onUpdate(
-      upd({
-        sessionUpdate: 'tool_call',
-        toolCallId: 't1',
-        kind: 'edit',
-        locations: [{ path: join(DESIGN, 'ui', 'Foo.tsx') }],
-      })
-    );
-    expect(calls).toHaveLength(1);
-    expect(calls[0]).toStartWith('start:.design/ui/Foo.tsx:');
-  });
-
-  test('follow-up update for the same file inside the beat throttle adds nothing', () => {
-    const { ai, calls } = mkAi();
-    const t = createAgentActivityTracker(mkCtx(), ai);
-    const loc = { locations: [{ path: join(DESIGN, 'ui', 'Foo.tsx') }] };
-    t.onUpdate(upd({ sessionUpdate: 'tool_call', toolCallId: 't1', kind: 'edit', ...loc }));
-    // kind omitted on the update — must be recalled from the tool_call by id.
-    t.onUpdate(upd({ sessionUpdate: 'tool_call_update', toolCallId: 't1', ...loc }));
-    expect(calls).toHaveLength(1);
-  });
-
-  test('read/search tools and non-canvas paths never banner', () => {
-    const { ai, calls } = mkAi();
-    const t = createAgentActivityTracker(mkCtx(), ai);
-    t.onUpdate(
-      upd({
-        sessionUpdate: 'tool_call',
-        toolCallId: 'r1',
-        kind: 'read',
-        locations: [{ path: join(DESIGN, 'ui', 'Foo.tsx') }],
-      })
-    );
-    t.onUpdate(
-      upd({
-        sessionUpdate: 'tool_call',
-        toolCallId: 'e2',
-        kind: 'edit',
-        locations: [{ path: join(ROOT, 'src', 'App.tsx') }], // outside designRoot
-      })
-    );
-    t.onUpdate(
-      upd({
-        sessionUpdate: 'tool_call',
-        toolCallId: 'e3',
-        kind: 'edit',
-        locations: [{ path: join(DESIGN, '_history', 'x', 'Foo.tsx') }], // runtime state
-      })
-    );
-    t.onUpdate(
-      upd({
-        sessionUpdate: 'tool_call',
-        toolCallId: 'e4',
-        kind: 'edit',
-        locations: [{ path: join(DESIGN, 'ui', 'Foo.meta.json') }], // not a canvas
-      })
-    );
-    expect(calls).toEqual([]);
-  });
-
-  test('rawInput.file_path works when locations are absent', () => {
-    const { ai, calls } = mkAi();
-    const t = createAgentActivityTracker(mkCtx(), ai);
-    t.onUpdate(
-      upd({
-        sessionUpdate: 'tool_call',
-        toolCallId: 'w1',
-        kind: 'edit',
-        rawInput: { file_path: join(DESIGN, 'ui', 'Bar.tsx') },
-      })
-    );
-    expect(calls).toHaveLength(1);
-    expect(calls[0]).toStartWith('start:.design/ui/Bar.tsx:');
-  });
-
-  test('endTurn ends every banner this turn raised', () => {
-    const { ai, calls } = mkAi();
-    const t = createAgentActivityTracker(mkCtx(), ai);
-    t.onUpdate(
-      upd({
-        sessionUpdate: 'tool_call',
-        toolCallId: 't1',
-        kind: 'edit',
-        locations: [{ path: join(DESIGN, 'ui', 'Foo.tsx') }],
-      })
-    );
-    t.onUpdate(
-      upd({
-        sessionUpdate: 'tool_call',
-        toolCallId: 't2',
-        kind: 'edit',
-        locations: [{ path: join(DESIGN, 'ui', 'Bar.tsx') }],
-      })
-    );
-    t.endTurn();
-    expect(calls.filter((c) => c.startsWith('end:'))).toEqual([
-      'end:.design/ui/Foo.tsx',
-      'end:.design/ui/Bar.tsx',
-    ]);
-    // A later turn on the same file must start (not silently beat) again.
-    t.onUpdate(
-      upd({
-        sessionUpdate: 'tool_call',
-        toolCallId: 't3',
-        kind: 'edit',
-        locations: [{ path: join(DESIGN, 'ui', 'Foo.tsx') }],
-      })
-    );
-    expect(calls.filter((c) => c.startsWith('start:'))).toHaveLength(3);
-  });
-});