agenticreplay 0.1.0 → 0.1.2

package/packages/cli/test/record-detection.test.ts

@@ -1,156 +0,0 @@
-import { execFile } from 'node:child_process';
-import { chmod, mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { delimiter, dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { promisify } from 'node:util';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-
-const run = promisify(execFile);
-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-detect-'));
-});
-afterEach(async () => {
-  await rm(dir, { recursive: true, force: true, maxRetries: 5, retryDelay: 200 });
-});
-
-/**
- * Detection answers "which agent is in use here". It must not answer it when the command line
- * already did.
- *
- * `detect` is machine-wide by construction — every adapter's is `detectAgent(binaries, homePaths)`,
- * which asks whether a binary is on PATH or a directory exists under `$HOME`. Neither is a fact
- * about `cwd`. That is the right question for "is this agent even installed", and the wrong one for
- * "what should I launch", and `agenticreplay record -- python my_graph.py` was answering the second with the
- * first:
- *
- *     $ agenticreplay record -- python my_graph.py     # in a LangGraph project
- *     info adapter.detected id=claude-code
- *     API Error: 400 unknown provider for model claude-opus-5
- *
- * Claude Code ran. `python my_graph.py` was handed to it as arguments and never launched. The run
- * was recorded, so the failure looks like a bad API key rather than like agenticreplay starting the wrong
- * program.
- *
- * A command after `--` is not a hint about the environment. It is the answer.
- */
-describe('agenticreplay record, when the command line already says what to run', () => {
-  const timeout = 60_000;
-  const bare = { ...process.env, NO_COLOR: '1', OPENAI_API_KEY: 'stub-key' };
-
-  /** Run the built CLI, returning what it printed whether or not it succeeded. */
-  async function agenticreplay(
-    argv: string[],
-    env: NodeJS.ProcessEnv = {},
-  ): Promise<{ code: number; said: string }> {
-    try {
-      const { stdout, stderr } = await run(process.execPath, [cli, ...argv], {
-        cwd: dir,
-        env: { ...bare, ...env },
-        timeout: timeout - 10_000,
-      });
-      return { code: 0, said: `${stdout}${stderr}` };
-    } catch (e) {
-      const err = e as { code?: number; stdout?: string; stderr?: string };
-      return { code: err.code ?? -1, said: `${err.stdout ?? ''}${err.stderr ?? ''}` };
-    }
-  }
-
-  it(
-    'does not detect an agent when a command was given after --',
-    async () => {
-      await writeFile(join(dir, 'agent.mjs'), "process.stdout.write('MINE RAN');\n");
-      const { said } = await agenticreplay(['record', '--', 'node', 'agent.mjs']);
-
-      expect(said, 'it picked an agent instead of running the command').not.toMatch(
-        /adapter\.detected/,
-      );
-      expect(said, 'the command on the line was not the one that ran').toContain('MINE RAN');
-    },
-    timeout,
-  );
-
-  /**
-   * And the adapter it falls back to has to redirect something.
-   *
-   * `exec` was the first choice here and it is the wrong one: both it and `generic-openai` decline
-   * to guess what the command is, but only the second redirects anything. `exec` points the agent
-   * nowhere and warns that interception is required — correct for a Go binary with its origin
-   * compiled in, and useless as a default, since most things run this way read a base-URL variable.
-   * Sending everyone to `--tls-intercept` to record a Python script would be a worse answer than the
-   * bug it replaced.
-   */
-  it(
-    'falls back to an adapter that actually redirects',
-    async () => {
-      await writeFile(
-        join(dir, 'shows-env.mjs'),
-        `process.stdout.write('BASE=' + (process.env.OPENAI_BASE_URL ?? 'unset'));${'\n'}`,
-      );
-      const { said } = await agenticreplay(['record', '--', 'node', 'shows-env.mjs']);
-      expect(said).toMatch(/BASE=http:\/\/127\.0\.0\.1:\d+/);
-      expect(said, 'it fell back to something that redirects nothing').not.toMatch(
-        /tls\.intercept_required/,
-      );
-    },
-    timeout,
-  );
-
-  /**
-   * And it still detects when there is nothing else to go on — the case detection was written for,
-   * and the one this must not break.
-   *
-   * Detection reads `PATH` and `$HOME`, so the test supplies both: a `claude` shim at the front of
-   * PATH, and a home with no agent config under it. That makes the answer the same on every
-   * machine, and — the reason it is written this way — means the run launches the shim rather than
-   * whatever real agent the machine running the suite happens to have installed.
-   */
-  it(
-    'still detects when no command and no agent name were given',
-    async () => {
-      const bin = join(dir, 'bin');
-      await mkdir(bin);
-      const shim = join(bin, process.platform === 'win32' ? 'claude.cmd' : 'claude');
-      const script =
-        process.platform === 'win32'
-          ? ['@echo off', 'echo SHIM RAN'].join('\r\n')
-          : ['#!/bin/sh', 'echo SHIM RAN'].join('\n');
-      await writeFile(shim, `${script}\n`);
-      await chmod(shim, 0o755);
-
-      // Prepended, not replaced. `hasBinary` shells out to `which` on POSIX, and a PATH holding
-      // only the shim dir cannot find `which` itself — detection then answers false for every
-      // adapter and the test fails on Linux for a reason that has nothing to do with the code
-      // under it. Prepending is enough to make the answer deterministic anyway: `claude-code` is
-      // the first adapter the registry tries, and PATH is walked in order, so the shim wins over
-      // any real agent the machine running the suite happens to have installed.
-      const path = `${bin}${delimiter}${process.env.PATH ?? ''}`;
-      const { said } = await agenticreplay(['record'], {
-        PATH: path,
-        Path: path,
-        HOME: dir,
-        USERPROFILE: dir,
-      });
-
-      expect(said, 'detection no longer runs when there is nothing else to go on').toMatch(
-        /adapter\.detected id=claude-code/,
-      );
-      expect(said, 'it detected an agent and then did not launch it').toContain('SHIM RAN');
-    },
-    timeout,
-  );
-
-  it(
-    'still uses the agent when one is named, even with a command after --',
-    async () => {
-      const { said } = await agenticreplay(['record', 'generic-openai', '--', 'node', '-e', '0']);
-      expect(said, 'a named agent should not be re-detected').not.toMatch(/adapter\.detected/);
-      expect(said).toMatch(/adapter=generic-openai/);
-    },
-    timeout,
-  );
-});

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

@@ -1,203 +0,0 @@
-import { execFile } from 'node:child_process';
-import { mkdtemp, readFile, readdir, rm, stat } 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';
-import { TRANSPORT_OWNER } from '../src/agent-spans.js';
-
-const run = promisify(execFile);
-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-teardown-'));
-});
-afterEach(async () => {
-  await rm(dir, { recursive: true, force: true });
-});
-
-/**
- * A run that dies before the agent starts still has to let go of the terminal.
- *
- * `agenticreplay record` opens a listening proxy before it does anything else, and a listening server keeps
- * Node's event loop alive on its own. So every throw between opening the proxy and the child's exit
- * printed its error and then hung — the process never returned, and the only way out was Ctrl-C.
- *
- * The teardown existed, but it started at the spawn. It covered the failure it was written for, an
- * agent that is not on PATH, and missed the one that comes first: an adapter validates the
- * invocation in `prepare`, before anything is spawned. `agenticreplay record node agent.mjs`, with the `--`
- * left out, printed exactly the right message about the missing `--` and then hung forever, which
- * is the first thing a new user does with the first command they run.
- *
- * Asserted by running the built CLI, because the thing under test is whether the process exits.
- * A test that called the command in-process would return, pass, and prove nothing.
- */
-describe('agenticreplay record, when the run dies before the agent starts', () => {
-  const timeout = 60_000;
-  const bare = { ...process.env, NO_COLOR: '1' };
-
-  /** The command exits, and the reason survives to say why. */
-  const failsWith = async (argv: string[], expected: RegExp): Promise<void> => {
-    const attempt = run(process.execPath, [cli, ...argv], {
-      cwd: dir,
-      env: bare,
-      timeout: timeout - 5_000,
-    });
-    // A hang shows up here as `killed`, which is what this test exists to catch — so it is
-    // 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 command hung instead of exiting').not.toBe(true);
-    expect(err.code, 'the command succeeded when it should have failed').toBe(1);
-    expect(`${err.stdout ?? ''}${err.stderr ?? ''}`).toMatch(expected);
-  };
-
-  it(
-    'exits when the adapter rejects the invocation',
-    async () => {
-      // `--` with nothing after it: the adapter has no command to run and says so in `prepare`,
-      // which is where the proxy is already listening and the hang used to happen.
-      //
-      // `agenticreplay record node agent.mjs` — the `--` left out entirely — was the original way in, and
-      // `assertNoStrayPositionals` now refuses that before the proxy is ever opened. Better for the
-      // user and useless here: the point is to throw *inside* the guarded window, so the case has
-      // to be one that reaches `prepare` rather than one that is turned away before it.
-      await failsWith(['record', 'node', '--'], /needs the command to run/);
-    },
-    timeout,
-  );
-
-  it(
-    'exits when the agent is not on PATH',
-    async () => {
-      await failsWith(
-        ['record', 'node', '--', 'agenticreplay-no-such-binary'],
-        /could not launch "agenticreplay-no-such-binary"/,
-      );
-    },
-    timeout,
-  );
-
-  it(
-    'exits when the adapter name is not one it knows',
-    async () => {
-      await failsWith(['record', 'no-such-adapter', '--', 'node', '-e', '0'], /unknown adapter/);
-    },
-    timeout,
-  );
-
-  /**
-   * A run that died is sealed rather than discarded, so it can be read — and reading it has to say
-   * that it died.
-   *
-   * The trace is sealed with its exit code deliberately absent, because a run whose agent never
-   * started has no exit code rather than a zero one. `agenticreplay show` rendered that absence as
-   * `exit 0`, so the one run you would open precisely because something went wrong presented
-   * itself as a clean success. `--json` had it right as `null` the whole time.
-   */
-  it('seals a died run so it can be read, and does not call it a success', async () => {
-    await run(process.execPath, [cli, 'record', 'node', '--', 'agenticreplay-no-such-binary'], {
-      cwd: dir,
-      env: bare,
-      timeout: 60_000,
-    }).catch(() => undefined);
-
-    const runs = join(dir, '.agenticreplay', 'runs');
-    const [id] = await readdir(runs);
-    expect(id, 'the failed run left no trace at all').toBeDefined();
-
-    // Sealed: the fields `verifyIntegrity` needs to call it finished rather than tampered with.
-    const manifest = JSON.parse(await readFile(join(runs, id!, '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 unknown exit code must not be recorded as one').toBeUndefined();
-
-    const { stdout } = await run(process.execPath, [cli, 'show', id!], { cwd: dir, env: bare });
-    expect(stdout).not.toMatch(/events {2}exit 0/);
-    expect(stdout).toContain('never finished');
-  }, 60_000);
-
-  /**
-   * The transports go with it, like the CA.
-   *
-   * Neither `agent-spans.jsonl` nor `shell-frames.jsonl` goes through the write path's redactor —
-   * both are written by a process agenticreplay does not own, the agent's interpreter and the shell shim —
-   * and `agenticreplay scrub` does not rewrite either. So neither may outlive the run. The success path
-   * removes them after the drain, but that is inside the region this teardown is the short-circuit
-   * for, so every throw after they are minted used to leave one behind. This run reaches both
-   * installs — they happen before the spawn, and it is the spawn that fails.
-   *
-   * **Looked for where they actually are.** The obvious assertion, that nothing named
-   * `agent-spans*` is in the run directory, is vacuous: the transports are minted under the
-   * system temp directory rather than in the run, so that holds whether or not anything cleans
-   * up. Confirmed by deleting the teardown and watching that version of this test pass anyway.
-   *
-   * What is left behind is identified by its owner, not by its name: each transport records the
-   * pid that minted it, and that pid is this one subprocess. So a leftover is unambiguous, a
-   * transport belonging to a test running in parallel is never mistaken for one, and renaming the
-   * directory prefix cannot quietly turn this back into a test that looks at nothing.
-   */
-  it('takes the transports with it, like the CA', async () => {
-    const temp = tmpdir();
-    const started = Date.now();
-    const attempt = run(
-      process.execPath,
-      [cli, 'record', 'node', '--', 'agenticreplay-no-such-binary'],
-      {
-        cwd: dir,
-        env: bare,
-        timeout: 60_000,
-      },
-    );
-    const pid = attempt.child.pid;
-    expect(pid, 'could not identify the recording process').toBeGreaterThan(0);
-    await attempt.catch(() => undefined);
-
-    const left: string[] = [];
-    for (const entry of await readdir(temp, { withFileTypes: true })) {
-      if (!entry.isDirectory()) continue;
-      const path = join(temp, entry.name);
-      // A pid is only unique among live processes, and this one has exited — so also require the
-      // directory to be newer than this test, or an orphan from an older run that happened to be
-      // given the same pid would be read as a leak of this one.
-      const age = await stat(path).then(
-        (info) => info.mtimeMs,
-        () => 0,
-      );
-      if (age < started - 5_000) continue;
-      const owner = await readFile(join(path, TRANSPORT_OWNER), 'utf8').catch(() => '');
-      if (owner.trim() === String(pid)) left.push(entry.name);
-    }
-    try {
-      expect(left, 'a failed run left its transport behind').toEqual([]);
-    } finally {
-      // Including when the assertion above just failed: a leak this test caught is still a
-      // directory of un-redacted material, and leaving it would also hand the next run a pid to
-      // collide with.
-      for (const name of left) await rm(join(temp, name), { recursive: true, force: true });
-    }
-
-    // And nothing of theirs reached the trace either.
-    const runs = join(dir, '.agenticreplay', 'runs');
-    const [id] = await readdir(runs);
-    expect(id, 'the failed run left no trace at all').toBeDefined();
-    const entries = await readdir(join(runs, id!), { recursive: true, withFileTypes: true });
-    expect(
-      entries
-        .filter((e) => e.name.startsWith('agent-spans') || e.name.startsWith('shell-frames'))
-        .map((e) => e.name),
-      'an un-redacted transport was left in the run directory',
-    ).toEqual([]);
-  }, 60_000);
-});

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

@@ -1,242 +0,0 @@
-import { execFile } from 'node:child_process';
-import { existsSync, lstatSync, symlinkSync, unlinkSync } from 'node:fs';
-import { mkdir, mkdtemp, readFile, readdir, 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 { Output } from '../src/out.js';
-import { FsCapture } from '@agenticreplay/fs-capture';
-import { assertOverwritable, removeIntroduced } from '../src/commands/replay.js';
-
-const run = promisify(execFile);
-
-/** The id git gives these bytes — asked of git, so the test does not share the code's arithmetic. */
-async function gitBlobId(dir: string, content: string): Promise<string> {
-  const probe = join(dir, '.probe');
-  await writeFile(probe, content);
-  const { stdout } = await run('git', ['hash-object', '--no-filters', probe]);
-  await rm(probe);
-  return stdout.trim();
-}
-
-/**
- * What a default replay takes away after putting the operator's tree back: files the recording
- * wrote where the operator had none. The list is made before the replayed agent runs and acted on
- * after it — minutes later, with a real harness, in a tree nothing else was told to keep out of —
- * and it names exactly the paths no copy holds. Taking whatever stood there then deleted the
- * operator's own new file, or a watcher's output, with nothing anywhere to bring it back.
- */
-describe('taking away what a replay introduced', () => {
-  let dir: string;
-  let lines: string[];
-  let out: Output;
-
-  beforeEach(async () => {
-    dir = await mkdtemp(join(tmpdir(), 'agenticreplay-putback-'));
-    lines = [];
-    out = new Output({ write: (s) => void lines.push(s), isTTY: false });
-  });
-
-  afterEach(async () => {
-    await rm(dir, { recursive: true, force: true });
-  });
-
-  it('takes a file only while it still holds a version the recording wrote', async () => {
-    const recorded = await gitBlobId(dir, 'RECORDED\n');
-    await mkdir(join(dir, 'made'));
-    await writeFile(join(dir, 'made', 'ours.txt'), 'RECORDED\n');
-    await writeFile(join(dir, 'theirs.txt'), 'WRITTEN BY SOMEONE ELSE DURING THE REPLAY\n');
-    await mkdir(join(dir, 'busy'));
-    await writeFile(join(dir, 'busy', 'unlisted.txt'), 'not in the recording\n');
-
-    await removeIntroduced(
-      dir,
-      {
-        files: [
-          { path: 'made/ours.txt', oids: new Set([recorded]) },
-          { path: 'theirs.txt', oids: new Set([recorded]) },
-          { path: 'never-written.txt', oids: new Set([recorded]) },
-        ],
-        dirs: ['made', 'busy'],
-        walked: new Map(),
-      },
-      out,
-    );
-
-    expect(existsSync(join(dir, 'made')), 'its own file, and the directory made for it').toBe(
-      false,
-    );
-    expect(
-      await readFile(join(dir, 'theirs.txt'), 'utf8'),
-      'a file the recording did not write, at a path it did',
-    ).toBe('WRITTEN BY SOMEONE ELSE DURING THE REPLAY\n');
-    expect(await readdir(join(dir, 'busy'))).toEqual(['unlisted.txt']);
-
-    const warned = lines.find((l) => l.includes('replay.left_in_place')) ?? '';
-    expect(warned, `nothing said what was left in:\n${lines.join('')}`).toContain('theirs.txt');
-    expect(warned).not.toContain('ours.txt');
-    expect((await readdir(dir)).filter((name) => name.includes('.agenticreplay-'))).toEqual([]);
-  });
-
-  /**
-   * Hashing a path and then removing the path looks it up twice. A writer that replaced the file in
-   * between had its bytes removed unjudged — the check passed on the old file, and `rm` took the new
-   * one. The file is now set aside before it is judged, so what is judged is what goes.
-   */
-  it('judges the very file it removes, not whatever stands at the path by then', async () => {
-    const recorded = await gitBlobId(dir, 'RECORDED\n');
-    await writeFile(join(dir, 'raced.txt'), 'RECORDED\n');
-
-    await removeIntroduced(
-      dir,
-      { files: [{ path: 'raced.txt', oids: new Set([recorded]) }], dirs: [], walked: new Map() },
-      out,
-      async (path) => {
-        await writeFile(path, 'WRITTEN WHILE AGENTICREPLAY WAS LOOKING\n');
-      },
-    );
-
-    expect(await readFile(join(dir, 'raced.txt'), 'utf8')).toBe(
-      'WRITTEN WHILE AGENTICREPLAY WAS LOOKING\n',
-    );
-    expect((await readdir(dir)).filter((name) => name.includes('.agenticreplay-'))).toEqual([]);
-  });
-
-  /**
-   * What does not match goes back — and never over something that has taken the path meanwhile.
-   * Every way back creates only if absent: a hard link for a file, a fresh link for a link. Here a
-   * newcomer arrives while the original is being judged: it keeps the path, and the original stays
-   * beside it under the name it was set aside as, named.
-   */
-  it('puts back what does not match without replacing what has taken the path since', async () => {
-    const recorded = await gitBlobId(dir, 'RECORDED\n');
-    await writeFile(join(dir, 'notes.txt'), 'THE OPERATOR WROTE THIS\n');
-
-    await removeIntroduced(
-      dir,
-      { files: [{ path: 'notes.txt', oids: new Set([recorded]) }], dirs: [], walked: new Map() },
-      out,
-      async (path) => {
-        await writeFile(path, 'AND THIS ARRIVED WHILE AGENTICREPLAY WAS LOOKING\n');
-      },
-    );
-
-    expect(await readFile(join(dir, 'notes.txt'), 'utf8')).toBe(
-      'AND THIS ARRIVED WHILE AGENTICREPLAY WAS LOOKING\n',
-    );
-    const aside = (await readdir(dir)).filter((name) =>
-      name.startsWith('notes.txt.agenticreplay-'),
-    );
-    expect(aside, 'the original must still exist, beside it').toHaveLength(1);
-    expect(await readFile(join(dir, aside[0]!), 'utf8')).toBe('THE OPERATOR WROTE THIS\n');
-    const warned = lines.find((l) => l.includes('replay.left_in_place')) ?? '';
-    expect(warned).toContain(`set_aside=${aside[0]}`);
-  });
-
-  it('puts a link back as a link', async () => {
-    const recorded = await gitBlobId(dir, 'RECORDED\n');
-    const pointee = join(dir, 'pointee');
-    await mkdir(pointee);
-    symlinkSync(pointee, join(dir, 'link'), process.platform === 'win32' ? 'junction' : 'dir');
-    try {
-      await removeIntroduced(
-        dir,
-        { files: [{ path: 'link', oids: new Set([recorded]) }], dirs: [], walked: new Map() },
-        out,
-      );
-      expect(lstatSync(join(dir, 'link')).isSymbolicLink(), 'the link is back, as a link').toBe(
-        true,
-      );
-      expect((await readdir(dir)).filter((name) => name.includes('.agenticreplay-'))).toEqual([]);
-    } finally {
-      unlinkSync(join(dir, 'link'));
-    }
-  });
-
-  /**
-   * The removal may pass through real directories, and through links git walked into when it took
-   * the copy. It had been handed every directory git walked into instead — so a real directory
-   * swapped for a link after the copy was taken still counted, and the removal followed the link
-   * out of the workspace to a file whose bytes happened to be the recording's.
-   */
-  it('does not follow a link that was a real directory when the copy was taken', async () => {
-    const ws = join(dir, 'ws');
-    const outside = join(dir, 'outside');
-    await mkdir(join(ws, 'data'), { recursive: true });
-    await mkdir(outside);
-    await writeFile(join(ws, 'data', 'a.csv'), 'A\n');
-
-    // The recording had data/x.csv; the operator's tree does not.
-    await writeFile(join(ws, 'data', 'x.csv'), 'RECORDED\n');
-    const recording = await FsCapture.start({ runDir: join(dir, 'recording'), cwd: ws });
-    const recordedTree = (await recording.snapshotTurn(0)).tree;
-    await rm(join(ws, 'data', 'x.csv'));
-    const copy = await FsCapture.start({ runDir: join(dir, 'copy'), cwd: ws });
-    const held = (await copy.snapshotTurn(0)).tree;
-
-    const introduced = await assertOverwritable(recording, [recordedTree], copy, held, ws);
-    expect(introduced.files.map((f) => f.path)).toEqual(['data/x.csv']);
-
-    // Then, during the replay, data becomes a link to a directory outside the workspace, holding a
-    // file with the recording's bytes at the same name.
-    await writeFile(join(outside, 'x.csv'), 'RECORDED\n');
-    await rm(join(ws, 'data'), { recursive: true, force: true });
-    symlinkSync(outside, join(ws, 'data'), process.platform === 'win32' ? 'junction' : 'dir');
-    try {
-      await removeIntroduced(ws, introduced, out);
-      expect(
-        await readFile(join(outside, 'x.csv'), 'utf8'),
-        'the removal followed a link out of the workspace',
-      ).toBe('RECORDED\n');
-    } finally {
-      unlinkSync(join(ws, 'data'));
-    }
-  });
-
-  /**
-   * The other direction of the same escape. A junction git walked into is a directory to git, and
-   * the removal may pass through it — but only while it points where it pointed when the copy was
-   * taken. Re-pointed during the replay, it is another link, and following it reached a directory
-   * agenticreplay was never given. Only Windows walks into a link (git records a POSIX symlink as itself),
-   * so only Windows can have one to re-point.
-   */
-  it.runIf(process.platform === 'win32')(
-    'does not follow a link re-pointed after the copy was taken',
-    async () => {
-      const ws = join(dir, 'ws');
-      const first = join(dir, 'first');
-      const second = join(dir, 'second');
-      await mkdir(ws);
-      await mkdir(first);
-      await mkdir(second);
-      await writeFile(join(first, 'a.csv'), 'A\n');
-      symlinkSync(first, join(ws, 'data'), 'junction');
-      try {
-        await writeFile(join(first, 'x.csv'), 'RECORDED\n');
-        const recording = await FsCapture.start({ runDir: join(dir, 'recording'), cwd: ws });
-        const recordedTree = (await recording.snapshotTurn(0)).tree;
-        await rm(join(first, 'x.csv'));
-        const copy = await FsCapture.start({ runDir: join(dir, 'copy'), cwd: ws });
-        const held = (await copy.snapshotTurn(0)).tree;
-
-        const introduced = await assertOverwritable(recording, [recordedTree], copy, held, ws);
-        expect(introduced.files.map((f) => f.path)).toEqual(['data/x.csv']);
-
-        // During the replay the junction is re-pointed at another directory, which holds a file
-        // with the recording's bytes at the same name.
-        await writeFile(join(second, 'x.csv'), 'RECORDED\n');
-        unlinkSync(join(ws, 'data'));
-        symlinkSync(second, join(ws, 'data'), 'junction');
-
-        await removeIntroduced(ws, introduced, out);
-        expect(
-          await readFile(join(second, 'x.csv'), 'utf8'),
-          'the removal followed a re-pointed link',
-        ).toBe('RECORDED\n');
-      } finally {
-        unlinkSync(join(ws, 'data'));
-      }
-    },
-  );
-});