gstack/test/review-pass.test.ts

/**
 * GSTA-167 calls PR 2: the staged pass manifest (lib/review-pass.ts), its bin commands, and the
 * checked-in Capy pass program (lib/capy-review-pass.js) run against a fake host whose shell is real.
 */
import { describe, expect, test } from 'bun:test';
import { spawnSync } from 'node:child_process';
import * as fs from 'node:fs';
import * as os from 'node:os';
import * as path from 'node:path';
import { promptHash, sectionTexts, withWorkspace, workspaceParagraph, workspaceStep } from '../lib/review-brief';
import { CHUNK_CHARS, PARENT_ONLY_QA, buildManifest, chunkCount, chunkOf, markReader, renderStage, specialistFindings, type Manifest } from '../lib/review-pass';
import type { Dispatch } from '../lib/review-depth';

const ROOT = path.resolve(import.meta.dir, '..');
const BIN = path.join(ROOT, 'bin');
const texts = sectionTexts(ROOT);
const SHA = 'a'.repeat(40);
const spec = (name: string, exclude: string[] = []): Dispatch => ({ role: 'specialist', name, effort: 'full', exclude });

function tmp(prefix: string) { return fs.mkdtempSync(path.join(os.tmpdir(), prefix)); }
function manifest(dispatches: Dispatch[], o: Partial<Parameters<typeof buildManifest>[0]> = {}): Manifest {
  const out = tmp('rp-out-');
  const root = tmp('rp-root-');
  fs.writeFileSync(path.join(root, 'package.json'), '{}');
  return buildManifest({ pass: 'p1', out, ledger: path.join(out, 'ledger.jsonl'), base: 'main', diffBase: SHA, root, checklistRoot: ROOT, dispatches, next: 'full', planLines: [], ...o });
}
const collectAll = (m: Manifest, stage: string) => { for (const r of m.readers.filter(x => x.stage === stage)) { markReader(m, r.reader, 'intent'); markReader(m, r.reader, 'created', { path: '9' }); markReader(m, r.reader, 'collected'); } };

describe('pass manifest', () => {
  test('stages follow the plan: specialists, Red Team, voices; batched light depth keeps its checklists and exclusions; a fix-check needs its files', () => {
    const m = manifest([spec('testing'), { role: 'red-team', name: 'red-team', effort: 'full', exclude: [] }, { role: 'adversarial-native', name: 'adversarial', effort: 'full', exclude: [] }, { role: 'outside-voice', name: 'outside-voice', effort: 'host', exclude: [] }]);
    expect(m.readers.map(r => [r.reader, r.stage, r.title])).toEqual([
      ['specialist/testing', 'specialists', 'ship p1 specialist/testing'], ['red-team', 'red-team', 'ship p1 red-team'],
      ['adversarial-native', 'voices', 'ship p1 adversarial-native'], ['outside-voice', 'voices', 'ship p1 outside-voice']]);
    expect(m.stack).toBe('node');
    expect(m.test_fw).toBe('unknown');
    const light = manifest([{ role: 'specialist', name: 'batched', effort: 'full', exclude: [':(exclude)docs/a.md'], checklists: ['testing', 'red-team'] }]);
    expect(light.readers[0]).toMatchObject({ reader: 'specialist-batched', role: 'specialist-batched', exclude: "-- . ':(exclude)docs/a.md'", checklists: ['testing', 'red-team'] });
    expect(() => manifest([{ role: 'fix-check', name: 'fix-check', effort: 'full', exclude: [] }])).toThrow(/the plan dispatches a fix-check: pass needs --fix-list, --hunks and --tests/);
    // PR #3665 review: the batched reviewer reads each checklist by path, as the render CLI is given them, never by bare name.
    renderStage(light, 'specialists', texts, () => '');
    expect(fs.readFileSync(light.readers[0]!.file!, 'utf8')).toContain(`Read each checklist at ${path.join(ROOT, 'review/specialists/testing.md')}, ${path.join(ROOT, 'review/specialists/red-team.md')} (tag each finding`);
  });

  test('a manifest render is byte for byte the render CLI\'s brief for the same slots', () => {
    const m = manifest([spec('security', [':(exclude)test/x.ts'])]);
    renderStage(m, 'specialists', texts, () => '');
    const out = tmp('rp-cli-');
    const r = spawnSync(path.join(BIN, 'gstack-review-dispatch'), ['render', '--role', 'specialist', '--name', 'security', '--out', out, '--diff-base', SHA, '--stack', 'node', '--test-fw', 'unknown', '--exclude', "-- . ':(exclude)test/x.ts'"], { encoding: 'utf8', timeout: 30_000 });
    expect(r.status, r.stderr).toBe(0);
    expect(r.stdout).toContain('sha256=' + m.readers[0]!.sha256);
    expect(fs.readFileSync(m.readers[0]!.file!, 'utf8')).toBe(fs.readFileSync(path.join(out, 'specialist-security.prompt.md'), 'utf8'));
  });

  test('the Red Team renders only after every earlier reader is collected, from the specialists\' merged lines byte for byte', () => {
    const m = manifest([spec('testing'), spec('security'), { role: 'red-team', name: 'red-team', effort: 'full', exclude: [] }]);
    renderStage(m, 'specialists', texts, () => '');
    expect(() => renderStage(m, 'red-team', texts, () => '')).toThrow(/still open: specialist\/testing, specialist\/security/);
    const lines = [{ id: 'specialist/testing#1', reader: 'specialist/testing', label: 'High', raw: 'High: a — ü', output_sha256: 'x' }, { id: 'red-team#1', reader: 'red-team', label: 'Low', raw: 'Low: b', output_sha256: 'y' }];
    fs.writeFileSync(m.merged, lines.map(l => JSON.stringify(l) + '\n').join(''));
    collectAll(m, 'specialists');
    renderStage(m, 'red-team', texts, () => '');
    const findings = fs.readFileSync(path.join(m.out, 'briefs/specialist-findings.jsonl'), 'utf8');
    expect(findings).toBe(JSON.stringify(lines[0]) + '\n');
    expect(findings).toBe(specialistFindings(m.merged));
    const rt = m.readers.find(r => r.reader === 'red-team')!;
    expect(rt.findings_sha256).toBe(promptHash(findings));
    const brief = fs.readFileSync(rt.file!, 'utf8');
    expect(brief).toContain('reviewed by 2 specialists');
    const batched = manifest([{ role: 'specialist', name: 'batched', effort: 'medium', exclude: [], checklists: ['testing', 'security', 'state-machines'] }, { role: 'red-team', name: 'red-team', effort: 'full', exclude: [] }]);
    renderStage(batched, 'specialists', texts, () => '');
    collectAll(batched, 'specialists');
    renderStage(batched, 'red-team', texts, () => '');
    expect(fs.readFileSync(batched.readers[1]!.file!, 'utf8')).toContain('reviewed by 3 specialists');
    expect(brief).toContain(findings.trim());
  });

  test('reader states move forward only: intent before create, a path with created or queued', () => {
    const m = manifest([spec('testing')]);
    renderStage(m, 'specialists', texts, () => '');
    expect(() => markReader(m, 'specialist/testing', 'created', { path: '1' })).toThrow(/cannot become created/);
    markReader(m, 'specialist/testing', 'intent');
    expect(() => markReader(m, 'specialist/testing', 'created')).toThrow(/only with its subagent path/);
    markReader(m, 'specialist/testing', 'queued', { path: '4' });
    markReader(m, 'specialist/testing', 'created');
    expect(() => markReader(m, 'specialist/testing', 'intent')).toThrow(/cannot become intent/);
    expect(m.readers[0]).toMatchObject({ state: 'created', path: '4' });
  });

  // Value: protects=an unreadable extra prompt stops as a BriefError naming the reader; fails_when=a directory prompt_file throws a raw
  //   EISDIR from the QA guard's read (GST-450 adversarial #4); seam=none
  test('a directory extra prompt stops as an unreadable prompt file, not a raw read error', () => {
    const d = manifest([spec('testing')], { extras: [{ name: 'plan', prompt_file: tmp('rp-qa-') }] });
    expect(() => renderStage(d, 'specialists', texts, () => '')).toThrow(/cannot read audit\/plan's prompt file/);
  });

  test('a brief over 1 MiB with invalid UTF-8 in its diff travels in bounded chunks that rejoin to the rendered sha', () => {
    const m = manifest([{ role: 'outside-voice', name: 'outside-voice', effort: 'host', exclude: [] }]);
    const diff = Buffer.concat([Buffer.from('+line \u00e9\n'.repeat(90_000)), Buffer.from([0xff, 0xfe, 0x0a]), Buffer.from('+"quoted" \\ back\n'.repeat(20_000))]).toString('utf8');
    renderStage(m, 'voices', texts, () => diff);
    const r = m.readers[0]!;
    const text = fs.readFileSync(r.file!, 'utf8');
    expect(Buffer.byteLength(text)).toBeGreaterThan(1024 * 1024);
    expect(r.chunks).toBe(chunkCount(text));
    let joined = '';
    for (let i = 0; i < r.chunks!; i++) {
      const c = spawnSync(path.join(BIN, 'gstack-review-dispatch'), ['chunk', '--manifest', writeManifestFile(m), '--reader', 'outside-voice', '--index', String(i)], { encoding: 'utf8', timeout: 30_000, maxBuffer: 8 * 1024 * 1024 });
      expect(c.status, c.stderr).toBe(0);
      const [head, body] = c.stdout.split('\n');
      expect(head).toBe('BRIEF_CHUNK: reader=outside-voice index=' + i + ' of=' + r.chunks + ' sha256=' + r.sha256);
      expect(Buffer.byteLength(body!)).toBeLessThan(1024 * 1024);
      joined += JSON.parse(body!);
    }
    expect(promptHash(joined)).toBe(r.sha256!);
    expect(() => chunkOf(text, r.chunks!)).toThrow(/outside/);
    expect(chunkOf(text, 0).length).toBe(CHUNK_CHARS);
  });
});

function writeManifestFile(m: Manifest): string {
  const f = path.join(m.out, 'pass-manifest.json');
  fs.writeFileSync(f, JSON.stringify(m));
  return f;
}

/** A repository on a feature branch with enough runtime lines for a full plan. */
function repo(): { dir: string; env: NodeJS.ProcessEnv } {
  const dir = tmp('rp-repo-');
  const env = { ...process.env, PATH: BIN + path.delimiter + process.env.PATH, GSTACK_STATE_ROOT: path.join(dir, '.state'), GIT_AUTHOR_NAME: 't', GIT_AUTHOR_EMAIL: 't@t', GIT_COMMITTER_NAME: 't', GIT_COMMITTER_EMAIL: 't@t' };
  const sh = (c: string) => { const r = spawnSync('bash', ['-c', c], { cwd: dir, env, encoding: 'utf8', timeout: 60_000 }); if (r.status !== 0) throw new Error(r.stderr); };
  sh("git init -q -b main && echo '{}' > package.json && mkdir src && echo 'export const a = 1;' > src/a.ts && echo .state > .gitignore && git add -A && git commit -qm base && git checkout -qb feat");
  sh('for i in $(seq 1 80); do echo "export const v$i = $i;" >> src/a.ts; done && git commit -qam feat');
  return { dir, env };
}

interface Sub { title: string; prompt: string; status: string; polls: number; model?: unknown; summary?: string; late?: boolean }
/** A fake Capy host: the shell is real (the repository's bins), subagents are scripted. */
const cleanReply = (title: string) => (title.endsWith('outside-voice') ? 'Recommendation: ship as-is because no finding survived' : 'NO FINDINGS');
/** The REVIEWED_TREE line a reader prints from dir (its brief's checkout when it follows the workspace paragraph); '' outside a checkout. */
function treeLine(dir: string): string {
  if (!dir) return '';
  const git = (a: string[]) => spawnSync('git', ['-C', dir, ...a], { encoding: 'utf8', timeout: 30_000 });
  const tree = git(['rev-parse', 'HEAD^{tree}']), top = git(['rev-parse', '--show-toplevel']);
  return tree.status === 0 && top.status === 0 ? `REVIEWED_TREE: ${tree.stdout.trim()} ${top.stdout.trim()}\n` : '';
}
const briefDir = (prompt: string) => /Workspace: the checkout under review is (.+?)\. Your shell and file tools/.exec(prompt)?.[1] ?? '';
function host(dir: string, env: NodeJS.ProcessEnv, o: { output?: (title: string) => string; reportFrom?: (title: string) => string; fail?: (title: string) => boolean; reject?: (title: string) => boolean; createThrows?: (title: string) => 'before' | 'after' | undefined; pollsToFinish?: number; lateSummary?: boolean } = {}) {
  let clock = 0;
  const subs = new Map<string, Sub>();
  const creates: Sub[] = [];
  const starts: number[][] = [];
  const reply = (s: Sub) => treeLine(o.reportFrom?.(s.title) ?? briefDir(s.prompt)) + (o.output?.(s.title) ?? cleanReply(s.title));
  const advance = () => {
    for (const s of subs.values()) {
      if (s.late && !s.summary) { s.summary = reply(s); continue; }
      if (s.status !== 'working') continue;
      if (++s.polls < (o.pollsToFinish ?? 1)) continue;
      if (o.fail?.(s.title)) s.status = 'failed';
      else if (o.lateSummary && !s.late) { s.status = 'done'; s.late = true; }
      else { s.status = 'done'; s.summary = reply(s); }
    }
  };
  const tools = {
    capy: {
      bash: async ({ command }: { command: string }) => {
        const r = spawnSync('bash', ['-c', command], { cwd: dir, env, encoding: 'utf8', timeout: 120_000, maxBuffer: 64 * 1024 * 1024 });
        return { exit_code: r.status ?? 1, output: (r.stdout ?? '') + (r.stderr ?? '') };
      },
      write: async ({ path: p, content }: { path: string; content: string }) => { fs.mkdirSync(path.dirname(p), { recursive: true }); fs.writeFileSync(p, content); return { path: p }; },
    },
    subagent: {
      create: async ({ tasks, start }: { tasks: Array<{ title: string; prompt: string }>; start: { machine: string; model?: unknown } }) => {
        const t = tasks[0]!;
        const mode = o.createThrows?.(t.title);
        if (mode === 'before') throw new Error('create lost before it ran');
        expect(start.machine).toBe('shared');
        const index = subs.size + 1;
        const rejected = !!o.reject?.(t.title) && !creates.some(c => c.title === t.title);
        const s: Sub = { title: t.title, prompt: t.prompt, status: rejected ? 'draft' : 'working', polls: 0, model: start.model };
        subs.set(String(index), s);
        creates.push(s);
        if (mode === 'after') throw new Error('create result lost');
        return { tasks: [{ index, title: t.title }], ...(rejected ? { rejected: [{ index, error: 'cap' }] } : {}) };
      },
      start: async ({ indices, model }: { indices: number[]; model?: unknown }) => { starts.push(indices); for (const i of indices) { const s = subs.get(String(i))!; s.status = 'working'; if (model) s.model = model; } return { started: indices.map(index => ({ index })), rejected: [] }; },
      list: async () => { advance(); return { tasks: [...subs].map(([p, s]) => ({ path: p, title: s.title, status: s.status })), total: subs.size }; },
      get: async ({ path: p }: { path: string }) => ({ path: p, status: subs.get(p)!.status, summary: subs.get(p)!.summary }),
    },
    thread: { get: async () => ({ cost: { tokens: 1000 + clock, credits: 1 + clock / 1000 } }) },
  };
  return { tools, subs, creates, starts, sleep: async (ms: number) => { clock += ms; }, now: async () => 1_000_000 + clock };
}

const PROGRAM = fs.readFileSync(path.join(ROOT, 'lib/capy-review-pass.js'), 'utf8');
const AsyncFunction = Object.getPrototypeOf(async () => {}).constructor as new (...a: string[]) => (...v: unknown[]) => Promise<string>;
async function runPass(h: ReturnType<typeof host>, input: Record<string, unknown>): Promise<string> {
  return new AsyncFunction('tools', 'sleep', 'now', 'input', PROGRAM)(h.tools, h.sleep, h.now, { startedAt: await h.now(), laneModel: 'anthropic/claude-opus-5-5', ...input });
}
const bin = (dir: string, env: NodeJS.ProcessEnv, a: string[]) => spawnSync(path.join(BIN, 'gstack-review-dispatch'), a, { cwd: dir, env, encoding: 'utf8', timeout: 60_000 });

describe('the targeted reader in a pass (GST-257 on main)', () => {
  // Value: protects=a pass whose plan dispatches the targeted reader stages it with Step 11's voices on the merge base, its brief byte for byte the render CLI's, and its ledger row carrying the classes, rules, brief and patch the receipt's review_targeted record reads; fails_when=the manifest refuses or drops the targeted role, renders it on another base, or writes a rendered row verify --targeted-out cannot use;
  //   why_new=#3671 added the targeted reader after PR 2's manifest; seam=none; no_claim=the reader's findings
  test('a secret-path diff stages the targeted reader with the voices, identical to the render CLI, with its targeted ledger fields', () => {
    const { dir, env } = repo();
    const sh = (c: string) => { const r = spawnSync('bash', ['-c', c], { cwd: dir, env, encoding: 'utf8', timeout: 60_000 }); if (r.status !== 0) throw new Error(r.stderr); return r.stdout; };
    sh("echo 'export const apiKeyName = \"X\";' > src/secrets.ts && git add -A && git commit -qm secret");
    const out = path.join(dir, '.state/run/p1');
    const p = bin(dir, env, ['pass', '--base', 'main', '--out', out, '--pass', 't1p1', '--', '--depth-floor', 'full']);
    expect(p.status, p.stdout + p.stderr).toBe(0);
    expect(p.stdout).toMatch(/^DISPATCH: targeted /m);
    const mf = path.join(out, 'pass-manifest.json');
    let m = JSON.parse(fs.readFileSync(mf, 'utf8')) as Manifest;
    const t = m.readers.find(r => r.role === 'targeted')!;
    expect(t).toMatchObject({ reader: 'targeted', stage: 'voices', classes: ['secret'] });
    const mergeBase = sh('git merge-base main HEAD').trim();
    expect(t.diff_base).toBe(mergeBase);
    for (const st of ['specialists', 'red-team']) {
      if (st === 'red-team') expect(bin(dir, env, ['stage', '--manifest', mf, '--stage', st]).status).toBe(0);
      m = JSON.parse(fs.readFileSync(mf, 'utf8')) as Manifest;
      for (const r of m.readers.filter(x => x.stage === st)) for (const [s, extra] of [['intent', []], ['created', ['--path', '1']], ['collected', []]] as const) expect(bin(dir, env, ['mark', '--manifest', mf, '--reader', r.reader, '--state', s, ...extra]).status).toBe(0);
    }
    const v = bin(dir, env, ['stage', '--manifest', mf, '--stage', 'voices']);
    expect(v.status, v.stdout + v.stderr).toBe(0);
    m = JSON.parse(fs.readFileSync(mf, 'utf8')) as Manifest;
    const staged = m.readers.find(r => r.role === 'targeted')!;
    const cli = bin(dir, env, ['render', '--role', 'targeted', '--classes', 'secret', '--base', 'main', '--diff-base', mergeBase, '--out', path.join(dir, '.state/cli'), '--stack', m.stack, '--test-fw', m.test_fw, ...(staged.exclude ? ['--exclude', staged.exclude] : [])]);
    expect(cli.status, cli.stdout + cli.stderr).toBe(0);
    expect(cli.stdout).toContain('sha256=' + staged.sha256);
    const row = fs.readFileSync(m.ledger, 'utf8').trim().split('\n').map(l => JSON.parse(l)).find(e => e.event === 'rendered' && e.reader === 'targeted');
    const cliRow = fs.readFileSync(path.join(dir, '.state/cli/review-ledger.jsonl'), 'utf8').trim().split('\n').map(l => JSON.parse(l)).at(-1);
    for (const k of ['classes', 'rules', 'brief_sha', 'diff_base', 'patch_id', 'sha256']) expect(row[k]).toEqual(cliRow[k]);
  }, 180_000);
});

describe('a large diff (GST-507)', () => {
  // Value: protects=a pass on a results PR with thousands of files reads gstack-review-plan's whole JSON plan through the pipe and stages its readers; fails_when=either bin exits before its stdout drains, so the plan JSON arrives cut short and pass dies on JSON.parse;
  //   why_new=HARN-1 hit it on a 4,000-file receipt tree (a 1.39 MB plan); seam=none; no_claim=what reviewers read on a large diff (GST-508)
  test('a 4,000-file diff round-trips a plan JSON over 1 MB and pass stages its readers', () => {
    const { dir, env } = repo();
    const files = 4000;
    const made = spawnSync('bash', ['-c', `for d in $(seq 1 40); do p=receipts/harness-evals-lane-b-results-run-$d/per-case-receipts/skill-behavior-panel; mkdir -p $p; for i in $(seq 1 100); do echo "{\\"case\\":$i}" > $p/receipt-for-case-number-$i-trial-a.json; done; done && git add -A && git commit -qm receipts`], { cwd: dir, env, encoding: 'utf8', timeout: 120_000 });
    expect(made.status, made.stderr).toBe(0);
    const plan = spawnSync(path.join(BIN, 'gstack-review-plan'), ['--base', 'main', '--json'], { cwd: dir, env, encoding: 'utf8', timeout: 120_000, maxBuffer: 64 * 1024 * 1024 });
    expect(plan.status, plan.stderr).toBe(0);
    expect(plan.stdout.length).toBeGreaterThan(1_000_000);
    expect((JSON.parse(plan.stdout) as { paths: string[] }).paths.filter(p => p.startsWith('receipts/'))).toHaveLength(files);
    const out = path.join(dir, '.state/run/p1');
    const p = spawnSync(path.join(BIN, 'gstack-review-dispatch'), ['pass', '--base', 'main', '--out', out, '--pass', 'big-p1'], { cwd: dir, env, encoding: 'utf8', timeout: 180_000 });
    expect(p.status, p.stdout + p.stderr).toBe(0);
    expect(p.stdout).toMatch(/^MANIFEST: file=.* pass=big-p1 readers=[1-9]/m);
  }, 300_000);
});

describe('Capy pass program (fake host, real bins)', () => {
  test('gstack-review-dispatch program serves the checked-in file verbatim with its sha', () => {
    const r = spawnSync(path.join(BIN, 'gstack-review-dispatch'), ['program'], { encoding: 'utf8', timeout: 30_000 });
    const [head, body] = r.stdout.split('\n');
    expect(head).toBe('PROGRAM: v1 sha256=' + promptHash(PROGRAM) + ' bytes=' + Buffer.byteLength(PROGRAM));
    expect(JSON.parse(body!)).toBe(PROGRAM);
  });

  test('one pass: specialists, then the Red Team on their collected lines; every prompt is the rendered brief; the ledger verifies clean', async () => {
    const { dir, env } = repo();
    const out = path.join(dir, '.state/run/p1');
    const h = host(dir, env, { output: t => (t.endsWith('specialist-batched') ? 'High: src/a.ts:3 the export is untested' : 'NO FINDINGS') });
    const medium = { model_id: 'anthropic/claude-opus-5-5', reasoning_mode: 'medium' };
    const res = await runPass(h, { base: 'main', out, pass: 'x1p1', planFlags: ['--depth-floor', 'full'], models: { specialist: medium, 'red-team': medium } });
    expect(h.creates.every(c => JSON.stringify(c.model) === JSON.stringify(medium))).toBe(true);
    expect(res).toContain('NEXT: judge (Phase 4)');
    const m = JSON.parse(fs.readFileSync(path.join(out, 'pass-manifest.json'), 'utf8')) as Manifest;
    const active = m.readers.filter(r => r.stage !== 'voices');
    expect(h.creates.map(c => c.title)).toEqual(active.map(r => r.title));
    expect(h.creates.at(-1)!.title).toBe('ship x1p1 red-team');
    for (const r of active) expect(h.creates.find(c => c.title === r.title)!.prompt).toBe(fs.readFileSync(r.file!, 'utf8'));
    expect(h.creates.at(-1)!.prompt).toContain('the export is untested');
    expect(active.every(r => r.state === 'collected')).toBe(true);
    const merged = fs.readFileSync(m.merged, 'utf8').trim().split('\n').map(l => JSON.parse(l) as { id: string; label: string });
    fs.writeFileSync(path.join(out, 'judged.jsonl'), merged.map(l => JSON.stringify({ id: l.id, severity: l.label }) + '\n').join(''));
    expect(bin(dir, env, ['judge', '--ledger', m.ledger, '--merged', m.merged, '--judged', path.join(out, 'judged.jsonl')]).status).toBe(0);
    const v = bin(dir, env, ['verify', '--ledger', m.ledger]);
    expect(v.stdout).toContain('VERIFY: clean briefs=' + active.length);
  }, 180_000);

  test('a pass past its 200 s window returns NEXT: poll and the rerun resumes without creating any reader twice', async () => {
    const { dir, env } = repo();
    const out = path.join(dir, '.state/run/p1');
    const h = host(dir, env, { pollsToFinish: 30 });
    const first = await runPass(h, { base: 'main', out, pass: 'x2p1', planFlags: ['--depth-floor', 'full'], logStart: ['review'] });
    expect(first).toContain('NEXT: poll');
    expect(first).toMatch(/REVIEW_LOG_START: review token=\S+/);
    expect(first).toMatch(/RUNNING: specialist-batched state=created path=1/);
    const created = h.creates.length;
    let res = '';
    for (let i = 0; i < 6 && !res.includes('NEXT: judge'); i++) res = await runPass(h, { base: 'main', out, pass: 'x2p1', planFlags: ['--depth-floor', 'full'], logStart: ['review'] });
    expect(res).toContain('NEXT: judge');
    expect(res).not.toContain('REVIEW_PLAN:');
    expect(res).not.toContain('REVIEW_LOG_START:');
    expect(new Set(h.creates.map(c => c.title)).size).toBe(h.creates.length);
    expect(h.creates.length).toBe(created + 1);
  }, 240_000);

  test('a create whose result was lost is reconciled by title on resume; a create that never ran stops the pass as ambiguous', async () => {
    const { dir, env } = repo();
    let lost = true;
    const h = host(dir, env, { createThrows: t => (t.endsWith('specialist-batched') && lost ? (lost = false, 'after') : undefined) });
    const input = { base: 'main', out: path.join(dir, '.state/run/p1'), pass: 'x3p1', planFlags: ['--depth-floor', 'full'] };
    expect(await runPass(h, input)).toContain('STOP: pass program error: create result lost');
    expect(await runPass(h, input)).toContain('NEXT: judge');
    expect(h.creates.filter(c => c.title === 'ship x3p1 specialist-batched')).toHaveLength(1);

    const b = repo();
    const h2 = host(b.dir, b.env, { createThrows: t => (t.endsWith('specialist-batched') ? 'before' : undefined) });
    const input2 = { ...input, out: path.join(b.dir, '.state/run/p1'), pass: 'x4p1' };
    expect(await runPass(h2, input2)).toContain('create lost before it ran');
    const again = await runPass(h2, input2);
    expect(again).toContain('STOP: specialist-batched was being created when the last program ended and 0 subagents carry its title');
  }, 240_000);

  test('a failed reader stops the pass before the Red Team; a reader refused at the cap is queued and started later', async () => {
    const { dir, env } = repo();
    const h = host(dir, env, { fail: t => t.endsWith('specialist-batched') });
    const res = await runPass(h, { base: 'main', out: path.join(dir, '.state/run/p1'), pass: 'x5p1', planFlags: ['--depth-floor', 'full'] });
    expect(res).toMatch(/STOP: specialist-batched \(subagent \d+\) failed/);
    expect(h.creates.some(c => c.title.endsWith('red-team'))).toBe(false);

    const b = repo();
    const h2 = host(b.dir, b.env, { reject: t => t.endsWith('specialist-batched') });
    const res2 = await runPass(h2, { base: 'main', out: path.join(b.dir, '.state/run/p1'), pass: 'x6p1', planFlags: ['--depth-floor', 'full'] });
    expect(res2).toContain('DISPATCHED: specialist-batched path=1 queued');
    expect(res2).toContain('NEXT: judge');
    expect(h2.starts).toEqual([[1]]);
  }, 240_000);

  // Value: protects=Step 11.5 always has an adversarial-review start token to bind; fails_when=Step 11 reuses the pass input's logStart: ["review"] and runs the voices with no adversarial-review start, or a missing token is found only after the voices ran;
  //   why_new=GBRA-218 reran a whole pass after the loader example's logStart was reused for stage voices; seam=lib/capy-review-pass.js log starts; no_claim=gstack-review-read's binding itself
  test('Step 11 takes the adversarial-review start token by default and refuses a list without it before anything runs', async () => {
    const { dir, env } = repo();
    const out = path.join(dir, '.state/run/p1');
    const h = host(dir, env);
    const models = { 'outside-voice': { model_id: 'openai/gpt-6.1-sol' } };
    const base = { base: 'main', out, pass: 'x12p1', planFlags: ['--depth-floor', 'full'], logStart: ['review'] };
    expect(await runPass(h, base)).toContain('NEXT: judge (Phase 4)');
    const created = h.creates.length;
    const reused = await runPass(h, { ...base, stage: 'voices', models });
    expect(reused).toStartWith('STOP: Step 11 (stage "voices") takes the adversarial-review start token');
    expect(h.creates.length).toBe(created);
    const voices = await runPass(h, { ...base, logStart: undefined, stage: 'voices', models });
    expect(voices).toMatch(/REVIEW_LOG_START: adversarial-review token=\S+/);
    expect(voices.indexOf('REVIEW_LOG_START: adversarial-review')).toBeLessThan(voices.indexOf('DISPATCHED:'));
    expect(voices).toContain('NEXT: judge the voices');
    const m = JSON.parse(fs.readFileSync(path.join(out, 'pass-manifest.json'), 'utf8'));
    expect(Object.keys(m.log_starts ?? {}).sort()).toEqual(['pass:review', 'voices:adversarial-review']);
  }, 240_000);

  test('Step 11 voices run from the same manifest; the outside voice needs a model of another family', async () => {
    const { dir, env } = repo();
    const out = path.join(dir, '.state/run/p1');
    const h = host(dir, env);
    const base = { base: 'main', out, pass: 'x7p1', planFlags: ['--depth-floor', 'full'] };
    expect(await runPass(h, base)).toContain('NEXT: judge (Phase 4)');
    expect(await runPass(h, { ...base, stage: 'voices', laneModel: undefined })).toContain("STOP: the outside voice needs input.models['outside-voice']");
    expect(h.creates.some(c => c.title.startsWith('ship x7p1 ') && /adversarial|outside/.test(c.title))).toBe(false);
    const models = { 'outside-voice': { model_id: 'openai/gpt-6.1-sol' }, 'adversarial-native': { model_id: 'anthropic/claude-opus-5-5', reasoning_mode: 'high' } };
    expect(await runPass(h, { ...base, stage: 'voices', models })).toContain('NEXT: judge the voices');
    expect(h.creates.find(c => c.title === 'ship x7p1 outside-voice')!.model).toEqual(models['outside-voice']);
    expect(h.creates.find(c => c.title === 'ship x7p1 adversarial-native')!.model).toEqual(models['adversarial-native']);
  }, 240_000);

  // Value: protects=Step 11's outside voice is never the native voice's or the lane's model family; fails_when=the STOP checks only that some model was given (lib/capy-review-pass.js before GSTA-167 PR B), so a Claude outside voice beside a Claude native voice runs as "outside";
  //   why_new=GSTA-167 plan R2 (autoplan-20261031135232); seam=none; no_claim=which family pairs find more
  test('a same-family explicit outside voice STOPs before either voice is created', async () => {
    const { dir, env } = repo();
    const h = host(dir, env);
    const base = { base: 'main', out: path.join(dir, '.state/run/p1'), pass: 'x14p1', planFlags: ['--depth-floor', 'full'] };
    expect(await runPass(h, base)).toContain('NEXT: judge (Phase 4)');
    expect(await runPass(h, { ...base, stage: 'voices', models: { 'outside-voice': { model_id: 'anthropic/claude-sonnet-5-5', reasoning_mode: 'medium' } } }))
      .toContain("STOP: the outside voice anthropic/claude-sonnet-5-5 is the anthropic family, the same as the lane model; Step 11 needs input.models['outside-voice'] from another family");
    expect(await runPass(h, { ...base, stage: 'voices', models: { 'outside-voice': { model_id: 'openai/gpt-6.1-sol', reasoning_mode: 'medium' }, 'adversarial-native': { model_id: 'openai/gpt-6-astra', reasoning_mode: 'high' } } }))
      .toContain('STOP: the outside voice openai/gpt-6.1-sol is the openai family, the same as the native voice');
    expect(h.creates.some(c => /^ship x14p1 (adversarial-native|outside-voice)$/.test(c.title))).toBe(false);
  }, 240_000);

  // Value: protects=a Step 11 rerun on one manifest keeps refusing a same-family outside voice, including one queued at the subagent cap that tools.subagent.start would pick up; fails_when=the family check runs only on the first render, so a resumed or queued voice starts unchecked;
  //   why_new=GSTA-167 plan R2; seam=none; no_claim=the host's cap timing
  test('a Step 11 rerun on one manifest still refuses a same-family outside voice, rendered or queued', async () => {
    const same = { 'outside-voice': { model_id: 'anthropic/claude-sonnet-5-5', reasoning_mode: 'medium' } };
    const refused = /STOP: the outside voice anthropic\/claude-sonnet-5-5 is the anthropic family/;
    const { dir, env } = repo();
    const h = host(dir, env);
    const base = { base: 'main', out: path.join(dir, '.state/run/p1'), pass: 'x15p1', planFlags: ['--depth-floor', 'full'] };
    expect(await runPass(h, base)).toContain('NEXT: judge (Phase 4)');
    expect(await runPass(h, { ...base, stage: 'voices', models: same })).toMatch(refused);
    expect(await runPass(h, { ...base, stage: 'voices', models: same })).toMatch(refused);
    expect(h.creates.some(c => /^ship x15p1 (adversarial-native|outside-voice)$/.test(c.title))).toBe(false);

    const b = repo();
    const h2 = host(b.dir, b.env, { reject: t => t.endsWith('outside-voice') });
    const base2 = { ...base, out: path.join(b.dir, '.state/run/p1'), pass: 'x18p1' };
    expect(await runPass(h2, base2)).toContain('NEXT: judge (Phase 4)');
    expect(await runPass(h2, { ...base2, stage: 'voices', budgetMs: 1 })).toMatch(/DISPATCHED: outside-voice path=\d+ queued/);
    const starts = h2.starts.length;
    const recorded = path.join(base2.out, 'voice-models.json');
    const kept = fs.readFileSync(recorded, 'utf8');
    fs.rmSync(recorded);
    expect(await runPass(h2, { ...base2, stage: 'voices', models: same })).toMatch(refused);
    expect(h2.starts.length).toBe(starts);
    fs.writeFileSync(recorded, kept);
    const resumed = await runPass(h2, { ...base2, stage: 'voices', models: same });
    expect(resumed).toContain('OUTSIDE_VOICE: openai/gpt-6.1-sol reasoning=medium as dispatched, started from the queue (certified configuration)');
    expect(h2.creates.find(c => c.title === 'ship x18p1 outside-voice')!.model).toEqual({ model_id: 'openai/gpt-6.1-sol', reasoning_mode: 'medium' });
  }, 300_000);

  // Value: protects=a queued outside voice resumes on the models recorded when the voices were dispatched, so changed rerun inputs cannot pair it with a native voice of its own family; fails_when=the rerun's input decides the queued voice's model and the native family (outside-voice finding on #3698: two OpenAI voices started);
  //   why_new=/ship Step 11 review of #3698; seam=none; no_claim=inputs that change between reruns on purpose
  test('a queued outside voice resumes on its dispatched model, checked against the dispatched native family', async () => {
    const { dir, env } = repo();
    const h = host(dir, env, { reject: t => t.endsWith('outside-voice') });
    const base = { base: 'main', out: path.join(dir, '.state/run/p1'), pass: 'x19p1', planFlags: ['--depth-floor', 'full'] };
    expect(await runPass(h, base)).toContain('NEXT: judge (Phase 4)');
    const first = { 'adversarial-native': { model_id: 'openai/gpt-6-astra', reasoning_mode: 'high' }, 'outside-voice': { model_id: 'google/gemini-4-argon', reasoning_mode: 'medium' } };
    expect(await runPass(h, { ...base, stage: 'voices', models: first, budgetMs: 1 })).toMatch(/DISPATCHED: outside-voice path=\d+ queued/);
    const res = await runPass(h, { ...base, stage: 'voices' });
    expect(res).not.toContain('STOP:');
    expect(res).toContain('OUTSIDE_VOICE: google/gemini-4-argon reasoning=medium as dispatched, started from the queue; outside the certified configuration');
    expect(h.creates.find(c => c.title === 'ship x19p1 outside-voice')!.model).toEqual(first['outside-voice']);
    expect(h.creates.find(c => c.title === 'ship x19p1 adversarial-native')!.model).toEqual(first['adversarial-native']);
  }, 300_000);

  // Value: protects=a lane whose family is unknown or not Anthropic gets no default outside voice, and an explicit one cannot skip the family check; fails_when=the pin applies to a lane it was not certified for, or an outside voice runs with nothing to compare its family to;
  //   why_new=GSTA-167 plan R2; seam=none; no_claim=an OpenAI lane's pairing, which is uncertified
  test('a missing lane identity STOPs the outside voice: none given, or given with nothing to compare its family to', async () => {
    const { dir, env } = repo();
    const h = host(dir, env);
    const base = { base: 'main', out: path.join(dir, '.state/run/p1'), pass: 'x16p1', planFlags: ['--depth-floor', 'full'] };
    expect(await runPass(h, base)).toContain('NEXT: judge (Phase 4)');
    const none = "STOP: the outside voice needs input.models['outside-voice'] (a model of another family); none was given";
    expect(await runPass(h, { ...base, stage: 'voices', laneModel: undefined })).toContain(none);
    expect(await runPass(h, { ...base, stage: 'voices', laneModel: 'openai/gpt-6.1-sol' })).toContain(none);
    expect(await runPass(h, { ...base, stage: 'voices', laneModel: undefined, models: { 'outside-voice': { model_id: 'openai/gpt-6.1-sol', reasoning_mode: 'medium' } } }))
      .toContain('STOP: the outside voice openai/gpt-6.1-sol cannot be checked against another family: neither input.laneModel nor a native voice model was given');
    expect(await runPass(h, { ...base, stage: 'voices', models: { 'outside-voice': { model_id: 'claude-sonnet-5-5' } } }))
      .toContain('STOP: the outside voice claude-sonnet-5-5 has no provider prefix, so its family cannot be checked');
    expect(await runPass(h, { ...base, stage: 'voices', models: { 'outside-voice': { model_id: 'Anthropic/claude-sonnet-5-5' } } }))
      .toContain('STOP: the outside voice Anthropic/claude-sonnet-5-5 is the anthropic family, the same as the lane model');
    expect(await runPass(h, { ...base, stage: 'voices', laneModel: 'claude-opus-5-5', models: { 'outside-voice': { model_id: 'openai/gpt-6.1-sol' } } }))
      .toContain('STOP: the outside voice openai/gpt-6.1-sol cannot be checked against another family: the lane model claude-opus-5-5 has no provider prefix and no native voice model was given');
    expect(h.creates.some(c => /^ship x16p1 (adversarial-native|outside-voice)$/.test(c.title))).toBe(false);
  }, 240_000);

  const certified = { model_id: 'openai/gpt-6.1-sol', reasoning_mode: 'medium' };
  async function voicesRun(dir: string, env: NodeJS.ProcessEnv, sub: string, models?: Record<string, unknown>) {
    const out = path.join(dir, '.state/run', sub);
    const h = host(dir, env);
    const base = { base: 'main', out, pass: 'x17p1', planFlags: ['--depth-floor', 'full'] };
    expect(await runPass(h, base)).toContain('NEXT: judge (Phase 4)');
    const res = await runPass(h, { ...base, stage: 'voices', ...(models ? { models } : {}) });
    const m = JSON.parse(fs.readFileSync(path.join(out, 'pass-manifest.json'), 'utf8')) as Manifest;
    for (const r of m.readers) expect(h.creates.find(c => c.title === r.title)!.prompt).toBe(fs.readFileSync(r.file!, 'utf8'));
    const shas = Object.fromEntries(h.creates.map(c => [c.title, promptHash(c.prompt.split(out).join('<out>'))]));
    return { res, shas, models: Object.fromEntries(h.creates.map(c => [c.title, c.model])) };
  }

  // Value: protects=an Anthropic lane's Step 11 gets the certified outside voice (openai/gpt-6.1-sol at medium, as rounds 3-6 and A3668 ran) without naming it, and every brief goes out byte for byte as it does with that model named; fails_when=the lane must pick the outside voice (gpt-6-astra in 6c/7e/8g), or the pin changes any reader's brief or another reader's model;
  //   why_new=GSTA-167 plan R2; seam=none; no_claim=the certified pair's recall, which arm-L6 measured
  test('an anthropic lane defaults the outside voice to the certified model, with every brief byte-identical to naming it', async () => {
    const { dir, env } = repo();
    const pinned = await voicesRun(dir, env, 'pin');
    expect(pinned.res).toContain('OUTSIDE_VOICE: openai/gpt-6.1-sol reasoning=medium default for an anthropic lane (certified configuration)');
    expect(pinned.res).toContain('NEXT: judge the voices');
    expect(pinned.models['ship x17p1 outside-voice']).toEqual(certified);
    const named = await voicesRun(dir, env, 'named', { 'outside-voice': certified });
    expect(named.res).toContain('OUTSIDE_VOICE: openai/gpt-6.1-sol reasoning=medium given (certified configuration)');
    expect(named.shas).toEqual(pinned.shas);
    expect(named.models).toEqual(pinned.models);
  }, 300_000);

  // Value: protects=an explicit cross-family override is accepted but its pass output says it is outside the certified configuration; fails_when=a changed outside-voice model or reasoning passes silently as if certified;
  //   why_new=GSTA-167 plan R2; seam=none; no_claim=the uncertified configuration's recall
  test('an explicit outside-voice override with changed reasoning runs and is recorded as uncertified, other briefs unchanged', async () => {
    const { dir, env } = repo();
    const high = { model_id: 'openai/gpt-6.1-sol', reasoning_mode: 'high' };
    const over = await voicesRun(dir, env, 'over', { 'outside-voice': high });
    expect(over.res).toContain('OUTSIDE_VOICE: openai/gpt-6.1-sol reasoning=high given; outside the certified configuration (openai/gpt-6.1-sol at medium beside an anthropic lane)');
    expect(over.res).toContain('NEXT: judge the voices');
    expect(over.models['ship x17p1 outside-voice']).toEqual(high);
    const named = await voicesRun(dir, env, 'named', { 'outside-voice': certified });
    expect(over.shas).toEqual(named.shas);
    for (const t of Object.keys(named.models)) if (t !== 'ship x17p1 outside-voice') expect(over.models[t]).toEqual(named.models[t]);
  }, 300_000);

  test('an audit reader marked first settles before any specialist starts; its output is returned, never merged', async () => {
    const { dir, env } = repo();
    const out = path.join(dir, '.state/run/p1');
    fs.mkdirSync(out, { recursive: true });
    fs.writeFileSync(path.join(out, 'coverage.prompt.md'), 'Run Step 7 as written.\n');
    fs.writeFileSync(path.join(out, 'extras.json'), JSON.stringify([{ name: 'coverage', prompt_file: path.join(out, 'coverage.prompt.md'), first: true, model: { model_id: 'anthropic/claude-sonnet-5-5', reasoning_mode: 'low' } }]));
    const h = host(dir, env, { output: t => (t.endsWith('audit/coverage') ? 'Coverage: 80% (one test added)' : 'NO FINDINGS') });
    const res = await runPass(h, { base: 'main', out, pass: 'x8p1', planFlags: ['--depth-floor', 'full'], extras: path.join(out, 'extras.json') });
    expect(h.creates[0]!.title).toBe('ship x8p1 audit/coverage');
    expect(h.creates[0]!.prompt).toBe(withWorkspace('Run Step 7 as written.\n', fs.realpathSync(dir)));
    expect(res).toContain('Coverage: 80% (one test added)');
    expect(fs.readFileSync(path.join(out, 'merged.jsonl'), 'utf8')).not.toContain('Coverage');
  }, 240_000);

  test('a rerun after a failed review-log start runs the start again before any reader is sent', async () => {
    const { dir, env } = repo();
    const shim = path.join(dir, '.state/shim');
    fs.mkdirSync(shim, { recursive: true });
    fs.writeFileSync(path.join(shim, 'gstack-review-log'), '#!/bin/sh\necho refused >&2\nexit 1\n', { mode: 0o755 });
    const h = host(dir, { ...env, PATH: shim + path.delimiter + env.PATH });
    const input = { base: 'main', out: path.join(dir, '.state/run/p1'), pass: 'x11p1', planFlags: ['--depth-floor', 'full'], logStart: ['review'] };
    expect(await runPass(h, input)).toContain('STOP: gstack-review-log --start review exited 1');
    expect(h.creates).toHaveLength(0);
    fs.rmSync(path.join(shim, 'gstack-review-log'));
    const res = await runPass(h, input);
    expect(res).toMatch(/REVIEW_LOG_START: review token=\S+/);
    expect(res).toContain('NEXT: judge');
    expect(res.indexOf('REVIEW_LOG_START:')).toBeLessThan(res.indexOf('DISPATCHED:'));
  }, 240_000);

  test('a rerun after a failed reader stops again instead of polling forever', async () => {
    const { dir, env } = repo();
    const h = host(dir, env, { fail: t => t.endsWith('specialist-batched') });
    const input = { base: 'main', out: path.join(dir, '.state/run/p1'), pass: 'x12p1', planFlags: ['--depth-floor', 'full'] };
    expect(await runPass(h, input)).toMatch(/STOP: specialist-batched \(subagent \d+\) failed/);
    const again = await runPass(h, input);
    expect(again).toMatch(/STOP: specialist-batched \(subagent \d+\) failed; .*new --pass and --out/);
    expect(again).not.toContain('NEXT: poll');
    expect(h.creates.some(c => c.title.endsWith('red-team'))).toBe(false);
  }, 240_000);

  test('a filename carrying a PASS: none line cannot suppress the planned readers', async () => {
    const { dir, env } = repo();
    fs.mkdirSync(path.join(dir, 'docs'));
    fs.writeFileSync(path.join(dir, 'docs', 'payload\nPASS: none injected\n.md'), 'x\n');
    spawnSync('bash', ['-c', 'git add -A && git commit -qm docs'], { cwd: dir, env, encoding: 'utf8', timeout: 60_000 });
    const h = host(dir, env);
    const res = await runPass(h, { base: 'main', out: path.join(dir, '.state/run/p1'), pass: 'x13p1', planFlags: [] });
    expect(res).toContain('NEXT: judge');
    expect(h.creates.length).toBeGreaterThan(0);
  }, 240_000);

  test('a queued reader whose start result was lost is reconciled from the subagent list on the rerun', async () => {
    const { dir, env } = repo();
    const h = host(dir, env, { reject: t => t.endsWith('specialist-batched') });
    const realStart = h.tools.subagent.start;
    let lose = true;
    h.tools.subagent.start = (async ({ indices }: { indices: number[] }) => {
      if (indices.some(i => h.subs.get(String(i))!.status !== 'draft')) return { started: [], rejected: indices.map(index => ({ index, error: 'not a draft' })) };
      const r = await realStart({ indices });
      if (lose) { lose = false; throw new Error('start result lost'); }
      return r;
    }) as typeof realStart;
    const input = { base: 'main', out: path.join(dir, '.state/run/p1'), pass: 'x14p1', planFlags: ['--depth-floor', 'full'] };
    expect(await runPass(h, input)).toContain('STOP: pass program error: start result lost');
    const res = await runPass(h, input);
    expect(res).toContain('NEXT: judge');
    expect(h.creates.filter(c => c.title === 'ship x14p1 specialist-batched')).toHaveLength(1);
  }, 240_000);

  test('a budget note that stops the run stops the pass instead of ending on NEXT: judge', async () => {
    const { dir, env } = repo();
    const rec = path.join(dir, '.state/rec.md');
    fs.mkdirSync(path.dirname(rec), { recursive: true });
    const s = spawnSync('bash', ['-c', 'gstack-ship-budget start --record "$1" --mode observe --token-cap 5000000 --reading 1000 --credits 1', '_', rec], { cwd: dir, env, encoding: 'utf8', timeout: 60_000 });
    expect(s.status).toBe(0);
    const h = host(dir, env);
    h.tools.thread.get = async () => ({ cost: { tokens: 90_000_000, credits: 50 } });
    const res = await runPass(h, { base: 'main', out: path.join(dir, '.state/run/p1'), pass: 'x15p1', planFlags: ['--depth-floor', 'full'], record: rec, jam: 'jam_test', step: '9' });
    expect(res).toMatch(/STOP:.*budget/);
    expect(res).not.toContain('NEXT: judge');
  }, 240_000);

  test('Step 14.5 runs as an audit-only pass: its docs reader alone, verbatim, with no reviewer plan', async () => {
    const { dir, env } = repo();
    const out = path.join(dir, '.state/run/docs');
    fs.mkdirSync(out, { recursive: true });
    fs.writeFileSync(path.join(out, 'docs.prompt.md'), 'Run Step 14.5 as written.\n');
    const extras = [{ name: 'docs', prompt_file: path.join(out, 'docs.prompt.md'), first: true }];
    const h = host(dir, env, { output: t => (t.endsWith('audit/docs') ? 'DOCS: README updated' : 'NO FINDINGS') });
    const res = await runPass(h, { base: 'main', out, pass: 'x16docs', step: '14.5', extras });
    expect(h.creates.map(c => c.title)).toEqual(['ship x16docs audit/docs']);
    expect(h.creates[0]!.prompt).toBe(withWorkspace('Run Step 14.5 as written.\n', fs.realpathSync(dir)));
    expect(res).toContain('DOCS: README updated');
    expect(res).toContain('NEXT: apply the docs audit (Step 14.5)');
    expect(bin(dir, env, ['pass', '--base', 'main', '--out', path.join(dir, '.state/run/d2'), '--pass', 'x16b', '--audit-only']).status).not.toBe(0);
  }, 240_000);

  test('Step 11 notes its own growth from its first dispatch, not from the pass\'s starting reading', async () => {
    const { dir, env } = repo();
    const rec = path.join(dir, '.state/rec.md');
    fs.mkdirSync(path.dirname(rec), { recursive: true });
    expect(spawnSync('bash', ['-c', 'gstack-ship-budget start --record "$1" --mode observe --reading 1000 --credits 1', '_', rec], { cwd: dir, env, encoding: 'utf8', timeout: 60_000 }).status).toBe(0);
    const h = host(dir, env, { pollsToFinish: 3 });
    const get = h.tools.thread.get;
    let last = 0;
    h.tools.thread.get = async () => { const r = await get(); last = r.cost.tokens; return r; };
    const out = path.join(dir, '.state/run/p1');
    const base = { base: 'main', out, pass: 'x17p1', planFlags: ['--depth-floor', 'full'], record: rec, jam: 'jam_test' };
    expect(await runPass(h, { ...base, step: '9' })).toContain('NEXT: judge (Phase 4)');
    const models = { 'outside-voice': { model_id: 'openai/gpt-6.1-sol' }, 'adversarial-native': { model_id: 'anthropic/claude-opus-5-5', reasoning_mode: 'high' } };
    const res = await runPass(h, { ...base, step: '11', stage: 'voices', models });
    const m = JSON.parse(fs.readFileSync(path.join(out, 'pass-manifest.json'), 'utf8'));
    expect(m.before_voices.tokens).toBeGreaterThan(m.before.tokens);
    const note = res.split('\n').find(l => l.startsWith('NOTE: '))!;
    expect(Number(note.match(/readers_tokens=(\d+)/)![1])).toBe(last - m.before_voices.tokens);
  }, 240_000);

  test('effort=medium readers run the lane model at medium reasoning; without laneModel or models the pass stops before creating any', async () => {
    const { dir, env } = repo();
    const h = host(dir, env);
    const base = { base: 'main', out: path.join(dir, '.state/run/p1'), pass: 'x11p1', planFlags: ['--depth-floor', 'full'] };
    expect(await runPass(h, { ...base, laneModel: undefined })).toMatch(/STOP: specialist\S* runs at effort=medium, which needs input.laneModel/);
    expect(h.creates).toHaveLength(0);
    expect(await runPass(h, base)).toContain('NEXT: judge (Phase 4)');
    const m = JSON.parse(fs.readFileSync(path.join(base.out, 'pass-manifest.json'), 'utf8')) as Manifest;
    for (const r of m.readers.filter(x => x.stage !== 'voices')) {
      const want = r.effort === 'medium' ? { model_id: 'anthropic/claude-opus-5-5', reasoning_mode: 'medium' } : undefined;
      expect(h.creates.find(c => c.title === r.title)!.model).toEqual(want);
    }
    expect(m.readers.some(r => r.effort === 'medium')).toBe(true);
  }, 180_000);

  // Value: protects=once Phase 2 starts the run's parts, the pass program carries the next phase's section parts in the room its own return leaves, so Phase 4 needs no read call of its own, and it never adds them to a run that did not start them; fails_when=the pass returns parts without a started run, overruns 32 KB, puts them after its NEXT line, or repeats a part a poll return already carried;
  //   why_new=GSTA-167 calls plan C5 in code; seam=none; no_claim=how much room real reader outputs leave
  test('a started run gets the next parts inside each poll and the finished pass, once each and before NEXT', async () => {
    const { dir, env } = repo();
    const out = path.join(dir, '.state/run/p1');
    const h = host(dir, env, { pollsToFinish: 30 });
    const input = { base: 'main', out, pass: 'x12p1', planFlags: ['--depth-floor', 'full'] };
    expect(await runPass(h, input)).not.toContain('PART: ');
    fs.mkdirSync(path.join(dir, '.state/run/parts'), { recursive: true });
    fs.writeFileSync(path.join(dir, '.state/run/parts/state.json'), JSON.stringify({ returned: ['review-9', 'review-9.1', 'review-red-team', 'review-9.2.1'] }));
    const ids: string[] = [];
    let res = '';
    for (let i = 0; i < 8 && !res.includes('NEXT: judge'); i++) {
      res = await runPass(h, input);
      expect(res.length).toBeLessThanOrEqual(32000);
      const got = [...res.matchAll(/^PART: (\S+) /gm)].map(m => m[1]!);
      if (got.length) expect(res.lastIndexOf('PART_END: ')).toBeLessThan(res.lastIndexOf('\nNEXT: '));
      ids.push(...got);
    }
    expect(res).toContain('NEXT: judge (Phase 4)');
    expect(ids.length).toBeGreaterThan(0);
    expect(new Set(ids).size).toBe(ids.length);
    expect(ids[0]).toBe('plan-8.1-8.2');
  }, 240_000);

  // Value: protects=the loader's input is filled as SKILL.md reads it: extras as JSON, the checkout named by cwd, and a reader whose summary lands a tick after its done status is collected, not stopped; fails_when=extras must be a file path (replay C2-34: BRIEF_RENDER_FAILED [object Object]), the bins run in the jam's directory instead of the checkout (C2-34: a wrapper launch file), or a done reader without its summary yet stops the pass (C2-34: "finished with no output", one extra call);
  //   why_new=replay C2-34 (GSTA-193) on PR 2; seam=none; no_claim=the host's status timing beyond one late summary
  test('extras as JSON, the checkout as cwd, and a late summary all run through without a STOP', async () => {
    const { dir, env } = repo();
    const out = path.join(dir, '.state/run/p1');
    fs.mkdirSync(out, { recursive: true });
    fs.writeFileSync(path.join(out, 'plan.prompt.md'), 'Plan completion brief');
    const h = host(dir, env, { lateSummary: true });
    const res = await runPass(h, { base: 'main', out, pass: 'x13p1', cwd: dir, planFlags: ['--depth-floor', 'full'],
      extras: [{ name: 'plan', prompt_file: path.join(out, 'plan.prompt.md'), model: { model_id: 'anthropic/claude-haiku-5-5', reasoning_mode: 'low' } }] });
    expect(res).not.toContain('STOP:');
    expect(res).toContain('NEXT: judge (Phase 4)');
    expect(h.creates.find(c => c.title === 'ship x13p1 audit/plan')!.prompt).toBe(withWorkspace('Plan completion brief', fs.realpathSync(dir)));
  }, 180_000);

  // Value: protects=Step 9.2.1's probes stay the parent's, as its section says, so QA coverage is never a subagent's refusal; fails_when=the
  //   pass program dispatches a QA extra (C4-36, C5-36: the QA reader refused both passes, "parent-only", and the parent ran the probes after it);
  //   why_new=extras took any prompt (GST-450); seam=the pass program; no_claim=the parent's probes themselves (DRIVER Phase 4)
  test('a QA extra, by name or by its section\'s parent-only brief, stops the pass before any reader is created', async () => {
    const section = fs.readFileSync(path.join(ROOT, 'ship/sections/review-army.md'), 'utf8');
    expect(section).toContain(PARENT_ONLY_QA);
    const brief = section.slice(section.indexOf('### Step 9.2.1'), section.indexOf('### Step 9.3'));
    for (const [name, text] of [['qa', 'QA brief'], ['exploratory', brief]] as const) {
      const { dir, env } = repo();
      const out = path.join(dir, '.state/run/p1');
      fs.mkdirSync(out, { recursive: true });
      fs.writeFileSync(path.join(out, name + '.prompt.md'), text);
      const h = host(dir, env);
      const res = await runPass(h, { base: 'main', out, pass: 'x14p1', planFlags: ['--depth-floor', 'full'],
        extras: [{ name, prompt_file: path.join(out, name + '.prompt.md'), model: { model_id: 'anthropic/claude-haiku-5-5', reasoning_mode: 'low' } }] });
      expect([name, res.includes('STOP:'), res.includes("Step 9.2.1 is the parent's report-only discovery"), h.creates.length]).toEqual([name, true, true, 0]);
    }
  }, 240_000);

  test('decision 3.5 runs in the program: one fix-check reader whose prompt is the render CLI brief byte for byte, sent and collected', async () => {
    const { dir, env } = repo();
    const out = path.join(dir, '.state/run/fc');
    const files = path.join(dir, '.state/fc');
    fs.mkdirSync(files, { recursive: true });
    const fc: Record<string, string> = {};
    for (const [k, v] of [['fix_list', '1. src/a.ts: guard v80\n'], ['hunks', 'diff --git a/src/a.ts b/src/a.ts\n+export const v81 = 81;\n'], ['tests', 'bun test: 3 pass, 0 fail\n'], ['callers', 'none\n']]) { fc[k] = path.join(files, k + '.txt'); fs.writeFileSync(fc[k]!, v!); }
    const planFlags = ['--pass', '1', '--last', 'full', '--fixed-below'];
    const missing = await runPass(host(dir, env), { base: 'main', out: path.join(dir, '.state/run/fc0'), pass: 'x19fc0', planFlags });
    expect(missing).toContain('STOP: gstack-review-dispatch pass exited');
    expect(missing).toContain('the plan dispatches a fix-check: pass needs --fix-list, --hunks and --tests');
    const h = host(dir, env);
    const res = await runPass(h, { base: 'main', out, pass: 'x19fc', planFlags, fixCheck: fc, logStart: ['review-fix-check'] });
    expect(res).toMatch(/REVIEW_LOG_START: review-fix-check token=\S+/);
    expect(res).toContain('NEXT: judge (Phase 4)');
    expect(h.creates.map(c => c.title)).toEqual(['ship x19fc fix-check']);
    const cli = bin(dir, env, ['render', '--role', 'fix-check', '--out', path.join(dir, '.state/cli'), '--fix-list', fc.fix_list!, '--hunks', fc.hunks!, '--tests', fc.tests!, '--callers', fc.callers!]);
    expect(cli.status).toBe(0);
    expect(h.creates[0]!.prompt).toBe(fs.readFileSync(path.join(dir, '.state/cli/fix-check.prompt.md'), 'utf8'));
    expect(h.creates[0]!.prompt).toContain('You are the fix-check reviewer');
    const v = bin(dir, env, ['verify', '--ledger', path.join(out, 'review-ledger.jsonl')]).stdout;
    expect(v).toMatch(/^BRIEF fix-check MATCH rendered=(\w+) sent=\1$/m);
    expect(v).toMatch(/^OUTPUT fix-check MATCH /m);
  }, 240_000);

  test('Step 11 records one start per row it logs, even when two rows share a skill (native and outside adversarial-review)', async () => {
    const { dir, env } = repo();
    const out = path.join(dir, '.state/run/p1');
    const h = host(dir, env);
    const base = { base: 'main', out, pass: 'x20p1', planFlags: ['--depth-floor', 'full'] };
    expect(await runPass(h, base)).toContain('NEXT: judge (Phase 4)');
    const models = { 'outside-voice': { model_id: 'openai/gpt-6.1-sol' }, 'adversarial-native': { model_id: 'anthropic/claude-opus-5-5', reasoning_mode: 'high' } };
    const res = await runPass(h, { ...base, stage: 'voices', models, logStart: ['adversarial-review', 'adversarial-review'] });
    const starts = res.split('\n').filter(l => l.startsWith('REVIEW_LOG_START: adversarial-review'));
    expect(starts.length).toBe(2);
    expect(new Set(starts.map(l => l.split('token=')[1])).size).toBe(2);
    const m = JSON.parse(fs.readFileSync(path.join(out, 'pass-manifest.json'), 'utf8'));
    expect(Object.keys(m.log_starts).sort()).toEqual(['voices:adversarial-review', 'voices:adversarial-review#2']);
    const again = await runPass(h, { ...base, stage: 'voices', models, logStart: ['adversarial-review', 'adversarial-review'] });
    expect(again).not.toContain('REVIEW_LOG_START:');
  }, 240_000);

  test('a repeat pass reads the range: diffBase reaches the specialists and the Red Team, byte for byte the render CLI at that base', async () => {
    const { dir, env } = repo();
    const sh = (c: string) => spawnSync('bash', ['-c', c], { cwd: dir, env, encoding: 'utf8', timeout: 60_000 });
    const rangeBase = sh('git rev-parse HEAD').stdout.trim();
    expect(sh('echo "export const fix = 1;" >> src/a.ts && git commit -qam fix').status).toBe(0);
    const out = path.join(dir, '.state/run/p2');
    const h = host(dir, env);
    expect(await runPass(h, { base: 'main', out, pass: 'x21p2', diffBase: rangeBase, planFlags: ['--depth-floor', 'full'] })).toContain('NEXT: judge (Phase 4)');
    const m = JSON.parse(fs.readFileSync(path.join(out, 'pass-manifest.json'), 'utf8'));
    expect(m.diff_base).toBe(rangeBase);
    const spec = m.readers.find((r: { role?: string }) => r.role === 'specialist-batched');
    const cli = bin(dir, env, ['render', '--role', 'specialist-batched', '--out', path.join(dir, '.state/cli'), '--diff-base', rangeBase, '--checklists', spec.checklists.join(','), '--stack', m.stack, '--test-fw', m.test_fw]);
    expect(cli.status, cli.stderr).toBe(0);
    expect(h.creates.find(c => c.title === 'ship x21p2 specialist-batched')!.prompt).toBe(fs.readFileSync(path.join(dir, '.state/cli/specialist-batched.prompt.md'), 'utf8'));
    expect(h.creates.find(c => c.title === 'ship x21p2 red-team')!.prompt).toContain('DIFF_BASE=' + rangeBase);
  }, 240_000);

  // Value: protects=the pass program dispatches the owner's granted fix-check from the plan, as decision 3.5 runs any fix-check, instead of PASS: none; fails_when=a recorded grant still prints PASS: none next=stop and the lane renders, sends and collects the fix-check by hand (C6-36 after-opus-grant);
  //   why_new=GST-967; seam=the pass program; no_claim=the fix-check reviewer's verdict
  test('GST-967: a recorded grant after round 2 runs its one scoped fix-check through the program', async () => {
    const { dir, env } = repo();
    const head = spawnSync('git', ['rev-parse', 'HEAD'], { cwd: dir, encoding: 'utf8', timeout: 10_000 }).stdout.trim();
    const add = spawnSync(path.join(BIN, 'gstack-approvals'), ['add', '--ask', `Owner grant: one scoped fix-check after round 2 (review_loop_grant ${head.slice(0, 12)})`, '--words', 'one scoped fix-check after round 2', '--by', 'GStack Minder', '--scope', 'this /ship invocation', '--json'], { cwd: dir, env: { ...env, GSTACK_APPROVALS_MIRROR: '0' }, encoding: 'utf8', timeout: 60_000 });
    expect(add.status, add.stderr).toBe(0);
    const id = JSON.parse(add.stdout).added[0] as string;
    const files = path.join(dir, '.state/gfc');
    fs.mkdirSync(files, { recursive: true });
    const fc: Record<string, string> = {};
    for (const [k, v] of [['fix_list', '1. src/a.ts: guard v80\n'], ['hunks', 'diff --git a/src/a.ts b/src/a.ts\n+export const v81 = 81;\n'], ['tests', 'bun test: 3 pass, 0 fail\n'], ['callers', 'none\n']]) { fc[k] = path.join(files, k + '.txt'); fs.writeFileSync(fc[k]!, v!); }
    const h = host(dir, env);
    const res = await runPass(h, { base: 'main', out: path.join(dir, '.state/run/gfc'), pass: 'x30gfc', planFlags: ['--pass', '2', '--last', 'full', '--fixed-blocking', '--range-base', head, '--grant', id], fixCheck: fc, logStart: ['review-fix-check'] });
    expect(res).not.toContain('PASS: none');
    expect(res).toContain(`NEXT: fix-check (the owner's grant ${id}`);
    expect(h.creates.map(c => c.title)).toEqual(['ship x30gfc fix-check']);
    expect(res).toContain('NEXT: judge (Phase 4)');
  }, 240_000);

  // Value: protects=the Capy pass program runs a scoped repeat with no fix-check files, dispatches its Red Team and leaves the fix-check to Step 3.5 as GST-619 does on the CLI; fails_when=the program stops a scoped plan for missing files or creates a fix-check reader in the scoped manifest;
  //   why_new=#3670 Step 11 (adversarial 1, red team 1), re-scoped to GST-619's model in the merge of main; seam=none; no_claim=the Step 3.5 fix-check itself
  test('a scoped repeat runs without fixCheck files and leaves its fix-check to Step 3.5 (GST-619)', async () => {
    const { dir, env } = repo();
    const sh = (c: string) => spawnSync('bash', ['-c', c], { cwd: dir, env, encoding: 'utf8', timeout: 60_000 });
    const rangeBase = sh('git rev-parse HEAD').stdout.trim();
    expect(sh('echo "export const fix = 1;" >> src/a.ts && git commit -qam fix').status).toBe(0);
    const planFlags = ['--pass', '1', '--last', 'full', '--fixed-blocking', '--pass1-depth', 'standard', '--range-base', rangeBase];
    const h = host(dir, env);
    const res = await runPass(h, { base: 'main', out: path.join(dir, '.state/run/s1'), pass: 'x22s1', diffBase: rangeBase, planFlags });
    expect(res).toContain('next=scoped');
    expect(res).not.toContain('STOP:');
    expect(res).toContain('FIX_CHECK: planned');
    expect(h.creates.map(c => c.title)).not.toContain('ship x22s1 fix-check');
    expect(h.creates.map(c => c.title)).toContain('ship x22s1 red-team');
  }, 240_000);

  // Value: protects=a scoped pass run through the Capy program as the driver now says, with no diffBase, gives the pending Step 11 voices the merge base and only the Red Team the fix range (GST-619); fails_when=the program sends a scoped pass a base of its own or the voices read the range before Step 11 ran;
  //   why_new=#3670 merge fix-check (row 454); the driver test "a scoped repeat pass passes no diffBase" is the failing-first half; seam=none; no_claim=an explicit --diff-base, which GST-619 lets win
  test('a scoped pass run as the driver says keeps the merge base for the Step 11 voices; only the Red Team reads the fix range', async () => {
    const { dir, env } = repo();
    const sh = (c: string) => spawnSync('bash', ['-c', c], { cwd: dir, env, encoding: 'utf8', timeout: 60_000 });
    const mergeBase = sh('git merge-base main HEAD').stdout.trim();
    const rangeBase = sh('git rev-parse HEAD').stdout.trim();
    expect(sh('echo "export const fix = 2;" >> src/a.ts && git commit -qam fix').status).toBe(0);
    const out = path.join(dir, '.state/run/s2');
    const planFlags = ['--pass', '1', '--last', 'full', '--fixed-blocking', '--pass1-depth', 'standard', '--range-base', rangeBase];
    const res = await runPass(host(dir, env), { base: 'main', out, pass: 'x22s2', planFlags });
    expect(res).toContain('next=scoped');
    const m = JSON.parse(fs.readFileSync(path.join(out, 'pass-manifest.json'), 'utf8')) as { diff_base: string; readers: { role?: string; stage: string; diff_base?: string }[] };
    expect(m.diff_base).toBe(mergeBase);
    expect(m.readers.find(r => r.role === 'red-team')!.diff_base).toBe(rangeBase);
    const voices = m.readers.filter(r => r.stage === 'voices');
    expect(voices.length).toBeGreaterThan(0);
    for (const v of voices) expect(v.diff_base ?? m.diff_base).toBe(mergeBase);
  }, 240_000);

  // Value: protects=the program's final NEXT line survives a return that its reader outputs push to the 32 KB cap, and a pass whose out is not <run dir>/<pass dir> says it skipped the parts; fails_when=finish() cuts the tail line, the room ignores the parts trailer, or parts are skipped without a line;
  //   why_new=#3670 Step 11 (outside voice 2, adversarial 2 and 6); seam=none; no_claim=what the parent does with a capped return
  test('a near-cap return still ends with its NEXT line, and an odd out prints PARTS: skipped', async () => {
    const { dir, env } = repo();
    const out = path.join(dir, '.state/run/p1');
    fs.mkdirSync(path.join(dir, '.state/run/parts'), { recursive: true });
    fs.writeFileSync(path.join(dir, '.state/run/parts/state.json'), JSON.stringify({ returned: [] }));
    const big = host(dir, env, { output: () => 'x'.repeat(15_900) + '\nNO FINDINGS' });
    const res = await runPass(big, { base: 'main', out, pass: 'x23p1', planFlags: ['--depth-floor', 'full'] });
    expect(res.length).toBeLessThanOrEqual(32000);
    expect(res.trimEnd().split('\n').at(-1)).toBe('NEXT: judge (Phase 4)');
    const odd = await runPass(host(dir, env), { base: 'main', out: path.join(dir, '.state/run/deep/p1'), pass: 'x23p2', planFlags: ['--depth-floor', 'full'] });
    expect(odd).toMatch(/^PARTS: skipped \(/m);
    expect(odd.trimEnd().split('\n').at(-1)).toBe('NEXT: judge (Phase 4)');
  }, 240_000);

  test('a plan with no reviewer pass dispatches nothing and passes NEXT through', async () => {
    const { dir, env } = repo();
    const h = host(dir, env);
    const res = await runPass(h, { base: 'main', out: path.join(dir, '.state/run/p2'), pass: 'x9p2', planFlags: ['--pass', '1', '--last', 'full'] });
    expect(res).toContain('PASS: none next=');
    expect(h.creates).toHaveLength(0);
  }, 120_000);
});

describe('the pass resolves --base the way preflight does', () => {
  function withOrigin(stale: boolean) {
    const { dir, env } = repo();
    const sh = (c: string) => { const r = spawnSync('bash', ['-c', c], { cwd: dir, env, encoding: 'utf8', timeout: 60_000 }); if (r.status !== 0) throw new Error(c + ': ' + r.stderr); return r.stdout.trim(); };
    const origin = tmp('rp-origin-');
    sh('git init -q --bare "$0" && git remote add origin "$0"'.split('$0').join(origin));
    if (stale) {
      sh('git checkout -q main && echo "# base" > BASE.md && git add BASE.md && git commit -qm m2 && git push -q origin main && git reset -q --hard HEAD~1 && git checkout -q feat && git merge -q --no-edit origin/main');
    } else {
      sh('git push -q origin main && git fetch -q origin && git branch -D main');
    }
    return { dir, env, originMain: sh('git rev-parse origin/main') };
  }
  // Value: protects=a checkout whose local main is missing or behind origin/main reviews the same fork point preflight merged, not a stale one or none; fails_when=pass resolves --base against the local branch only (replay C5-36: BRIEF_RENDER_FAILED: no merge base between main and HEAD);
  //   why_new=identity checks ran with local main equal to origin/main; seam=gstack-review-dispatch pass; no_claim=hosts whose remote is not named origin
  test.each([['no local main', false], ['a local main behind origin/main', true]])('%s: diff base is the fork point with origin/main, briefs byte for byte the render CLI there', (_, stale) => {
    const { dir, env, originMain } = withOrigin(stale as boolean);
    const out = path.join(dir, '.state/run/p1');
    const r = bin(dir, env, ['pass', '--base', 'main', '--out', out, '--pass', 'x22p1', '--', '--depth-floor', 'full']);
    expect(r.status, r.stdout + r.stderr).toBe(0);
    const m = JSON.parse(fs.readFileSync(path.join(out, 'pass-manifest.json'), 'utf8'));
    expect(m.diff_base).toBe(originMain);
    const spec = m.readers.find((x: { role?: string }) => x.role === 'specialist-batched');
    const cli = bin(dir, env, ['render', '--role', 'specialist-batched', '--out', path.join(dir, '.state/cli'), '--diff-base', originMain, '--checklists', spec.checklists.join(','), '--stack', m.stack, '--test-fw', m.test_fw]);
    expect(cli.status, cli.stderr).toBe(0);
    expect(fs.readFileSync(spec.file, 'utf8')).toBe(fs.readFileSync(path.join(dir, '.state/cli/specialist-batched.prompt.md'), 'utf8'));
  }, 120_000);
});

describe('the Capy skill loader', () => {
  // The loader is copied from capy/skill/gstack/SKILL.md with only its placeholders filled, so a drift in either breaks here.
  test('runs the served program unchanged and the pass notes its readers in the budget', async () => {
    const skill = fs.readFileSync(path.join(ROOT, 'capy/skill/gstack/SKILL.md'), 'utf8');
    const at = skill.indexOf('one call to the checked-in pass program');
    const open = skill.indexOf('(fill only `input`): `', at) + '(fill only `input`): `'.length;
    const code = skill.slice(open, skill.indexOf('`', open));
    const { dir, env } = repo();
    const launch = path.join(dir, '.state/launch.env');
    const rec = path.join(dir, '.state/rec.md');
    fs.mkdirSync(path.dirname(launch), { recursive: true });
    fs.writeFileSync(launch, '');
    expect(spawnSync('bash', ['-c', 'gstack-ship-budget start --record "$1" --mode observe --reading 1000 --credits 1', '_', rec], { cwd: dir, env, encoding: 'utf8', timeout: 60_000 }).status).toBe(0);
    const filled = code.split('<launch file>').join(launch).split('<base>').join('main').split('<run dir>/p<n>').join(path.join(dir, '.state/run/p1'))
      .split('<run>-p<n>').join('x10p1').split('<jam id>').join('jam_test').split('<rec>').join(rec).split('<your model id>').join('anthropic/claude-opus-5-5').split('<repo>').join(dir);
    expect(filled).not.toMatch(/<[a-z ]+>/);
    const h = host(dir, env);
    const res = await new AsyncFunction('tools', 'sleep', 'now', filled)(h.tools, h.sleep, h.now);
    expect(res.split('\n')[0]).toBe('PROGRAM: v1 sha256=' + promptHash(PROGRAM) + ' bytes=' + Buffer.byteLength(PROGRAM));
    expect(res).toMatch(/REVIEW_LOG_START: review token=\S+/);
    expect(res).toMatch(/NOTE: \S+ used=\d+ credits=\S+ readers=\d+/);
    expect(res).toContain('NEXT: judge (Phase 4)');
    expect(h.creates.length).toBeGreaterThan(0);
  }, 180_000);
});


describe('a scoped pass after a blocker fix (GST-619)', () => {
  // Value: protects=the pass command accepts the scoped plan gstack-review-plan writes after a blocking fix, invoked as GEVA-2 ran it: the Red Team reviews the fix range, Step 11's voices still pending keep the whole branch, the fix-check is named outside the manifest for Step 3.5, and a resumed pass names it again; fails_when=pass refuses the scoped plan, stages the Red Team on the merge base, stages pending Step 11 voices on the range, drops the fix-check silently, or puts it in the manifest;
  //   why_new=GEVA-82 on 1.91.379.0 hit BRIEF_RENDER_FAILED on every scoped pass and rendered briefs by hand; seam=none; no_claim=the fix-check's own brief
  function scoped(flags: string[], explicitMergeBase = false) {
    const { dir, env } = repo();
    const sh = (c: string) => { const r = spawnSync('bash', ['-c', c], { cwd: dir, env, encoding: 'utf8', timeout: 60_000 }); if (r.status !== 0) throw new Error(r.stderr); return r.stdout.trim(); };
    const mergeBase = sh('git merge-base main HEAD');
    const rangeBase = sh('git rev-parse HEAD');
    sh('for i in $(seq 1 24); do echo "export const f$i = $i;" >> src/fix.ts; done && git add -A && git commit -qm "fix: pre-landing review fixes"');
    const out = path.join(dir, '.state/run/p2');
    const extras = path.join(dir, '.state/extras.json');
    fs.mkdirSync(path.join(dir, '.state'), { recursive: true });
    fs.writeFileSync(path.join(dir, '.state/plan.md'), 'Check the plan items against the fix.\n');
    fs.writeFileSync(extras, JSON.stringify([{ name: 'plan', prompt_file: path.join(dir, '.state/plan.md') }]));
    const args = ['pass', '--base', 'main', '--out', out, '--pass', 'p2', '--extras', extras, ...(explicitMergeBase ? ['--diff-base', mergeBase] : []), '--', '--pass', '1', '--last', 'full', '--pass1-depth', 'standard', '--fixed-blocking', ...flags, '--range-base', rangeBase.slice(0, 7)];
    const p = bin(dir, env, args);
    expect(p.status, p.stdout + p.stderr).toBe(0);
    expect(p.stdout).toMatch(/^NEXT: scoped /m);
    expect(p.stdout).toMatch(/^FIX_CHECK: planned effort=full \(Step 3\.5 runs it on its own; not in this manifest\)$/m);
    const mf = path.join(out, 'pass-manifest.json');
    return { dir, env, args, mf, mergeBase, rangeBase, m: JSON.parse(fs.readFileSync(mf, 'utf8')) as Manifest };
  }
  const settle = (s: ReturnType<typeof scoped>, stage: string) => {
    if (stage !== 'specialists') expect(bin(s.dir, s.env, ['stage', '--manifest', s.mf, '--stage', stage]).status).toBe(0);
    const m = JSON.parse(fs.readFileSync(s.mf, 'utf8')) as Manifest;
    const reply = path.join(s.dir, '.state/reply.txt');
    fs.writeFileSync(reply, treeLine(s.dir) + 'NO FINDINGS\n');
    for (const r of m.readers.filter(x => x.stage === stage)) for (const [st, extra] of [['intent', []], ['created', ['--path', '1']], ['collected', r.reader.startsWith('audit/') ? ['--output', reply] : []]] as const) expect(bin(s.dir, s.env, ['mark', '--manifest', s.mf, '--reader', r.reader, '--state', st, ...extra]).status).toBe(0);
    return JSON.parse(fs.readFileSync(s.mf, 'utf8')) as Manifest;
  };

  test('GEVA-2\'s invocation: the Red Team reads the fix range, the pending Step 11 voices read the whole branch, and the fix-check is named outside the manifest', () => {
    const s = scoped([]);
    expect(s.m.next).toBe('scoped');
    expect(s.m.diff_base).toBe(s.mergeBase);
    expect(s.m.readers.map(r => [r.reader, r.diff_base ?? null])).toEqual([['red-team', s.rangeBase], ['adversarial-native', null], ['outside-voice', null], ['audit/plan', null]]);
    settle(s, 'specialists');
    const m = settle(s, 'red-team');
    const redTeam = fs.readFileSync(m.readers.find(r => r.reader === 'red-team')!.file!, 'utf8');
    expect(redTeam).toContain(s.rangeBase);
    expect(redTeam).not.toContain(s.mergeBase);
    expect(bin(s.dir, s.env, ['stage', '--manifest', s.mf, '--stage', 'voices']).status).toBe(0);
    const voices = JSON.parse(fs.readFileSync(s.mf, 'utf8')) as Manifest;
    expect(fs.readFileSync(voices.readers.find(r => r.reader === 'outside-voice')!.file!, 'utf8')).toContain('+export const v1 = 1;');
    const again = bin(s.dir, s.env, s.args);
    expect(again.status, again.stdout + again.stderr).toBe(0);
    expect(again.stdout).toMatch(/^FIX_CHECK: planned effort=full /m);
    expect(again.stdout).toContain('readers=4 resumed');
  }, 120_000);

  test('after Step 11 ran (--adversarial-ran), the whole scoped pass reads the fix range', () => {
    const s = scoped(['--adversarial-ran']);
    expect(s.m.diff_base).toBe(s.rangeBase);
    expect(s.m.readers.map(r => [r.reader, r.diff_base ?? null])).toEqual([['red-team', s.rangeBase], ['adversarial-native', null], ['audit/plan', null]]);
  }, 120_000);

  // Value: protects=an explicit --diff-base reaches every reader, the Red Team included; fails_when=a scoped pass asked to read the whole branch still stages its Red Team on the fix range; why_new=GST-738 (outside voice); seam=none; no_claim=none
  test('an explicit --diff-base widens the scoped Red Team too (GST-738)', () => {
    const s = scoped([], true);
    expect(s.m.diff_base).toBe(s.mergeBase);
    const m = settle(s, 'specialists') && settle(s, 'red-team');
    const redTeam = fs.readFileSync(m.readers.find(r => r.reader === 'red-team')!.file!, 'utf8');
    expect({ diffBase: m.readers.find(r => r.reader === 'red-team')!.diff_base ?? null, reads: redTeam.includes(s.mergeBase) }).toEqual({ diffBase: null, reads: true });
  }, 120_000);
});

describe('readers on a shared machine review the checkout the pass ships (GST-482)', () => {
  /** The primary checkout on feat, and a worktree of it on another branch with one more commit: the GBRA-218 layout. */
  function worktree() {
    const { dir, env } = repo();
    const wt = path.join(tmp('rp-wt-'), 'wt');
    const sh = (c: string, cwd = dir) => { const r = spawnSync('bash', ['-c', c], { cwd, env, encoding: 'utf8', timeout: 60_000 }); if (r.status !== 0) throw new Error(c + ': ' + r.stderr); return r.stdout.trim(); };
    sh(`git worktree add -q -b allow ${JSON.stringify(wt)} feat`);
    sh('for i in $(seq 1 20); do echo "export const w$i = $i;" >> src/a.ts; done && git commit -qam allow', wt);
    return { dir, env, wt: fs.realpathSync(wt) };
  }
  // Value: protects=no reader is started where Capy will put it (the shared machine's start checkout) when /ship ships another checkout; fails_when=the program dispatches readers that start in the primary checkout while the pass ships a worktree (GBRA-218's outside voice ignored `cd <dir> &&` and reviewed the primary checkout, losing Step 11 outside coverage);
  //   why_new=GBRA-218 on gstack 1.92.25.0; Capy subagents take no working directory; seam=lib/capy-review-pass.js before any log start or create; no_claim=that Capy can start a reader in a chosen directory
  test('a shared machine whose start checkout is not the worktree refuses before any start token or reader; a start directory outside any checkout dispatches', async () => {
    const { dir, env, wt } = worktree();
    const out = path.join(wt, '.state/run/p1');
    const h = host(dir, env);
    const res = await runPass(h, { base: 'main', out, pass: 'w0p1', cwd: wt, planFlags: ['--depth-floor', 'full'], logStart: ['review'] });
    expect(res).toContain(`STOP: readers on the shared machine start in ${fs.realpathSync(dir)}, not in ${wt}`);
    expect(res).not.toContain('REVIEW_LOG_START:');
    expect(h.creates.length).toBe(0);
    const voices = await runPass(h, { base: 'main', out, pass: 'w0p1', cwd: wt, planFlags: ['--depth-floor', 'full'], stage: 'voices', models: { 'outside-voice': { model_id: 'openai/gpt-6.1-sol' } } });
    expect(voices).toContain('STOP: readers on the shared machine start in ');
    expect(h.creates.length).toBe(0);
    const started = host(wt, env);
    expect(await runPass(started, { base: 'main', out: path.join(wt, '.state/run/p2'), pass: 'w0p2', cwd: wt, planFlags: ['--depth-floor', 'full'] })).toContain('NEXT: judge (Phase 4)');
    expect(started.creates.length).toBeGreaterThan(0);
    const outside = host(path.dirname(wt), env);
    expect(await runPass(outside, { base: 'main', out: path.join(wt, '.state/run/p3'), pass: 'w0p3', cwd: wt, planFlags: ['--depth-floor', 'full'] })).toContain('NEXT: judge (Phase 4)');
    const broken = tmp('rp-broken-');
    fs.writeFileSync(path.join(broken, '.git'), 'garbage\n');
    const unreadable = host(broken, env);
    expect(await runPass(unreadable, { base: 'main', out: path.join(wt, '.state/run/p4'), pass: 'w0p4', cwd: wt, planFlags: ['--depth-floor', 'full'] })).toContain('STOP: cannot read the directory readers on the shared machine start in: fatal: invalid gitfile format');
    expect(unreadable.creates.length).toBe(0);
    const slow = host(wt, env, { pollsToFinish: 30 });
    let probes = 0;
    const bash = slow.tools.capy.bash;
    slow.tools.capy.bash = async (a) => { if (a.command.startsWith('if d=$(git rev-parse')) probes++; return bash(a); };
    const input = { base: 'main', out: path.join(wt, '.state/run/p5'), pass: 'w0p5', cwd: wt, planFlags: ['--depth-floor', 'full'] };
    expect(await runPass(slow, input)).toContain('NEXT: poll');
    expect(await runPass(slow, input)).toContain('NEXT: poll');
    expect(probes).toBe(1);
    expect(await runPass(host(wt, env), { ...input, logStart: [7] })).toStartWith('STOP: input.logStart must be a list');
  }, 240_000);

  // Value: protects=a reader that never left the machine's default checkout cannot hand /ship a review of another tree; fails_when=collect merges a reply whose REVIEWED_TREE names the primary checkout while the pass ships a worktree, or a reply with no such line;
  //   why_new=GBRA-218: pass 1's specialist reviewed /workspace/gbrain while /ship shipped ~/.capy/work/wt-allow; seam=gstack-review-dispatch collect; no_claim=a reader that fingerprints the right checkout but reads another
  test('a reader that reviews the primary checkout instead of the worktree is refused and nothing it said is merged', async () => {
    const { dir, env, wt } = worktree();
    const out = path.join(wt, '.state/run/p1');
    const h = host(wt, env, { reportFrom: () => dir, output: t => (t.includes('specialist') ? '[CRITICAL] (confidence: 9/10) src/other.ts:3 a file outside this PR' : cleanReply(t)) });
    const res = await runPass(h, { base: 'main', out, pass: 'w1p1', cwd: wt, planFlags: ['--depth-floor', 'full'] });
    expect(res).toContain('COLLECT_WRONG_TREE: reader=');
    expect(res).toContain(`reported="${treeLine(dir).slice(15).trim()}"`);
    expect(res).toMatch(/STOP: collect \S+ exited 1/);
    expect(res).not.toContain('NEXT: judge');
    expect(fs.existsSync(path.join(out, 'merged.jsonl')) ? fs.readFileSync(path.join(out, 'merged.jsonl'), 'utf8') : '').toBe('');
    const v = bin(wt, env, ['verify', '--ledger', path.join(out, 'review-ledger.jsonl')]).stdout;
    expect(v).toMatch(/^OUTPUT \S+ NOT_REVIEWED .*wrong_tree/m);
    expect(v).toContain('VERIFY: dirty');
  }, 240_000);

  test('a reply that names no checkout is refused the same way', async () => {
    const { dir, env, wt } = worktree();
    const out = path.join(wt, '.state/run/p1');
    const res = await runPass(host(wt, env, { reportFrom: () => '' }), { base: 'main', out, pass: 'w2p1', cwd: wt, planFlags: ['--depth-floor', 'full'] });
    expect(res).toContain('COLLECT_WRONG_TREE: reader=');
    expect(res).toContain('reported="none"');
    expect(res).not.toContain('NEXT: judge');
  }, 240_000);

  // Value: protects=/ship from a worktree that is the shared machine's start checkout works, its readers' briefs naming it (GST-776 refuses any other start checkout up front); fails_when=a brief does not name the shipped checkout, or a correct reply is refused;
  //   why_new=GBRA-218 (no brief named a directory); seam=lib/review-pass.ts renderStage and the Capy pass program; no_claim=model compliance with the paragraph
  test('a reader that works in the checkout its brief names passes, and every brief names the worktree', async () => {
    const { dir, env, wt } = worktree();
    const out = path.join(wt, '.state/run/p1');
    fs.mkdirSync(out, { recursive: true });
    fs.writeFileSync(path.join(out, 'coverage.prompt.md'), 'Run Step 7 as written.\n');
    const h = host(wt, env);
    const res = await runPass(h, { base: 'main', out, pass: 'w3p1', cwd: wt, planFlags: ['--depth-floor', 'full'],
      extras: [{ name: 'coverage', prompt_file: path.join(out, 'coverage.prompt.md'), first: true }] });
    expect(res).not.toContain('STOP:');
    expect(res).toContain('NEXT: judge (Phase 4)');
    expect(h.creates.length).toBeGreaterThan(2);
    for (const c of h.creates) expect([c.prompt.startsWith(workspaceStep(wt) + '\n\n'), c.prompt.endsWith('\n\n' + workspaceParagraph(wt))], c.title).toEqual([true, true]);
    expect(bin(wt, env, ['verify', '--ledger', path.join(out, 'review-ledger.jsonl')]).stdout).not.toContain('wrong_tree');
  }, 240_000);

  test('an audit reader that worked in the primary checkout is refused when it is collected', async () => {
    const { dir, env, wt } = worktree();
    const out = path.join(wt, '.state/run/p1');
    fs.mkdirSync(out, { recursive: true });
    fs.writeFileSync(path.join(out, 'docs.prompt.md'), 'Run the Step 14.5 audit as written.\n');
    const h = host(wt, env, { reportFrom: t => (t.endsWith('audit/docs') ? dir : briefDirOf(h, t)) });
    const res = await runPass(h, { base: 'main', out, pass: 'w4p1', cwd: wt, planFlags: ['--depth-floor', 'full'],
      extras: [{ name: 'docs', prompt_file: path.join(out, 'docs.prompt.md'), first: true }] });
    expect(res).toContain('COLLECT_WRONG_TREE: reader=audit/docs');
    expect(res).not.toContain('NEXT: judge');
    expect(h.creates.map(c => c.title)).toEqual(['ship w4p1 audit/docs']);
  }, 240_000);

  test('a rerun after a wrong-tree STOP stops on the failed reader and never collects its reply twice', async () => {
    const { dir, env, wt } = worktree();
    const out = path.join(wt, '.state/run/p1');
    const h = host(wt, env, { reportFrom: () => dir });
    const input = { base: 'main', out, pass: 'w5p1', cwd: wt, planFlags: ['--depth-floor', 'full'] };
    expect(await runPass(h, input)).toContain('COLLECT_WRONG_TREE: reader=');
    const again = await runPass(h, input);
    expect(again).toMatch(/STOP: \S+ \(subagent \d+\) reviewed another tree: [0-9a-f]{40} /);
    const outputs = fs.readFileSync(path.join(out, 'review-ledger.jsonl'), 'utf8').trim().split('\n').map(l => JSON.parse(l)).filter(e => e.event === 'output');
    expect(outputs.length).toBe(1);
  }, 240_000);

  test('a worktree at the same commit as the primary checkout is still told apart by its toplevel', async () => {
    const { dir, env } = repo();
    const wt = path.join(tmp('rp-wt-'), 'same');
    expect(spawnSync('git', ['worktree', 'add', '-q', '--detach', wt, 'feat'], { cwd: dir, env, encoding: 'utf8', timeout: 60_000 }).status).toBe(0);
    const out = path.join(wt, '.state/run/p1');
    const res = await runPass(host(wt, env, { reportFrom: () => dir }), { base: 'main', out, pass: 'w6p1', cwd: fs.realpathSync(wt), planFlags: ['--depth-floor', 'full'] });
    expect(res).toContain('COLLECT_WRONG_TREE: reader=');
    expect(res).not.toContain('COLLECT_TREE_MOVED');
  }, 240_000);

  test('a commit between render and reply is COLLECT_TREE_MOVED, not a pass', async () => {
    const { dir, env, wt } = worktree();
    const out = path.join(wt, '.state/run/p1');
    let moved = false;
    const h = host(wt, env, { reportFrom: t => {
      if (!moved) { moved = true; spawnSync('bash', ['-c', 'echo "export const late = 1;" >> src/a.ts && git commit -qam late'], { cwd: wt, env, encoding: 'utf8', timeout: 60_000 }); }
      return briefDirOf(h, t);
    } });
    const res = await runPass(h, { base: 'main', out, pass: 'w7p1', cwd: wt, planFlags: ['--depth-floor', 'full'] });
    expect(res).toContain('COLLECT_TREE_MOVED: reader=');
    expect(res).not.toContain('NEXT: judge');
  }, 240_000);

  test('an outside voice that reviewed another tree is recorded as unavailable coverage, never clean, and the voices still finish', async () => {
    const { dir, env, wt } = worktree();
    const out = path.join(wt, '.state/run/p1');
    const h = host(wt, env, { reportFrom: t => (t.endsWith('outside-voice') ? dir : briefDirOf(h, t)) });
    const base = { base: 'main', out, pass: 'w8p1', cwd: wt, planFlags: ['--depth-floor', 'full'] };
    expect(await runPass(h, base)).toContain('NEXT: judge (Phase 4)');
    const models = { 'outside-voice': { model_id: 'openai/gpt-6.1-sol' }, 'adversarial-native': { model_id: 'anthropic/claude-opus-5-5', reasoning_mode: 'high' } };
    const res = await runPass(h, { ...base, stage: 'voices', models });
    expect(res).toContain('COLLECT_UNAVAILABLE: reader=outside-voice');
    expect(res).toContain('reviewed another tree');
    expect(res).toContain('NEXT: judge the voices');
    const v = bin(wt, env, ['verify', '--ledger', path.join(out, 'review-ledger.jsonl')]).stdout;
    expect(v).toMatch(/^BRIEF outside-voice UNAVAILABLE /m);
  }, 240_000);
});
const briefDirOf = (h: ReturnType<typeof host>, title: string) => briefDir(h.creates.find(c => c.title === title)?.prompt ?? '');