agenticreplay 0.1.0 → 0.1.2

package/packages/cli/test/replay-spill.test.ts

@@ -1,116 +0,0 @@
-import { mkdtemp, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { TraceReader, TraceWriter } from '@agenticreplay/core';
-import { INLINE_PAYLOAD_LIMIT, isBlobRef } from '@agenticreplay/schema';
-import { loadExchanges } from '../src/commands/replay.js';
-
-/**
- * Regression guard for the bug that made replay useless against a real agent.
- *
- * The writer spills any payload over `INLINE_PAYLOAD_LIMIT` into a blob as `JSON.stringify(payload)`.
- * Every wire body is a *string*, so a spilled body lands in the blob as a JSON string literal —
- * quoted and backslash-escaped — while the identical body under the limit is stored as itself.
- * Replay read the blob bytes straight back, so it canonicalized an escaped copy: `model` came out
- * empty, `messages` came out `[]`, and every request in the recording fell to rung 4.
- *
- * It was invisible for months of tests because every fixture body was comfortably under 4 KB, and
- * catastrophic in practice because a real harness sends a system prompt and a tool catalogue on the
- * very first turn. Hence the size assertions: a test that stops crossing the spill boundary has
- * stopped testing the thing that broke.
- */
-describe('replay across the inline/blob spill boundary', () => {
-  let dir: string;
-
-  beforeEach(async () => {
-    dir = await mkdtemp(join(tmpdir(), 'agenticreplay-spill-'));
-  });
-
-  afterEach(async () => {
-    await rm(dir, { recursive: true, force: true });
-  });
-
-  /** A request body shaped like a real one: a long system prompt is what pushes it over the limit. */
-  function bigRequest(): string {
-    return JSON.stringify({
-      model: 'claude-opus-5',
-      max_tokens: 1024,
-      system: `You are a coding agent. ${'Follow the repository conventions. '.repeat(200)}`,
-      messages: [{ role: 'user', content: [{ type: 'text', text: 'fix the auth test' }] }],
-    });
-  }
-
-  async function writeRun(rawRequest: string): Promise<string> {
-    const writer = await TraceWriter.create(dir, {
-      adapter: { id: 'claude-code', version: '0.0.0' },
-      argv: ['claude-code'],
-      cwd: dir,
-      agenticreplayVersion: '0.0.0',
-    });
-    await writer.append({
-      type: 'net.request',
-      actor: 'agent',
-      turn: 1,
-      attrs: {
-        phase: 'body',
-        request_id: 'attempt-1',
-        model_dialect: 'anthropic',
-        path: '/v1/messages',
-      },
-      payload: rawRequest,
-    });
-    await writer.append({
-      type: 'net.response',
-      actor: 'agenticreplay',
-      turn: 1,
-      causes: [0],
-      attrs: { request_id: 'attempt-1', status: 200, response_complete: true },
-      payload: JSON.stringify({ id: 'msg_1', content: [{ type: 'text', text: 'done' }] }),
-    });
-    await writer.close(0);
-    return writer.runDir;
-  }
-
-  it('canonicalizes a spilled request body identically to an inline one', async () => {
-    const raw = bigRequest();
-    expect(Buffer.byteLength(raw)).toBeGreaterThan(INLINE_PAYLOAD_LIMIT);
-
-    const reader = await TraceReader.open(await writeRun(raw));
-    const events = await reader.events();
-    // The premise of the test: this body really did spill.
-    expect(isBlobRef(events.find((e) => e.type === 'net.request')?.payload)).toBe(true);
-
-    const [exchange] = await loadExchanges(reader);
-    expect(exchange).toBeDefined();
-    expect(exchange!.canonicalRequest.model).toBe('claude-opus-5');
-    expect(exchange!.canonicalRequest.messages).toHaveLength(1);
-  });
-
-  it('hands the agent back the exact bytes that were recorded', async () => {
-    const raw = bigRequest();
-    const reader = await TraceReader.open(await writeRun(raw));
-    const [exchange] = await loadExchanges(reader);
-    // Not "parses to the same object" — the same bytes. Exact replay means exact.
-    expect(exchange!.rawRequest).toBe(raw);
-  });
-
-  it('treats an inline body and a spilled body the same way', async () => {
-    const small = JSON.stringify({
-      model: 'claude-opus-5',
-      max_tokens: 1024,
-      messages: [{ role: 'user', content: [{ type: 'text', text: 'hi' }] }],
-    });
-    expect(Buffer.byteLength(small)).toBeLessThan(INLINE_PAYLOAD_LIMIT);
-
-    const inline = await loadExchanges(await TraceReader.open(await writeRun(small)));
-    const spilled = await loadExchanges(await TraceReader.open(await writeRun(bigRequest())));
-
-    // Same shape out of both paths: a model, a message list, and the raw bytes intact.
-    for (const set of [inline, spilled]) {
-      expect(set[0]!.canonicalRequest.model).toBe('claude-opus-5');
-      expect(set[0]!.canonicalRequest.messages.length).toBeGreaterThan(0);
-      expect(() => JSON.parse(set[0]!.rawRequest)).not.toThrow();
-    }
-  });
-});

package/packages/cli/test/replay-teardown.test.ts

@@ -1,143 +0,0 @@
-import { execFile } from 'node:child_process';
-import { mkdtemp, readFile, readdir, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { promisify } from 'node:util';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-
-const exec = promisify(execFile);
-// Filesystem-only fixture agents intentionally make no HTTP requests. The recorder correctly
-// exits 2 for absent capture; these tests inspect filesystem restore and process teardown.
-const run: typeof exec = (async (...args: Parameters<typeof exec>) => {
-  try {
-    return await exec(...args);
-  } catch (error) {
-    const failure = error as { code?: number; stdout?: string; stderr?: string };
-    if (
-      failure.code === 2 &&
-      failure.stdout?.includes('capture.empty') &&
-      args[1]?.includes('record')
-    )
-      return { stdout: failure.stdout, stderr: failure.stderr ?? '' };
-    throw error;
-  }
-}) as typeof exec;
-const here = dirname(fileURLToPath(import.meta.url));
-const cli = join(here, '..', 'dist', 'cli.js');
-
-let dir: string;
-beforeEach(async () => {
-  dir = await mkdtemp(join(tmpdir(), 'agenticreplay-replay-teardown-'));
-});
-afterEach(async () => {
-  await rm(dir, { recursive: true, force: true });
-});
-
-/**
- * A replay whose agent cannot be launched has to let go of the terminal.
- *
- * `agenticreplay replay` opens a listening proxy, and a listening server keeps node's event loop alive on
- * its own — so a throw from the spawn printed `could not launch` and then hung, with Ctrl-C the
- * only way out. The fork path in the same file already handled this and says so in a comment; this
- * was the third of the three and the one still missing it.
- *
- * The agent that was recorded is not always installed where the recording is replayed. That is half
- * the point of having a trace, and `spawn <agent> ENOENT` is what it looks like from inside the
- * replay.
- */
-describe('agenticreplay replay, when the recorded agent will not launch', () => {
-  const timeout = 90_000;
-  const bare = { ...process.env, NO_COLOR: '1' };
-
-  /** Record a real run, then point its manifest at an agent that is not installed. */
-  async function runWithMissingAgent(): Promise<string> {
-    await writeFile(join(dir, 'a.mjs'), "process.stdout.write('HI');\n");
-    await run(process.execPath, [cli, 'record', 'node', '--', 'node', 'a.mjs'], {
-      cwd: dir,
-      env: bare,
-      timeout: timeout - 10_000,
-    });
-    const runs = join(dir, '.agenticreplay', 'runs');
-    const [id] = await readdir(runs);
-    const path = join(runs, id!, 'manifest.json');
-    const manifest = JSON.parse(await readFile(path, 'utf8')) as { argv: string[] };
-    manifest.argv = ['node', 'agenticreplay-no-such-binary', 'a.mjs'];
-    await writeFile(path, JSON.stringify(manifest, null, 2));
-    return id!;
-  }
-
-  it(
-    'exits instead of hanging, and says why',
-    async () => {
-      const id = await runWithMissingAgent();
-      const attempt = run(process.execPath, [cli, 'replay', id, '--in-place'], {
-        cwd: dir,
-        env: bare,
-        timeout: timeout - 20_000,
-      });
-      // A hang arrives here as `killed`, which is the whole point of the test and is therefore
-      // distinguished from an ordinary non-zero exit rather than lumped in with it.
-      const err = (await attempt.catch((e: unknown) => e)) as {
-        killed?: boolean;
-        code?: number;
-        stdout?: string;
-        stderr?: string;
-      };
-      expect(err.killed, 'the replay hung instead of exiting').not.toBe(true);
-      expect(err.code).toBe(1);
-      expect(`${err.stdout ?? ''}${err.stderr ?? ''}`).toMatch(/could not launch/);
-    },
-    timeout,
-  );
-
-  /**
-   * And the trace the replay was writing is sealed rather than left open, for the reason the fork
-   * path gives: a run that failed to launch is still a run someone will want to read, and an
-   * unsealed trace has no `ended_at` or `integrity`, so `verifyIntegrity` reports it as tampered
-   * with rather than as unfinished. The exit code stays absent, because there was never one.
-   */
-  it(
-    'seals the trace it was writing, with the reason and without an exit code',
-    async () => {
-      const id = await runWithMissingAgent();
-      await run(process.execPath, [cli, 'replay', id, '--in-place'], {
-        cwd: dir,
-        env: bare,
-        timeout: timeout - 20_000,
-      }).catch(() => undefined);
-
-      const runs = join(dir, '.agenticreplay', 'runs');
-      const written = (await readdir(runs)).filter((r) => r !== id);
-      expect(written, 'the replay left no trace of its own').toHaveLength(1);
-
-      const manifest = JSON.parse(
-        await readFile(join(runs, written[0]!, 'manifest.json'), 'utf8'),
-      ) as { ended_at?: string; integrity?: unknown; exit_code?: number };
-      expect(manifest.ended_at).toBeDefined();
-      expect(manifest.integrity).toBeDefined();
-      expect(manifest.exit_code, 'an exit code that never happened must not be recorded').toBe(
-        undefined,
-      );
-
-      const events = await readFile(join(runs, written[0]!, 'events.jsonl'), 'utf8');
-      expect(events).toMatch(/could not launch/);
-    },
-    timeout,
-  );
-
-  /** The working tree is still put back, which the `finally` was already there to guarantee. */
-  it(
-    'restores the working tree it replayed over',
-    async () => {
-      const id = await runWithMissingAgent();
-      await run(process.execPath, [cli, 'replay', id], {
-        cwd: dir,
-        env: bare,
-        timeout: timeout - 20_000,
-      }).catch(() => undefined);
-      await expect(readFile(join(dir, 'a.mjs'), 'utf8')).resolves.toContain('HI');
-    },
-    timeout,
-  );
-});

package/packages/cli/test/replay-trace.test.ts

@@ -1,199 +0,0 @@
-import { execFile } from 'node:child_process';
-import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { promisify } from 'node:util';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { TraceReader, listRuns, resolveRunSelector } from '@agenticreplay/core';
-import { validateEvent, validateManifest, type TraceEvent } from '@agenticreplay/schema';
-import { parseArgs } from '../src/args.js';
-import { Output } from '../src/out.js';
-import { recordCommand } from '../src/commands/record.js';
-import { replayCommand } from '../src/commands/replay.js';
-import { startFakeModel } from './fixtures/fake-model.mjs';
-
-const run = promisify(execFile);
-const FAKE_AGENT = join(import.meta.dirname, 'fixtures', 'fake-agent.mjs');
-
-/**
- * Spec §4: "Replay MUST NOT silently approximate. Every inexact match is an event in the trace."
- *
- * The fork path honoured that and the exact path did not — divergences went to a local array, got
- * printed, and were gone with the scrollback. So an exact replay now writes its own run, and these
- * tests are about the two halves of that: the findings actually land on disk, and the run being
- * replayed is not touched to get them there.
- */
-describe('exact replay writes a trace of itself', () => {
-  let workspace: string;
-  let model: Awaited<ReturnType<typeof startFakeModel>>;
-  let out: Output;
-  let lines: string[];
-
-  beforeEach(async () => {
-    workspace = await mkdtemp(join(tmpdir(), 'agenticreplay-rtrace-'));
-    model = await startFakeModel();
-    lines = [];
-    out = new Output({ write: (s) => void lines.push(s), isTTY: false });
-    await run('git', ['init', '-q'], { cwd: workspace });
-    await run('git', ['config', 'user.email', 't@e.com'], { cwd: workspace });
-    await run('git', ['config', 'user.name', 'T'], { cwd: workspace });
-    await writeFile(join(workspace, 'auth.ts'), 'export const fixed = false;\n');
-    process.env.FAKE_AGENT_TURNS = '3';
-    // The agent must run in the directory the replay puts it in, exactly as a real harness does.
-    delete process.env.FAKE_AGENT_CWD;
-  });
-
-  afterEach(async () => {
-    delete process.env.FAKE_AGENT_PAD;
-    delete process.env.FAKE_AGENT_PROMPT;
-    await model.close();
-    await rm(workspace, { recursive: true, force: true });
-  });
-
-  async function record() {
-    return recordCommand(
-      parseArgs([
-        'record',
-        'generic-openai',
-        '--upstream-anthropic',
-        model.url,
-        '--',
-        'node',
-        FAKE_AGENT,
-      ]),
-      out,
-      workspace,
-    );
-  }
-
-  async function eventsOf(runId: string): Promise<TraceEvent[]> {
-    const dir = (await resolveRunSelector(workspace, runId)).dir;
-    return (await TraceReader.open(dir)).events();
-  }
-
-  async function manifestOf(runId: string) {
-    const dir = (await resolveRunSelector(workspace, runId)).dir;
-    return (await TraceReader.open(dir)).manifest();
-  }
-
-  it('produces a second run whose manifest names the run it replayed', async () => {
-    const recorded = await record();
-
-    const result = await replayCommand(parseArgs(['replay', 'last']), out, workspace);
-
-    expect(result.traceRunId, 'the replay must report the run it wrote').toBeTruthy();
-    expect(result.traceRunId).not.toBe(recorded.runId);
-    expect((await listRuns(workspace)).length).toBe(2);
-
-    const manifest = await manifestOf(result.traceRunId!);
-    expect(manifest.parent_run).toBe(recorded.runId);
-    // An exact replay has no checkpoint it forked at, so inventing one would be a lie that
-    // `agenticreplay list` and `agenticreplay show` would both print.
-    expect(manifest.fork_point).toBeUndefined();
-    expect(validateManifest(manifest).valid).toBe(true);
-  });
-
-  it('writes one divergence event per divergence, valid against the normative schema', async () => {
-    await record();
-
-    // Same conversation, a system prompt that was not there when it was recorded: the trailing
-    // message still matches, so every request matches inexactly rather than halting. That is
-    // precisely the case §4 exists for — served from the recording, but not the same request.
-    process.env.FAKE_AGENT_PAD = '1';
-    const result = await replayCommand(parseArgs(['replay', 'last']), out, workspace);
-
-    expect(result.divergences, 'fixture must actually diverge').toBeGreaterThan(0);
-
-    const events = await eventsOf(result.traceRunId!);
-    const divergences = events.filter((e) => e.type === 'divergence');
-    expect(divergences.length).toBe(result.divergences);
-
-    for (const d of divergences) {
-      expect(d.attrs?.level).toMatch(/^(minor|major)$/);
-      expect(d.attrs?.rung).toBeTypeOf('number');
-      expect(d.attrs?.detail).toBeTypeOf('string');
-      // The seq in the run being replayed, which is the only way back to what was recorded.
-      expect(d.attrs?.source_seq).toBeTypeOf('number');
-    }
-
-    for (const event of events) {
-      const r = validateEvent(event);
-      expect(r.valid, `seq ${event.seq}: ${r.errors.join(', ')}`).toBe(true);
-    }
-  });
-
-  it('still writes a trace when the replay was clean — an empty finding is a finding', async () => {
-    await record();
-
-    const result = await replayCommand(parseArgs(['replay', 'last']), out, workspace);
-    expect(result.divergences).toBe(0);
-
-    const events = await eventsOf(result.traceRunId!);
-    expect(events.some((e) => e.type === 'run.start')).toBe(true);
-    expect(events.some((e) => e.type === 'run.end')).toBe(true);
-    expect(events.filter((e) => e.type === 'divergence')).toHaveLength(0);
-
-    const end = events.find((e) => e.type === 'run.end');
-    expect(end?.attrs?.exit_code).toBe(result.exitCode);
-  });
-
-  it('names the run it wrote on the replay.done line', async () => {
-    // A run nobody can find is a run nobody reads. This line is the only place the id appears.
-    await record();
-    const result = await replayCommand(parseArgs(['replay', 'last']), out, workspace);
-
-    const done = lines.find((l) => l.includes('replay.done')) ?? '';
-    expect(done, `no replay.done line in:\n${lines.join('\n')}`).toContain(
-      `trace=${result.traceRunId}`,
-    );
-  });
-
-  it('records why it halted, which is the one finding that is nowhere else', async () => {
-    // A matched exchange is already in the parent trace. A request the recording cannot answer is
-    // not — it existed only in the terminal, and the terminal is where debugging sessions go to
-    // die. It is an `error` rather than a `divergence` because nothing was served at all.
-    await record();
-
-    process.env.FAKE_AGENT_PROMPT = 'ask something else entirely';
-    const result = await replayCommand(parseArgs(['replay', 'last']), out, workspace);
-    expect(result.exitCode).not.toBe(0);
-
-    const events = await eventsOf(result.traceRunId!);
-    const halt = events.find((e) => e.type === 'error');
-    expect(halt, `no halt recorded in:\n${JSON.stringify(events, null, 2)}`).toBeDefined();
-    expect(halt?.attrs?.rule).toBe('replay_unmatched');
-    expect(String(halt?.attrs?.reason)).toContain('does not match the recording');
-    expect(events.find((e) => e.type === 'run.end')?.attrs?.exit_code).toBe(result.exitCode);
-    for (const event of events) {
-      const r = validateEvent(event);
-      expect(r.valid, `seq ${event.seq}: ${r.errors.join(', ')}`).toBe(true);
-    }
-  });
-
-  it('writes nothing at all under --no-trace', async () => {
-    await record();
-    const before = await listRuns(workspace);
-
-    const result = await replayCommand(parseArgs(['replay', 'last', '--no-trace']), out, workspace);
-
-    expect(result.traceRunId).toBeUndefined();
-    expect((await listRuns(workspace)).map((r) => r.runId)).toEqual(before.map((r) => r.runId));
-  });
-
-  it('leaves the replayed run byte-identical, integrity included', async () => {
-    // The one that matters most. The run being replayed is append-only and carries a digest over
-    // events.jsonl; a replay that wrote so much as a newline into it would invalidate every trace
-    // anyone had ever verified.
-    const recorded = await record();
-    const eventsPath = join(recorded.runDir, 'events.jsonl');
-    const before = await readFile(eventsPath);
-    const manifestBefore = await readFile(join(recorded.runDir, 'manifest.json'));
-
-    process.env.FAKE_AGENT_PAD = '1';
-    await replayCommand(parseArgs(['replay', recorded.runId]), out, workspace);
-
-    expect(await readFile(eventsPath)).toEqual(before);
-    expect(await readFile(join(recorded.runDir, 'manifest.json'))).toEqual(manifestBefore);
-    expect((await (await TraceReader.open(recorded.runDir)).verifyIntegrity()).ok).toBe(true);
-  });
-});

package/packages/cli/test/replay-transport.test.ts

@@ -1,113 +0,0 @@
-import { mkdtemp, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, expect, it } from 'vitest';
-import { TraceReader, TraceWriter } from '@agenticreplay/core';
-import { loadExchanges } from '../src/commands/replay.js';
-
-const dirs: string[] = [];
-afterEach(async () => {
-  await Promise.all(dirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })));
-});
-async function writer() {
-  const dir = await mkdtemp(join(tmpdir(), 'agenticreplay-wire-'));
-  dirs.push(dir);
-  return TraceWriter.create(dir, {
-    adapter: { id: 'test' },
-    argv: [],
-    cwd: dir,
-    agenticreplayVersion: '0.5.0',
-  });
-}
-const request = JSON.stringify({
-  model: 'test',
-  messages: [{ role: 'user', content: 'wire sentinel' }],
-  unknown_field: { keep: true },
-});
-
-it('never fabricates a replay response from a logical request without transport evidence', async () => {
-  const w = await writer();
-  await w.append({
-    type: 'model.request',
-    actor: 'agent',
-    attrs: { dialect: 'openai' },
-    payload: request,
-  });
-  await w.close(0);
-  expect(await loadExchanges(await TraceReader.open(w.runDir))).toEqual([]);
-});
-
-it('pairs complete transport bodies by identity and rejects interrupted attempts', async () => {
-  const w = await writer();
-  const requests = [];
-  for (let i = 0; i < 3; i++)
-    requests.push(
-      await w.append({
-        type: 'net.request',
-        actor: 'agent',
-        attrs: {
-          phase: 'body',
-          request_id: `attempt-${i}`,
-          model_dialect: 'openai',
-          path: '/v1/chat/completions',
-          capture_incomplete: false,
-        },
-        payload: request,
-      }),
-    );
-  for (const i of [2, 1, 0])
-    await w.append({
-      type: 'net.response',
-      actor: 'agenticreplay',
-      causes: [requests[i]!.seq],
-      attrs: {
-        request_id: `attempt-${i}`,
-        status: i === 0 ? 500 : 200,
-        response_complete: i !== 1,
-        capture_incomplete: i === 1,
-      },
-      payload: JSON.stringify({ sentinel: `response-${i}` }),
-    });
-  await w.close(0);
-  const exchanges = await loadExchanges(await TraceReader.open(w.runDir));
-  expect(exchanges).toHaveLength(2);
-  expect(exchanges.map((e) => e.status)).toEqual([500, 200]);
-  expect(exchanges.map((e) => e.rawResponse)).toEqual([
-    JSON.stringify({ sentinel: 'response-0' }),
-    JSON.stringify({ sentinel: 'response-2' }),
-  ]);
-  expect(exchanges[0]!.rawRequest).toBe(request);
-});
-
-it('does not replay origin bytes that were translated before reaching the client', async () => {
-  const w = await writer();
-  const req = await w.append({
-    type: 'net.request',
-    actor: 'agent',
-    attrs: {
-      phase: 'body',
-      request_id: 'translated-attempt',
-      model_dialect: 'openai',
-      path: '/v1/chat/completions',
-    },
-    payload: request,
-  });
-  await w.append({
-    type: 'net.response',
-    actor: 'agenticreplay',
-    causes: [req.seq],
-    attrs: { request_id: 'translated-attempt', status: 200, response_complete: true },
-    transformations: [
-      {
-        kind: 'encoding',
-        location: 'response.body',
-        rule: 'provider-protocol-translation',
-        count: 1,
-        reason: 'openai response translated to anthropic for the client',
-      },
-    ],
-    payload: '{"choices":[{"message":{"content":"origin body"}}]}',
-  });
-  await w.close(0);
-  expect(await loadExchanges(await TraceReader.open(w.runDir))).toEqual([]);
-});

package/packages/cli/test/reset-roots.test.ts

@@ -1,67 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { resetRoots } from '../src/commands/replay.js';
-
-/**
- * What `agenticreplay replay` is about to `rm -rf` before it restores the recording's initial tree.
- *
- * This is the most destructive thing agenticreplay does to a directory it did not create, so what it
- * resolves to matters more than most path handling in the codebase: the rule it operates under is
- * that agenticreplay deletes only what it took a copy of first, and the copy is taken from the adapter's
- * declared paths. A deletion wider than the declaration is a deletion wider than the copy.
- */
-const dir = process.cwd();
-const artifacts = (resetBeforeReplay: string[]) => ({ resetBeforeReplay });
-
-describe('resetRoots', () => {
-  it('takes the declared path itself, not its first segment', () => {
-    // The regression: `'data/cache'.split(/[\\/]/)[0]` is `'data'`, so a replay ran
-    // `rm -rf <cwd>/data` — taking `data/raw-inputs/` with it, which nothing had a copy of,
-    // while reporting that the files come back when the replay ends.
-    expect(resetRoots(dir, artifacts(['data/cache']))).toEqual(['data/cache']);
-    expect(resetRoots(dir, artifacts(['a/b/c']))).toEqual(['a/b/c']);
-  });
-
-  it('strips a trailing glob, which is the only part of a pattern it can act on', () => {
-    expect(resetRoots(dir, artifacts(['cache/**']))).toEqual(['cache']);
-    expect(resetRoots(dir, artifacts(['data/cache/*']))).toEqual(['data/cache']);
-    expect(resetRoots(dir, artifacts(['cache/']))).toEqual(['cache']);
-  });
-
-  it('keeps the ordinary declaration ordinary', () => {
-    expect(resetRoots(dir, artifacts(['cache', 'vector_store']))).toEqual([
-      'cache',
-      'vector_store',
-    ]);
-    expect(resetRoots(dir, undefined)).toEqual([]);
-    expect(resetRoots(dir, artifacts([]))).toEqual([]);
-  });
-
-  it('refuses a declaration that names no path, or a glob it cannot resolve to one', () => {
-    expect(resetRoots(dir, artifacts(['', '.', '..', '*', 'test_results_*.json']))).toEqual([]);
-  });
-
-  it('refuses to leave the workspace, whatever an adapter declares', () => {
-    expect(resetRoots(dir, artifacts(['../elsewhere', '../../etc', 'ok/../../out']))).toEqual([]);
-  });
-
-  it('reports each path once, however many patterns name it', () => {
-    expect(resetRoots(dir, artifacts(['cache', 'cache/**', 'cache/']))).toEqual(['cache']);
-  });
-
-  it('answers with the path the deletion acts on, not the spelling it was declared in', () => {
-    // `resetArtifacts` removes `resolve(dir, root)` and the guard before it compares these
-    // strings, so a declaration that resolves to `cache` has to leave here as `cache`. It did
-    // not: `./cache` and `data//cache` came back unchanged, the guard's prefix test then missed
-    // a nested repository under them, and the `rm` took it anyway.
-    expect(resetRoots(dir, artifacts(['./cache']))).toEqual(['cache']);
-    expect(resetRoots(dir, artifacts(['data//cache']))).toEqual(['data/cache']);
-    expect(resetRoots(dir, artifacts(['data/./cache']))).toEqual(['data/cache']);
-    expect(resetRoots(dir, artifacts(['tools/../cache']))).toEqual(['cache']);
-    // And one that resolves to the workspace itself names no path to delete.
-    expect(resetRoots(dir, artifacts(['cache/..']))).toEqual([]);
-  });
-
-  it('answers in the spelling both `resolve` and a git pathspec accept', () => {
-    expect(resetRoots(dir, artifacts(['data\\cache']))).toEqual(['data/cache']);
-  });
-});