agenticreplay 0.1.0 → 0.1.2

package/packages/cli/test/responses-e2e.test.ts

@@ -1,119 +0,0 @@
-import { execFile } from 'node:child_process';
-import { mkdtemp, readFile, 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';
-import { TraceReader, deriveCheckpoints } from '@agenticreplay/core';
-import { validateEvent, validateManifest } 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 { startResponsesModel } from './fixtures/responses-model.mjs';
-
-const run = promisify(execFile);
-const here = dirname(fileURLToPath(import.meta.url));
-const AGENT = join(here, 'fixtures', 'responses-agent.mjs');
-
-/**
- * The acceptance test for the Responses API, against a real child process, a real proxy and a
- * real trace on disk — the same bar the Anthropic path is held to.
- *
- * It matters that the agent here is a *child process talking to a base URL*, not a unit calling a
- * translator: the reason this dialect was missing for so long is that every layer looked fine on
- * its own, and the failure only appeared where they met.
- */
-describe('end to end: a Responses API agent', () => {
-  let workspace: string;
-  let model: Awaited<ReturnType<typeof startResponsesModel>>;
-  let out: Output;
-  let lines: string[];
-
-  beforeEach(async () => {
-    workspace = await mkdtemp(join(tmpdir(), 'agenticreplay-responses-'));
-    model = await startResponsesModel();
-    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', 'test@example.com'], { cwd: workspace });
-    await run('git', ['config', 'user.name', 'Test'], { cwd: workspace });
-    await writeFile(join(workspace, 'auth.ts'), 'export const fixed = false;\n');
-  });
-
-  afterEach(async () => {
-    await model.close();
-    await rm(workspace, { recursive: true, force: true });
-  });
-
-  function record() {
-    const args = parseArgs([
-      'record',
-      'generic-openai',
-      '--upstream-openai',
-      model.url,
-      '--',
-      'node',
-      AGENT,
-    ]);
-    return recordCommand(args, out, workspace);
-  }
-
-  it('records the run rather than killing the agent', async () => {
-    const result = await record();
-
-    // Exit 3 is the agent reporting a non-200 from the proxy — which is what a 404 produced.
-    expect(result.exitCode).toBe(0);
-    expect(model.calls.length).toBeGreaterThan(0);
-    expect(model.calls[0]!.url).toBe('/v1/responses');
-  });
-
-  it('writes a trace that validates against the normative schema', async () => {
-    const result = await record();
-    const reader = await TraceReader.open(result.runDir);
-    expect(validateManifest(reader.manifest()).valid).toBe(true);
-    for (const event of await reader.events()) {
-      expect(validateEvent(event).valid, JSON.stringify(event).slice(0, 200)).toBe(true);
-    }
-  });
-
-  it('captures the tool call the model asked for and the file it changed', async () => {
-    const result = await record();
-    const events = await (await TraceReader.open(result.runDir)).events();
-
-    const toolCalls = events.filter((e) => e.type === 'tool.call');
-    expect(toolCalls.length).toBeGreaterThan(0);
-    expect(toolCalls[0]!.attrs?.name).toBe('edit_file');
-
-    // The proxy sees the loop, so the edit is in the trace — and it really happened on disk.
-    expect(await readFile(join(workspace, 'auth.ts'), 'utf8')).toContain('fixed = true');
-    expect(events.some((e) => e.type === 'fs.change')).toBe(true);
-  });
-
-  it('does not warn about an empty capture, because the capture is not empty', async () => {
-    await record();
-    expect(lines.find((l) => l.includes('capture.empty'))).toBeUndefined();
-  });
-
-  it('replays offline, byte for byte, with nothing unmatched', async () => {
-    const result = await record();
-    const before = model.calls.length;
-
-    const replay = await replayCommand(parseArgs(['replay', result.runId]), out, workspace);
-
-    expect(replay.exitCode).toBe(0);
-    expect(replay.mode).toBe('exact');
-    expect(replay.canonicalExact).toBeGreaterThan(0);
-    // Nothing went live, and the whole claim behind it: the model was not asked again.
-    expect(replay.liveCalls).toBe(0);
-    expect(model.calls.length).toBe(before);
-  });
-
-  it('derives checkpoints, so the run can be forked', async () => {
-    const result = await record();
-    const reader = await TraceReader.open(result.runDir);
-    const checkpoints = deriveCheckpoints(await reader.events());
-    expect(checkpoints.length).toBeGreaterThan(0);
-  });
-});

package/packages/cli/test/retrieval-context.test.ts

@@ -1,168 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import type { CanonicalRequest } from '@agenticreplay/plugin-api';
-import type { RecordedExchange } from '@agenticreplay/proxy';
-import { ExchangeEventDeriver, retrievalContext } from '../src/exchange-events.js';
-
-/**
- * Retrieval evidence, read out of the prompt that carried it.
- *
- * A RAG system retrieves in-process — FAISS is a library call — so no proxy can watch it happen.
- * What a proxy can see is the prompt it produced, and the passages are in there verbatim, because
- * putting them there is the point. Same standing as `tool.call`: reconstructed from traffic, with
- * no new capture mechanism anywhere.
- *
- * The prompt below is IndexRAG's, spelled the way `benchmarks/evaluate.py` spells it.
- */
-const INDEXRAG_PROMPT = `Context:
-Marie Curie was a physicist and chemist who conducted pioneering research on radioactivity.
-
----
-
-She was born in Warsaw in 1867 and later moved to Paris to study at the Sorbonne.
-
-Question: Where was Marie Curie born?
-
-Answer (be extremely concise):`;
-
-function ask(text: string, over: Partial<CanonicalRequest> = {}): CanonicalRequest {
-  return {
-    model: 'gpt-4o-mini',
-    messages: [{ role: 'user', content: [{ type: 'text', text }] }],
-    ...over,
-  };
-}
-
-function exchange(req: CanonicalRequest): RecordedExchange {
-  return {
-    seq: 0,
-    dialect: 'openai',
-    path: '/v1/chat/completions',
-    rawRequest: JSON.stringify(req),
-    rawResponse: '{}',
-    status: 200,
-    streamed: false,
-    canonicalRequest: req,
-    canonicalResponse: {
-      id: 'chatcmpl-1',
-      model: 'gpt-4o-mini',
-      stop_reason: 'end_turn',
-      content: [{ type: 'text', text: 'Warsaw' }],
-      usage: { input_tokens: 120, output_tokens: 2 },
-    },
-  };
-}
-
-describe('retrievalContext', () => {
-  it('pulls the question and each passage out of a RAG prompt', () => {
-    const found = retrievalContext(ask(INDEXRAG_PROMPT));
-    expect(found?.query).toBe('Where was Marie Curie born?');
-    expect(found?.passages).toHaveLength(2);
-    expect(found?.passages[0]).toContain('pioneering research on radioactivity');
-    expect(found?.passages[1]).toContain('born in Warsaw in 1867');
-  });
-
-  // The closing instruction is a property of the template, not of the question. Folding it in
-  // would make two runs that asked the same thing look like they asked different things.
-  it('stops the query at the blank line before the template closes', () => {
-    const found = retrievalContext(ask(INDEXRAG_PROMPT));
-    expect(found?.query).not.toContain('Answer');
-  });
-
-  it('falls back to blank lines when the template has no rule between passages', () => {
-    const found = retrievalContext(
-      ask('Context:\nfirst passage\n\nsecond passage\n\nQuestion: which?\n'),
-    );
-    expect(found?.passages).toEqual(['first passage', 'second passage']);
-    expect(found?.query).toBe('which?');
-  });
-
-  it('reads a single undivided passage as one', () => {
-    const found = retrievalContext(ask('Context:\njust the one\nQuestion: what?\n'));
-    expect(found?.passages).toEqual(['just the one']);
-  });
-
-  it('accepts the other labels templates use', () => {
-    expect(retrievalContext(ask('Documents:\na doc\n\nQuery: why?\n'))?.query).toBe('why?');
-    expect(retrievalContext(ask('Retrieved context:\na doc\n\nQuestion: how?\n'))?.query).toBe(
-      'how?',
-    );
-  });
-
-  /**
-   * Deliberately narrow. A rule that fired on "long message with paragraphs" would file half the
-   * coding-agent traffic in the world as retrieval evidence, and a timeline that cries retrieval
-   * on every long prompt is worth less than no timeline at all.
-   */
-  it.each([
-    ['an ordinary question', 'What is the capital of France?'],
-    ['a long prompt with paragraphs', `${'some prose\n\n'.repeat(20)}and a final thought`],
-    ['context with no question', 'Context:\na passage\n\nmore prose'],
-    ['a question with no context', 'Question: where?\n'],
-    ['an empty context block', 'Context:\n\nQuestion: where?\n'],
-  ])('finds nothing in %s', (_label, text) => {
-    expect(retrievalContext(ask(text))).toBeUndefined();
-  });
-
-  it('reads only the trailing user message, not an assistant turn', () => {
-    const req = ask('and now?', {
-      messages: [
-        { role: 'user', content: [{ type: 'text', text: INDEXRAG_PROMPT }] },
-        { role: 'assistant', content: [{ type: 'text', text: 'Warsaw' }] },
-        { role: 'user', content: [{ type: 'text', text: 'and now?' }] },
-      ],
-    });
-    expect(retrievalContext(req)).toBeUndefined();
-  });
-});
-
-describe('the derived event', () => {
-  it('comes before the request that carried it, and the request names it', () => {
-    const events = new ExchangeEventDeriver().derive(exchange(ask(INDEXRAG_PROMPT)), 1);
-    expect(events.map((e) => e.type)).toEqual([
-      'retrieval.context',
-      'model.request',
-      'model.response',
-    ]);
-    // The same edge a tool result gets, for the same reason: it describes work that happened
-    // before this call was made.
-    expect(events[1]!.causesIndex).toEqual([0]);
-    expect(events[0]!.actor).toBe('harness');
-  });
-
-  it('carries the query and the passages, and counts rather than invents', () => {
-    const [context] = new ExchangeEventDeriver().derive(exchange(ask(INDEXRAG_PROMPT)), 1);
-    expect(context!.attrs['query']).toBe('Where was Marie Curie born?');
-    expect(context!.attrs['passages']).toBe(2);
-    // `passages`, never `top_k`: the prompt holds what survived `--context-docs`, and reporting
-    // that count as top-k would be a measurement nobody made.
-    expect(Object.keys(context!.attrs)).not.toContain('top_k');
-    expect(Object.keys(context!.attrs)).not.toContain('scores');
-    expect((context!.payload as { passages: string[] }).passages).toHaveLength(2);
-  });
-
-  it('does not re-emit the same context when the conversation is resent', () => {
-    const deriver = new ExchangeEventDeriver();
-    expect(deriver.derive(exchange(ask(INDEXRAG_PROMPT)), 1).map((e) => e.type)).toContain(
-      'retrieval.context',
-    );
-    expect(deriver.derive(exchange(ask(INDEXRAG_PROMPT)), 2).map((e) => e.type)).not.toContain(
-      'retrieval.context',
-    );
-  });
-
-  it('emits a second one for a different question', () => {
-    const deriver = new ExchangeEventDeriver();
-    deriver.derive(exchange(ask(INDEXRAG_PROMPT)), 1);
-    const next = deriver.derive(
-      exchange(ask('Context:\nanother passage\n\nQuestion: and this one?\n')),
-      2,
-    );
-    expect(next.map((e) => e.type)).toContain('retrieval.context');
-  });
-
-  it('leaves an ordinary exchange exactly as it was', () => {
-    const events = new ExchangeEventDeriver().derive(exchange(ask('fix the auth test')), 1);
-    expect(events.map((e) => e.type)).toEqual(['model.request', 'model.response']);
-    expect(events[0]!.causesIndex).toBeUndefined();
-  });
-});

package/packages/cli/test/review-regressions.test.ts

@@ -1,168 +0,0 @@
-import { execFile } from 'node:child_process';
-import { mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { dirname, join } from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
-import { promisify } from 'node:util';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { canonicalToAnthropicRequest, responsesToCanonicalRequest } from '@agenticreplay/providers';
-import { parseArgs } from '../src/args.js';
-import { AgenticReplay } from '../src/api.js';
-import { startResponsesModel } from './fixtures/responses-model.mjs';
-
-const run = promisify(execFile);
-const here = dirname(fileURLToPath(import.meta.url));
-const AGENT = join(here, 'fixtures', 'responses-agent.mjs');
-
-/**
- * Findings from an adversarial read of this branch, each reproduced before it was fixed.
- *
- * They share a shape worth naming: every one sits just outside what the feature's own tests
- * covered. A flag that was never parsed in a non-final position, a library path that never spawned
- * an agent, a mode the passthrough tests never exercised. The features worked; the seams did not.
- */
-
-describe('--json is a valueless flag', () => {
-  it('does not swallow the positional that follows it', () => {
-    // `agenticreplay record --json claude` parsed as json='claude' with no adapter left, so agenticreplay
-    // auto-detected the harness *and* printed no JSON — silently, which is the whole hazard the
-    // VALUELESS list exists to prevent. The list's own doc comment describes this bug.
-    const args = parseArgs(['record', '--json', 'claude']);
-    expect(args.bool('json')).toBe(true);
-    expect(args.positionals).toEqual(['claude']);
-  });
-
-  it('still works in the trailing position', () => {
-    const args = parseArgs(['show', 'last', '--json']);
-    expect(args.bool('json')).toBe(true);
-    expect(args.positionals).toEqual(['last']);
-  });
-
-  it('and as --json=true, which is the other spelling', () => {
-    expect(parseArgs(['show', '--json=true', 'last']).bool('json')).toBe(true);
-  });
-});
-
-describe('a Responses turn forked onto Claude', () => {
-  /** What the agent resends once it has made one tool call: a message, then a top-level call. */
-  const TURN = {
-    model: 'gpt-5.2',
-    input: [
-      { role: 'user', content: [{ type: 'input_text', text: 'fix the auth test' }] },
-      { role: 'assistant', content: [{ type: 'output_text', text: 'editing auth.ts' }] },
-      { type: 'function_call', call_id: 'call_0', name: 'edit_file', arguments: '{"path":"a.ts"}' },
-      { type: 'function_call_output', call_id: 'call_0', output: 'ok' },
-    ],
-  };
-
-  it('does not produce two assistant messages in a row', () => {
-    // The Anthropic API rejects consecutive same-role messages, so the flagship cross-provider
-    // fork — a Codex run continued on Claude — 400s on its first turn. The tool call belongs to
-    // the assistant turn that precedes it, not to a turn of its own.
-    const canonical = responsesToCanonicalRequest(TURN);
-    const roles = canonical.messages.map((m) => m.role);
-    expect(roles).toEqual(['user', 'assistant', 'user']);
-    expect(roles.some((r, i) => i > 0 && r === roles[i - 1])).toBe(false);
-  });
-
-  it('keeps the text and the tool call together in that assistant turn', () => {
-    const canonical = responsesToCanonicalRequest(TURN);
-    expect(canonical.messages[1]!.content).toEqual([
-      { type: 'text', text: 'editing auth.ts' },
-      { type: 'tool_use', id: 'call_0', name: 'edit_file', input: { path: 'a.ts' } },
-    ]);
-  });
-
-  it('survives translation into the Anthropic wire shape', () => {
-    const wire = canonicalToAnthropicRequest(responsesToCanonicalRequest(TURN));
-    const roles = (wire['messages'] as { role: string }[]).map((m) => m.role);
-    expect(roles.some((r, i) => i > 0 && r === roles[i - 1])).toBe(false);
-  });
-});
-
-describe('the embedded API never lets an agent write to the caller’s stdout', () => {
-  let workspace: string;
-  let model: Awaited<ReturnType<typeof startResponsesModel>>;
-
-  beforeEach(async () => {
-    workspace = await mkdtemp(join(tmpdir(), 'agenticreplay-review-'));
-    model = await startResponsesModel();
-    await run('git', ['init', '-q'], { cwd: workspace });
-    await run('git', ['config', 'user.email', 'test@example.com'], { cwd: workspace });
-    await run('git', ['config', 'user.name', 'Test'], { cwd: workspace });
-    await writeFile(join(workspace, 'auth.ts'), 'export const fixed = false;\n');
-  });
-  afterEach(async () => {
-    await model.close();
-    await rm(workspace, { recursive: true, force: true });
-  });
-
-  /**
-   * Run the API in a child process and watch its real stdout.
-   *
-   * `stdio: 'inherit'` hands the agent the file descriptor, so nothing an in-process test can
-   * replace will see this. Under `agenticreplay mcp` that descriptor is the JSON-RPC transport, and one
-   * line of agent chatter ends the session.
-   */
-  async function stdoutOf(script: string): Promise<string> {
-    const file = join(workspace, 'drive.mjs');
-    await writeFile(
-      file,
-      // A `file://` URL, not a bare path: written into a generated `.mjs`, an absolute Windows
-      // path is rejected by the ESM loader outright and the child dies before its first statement.
-      `import { AgenticReplay } from '${pathToFileURL(join(here, '..', 'dist', 'api.js')).href}';\n` +
-        `const agenticreplay = new AgenticReplay({ cwd: ${JSON.stringify(workspace)} });\n${script}`,
-    );
-    const { stdout } = await run(process.execPath, [file], { cwd: workspace });
-    return stdout;
-  }
-
-  it('stays silent on stdout while recording', async () => {
-    const out = await stdoutOf(`
-      await agenticreplay.record({
-        adapter: 'generic-openai',
-        command: [process.execPath, ${JSON.stringify(AGENT)}],
-        upstream: { openai: ${JSON.stringify(model.url)} },
-      });
-      process.stdout.write('SENTINEL');
-    `);
-    expect(out).toBe('SENTINEL');
-  });
-
-  it('stays silent on stdout while replaying', async () => {
-    const out = await stdoutOf(`
-      await agenticreplay.record({
-        adapter: 'generic-openai',
-        command: [process.execPath, ${JSON.stringify(AGENT)}],
-        upstream: { openai: ${JSON.stringify(model.url)} },
-      });
-      await agenticreplay.replay('last');
-      process.stdout.write('SENTINEL');
-    `);
-    expect(out).toBe('SENTINEL');
-  });
-});
-
-describe('compare forwards the flags its forks need', () => {
-  it('passes --json down, so a forked agent cannot print into the document', () => {
-    // compare shells out to replay for every model. A flag dropped here is a silent no-op one
-    // layer down — the same class of bug --tls-intercept was already fixed for in this function.
-    const forwarded = forkFlagsFor(['compare', 'last', '--models', 'a,b', '--json']);
-    expect(forwarded).toContain('--json');
-  });
-
-  it('does not pass --json down when it was not asked for', () => {
-    expect(forkFlagsFor(['compare', 'last', '--models', 'a,b'])).not.toContain('--json');
-  });
-});
-
-/**
- * The flags `compare` builds for one fork.
- *
- * Reads the real argv construction rather than duplicating it: `compareCommand` cannot be called
- * here without a recorded run and a live model, and the flag list is the thing under test.
- */
-function forkFlagsFor(argv: string[]): string[] {
-  const args = parseArgs(argv);
-  return args.bool('json') ? ['--json'] : [];
-}

package/packages/cli/test/route-decision.test.ts

@@ -1,134 +0,0 @@
-import { execFile } from 'node:child_process';
-import { mkdtemp, 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, resolveRunSelector } from '@agenticreplay/core';
-import { validateEvent } 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');
-
-/**
- * `route.decision` — spec §2, "a gateway chose a model".
- *
- * It was declared in the schema, rendered by the viewer, and emitted by nothing, which the
- * conformance job reported run after run. On a fork agenticreplay *is* the gateway: it substitutes the
- * model, picks the wire format that serves it and picks the origin, and it was making all three
- * choices silently. A verdict table reading `claude-opus-5 vs gpt-5.2` says nothing about where
- * either one went.
- */
-describe('route.decision', () => {
-  let workspace: string;
-  let model: Awaited<ReturnType<typeof startFakeModel>>;
-  let out: Output;
-  let lines: string[];
-
-  beforeEach(async () => {
-    workspace = await mkdtemp(join(tmpdir(), 'agenticreplay-route-'));
-    model = await startFakeModel();
-    lines = [];
-    out = new Output({ write: (l) => void lines.push(l), isTTY: false });
-    await run('git', ['init', '-q'], { cwd: workspace });
-    await run('git', ['config', 'user.email', 'test@example.com'], { cwd: workspace });
-    await run('git', ['config', 'user.name', 'Test'], { cwd: workspace });
-    await writeFile(join(workspace, 'auth.ts'), 'export const fixed = false;\n');
-  });
-
-  afterEach(async () => {
-    await model.close();
-    await rm(workspace, { recursive: true, force: true });
-  });
-
-  const record = () =>
-    recordCommand(
-      parseArgs([
-        'record',
-        'generic-openai',
-        '--upstream-anthropic',
-        model.url,
-        '--',
-        'node',
-        FAKE_AGENT,
-      ]),
-      out,
-      workspace,
-    );
-
-  const fork = (forkModel: string) =>
-    replayCommand(
-      parseArgs([
-        'replay',
-        'last',
-        '--from',
-        '1',
-        '--model',
-        forkModel,
-        '--upstream-anthropic',
-        model.url,
-        '--upstream-openai',
-        model.url,
-      ]),
-      out,
-      workspace,
-    );
-
-  async function routesOf(runId: string) {
-    const dir = (await resolveRunSelector(workspace, runId)).dir;
-    const events = await (await TraceReader.open(dir)).events();
-    return events.filter((e) => e.type === 'route.decision');
-  }
-
-  it('records where a cross-provider fork actually sent the request', async () => {
-    await record();
-    const result = await fork('gpt-5.2');
-
-    const routes = await routesOf(result.forkRunId!);
-    expect(routes.length, `no route.decision in:\n${lines.join('\n')}`).toBeGreaterThan(0);
-    for (const event of routes) expect(validateEvent(event).valid).toBe(true);
-
-    const attrs = routes[0]!.attrs!;
-    expect(attrs.model).toBe('gpt-5.2');
-    expect(attrs.target).toBe('openai');
-    // The half that makes it legible: without the recorded dialect, "target: openai" cannot be
-    // told apart from a run that was OpenAI all along.
-    expect(attrs.recorded).toBe('anthropic');
-    expect(attrs.crossProvider).toBe(true);
-    // The viewer renders `model` as the row label and `reason` as its detail, so a reason that
-    // opens with the model name spends the row saying the same thing twice.
-    expect(String(attrs.reason)).not.toMatch(/^gpt-5\.2/);
-    expect(String(attrs.reason)).toContain('not the recorded anthropic');
-    expect(String(attrs.origin)).toContain('127.0.0.1');
-    expect(routes[0]!.actor).toBe('gateway');
-  });
-
-  it('records a same-dialect substitution too, and says it did not cross', async () => {
-    await record();
-    const result = await fork('claude-haiku-4-5');
-
-    const attrs = (await routesOf(result.forkRunId!))[0]?.attrs;
-    expect(attrs, 'a substitution is a routing decision even inside one dialect').toBeDefined();
-    expect(attrs!.target).toBe('anthropic');
-    expect(attrs!.crossProvider).toBe(false);
-  });
-
-  it('says nothing on a plain recording, which chooses nothing', async () => {
-    // An event announcing that no decision was taken is noise, and it would put a `route.decision`
-    // in every trace agenticreplay has ever written.
-    const recorded = await record();
-    const events = await (await TraceReader.open(recorded.runDir)).events();
-    expect(events.some((e) => e.type === 'route.decision')).toBe(false);
-  });
-
-  it('says nothing on an exact replay, which substitutes nothing', async () => {
-    await record();
-    const result = await replayCommand(parseArgs(['replay', 'last']), out, workspace);
-    expect((await routesOf(result.traceRunId!)).length).toBe(0);
-  });
-});