agenticreplay 0.1.0 → 0.1.2

package/packages/cli/test/share-card.test.ts

@@ -1,135 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { CREDIT_MADE_BY, CREDIT_REPO } from '@agenticreplay/viewer';
-import { renderCompareCard } from '../src/share-card.js';
-import type { CompareRow } from '../src/commands/compare.js';
-
-const rows: CompareRow[] = [
-  {
-    model: 'claude-opus-5',
-    verdict: 'pass',
-    exitCode: 0,
-    divergences: 0,
-    inputTokens: 182_000,
-    outputTokens: 4_100,
-    cost: 5.81,
-    wallMs: 312_000,
-    forkRunId: 'run_a',
-  },
-  {
-    model: 'glm-5.3-flash',
-    verdict: 'pass',
-    exitCode: 0,
-    divergences: 0,
-    inputTokens: 196_000,
-    outputTokens: 4_400,
-    cost: 0.61,
-    wallMs: 242_000,
-    forkRunId: 'run_b',
-  },
-  {
-    model: 'qwen3-coder',
-    verdict: 'fail',
-    exitCode: 1,
-    divergences: 2,
-    inputTokens: 174_000,
-    outputTokens: 3_900,
-    cost: 0.29,
-    wallMs: 191_000,
-    forkRunId: 'run_c',
-  },
-];
-
-const meta = { runId: 'run_9f2c14', forkPoint: 17, verify: 'npm test' };
-
-describe('renderCompareCard', () => {
-  it('is one self-contained SVG with no external reference', () => {
-    const svg = renderCompareCard(rows, meta);
-    expect(svg.trimStart().startsWith('<svg')).toBe(true);
-    expect(svg).toMatch(/<\/svg>\s*$/);
-    // The point of a share card is that it survives being dropped anywhere, so nothing may be
-    // fetched at render time. The xmlns declaration is a namespace identifier, never a request,
-    // so the assertion is about actual resource references rather than any URL-shaped string.
-    expect(svg).not.toContain('<image');
-    expect(svg).not.toMatch(/href\s*=/);
-    expect(svg).not.toMatch(/url\(/);
-    const urls = [...svg.matchAll(/https?:\/\/[^"' ]+/g)].map((m) => m[0]);
-    expect(urls).toEqual(['http://www.w3.org/2000/svg']);
-  });
-
-  it('names every model, its verdict and its cost', () => {
-    const svg = renderCompareCard(rows, meta);
-    for (const row of rows) {
-      expect(svg).toContain(row.model);
-    }
-    expect(svg).toContain('$5.81');
-    expect(svg).toContain('$0.61');
-  });
-
-  it('states what the verdict actually measured, so the number is not free-floating', () => {
-    const svg = renderCompareCard(rows, meta);
-    expect(svg).toContain('npm test');
-    expect(svg).toContain('17');
-  });
-
-  it('escapes trace-derived text — a model name is untrusted input', () => {
-    const hostile = [{ ...rows[0]!, model: '</text><script>alert(1)</script>' }];
-    const svg = renderCompareCard(hostile, meta);
-    expect(svg).not.toContain('<script>');
-    expect(svg).toContain('&lt;');
-  });
-
-  it('renders a dash for an unpriced model rather than implying it was free', () => {
-    const svg = renderCompareCard([{ ...rows[0]!, cost: null }], meta);
-    expect(svg).toContain('—');
-    expect(svg).not.toMatch(/\$0\.00\b/);
-  });
-
-  it('carries the attribution line that makes sharing a conversion path', () => {
-    const svg = renderCompareCard(rows, meta);
-    expect(svg).toContain(CREDIT_MADE_BY);
-    expect(svg).toContain(CREDIT_REPO);
-  });
-
-  // The card and the exported page are the two things a stranger sees first, and they used to
-  // carry the same literal in two packages. Asserting against the constant is what keeps a change
-  // to one from silently leaving the other behind.
-  it('credits the team from the same constant the exported page uses', () => {
-    expect(CREDIT_MADE_BY).toContain('AgenticReplay');
-    expect(renderCompareCard(rows, meta)).toContain('text-anchor="end"');
-  });
-
-  it('survives an empty comparison without producing broken markup', () => {
-    const svg = renderCompareCard([], meta);
-    expect(svg.trimStart().startsWith('<svg')).toBe(true);
-    expect(svg).toMatch(/<\/svg>\s*$/);
-  });
-
-  it('grows its canvas with the number of rows so nothing overflows', () => {
-    const short = renderCompareCard(rows.slice(0, 1), meta);
-    const long = renderCompareCard([...rows, ...rows], meta);
-    const height = (svg: string) => Number(/viewBox="0 0 \d+ (\d+)"/.exec(svg)?.[1]);
-    expect(height(long)).toBeGreaterThan(height(short));
-  });
-});
-
-describe('card geometry', () => {
-  it('draws the column headers above the first row, not underneath it', () => {
-    // The first version rendered the header labels behind the first row's background rect, so the
-    // card shipped with an unlabelled table. Geometry is testable; eyeballing it is not.
-    const svg = renderCompareCard(rows, meta);
-    const headerY = Number(/<text x="28" y="(\d+)"[^>]*>MODEL</.exec(svg)?.[1]);
-    const firstRowRectY = Number(/<rect x="0" y="(\d+)"/.exec(svg)?.[1]);
-    expect(headerY).toBeGreaterThan(0);
-    expect(firstRowRectY).toBeGreaterThan(headerY);
-  });
-
-  it('keeps every row inside the canvas', () => {
-    const svg = renderCompareCard([...rows, ...rows], meta);
-    const height = Number(/viewBox="0 0 \d+ (\d+)"/.exec(svg)?.[1]);
-    const rowTops = [...svg.matchAll(/<rect x="0" y="(\d+)" width="720" height="30"/g)].map((m) =>
-      Number(m[1]),
-    );
-    expect(rowTops.length).toBe(6);
-    for (const top of rowTops) expect(top + 30).toBeLessThan(height);
-  });
-});

package/packages/cli/test/shell-capture.test.ts

@@ -1,184 +0,0 @@
-import { execFile } from 'node:child_process';
-import { mkdtemp, rm, writeFile, chmod } 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 } 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 { startFakeModel } from './fixtures/fake-model.mjs';
-
-const run = promisify(execFile);
-
-/**
- * Shell capture exists for exactly the facts the protocol layer cannot recover: an exit code, a
- * real duration, and a stdout/stderr split. The model only ever sees the harness's rendering of
- * the output, one turn late.
- */
-describe.skipIf(process.platform === 'win32')('shell capture (POSIX)', () => {
-  let workspace: string;
-  let model: Awaited<ReturnType<typeof startFakeModel>>;
-  let out: Output;
-  let lines: string[];
-
-  beforeEach(async () => {
-    workspace = await mkdtemp(join(tmpdir(), 'agenticreplay-shell-e2e-'));
-    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 });
-
-    // An agent that shells out: the shim is the only thing that can see how that went.
-    const agent = join(workspace, 'shelling-agent.mjs');
-    await writeFile(
-      agent,
-      [
-        "import { execFileSync } from 'node:child_process';",
-        "try { execFileSync('sh', ['-c', 'printf hello; printf boom 1>&2; exit 4'], { stdio: 'pipe' }); }",
-        'catch { /* the non-zero exit is the point */ }',
-        // Then keep running. Frames are drained after the agent exits, so a command that ran and a
-        // command that was *stamped* at the drain are indistinguishable unless there is measurable
-        // time between them — without this gap the timestamp test passes either way.
-        'Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 400);',
-        "console.log('agent done');",
-      ].join('\n'),
-    );
-    await chmod(agent, 0o755);
-    process.env.FAKE_AGENT_TURNS = '1';
-  });
-
-  afterEach(async () => {
-    await model.close();
-    await rm(workspace, { recursive: true, force: true });
-  });
-
-  async function record(flags: string[] = []) {
-    return recordCommand(
-      parseArgs([
-        'record',
-        'generic-openai',
-        '--upstream-anthropic',
-        model.url,
-        ...flags,
-        '--',
-        'node',
-        join(workspace, 'shelling-agent.mjs'),
-      ]),
-      out,
-      workspace,
-    );
-  }
-
-  it('timestamps a shell command when it ran, not when the file was drained', async () => {
-    // Shell frames are read off disk after the agent exits. Stamping them at write time put every
-    // command at the very end of the run, so `mono_us` — which spec §2.1 calls authoritative for
-    // duration — described the drain rather than the command, and a command could never be seen to
-    // have happened between the model turns it actually sat between.
-    const result = await record();
-    const events = await (await TraceReader.open(result.runDir)).events();
-    const exec = events.find((e) => e.type === 'shell.exec');
-    const runEnd = events.find((e) => e.type === 'run.end');
-    expect(exec, 'no shell.exec event was recorded').toBeDefined();
-
-    // It ran during the run, not after it — and by a margin the drain cannot fake. The agent sits
-    // for 400ms after the command finishes, so a timestamp taken at the drain lands within a few
-    // milliseconds of `run.end` while a timestamp taken when the command ran is 400ms clear of it.
-    // `toBeLessThanOrEqual` was true of both, which is why the bug survived a passing test.
-    expect(Date.parse(runEnd!.ts) - Date.parse(exec!.ts)).toBeGreaterThan(300);
-    expect(runEnd!.mono_us - exec!.mono_us).toBeGreaterThan(300_000);
-  });
-
-  it('attributes a shell command to the turn it happened during', async () => {
-    // The turn used to be whichever one was current when the frames file was drained — always the
-    // last — so every shell command in a run claimed to belong to the final turn, and `causes`
-    // could never link a tool call to the command it produced.
-    //
-    // This agent shells out *between* two model calls, so there is a right answer and a wrong one:
-    // turn 1, not turn 2.
-    const agent = join(workspace, 'interleaving-agent.mjs');
-    await writeFile(
-      agent,
-      [
-        "import { execFileSync } from 'node:child_process';",
-        'const base = process.env.OPENAI_BASE_URL ?? process.env.ANTHROPIC_BASE_URL;',
-        'const call = async () => {',
-        '  const res = await fetch(`${base}/chat/completions`, {',
-        "    method: 'POST',",
-        "    headers: { 'content-type': 'application/json' },",
-        "    body: JSON.stringify({ model: 'gpt-5.2', messages: [{ role: 'user', content: 'hi' }] }),",
-        '  });',
-        '  await res.text();',
-        '};',
-        'await call();',
-        "execFileSync('sh', ['-c', 'exit 0'], { stdio: 'pipe' });",
-        'await call();',
-      ].join('\n'),
-    );
-
-    const result = await recordCommand(
-      parseArgs(['record', 'generic-openai', '--upstream-openai', model.url, '--', 'node', agent]),
-      out,
-      workspace,
-    );
-
-    const events = await (await TraceReader.open(result.runDir)).events();
-    const turns = events.filter((e) => e.type === 'model.request').map((e) => e.turn);
-    const exec = events.find((e) => e.type === 'shell.exec');
-    expect(exec, 'no shell.exec event was recorded').toBeDefined();
-    expect(turns, 'the fixture must make two model calls for this to mean anything').toEqual([
-      1, 2,
-    ]);
-    expect(exec!.turn).toBe(1);
-  });
-
-  it('records the exit code the model never sees', async () => {
-    const result = await record();
-    const events = await (await TraceReader.open(result.runDir)).events();
-    const shellResult = events.find((e) => e.type === 'shell.result');
-    expect(shellResult, 'no shell.result event was recorded').toBeDefined();
-    expect(shellResult!.attrs?.exit_code).toBe(4);
-  });
-
-  it('records the stdout and stderr split', async () => {
-    const result = await record();
-    const events = await (await TraceReader.open(result.runDir)).events();
-    const shellResult = events.find((e) => e.type === 'shell.result')!;
-    expect(shellResult.attrs?.stdout_bytes).toBe(5);
-    expect(shellResult.attrs?.stderr_bytes).toBe(4);
-  });
-
-  it('records the command and links the result back to it', async () => {
-    const result = await record();
-    const events = await (await TraceReader.open(result.runDir)).events();
-    const exec = events.find((e) => e.type === 'shell.exec')!;
-    const shellResult = events.find((e) => e.type === 'shell.result')!;
-    expect(exec.attrs?.argv).toEqual(['sh', '-c', 'printf hello; printf boom 1>&2; exit 4']);
-    expect(shellResult.causes).toContain(exec.seq);
-  });
-
-  it('keeps every event valid against the normative schema', async () => {
-    const result = await record();
-    for (const event of await (await TraceReader.open(result.runDir)).events()) {
-      const r = validateEvent(event);
-      expect(r.valid, `seq ${event.seq}: ${r.errors.join(', ')}`).toBe(true);
-    }
-  });
-
-  it('does not change what the agent itself observes', async () => {
-    // The shim is in the agent's PATH during this run; the agent still completes normally.
-    const result = await record();
-    expect(result.childExitCode).toBe(0);
-  });
-
-  it('can be turned off, and then records no shell events', async () => {
-    const result = await record(['--no-shell']);
-    const events = await (await TraceReader.open(result.runDir)).events();
-    expect(events.some((e) => e.type === 'shell.exec')).toBe(false);
-    expect(lines.join('')).toContain('shell=off');
-  });
-});

package/packages/cli/test/shell-frames-drain.test.ts

@@ -1,91 +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, vi } from 'vitest';
-
-/**
- * A frame the reader keeps has to be one the drain can actually write.
- *
- * `readShellFrames` keeps a torn frame deliberately: a command that really ran must not vanish
- * from the trace because the line recording it lost its tail to a concurrent append. That is only
- * the right call if the consumer can take it — the claim is that it degrades a field rather than
- * failing, dropping `occurredAt` and stamping the events from the drain's own clock.
- *
- * Asserted rather than reasoned about, because the reader and the consumer live in different
- * packages and the last two rounds of this were exactly the two of them disagreeing about which
- * fields are load-bearing. The frame is planted through `installShellShim` so it is the real
- * `record` path that reads it, and it is the shape a real tear produces: everything from
- * `startedAt` onwards gone.
- */
-const planted = vi.hoisted(() => ({ line: '' }));
-vi.mock('@agenticreplay/shell-shim', async (importOriginal) => {
-  const actual = await importOriginal<typeof import('@agenticreplay/shell-shim')>();
-  return {
-    ...actual,
-    installShellShim: async (options: Parameters<typeof actual.installShellShim>[0]) => {
-      const shim = await actual.installShellShim(options);
-      // After the install, so this is what the drain finds; the shim only ever appends.
-      if (planted.line !== '') await writeFile(shim.framesPath, `${planted.line}\n`, 'utf8');
-      return shim;
-    },
-  };
-});
-import { parseArgs } from '../src/args.js';
-import { recordCommand } from '../src/commands/record.js';
-import { Output } from '../src/out.js';
-
-interface Row {
-  type: string;
-  ts: string;
-  attrs?: Record<string, unknown>;
-}
-
-describe('a torn shell frame, through the drain that writes it', () => {
-  const exec = promisify(execFile);
-  let workspace: string;
-
-  beforeEach(async () => {
-    planted.line = '';
-    workspace = await mkdtemp(join(tmpdir(), 'agenticreplay-frames-'));
-    await exec('git', ['init', '-q'], { cwd: workspace });
-    await exec('git', ['config', 'user.email', 'test@example.com'], { cwd: workspace });
-    await exec('git', ['config', 'user.name', 'Test'], { cwd: workspace });
-  });
-
-  afterEach(async () => {
-    await rm(workspace, { recursive: true, force: true });
-  });
-
-  /** One recorded run, and the events it wrote. */
-  async function record(): Promise<Row[]> {
-    const agent = join(workspace, 'agent.mjs');
-    await writeFile(agent, "console.log('GOT: done');\n");
-    const result = await recordCommand(
-      parseArgs(['record', 'generic-openai', '--', process.execPath, agent]),
-      new Output({ write: () => {}, isTTY: false }),
-      workspace,
-    );
-    const events = join(workspace, '.agenticreplay', 'runs', result.runId, 'events.jsonl');
-    return (await readFile(events, 'utf8'))
-      .split('\n')
-      .filter((line) => line.trim() !== '')
-      .map((line) => JSON.parse(line) as Row);
-  }
-
-  it('reaches the trace as both its events, stamped from the drain', async () => {
-    planted.line = '{"name":"sh","argv":["-c","npm test"],"cwd":"/tmp","exitCode":1,"signal":null}';
-
-    const rows = await record();
-    const ran = rows.find((row) => row.type === 'shell.exec');
-    const result = rows.find((row) => row.type === 'shell.result');
-
-    expect(ran, 'a command the agent ran is missing from the trace').toBeDefined();
-    expect(result, 'the command is there and its result is not').toBeDefined();
-    expect(ran!.attrs!['argv']).toEqual(['sh', '-c', 'npm test']);
-    expect(result!.attrs!['exit_code'], 'the exit code only the shim can see was lost').toBe(1);
-    // Degraded, not failed: no instant came off the frame, so both events carry the drain's.
-    expect(Number.isNaN(Date.parse(result!.ts)), 'the event has no usable timestamp').toBe(false);
-  }, 60_000);
-});

package/packages/cli/test/snapshot-retry.test.ts

@@ -1,54 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { snapshotWithRetry, type SnapshotSource } from '../src/snapshot.js';
-
-function source(results: Array<Error | { tree: string; changes: unknown[] }>): SnapshotSource {
-  let i = 0;
-  return {
-    async snapshotTurn() {
-      const next = results[Math.min(i, results.length - 1)]!;
-      i += 1;
-      if (next instanceof Error) throw next;
-      return next as never;
-    },
-  };
-}
-
-describe('snapshotWithRetry', () => {
-  it('returns the snapshot when it works first time', async () => {
-    const r = await snapshotWithRetry(source([{ tree: 'abc', changes: [] }]), 1, { delayMs: 0 });
-    expect(r.ok).toBe(true);
-    expect(r.snapshot?.tree).toBe('abc');
-    expect(r.attempts).toBe(1);
-  });
-
-  it('retries a transient git race and succeeds', async () => {
-    // These are the two real ones: the agent writing a file while git indexes it, and two
-    // snapshots overlapping on the index lock.
-    const src = source([
-      new Error('git add failed (128): error: short read while indexing auth.ts'),
-      { tree: 'def', changes: [] },
-    ]);
-    const r = await snapshotWithRetry(src, 1, { delayMs: 0 });
-    expect(r.ok).toBe(true);
-    expect(r.snapshot?.tree).toBe('def');
-    expect(r.attempts).toBe(2);
-  });
-
-  it('gives up after the retry budget and reports why, without throwing', async () => {
-    const err = new Error("git add failed (128): Unable to create 'index.lock': File exists.");
-    const r = await snapshotWithRetry(source([err]), 1, { delayMs: 0, attempts: 3 });
-    // Losing a snapshot degrades the trace. Aborting loses the run the user actually wanted.
-    expect(r.ok).toBe(false);
-    expect(r.attempts).toBe(3);
-    expect(r.error).toContain('index.lock');
-  });
-
-  it('does not retry an error that is not a transient race', async () => {
-    const r = await snapshotWithRetry(source([new Error('fatal: not a git repository')]), 1, {
-      delayMs: 0,
-      attempts: 3,
-    });
-    expect(r.ok).toBe(false);
-    expect(r.attempts, 'retrying a permanent failure just delays the run').toBe(1);
-  });
-});

package/packages/cli/test/support-claims.test.ts

@@ -1,127 +0,0 @@
-import { readFile } from 'node:fs/promises';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { describe, expect, it } from 'vitest';
-
-const here = dirname(fileURLToPath(import.meta.url));
-const ROOT = join(here, '..', '..', '..');
-const README = join(ROOT, 'README.md');
-const INTEGRATIONS = join(ROOT, 'docs', 'integrations.md');
-const RUNNER = join(ROOT, 'test', 'integrations', 'run.mjs');
-
-/**
- * The support table says which frameworks work and points at CI for the ones a check covers. This
- * holds those rows to the runner, because a row that cannot be checked is worse than no row: these
- * exist to be read by people who maintain the frameworks they name, and the first thing such a
- * reader does is look.
- *
- * Two failures it is built to catch, both of which have already happened here:
- *
- *   - **A cited check that does not exist**, or an `exact=N` that disagrees with the exchange count
- *     the check asserts. Easy to introduce by copying a row.
- *   - **A row that outlives its reason.** The CrewAI row said all of CrewAI, Aider and OpenHands
- *     route through LiteLLM, and CrewAI 1.x stopped doing that — LiteLLM became an optional extra
- *     and CrewAI grew native providers. Capture went on working, so nothing failed; the sentence
- *     explaining why had simply been wrong for a major version. Only running CrewAI itself found
- *     it, which is why the row now cites a check that runs CrewAI.
- *
- * So the assertions below are not only "does the number match". They pin the distinction each row
- * has to keep making: whether CI drives the framework, or the layer beneath it.
- */
-describe('the support table is backed by checks that exist', () => {
-  async function sources() {
-    const [readme, integrations, runner] = await Promise.all([
-      readFile(README, 'utf8'),
-      readFile(INTEGRATIONS, 'utf8'),
-      readFile(RUNNER, 'utf8'),
-    ]);
-    /** Every check the runner defines, and the exchange count it asserts. */
-    const checks = new Map<string, number>();
-    for (const m of runner.matchAll(/id: '([^']+)'[\s\S]*?exchanges: (\d+)/g)) {
-      checks.set(m[1]!, Number(m[2]));
-    }
-    /** The anchors GitHub generates from `docs/integrations.md` headings. */
-    const anchors = new Set(
-      [...integrations.matchAll(/^## (.+)$/gm)].map((m) =>
-        m[1]!
-          .toLowerCase()
-          .replace(/[^\w\s-]/g, '')
-          .trim()
-          .replace(/\s+/g, '-'),
-      ),
-    );
-    const rows = readme.split('\n').filter((l) => l.startsWith('| **') && l.includes('in CI'));
-    return { readme, checks, anchors, rows };
-  }
-
-  /** The row naming this framework, or undefined. */
-  function rowFor(rows: string[], framework: string): string | undefined {
-    return rows.find((r) => r.startsWith(`| **${framework}**`));
-  }
-
-  const CITED = [
-    { framework: 'OpenAI Agents SDK', checks: ['openai-agents'], exact: 1 },
-    { framework: 'Vercel AI SDK', checks: ['ai-sdk-openai', 'fetch-hook'], exact: 1 },
-    {
-      framework: 'LangGraph / LangChain',
-      checks: ['langgraph-stream', 'langgraph-tools'],
-      exact: 2,
-    },
-    { framework: 'CrewAI', checks: ['crewai'], exact: 1 },
-    { framework: 'Aider', checks: ['litellm'], exact: 1 },
-    { framework: 'browser-use', checks: ['browser-use'], exact: 1 },
-  ];
-
-  it.each(CITED)('$framework cites a check that exists and agrees on the count', async (c) => {
-    const { checks, rows } = await sources();
-    const row = rowFor(rows, c.framework);
-    expect(row, `no CI-citing row for ${c.framework}`).toBeDefined();
-
-    for (const id of c.checks) {
-      expect(checks.has(id), `run.mjs has no check called ${id}`).toBe(true);
-      expect(checks.get(id), `${id} asserts a different exchange count`).toBe(c.exact);
-    }
-    expect(row).toContain(`\`canonical_exact=${c.exact}\``);
-  });
-
-  it('every docs/integrations.md anchor a row links to resolves', async () => {
-    const { readme, anchors } = await sources();
-    const linked = [...readme.matchAll(/\(docs\/integrations\.md#([\w-]+)\)/g)].map((m) => m[1]!);
-    expect(linked.length).toBeGreaterThan(0);
-    for (const anchor of linked) {
-      expect(anchors.has(anchor), `#${anchor} is not a heading in docs/integrations.md`).toBe(true);
-    }
-  });
-
-  /**
-   * The honesty rule, which is the part that keeps these rows worth citing.
-   *
-   * A check either drives the framework or drives the layer beneath it, and the row has to say
-   * which. `litellm` runs `litellm.completion()`, so the row it backs may not claim CI runs Aider.
-   * `crewai` runs a real Crew, so that row may not still say CrewAI rides on LiteLLM — it does not.
-   */
-  it('a row claims only what its check actually runs', async () => {
-    const { rows } = await sources();
-
-    const crewai = rowFor(rows, 'CrewAI');
-    expect(crewai, 'CrewAI has no row').toBeDefined();
-    expect(crewai, 'the CrewAI row still says it routes through LiteLLM').not.toMatch(/LiteLLM/i);
-    expect(crewai, 'the CrewAI row does not say the check runs CrewAI itself').toMatch(
-      /Agent.*Task.*Crew/,
-    );
-
-    const aider = rowFor(rows, 'Aider');
-    expect(aider, 'Aider has no row').toBeDefined();
-    expect(aider, 'the Aider row must name the layer its check actually runs').toMatch(/LiteLLM/);
-
-    const agents = rowFor(rows, 'OpenAI Agents SDK');
-    expect(agents, 'the Agents SDK row must name the Responses API its check runs on').toMatch(
-      /Responses API/,
-    );
-
-    const browser = rowFor(rows, 'browser-use');
-    expect(browser, 'the browser-use check drives no browser, and the row must say so').toMatch(
-      /LLM layer only/,
-    );
-  });
-});