Skip to content

Garry's Opinionated OpenClaw/Hermes Agent Brain

TypeScript
22.8 KB
Raw Blame
import { describe, test, expect } from 'bun:test';
import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, readdirSync, rmSync, copyFileSync, chmodSync, existsSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
import { spawnSync } from 'node:child_process';

const repo = join(import.meta.dir, '../..');
function setup() {
  const root = mkdtempSync(join(tmpdir(), 'gbrain-e2e-runner-'));
  for (const dir of ['scripts/lib', 'test/e2e', 'bin']) mkdirSync(join(root, dir), { recursive: true });
  for (const file of ['run-e2e.sh', 'sharding.ts', 'lib/test-env.sh']) copyFileSync(join(repo, 'scripts', file), join(root, 'scripts', file));
  for (const name of ['a', 'b']) writeFileSync(join(root, `test/e2e/${name}.test.ts`), `import {test,expect} from 'bun:test'; test('isolated routing',()=>{ expect(process.env.SHARD).toBeUndefined(); expect(process.env.COVERAGE_DIR ?? '').toBe(''); });`);
  return root;
}
for (const githubActions of ['', 'true']) describe(`sequential E2E runner (GITHUB_ACTIONS=${githubActions})`, () => {
  const env = { ...process.env, GITHUB_ACTIONS: githubActions, GBRAIN_NO_SNAPSHOT: '1', DATABASE_URL: '', GBRAIN_DATABASE_URL: '', SHARD: '', COVERAGE_DIR: '' };
  function run(root: string, args: string[], shard = '') {
    return spawnSync('bash', ['scripts/run-e2e.sh', ...args], { cwd: root, encoding: 'utf8', env: { ...env, SHARD: shard } });
  }
  test('weighted shards cover exactly the explicit input; empty shards launch nothing', () => {
    const root = setup();
    try {
      const files = ['test/e2e/a.test.ts', 'test/e2e/b.test.ts'];
      const selected = [1, 2, 3].flatMap(n => {
        const r = run(root, ['--dry-run-list', ...files], `${n}/3`);
        expect(r.status, r.stderr).toBe(0);
        return r.stdout.trim().split('\n').filter(Boolean);
      });
      expect(selected.sort()).toEqual(files);
      expect(run(root, files, '3/3').stdout).toContain('No files for shard 3/3');
      for (const bad of ['2', '0/2', '3/2', '1/0', '1/2x', '1/2/3']) expect(run(root, files, bad).status).not.toBe(0);
    } finally { rmSync(root, { recursive: true, force: true }); }
  });
  test('runs each file and preserves an assertion failure in the final status', () => {
    const root = setup();
    try {
      const files = ['test/e2e/a.test.ts', 'test/e2e/b.test.ts'];
      const good = run(root, files, '1/1');
      expect(good.status, good.stderr + good.stdout).toBe(0);
      expect(good.stdout).toContain('Files: 2 total, 2 passed, 0 failed');
      writeFileSync(join(root, files[0]), "import {test,expect} from 'bun:test';test('failure',()=>expect(1).toBe(2));");
      const bad = run(root, files);
      expect(bad.status).toBe(1);
      expect(bad.stdout).toContain('Files: 2 total, 1 passed, 1 failed');
    } finally { rmSync(root, { recursive: true, force: true }); }
  });
  test('coverage keeps fresh processes, disjoint LCOV directories, shard identity and successful execution receipts', () => {
    const root = setup();
    try {
      const coverage = join(root, 'coverage');
      const files = ['test/e2e/a.test.ts', 'test/e2e/b.test.ts'];
      writeFileSync(join(root, 'bin/git'), '#!/bin/sh\nprintf fixture-commit\n', { mode: 0o755 });
      writeFileSync(join(root, 'test/e2e/source.ts'), 'export const answer = () => 42;');
      for (const file of files) writeFileSync(join(root, file), `import {test,expect} from 'bun:test';
import {appendFileSync} from 'node:fs';
import {answer} from './source';
test('fresh process',()=>{
  expect(process.env.SHARD).toBeUndefined();
  expect((globalThis as any).priorFile).toBeUndefined();
  (globalThis as any).priorFile = true;
  expect(answer()).toBe(42);
  appendFileSync(${JSON.stringify(join(root, 'pids.txt'))}, process.pid+'\\n');
});`);
      const coverageEnv = { ...env, SHARD: '1/1', COVERAGE_DIR: coverage, PATH: `${join(root, 'bin')}:${process.env.PATH}` };
      const good = spawnSync('bash', ['scripts/run-e2e.sh', ...files], { cwd: root, env: coverageEnv, encoding: 'utf8' });
      expect(good.status, good.stdout + good.stderr).toBe(0);
      expect(new Set(readFileSync(join(root, 'pids.txt'), 'utf8').trim().split('\n')).size).toBe(2);
      expect(existsSync(join(coverage, 'e2e-1/lcov.info'))).toBe(true);
      expect(existsSync(join(coverage, 'e2e-2/lcov.info'))).toBe(true);
      expect(JSON.parse(readFileSync(join(coverage, 'lane-manifest.json'), 'utf8'))).toEqual({ lane: 'e2e-1', sha: 'fixture-commit', lcovCount: 2, complete: true });
      expect(readFileSync(join(coverage, 'executed-files.txt'), 'utf8').trim().split('\n').sort()).toEqual(files);
      const shorterCoverage = join(root, 'shorter-coverage');
      const shorter = spawnSync('bash', ['scripts/run-e2e.sh', files[0]], { cwd: root, env: { ...coverageEnv, COVERAGE_DIR: shorterCoverage }, encoding: 'utf8' });
      expect(shorter.status, shorter.stdout + shorter.stderr).toBe(0);
      expect(existsSync(join(shorterCoverage, 'e2e-2/lcov.info'))).toBe(false);
      expect(JSON.parse(readFileSync(join(shorterCoverage, 'lane-manifest.json'), 'utf8')).lcovCount).toBe(1);
      expect(readFileSync(join(shorterCoverage, 'executed-files.txt'), 'utf8')).toBe(files[0] + '\n');
      writeFileSync(join(root, files[0]), "import {test} from 'bun:test';test.skip('optional',()=>{});");
      const skippedCoverage = join(root, 'skipped-coverage');
      const skipped = spawnSync('bash', ['scripts/run-e2e.sh', files[0]], { cwd: root, env: { ...coverageEnv, COVERAGE_DIR: skippedCoverage }, encoding: 'utf8' });
      expect(skipped.status, skipped.stdout + skipped.stderr).toBe(0);
      expect(existsSync(join(skippedCoverage, 'e2e-1/lcov.info'))).toBe(false);
      expect(JSON.parse(readFileSync(join(skippedCoverage, 'lane-manifest.json'), 'utf8')).lcovCount).toBe(0);
      expect(existsSync(join(coverage, 'e2e-2/lcov.info'))).toBe(true);
      expect(JSON.parse(readFileSync(join(coverage, 'lane-manifest.json'), 'utf8')).lcovCount).toBe(2);
      writeFileSync(join(root, files[0]), "import {test,expect} from 'bun:test';test('failure',()=>expect(1).toBe(2));");
      const failedCoverage = join(root, 'failed-coverage');
      const bad = spawnSync('bash', ['scripts/run-e2e.sh', ...files], { cwd: root, env: { ...coverageEnv, COVERAGE_DIR: failedCoverage }, encoding: 'utf8' });
      expect(bad.status).toBe(1);
      // B9: a red lane still records which files it ran; only the
      // complete:true manifest stays green-only.
      expect(existsSync(join(failedCoverage, 'lane-manifest.json'))).toBe(false);
      expect(readFileSync(join(failedCoverage, 'executed-files.txt'), 'utf8').trim().split('\n').sort()).toEqual(files);
    } finally { rmSync(root, { recursive: true, force: true }); }
  });
  test.each(['empty', 'populated'])('refuses an existing %s coverage destination without changing its files', kind => {
    const root = setup();
    try {
      const coverage = join(root, 'coverage');
      mkdirSync(coverage);
      const prior: Record<string, string> = kind === 'empty' ? {} : {
        'e2e-1/lcov.info': 'numbered prior result',
        'other/lcov.info': 'unrelated prior result',
        'lane-manifest.json': '{"complete":true,"sha":"prior-commit"}',
        'executed-files.txt': 'prior file receipt',
      };
      for (const [file, contents] of Object.entries(prior)) {
        mkdirSync(join(coverage, file, '..'), { recursive: true });
        writeFileSync(join(coverage, file), contents);
      }
      const result = spawnSync('bash', ['scripts/run-e2e.sh', 'test/e2e/a.test.ts'], {
        cwd: root, encoding: 'utf8', env: { ...env, COVERAGE_DIR: coverage },
      });
      expect(result.status).toBe(1);
      expect(result.stderr).toContain('must be a new, unused directory');
      expect(result.stdout).not.toContain('=== a.test.ts ===');
      for (const [file, contents] of Object.entries(prior)) expect(readFileSync(join(coverage, file), 'utf8')).toBe(contents);
    } finally { rmSync(root, { recursive: true, force: true }); }
  });
  test('coverage runs default GBRAIN_TEST_WAIT_MULTIPLIER to 2 and keep an explicit value through the env scrub', () => {
    const root = setup();
    try {
      writeFileSync(join(root, 'bin/git'), '#!/bin/sh\nprintf fixture-commit\n', { mode: 0o755 });
      writeFileSync(join(root, 'test/e2e/a.test.ts'), "import {test,expect} from 'bun:test'; test('multiplier',()=>expect(process.env.GBRAIN_TEST_WAIT_MULTIPLIER).toBe(process.env.EXPECTED_MULTIPLIER));");
      const path = `${join(root, 'bin')}:${process.env.PATH}`;
      for (const [coverage, multiplier, expected] of [['coverage-a', '', '2'], ['coverage-b', '3', '3'], ['', '1.5', '1.5']]) {
        const result = spawnSync('bash', ['scripts/run-e2e.sh', 'test/e2e/a.test.ts'], {
          cwd: root, encoding: 'utf8', env: { ...env, COVERAGE_DIR: coverage, GBRAIN_TEST_WAIT_MULTIPLIER: multiplier, EXPECTED_MULTIPLIER: expected, PATH: path },
        });
        expect(result.status, result.stdout + result.stderr).toBe(0);
      }
    } finally { rmSync(root, { recursive: true, force: true }); }
  });
  test('a fully skipped file has execution evidence but need not emit LCOV', () => {
    const root = setup();
    try {
      writeFileSync(join(root, 'bin/git'), '#!/bin/sh\nprintf fixture-commit\n', { mode: 0o755 });
      writeFileSync(join(root, 'test/e2e/a.test.ts'), "import {test} from 'bun:test'; test.skip('requires optional fixture',()=>{});");
      const result = spawnSync('bash', ['scripts/run-e2e.sh', 'test/e2e/a.test.ts'], {
        cwd: root, encoding: 'utf8', env: { ...env, COVERAGE_DIR: 'coverage', PATH: `${join(root, 'bin')}:${process.env.PATH}` },
      });
      expect(result.status, result.stdout + result.stderr).toBe(0);
      expect(JSON.parse(readFileSync(join(root, 'coverage/lane-manifest.json'), 'utf8'))).toEqual({ lane: 'e2e', sha: 'fixture-commit', lcovCount: 0, complete: true });
      expect(readFileSync(join(root, 'coverage/executed-files.txt'), 'utf8')).toBe('test/e2e/a.test.ts\n');
    } finally { rmSync(root, { recursive: true, force: true }); }
  });
  test('native reports retain nested imported suites, skips and todos within the selected file', () => {
    const root = setup();
    try {
      writeFileSync(join(root, 'test/imported.ts'), `import {describe,test,expect} from 'bun:test';
describe('imported',()=>{
  test('pass',()=>expect(1).toBe(1));
  describe('nested',()=>test.skip('skip',()=>{}));
});
describe('second',()=>test.todo('todo'));`);
      writeFileSync(join(root, 'test/e2e/a.test.ts'), "import '../imported';");
      const result = run(root, ['test/e2e/a.test.ts']);
      expect(result.status, result.stdout + result.stderr).toBe(0);
      expect(result.stdout).toContain('1 pass');
      expect(result.stdout).toContain('1 skip');
      expect(result.stdout).toContain('1 todo');
    } finally { rmSync(root, { recursive: true, force: true }); }
  });
  test.each(['early exit', 'nested summary without parent', 'nested summary with parent'])('%s requires the selected Bun process to finish', kind => {
    const root = setup();
    try {
      writeFileSync(join(root, 'bin/git'), '#!/bin/sh\nprintf fixture-commit\n', { mode: 0o755 });
      writeFileSync(join(root, 'test/child.test.ts'), "import {test,expect} from 'bun:test'; test('child',()=>expect(1).toBe(1));");
      writeFileSync(join(root, 'test/e2e/a.test.ts'), `import {test,expect} from 'bun:test';
import {spawnSync} from 'node:child_process';
test('parent',()=>{
  if (${kind !== 'early exit'}) {
    const child = spawnSync(process.execPath, ['test', 'test/child.test.ts'], {encoding:'utf8'});
    console.log(child.stdout);
    console.error(child.stderr);
    expect(child.status).toBe(0);
  }
  if (${kind !== 'nested summary with parent'}) process.exit(0);
});`);
      const result = spawnSync('bash', ['scripts/run-e2e.sh', 'test/e2e/a.test.ts'], {
        cwd: root, encoding: 'utf8', env: { ...env, COVERAGE_DIR: 'coverage', PATH: `${join(root, 'bin')}:${process.env.PATH}` },
      });
      const complete = kind === 'nested summary with parent';
      expect(result.status, result.stdout + result.stderr).toBe(complete ? 0 : 1);
      expect(existsSync(join(root, 'coverage/lane-manifest.json'))).toBe(complete);
      expect(readFileSync(join(root, 'coverage/executed-files.txt'), 'utf8')).toBe('test/e2e/a.test.ts\n');
      if (!complete) expect(result.stdout).toContain('did not produce a complete native Bun report');
    } finally { rmSync(root, { recursive: true, force: true }); }
  });
  test.each(['missing console summary', 'missing pass count', 'wrong console file', 'wrong report file', 'reported failure', 'missing testcases', 'truncated XML', 'mismatched XML', 'hidden failure', 'wrong suite count'])('%s cannot turn zero exit into completion', kind => {
    const root = setup();
    try {
      const selected = 'test/e2e/a.test.ts';
      const header = kind === 'wrong console file' ? 'test/e2e/other.test.ts' : selected;
      const file = kind === 'wrong report file' ? 'test/e2e/other.test.ts' : selected;
      const failures = kind === 'reported failure' ? 1 : 0;
      const counts = kind === 'missing pass count' ? ' 0 fail\n' : ` ${1 - failures} pass\n ${failures} fail\n`;
      const output = `bun test v1.3.13\n\n${githubActions ? '::group::' : ''}${header}:\n${counts}${kind === 'missing console summary' ? '' : 'Ran 1 test across 1 file. [1.00ms]\n'}`;
      const testcase = kind === 'missing testcases' ? '' : `<testcase name="parent" file="${file}">${failures || kind === 'hidden failure' ? '<failure />' : ''}</testcase>`;
      let xml = `<testsuites tests="1" failures="${failures}" skipped="0">\n  <testsuite file="${file}" tests="${kind === 'wrong suite count' ? 2 : 1}" failures="${failures}" skipped="0">${testcase}</testsuite>\n</testsuites>\n`;
      if (kind === 'truncated XML') xml = xml.slice(0, xml.indexOf('</testsuites>'));
      if (kind === 'mismatched XML') xml = xml.replace('</testcase>', '</broken>');
      writeFileSync(join(root, 'bin/bun'), `#!/bin/sh
for arg do case "$arg" in --reporter-outfile=*) report="\${arg#*=}" ;; esac; done
printf '%s' '${xml}' > "$report"
printf '%s' '${output}'
`, { mode: 0o755 });
      const result = spawnSync('bash', ['scripts/run-e2e.sh', selected], {
        cwd: root, encoding: 'utf8', env: { ...env, COVERAGE_DIR: 'coverage', PATH: `${join(root, 'bin')}:${process.env.PATH}` },
      });
      expect(result.status, result.stdout + result.stderr).toBe(1);
      expect(result.stdout).toContain('did not produce a complete native Bun report');
      expect(existsSync(join(root, 'coverage/lane-manifest.json'))).toBe(false);
      expect(readFileSync(join(root, 'coverage/executed-files.txt'), 'utf8')).toBe(`${selected}\n`);
    } finally { rmSync(root, { recursive: true, force: true }); }
  });
  for (const firstFails of [false, true]) test(`each file has a fresh home after a ${firstFails ? 'failing' : 'passing'} config writer`, () => {
    const root = setup();
    try {
      const homes = join(root, 'homes.jsonl');
      writeFileSync(join(root, 'test/e2e/a.test.ts'), `
        import {test,expect} from 'bun:test';
        import {writeFileSync,appendFileSync,mkdirSync} from 'node:fs';
        import {join} from 'node:path';
        test('write a schema and harness config',()=>{
          expect(process.env.HOME).toBe(process.env.GBRAIN_HOME);
          appendFileSync(${JSON.stringify(homes)},JSON.stringify(process.env.HOME)+'\\n');
          mkdirSync(join(process.env.GBRAIN_HOME!,'.gbrain'),{recursive:true});
          writeFileSync(join(process.env.GBRAIN_HOME!,'.gbrain/config.json'),'"example-schema-override"');
          writeFileSync(join(process.env.HOME!,'harness-config'),'example');
          expect(${JSON.stringify(firstFails)}).toBe(false);
        });
      `);
      writeFileSync(join(root, 'test/e2e/b.test.ts'), `
        import {test,expect} from 'bun:test';
        import {existsSync,appendFileSync} from 'node:fs';
        import {join} from 'node:path';
        test('start without the preceding file configuration',()=>{
          expect(process.env.HOME).toBe(process.env.GBRAIN_HOME);
          appendFileSync(${JSON.stringify(homes)},JSON.stringify(process.env.HOME)+'\\n');
          expect(existsSync(join(process.env.GBRAIN_HOME!,'.gbrain/config.json'))).toBe(false);
          expect(existsSync(join(process.env.HOME!,'harness-config'))).toBe(false);
        });
      `);
      const result = run(root, ['test/e2e/a.test.ts', 'test/e2e/b.test.ts']);
      expect(result.status, result.stderr + result.stdout).toBe(firstFails ? 1 : 0);
      expect(result.stdout).toContain(`Files: 2 total, ${firstFails ? 1 : 2} passed, ${firstFails ? 1 : 0} failed`);
      const selected = readFileSync(homes, 'utf8').trim().split('\n').map(line => JSON.parse(line) as string);
      expect(selected).toHaveLength(2);
      expect(new Set(selected).size).toBe(2);
      for (const home of selected) expect(existsSync(home)).toBe(false);
    } finally { rmSync(root, { recursive: true, force: true }); }
  });
  test.each(['SIGTERM', 'SIGINT'] as const)('%s terminates its owned interrupt-resistant child', async signal => {
    const root = setup();
    let child: ReturnType<typeof Bun.spawn> | undefined;
    let pid: number | undefined;
    try {
      const fake = join(root, 'bin/bun');
      const coverage = join(root, 'coverage');
      writeFileSync(fake, `#!/usr/bin/env bash\ntrap '' INT TERM\necho $$ > '${join(root, 'child.pid.tmp')}'\nmv '${join(root, 'child.pid.tmp')}' '${join(root, 'child.pid')}'\nwhile true; do sleep 1; done\n`);
      chmodSync(fake, 0o755);
      child = Bun.spawn(['bash', 'scripts/run-e2e.sh', 'test/e2e/a.test.ts'], { cwd: root, env: { ...env, COVERAGE_DIR: coverage, PATH: `${join(root, 'bin')}:${process.env.PATH}` }, stdout: 'ignore', stderr: 'ignore' });
      const deadline = Date.now() + 5000;
      while (!existsSync(join(root, 'child.pid')) && Date.now() < deadline) await Bun.sleep(20);
      expect(existsSync(join(root, 'child.pid'))).toBe(true);
      pid = Number(readFileSync(join(root, 'child.pid'), 'utf8').trim());
      expect(pid).toBeGreaterThan(0);
      const collision = spawnSync('bash', ['scripts/run-e2e.sh', 'test/e2e/a.test.ts'], {
        cwd: root, env: { ...env, COVERAGE_DIR: coverage, PATH: `${join(root, 'bin')}:${process.env.PATH}` }, encoding: 'utf8',
      });
      expect(collision.status).toBe(1);
      expect(collision.stderr).toContain('must be a new, unused directory');
      expect(() => process.kill(pid!, 0)).not.toThrow();
      child.kill(signal);
      expect(await child.exited).toBe(signal === 'SIGINT' ? 130 : 143);
      // The SIGKILLed child is reparented and reaped asynchronously; on a
      // loaded host it can still answer signal 0 just after the runner exits.
      const reaped = async () => {
        for (const deadline = Date.now() + 5000; Date.now() < deadline; await Bun.sleep(20)) {
          try { process.kill(pid!, 0); } catch { return true; }
        }
        return false;
      };
      expect(await reaped()).toBe(true);
      expect(existsSync(join(coverage, 'lane-manifest.json'))).toBe(false);
      expect(existsSync(join(coverage, 'executed-files.txt'))).toBe(false);
    } finally {
      child?.kill();
      if (pid) { try { process.kill(pid, 'SIGKILL'); } catch {} }
      rmSync(root, { recursive: true, force: true });
    }
  }, 10000);
});

describe('per-file HOME cleanup and receipts', () => {
  const env = { ...process.env, GBRAIN_NO_SNAPSHOT: '1', DATABASE_URL: '', GBRAIN_DATABASE_URL: '', SHARD: '', COVERAGE_DIR: '' };
  const files = ['test/e2e/a.test.ts', 'test/e2e/b.test.ts'];

  test('a HOME that cannot be removed fails that file by name and the partition continues (B2)', () => {
    const root = setup();
    const tmp = join(root, 'tmp');
    mkdirSync(tmp);
    try {
      writeFileSync(join(root, files[0]), `import {test} from 'bun:test';
import {mkdirSync,writeFileSync,chmodSync} from 'node:fs';
test('leaves an unremovable HOME entry',()=>{
  const dir = process.env.HOME + '/locked';
  mkdirSync(dir + '/inner', { recursive: true });
  writeFileSync(dir + '/inner/x', 'x');
  chmodSync(dir, 0o500);
});`);
      const r = spawnSync('bash', ['scripts/run-e2e.sh', ...files], { cwd: root, encoding: 'utf8', env: { ...env, TMPDIR: tmp } });
      expect(r.status, r.stdout + r.stderr).toBe(1);
      expect(r.stdout).toMatch(/FAILED: a\.test\.ts left a process writing to its HOME; cleanup could not remove \S+file-1-direct/);
      expect(r.stdout).toContain('Fix: make the test wait for or stop its children; reproduce with: bash scripts/run-e2e.sh test/e2e/a.test.ts');
      expect(r.stdout).toContain('=== b.test.ts ===');
      expect(r.stdout).toContain('Files: 2 total, 1 passed, 1 failed');
    } finally {
      spawnSync('chmod', ['-R', 'u+rwx', tmp]);
      rmSync(root, { recursive: true, force: true });
    }
  });

  test.skipIf(process.platform !== 'linux')('a child left running with the file HOME is killed before cleanup and named', () => {
    const root = setup();
    try {
      writeFileSync(join(root, files[0]), `import {test} from 'bun:test';
import {spawn} from 'node:child_process';
import {writeFileSync} from 'node:fs';
test('leaks a detached child',()=>{
  const child = spawn('sleep', ['60'], { detached: true, stdio: 'ignore', env: process.env });
  child.unref();
  writeFileSync(${JSON.stringify(join(root, 'leak.pid'))}, String(child.pid));
});`);
      const r = spawnSync('bash', ['scripts/run-e2e.sh', files[0]], { cwd: root, encoding: 'utf8', env });
      expect(r.status, r.stdout + r.stderr).toBe(0);
      expect(r.stdout).toContain('WARN: a.test.ts left processes running with HOME=');
      const pid = Number(readFileSync(join(root, 'leak.pid'), 'utf8'));
      let alive = true;
      for (let i = 0; i < 50 && alive; i++) {
        try { process.kill(pid, 0); alive = !/\) Z /.test(readFileSync(`/proc/${pid}/stat`, 'utf8')); } catch { alive = false; }
        if (alive) Bun.sleepSync(20);
      }
      expect(alive).toBe(false);
    } finally { rmSync(root, { recursive: true, force: true }); }
  });

  test('each file pass leaves a receipt with its native JUnit report, failures included', () => {
    const root = setup();
    try {
      writeFileSync(join(root, files[1]), "import {test,expect} from 'bun:test';test('breaks',()=>expect(1).toBe(2));");
      const receipts = join(root, 'receipts');
      const r = spawnSync('bash', ['scripts/run-e2e.sh', ...files], { cwd: root, encoding: 'utf8', env: { ...env, GBRAIN_TEST_RECEIPT_DIR: receipts, GBRAIN_TEST_RECEIPT_LANE: 'tier9' } });
      expect(r.status).toBe(1);
      const ids = readdirSync(receipts).filter(n => n.endsWith('.receipt')).sort();
      expect(ids).toEqual(['tier9--run-f1-direct--primary.receipt', 'tier9--run-f2-direct--primary.receipt']);
      expect(readFileSync(join(receipts, ids[1]), 'utf8')).toContain('exit=1');
      expect(readFileSync(join(receipts, 'tier9--run-f2-direct--primary.junit.xml'), 'utf8')).toContain('<failure');
      expect(readFileSync(join(receipts, 'tier9--run-f2-direct--primary.files'), 'utf8')).toBe('test/e2e/b.test.ts\n');
    } finally { rmSync(root, { recursive: true, force: true }); }
  });
});