v1.91.362.0 ship: one call per review pass on Capy (GSTA-167 calls PR 2) (#3665)

* ship: poll readers in-program, never wait on wakes; 32 KB returns; gated fix program; unattended push defers the guard offer; calls meter (GSTA-167 calls PR 1)

Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

* fix: pre-landing review fixes (inventory lib/ship-release.ts as a GSTACK_SESSION_KIND reader)

Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

* docs(ship-budget): document calls and dotted --step notes

Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

* ship: one call per review pass on Capy; staged dispatch manifest, chunked briefs, intent before create (GSTA-167 calls PR 2)

Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

* fix: pre-landing review fixes (pass program reruns a failed review-log start and stops on a failed reader every run)

Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

* fix: Step 11 review fixes (PASS: none read from the last line only, queued readers reconciled and timed out, a budget stop ends the pass)

Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

* ship: judge treats a missing severity as invalid; Capy passes rendered briefs via cat (replay C1-34 breaks)

Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

* fix: the batched reviewer reads its checklists by path, as the render CLI is given them (PR #3665 review)

Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

* fix: keep the Capy skill under its context budget after the main merge

Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

* chore: drop PR 1's changelog fragment, which main's v1.91.355.0 stamp already consumed

Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

* fix(ship): the pass program takes extras as JSON and a cwd, and waits a minute for a done reader's summary (replay C2-34)

Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

---------

Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [1.91.362.0] - 2026-10-31
+
+**A /ship review pass on Capy is one call to a checked-in program, and reviewer briefs no longer pass through the model.** In the GSTA-189 replay one pass took about 10 parent calls to plan, render, create, check and poll its readers, and the Red Team brief went out wrong twice because a file read cut its long lines. What reviewers see, which reviewers run, their depth and the blocking floor are unchanged, and the new path renders all 16 briefs of that replay byte for byte.
+
+### Added
+- **`gstack-review-dispatch pass`** plans a pass and writes a staged manifest: audits marked first, then specialists with QA and the other audits, then the Red Team, then Step 11's voices. Each brief is rendered once its inputs exist, and the Red Team's findings file is the specialists' collected lines byte for byte.
+- **Briefs travel in chunks** (`gstack-review-dispatch chunk`) of at most 65,536 characters, so a brief over 1 MB, or one whose diff has invalid UTF-8, reaches the reader whole and is checked by `sent` before the reader starts.
+- **The Capy pass program** (`lib/capy-review-pass.js`, served by `gstack-review-dispatch program`) runs plan, review-log start, dispatch, poll, collect, the Red Team and the budget note in one call, returning within 200 s; the gstack Capy skill carries the loader. Each reader's intent is saved before its subagent is created, so a rerun after a lost create result finds the reader by title instead of starting it twice, and an unclear outcome stops the pass. A failed reader stops every rerun instead of leaving it polling, and a review-log start that failed is retried before any reader goes out.
+
+### Fixed
+- **The pass program takes its input as the Capy skill writes it.** `extras` may be JSON in the input, not only a file path, and `cwd` names the checkout its commands run in. A reader that reports done a moment before its summary arrives is collected on a later poll instead of stopping the pass. Replay C2-34 (GSTA-193) lost 7 of its 15 calls to these three issues.
+- **The targeted reader runs in the pass.** When the plan dispatches it for money, gate, auth or secret code, it is staged with Step 11's voices on the merge base. Its brief matches `gstack-review-dispatch render --role targeted` byte for byte, and its ledger row carries the classes, rules, brief and patch the receipt's targeted record reads.
+
 ## [1.91.361.0] - 2026-10-31
 
 **A reviewer's install no longer rewrites the lane's launch environment, and a hand-run `gstack-upgrade` on Capy no longer moves a checkout under another session.** These are follow-ups to the v1.91.356.0 fix that stopped reviewer installs from upgrading the shared checkout.

VERSION

@@ -1 +1 @@
-1.91.361.0
+1.91.362.0

agents-digest/gstack-AGENTS.md

@@ -1,4 +1,4 @@
-# gstack digest v1.91.361.0 — regenerate/re-copy after upgrading gstack
+# gstack digest v1.91.362.0 — regenerate/re-copy after upgrading gstack
 
 Behavioral rules from gstack (https://github.com/garrytan/gstack), compressed
 for agent hosts without a full skill install. The full skills add workflows,

bin/gstack-review-dispatch

@@ -8,8 +8,12 @@
  *   gstack-review-dispatch collect --ledger <f> --role <role> [--name <n>] --output <file> --merged <file>
  *   gstack-review-dispatch judge --ledger <f> --merged <file> --judged <file>        no drop, no downgrade
  *   gstack-review-dispatch verify --ledger <f> [--targeted-out <file>]               replay every hash and the judgment
+ *   gstack-review-dispatch pass --base <b> --out <dir> --pass <id> [-- plan flags]  the pass's staged manifest
+ *   gstack-review-dispatch show|stage|chunk|mark --manifest <f> ...                  one manifest step
+ *   gstack-review-dispatch program [--ledger <f>]                                    the checked-in Capy pass program
  *
- * Logic: lib/review-brief.ts (rendering from the sections) and lib/review-ledger.ts (ledger, collect, judge, verify).
+ * Logic: lib/review-brief.ts (rendering from the sections), lib/review-ledger.ts (ledger, collect, judge, verify),
+ * lib/review-pass.ts (the staged manifest) and lib/capy-review-pass.js (the Capy program that runs it).
  */
 import { spawnSync } from 'node:child_process';
 import * as fs from 'node:fs';
@@ -17,6 +21,9 @@ import * as path from 'node:path';
 import { EXIT, exitTableHelp } from '../lib/headless-artifacts';
 import { BRIEF_ROLES, BriefError, briefFile, promptHash, renderBrief, sectionTexts, type BriefRole, type Slots } from '../lib/review-brief';
 import { collect, readJsonl, readLedger, readerKey, recordJudgment, recordSent, appendEvent, verify, type JudgedLine, type MergedLine, type VerifyRow } from '../lib/review-ledger';
+import { buildManifest, chunkCount, chunkOf, manifestPath, markReader, readManifest, renderStage, writeManifest, STAGES, type Extra, type Manifest, type PassReader, type ReaderState, type Stage } from '../lib/review-pass';
+import type { Dispatch } from '../lib/review-depth';
+import { runScriptSync } from '../lib/script-invocation';
 import { TARGETED_RULES, parseClassList, targetedBriefSha, targetedPatchId } from '../lib/review-targeted';
 import { resolveBaseBranch } from '../lib/ship-policy';
 
@@ -44,6 +51,24 @@ const HELP = `gstack-review-dispatch — verbatim reviewer briefs and loss-free
       BRIEF, OUTPUT and JUDGE rows from the ledger alone, then VERIFY: clean (exit 0), VERIFY: dirty (exit 1) or
       VERIFY: no brief records (exit 3: this run's ledger kept no prompts). A ledger with a targeted brief also prints
       TARGETED_RECORD: and --targeted-out writes it as the JSON gstack-ship-receipt write --review-targeted reads
+  pass --base <ref> --out <dir> --pass <id> [--ledger <f>] [--diff-base <sha>] [--learnings-file <f>] [--extras <json>]
+       [--checklist-root <dir>] [-- <gstack-review-plan flags>]
+      runs gstack-review-plan and writes <out>/pass-manifest.json: stage first (audit readers marked first in --extras),
+      specialists (with the other --extras readers), red-team, voices (Step 11). Renders first and specialists now; prints
+      the plan, MANIFEST: and one READER: line per reader. A plan whose NEXT is not full or scoped prints PASS: none.
+      An existing manifest for the same --pass is reused (resumed). --extras: [{"name","prompt_file","first"?,"model"?}]
+  show --manifest <f>                         MANIFEST_JSON: <the manifest on one line>
+  stage --manifest <f> --stage <first|specialists|red-team|voices>
+      renders a stage; the Red Team only after every earlier reader is collected, its findings file being the
+      specialists' merged.jsonl lines byte for byte
+  chunk --manifest <f> --reader <r> --index <i>
+      BRIEF_CHUNK: reader=… index=i of=n sha256=…, then one JSON string line of at most 65,536 brief characters
+  mark --manifest <f> --reader <r> --state <intent|created|queued|collected|failed> [--path <p>] [--output <f>] [--error <e>]
+  mark --manifest <f> --before <tokens>,<credits>
+  mark --manifest <f> --log-start <key> --token <t>   records a review-log start token once, so a rerun starts only what is missing
+      reader states move forward only; intent is recorded before the subagent is created, its path right after
+  program [--ledger <f>]
+      PROGRAM: v<n> sha256=… bytes=…, then lib/capy-review-pass.js as one JSON string line (see the gstack Capy skill)
 ${exitTableHelp()}`;
 
 const args = process.argv.slice(2);
@@ -96,6 +121,113 @@ function render(): number {
   return EXIT.ok;
 }
 
+const PROGRAM_FILE = path.join(ROOT, 'lib', 'capy-review-pass.js');
+const PROGRAM_VERSION = 1;
+const git = (a: string[]) => { const r = spawnSync('git', a, { encoding: 'utf8', timeout: 60_000, maxBuffer: 256 * 1024 * 1024 }); return r.status === 0 ? r.stdout : null; };
+const readerLine = (m: Manifest, r: PassReader) => `READER: ${r.reader} stage=${r.stage} state=${r.state} title="${r.title}"${r.sha256 ? ` sha256=${r.sha256} bytes=${r.bytes} chunks=${r.chunks}` : ''}${r.path ? ` path=${r.path}` : ''}`;
+const branchDiff = (base: string) => {
+  const d = git(['-c', 'core.quotePath=false', 'diff', '--no-color', '--no-ext-diff', base]);
+  if (d === null) throw new BriefError(`git diff ${base} failed`);
+  return d;
+};
+
+function pass(): number {
+  const base = flag('--base'), out = flag('--out'), id = flag('--pass');
+  if (!base || !out || !id || !/^[a-z0-9-]+$/.test(id)) { process.stderr.write('gstack-review-dispatch pass: needs --base <ref>, --out <dir> and --pass <id> (lowercase letters, digits, dashes)\n'); return EXIT.usage; }
+  const file = manifestPath(out);
+  if (fs.existsSync(file)) {
+    const m = readManifest(file);
+    if (m.pass !== id) throw new BriefError(`${file} belongs to pass ${m.pass}, not ${id}`);
+    process.stdout.write([...m.plan_lines, `MANIFEST: file=${file} pass=${m.pass} readers=${m.readers.length} resumed`, ...m.readers.map(r => readerLine(m, r))].join('\n') + '\n');
+    return EXIT.ok;
+  }
+  const planArgs = args.includes('--') ? args.slice(args.indexOf('--') + 1) : [];
+  const plan = (json: boolean) => runScriptSync(path.join(ROOT, 'bin', 'gstack-review-plan'), ['--base', base, ...planArgs, ...(json ? ['--json'] : [])], { encoding: 'utf8', timeout: 180_000, maxBuffer: 64 * 1024 * 1024 });
+  const text = plan(false);
+  if (text.status !== 0) { process.stdout.write(text.stdout ?? ''); process.stderr.write(text.stderr ?? ''); return EXIT.fail; }
+  const j = plan(true);
+  if (j.status !== 0) { process.stderr.write(j.stderr ?? ''); return EXIT.fail; }
+  const p = JSON.parse(j.stdout) as { next: { step: string }; dispatches: Dispatch[]; targeted?: { classes: string[] } };
+  const planLines = text.stdout.trimEnd().split('\n');
+  const step = p.next.step;
+  if (step !== 'full' && step !== 'scoped') { process.stdout.write([...planLines, `PASS: none next=${step} (no reviewer pass; follow NEXT)`].join('\n') + '\n'); return EXIT.ok; }
+  const diffBase = flag('--diff-base') ?? git(['merge-base', base, 'HEAD'])?.trim();
+  if (!diffBase) throw new BriefError(`no merge base between ${base} and HEAD`);
+  const root = git(['rev-parse', '--show-toplevel'])?.trim() ?? process.cwd();
+  const extrasFile = flag('--extras');
+  const extras = extrasFile ? JSON.parse(readFile(extrasFile, 'extras')!) as Extra[] : [];
+  const m = buildManifest({ pass: id, out, ledger: flag('--ledger') ?? path.join(out, 'review-ledger.jsonl'), base, diffBase, root, checklistRoot: flag('--checklist-root') ?? ROOT,
+    dispatches: p.dispatches, next: step, planLines, learnings: readFile(flag('--learnings-file'), 'learnings') ?? null, extras,
+    targetedClasses: p.targeted?.classes, mergeBase: git(['merge-base', base, 'HEAD'])?.trim() });
+  fs.mkdirSync(m.out, { recursive: true, mode: 0o700 });
+  const t = sectionTexts(ROOT);
+  renderStage(m, 'first', t, branchDiff);
+  renderStage(m, 'specialists', t, branchDiff);
+  writeManifest(file, m);
+  const count = (s: string) => m.readers.filter(r => r.stage === s).length;
+  process.stdout.write([...planLines, `MANIFEST: file=${file} pass=${id} readers=${m.readers.length} first=${count('first')} specialists=${count('specialists')} red-team=${count('red-team')} voices=${count('voices')}`, ...m.readers.map(r => readerLine(m, r))].join('\n') + '\n');
+  return EXIT.ok;
+}
+
+function passStep(cmd: string): number {
+  const file = flag('--manifest');
+  if (!file) { process.stderr.write(`gstack-review-dispatch ${cmd}: --manifest <file> is required\n`); return EXIT.usage; }
+  const m = readManifest(file);
+  if (cmd === 'show') { process.stdout.write(`MANIFEST_JSON: ${JSON.stringify(m)}\n`); return EXIT.ok; }
+  if (cmd === 'stage') {
+    const stage = flag('--stage') as Stage | undefined;
+    if (!stage || !STAGES.includes(stage)) { process.stderr.write(`gstack-review-dispatch stage: --stage ${STAGES.join('|')}\n`); return EXIT.usage; }
+    const done = renderStage(m, stage, sectionTexts(ROOT), branchDiff);
+    writeManifest(file, m);
+    process.stdout.write([`STAGE: ${stage} rendered=${done.length}`, ...done.map(r => readerLine(m, r))].join('\n') + '\n');
+    return EXIT.ok;
+  }
+  if (cmd === 'chunk') {
+    const r = m.readers.find(x => x.reader === flag('--reader'));
+    if (!r?.file || !r.sha256) { process.stderr.write(`gstack-review-dispatch chunk: no rendered reader ${flag('--reader')}\n`); return EXIT.usage; }
+    const text = readFile(r.file, 'brief')!;
+    if (promptHash(text) !== r.sha256) throw new BriefError(`${r.reader}'s brief ${r.file} changed since it was rendered`);
+    const index = Number(flag('--index') ?? '0');
+    process.stdout.write(`BRIEF_CHUNK: reader=${r.reader} index=${index} of=${chunkCount(text)} sha256=${r.sha256}\n${JSON.stringify(chunkOf(text, index))}\n`);
+    return EXIT.ok;
+  }
+  if (cmd === 'mark') {
+    const logStart = flag('--log-start');
+    if (logStart) {
+      const token = flag('--token');
+      if (!token) { process.stderr.write('gstack-review-dispatch mark: --log-start <key> --token <t>\n'); return EXIT.usage; }
+      m.log_starts ??= {};
+      m.log_starts[logStart] ??= token;
+      writeManifest(file, m);
+      process.stdout.write(`LOG_START: ${logStart} token=${m.log_starts[logStart]}\n`);
+      return EXIT.ok;
+    }
+    const before = flag('--before');
+    if (before) {
+      const [tokens, credits] = before.split(',').map(Number);
+      if (!Number.isFinite(tokens) || !Number.isFinite(credits)) { process.stderr.write('gstack-review-dispatch mark: --before <tokens>,<credits>\n'); return EXIT.usage; }
+      m.before ??= { tokens: tokens!, credits: credits! };
+      writeManifest(file, m);
+      process.stdout.write(`BEFORE: tokens=${m.before.tokens} credits=${m.before.credits}\n`);
+      return EXIT.ok;
+    }
+    const r = markReader(m, flag('--reader') ?? '', flag('--state') as ReaderState, { path: flag('--path'), output: flag('--output'), error: flag('--error') });
+    writeManifest(file, m);
+    process.stdout.write(readerLine(m, r) + '\n');
+    return EXIT.ok;
+  }
+  return EXIT.usage;
+}
+
+function program(): number {
+  const text = readFile(PROGRAM_FILE, 'pass program')!;
+  const sha = promptHash(text);
+  const ledger = flag('--ledger');
+  if (ledger) appendEvent(ledger, { event: 'program', version: PROGRAM_VERSION, sha256: sha });
+  process.stdout.write(`PROGRAM: v${PROGRAM_VERSION} sha256=${sha} bytes=${Buffer.byteLength(text)}\n${JSON.stringify(text)}\n`);
+  return EXIT.ok;
+}
+
 /**
  * The receipt's review_targeted record from the newest targeted dispatch: done only when its brief was sent verbatim, its output
  * collected, and the committed diff it was rendered on is still the one at verify (targetedPatchId; uncommitted never proves it).
@@ -117,6 +249,9 @@ function main(): number {
   const cmd = args[0];
   if (!cmd || cmd === '--help' || cmd === '-h') { process.stdout.write(HELP + '\n'); return cmd ? EXIT.ok : EXIT.usage; }
   if (cmd === 'render') return render();
+  if (cmd === 'pass') return pass();
+  if (cmd === 'program') return program();
+  if (['show', 'stage', 'chunk', 'mark'].includes(cmd)) return passStep(cmd);
   const ledger = flag('--ledger');
   if (!ledger) { process.stderr.write(`gstack-review-dispatch ${cmd}: --ledger <file> is required\n`); return EXIT.usage; }
   const reader = flag('--role') ? readerKey(flag('--role')!, flag('--name')) : '';

capy/skill/gstack/SKILL.md

@@ -38,7 +38,7 @@ If no specific skill was requested, use the router's task-to-skill mapping. Read
 
 For `/autoplan` driven from Capy, read `autoplan/DRIVER.md` in the checkout (`~/.local/share/gstack/autoplan/DRIVER.md`): the compact phase loop, artifact contract and gate protocol, without the interactive preamble. A checkout without that file predates it; follow its `autoplan/SKILL.md` instead. Run every command with the `GSTACK_LAUNCH` assignments and read outputs as files, not prose: the run directory holds `run.json`, `decisions.jsonl`, `findings.jsonl`, `tasks.jsonl`, `timing.json`, `plan.md` and `review-record.md`, and the run ends with `GSTACK_RESULT: skill=autoplan status=gate_pending run=<dir>`. `~/.local/share/gstack/bin/gstack-artifact validate <dir>/run.json` is the completion check. The gate is answered through `gstack-autoplan answer` (or `gstack-gate parse`) with the printed `gate_rev`; an unattended run never approves its own gate. `docs/unattended.md` in the checkout is the contract.
 
-For `/ship` driven from Capy, read `ship/DRIVER.md` in the checkout (`~/.local/share/gstack/ship/DRIVER.md`): the phase loop at one or two calls per phase, and the section each STOP needs. A checkout without that file predates it; follow its `ship/SKILL.md` instead. It starts the budget with `--mode observe`, and its review phases run their sections as written.
+For `/ship` driven from Capy, read `ship/DRIVER.md` in the checkout (`~/.local/share/gstack/ship/DRIVER.md`): the phase loop at one or two calls per phase, and the section each STOP needs. A checkout without that file predates it; follow its `ship/SKILL.md` instead.
 
 Run directories and scratch on Capy live under `~/.capy/work/<name>` (`--out ~/.capy/work/<project>/autoplan`), never `/tmp`: Capy wipes `/tmp` when a machine sleeps, and a vanished run cannot be resumed, answered or exported. The same holds for any file a later turn reads.
 
@@ -46,7 +46,7 @@ Capy checklist for `/autoplan`: drive `gstack-autoplan`, never a hand adaptation
 
 Token caps on /ship: pass a brief's cap as `--token-cap <n>`. /ship reads `cost.tokens` and `cost.credits` from `tools.thread.get({ thread_id: "<your own jam id>" })` (its own jam, subagents included; `"this"` names the root thread, so only a root run may pass it) inside the same execute program as the `gstack-ship-budget` command that takes them as `--reading <n> --credits <c>`, never in a call of its own. `ship/DRIVER.md` starts `--mode observe`: each program ends with `note`, and only a note past the cap stops (`docs/ship-budget.md`).
 
-/ship on Capy is about a dozen calls, each one execute program (`ship/DRIVER.md`). A review pass, Step 11 and the Step 14.5 audit each run inside one program, in order: (1) `gstack-review-plan --base <base>` with the pass's flags (its `DISPATCH:` lines); (2) `gstack-review-log --start <skill>` once per row the step logs (admission mode: `--reservation` from `RESERVATION_ID:`); (3) `BEFORE`; (4) `tools.subagent.create`, one reader each, `machine: "shared"`, reasoning from its `effort=` (`full` the lane's, `medium` medium, `light` low), its brief copied verbatim from the section that dispatches it (a rendered file via bash `cat`, never a file read); audit readers (Steps 7, 8, 9.2.1, 14.5) cannot block, so they add `model: { model_id: "anthropic/claude-sonnet-5-5", reasoning_mode: "low" }` (`anthropic/claude-haiku-5-5` also fits); (5) a poll: one `tools.subagent.list` per ~20 s tick (a `tools.subagent.get` with `transcript: "none"` only on a status change), returning 200 s after the program's first line, where a reader is settled only at status `done` or `failed` or with a `summary` (a just-created `idle` reader has not run); start readers listed under `rejected` with `tools.subagent.start` as slots free; report one stuck 20 minutes; (6) `gstack-ship-budget note --record <rec> --step <n> --reading <AFTER> --credits <c> --dispatched-at <BEFORE> --dispatched-credits <c> --readers <n>`; (7) return only each reader's final output. The parent never walks the dispatch steps call by call. Waits: never let 5 minutes pass between calls. While readers run, never end the turn on `wait`; rerun the poll program. Otherwise re-issue `wait` with `duration_seconds: 200` and the operation ids. At Step 22 report the `CALLS:` line of `gstack-ship-budget calls --events <file>` on your jam's transcript since /ship started. A small waiting child saves nothing.
+/ship on Capy is about a dozen calls, each one execute program (`ship/DRIVER.md`). Each review pass and Step 11 is one call to the checked-in pass program (fill only `input`): `const t0 = await now(); const p = (await tools.capy.bash({ command: ". '<launch file>' && gstack-review-dispatch program", description: "Pass" })).output.split("\n"); return p[0] + "\n" + (await new (Object.getPrototypeOf(async () => {}).constructor)("tools", "sleep", "now", "input", JSON.parse(p[1]))(tools, sleep, now, { startedAt: t0, launch: "<launch file>", cwd: "<repo>", base: "<base>", out: "<run dir>/p<n>", pass: "<run>-p<n>", laneModel: "<your model id>", planFlags: [], logStart: ["review"], jam: "<jam id>", record: "<rec>", step: "9.2" }));` It plans, logs `logStart` (`reservation` mode from `RESERVATION_ID:`), sends each brief on `machine: "shared"`, then polls: one `tools.subagent.list` per ~20 s tick, returning 200 s after the program's first line, where a reader is settled only at status `done` or `failed` or with a `summary` (a just-created `idle` reader has not run); it starts readers listed under `rejected` with `tools.subagent.start` as slots free and stops on one stuck 20 minutes. It ends on `NEXT: judge`, `NEXT: poll` (rerun) or `STOP:`. `models` maps a role to its model (`outside-voice`: another family); Step 11 adds `stage: "voices"`. Steps 7, 8 and 9.2.1 go in `extras`, JSON `{name, prompt_file, first, model}` (prompts verbatim from their sections, Step 7 `first`); they cannot block, so `model: { model_id: "anthropic/claude-sonnet-5-5", reasoning_mode: "low" }` (`anthropic/claude-haiku-5-5` also fits). Waits: never let 5 minutes pass between calls. While readers run, never end the turn on `wait`; rerun the loader. Otherwise re-issue `wait` with `duration_seconds: 200` and operation ids. At Step 22 report the `CALLS:` line of `gstack-ship-budget calls --events <file>` on your jam's transcript since /ship started. A small waiting child saves nothing.
 
 ## Plan, approve, ship
 

docs/review-policy.md

@@ -490,10 +490,23 @@ ones, and the arm lost blockers. `bin/gstack-review-dispatch` closes both ends:
    against the merged lines they produced, and the judgment rerun against the
    recorded judged set, covering every collected id. A ledger from a run that kept no
    prompts prints `VERIFY: no brief records` (exit 3), never clean.
+6. `pass --base <b> --out <dir> --pass <id> -- <plan flags>` runs one pass from a
+   staged manifest (`<dir>/pass-manifest.json`): audit readers marked first, then
+   the specialists with QA and the other audits, then the Red Team, then Step 11's
+   voices. Each reviewer keeps its plan entry and is rendered by the same code as
+   `render`, once its inputs exist; the Red Team's findings file is the specialists'
+   `merged.jsonl` lines byte for byte. A brief leaves the bin in indexed chunks of at
+   most 65,536 characters (`chunk`), so no tool output line carries a whole brief and a
+   host's line or output cap cannot cut one. Each reader's intent is recorded before its
+   subagent is created and its path right after (`mark`), so a resumed pass finds a
+   create whose result was lost by its title and never starts a reader twice; a
+   missing or doubled title stops the pass. On Capy the pass runs as one call to the
+   checked-in program `lib/capy-review-pass.js`, served by `program` and loaded
+   unchanged by the gstack Capy skill.
 
 ## Where this is enforced
 
-- `lib/review-brief.ts`, `lib/review-ledger.ts`, `bin/gstack-review-dispatch`: [verbatim dispatch](#verbatim-dispatch) (`test/review-dispatch.test.ts`).
+- `lib/review-brief.ts`, `lib/review-ledger.ts`, `lib/review-pass.ts`, `lib/capy-review-pass.js`, `bin/gstack-review-dispatch`: [verbatim dispatch](#verbatim-dispatch) (`test/review-dispatch.test.ts`, `test/review-pass.test.ts`).
 
 - `scripts/resolvers/review-army.ts`: the floor and `NO FINDINGS` in every specialist and Red Team prompt (rendered into `review/sections/review-army.md` and `ship/sections/review-army.md`), and the lead judgment's "On record" line that turns a [ruled class](#rulings-below-the-floor) into a note; in `/ship` every specialist and Red Team prompt it renders carries its diff base as a literal sha the parent writes in (`DIFF_BASE=<diff-base>`: the merge base on pass 1, `RANGE_BASE` from pass 2 on) beside its plan's `DIFF_CMD` excludes, because a reviewer is its own process and never sees the parent's shell variables; the fan-out batches above.
 - `ship/sections/review-army.md` Step 9: the plan's `REVIEW_DEPTH`, `GATE_SCAN` and `--depth-floor` on every run, the depth fields of the review-log row, passes, `RANGE_BASE`, classify, defer, render, the cap check before any edit, the Step 11 late-defer row, scratch files under `.gstack/tmp/`, the cap decisions; `ship/sections/adversarial.md` Step 11: the outside voice reads the same range and scopes queued fixes the same way.

lib/capy-review-pass.js

@@ -0,0 +1,196 @@
+// gstack /ship review pass program for Capy (lib/capy-review-pass.js, GSTA-167 calls PR 2).
+// The body of an async function (tools, sleep, now, input), loaded verbatim by the loader in
+// ship/DRIVER.md from `gstack-review-dispatch program`; never retyped. One call runs one pass or Step 11's
+// voices from the manifest `gstack-review-dispatch pass` writes: render, chunked brief transport, `sent`,
+// intent before create, create, poll, collect. It returns 200 s after the loader's first line
+// (input.startedAt) at most; the next call resumes from the manifest. A failed, stuck or ambiguous
+// reader, a brief mismatch or a failing bin returns `STOP:` for the parent; nothing is dropped.
+const T0 = input.startedAt ?? (await now());
+const deadline = T0 + (input.budgetMs ?? 200000);
+const tick = input.tickMs ?? 20000;
+const stuckMs = input.stuckMs ?? 20 * 60000;
+const emptyGraceMs = 60000;
+const emptyDone = {};
+const RETURN_BYTES = 32000;
+const q = (s) => "'" + String(s).replace(/'/g, "'\\''") + "'";
+const lines = [];
+const sh = async (cmd) => {
+  const r = await tools.capy.bash({ command: (input.launch ? '. ' + q(input.launch) + ' && ' : '') + (input.cwd ? 'cd ' + q(input.cwd) + ' && ' : '') + cmd, description: 'Ship review pass ' + input.pass, timeout: 300 });
+  return { code: r.exit_code, out: r.output || '' };
+};
+const bin = 'gstack-review-dispatch';
+const finish = (tail) => {
+  const all = [...lines, ...tail];
+  let text = all.join('\n');
+  if (text.length > RETURN_BYTES) text = text.slice(0, RETURN_BYTES) + '\n(return capped at 32 KB; the rest is in the files named above)';
+  return text;
+};
+const stop = (why) => finish(['STOP: ' + why]);
+
+const passCmd = [bin, 'pass', '--base', q(input.base), '--out', q(input.out), '--pass', q(input.pass)];
+if (input.ledger) passCmd.push('--ledger', q(input.ledger));
+if (input.extras && typeof input.extras !== 'string') {
+  const file = input.out.replace(/\/+$/, '') + '/extras.json';
+  await tools.capy.write({ path: file, content: JSON.stringify(Array.isArray(input.extras) ? input.extras : [input.extras]) });
+  passCmd.push('--extras', q(file));
+} else if (input.extras) passCmd.push('--extras', q(input.extras));
+if (input.learnings) passCmd.push('--learnings-file', q(input.learnings));
+passCmd.push('--', ...(input.planFlags || []).map(q));
+const pr = await sh(passCmd.join(' '));
+if (pr.code !== 0) return stop('gstack-review-dispatch pass exited ' + pr.code + ': ' + pr.out.slice(-1500));
+const passOut = pr.out.trimEnd().split('\n');
+if (passOut[passOut.length - 1].startsWith('PASS: none ')) return finish(passOut);
+const resumed = passOut.some((l) => l.startsWith('MANIFEST: ') && l.endsWith(' resumed'));
+lines.push(...passOut.filter((l) => !resumed || l.startsWith('MANIFEST: ')));
+const mf = input.out.replace(/\/+$/, '') + '/pass-manifest.json';
+
+const load = async () => {
+  const r = await sh(bin + ' show --manifest ' + q(mf));
+  const at = r.out.indexOf('MANIFEST_JSON: ');
+  if (r.code !== 0 || at < 0) throw new Error('show failed: ' + r.out.slice(-500));
+  return JSON.parse(r.out.slice(at + 15).split('\n')[0]);
+};
+const mark = async (reader, state, extra) => {
+  let cmd = bin + ' mark --manifest ' + q(mf) + ' --reader ' + q(reader) + ' --state ' + state;
+  for (const [k, v] of Object.entries(extra || {})) cmd += ' --' + k + ' ' + q(v);
+  const r = await sh(cmd);
+  if (r.code !== 0) throw new Error('mark ' + reader + ' ' + state + ' failed: ' + r.out.slice(-500));
+};
+const reading = async () => {
+  if (!input.record || !input.jam) return null;
+  const t = await tools.thread.get({ thread_id: input.jam });
+  return { tokens: t.cost.tokens, credits: t.cost.credits };
+};
+const briefText = async (r) => {
+  let text = '';
+  for (let i = 0; i < r.chunks; i++) {
+    const c = await sh(bin + ' chunk --manifest ' + q(mf) + ' --reader ' + q(r.reader) + ' --index ' + i);
+    const nl = c.out.indexOf('\n');
+    const head = c.out.slice(0, nl);
+    if (c.code !== 0 || !head.startsWith('BRIEF_CHUNK: ') || !head.includes(' of=' + r.chunks + ' ') || !head.endsWith('sha256=' + r.sha256)) throw new Error('chunk ' + i + ' of ' + r.reader + ': ' + c.out.slice(0, 300));
+    text += JSON.parse(c.out.slice(nl + 1).split('\n')[0]);
+  }
+  return text;
+};
+const roleArgs = (r) => ' --role ' + q(r.role) + (r.name ? ' --name ' + q(r.name) : '');
+const REASONING = { medium: 'medium', light: 'low' };
+const modelOf = (r) => r.model || (input.models || {})[r.role === 'specialist-batched' ? 'specialist' : r.role]
+  || (REASONING[r.effort] && input.laneModel ? { model_id: input.laneModel, reasoning_mode: REASONING[r.effort] } : undefined);
+const safe = (s) => s.replace(/[^a-zA-Z0-9._-]/g, '_');
+const active = input.stage === 'voices' ? ['voices'] : ['first', 'specialists', 'red-team'];
+
+try {
+  let m = await load();
+  if (input.stage === 'voices' && !m.readers.some((r) => r.stage === 'voices')) return finish(['VOICES: none (the pass plan lists no Step 11 voice)', 'NEXT: judge']);
+  for (const s of input.logStart || []) {
+    const key = (input.stage === 'voices' ? 'voices:' : 'pass:') + s;
+    if ((m.log_starts || {})[key]) continue;
+    const l = await sh('gstack-review-log --start ' + s.split(' ').map(q).join(' ') + (input.reservation ? ' --reservation ' + q(input.reservation) : ''));
+    if (l.code !== 0) return stop('gstack-review-log --start ' + s + ' exited ' + l.code + ': ' + l.out.slice(-500));
+    const token = l.out.trim();
+    const k = await sh(bin + ' mark --manifest ' + q(mf) + ' --log-start ' + q(key) + ' --token ' + q(token));
+    if (k.code !== 0) return stop('recording the ' + s + ' start token exited ' + k.code + ': ' + k.out.slice(-500));
+    lines.push('REVIEW_LOG_START: ' + s + ' token=' + token);
+  }
+  for (;;) {
+    const failed = m.readers.find((x) => active.includes(x.stage) && x.state === 'failed');
+    if (failed) return stop(failed.reader + ' (subagent ' + failed.path + ') ' + (failed.error || 'failed') + '; its review is incomplete, so the pass cannot certify coverage; restore it with a fresh pass under a new --pass and --out');
+    const list = await tools.subagent.list({});
+    const byTitle = (t) => list.tasks.filter((x) => x.title === t);
+    const byPath = new Map(list.tasks.map((x) => [x.path, x]));
+    for (const r of m.readers.filter((x) => active.includes(x.stage) && x.state === 'intent')) {
+      const found = byTitle(r.title);
+      if (found.length !== 1) return stop(r.reader + ' was being created when the last program ended and ' + found.length + ' subagents carry its title "' + r.title + '"; check them by hand before any rerun');
+      await mark(r.reader, found[0].status === 'draft' ? 'queued' : 'created', { path: found[0].path });
+    }
+    m = await load();
+    for (const r of m.readers.filter((x) => active.includes(x.stage) && x.state === 'queued')) {
+      const t = byPath.get(r.path);
+      if (t && t.status !== 'draft') { await mark(r.reader, 'created', {}); continue; }
+      const model = modelOf(r);
+      const s = await tools.subagent.start({ indices: [Number(r.path)], machine: 'shared', ...(model ? { model } : {}) });
+      if ((s.started || []).length) await mark(r.reader, 'created', {});
+      else if (r.state_at && (await now()) - Date.parse(r.state_at) > stuckMs) return stop(r.reader + ' (subagent ' + r.path + ') still queued after ' + Math.round(stuckMs / 60000) + ' minutes; free a subagent slot, then rerun');
+    }
+    for (const r of m.readers.filter((x) => active.includes(x.stage) && x.state === 'created')) {
+      const t = byPath.get(r.path);
+      if (!t) return stop(r.reader + "'s subagent " + r.path + ' is missing from the subagent list');
+      if (t.status === 'failed' || t.status === 'stopped') { await mark(r.reader, 'failed', { error: t.status }); return stop(r.reader + ' (subagent ' + r.path + ') ' + t.status + '; its review is incomplete, so the pass cannot certify coverage'); }
+      const stuck = async () => r.state_at && (await now()) - Date.parse(r.state_at) > stuckMs;
+      const g = t.status === 'done' || t.status === 'idle' ? await tools.subagent.get({ path: r.path, transcript: 'none' }) : null;
+      if (!g || !g.summary) {
+        if (t.status === 'done') {
+          const seen = (emptyDone[r.reader] ??= await now());
+          if ((await now()) - seen >= emptyGraceMs) return stop(r.reader + ' (subagent ' + r.path + ') finished with no output');
+          continue;
+        }
+        if (await stuck()) return stop(r.reader + ' (subagent ' + r.path + ') still ' + t.status + ' after ' + Math.round(stuckMs / 60000) + ' minutes with no output');
+        continue;
+      }
+      const file = m.out + '/out/' + safe(r.reader) + '.txt';
+      await tools.capy.write({ path: file, content: g.summary });
+      if (!r.prompt_file) {
+        const c = await sh(bin + ' collect --ledger ' + q(m.ledger) + roleArgs(r) + ' --output ' + q(file) + ' --merged ' + q(m.merged));
+        if (c.code !== 0) return stop('collect ' + r.reader + ' exited ' + c.code + ': ' + c.out.slice(-500));
+        lines.push(c.out.trim());
+      }
+      await mark(r.reader, 'collected', { output: file });
+    }
+    m = await load();
+    const stage = active.find((s) => m.readers.some((r) => r.stage === s && r.state !== 'collected'));
+    if (!stage) break;
+    if (m.readers.some((r) => r.stage === stage && r.state === 'planned')) {
+      const s = await sh(bin + ' stage --manifest ' + q(mf) + ' --stage ' + stage);
+      if (s.code !== 0) return stop('stage ' + stage + ' exited ' + s.code + ': ' + s.out.slice(-800));
+      lines.push(...s.out.trim().split('\n'));
+      m = await load();
+    }
+    if (m.readers.some((x) => x.stage === stage && x.role === 'outside-voice' && x.state === 'rendered' && !modelOf(x))) return stop("the outside voice needs input.models['outside-voice'] (a model of another family); none was given");
+    const unmapped = m.readers.find((x) => x.stage === stage && x.state === 'rendered' && REASONING[x.effort] && !modelOf(x));
+    if (unmapped) return stop(unmapped.reader + ' runs at effort=' + unmapped.effort + ', which needs input.laneModel (your model id) or input.models; none was given');
+    for (const r of m.readers.filter((x) => x.stage === stage && x.state === 'rendered')) {
+      const model = modelOf(r);
+      const text = await briefText(r);
+      const sent = m.out + '/sent/' + safe(r.reader) + '.txt';
+      await tools.capy.write({ path: sent, content: text });
+      if (!r.prompt_file) {
+        const s = await sh(bin + ' sent --ledger ' + q(m.ledger) + roleArgs(r) + ' --sent ' + q(sent));
+        if (s.code !== 0) return stop(s.out.trim());
+        lines.push(s.out.trim());
+      }
+      if (!m.before) {
+        const b = await reading();
+        if (b) { await sh(bin + ' mark --manifest ' + q(mf) + ' --before ' + b.tokens + ',' + b.credits); m.before = b; }
+      }
+      await mark(r.reader, 'intent', {});
+      const res = await tools.subagent.create({ tasks: [{ title: r.title, prompt: text }], start: { machine: 'shared', ...(model ? { model } : {}) } });
+      const idx = String(res.tasks[0].index);
+      const queued = (res.rejected || []).some((x) => String(x.index) === idx);
+      await mark(r.reader, queued ? 'queued' : 'created', { path: idx });
+      lines.push('DISPATCHED: ' + r.reader + ' path=' + idx + (queued ? ' queued (subagent cap; started as a slot frees)' : ''));
+    }
+    m = await load();
+    if ((await now()) + tick >= deadline) {
+      const open = m.readers.filter((r) => active.includes(r.stage) && r.state !== 'collected');
+      return finish([...open.map((r) => 'RUNNING: ' + r.reader + ' state=' + r.state + (r.path ? ' path=' + r.path : '')), 'NEXT: poll (run this same program again now; it resumes from the manifest)']);
+    }
+    await sleep(tick);
+  }
+  const done = m.readers.filter((r) => active.includes(r.stage));
+  const after = await reading();
+  let noteExit = 0;
+  if (after && m.before && input.record && input.step) {
+    const n = await sh('gstack-ship-budget note --step ' + q(input.step) + ' --reading ' + after.tokens + ' --credits ' + after.credits + ' --record ' + q(input.record) + ' --dispatched-at ' + m.before.tokens + ' --dispatched-credits ' + m.before.credits + ' --readers ' + done.length);
+    lines.push(n.out.trim());
+    noteExit = n.code;
+  }
+  const outs = [];
+  for (const r of done) {
+    const o = await sh('cat ' + q(r.output));
+    outs.push('OUTPUT: ' + r.reader + ' file=' + r.output, o.out.trimEnd());
+  }
+  if (noteExit !== 0) return finish([...outs, 'STOP: gstack-ship-budget note exited ' + noteExit + ' (its lines above say why); judge nothing further until the budget allows it']);
+  return finish([...outs, input.stage === 'voices' ? 'NEXT: judge the voices' : 'NEXT: judge (Phase 4)']);
+} catch (e) {
+  return stop('pass program error: ' + (e && e.message ? e.message : String(e)) + ' (the manifest keeps every recorded reader; rerun resumes)');
+}

lib/review-ledger.ts

@@ -18,7 +18,7 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { promptHash } from './review-brief';
 
-export interface LedgerEvent { event: 'rendered' | 'sent' | 'output' | 'judgment' | 'judge'; [k: string]: unknown }
+export interface LedgerEvent { event: 'rendered' | 'sent' | 'output' | 'judgment' | 'judge' | 'program'; [k: string]: unknown }
 export const readerKey = (role: string, name?: string) => (name ? `${role}/${name}` : role);
 
 export function appendEvent(ledger: string, e: LedgerEvent): void {

lib/review-pass.ts

@@ -0,0 +1,191 @@
+/**
+ * review-pass — one staged dispatch manifest per /ship review pass (GSTA-167 calls PR 2).
+ *
+ * gstack-review-dispatch pass turns gstack-review-plan's dispatches into a manifest: stage `first`
+ * (audit readers that may write tests, so they settle before any reviewer reads the tree), stage
+ * `specialists` (the specialists, plus the other audit and QA readers), stage `red-team` and stage
+ * `voices` (Step 11). Each reviewer keeps its plan entry (role, effort, exclusions) and is rendered
+ * once, when its inputs exist, by lib/review-brief.ts; the Red Team's findings file is the
+ * specialists' merged.jsonl lines, byte for byte. Briefs travel to the dispatch program in bounded
+ * indexed chunks, so no tool output line carries a whole brief. Every reader's dispatch intent is
+ * persisted before its subagent is created and its path right after, so a resumed program
+ * reconciles by deterministic title and never doubles a reader.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { BriefError, briefFile, promptHash, renderBrief, type BriefRole, type SectionTexts, type Slots } from './review-brief';
+import { appendEvent, readerKey } from './review-ledger';
+import { diffCommand, type Dispatch } from './review-depth';
+import { TARGETED_RULES, parseClassList, targetedBriefSha, targetedPatchId } from './review-targeted';
+
+export const STAGES = ['first', 'specialists', 'red-team', 'voices'] as const;
+export type Stage = typeof STAGES[number];
+export type ReaderState = 'planned' | 'rendered' | 'intent' | 'created' | 'queued' | 'collected' | 'failed';
+
+export interface PassModel { model_id: string; reasoning_mode?: string }
+export interface PassReader {
+  reader: string; stage: Stage; title: string; state: ReaderState;
+  role?: BriefRole; name?: string; effort?: string; exclude?: string; checklists?: string[];
+  /** The targeted reader: the plan's TARGETED classes and the merge base it reads on every pass. */
+  classes?: string[]; diff_base?: string;
+  /** An audit or QA reader: its prompt is a file the parent wrote from its section; its output is returned, never collected. */
+  prompt_file?: string; model?: PassModel;
+  file?: string; sha256?: string; bytes?: number; chunks?: number; findings_sha256?: string;
+  path?: string; output?: string; error?: string; state_at?: string;
+}
+export interface Manifest {
+  version: 1; pass: string; out: string; ledger: string; merged: string; base: string; diff_base: string;
+  stack: string; test_fw: string; learnings: string | null; checklist_root: string;
+  next: string; plan_lines: string[]; readers: PassReader[]; before?: { tokens: number; credits: number };
+  log_starts?: Record<string, string>;
+}
+export interface Extra { name: string; prompt_file: string; first?: boolean; model?: PassModel }
+
+/** Brief characters per transport chunk: even with every character escaped, one chunk line stays far under 1 MiB. */
+export const CHUNK_CHARS = 65_536;
+
+/** STACK from Step 9.1's detection block in ship/sections/review-army.md, trimmed. */
+export function detectStack(root: string): string {
+  const has = (f: string) => fs.existsSync(path.join(root, f));
+  const s = [has('Gemfile') && 'ruby', has('package.json') && 'node', (has('requirements.txt') || has('pyproject.toml')) && 'python',
+    has('go.mod') && 'go', has('Cargo.toml') && 'rust', has('pubspec.yaml') && 'dart'].filter(Boolean).join(' ');
+  return s || 'unknown';
+}
+
+/** TEST_FW from the same block: the last matching rule wins. */
+export function detectTestFw(root: string): string {
+  const has = (f: string) => fs.existsSync(path.join(root, f));
+  let fw = '';
+  if (has('jest.config.ts') || has('jest.config.js')) fw = 'jest';
+  if (has('vitest.config.ts')) fw = 'vitest';
+  if (has('spec/spec_helper.rb') || has('.rspec')) fw = 'rspec';
+  if (has('pytest.ini') || has('conftest.py')) fw = 'pytest';
+  if (has('go.mod')) fw = 'go-test';
+  if (has('pubspec.yaml')) fw = /^ +sdk: *.?flutter/m.test(fs.readFileSync(path.join(root, 'pubspec.yaml'), 'utf8')) ? 'flutter-test' : 'dart-test';
+  return fw || 'unknown';
+}
+
+const safe = (reader: string) => reader.replace(/[^a-zA-Z0-9._-]/g, '_');
+const STAGE_OF: Record<string, Stage> = { specialist: 'specialists', 'red-team': 'red-team', 'adversarial-native': 'voices', 'outside-voice': 'voices', targeted: 'voices' };
+
+/** The manifest for one pass from the plan's dispatches. A fix-check is not part of a pass, so it is refused. */
+export function buildManifest(o: {
+  pass: string; out: string; ledger: string; base: string; diffBase: string; root: string; checklistRoot: string;
+  dispatches: Dispatch[]; next: string; planLines: string[]; learnings?: string | null; extras?: Extra[];
+  targetedClasses?: readonly string[]; mergeBase?: string;
+}): Manifest {
+  const readers: PassReader[] = [];
+  for (const d of o.dispatches) {
+    const stage = STAGE_OF[d.role];
+    if (!stage) throw new BriefError(`a pass dispatches no ${d.role} reader (fix-check runs on its own)`);
+    const role: BriefRole = d.role === 'specialist' && d.checklists ? 'specialist-batched' : d.role as BriefRole;
+    const name = role === 'specialist' ? d.name : undefined;
+    const reader = readerKey(role, name);
+    const exclude = d.exclude.length ? diffCommand(d).slice('git diff <diff-base> '.length) : undefined;
+    readers.push({ reader, stage, title: `ship ${o.pass} ${reader}`, state: 'planned', role, name, effort: d.effort, exclude, checklists: d.checklists,
+      ...(role === 'targeted' ? { classes: [...(o.targetedClasses ?? [])], diff_base: o.mergeBase ?? o.diffBase } : {}) });
+  }
+  for (const e of o.extras ?? []) {
+    if (!/^[a-z0-9-]+$/.test(e.name)) throw new BriefError(`an audit reader's name is lowercase letters, digits and dashes: ${e.name}`);
+    readers.push({ reader: `audit/${e.name}`, stage: e.first ? 'first' : 'specialists', title: `ship ${o.pass} audit/${e.name}`, state: 'planned', prompt_file: path.resolve(e.prompt_file), model: e.model });
+  }
+  if (new Set(readers.map(r => r.reader)).size !== readers.length) throw new BriefError('two readers share a key in this pass');
+  const out = path.resolve(o.out);
+  return {
+    version: 1, pass: o.pass, out, ledger: path.resolve(o.ledger), merged: path.join(out, 'merged.jsonl'), base: o.base, diff_base: o.diffBase,
+    stack: detectStack(o.root), test_fw: detectTestFw(o.root), learnings: o.learnings ?? null, checklist_root: o.checklistRoot,
+    next: o.next, plan_lines: o.planLines, readers,
+  };
+}
+
+export const manifestPath = (out: string) => path.join(path.resolve(out), 'pass-manifest.json');
+export function readManifest(file: string): Manifest {
+  let m: Manifest;
+  try { m = JSON.parse(fs.readFileSync(file, 'utf8')) as Manifest; } catch { throw new BriefError(`cannot read the pass manifest ${file}`); }
+  if (m.version !== 1) throw new BriefError(`pass manifest ${file} has version ${String(m.version)}; this gstack reads version 1`);
+  return m;
+}
+export function writeManifest(file: string, m: Manifest): void {
+  const tmp = `${file}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, JSON.stringify(m, null, 1) + '\n', { mode: 0o600 });
+  fs.renameSync(tmp, file);
+}
+
+/** The Red Team's findings file: the specialists' merged lines exactly as collect wrote them. */
+export function specialistFindings(mergedFile: string): string {
+  let text = '';
+  try { text = fs.readFileSync(mergedFile, 'utf8'); } catch { return ''; }
+  const lines = text.split('\n').filter(l => l.trim() && String((JSON.parse(l) as { reader?: unknown }).reader ?? '').startsWith('specialist'));
+  return lines.length ? lines.join('\n') + '\n' : '';
+}
+
+/** Render every planned reader of a stage. The Red Team renders only after every earlier reader is collected. */
+export function renderStage(m: Manifest, stage: Stage, t: SectionTexts, diffFor: (base: string) => string): PassReader[] {
+  const open = m.readers.filter(r => (r.stage === 'first' || r.stage === 'specialists') && r.state !== 'collected');
+  if (stage === 'red-team' && open.length) throw new BriefError(`the Red Team renders after every earlier reader is collected; still open: ${open.map(r => r.reader).join(', ')}`);
+  const briefs = path.join(m.out, 'briefs');
+  fs.mkdirSync(briefs, { recursive: true, mode: 0o700 });
+  const done: PassReader[] = [];
+  for (const r of m.readers.filter(x => x.stage === stage && x.state === 'planned')) {
+    if (r.prompt_file) {
+      let text: string;
+      try { text = fs.readFileSync(r.prompt_file, 'utf8'); } catch { throw new BriefError(`cannot read ${r.reader}'s prompt file ${r.prompt_file}`); }
+      Object.assign(r, { file: r.prompt_file, sha256: promptHash(text), bytes: Buffer.byteLength(text), chunks: chunkCount(text), state: 'rendered' });
+      done.push(r);
+      continue;
+    }
+    const role = r.role!;
+    const slots: Slots = { name: r.name, diff_base: m.diff_base, exclude: r.exclude, stack: m.stack, test_fw: m.test_fw, learnings: m.learnings ?? undefined,
+      checklists: r.checklists?.map(n => path.join(m.checklist_root, 'review/specialists', `${n}.md`)).join(',') };
+    if (role === 'specialist') slots.checklist = path.join(m.checklist_root, 'review/specialists', `${r.name}.md`);
+    let findingsSha: string | undefined;
+    if (role === 'red-team') {
+      const findings = specialistFindings(m.merged);
+      fs.writeFileSync(path.join(briefs, 'specialist-findings.jsonl'), findings, { mode: 0o600 });
+      findingsSha = promptHash(findings);
+      const specialists = m.readers.reduce((n, x) => n + (x.role === 'specialist' ? 1 : x.role === 'specialist-batched' ? (x.checklists ?? []).filter(c => c !== 'red-team').length : 0), 0);
+      Object.assign(slots, { checklist: path.join(m.checklist_root, 'review/specialists/red-team.md'), findings, specialists: String(specialists) });
+    }
+    if (role === 'outside-voice') slots.diff = diffFor(m.diff_base);
+    let targeted = {};
+    if (role === 'targeted') {
+      const checklist = path.join(m.checklist_root, 'review/specialists/targeted.md');
+      let brief: string;
+      try { brief = fs.readFileSync(checklist, 'utf8'); } catch { throw new BriefError(`cannot read the targeted brief ${checklist}`); }
+      Object.assign(slots, { checklist, brief, classes: (r.classes ?? []).join(','), diff_base: r.diff_base ?? m.diff_base });
+      targeted = { classes: parseClassList(slots.classes!), rules: TARGETED_RULES, brief_sha: targetedBriefSha(checklist), diff_base: slots.diff_base, patch_id: targetedPatchId(process.cwd(), slots.diff_base!) };
+    }
+    const text = renderBrief(role, slots, t);
+    const file = path.join(briefs, briefFile(role, r.name));
+    fs.writeFileSync(file, text, { mode: 0o600 });
+    const sha = promptHash(text);
+    const bytes = Buffer.byteLength(text);
+    appendEvent(m.ledger, { event: 'rendered', reader: r.reader, role, name: r.name ?? null, file, sha256: sha, bytes, pass: m.pass, stage, ...(findingsSha ? { findings_sha256: findingsSha } : {}), ...targeted });
+    Object.assign(r, { file, sha256: sha, bytes, chunks: chunkCount(text), state: 'rendered', ...(findingsSha ? { findings_sha256: findingsSha } : {}) });
+    done.push(r);
+  }
+  return done;
+}
+
+export const chunkCount = (text: string) => Math.max(1, Math.ceil(text.length / CHUNK_CHARS));
+export function chunkOf(text: string, index: number): string {
+  if (!Number.isInteger(index) || index < 0 || index >= chunkCount(text)) throw new BriefError(`chunk index ${index} is outside 0..${chunkCount(text) - 1}`);
+  return text.slice(index * CHUNK_CHARS, (index + 1) * CHUNK_CHARS);
+}
+
+const NEXT_STATE: Record<ReaderState, ReaderState[]> = {
+  planned: [], rendered: ['intent'], intent: ['created', 'queued'], queued: ['created'], created: ['collected', 'failed'], collected: [], failed: [],
+};
+
+/** Record one transition: intent before create, a subagent path with created or queued, never backward. */
+export function markReader(m: Manifest, reader: string, to: ReaderState, extra: { path?: string; output?: string; error?: string } = {}): PassReader {
+  const r = m.readers.find(x => x.reader === reader);
+  if (!r) throw new BriefError(`no reader ${reader} in pass ${m.pass}`);
+  if (!NEXT_STATE[r.state].includes(to)) throw new BriefError(`${reader} is ${r.state}; it cannot become ${to}`);
+  if ((to === 'created' || to === 'queued') && !extra.path && !r.path) throw new BriefError(`${reader} becomes ${to} only with its subagent path`);
+  Object.assign(r, { state: to, state_at: new Date().toISOString() }, extra.path ? { path: extra.path } : {}, extra.output ? { output: extra.output } : {}, extra.error ? { error: extra.error } : {});
+  return r;
+}
+
+export const sentFile = (m: Manifest, reader: string) => path.join(m.out, 'sent', `${safe(reader)}.txt`);
+export const outputFile = (m: Manifest, reader: string) => path.join(m.out, 'out', `${safe(reader)}.txt`);

package.json

@@ -1,6 +1,6 @@
 {
   "name": "gstack",
-  "version": "1.91.361",
+  "version": "1.91.362",
   "description": "Garry's Stack — Claude Code skills + fast headless browser. One repo, one install, entire AI engineering workflow.",
   "license": "MIT",
   "type": "module",

ship/DRIVER.md

@@ -23,7 +23,7 @@ version, CHANGELOG, commits), **Documentation** (Step 14.5) and **Next steps** (
 
 **Reviewers are the sections' own.** Every audit, specialist, Red Team, QA, fix-check, adversarial,
 outside-voice and documentation brief, its severity and confidence rules and its gates come from its
-section verbatim, with only its placeholders filled. This file restates none of them and
+section verbatim, with only its placeholders filled; this file
 never shortens a reviewer's brief. A blocking reader's prompt is its `gstack-review-dispatch render`
 file, unchanged; its findings reach `merged.jsonl` only via `collect`; `judge` refuses a drop or downgrade. Audit readers (Steps 7, 8, 9.2.1, 14.5) cannot block, so each runs on a
 small model at low effort; their findings go to the PR body.
@@ -44,10 +44,10 @@ readers run (each wakes it). A small waiting child saves nothing. Past 100 minut
 ≤32 KB per program; split longer reads at headings, each byte once, before first use.
 
 **One program per pass.** Each review pass, Step 11 and the Step 14.5 audit is one program, and the
-parent makes no other call while it runs: (1) `gstack-review-plan --base <base>` with the pass's
-flags (its `DISPATCH:` lines; Step 14.5 has one reader, `docs`); (2) `gstack-review-log --start
-<skill>` once per row the step logs (Step 14.5 takes none); (3) `BEFORE`; (4) one subagent per reader on its rendered file, then
-`sent` (`BRIEF_MISMATCH` voids it);
+parent makes no other call while it runs: (1) `gstack-review-dispatch pass`: `gstack-review-plan --base <base>`
+with the pass's flags, then its staged manifest (Step 14.5 has one reader, `docs`); (2) `gstack-review-log --start
+<skill>` once per row the step logs (Step 14.5 takes none); (3) `BEFORE`; (4) `sent` (`BRIEF_MISMATCH` voids it), then one
+subagent per reader on its rendered file;
 (5) a poll until every reader settles (status `done` or `failed`, or a final summary; a fresh `idle`
 has not run); (6) `note` with the reading pair; a later batch (the Red Team,
 given the specialists' collected lines) repeats (3)-(6); (7) the collect: return only each reader's

ship/DRIVER.md.tmpl

@@ -21,7 +21,7 @@ version, CHANGELOG, commits), **Documentation** (Step 14.5) and **Next steps** (
 
 **Reviewers are the sections' own.** Every audit, specialist, Red Team, QA, fix-check, adversarial,
 outside-voice and documentation brief, its severity and confidence rules and its gates come from its
-section verbatim, with only its placeholders filled. This file restates none of them and
+section verbatim, with only its placeholders filled; this file
 never shortens a reviewer's brief. A blocking reader's prompt is its `gstack-review-dispatch render`
 file, unchanged; its findings reach `merged.jsonl` only via `collect`; `judge` refuses a drop or downgrade. Audit readers (Steps 7, 8, 9.2.1, 14.5) cannot block, so each runs on a
 small model at low effort; their findings go to the PR body.
@@ -42,10 +42,10 @@ readers run (each wakes it). A small waiting child saves nothing. Past 100 minut
 ≤32 KB per program; split longer reads at headings, each byte once, before first use.
 
 **One program per pass.** Each review pass, Step 11 and the Step 14.5 audit is one program, and the
-parent makes no other call while it runs: (1) `gstack-review-plan --base <base>` with the pass's
-flags (its `DISPATCH:` lines; Step 14.5 has one reader, `docs`); (2) `gstack-review-log --start
-<skill>` once per row the step logs (Step 14.5 takes none); (3) `BEFORE`; (4) one subagent per reader on its rendered file, then
-`sent` (`BRIEF_MISMATCH` voids it);
+parent makes no other call while it runs: (1) `gstack-review-dispatch pass`: `gstack-review-plan --base <base>`
+with the pass's flags, then its staged manifest (Step 14.5 has one reader, `docs`); (2) `gstack-review-log --start
+<skill>` once per row the step logs (Step 14.5 takes none); (3) `BEFORE`; (4) `sent` (`BRIEF_MISMATCH` voids it), then one
+subagent per reader on its rendered file;
 (5) a poll until every reader settles (status `done` or `failed`, or a final summary; a fresh `idle`
 has not run); (6) `note` with the reading pair; a later batch (the Red Team,
 given the specialists' collected lines) repeats (3)-(6); (7) the collect: return only each reader's

test/review-pass.test.ts

@@ -0,0 +1,461 @@
+/**
+ * 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 } from '../lib/review-brief';
+import { CHUNK_CHARS, 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; fix-check is refused', () => {
+    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(/fix-check runs on its own/);
+    // 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' });
+  });
+
+  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. */
+function host(dir: string, env: NodeJS.ProcessEnv, o: { output?: (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 advance = () => {
+    for (const s of subs.values()) {
+      if (s.late && !s.summary) { s.summary = o.output?.(s.title) ?? 'NO FINDINGS'; 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 = o.output?.(s.title) ?? 'NO FINDINGS'; }
+    }
+  };
+  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 }: { indices: number[] }) => { starts.push(indices); for (const i of indices) subs.get(String(i))!.status = 'working'; 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('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);
+
+  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' })).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);
+
+  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('Run Step 7 as written.\n');
+    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('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=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 elsewhere = tmp('rp-cwd-');
+    const out = path.join(dir, '.state/run/p1');
+    fs.mkdirSync(out, { recursive: true });
+    fs.writeFileSync(path.join(out, 'qa.prompt.md'), 'QA brief');
+    const h = host(elsewhere, env, { lateSummary: true });
+    const res = await runPass(h, { base: 'main', out, pass: 'x13p1', cwd: dir, planFlags: ['--depth-floor', 'full'],
+      extras: [{ name: 'qa', prompt_file: path.join(out, 'qa.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/qa')!.prompt).toBe('QA brief');
+  }, 180_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 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);
+});
+

test/ship-budget-reader-drift.test.ts

@@ -264,14 +264,18 @@ describe('the budget section states both contracts', () => {
   test('a review pass is one execute program: plan, review-log --start, BEFORE, create, poll, note with the pair, collect (Capy, observe mode); the admission-mode section keeps check and settle', () => {
     const capy = fs.readFileSync(path.join(import.meta.dir, '..', 'capy', 'skill', 'gstack', 'SKILL.md'), 'utf8');
     const pass = capy.slice(capy.indexOf('/ship on Capy is about a dozen calls'), capy.indexOf('## Plan, approve, ship'));
-    expect(pass).toMatch(/A review pass, Step 11 and the Step 14\.5 audit each run inside one program/);
+    expect(pass).toContain('Each review pass and Step 11 is one call to the checked-in pass program');
+    expect(pass).toContain('gstack-review-dispatch program');
     expect(pass).not.toMatch(/one execute program per batch/);
-    expect(pass).toContain('its brief copied verbatim from the section that dispatches it');
-    expect(pass).toContain('never walks the dispatch steps call by call');
-    const order = ['gstack-review-plan --base <base>', 'gstack-review-log --start', '`BEFORE`', 'tools.subagent.create', 'tools.subagent.get', 'gstack-ship-budget note', '--dispatched-at <BEFORE>', 'return only each reader\'s final output'];
+    expect(pass).toContain('prompts verbatim from their sections');
+    expect(fs.readFileSync(path.join(import.meta.dir, '..', 'ship', 'DRIVER.md'), 'utf8').replace(/\s+/g, ' ')).toContain('never walks the dispatch steps call by call');
+    // GSTA-167 calls PR 2: the order now lives in the program the loader runs unchanged.
+    const program = fs.readFileSync(path.join(import.meta.dir, '..', 'lib', 'capy-review-pass.js'), 'utf8');
+    for (const s of ['tools.subagent.list', 'tools.subagent.get']) expect(program).toContain(s);
+    const order = ["bin, 'pass'", 'gstack-review-log --start', "' sent --ledger '", "' --before '", "mark(r.reader, 'intent'", 'tools.subagent.create', 'gstack-ship-budget note', '--dispatched-at', "'OUTPUT: '"];
     const block = tmpl.slice(tmpl.indexOf('**One program per review pass.**'));
     const tmplOrder = ['gstack-review-plan', 'check --step <n> --next dispatch:<roles>', 'gstack-review-log --start', 'BEFORE', 'AFTER', 'gstack-ship-budget settle', 'the collect'];
-    for (const [text, want] of [[pass, order], [block, tmplOrder]] as const) {
+    for (const [text, want] of [[program, order], [block, tmplOrder]] as const) {
       const at = want.map(o => text.indexOf(o));
       expect(at.every(i => i >= 0), want.filter((_, k) => at[k]! < 0).join(',')).toBe(true);
       expect([...at].sort((a, b) => a - b)).toEqual(at);

test/ship-driver.test.ts

@@ -130,8 +130,8 @@ describe('one program per pass (GSTA-167 variant E)', () => {
   test('the shared program lists its acts in order and the review pass, Step 11 and Step 14.5 run through it', () => {
     const block = flat(doc.slice(doc.indexOf('**One program per pass.**'), doc.indexOf('\n## ', doc.indexOf('**One program per pass.**'))));
     expect(block).toContain('Each review pass, Step 11 and the Step 14.5 audit is one program, and the parent makes no other call while it runs');
-    const order = ['gstack-review-plan --base <base>', 'gstack-review-log --start <skill>` once per row the step logs', '(3) `BEFORE`',
-      '(4) one subagent per reader', '(5) a poll until every reader settles', '(6) `note` with the reading pair',
+    const order = ['`gstack-review-dispatch pass`', 'gstack-review-plan --base <base>', 'then its staged manifest', 'gstack-review-log --start <skill>` once per row the step logs', '(3) `BEFORE`',
+      '(4) `sent` (`BRIEF_MISMATCH` voids it), then one subagent per reader', '(5) a poll until every reader settles', '(6) `note` with the reading pair',
       'a later batch (the Red Team', '(7) the collect: return only each reader\'s final output', 'it never walks the dispatch steps call by call'];
     const at = order.map(o => block.indexOf(o));
     expect(order.filter((_, k) => at[k]! < 0)).toEqual([]);
@@ -222,7 +222,7 @@ describe('variant G: the call plan, observe budget, waits and audit readers (GST
   test('briefs go out as rendered and findings come back unchanged: render, sent, collect, judge, verify', () => {
     const f = flat(doc);
     for (const s of ["A blocking reader's prompt is its `gstack-review-dispatch render` file, unchanged", 'only via `collect`', '`judge` refuses a drop or downgrade',
-      '(4) one subagent per reader on its rendered file, then `sent` (`BRIEF_MISMATCH` voids it)', 'final output and status, via `collect`', '`JUDGMENT: ok` before any fix',
+      '(4) `sent` (`BRIEF_MISMATCH` voids it), then one subagent per reader on its rendered file', 'final output and status, via `collect`', '`JUDGMENT: ok` before any fix',
       '`gstack-review-dispatch verify` (`VERIFY: clean`)']) expect(f).toContain(s);
     expect(f.indexOf('gstack-review-dispatch verify')).toBeLessThan(f.indexOf('`gstack-review-read`'));
   });