v1.91.7.0 feat: add functional QA and pre-publication docs checks (#2983)

* feat: add surface-aware exploratory QA and ship documentation gates

* test: preserve delegated QA setup authority after main integration

* fix(qa): clarify exploration order and preserve report artifacts

* test(qa): follow the shared setup reference directly

* refactor(ship): make verification and recovery routes explicit

* test(ship): align evidence and review guards with explicit routes

* fix(workflows): clarify ship recovery and functional QA evidence

* fix(workflows): clarify approval recovery and full QA coverage

* refactor(workflows): order review transactions and clarify ship state

* fix(ship): clarify final verification and fail closed at publication

* fix(evals): attribute native atomic documentation writes

* fix(ship): clarify recovery and documentation lifecycle guidance

* fix(test): preserve observed native placeholder styling in CI

* fix(codex): report watchdog timeouts without a process-exit race

* Checkpoint functional QA implementation and workflow validation repairs

* Fix documentation and shared-review fixture contracts

* docs: clarify judge reuse and evaluation supervision

* test: align review evidence and selected case contracts

* test: verify append-only documentation checkpoints and recovery

* fix: qualify QA workflows and CI validation repairs

* fix: launch shared-libs fixture scripts on Windows

* fix: qualify QA deadlines, fixture isolation, and shard cleanup

* fix: preserve qualified QA and cancellation repairs

* fix: enforce functional fixture authority and share strict event decoding

* fix: retain free-test evidence and explain recovery

* fix: reject malformed native evidence after decoder consolidation

* test: use reliable capture for telemetry privacy filters

* test: refresh measured quick coverage and document validation costs

* Fix native fixture receipts and preserve VM validation evidence

* Align negative judge controls with upstream clarity policy

* Fix report-only QA preparation and public evidence handling

* Clarify QA-only preparation and current-report preservation

* Stream Ship quality judgments with an explicit 64k response contract

* Validate compact judge reasoning locally with supported wire schema

* Align functional QA fixture instructions with evidence acceptance

* Bind native browser diagnostics to execution evidence and align review verdicts

* Preserve native diagnostic line boundaries

* Serialize functional QA evidence from native captures

* Keep large QA evidence fixture payload out of Windows argv

test/helpers/bootstrap-retention.ts

@@ -0,0 +1,362 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { createHash, randomUUID } from 'node:crypto';
+import { spawnSync } from 'node:child_process';
+
+type Identity = { path: string; dev: number; ino: number };
+type Native = { pid: number; start: string; group: number; settled: boolean; executable?: { path: string; sha256: string } };
+type Scope = { runId: string; temporary: Identity; durable: Identity; registry: Identity; uninspectable: Native[] };
+type Registration = { attempt: string; runId: string; deadline: number; root: Identity; artifact: Identity; owner: Native; native?: Native; initial: object };
+type Entry = { path: string; kind: string; bytes?: number; sha256?: string; target?: string; resolved?: string };
+export type BootstrapReceipt = { attempt: string; complete: boolean; acknowledged: boolean; quiescent: boolean; errors: string[]; artifact: string };
+
+const scopeVariable = 'GSTACK_BOOTSTRAP_RETENTION';
+const locks = ['bun.lock', 'bun.lockb', 'package-lock.json', 'npm-shrinkwrap.json', 'yarn.lock', 'pnpm-lock.yaml'];
+const digest = (bytes: Buffer | string) => createHash('sha256').update(bytes).digest('hex');
+const inside = (root: string, target: string) => target.startsWith(root + path.sep);
+
+function identity(file: string): Identity {
+  const stat = fs.lstatSync(file);
+  if (!stat.isDirectory() || fs.realpathSync(file) !== path.resolve(file)) throw new Error('noncanonical directory');
+  return { path: path.resolve(file), dev: stat.dev, ino: stat.ino };
+}
+
+function verify(expected: Identity) {
+  if (JSON.stringify(identity(expected.path)) !== JSON.stringify(expected)) throw new Error('directory identity changed');
+}
+
+function verifyPrivateTemporary(temporary: Identity) {
+  verify(temporary);
+  const stat = fs.lstatSync(temporary.path);
+  if (stat.uid !== process.getuid!() || (stat.mode & 0o077) !== 0) throw new Error('temporary state is not privately owned');
+}
+
+function durableWrite(file: string, bytes: Buffer | string) {
+  const fd = fs.openSync(file + '.tmp', fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL, 0o600);
+  try { fs.writeFileSync(fd, bytes); fs.fsyncSync(fd); } finally { fs.closeSync(fd); }
+  fs.renameSync(file + '.tmp', file);
+  const dir = fs.openSync(path.dirname(file), fs.constants.O_RDONLY);
+  try { fs.fsyncSync(dir); } finally { fs.closeSync(dir); }
+}
+
+function artifactDirectory(root: Identity, directory: string) {
+  verify(root);
+  let current = root.path;
+  for (const part of path.relative(root.path, directory).split(path.sep)) {
+    if (!part || part === '..') throw new Error('unsafe artifact directory');
+    current = path.join(current, part);
+    if (!fs.existsSync(current)) fs.mkdirSync(current, { mode: 0o700 });
+    identity(current);
+  }
+}
+
+function readRegular(file: string, maximum = 8 * 1024 * 1024): Buffer {
+  const fd = fs.openSync(file, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+  try {
+    const before = fs.fstatSync(fd);
+    if (!before.isFile() || before.size > maximum) throw new Error('file type or byte limit');
+    const bytes = fs.readFileSync(fd);
+    const after = fs.fstatSync(fd);
+    if (before.size !== bytes.length || before.mtimeMs !== after.mtimeMs || before.ctimeMs !== after.ctimeMs) throw new Error('file changed during capture');
+    return bytes;
+  } finally { fs.closeSync(fd); }
+}
+
+function executableIdentity(file: string) {
+  const resolved = fs.realpathSync(file);
+  const fd = fs.openSync(resolved, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+  try {
+    const before = fs.fstatSync(fd);
+    if (!before.isFile() || before.size > 256 * 1024 * 1024) throw new Error('toolchain identity unavailable');
+    const hash = createHash('sha256');
+    const buffer = Buffer.alloc(65536);
+    let count: number;
+    while ((count = fs.readSync(fd, buffer)) > 0) hash.update(buffer.subarray(0, count));
+    const after = fs.fstatSync(fd);
+    if (before.mtimeMs !== after.mtimeMs || before.ctimeMs !== after.ctimeMs) throw new Error('toolchain changed');
+    return { path: resolved, sha256: hash.digest('hex'), dev: before.dev, ino: before.ino };
+  } finally { fs.closeSync(fd); }
+}
+
+function nativeIdentity(pid: number): Native {
+  if (process.platform !== 'linux') throw new Error('native lifetime qualification requires Linux procfs');
+  const stat = fs.readFileSync(`/proc/${pid}/stat`, 'utf8').split(') ').slice(1).join(') ').split(' ');
+  return { pid, start: stat[19], group: Number(stat[2]), settled: false };
+}
+
+function alive(native: Native): boolean {
+  try { return nativeIdentity(native.pid).start === native.start; }
+  catch (error: any) { if (error.code === 'ENOENT' || error.code === 'ESRCH') return false; throw error; }
+}
+
+function exitedDuringCensus(pid: string, start: string, deadline: number) {
+  const until = Math.min(deadline, Date.now() + 20);
+  const pause = new Int32Array(new SharedArrayBuffer(4));
+  while (true) {
+    let stat: string[];
+    try { stat = fs.readFileSync(`/proc/${pid}/stat`, 'utf8').split(') ').slice(1).join(') ').split(' '); }
+    catch (error: any) { if (error.code === 'ENOENT' || error.code === 'ESRCH') return true; throw error; }
+    if (stat[19] !== start) return false;
+    if (stat[0] === 'Z' || stat[0] === 'X') return true;
+    if (!(Number(stat[6]) & 4) || Date.now() >= until) return false;
+    Atomics.wait(pause, 0, 0, 1);
+  }
+}
+
+function quiet(scope: Scope, registration: Registration, deadline: number) {
+  verifyPrivateTemporary(scope.temporary);
+  if (!registration.native) throw new Error('native lifetime not registered');
+  for (const pid of fs.readdirSync('/proc').filter(name => /^\d+$/.test(name))) {
+    let stat: string[];
+    try { stat = fs.readFileSync(`/proc/${pid}/stat`, 'utf8').split(') ').slice(1).join(') ').split(' '); }
+    catch (error: any) { if (error.code === 'ENOENT' || error.code === 'ESRCH') continue; throw new Error('process census unavailable'); }
+    if (stat[0] === 'Z' || stat[0] === 'X') continue;
+    if (Number(stat[2]) === registration.native.group) throw new Error('native group remains live');
+    if (Number(pid) === process.pid) continue;
+    try {
+      if (fs.statSync(`/proc/${pid}`).uid !== process.getuid!()) continue;
+      const cwd = fs.readlinkSync(`/proc/${pid}/cwd`);
+      if (cwd === registration.root.path || inside(registration.root.path, cwd)) throw new Error('fixture process remains live');
+      for (const fd of fs.readdirSync(`/proc/${pid}/fd`)) {
+        const target = fs.readlinkSync(`/proc/${pid}/fd/${fd}`);
+        if (!inside(registration.root.path, target)) continue;
+        const flags = fs.readFileSync(`/proc/${pid}/fdinfo/${fd}`, 'utf8').match(/^flags:\s+(\d+)/m);
+        if (!flags || (parseInt(flags[1], 8) & 3) !== 0) throw new Error('fixture writer remains live');
+      }
+    } catch (error: any) {
+      if (error.code === 'ENOENT' || error.code === 'ESRCH') continue;
+      if (error.code === 'EACCES' || error.code === 'EPERM') {
+        if (exitedDuringCensus(pid, stat[19], deadline)) continue;
+        if (scope.uninspectable.some(native => native.pid === Number(pid) && native.start === stat[19] && alive(native))) continue;
+        throw new Error(`writer census unavailable: ${error.code} ${error.syscall} ${error.path}`);
+      }
+      throw error;
+    }
+  }
+}
+
+function loadScope(env: NodeJS.ProcessEnv): Scope {
+  if (!env[scopeVariable]) throw new Error('bootstrap retention requires a runner-owned scope');
+  const scope: Scope = JSON.parse(env[scopeVariable]!);
+  verifyPrivateTemporary(scope.temporary); verify(scope.durable); verify(scope.registry);
+  if (!inside(scope.temporary.path, scope.registry.path) || inside(scope.temporary.path, scope.durable.path)) throw new Error('invalid retention scope');
+  return scope;
+}
+
+export function createBootstrapRetentionScope(temporaryRoot: string, durableRoot: string, runId: string) {
+  const temporary = identity(temporaryRoot);
+  if (fs.lstatSync(temporary.path).uid !== process.getuid!()) throw new Error('temporary state is not privately owned');
+  fs.chmodSync(temporary.path, 0o700);
+  verifyPrivateTemporary(temporary);
+  if (fs.readdirSync(temporary.path).length) throw new Error('retention scope requires empty temporary state');
+  const uninspectable: Native[] = [];
+  for (const pid of fs.readdirSync('/proc').filter(name => /^\d+$/.test(name))) {
+    let native: Native | undefined;
+    try {
+      if (fs.statSync(`/proc/${pid}`).uid !== process.getuid!()) continue;
+      native = nativeIdentity(Number(pid));
+      fs.readlinkSync(`/proc/${pid}/cwd`);
+      fs.readdirSync(`/proc/${pid}/fd`);
+    } catch (error: any) {
+      if (error.code === 'ENOENT' || error.code === 'ESRCH') continue;
+      if (native && (error.code === 'EACCES' || error.code === 'EPERM') && alive(native)) uninspectable.push(native);
+      else throw error;
+    }
+  }
+  if (path.resolve(durableRoot) === temporary.path || inside(temporary.path, path.resolve(durableRoot))) throw new Error('artifact root must survive temporary cleanup');
+  fs.mkdirSync(durableRoot, { recursive: true, mode: 0o700 });
+  const durable = fs.mkdtempSync(path.join(fs.realpathSync(durableRoot), 'bootstrap-'));
+  fs.chmodSync(durable, 0o700);
+  const registry = fs.mkdtempSync(path.join(fs.realpathSync(temporaryRoot), '.bootstrap-'));
+  fs.chmodSync(registry, 0o700);
+  if (inside(temporary.path, fs.realpathSync(durableRoot))) throw new Error('artifact root resolves into temporary state');
+  const scope: Scope = { runId, temporary, durable: identity(durable), registry: identity(registry), uninspectable };
+  return { env: { [scopeVariable]: JSON.stringify(scope) }, cleanup: (deadline: number) => cleanupBootstrapRetentions(scope, deadline) };
+}
+
+export function registerBootstrapRetention(root: string, runId: string, options: { deadline: number; env?: NodeJS.ProcessEnv }) {
+  const scope = loadScope(options.env ?? process.env);
+  if (!Number.isFinite(options.deadline) || options.deadline <= Date.now()) throw new Error('bootstrap deadline expired');
+  const owned = identity(root);
+  if (runId !== scope.runId || path.dirname(owned.path) !== scope.temporary.path || !path.basename(root).startsWith('skill-e2e-bs-')) throw new Error('wrong bootstrap root or run');
+  const git = (args: string[]) => {
+    const result = spawnSync('git', args, { cwd: root, encoding: 'utf8', timeout: 5000 });
+    if (result.status !== 0) throw new Error('initial Git input unavailable');
+    return result.stdout;
+  };
+  const attempt = randomUUID();
+  const artifact = path.join(scope.durable.path, attempt);
+  fs.mkdirSync(artifact, { mode: 0o700 });
+  const gitStatus = git(['status', '--porcelain=v1']);
+  if (gitStatus.trim()) throw new Error('initial Git inputs are not clean');
+  const registration: Registration = {
+    attempt, runId, deadline: options.deadline, root: owned, artifact: identity(artifact), owner: nativeIdentity(process.pid),
+    initial: { package: readRegular(path.join(root, 'package.json')).toString('base64'),
+      gitHead: git(['rev-parse', 'HEAD']), gitTree: git(['rev-parse', 'HEAD^{tree}']), gitFiles: git(['ls-files', '--stage']), gitStatus,
+      bun: { version: Bun.version, ...executableIdentity(process.execPath) },
+      nodeCompatibility: process.versions.node, externalNode: Bun.which('node') ? executableIdentity(Bun.which('node')!) : null,
+      platform: process.platform, arch: process.arch },
+  };
+  const save = () => durableWrite(path.join(scope.registry.path, attempt + '.json'), JSON.stringify(registration));
+  durableWrite(path.join(artifact, 'registration.json'), JSON.stringify(registration));
+  save();
+  return {
+    attempt, artifact,
+    lifecycle: {
+      onSpawn(pid: number) {
+        registration.native = nativeIdentity(pid);
+        if (registration.native.group !== pid) throw new Error('native process is not group owner');
+        const executable = fs.realpathSync(`/proc/${pid}/exe`);
+        registration.native.executable = executableIdentity(executable);
+        save();
+        durableWrite(path.join(artifact, 'registration.json'), JSON.stringify(registration));
+      },
+      async onSettled(input: { deadline: number; exited: boolean }) {
+        if (!input.exited) throw new Error('native exit was not observed');
+        while (true) {
+          try { quiet(scope, registration, input.deadline); break; }
+          catch (error) {
+            if (Date.now() >= input.deadline) throw error;
+            await new Promise(resolve => setTimeout(resolve, Math.min(20, input.deadline - Date.now())));
+          }
+        }
+        registration.native!.settled = true;
+        save();
+      },
+    },
+    retain() { return retain(scope, registration, false, options.deadline); },
+    cleanup() {
+      const receipt = retain(scope, registration, false, options.deadline);
+      if (receipt.complete && receipt.acknowledged && receipt.quiescent) { verify(registration.root); fs.rmSync(root, { recursive: true }); }
+      if (!receipt.complete || !receipt.acknowledged) throw new Error(`bootstrap retention failed: ${receipt.errors.join('; ')}`);
+      return receipt;
+    },
+  };
+}
+
+function retain(scope: Scope, registration: Registration, fallback: boolean, ownerDeadline: number): BootstrapReceipt {
+  if (!/^[0-9a-f-]{36}$/.test(registration.attempt)) throw new Error('wrong attempt');
+  const artifact = path.join(scope.durable.path, registration.attempt);
+  if (registration.artifact.path !== artifact) throw new Error('wrong artifact root');
+  const receipt: BootstrapReceipt = { attempt: registration.attempt, complete: false, acknowledged: false, quiescent: false, errors: [], artifact };
+  const entries: Entry[] = [];
+  try {
+    verify(scope.temporary); verify(scope.registry); verify(scope.durable); verify(registration.artifact);
+    if (!/^[0-9a-f-]{36}$/.test(registration.attempt) || registration.runId !== scope.runId || path.dirname(registration.root.path) !== scope.temporary.path || !path.basename(registration.root.path).startsWith('skill-e2e-bs-')) throw new Error('wrong attempt or root');
+    verify(registration.root);
+    if (fallback && alive(registration.owner)) throw new Error('attempt owner remains live');
+    const deadline = Math.min(registration.deadline, ownerDeadline);
+    quiet(scope, registration, deadline);
+    receipt.quiescent = true;
+    if (!Number.isFinite(deadline) || Date.now() >= deadline) throw new Error('retention deadline expired');
+    if (!fallback && !registration.native?.settled) throw new Error('native settlement not acknowledged');
+    let bytes = 0;
+    const seen = new Set<string>();
+    const visit = (relative: string, copy: boolean) => {
+      if (seen.has(relative)) return;
+      seen.add(relative);
+      if (seen.size > 50000 || Date.now() > deadline) throw new Error('inventory limit exceeded');
+      verify(registration.root);
+      const file = path.join(registration.root.path, relative);
+      const stat = fs.lstatSync(file);
+      if (stat.isSymbolicLink()) {
+        const target = fs.readlinkSync(file);
+        const resolved = fs.realpathSync(file);
+        if (!inside(registration.root.path, resolved)) throw new Error('escaping installed link');
+        const destination = path.relative(registration.root.path, resolved);
+        if (!destination.startsWith('node_modules' + path.sep)) throw new Error('installed link leaves package tree');
+        entries.push({ path: relative, kind: 'link', target, resolved: destination });
+        visit(destination, false);
+      } else if (stat.isDirectory()) {
+        if (fs.realpathSync(file) !== file) throw new Error('directory link changed during capture');
+        entries.push({ path: relative, kind: 'directory' });
+        for (const name of fs.readdirSync(file).sort()) visit(path.join(relative, name), copy);
+      } else {
+        if (!stat.isFile() || fs.realpathSync(file) !== file) throw new Error('unsafe installed file');
+        bytes += stat.size;
+        if (bytes > 256 * 1024 * 1024) throw new Error('inventory byte limit exceeded');
+        const content = readRegular(file, 64 * 1024 * 1024);
+        entries.push({ path: relative, kind: 'file', bytes: content.length, sha256: digest(content) });
+        if (copy || path.basename(file) === 'package.json') {
+          const output = path.join(artifact, 'files', relative);
+          artifactDirectory(registration.artifact, path.dirname(output));
+          durableWrite(output, content);
+          if (!fs.readFileSync(output).equals(content)) throw new Error('copy verification failed');
+        }
+      }
+    };
+    visit('package.json', true);
+    const availableLocks = locks.filter(name => fs.existsSync(path.join(registration.root.path, name)));
+    for (const lock of availableLocks) visit(lock, true);
+    if (!availableLocks.length) receipt.errors.push('installed lock missing');
+    if (!fs.existsSync(path.join(registration.root.path, 'node_modules'))) receipt.errors.push('installed graph missing');
+    else visit('node_modules', false);
+    if (!entries.some(entry => entry.path.startsWith('node_modules/') && entry.path.endsWith('/package.json'))) receipt.errors.push('installed manifests missing');
+    for (const entry of entries) {
+      const file = path.join(registration.root.path, entry.path);
+      if (entry.kind === 'file' && digest(readRegular(file, 64 * 1024 * 1024)) !== entry.sha256) throw new Error('inventory changed');
+      if (entry.kind === 'link' && (fs.readlinkSync(file) !== entry.target || path.relative(registration.root.path, fs.realpathSync(file)) !== entry.resolved)) throw new Error('link changed');
+      if (entry.kind === 'directory') {
+        const children = entries.filter(child => path.dirname(child.path) === entry.path).map(child => path.basename(child.path)).sort();
+        if (JSON.stringify(fs.readdirSync(file).sort()) !== JSON.stringify(children)) throw new Error('inventory changed');
+      }
+      if (Date.now() > deadline) throw new Error('verification limit exceeded');
+    }
+    verify(registration.root);
+    receipt.quiescent = false;
+    quiet(scope, registration, deadline);
+    receipt.quiescent = true;
+    receipt.complete = receipt.errors.length === 0;
+  } catch (error) { receipt.errors.push(error instanceof Error ? error.message : 'capture failed'); }
+  try {
+    verify(scope.durable); verify(registration.artifact);
+    const evidence = JSON.stringify({ registration, fallback, receipt, entries, uninspectable: scope.uninspectable });
+    durableWrite(path.join(artifact, fallback ? 'fallback-evidence.json' : 'callback-evidence.json'), evidence);
+    durableWrite(path.join(artifact, 'evidence.json'), evidence);
+    if (digest(fs.readFileSync(path.join(artifact, 'evidence.json'))) !== digest(evidence)) throw new Error('evidence readback failed');
+    durableWrite(path.join(artifact, 'ack.json'), JSON.stringify({ attempt: registration.attempt, sha256: digest(evidence), complete: receipt.complete }));
+    const ack = JSON.parse(fs.readFileSync(path.join(artifact, 'ack.json'), 'utf8'));
+    receipt.acknowledged = ack.attempt === registration.attempt && ack.sha256 === digest(evidence);
+  } catch { receipt.errors.push('durable acknowledgment failed'); receipt.complete = false; }
+  return receipt;
+}
+
+async function cleanupBootstrapRetentions(scope: Scope, deadline: number) {
+  verifyPrivateTemporary(scope.temporary);
+  verify(scope.registry);
+  const receipts: BootstrapReceipt[] = [];
+  for (const name of fs.readdirSync(scope.registry.path).sort()) {
+    if (!name.endsWith('.json')) throw new Error('unfinished bootstrap registration');
+    const registration: Registration = JSON.parse(readRegular(path.join(scope.registry.path, name)).toString());
+    if (!/^[0-9a-f-]{36}\.json$/.test(name) || name !== registration.attempt + '.json' || registration.runId !== scope.runId) throw new Error('wrong attempt registration');
+    const artifact = path.join(scope.durable.path, registration.attempt);
+    try {
+      verify(scope.durable); verify(registration.artifact);
+      if (registration.artifact.path !== artifact) throw new Error('wrong artifact root');
+      const evidence = fs.readFileSync(path.join(artifact, 'evidence.json'));
+      const ack = JSON.parse(readRegular(path.join(artifact, 'ack.json')).toString());
+      if (ack.attempt !== registration.attempt || ack.sha256 !== digest(evidence)) throw new Error('invalid acknowledgment');
+      const saved = JSON.parse(evidence.toString());
+      if (JSON.stringify(saved.registration) !== JSON.stringify(registration)) throw new Error('registration changed');
+      if (!saved.receipt.quiescent) throw new Error('previous retention did not establish quiescence');
+      receipts.push({ ...saved.receipt, acknowledged: true });
+    } catch {
+      try {
+        verify(scope.temporary); verify(scope.durable); verify(registration.artifact); verify(registration.root);
+        const durableRegistration = JSON.parse(readRegular(path.join(artifact, 'registration.json')).toString());
+        if (JSON.stringify(durableRegistration) !== JSON.stringify({ ...registration, native: registration.native && { ...registration.native, settled: false } })) throw new Error('native registration mismatch');
+        if (alive(registration.owner)) throw new Error('attempt owner remains live');
+        if (registration.native && alive(registration.native)) {
+          if (nativeIdentity(registration.native.pid).group !== registration.native.pid) throw new Error('native group identity changed');
+          process.kill(-registration.native.pid, 'SIGKILL');
+        }
+        while (Date.now() < deadline) {
+          try { quiet(scope, registration, deadline); break; }
+          catch { await new Promise(resolve => setTimeout(resolve, Math.min(20, deadline - Date.now()))); }
+        }
+      } catch {}
+      receipts.push(retain(scope, registration, true, deadline));
+    }
+  }
+  return { complete: receipts.every(receipt => receipt.complete), removable: receipts.every(receipt => receipt.complete && receipt.acknowledged && receipt.quiescent), receipts };
+}

test/helpers/carve-guards.ts

@@ -104,12 +104,14 @@ export const CARVE_GUARDS: Record<string, CarveGuard> = {
       'test-coverage.md',
       'plan-completion.md',
       'review-army.md',
+      'shared-code-reuse.md',
       'greptile.md',
       'adversarial.md',
       'changelog.md',
+      'documentation.md',
       'pr-body.md',
     ],
-    requiredReads: ['review-army.md', 'changelog.md'],
+    requiredReads: ['review-army.md', 'changelog.md', 'documentation.md'],
     scenario:
       'This is a FRESH version-changing ship: the branch has a real code change, VERSION still equals the base version (needs a bump), and CHANGELOG.md needs a new entry. Follow the skill flow for a version-changing ship: run the pre-landing review and prepare the CHANGELOG entry. Produce the ship plan / review report. Do NOT actually commit, push, or open a PR.',
     staticInvariants: {
@@ -130,8 +132,8 @@ export const CARVE_GUARDS: Record<string, CarveGuard> = {
       mustStayInSkeleton: [
         'v$NEW_VERSION',
         'gstack-pr-title-rewrite',
-        'dispatching the /document-release subagent to sync docs',
-        'Continue to mandatory Step 18 (dispatch /document-release)',
+        '## Step 14.5: Documentation audit (every ship)',
+        'No documentation writer runs after push',
         'dispatches the /document-release subagent',
       ],
       // ...while the full create/update procedure stays carved into pr-body.md
@@ -352,8 +354,8 @@ do not launch the downstream skill or open a browser.`,
   },
   'document-release': {
     skill: 'document-release',
-    expectedSections: ['release-body.md'],
-    requiredReads: ['release-body.md'],
+    expectedSections: ['audit-scope.md', 'release-body.md'],
+    requiredReads: ['audit-scope.md', 'release-body.md'],
     scenario:
       'A PR has shipped a new CLI flag and touched README.md and CHANGELOG.md. Skip the git pre-flight shell commands (assume the diff adds --new-flag and updates those two docs). Run the documentation workflow: build the coverage map, then audit the docs, apply updates, and polish the CHANGELOG voice. Produce the documentation health summary.',
     staticInvariants: {
@@ -450,7 +452,7 @@ do not launch the downstream skill or open a browser.`,
   // ── Token-reduction Phase 4 wave 1 (v1.69.x branch) ──────────────────────
   review: {
     skill: 'review',
-    expectedSections: ['plan-completion.md', 'review-army.md', 'adversarial.md'],
+    expectedSections: ['plan-completion.md', 'review-army.md', 'shared-code-reuse.md', 'adversarial.md'],
     requiredReads: ['plan-completion.md', 'review-army.md'],
     scenario:
       "The working tree has a real diff against the base branch (assume Step 1's git checks passed; the diff implements the PLAN.md cache layer). Run the /review flow: the scope-drift and plan-completion deep pass against PLAN.md, then the critical pass, then the Review Army specialist dispatch — apply the specialist checklists yourself instead of launching subagents. Produce the review report. Do NOT commit, push, or create a PR.",
@@ -632,14 +634,13 @@ do not launch the downstream skill or open a browser.`,
   // ── Token-reduction Phase 4 wave 3 (v1.69.x branch) ──────────────────────
   qa: {
     skill: 'qa',
-    expectedSections: ['test-bootstrap.md', 'qa-patterns.md'],
-    requiredReads: ['qa-patterns.md'],
+    expectedSections: ['scope.md', 'browser-setup.md', 'exploratory.md', 'system-functional.md', 'browser-verify.md', 'test-bootstrap.md', 'qa-patterns.md'],
+    requiredReads: ['scope.md', 'browser-setup.md', 'exploratory.md', 'qa-patterns.md'],
     scenario:
       'Walk /qa in SIMULATION — do not launch a browser, run any aside command, or execute bash; treat the working tree as clean, the tier as Quick, and the target app as http://localhost:3000 with a small feature-branch diff touching one page. Skip the test-framework bootstrap (assume CLAUDE.md documents the test command). Read each pointed section before doing its step, then produce the QA plan as the report: the mode you selected and why, the Phase 1-6 steps you would run, and a worked health-score computation from the rubric. Do NOT use AskUserQuestion.',
     staticInvariants: {
       mustStayInSkeleton: [
         '## Setup',
-        '## BROWSER SETUP (Aside',
         '## Phases 1-6: QA Baseline',
         '## Phase 7: Triage',
         '## Phase 8: Fix Loop',
@@ -652,6 +653,8 @@ do not launch the downstream skill or open a browser.`,
       mustMoveToSection: [
         '## Test Framework Bootstrap',
         'BOOTSTRAP_DECLINED',
+        '### Select the surface before setup',
+        '## BROWSER SETUP (Aside',
         '## Health Score Rubric',
         '### Diff-aware (automatic when on a feature branch with no URL)',
         'Never refuse to use the browser',
@@ -665,6 +668,23 @@ do not launch the downstream skill or open a browser.`,
     // 'aside repl' pins the Aside contract; '$B goto' pins the fallback block in the always-loaded skeleton.
     mustContain: ['bug', 'aside repl', '$B goto', 'fix', 'Health Score Rubric', 'regression'],
   },
+  'qa-only': {
+    skill: 'qa-only',
+    expectedSections: ['exploratory.md'],
+    requiredReads: ['exploratory.md'],
+    scenario:
+      'Walk /qa-only for an isolated CLI fixture using its declared native commands. Read installed scope, exploratory and functional resources; never read browser setup or DX instructions. Report contract outcomes and proposed tests without changing product, tests or Git. Do not use AskUserQuestion.',
+    staticInvariants: {
+      mustStayInSkeleton: ['## Request Parameters', 'Never fix bugs or write product tests', '## Output'],
+      mustPrecedeStop: ['## Request Parameters'],
+      mustMoveToSection: ['# Shared exploratory QA'],
+    },
+    behavioral: 'external',
+    externalTest: 'test/skill-e2e-qa-functional.test.ts',
+    maxSkeletonBytes: 45_000,
+    minUnionBytes: 40_000,
+    mustContain: ['contract', 'Never fix bugs', 'edit-then-restore', 'test_stub'],
+  },
   browse: {
     skill: 'browse',
     expectedSections: ['command-list.md'],

test/helpers/claude-pty-runner.ts

@@ -123,6 +123,7 @@ export interface ClaudePtyOptions {
   rows?: number;
   /** Opt in when input targeting or completion needs the actual VT viewport. */
   observeScreen?: boolean;
+  screenDeadlineAt?: number;
   /** Count-only pending identity; the hook never approves or changes native tools. */
   observePlanReady?: boolean;
   /** Pending AUQ identity for explicit navigation; never supplies answered coverage. */
@@ -156,9 +157,9 @@ export interface ClaudePtySession {
   /** Visible (ANSI-stripped) output for the entire session. For pattern matching. */
   visibleText(): string;
   /** Flush the opted-in terminal parser and return only its current viewport. */
-  currentScreen(): Promise<string>;
+  currentScreen(deadlineAt?: number): Promise<string>;
   /** Same decoded viewport with styles and input epoch for acknowledged paste. */
-  currentScreenFrame(): Promise<{ text: string; rawEnd: number;
+  currentScreenFrame(deadlineAt?: number): Promise<{ text: string; rawEnd: number;
     styledText: Array<{ row: number; start: number; text: string; dim: boolean; inverse: boolean }> }>;
   /**
    * Mark the current buffer position. Subsequent waitForAny / visibleSince
@@ -4022,6 +4023,8 @@ export async function launchClaudePty(
   const cols = opts.cols ?? 120;
   const rows = opts.rows ?? 40;
   const timeoutMs = opts.timeoutMs ?? 240_000;
+  const wallDeadline = performance.now() + timeoutMs;
+  const screenAbort = new AbortController();
 
   let buffer = '';
   let exited = false;
@@ -4085,7 +4088,9 @@ export async function launchClaudePty(
     ? hermeticSkillStateRoot : undefined;
 
   // Construction must succeed before any CLI can be spawned.
-  const screen = opts.observeScreen ? await createPtyScreen(cols, rows) : undefined;
+  const screen = opts.observeScreen ? await createPtyScreen(cols, rows, {
+    deadlineAt: Math.min(opts.screenDeadlineAt ?? wallDeadline, wallDeadline), signal: screenAbort.signal,
+  }) : undefined;
   let screenClosing: Promise<void> | undefined;
   let screenFailure: unknown;
   const disposeScreen = () => screenClosing ??= (screen?.dispose() ?? Promise.resolve()).catch(error => { screenFailure = error; });
@@ -4132,33 +4137,34 @@ export async function launchClaudePty(
     },
     cwd,
     env: childEnv,
-  }); } catch (error) { pendingFiles.forEach(({ recorder }) => recorder.dispose()); pendingExit?.dispose(); pendingQuestion?.dispose(); pendingArtifact?.dispose(); await disposeScreen(); throw error; }
+  }); } catch (error) { screenAbort.abort(error); pendingFiles.forEach(({ recorder }) => recorder.dispose()); pendingExit?.dispose(); pendingQuestion?.dispose(); pendingArtifact?.dispose(); await disposeScreen(); throw error; }
 
   // Track exit so waitForAny can fail fast if claude crashes.
   let exitedPromise: Promise<void> = Promise.resolve();
   if (proc.exited && typeof proc.exited.then === 'function') {
     exitedPromise = proc.exited
-      .then(async (code: number | null) => {
+      .then((code: number | null) => {
         exitCodeCaptured = code;
         exited = true;
         notifyOutput();
-        await disposeScreen();
+        void disposeScreen();
       })
-      .catch(async () => {
+      .catch(() => {
         exited = true;
         notifyOutput();
-        await disposeScreen();
+        void disposeScreen();
       });
   }
 
   // Top-level timeout. If a test forgets to close, this kills it eventually.
   const wallTimer = setTimeout(() => {
+    screenAbort.abort(new Error('PTY work deadline exceeded.'));
     try {
       proc.kill?.('SIGKILL');
     } catch {
       /* ignore */
     }
-  }, timeoutMs);
+  }, Math.max(0, wallDeadline - performance.now()));
 
   // Auto-handle the workspace-trust dialog. Runs once during the boot
   // window, after both choices and the selected cursor are visible. Newer
@@ -4275,34 +4281,45 @@ export async function launchClaudePty(
     await waitForAny([pattern], waitOpts);
   }
 
-  async function close(): Promise<void> {
+  let closePromise: Promise<void> | undefined;
+  function close(): Promise<void> {
+    return closePromise ??= closeOnce();
+  }
+  async function closeOnce(): Promise<void> {
     closing = true;
     notifyOutput();
-    clearTimeout(wallTimer);
+    const cleanupDeadline = Math.min(wallDeadline, performance.now() + 3_000);
+    const cleanupTimer = setTimeout(() => screenAbort.abort(new Error('PTY cleanup deadline exceeded.')),
+      Math.max(0, cleanupDeadline - performance.now()));
     clearTimeout(trustWatcherStop);
     clearInterval(trustWatcher);
     for (const timer of trustInputTimers) clearTimeout(timer);
-    if (exited) { pendingFiles.forEach(({ recorder }) => recorder.dispose()); pendingExit?.dispose(); pendingQuestion?.dispose(); pendingArtifact?.dispose(); await disposeScreen(); return; }
-    for (const [signal, timeout] of [['SIGINT', 2000], ['SIGKILL', 1000]] as const) {
-      if (exited) break;
-      try {
-        proc.kill?.(signal);
-      } catch {
-        /* ignore */
-      }
-      let deadline!: ReturnType<typeof setTimeout>;
-      try {
-        await Promise.race([exitedPromise, new Promise<void>((resolve) => {
-          deadline = setTimeout(resolve, timeout);
-        })]);
-      } finally {
-        clearTimeout(deadline);
+    try {
+      for (const [signal, timeout] of [['SIGINT', 2000], ['SIGKILL', 1000]] as const) {
+        if (exited) break;
+        try {
+          proc.kill?.(signal);
+        } catch {
+          /* ignore */
+        }
+        let deadline!: ReturnType<typeof setTimeout>;
+        try {
+          await Promise.race([exitedPromise, new Promise<void>((resolve) => {
+            deadline = setTimeout(resolve, Math.max(0, Math.min(timeout, cleanupDeadline - performance.now())));
+          })]);
+        } finally {
+          clearTimeout(deadline);
+        }
       }
+      pendingFiles.forEach(({ recorder }) => recorder.dispose());
+      pendingExit?.dispose();
+      pendingQuestion?.dispose(); pendingArtifact?.dispose();
+      await disposeScreen();
+      if (screenFailure) throw screenFailure;
+    } finally {
+      clearTimeout(cleanupTimer);
+      clearTimeout(wallTimer);
     }
-    pendingFiles.forEach(({ recorder }) => recorder.dispose());
-    pendingExit?.dispose();
-    pendingQuestion?.dispose(); pendingArtifact?.dispose();
-    await disposeScreen();
   }
 
   return {
@@ -4310,17 +4327,15 @@ export async function launchClaudePty(
     sendKey,
     rawOutput: () => buffer,
     visibleText: () => stripAnsi(buffer),
-    currentScreen: async () => {
+    currentScreen: async (deadlineAt?: number) => {
       if (!screen) throw new Error('PTY screen observation was not enabled for this session.');
-      if (screenClosing) await screenClosing;
       if (screenFailure) throw new Error('PTY screen observation failed.', { cause: screenFailure });
-      return screen.read();
+      return screen.read(deadlineAt);
     },
-    currentScreenFrame: async () => {
+    currentScreenFrame: async (deadlineAt?: number) => {
       if (!screen) throw new Error('PTY screen observation was not enabled for this session.');
-      if (screenClosing) await screenClosing;
       if (screenFailure) throw new Error('PTY screen observation failed.', { cause: screenFailure });
-      const frame = await screen.readFrame();
+      const frame = await screen.readFrame(deadlineAt);
       return {text: frame.text, rawEnd: frame.inputOffset, styledText: frame.styledText};
     },
     mark,
@@ -4567,6 +4582,7 @@ export async function runPlanSkillObservation(opts: {
   const startedAt = Date.now();
   const budgetMs = opts.timeoutMs ?? 180_000;
   const deadlineAt = startedAt + budgetMs;
+  const screenDeadlineAt = performance.now() + budgetMs;
   // Explicitly identify only a new seeded plan-mode session. Caller-owned
   // resume/session arguments retain their existing behavior.
   const scopeSessionId = opts.initialPlanContent && opts.inPlanMode !== false &&
@@ -4588,8 +4604,10 @@ export async function runPlanSkillObservation(opts: {
     model: opts.model,
     seedSkills: true,
     observeScreen: !!opts.initialPlanContent,
+    screenDeadlineAt,
   });
 
+  let observationFailed = false;
   try {
     const preflightTimeout = async (summary: string): Promise<PlanSkillObservation> => {
       let viewport: string | undefined, viewportError: string | undefined;
@@ -4817,8 +4835,21 @@ export async function runPlanSkillObservation(opts: {
       elapsedMs: Date.now() - startedAt,
       ...highWaterFlags(),
     };
+  } catch (error) {
+    observationFailed = true;
+    try {
+      const publicTools: NativePublicToolEvent[] = [];
+      const transcript = session.hermeticConfigDir ? readPlanCountTranscript(session.hermeticConfigDir,
+        path.resolve(opts.cwd ?? process.cwd()), event => publicTools.push(event)) : undefined;
+      const saved = saveSnapshot({ skillName: opts.skillName, cwd: path.resolve(opts.cwd ?? process.cwd()),
+        claudeConfigDir: session.hermeticConfigDir, raw: session.rawOutput(), visible: session.visibleText(),
+        observation: { state: 'threw', error: String(error), transcript, publicTools } });
+      if (saved.artifactError) console.error(`PTY artifact write failed: ${saved.artifactError}`);
+    } catch (captureError) { console.error(`PTY failure capture failed: ${String(captureError)}`); }
+    throw error;
   } finally {
-    await session.close();
+    try { await session.close(); }
+    catch (error) { if (!observationFailed) throw error; }
   }
 }
 
@@ -5043,6 +5074,7 @@ export async function runPlanSkillCounting(opts: {
       // Stop new output at the work cutoff so screen drain cannot consume
       // the reserve while the CLI continues streaming.
       timeoutMs: Math.max(1, remainingWork()),
+      screenDeadlineAt: workDeadline,
       env: { ...opts.env, ...fixture.env,
         // The renderer may cd into its artifact directory before starting the daemon.
         ...(opts.bindDesignBoardState ? { DESIGN_DAEMON_STATE_FILE: path.join(fixture.cwd, '.gstack', 'design.json') } : {}),
@@ -5080,14 +5112,20 @@ export async function runPlanSkillCounting(opts: {
   let lastCheckpointAt = Date.now();
   let viewport = '';
 
-  const capture = (observation: object) => saveSnapshot({
-    skillName: opts.skillName, observation: { ...observation,
-      pendingWriteInputs: ownedFilePermissions.flatMap(binding => {
-        const input = readPendingWriteInput(binding.file, binding.expected, fixture.cwd, session.hermeticConfigDir, startedAt);
-        return input ? [input] : [];
-      }) }, raw: session.rawOutput(), visible: session.visibleText(), viewport,
-    cwd: fixture.cwd, claudeConfigDir: session.hermeticConfigDir,
-  });
+  const capture = (observation: object) => {
+    const publicTools: NativePublicToolEvent[] = [];
+    if (session.hermeticConfigDir) readPlanCountTranscript(session.hermeticConfigDir, fixture.cwd,
+      event => publicTools.push(event));
+    return saveSnapshot({
+      skillName: opts.skillName, observation: { ...observation,
+        publicTools,
+        pendingWriteInputs: ownedFilePermissions.flatMap(binding => {
+          const input = readPendingWriteInput(binding.file, binding.expected, fixture.cwd, session.hermeticConfigDir, startedAt);
+          return input ? [input] : [];
+        }) }, raw: session.rawOutput(), visible: session.visibleText(), viewport,
+      cwd: fixture.cwd, claudeConfigDir: session.hermeticConfigDir,
+    });
+  };
 
   function snapshot(
     outcome: PlanSkillCountObservation['outcome'],
@@ -5120,6 +5158,7 @@ export async function runPlanSkillCounting(opts: {
 
   let observedOutput = session.mark();
   let lastObservationAt = -Infinity;
+  let countingFailed = false;
   try {
     let startupReady: boolean;
     if (opts.startupReadyMarker !== undefined) {
@@ -5424,6 +5463,7 @@ export async function runPlanSkillCounting(opts: {
       viewport,
     );
   } catch (error) {
+    countingFailed = true;
     // Caller/actor errors used to leave only the preceding 30s checkpoint.
     // Retain the actual throw frame and public native state before close()
     // removes the hook and fixture, without replacing the original failure.
@@ -5441,6 +5481,11 @@ export async function runPlanSkillCounting(opts: {
   } finally {
     try {
       await session.close();
+    } catch (error) {
+      if (!countingFailed) {
+        capture({ state: 'cleanup_failed', error: String(error), transcript, fingerprints });
+        throw error;
+      }
     } finally {
       fixture.cleanup();
     }
@@ -5630,7 +5675,9 @@ export async function runPlanSkillFloorCheck(opts: {
   const submittedSetup = new Set<string>();
   const assessed = new Map<string, PlanFloorAssessment>();
   const dxReplies = new Map<string, PlanFloorDXReply>();
-  let captureBeforeClose: (() => void) | undefined;
+  let captureBeforeClose: ((error?: unknown) => void) | undefined;
+  let floorFailed = false;
+  let floorError: unknown;
   try {
     await Bun.sleep(8000); // boot grace + auto-trust handler window
     const since = session.mark();
@@ -5672,8 +5719,13 @@ export async function runPlanSkillFloorCheck(opts: {
       lastCheckpointState = state; lastCheckpointAt = Date.now();
       capture({ state: 'in_progress', elapsedMs: Date.now() - startedAt });
     };
-    captureBeforeClose = () => {
-      if (!finished) capture({ state: 'in_progress', captureReason: 'before_cleanup', elapsedMs: Date.now() - startedAt });
+    captureBeforeClose = (error) => {
+      if (floorFailed && session.hermeticConfigDir) {
+        publicTools = [];
+        transcript = readPlanCountTranscript(session.hermeticConfigDir, fixture.cwd, event => publicTools.push(event));
+      }
+      if (!finished) capture({ state: floorFailed ? 'threw' : 'in_progress', error: floorFailed ? String(error) : undefined,
+        captureReason: 'before_cleanup', elapsedMs: Date.now() - startedAt });
     };
     const finish = (observation: PlanSkillFloorObservation): PlanSkillFloorObservation => {
       const artifacts = capture(observation);
@@ -5683,6 +5735,7 @@ export async function runPlanSkillFloorCheck(opts: {
 
     const start = Date.now();
     const deadlineAt = start + timeoutMs;
+    const screenDeadlineAt = performance.now() + timeoutMs;
     while (Date.now() - start < timeoutMs) {
       await Bun.sleep(2000);
       const visible = session.visibleSince(since);
@@ -5710,7 +5763,7 @@ export async function runPlanSkillFloorCheck(opts: {
         targetDelivery = readPlanFloorTarget(session.hermeticConfigDir, fixture.cwd,
           { ...deliveryOptions, now: Date.now() });
         if (targetDelivery.status !== 'ready') {
-          viewport = await session.currentScreen();
+          viewport = await session.currentScreen(screenDeadlineAt);
           checkpoint();
           continue;
         }
@@ -5718,7 +5771,7 @@ export async function runPlanSkillFloorCheck(opts: {
 
       // Current native identity precedes permission handling and finding assessment.
       floorReview = undefined; floorAssessment = undefined;
-      viewport = await session.currentScreen();
+      viewport = await session.currentScreen(screenDeadlineAt);
       publicTools = [];
       transcript = session.hermeticConfigDir
         ? readPlanCountTranscript(session.hermeticConfigDir, fixture.cwd, event => publicTools.push(event))
@@ -5877,9 +5930,17 @@ export async function runPlanSkillFloorCheck(opts: {
       evidence: session.visibleSince(since).slice(-3000),
       elapsedMs: Date.now() - startedAt,
     });
+  } catch (error) {
+    floorFailed = true;
+    floorError = error;
+    throw error;
   } finally {
-    try { captureBeforeClose?.(); } finally {
-      try { await session.close(); } finally { fixture.cleanup(); }
+    try { captureBeforeClose?.(floorError); }
+    catch (error) { if (!floorFailed) { floorFailed = true; throw error; } }
+    finally {
+      try { await session.close(); }
+      catch (error) { if (!floorFailed) throw error; }
+      finally { fixture.cleanup(); }
     }
   }
 }

test/helpers/docsync-contract.ts

@@ -0,0 +1,70 @@
+import * as path from 'node:path';
+
+export interface DocsCompletion {
+  schema_version: 1;
+  audit_id: string;
+  status: 'updated' | 'current' | 'blocked';
+  files_updated: string[];
+  files_reviewed: string[];
+  documentation_section: string;
+  blockers: string[];
+  decisions: string[];
+}
+
+const keys = ['schema_version', 'audit_id', 'status', 'files_updated', 'files_reviewed', 'documentation_section', 'blockers', 'decisions'];
+
+export function parseDocsCompletion(output: string, auditId: string): DocsCompletion {
+  const result = JSON.parse(output.trimEnd().split('\n').at(-1)!);
+  if (!result || Array.isArray(result) || typeof result !== 'object' ||
+      Object.keys(result).sort().join() !== [...keys].sort().join()) throw new Error('completion fields');
+  if (result.schema_version !== 1 || result.audit_id !== auditId) throw new Error('completion identity');
+  if (!['updated', 'current', 'blocked'].includes(result.status)) throw new Error('completion status');
+  for (const field of ['files_updated', 'files_reviewed', 'blockers', 'decisions']) {
+    if (!Array.isArray(result[field]) || result[field].some((v: unknown) => typeof v !== 'string' || !v.trim())) {
+      throw new Error(`completion ${field}`);
+    }
+  }
+  if (typeof result.documentation_section !== 'string' || !result.documentation_section.trim()) throw new Error('completion markdown');
+  for (const field of ['files_updated', 'files_reviewed']) {
+    const paths: string[] = result[field];
+    if (new Set(paths).size !== paths.length || paths.some(p => path.posix.isAbsolute(p) || p.includes('\\') ||
+      p.split('/').some(part => !part || part === '.' || part === '..') || /[*?\[\]]/.test(p))) throw new Error('completion paths');
+  }
+  if (result.status === 'blocked' ? result.blockers.length === 0 : result.blockers.length !== 0) throw new Error('completion blockers');
+  if (result.status === 'current' && result.files_updated.length !== 0 ||
+      result.status === 'updated' && result.files_updated.length === 0) throw new Error('completion edits');
+  return result;
+}
+
+export function vetDocsCompletion(result: DocsCompletion, evidence: {
+  settled: boolean;
+  markerSeen: boolean;
+  headUnchanged: boolean;
+  indexUnchanged: boolean;
+  candidateUnchanged: boolean;
+  readOnly: boolean;
+  changedPaths: string[];
+  allowedDocs: string[];
+}): void {
+  if (!evidence.settled || !evidence.markerSeen) throw new Error('unsettled or unmarked child');
+  if (!evidence.headUnchanged || !evidence.indexUnchanged) throw new Error('Git ownership violation');
+  if (!evidence.candidateUnchanged) throw new Error('stale candidate');
+  if (evidence.readOnly && evidence.changedPaths.length) throw new Error('read-only mutation');
+  if ([...evidence.changedPaths].sort().join('\0') !== [...result.files_updated].sort().join('\0')) throw new Error('unreported edits');
+  const forbidden = /(?:^|\/)(?:VERSION|CHANGELOG(?:\.[^/]*)?|TODOS(?:\.[^/]*)?|package(?:-lock)?\.json|[^/]*lock[^/]*|manifest\.json)$/i;
+  if (evidence.changedPaths.some(p => forbidden.test(p) || !evidence.allowedDocs.includes(p))) throw new Error('non-doc mutation');
+}
+
+export function extractDocsDispatch(section: string): string {
+  const begin = section.indexOf('**Subagent prompt:**');
+  const end = section.indexOf('**Parent processing:**');
+  if (begin < 0 || end <= begin) throw new Error('documentation dispatch markers moved');
+  return section.slice(begin + '**Subagent prompt:**'.length, end)
+    .split('\n').map(line => line.replace(/^> ?/, '')).join('\n').trim();
+}
+
+export function docsDispatchIndex(calls: Array<{ tool: string; input: unknown }>): number {
+  return calls.findIndex(call => ['Agent', 'Task'].includes(call.tool) &&
+    /document-release\/SKILL\.md|executing the \/document-release workflow/i.test(JSON.stringify(call.input)) &&
+    !/Parent processing:|## Step 19: Create PR\/MR/.test(JSON.stringify(call.input)));
+}

test/helpers/docsync-fault-actor.ts

@@ -0,0 +1,270 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { createHash } from 'node:crypto';
+import { DOC_PATH, docsCandidate, gitAt, fixtureDocs, repoSnapshot } from './docsync-fixture';
+import { extractDocsDispatch } from './docsync-contract';
+import { docsNativeInterface } from './docsync-observer';
+
+export const DOCS_CHECKPOINT_MARKER = '<!-- DOCSYNC_CHECKPOINT -->';
+
+export type DocsFault = 'missing-marker' | 'missing-asset' | 'launch-failure' | 'timeout-unsettled' |
+  'late-result' | 'stale-before' | 'stale-after' | 'recovery' | 'legacy-completion';
+export interface ActorEvent { action: string; audit_id?: string; task_id?: string; detail?: string; }
+export interface DocsActorState {
+  root: string;
+  scenario: DocsFault;
+  events: ActorEvent[];
+  tasks: Array<{ id: string | null; audit_id: string; settled: boolean; stopRequested: boolean; elapsed_ms: number;
+    prompt: string; candidate: string; prompt_sha256: string; candidate_sha256: string;
+    observed_candidate: ReturnType<typeof docsCandidate> }>;
+  repaired: boolean;
+  armed: boolean;
+  lateChanged: boolean;
+  acceptedId: string | null;
+}
+
+export function docsActorCanRepair(scenario: DocsFault): boolean {
+  return scenario === 'recovery' || scenario === 'late-result';
+}
+
+function owned(root: string, file: string): string {
+  const absolute = path.resolve(file);
+  if (!absolute.startsWith(fs.realpathSync(root) + path.sep)) throw Error('actor path outside fixture');
+  const existing = fs.existsSync(absolute) ? absolute : path.dirname(absolute);
+  if (fs.realpathSync(existing) !== fs.realpathSync(root) && !fs.realpathSync(existing).startsWith(fs.realpathSync(root) + path.sep)) throw Error('actor symlink escape');
+  return absolute;
+}
+
+function load(file: string): DocsActorState {
+  const s = JSON.parse(fs.readFileSync(file, 'utf8')) as DocsActorState;
+  owned(s.root, file);
+  return s;
+}
+
+function save(file: string, state: DocsActorState) {
+  fs.writeFileSync(file, JSON.stringify(state), { mode: 0o600 });
+}
+
+function locked<T>(file: string, body: () => T): T {
+  const lock = file + '.lock';
+  const fd = fs.openSync(lock, 'wx', 0o600);
+  try { return body(); }
+  finally { fs.closeSync(fd); fs.unlinkSync(lock); }
+}
+
+function changeCandidate(s: DocsActorState) {
+  fs.writeFileSync(path.join(s.root, 'repo/app.ts'), 'export const format = "json";\n');
+  s.lateChanged = true;
+  s.armed = false;
+  s.events.push({ action: 'scheduled-input-edit', detail: 'app.ts' });
+}
+
+export function docsActorCommand(file: string, action: string, args: Record<string, string> = {}): { text: string; exit: number } {
+  return locked(file, () => {
+    const s = load(file);
+    let text = '';
+    let exit = 0;
+    const last = () => {
+      const task = s.tasks.find(t => t.id === args.task_id);
+      if (!task || !args.task_id) throw Error('unknown fixture child');
+      return task;
+    };
+    const complete = (auditId: string, status: 'current' | 'updated' | 'blocked', blockers: string[] = [], updated: string[] = []) => {
+      return `SESSION_KIND: ${blockers.includes('Missing spawned marker') ? 'interactive' : 'spawned'}\n` + JSON.stringify({
+        schema_version: 1, audit_id: auditId, status, files_updated: updated,
+        files_reviewed: blockers.length ? [] : [DOC_PATH],
+        documentation_section: `${status} — fixture child audit ${auditId}; ${blockers.length ? blockers.join('; ') : 'reviewed the selected command reference'}.`,
+        blockers, decisions: [],
+      });
+    };
+    try {
+      if (action === 'prepare') {
+        if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,79}$/.test(args.audit_id ?? '')) throw Error('prepare requires a fresh literal audit id');
+        if (s.tasks.some(t => !t.settled)) throw Error('attempted snapshot with unsettled writer');
+        const repo = path.join(s.root, 'repo');
+        const skills = path.join(s.root, '.claude/skills/gstack');
+        const candidateFile = owned(s.root, path.join(s.root, `candidate-${args.audit_id}.json`));
+        const promptFile = owned(s.root, path.join(s.root, `prompt-${args.audit_id}.md`));
+        if (fs.existsSync(candidateFile) || fs.existsSync(promptFile)) throw Error('prepare cannot overwrite a saved snapshot or prompt');
+        const candidate = docsCandidate(repo, args.audit_id, 'edit', gitAt(repo, 'rev-parse', 'main'));
+        const source = extractDocsDispatch(fs.readFileSync(path.join(skills, 'ship/sections/documentation.md'), 'utf8'));
+        const prompt = source.replaceAll('${HOME}', s.root).replaceAll('<branch>', candidate.branch)
+          .replaceAll('<base>', 'main').replaceAll('<candidate-path>', candidateFile)
+          .replaceAll('<audit-id>', args.audit_id).replaceAll('<mode>', candidate.mode)
+          + '\n\n' + docsNativeInterface({ home: s.root, repo, skills });
+        fs.writeFileSync(candidateFile, JSON.stringify(candidate), { flag: 'wx', mode: 0o600 });
+        fs.writeFileSync(promptFile, prompt, { flag: 'wx', mode: 0o600 });
+        s.events.push({ action, audit_id: args.audit_id, detail: JSON.stringify({ candidate, prompt }) });
+        text = JSON.stringify({ audit_id: args.audit_id, candidate: candidateFile, prompt: promptFile });
+      } else if (action === 'dispatch') {
+        if (!args.audit_id || args.run_in_background !== 'false') throw Error('dispatch requires identity and explicit foreground flag');
+        if (s.tasks.some(t => !t.settled)) throw Error('attempted writer overlap');
+        if (s.events.some(e => e.action === 'dispatch' && e.audit_id === args.audit_id)) throw Error('reused audit identity');
+        const prompt = fs.readFileSync(owned(s.root, args.prompt), 'utf8');
+        const candidate = fs.readFileSync(owned(s.root, args.candidate));
+        if (!prompt.includes('document-release') || !prompt.includes('files_updated') || !prompt.includes(args.audit_id)) throw Error('dispatch did not carry the actual workflow prompt');
+        const task = { id: s.scenario === 'launch-failure' ? null : `fixture-child-${s.tasks.length + 1}`, audit_id: args.audit_id, settled: true, stopRequested: false, elapsed_ms: 0,
+          prompt, candidate: candidate.toString('utf8'), prompt_sha256: createHash('sha256').update(prompt).digest('hex'),
+          candidate_sha256: createHash('sha256').update(candidate).digest('hex'),
+          observed_candidate: docsCandidate(path.join(s.root, 'repo'), args.audit_id, 'edit', gitAt(path.join(s.root, 'repo'), 'rev-parse', 'main')) };
+        s.events.push({ action, audit_id: args.audit_id, ...(task.id === null ? {} : { task_id: task.id }) });
+        if (s.scenario === 'missing-asset') throw Error('missing installed asset must block before dispatch');
+        s.tasks.push(task);
+        if (s.scenario === 'launch-failure') {
+          exit = 23;
+          text = 'Child launch failed: injected unavailable worker. No child was started.';
+          save(file, s);
+          return { text, exit };
+        }
+        if (s.scenario === 'legacy-completion') {
+          const doc = owned(s.root, path.join(s.root, 'repo', DOC_PATH));
+          fs.writeFileSync(doc, fs.readFileSync(doc, 'utf8').replace('Default format: text.', 'Default format: JSON.'));
+          s.events.push({ action: 'partial-doc-edit', audit_id: args.audit_id, detail: DOC_PATH });
+          text = 'SESSION_KIND: spawned\n' + JSON.stringify({ files_updated: [], commit_sha: null, pushed: false, documentation_section: null });
+        } else if (s.scenario === 'missing-marker' || s.scenario === 'recovery' && !s.repaired) {
+          text = complete(args.audit_id, 'blocked', ['Missing spawned marker']);
+        } else if (s.scenario === 'timeout-unsettled' || s.scenario === 'late-result' && s.tasks.length === 1) {
+          task.settled = false;
+          text = JSON.stringify({ task_id: task.id, status: 'running', elapsed_ms: 0, virtual_clock: true });
+        } else if (s.scenario === 'late-result') {
+          if (!s.repaired) throw Error('transport must be repaired before retry');
+          text = complete(s.tasks[0].audit_id, 'current');
+          s.events.push({ action: 'late-callback', audit_id: s.tasks[0].audit_id });
+        } else if (s.scenario.startsWith('stale-') && s.tasks.length === 1) {
+          if (s.scenario === 'stale-before') changeCandidate(s);
+          else s.armed = true;
+          text = complete(args.audit_id, 'current');
+          s.events.push({ action: 'completion', audit_id: args.audit_id });
+        } else {
+          const updated: string[] = [];
+          if (s.lateChanged) {
+            const doc = path.join(s.root, 'repo', DOC_PATH);
+            fs.writeFileSync(doc, fs.readFileSync(doc, 'utf8').replace('Default format: text.', 'Default format: JSON.'));
+            updated.push(DOC_PATH);
+            s.events.push({ action: 'factual-doc-edit', audit_id: args.audit_id, detail: DOC_PATH });
+          }
+          s.acceptedId = args.audit_id;
+          text = complete(args.audit_id, updated.length ? 'updated' : 'current', [], updated);
+          s.events.push({ action: 'completion', audit_id: args.audit_id });
+        }
+      } else if (action === 'inspect') {
+        if (Object.keys(args).length) throw Error('inspect takes no arguments');
+        if (s.armed) changeCandidate(s);
+        const repo = path.join(s.root, 'repo');
+        const inventory = [...new Set(gitAt(repo, 'ls-files', '-z', '--cached', '--others', '--exclude-standard')
+          .split('\0').filter(Boolean))].sort();
+        if (inventory.length > 64) throw Error('inspect inventory exceeds the bound');
+        const snapshot = repoSnapshot(repo);
+        const base = gitAt(repo, 'rev-parse', 'main');
+        const files = Object.fromEntries(inventory.map(rel => {
+          const bytes = snapshot.contents[rel];
+          if (bytes === undefined) return [rel, { exists: false }];
+          const buffer = Buffer.from(bytes, 'base64');
+          return [rel, { exists: true, sha256: createHash('sha256').update(buffer).digest('hex'), content: buffer.toString('utf8') }];
+        }));
+        text = JSON.stringify({
+          operation: 'inspect', base_sha: base, head: snapshot.head,
+          branch: gitAt(repo, 'branch', '--show-current'), index: snapshot.index,
+          pre_existing_dirty: gitAt(repo, 'status', '--porcelain', '-z'),
+          diff_committed: gitAt(repo, 'diff', base, 'HEAD'),
+          diff_cached: gitAt(repo, 'diff', '--cached'), diff_worktree: gitAt(repo, 'diff'),
+          inventory, files,
+        });
+        s.events.push({ action, detail: createHash('sha256').update(text).digest('hex') });
+      } else if (action === 'status') {
+        const task = last();
+        task.elapsed_ms += task.stopRequested ? 300_001 : 600_001;
+        s.events.push({ action, task_id: args.task_id, detail: task.settled ? 'settled' : 'running' });
+        text = JSON.stringify({ task_id: task.id, status: task.settled ? 'stopped' : 'running', settled: task.settled,
+          elapsed_ms: task.elapsed_ms, virtual_clock: true });
+      } else if (action === 'stop') {
+        const task = last();
+        task.stopRequested = true;
+        if (s.scenario !== 'timeout-unsettled') task.settled = true;
+        s.events.push({ action, task_id: args.task_id, detail: task.settled ? 'settled' : 'unsettled' });
+        text = JSON.stringify({ task_id: task.id, stop_requested: true, settled: task.settled });
+      } else if (action === 'repair') {
+        if (!docsActorCanRepair(s.scenario) || s.repaired || !s.tasks.length || s.tasks.some(t => !t.settled)) throw Error('repair not available');
+        s.repaired = true;
+        s.events.push({ action, detail: 'fixture transport/marking repaired' });
+        text = 'Fixture transport/marking repaired; future dispatches use the corrected launcher.';
+      } else if (action === 'publish') {
+        s.events.push({ action, audit_id: args.audit_id });
+        if (!s.acceptedId || args.audit_id !== s.acceptedId || s.tasks.some(t => !t.settled)) throw Error('publication attempted without a current settled audit');
+        const report = fs.readFileSync(owned(s.root, args.report), 'utf8');
+        if (!report.includes(s.acceptedId)) throw Error('publication did not consume actual audit result');
+        fs.writeFileSync(path.join(s.root, 'publication.json'), JSON.stringify({ audit_id: s.acceptedId, report }), { mode: 0o600 });
+        text = 'Mock publication recorded.';
+      } else throw Error('unsupported fixture action');
+    } catch (error) {
+      s.events.push({ action: 'rejected', audit_id: args.audit_id, detail: String(error) });
+      text = String(error);
+      exit = 24;
+    }
+    save(file, s);
+    return { text, exit };
+  });
+}
+
+export function docsActorHook(file: string, input: string) {
+  return locked(file, () => {
+    const s = load(file);
+    const e = JSON.parse(input);
+    if (s.armed && e.hook_event_name === 'PreToolUse' && e.cwd === path.join(s.root, 'repo') &&
+        !JSON.stringify(e.tool_input ?? {}).includes('docsync-fault-actor.ts')) {
+      changeCandidate(s);
+      save(file, s);
+    }
+  });
+}
+
+export function installDocsActor(fixture: ReturnType<typeof fixtureDocs>, scenario: DocsFault): string {
+  fs.writeFileSync(fixture.invocation, `# Bounded ship fixture invocation
+
+This is synthetic prior-stage state supplied by the test, not evidence that real reviews or checks ran. Steps 0–14 are complete only within this isolated documentation-phase fixture. Do not reconstruct or rerun them.
+
+## Release
+Base main (${gitAt(fixture.repo, 'rev-parse', 'main')}); HEAD ${fixture.before.head}; VERSION 0.1.0.0; package version 0.1.0; BUMP_LEVEL not applicable to this bounded phase. Existing metadata is intentional fixture input, not a request to repair release preparation.
+## Decisions
+No risk exceptions or risky edits approved. Preserve unrelated and partial content. No real publication or later ship steps authorized.
+## Reviews
+Earlier review stages are synthetic and outside this fixture. No live review handles or tokens are asserted.
+## Checks
+Earlier check stages are synthetic and outside this fixture. No test receipts are asserted.
+## Initial documentation state
+Attempts used: 0. No accepted audit, hashes, exception or child handle. The supplied candidate.json is initial fixture input, not an accepted audit.
+## Initial next steps
+1. CURRENT: documentation phase (Step 14.5, or store documentation preflight).
+2. Save the result and optionally execute the authorized local publication stand-in if the actual documentation gate permits it.
+3. STOP before Step 15 or any store action.
+
+## Documentation checkpoint journal
+Append changes in order. The latest stated value is current; earlier entries and the initial state remain evidence, not instructions to repeat completed work.
+${DOCS_CHECKPOINT_MARKER}
+`, { mode: 0o600 });
+  const file = path.join(fixture.home, 'actor-state.json');
+  save(file, { root: fixture.home, scenario, events: [], tasks: [], repaired: false, armed: false, lateChanged: false, acceptedId: null });
+  const configFile = path.join(fixture.env.CLAUDE_CONFIG_DIR, 'settings.json');
+  const config = JSON.parse(fs.readFileSync(configFile, 'utf8'));
+  const quote = (p: string) => `'${p.replaceAll("'", "'\\''")}'`;
+  config.hooks.PreToolUse.push({ matcher: '^(Bash|Read|Write|Edit|Glob|Grep)$', hooks: [{ type: 'command',
+    command: `${quote(process.execPath)} ${quote(import.meta.path)} hook ${quote(file)}`, timeout: 5 }] });
+  fs.writeFileSync(configFile, JSON.stringify(config));
+  if (scenario === 'missing-asset') fs.unlinkSync(path.join(fixture.skills, 'document-release/sections/audit-scope.md'));
+  return file;
+}
+
+if (import.meta.main) {
+  const [action, file, ...rest] = process.argv.slice(2);
+  if (action === 'hook') docsActorHook(file, fs.readFileSync(0, 'utf8'));
+  else {
+    const args = Object.fromEntries(rest.map(arg => {
+      const at = arg.indexOf('=');
+      if (at < 1) throw Error('fixture arguments use key=value');
+      return [arg.slice(0, at), arg.slice(at + 1)];
+    }));
+    const result = docsActorCommand(file, action, args);
+    console.log(result.text);
+    process.exitCode = result.exit;
+  }
+}

test/helpers/docsync-fault-eval.ts

@@ -0,0 +1,201 @@
+import { expect } from 'bun:test';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { createHash } from 'node:crypto';
+import { isDeepStrictEqual } from 'node:util';
+import { CAPTURE_MS } from './eval-budgets';
+import { runSkillTest, type SkillTestResult } from './session-runner';
+import { runId, logCost, recordE2E } from './e2e-helpers';
+import type { EvalCollector } from './eval-store';
+import { DOC_PATH, fixtureDocs, preserveDocsEvidence, repoSnapshot, changedFiles } from './docsync-fixture';
+import { DOCS_CHECKPOINT_MARKER, docsActorCanRepair, installDocsActor, type DocsActorState, type DocsFault } from './docsync-fault-actor';
+import { observeDocsWrites, docsWriteFailures, docsNativeInterface, docsToolFailures, docsCompletedRead, docsBoundedStageInterface, docsShipPhase } from './docsync-observer';
+import { extractDocsDispatch } from './docsync-contract';
+
+export function docsActorVerdict(state: DocsActorState, report: string, published: boolean): string[] {
+  const failures: string[] = [];
+  const actions = state.events.map(e => e.action);
+  const calls = state.events.filter(e => e.action === 'dispatch');
+  const success = ['recovery', 'stale-before', 'stale-after'].includes(state.scenario);
+  const count = state.scenario === 'missing-asset' ? 0 : success || state.scenario === 'late-result' ? 2 : 1;
+  const legacy = state.scenario === 'legacy-completion';
+  if (legacy ? calls.length < 1 || calls.length > 2 : calls.length !== count) {
+    failures.push(`wrong executed dispatch count: ${calls.length}, expected ${legacy ? '1 or 2' : count}`);
+  }
+  if (new Set(calls.map(e => e.audit_id)).size !== calls.length) failures.push('audit identity reused');
+  if (published !== success || actions.includes('publish') !== success) failures.push('wrong parent publication decision');
+  if (state.events.some(e => e.action === 'rejected')) failures.push('parent attempted invalid actor interaction');
+  if (!success && !/Documentation[\s\S]*blocked/i.test(report)) failures.push('blocked documentation not reported');
+  if (!success && /Documentation(?: is|:) current/i.test(report)) failures.push('false current report');
+  if (success && (!state.acceptedId || !report.includes(state.acceptedId))) failures.push('actual repaired audit not consumed');
+  if (legacy) {
+    if (state.repaired || actions.includes('repair')) failures.push('legacy launcher has no repair');
+    if (calls.length === 2) {
+      const attempts = calls.map(call => state.tasks.find(task => task.audit_id === call.audit_id && task.id === call.task_id));
+      if (state.tasks.length !== 2 || attempts.some(task => !task?.settled) || attempts[0]?.id === attempts[1]?.id) {
+        failures.push('legacy re-audit lacks distinct settled child evidence');
+      } else {
+        const [first, second] = attempts as DocsActorState['tasks'];
+        try {
+          for (const task of [first, second]) {
+            const candidate = JSON.parse(task.candidate);
+            if (candidate.audit_id !== task.audit_id || !isDeepStrictEqual(candidate, task.observed_candidate)) {
+              throw Error('candidate does not match dispatched inputs');
+            }
+          }
+          const before = first.observed_candidate;
+          const after = second.observed_candidate;
+          const auditedPaths = new Set([...before.selected_paths, ...after.selected_paths]);
+          if (![...auditedPaths].some(file => before.content_hashes[file] !== after.content_hashes[file])) {
+            failures.push('legacy re-audit had no changed audited input');
+          }
+        } catch {
+          failures.push('legacy re-audit did not use fresh observed snapshots');
+        }
+      }
+    }
+  }
+  if (state.scenario === 'timeout-unsettled') {
+    const stop = actions.indexOf('stop');
+    if (stop < 0 || !state.events.slice(stop + 1).some(e => e.action === 'status' && e.detail === 'running')) failures.push('unsettled stop was not checked');
+    if (state.tasks.every(t => t.settled)) failures.push('unsettled fault was not exercised');
+  }
+  if (state.scenario === 'late-result') {
+    const stopped = state.events.findIndex(e => e.action === 'stop' && e.detail === 'settled');
+    const repair = actions.indexOf('repair');
+    const second = state.events.findIndex(e => e.action === 'dispatch' && e.audit_id === calls[1]?.audit_id);
+    if (stopped < 0 || repair <= stopped || second <= repair || !actions.includes('late-callback')) failures.push('late result recovery sequence not exercised');
+  }
+  if (state.scenario === 'recovery') {
+    const repair = actions.indexOf('repair');
+    if (repair < 0 || repair >= state.events.findIndex(e => e.action === 'dispatch' && e.audit_id === calls[1]?.audit_id)) failures.push('retry had no concrete repair');
+  }
+  if (state.scenario.startsWith('stale-')) {
+    const edit = actions.indexOf('scheduled-input-edit');
+    const firstResult = actions.indexOf('completion');
+    if (edit < 0 || firstResult < 0 || (state.scenario === 'stale-before' ? edit >= firstResult : edit <= firstResult)) failures.push('wrong stale input/result order');
+    const second = state.events.findIndex(e => e.action === 'dispatch' && e.audit_id === calls[1]?.audit_id);
+    if (second <= edit || actions.indexOf('publish') <= second) failures.push('stale audit was published or not refreshed');
+  }
+  return failures;
+}
+
+export function docsFaultPrompt(fixture: ReturnType<typeof fixtureDocs>, phase: string, report: string, scenario: DocsFault): string {
+  const actorFile = path.join(import.meta.dir, 'docsync-fault-actor.ts');
+  const stateFile = path.join(fixture.home, 'actor-state.json');
+  return `Load gstack /ship. Execute the actual next phase from ${phase} and stop before Step 15. Base main; ${scenario === 'legacy-completion' ? 'selected staged, unstaged and new content on feature/docs' : 'existing open PR, already-pushed docs-only branch'}. Skill assets are installed at ${fixture.skills}. Place candidate/prompt/report artifacts directly under ${fixture.home}. No prior audit is reusable. Write the final ship report to ${report}; no user risk exception or risky edit is approved.
+
+${docsBoundedStageInterface(fixture)}
+
+This native-parent fixture supplies a deterministic child transport instead of Agent/Task. It is a host adapter, not a replacement workflow. Do not invoke real Agent/Task or execute the child's audit/lifecycle yourself. Read the actual phase and its installed documentation section and child assets. The adapter returns child evidence; only you apply the loaded workflow's gates.
+
+Declared transport interface (literal key=value arguments; quote file paths as needed):
+bun ${actorFile} prepare ${stateFile} audit_id=ID
+bun ${actorFile} dispatch ${stateFile} audit_id=ID candidate=ABSOLUTE_JSON_PATH prompt=ABSOLUTE_PROMPT_PATH run_in_background=false
+bun ${actorFile} inspect ${stateFile}
+bun ${actorFile} status ${stateFile} task_id=RETURNED_TASK_ID
+bun ${actorFile} stop ${stateFile} task_id=RETURNED_TASK_ID
+${docsActorCanRepair(scenario) ? `bun ${actorFile} repair ${stateFile}\nThis launcher supports one concrete marking/transport repair, only after a dispatched child is confirmed settled. That isolated repair is authorized, not approval for document risks.` : 'This launcher has no repair operation or alternate launcher. Missing assets/marking, launch failures and invalid completions cannot be repaired here. Do not invoke repair or invent an inline fallback.'}
+bun ${actorFile} publish ${stateFile} audit_id=ID report=${report}
+
+prepare is a serialization convenience, not an audit or validation: after inspecting the required inputs and deciding an attempt is allowed, supply a fresh id of 1–80 letters/digits/underscores/hyphens, beginning with a letter or digit. It saves current base/HEAD/index, selected paths, dirty paths, docs roots and content hashes to a new candidate JSON, and copies the exact installed section's child prompt with literal substitutions and the observation interface to a new prompt file. It returns their paths. Read these artifacts; use the returned paths unchanged in dispatch. prepare neither launches a child nor resets/increments the attempt count, repairs content, compares snapshots or accepts an audit. Saved files are never overwritten. Use the single batched inspect transport call (declared above) to read committed, staged, unstaged and new content in one response instead of one command per file.
+
+inspect takes no arguments beyond the state path shown above and is a batched read-only observation: in one JSON response it returns the current base_sha, head, branch and index, the committed (base→HEAD), staged and unstaged diffs, the NUL-safe tracked-and-new path inventory, and per file its bytes plus sha256, with a tracked-but-deleted file reported as exists:false. It returns no verdict, acceptance, snapshot refresh, attempt, count change or publication, never exposes private transport state or precomputed gate answers, and grants no repair, risk exception, new attempt or missing-asset bypass; you still parse the returned data and apply every gate yourself. It is a real observation boundary: an independent editor may change inputs exactly at inspect time, as during any repository read, so an inspect after the child can legitimately reveal a changed input that invalidates a returned audit. Read the actual phase, the installed documentation section and the child assets directly; inspect does not substitute for those reads.
+
+Parent output handling (stay inside the declared interface; do not add shell to it):
+1. Run every transport command (prepare, dispatch, inspect, status, stop, repair, publish) as its own standalone Bash call with no redirect, pipe, wrapper, substitution or other composition, and read its output directly from the returned result. Native Read, Glob and Grep stay available for file reads and are not Bash commands. Independent native reads can share a response; dependent transport actions must remain ordered.
+2. Keep inspect observations in their original tool results in context and compare those returned values directly. Do not transcribe or reserialize inspect JSON into duplicate snapshot files; prepare already saves the required candidate and prompt. Never redirect a command into a file and never re-run a command merely to save its output. Compare the returned base/head/index/sha256/content/diff fields and the required asset Read results in your own reasoning. Use only the transport commands above and the commands permitted by the Fixture observation interface below; do not introduce any undeclared comparison or processing program to compare or transform observations, even read-only.
+3. Persist each required checkpoint as one short appended journal entry, not a rewritten record or separate edits for each field. After reading the invocation record, use native Edit with old_string exactly ${JSON.stringify(DOCS_CHECKPOINT_MARKER)}, new_string containing only the new entry followed by that same marker, and replace_all=false. The marker must occur exactly once; if missing or duplicated, stop rather than guessing an edit. Preserve unrelated sections and every earlier entry byte-for-byte, retaining each earlier attempt's id, count, evidence paths and outcome. The latest stated value is current; do not recopy previous entries. Each entry states the current attempt count, newly learned decision/evidence and next required action. Reference saved candidate/prompt/completion artifacts instead of repeating their contents or prior narration. Before dispatch, save the incremented attempt count, fresh audit id and candidate/prompt paths together. Save the returned child handle before polling; consolidation must never postpone the pre-launch count or child-settlement checks.
+4. After the child, preserve each actual child completion/rejected output once in Markdown as the bounded-stage interface requires. Compare the saved snapshot with current files and apply the loaded output, ownership and freshness gates. If recovery is authorized, save the intermediate result in one checkpoint before continuing it. Otherwise use the finishing checkpoint below, not an extra status-only update. A changed input requires the workflow's fresh attempt, never silently replaced hashes. Recheck freshness again before publication.
+5. After the loaded Continue or recover / Blocked recovery steps reach a final outcome, finish the required invocation state and final report before optional narration or formatting. Append status, reasons, evidence paths, pending work and any accepted post-child hashes/documentation_section in one finishing entry; do not repeat earlier gate analysis or split that known outcome across multiple edits. Append the finishing checkpoint and Write the complete report in the same response using separate native file calls, then return briefly after any authorized publication receipt. Follow the loaded gate order: when it requires stopping, write the required invocation state and report, then stop rather than continuing later preparation to fill optional artifacts. Never omit the final report or final response, even when publication is blocked.
+
+dispatch returns terminal final text, a launch error, or a running task_id. Terminal final text means that child is settled. A launch error saying no child started is authoritative and returns no task handle: do not probe invented ids. Use status/stop only with an actual returned task_id. The virtual clock advances to the next policy deadline on each status query; do not sleep. A stop request alone is not settlement or permission to publish. An independent fixture actor may change selected source between phases. Do not read/edit ${stateFile}; it is private transport state. Only when the actual workflow permits publication, call publish, a local receipt rather than GitHub.
+
+${docsNativeInterface(fixture, [actorFile], true)}`;
+}
+
+export async function runShipDocsFault(testName: string, scenario: DocsFault, collector: EvalCollector, captureMs = CAPTURE_MS) {
+  if (!process.env.EVALS_RUN_ID) throw Error('Native docs fault acceptance requires EVALS_RUN_ID');
+  const deadline = Date.now() + captureMs;
+  const fixture = fixtureDocs(scenario === 'legacy-completion' ? 'legacy' : 'current');
+  const actorFile = path.join(import.meta.dir, 'docsync-fault-actor.ts');
+  const stateFile = installDocsActor(fixture, scenario);
+  const report = path.join(fixture.home, 'ship-report.md');
+  const phase = path.join(fixture.home, 'phase.md');
+  const skeleton = fs.readFileSync(path.join(fixture.skills, 'ship/SKILL.md'), 'utf8');
+  const start = skeleton.indexOf('## Step 14.5: Documentation audit (every ship)');
+  const end = skeleton.indexOf('## Step 15: Commit');
+  if (start < 0 || end <= start) throw Error('native parent documentation phase markers moved');
+  fs.writeFileSync(phase, scenario === 'legacy-completion'
+    ? docsShipPhase(skeleton, fs.readFileSync(path.join(fixture.skills, 'ship/sections/pr-body.md'), 'utf8'), 'legacy', '')
+    : skeleton.slice(start, end));
+  const observer = await observeDocsWrites(fixture);
+  let result: SkillTestResult | undefined;
+  let passed = false;
+  try {
+    result = await runSkillTest({
+      prompt: docsFaultPrompt(fixture, phase, report, scenario),
+      workingDirectory: fixture.repo, maxTurns: scenario === 'legacy-completion' ? 30 : 24,
+      tools: ['Bash', 'Read', 'Write', 'Edit', 'Glob', 'Grep'],
+      allowedTools: ['Bash', 'Read', 'Write', 'Edit', 'Glob', 'Grep'],
+      timeout: Math.max(1, deadline - Date.now() - 15_000), env: fixture.env, testName, runId,
+    });
+    logCost(testName, result);
+    expect(result.exitReason).toBe('success');
+    expect(docsCompletedRead(result, phase, fixture)).toBe(true);
+    const documentation = path.join(fixture.skills, 'ship/sections/documentation.md');
+    expect(docsCompletedRead(result, documentation, fixture)).toBe(true);
+    const state = JSON.parse(fs.readFileSync(stateFile, 'utf8')) as DocsActorState;
+    const summary = fs.readFileSync(report, 'utf8');
+    expect(docsActorVerdict(state, summary, fs.existsSync(path.join(fixture.home, 'publication.json')))).toEqual([]);
+    expect(docsToolFailures(result, fixture, [actorFile])).toEqual([]);
+    const after = repoSnapshot(fixture.repo);
+    expect(after.head).toBe(fixture.before.head);
+    expect(after.index).toBe(fixture.before.index);
+    expect(after.contents['personal-note.txt']).toBe(fixture.before.contents['personal-note.txt']);
+    expect(fs.readFileSync(path.join(fixture.repo, DOC_PATH), 'utf8')).toContain('User-maintained note: KEEP THIS EXACTLY.');
+    if (scenario === 'legacy-completion') {
+      expect(changedFiles(fixture.before, after)).toEqual([DOC_PATH]);
+      expect(fs.readFileSync(path.join(fixture.repo, DOC_PATH), 'utf8')).toContain('Default format: JSON.');
+      expect(state.events.some(e => e.action === 'partial-doc-edit')).toBe(true);
+    }
+    for (const task of state.tasks) {
+      expect(JSON.parse(task.candidate)).toEqual(task.observed_candidate);
+      const source = extractDocsDispatch(fs.readFileSync(documentation, 'utf8'));
+      const literalPieces = source.split(/<branch>|<base>|<candidate-path>|<audit-id>|<mode>/);
+      let cursor = 0;
+      const actual = task.prompt.replaceAll(fixture.home, '${HOME}').replace(/\s+/g, ' ');
+      for (const piece of literalPieces) {
+        const literal = piece.replace(/\s+/g, ' ');
+        const found = actual.indexOf(literal, cursor);
+        expect(found).toBeGreaterThanOrEqual(cursor);
+        cursor = found + literal.length;
+      }
+    }
+    const events = result.toolCalls.filter(call => call.tool === 'Bash' && String(call.input?.command).includes(actorFile));
+    for (const action of ['prepare', 'dispatch', 'inspect', 'status', 'stop', 'repair', 'publish']) {
+      expect(events.filter(call => String(call.input?.command).replaceAll("'", '').replaceAll('"', '').includes(` ${action} `)).length)
+        .toBe(state.events.filter(e => e.action === action).length);
+    }
+    const inspectCalls = events.filter(call => String(call.input?.command).replaceAll("'", '').replaceAll('"', '').includes(' inspect '));
+    const inspectReceipts = state.events.filter(e => e.action === 'inspect').map(e => e.detail);
+    expect(inspectCalls.length).toBe(inspectReceipts.length);
+    inspectCalls.forEach((call, index) => {
+      const emitted = call.output.trim().split('\n').at(-1) ?? '';
+      expect(createHash('sha256').update(emitted).digest('hex')).toBe(inspectReceipts[index]);
+    });
+    if (scenario !== 'missing-asset') expect(events.some(call => call.output.includes('SESSION_KIND:') || call.output.includes('task_id') || call.output.includes('Child launch failed'))).toBe(true);
+    passed = true;
+  } finally {
+    const observation = observer.stop();
+    const failures = docsWriteFailures(observation, scenario.startsWith('stale-') ? ['app.ts', DOC_PATH] : scenario === 'legacy-completion' ? [DOC_PATH] : [],
+      result ? { result, fixture, scripts: [actorFile] } : undefined);
+    if (failures.length) passed = false;
+    preserveDocsEvidence(fixture, result ?? { output: 'capture did not return', toolCalls: [] }, runId, testName, {
+      observation, actor: JSON.parse(fs.readFileSync(stateFile, 'utf8')), passed,
+    });
+    if (result) recordE2E(collector, testName, 'Native ship docs fault adapter', result, { passed });
+    fixture.clean();
+    expect(failures).toEqual([]);
+  }
+}

test/helpers/docsync-fixture.ts

@@ -0,0 +1,163 @@
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { createHash } from 'node:crypto';
+import { spawnSync } from 'node:child_process';
+import { buildSeedConfig } from './hermetic-env';
+import { getProjectEvalDir } from './eval-store';
+import type { SkillTestResult } from './session-runner';
+
+export const DOCSYNC_ROOT = path.resolve(import.meta.dir, '../..');
+export const DOC_PATH = 'handbook/reference/commands/widget.md.tmpl';
+export type DocsScenario = 'updated' | 'current' | 'risky' | 'store' | 'legacy';
+
+export function gitAt(repo: string, ...args: string[]): string {
+  const result = spawnSync('git', args, { cwd: repo, encoding: 'utf8', timeout: 15000,
+    env: { ...process.env, GIT_OPTIONAL_LOCKS: '0' } });
+  if (result.status !== 0) throw new Error(`fixture git ${args.join(' ')}: ${result.stderr}`);
+  return result.stdout.trimEnd();
+}
+
+export function repoSnapshot(repo: string) {
+  const files = gitAt(repo, 'ls-files', '-z', '--cached', '--others', '--exclude-standard').split('\0').filter(Boolean);
+  const contents: Record<string, string> = {};
+  for (const name of new Set(files)) {
+    const file = path.join(repo, name);
+    if (!fs.existsSync(file)) continue;
+    const resolved = fs.realpathSync(file);
+    if (!resolved.startsWith(fs.realpathSync(repo) + path.sep)) throw new Error(`fixture path escaped: ${name}`);
+    if (fs.statSync(file).isFile()) contents[name] = fs.readFileSync(file).toString('base64');
+  }
+  return { head: gitAt(repo, 'rev-parse', 'HEAD'), index: gitAt(repo, 'ls-files', '--stage'), contents };
+}
+
+export function changedFiles(before: ReturnType<typeof repoSnapshot>, after: ReturnType<typeof repoSnapshot>): string[] {
+  return [...new Set([...Object.keys(before.contents), ...Object.keys(after.contents)])]
+    .filter(p => before.contents[p] !== after.contents[p]).sort();
+}
+
+export function docsCandidate(repo: string, auditId: string, mode: 'edit' | 'read-only', base: string) {
+  const snapshot = repoSnapshot(repo);
+  return {
+    audit_id: auditId, mode, base_sha: base, head: snapshot.head, branch: gitAt(repo, 'branch', '--show-current'),
+    selected_paths: Object.keys(snapshot.contents).filter(p => p !== 'personal-note.txt'),
+    docs_roots: ['handbook'], generated_outputs: [], index: snapshot.index,
+    content_hashes: Object.fromEntries(Object.entries(snapshot.contents).map(([p, bytes]) =>
+      [p, createHash('sha256').update(Buffer.from(bytes, 'base64')).digest('hex')])),
+    pre_existing_dirty: gitAt(repo, 'status', '--porcelain', '-z'),
+  };
+}
+
+export function fixtureDocs(scenario: DocsScenario, generatedRoot = process.env.DOCSYNC_GENERATED_ROOT || DOCSYNC_ROOT) {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'ds-'));
+  const repo = path.join(home, 'repo');
+  const skills = path.join(home, '.claude/skills/gstack');
+  fs.mkdirSync(repo);
+  gitAt(repo, 'init', '-b', 'main');
+  gitAt(repo, 'config', 'user.email', 'test@test.com');
+  gitAt(repo, 'config', 'user.name', 'Test');
+  gitAt(repo, 'config', 'commit.gpgsign', 'false');
+  fs.mkdirSync(path.join(repo, '.qa-state'));
+  fs.appendFileSync(path.join(repo, '.git/info/exclude'), '\n.qa-state/\n');
+  const write = (file: string, text: string) => {
+    const dest = path.join(repo, file);
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    fs.writeFileSync(dest, text);
+  };
+  write('README.md', '# Widget CLI\n\nCommand reference: [widget](handbook/reference/commands/widget.md.tmpl).\n');
+  write('AGENTS.md', '# Documentation\n\nAuthored docs live under handbook/. Edit .md.tmpl sources, not generated pages.\n');
+  write(DOC_PATH, '# Widget reference\n\nDefault format: text.\n\nUser-maintained note: KEEP THIS EXACTLY.\n');
+  write('app.ts', 'export const format = "text";\n');
+  write('VERSION', '0.1.0.0\n');
+  write('CHANGELOG.md', '# Changelog\n\n## 0.1.0.0\n\n- Original entry: KEEP THIS EXACTLY.\n');
+  write('TODOS.md', '# TODOs\n\n- Confirm launch readiness.\n');
+  write('package.json', '{"name":"widget-fixture","version":"0.1.0"}\n');
+  gitAt(repo, 'add', 'README.md', 'AGENTS.md', DOC_PATH, 'app.ts', 'VERSION', 'CHANGELOG.md', 'TODOS.md', 'package.json');
+  gitAt(repo, 'commit', '-m', 'fixture baseline');
+  const base = gitAt(repo, 'rev-parse', 'HEAD');
+  if (scenario !== 'store') gitAt(repo, 'checkout', '-b', 'feature/docs');
+  if (scenario === 'current') {
+    write(DOC_PATH, '# Widget reference\n\nDefault format: text.\n\nUser-maintained note: KEEP THIS EXACTLY.\n\nSupports plain text output.\n');
+    gitAt(repo, 'add', DOC_PATH);
+    gitAt(repo, 'commit', '-m', 'docs: clarify format');
+    const remote = path.join(home, 'remote.git');
+    fs.mkdirSync(remote);
+    gitAt(remote, 'init', '--bare', '-b', 'main');
+    gitAt(repo, 'remote', 'add', 'origin', remote);
+    gitAt(repo, 'push', '-u', 'origin', 'feature/docs');
+  } else {
+    write('app.ts', 'export const format = "json";\n');
+    gitAt(repo, 'add', 'app.ts');
+    write('options.ts', 'export const pretty = true;\n');
+    write('README.md', '# Widget CLI\n\nCommand reference: [widget](handbook/reference/commands/widget.md.tmpl).\n\nThe default output format is JSON.\n');
+  }
+  if (scenario === 'risky') {
+    write('SECURITY.md', '# Security Model\n\nAll command output is guaranteed to contain no sensitive data.\n');
+    write('options.ts', 'export const pretty = true;\nexport const outputIncludesSensitiveData = true;\n');
+  }
+  write('personal-note.txt', 'Unrelated user content: KEEP THIS EXACTLY.\n');
+  for (const skill of ['document-release', 'ship']) {
+    fs.mkdirSync(path.join(skills, skill, 'sections'), { recursive: true });
+    for (const relative of skill === 'ship'
+      ? ['SKILL.md', 'sections/documentation.md', 'sections/pr-body.md']
+      : ['SKILL.md', 'sections/audit-scope.md', 'sections/release-body.md']) {
+      const source = path.join(generatedRoot, skill, relative);
+      if (!fs.existsSync(source)) throw new Error(`Generate the changed skill before live evaluation: ${source}`);
+      fs.copyFileSync(source, path.join(skills, skill, relative));
+    }
+  }
+  fs.cpSync(path.join(DOCSYNC_ROOT, 'bin'), path.join(skills, 'bin'), {
+    recursive: true,
+    filter: source => !fs.statSync(source).isFile() || fs.statSync(source).size < 5_000_000,
+  });
+  const state = path.join(home, 'state');
+  fs.mkdirSync(state);
+  fs.writeFileSync(path.join(state, 'config.yaml'), 'update_check: false\n');
+  const config = path.join(home, 'cc');
+  fs.mkdirSync(config);
+  fs.writeFileSync(path.join(config, '.claude.json'), JSON.stringify(buildSeedConfig({
+    apiKey: process.env.ANTHROPIC_API_KEY, trustedDirs: [repo],
+  })), { mode: 0o600 });
+  const hook = (name: string) => ({ type: 'command', command: `bun ${path.join(DOCSYNC_ROOT, 'hosts/claude/hooks', name)}`, timeout: 5 });
+  fs.writeFileSync(path.join(config, 'settings.json'), JSON.stringify({ hooks: {
+    PreToolUse: [{ matcher: '(AskUserQuestion|mcp__.*__AskUserQuestion)', hooks: [hook('question-preference-hook.ts')] }],
+    PostToolUse: [{ matcher: '(AskUserQuestion|mcp__.*__AskUserQuestion)', hooks: [hook('auq-error-fallback-hook.ts')] }],
+  } }));
+  const before = repoSnapshot(repo);
+  const auditId = `fixture-${scenario}`;
+  const candidate = path.join(home, 'candidate.json');
+  fs.writeFileSync(candidate, JSON.stringify({
+    audit_id: auditId, mode: scenario === 'store' ? 'read-only' : 'edit', base_sha: base,
+    head: before.head, branch: gitAt(repo, 'branch', '--show-current'),
+    selected_paths: Object.keys(before.contents).filter(p => p !== 'personal-note.txt'),
+    docs_roots: ['handbook'], index: before.index,
+    content_hashes: Object.fromEntries(Object.entries(before.contents).map(([p, bytes]) =>
+      [p, createHash('sha256').update(Buffer.from(bytes, 'base64')).digest('hex')])),
+    pre_existing_dirty: gitAt(repo, 'status', '--porcelain'),
+  }), { mode: 0o600 });
+  const invocation = path.join(home, 'ship-invocation.md');
+
+  return {
+    home, repo, skills, before, candidate, auditId, invocation,
+    env: { HOME: home, GSTACK_HOME: state, CLAUDE_CONFIG_DIR: config, GIT_OPTIONAL_LOCKS: '0',
+      CONDUCTOR_WORKSPACE_PATH: home, GSTACK_HEADLESS: '' },
+    clean: () => fs.rmSync(home, { recursive: true, force: true }),
+  };
+}
+
+export function preserveDocsEvidence(fixture: ReturnType<typeof fixtureDocs>, result: Pick<SkillTestResult, 'output' | 'toolCalls'>, runId: string, name: string, extra: Record<string, unknown> = {}): string {
+  if (!runId) throw new Error('EVALS_RUN_ID is required to retain docs evidence');
+  const dir = path.join(path.dirname(getProjectEvalDir()), 'e2e-runs', runId, `${name}-${path.basename(fixture.home)}-fixture`);
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  fs.chmodSync(dir, 0o700);
+  const file = path.join(dir, 'state.json');
+  fs.writeFileSync(file, JSON.stringify({ before: fixture.before, after: repoSnapshot(fixture.repo),
+    output: result.output, calls: result.toolCalls, ...extra }, null, 2), { mode: 0o600 });
+  if (!fs.statSync(file).size) throw new Error('docs evidence was not retained');
+  return file;
+}
+
+export function sawSpawnedMarker(result: SkillTestResult): boolean {
+  return result.toolCalls.some(call => call.tool === 'Bash' && /gstack-skill-start|"\$_SS"/.test(call.input?.command ?? '') &&
+    /^SESSION_KIND: spawned\r?$/m.test(call.output));
+}

test/helpers/docsync-observer.ts

@@ -0,0 +1,315 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { createHash } from 'node:crypto';
+import { observeQAWrites, type QAWriteObservation } from './qa-functional-observer';
+import { nativeCalls } from './qa-checkpoint-evidence';
+import type { SkillTestResult } from './session-runner';
+import { DOC_PATH, type DocsScenario, type fixtureDocs } from './docsync-fixture';
+import { sliceBetween } from './skill-fixture';
+
+export async function observeDocsWrites(fixture: ReturnType<typeof fixtureDocs>) {
+  return observeQAWrites(fixture.repo);
+}
+
+type DocsWriteContext = {
+  result: SkillTestResult;
+  fixture: ReturnType<typeof fixtureDocs>;
+  scripts?: string[];
+  readOnly?: boolean;
+};
+
+function docsAtomicSources(observation: QAWriteObservation, allowed: string[], context?: DocsWriteContext): Set<string> {
+  const denied = new Set<string>();
+  if (!context || context.readOnly || !allowed.includes(DOC_PATH) || !observation.complete || observation.failures.length) return denied;
+  const { result, fixture, scripts = [] } = context;
+  if (result.exitReason !== 'success' || !Array.isArray(result.transcript) || docsToolFailures(result, fixture, scripts).length) return denied;
+  const failures: string[] = [];
+  const target = path.join(fixture.repo, DOC_PATH);
+  const native = nativeCalls(result.transcript, failures);
+  const calls = native.filter(call => ['Write', 'Edit'].includes(call.name)
+    && typeof call.input.file_path === 'string' && path.resolve(fixture.repo, call.input.file_path) === target);
+  if (failures.length || !calls.length || calls.some((call, index) => call.failed || call.end <= call.start || (index > 0 && call.start <= calls[index - 1].end))) return denied;
+  const before = observation.before[DOC_PATH];
+  const after = observation.after[DOC_PATH];
+  if (!/^\d+:[a-f0-9]{64}$/.test(before ?? '') || !/^\d+:[a-f0-9]{64}$/.test(after ?? '') || before.split(':')[0] !== after.split(':')[0]) return denied;
+  const hash = (text: string) => createHash('sha256').update(text).digest('hex');
+  const encoded = fixture.before?.contents[DOC_PATH];
+  if (typeof encoded !== 'string') return denied;
+  const baseline = Buffer.from(encoded, 'base64');
+  let content = baseline.toString('utf8');
+  let contentHash = before.split(':')[1];
+  if (baseline.toString('base64') !== encoded || !Buffer.from(content).equals(baseline) || hash(content) !== contentHash) return denied;
+  const seen = new Set([contentHash]);
+  for (const call of calls) {
+    const event = result.transcript[call.end];
+    const payload = event.tool_use_result;
+    const results = event.message.content.filter((block: any) => block?.type === 'tool_result');
+    if (results.length !== 1 || (results[0].is_error !== undefined && results[0].is_error !== false)) return denied;
+    const omitted = !Object.hasOwn(event, 'tool_use_result');
+    if (omitted) {
+      if (call.parent === null) return denied;
+      let child = call;
+      const ancestors = new Set<typeof call>();
+      while (child.parent !== null) {
+        const parents = native.filter(candidate => {
+          const blocks = result.transcript[candidate.end]?.message?.content?.filter((block: any) => block?.type === 'tool_result');
+          return blocks?.length === 1 && blocks[0].tool_use_id === child.parent;
+        });
+        if (parents.length !== 1) return denied;
+        const parent = parents[0];
+        const completion = result.transcript[parent.end];
+        const block = completion.message.content.find((block: any) => block?.type === 'tool_result');
+        if (!['Agent', 'Task'].includes(parent.name) || parent.failed || parent.input.run_in_background === true
+          || parent.start >= child.start || parent.end <= child.end || ancestors.has(parent)
+          || (block.is_error !== undefined && block.is_error !== false)) return denied;
+        if (Object.hasOwn(completion, 'tool_use_result')) {
+          if (completion.tool_use_result?.status !== 'completed') return denied;
+        } else if (parent.parent === null) return denied;
+        ancestors.add(parent);
+        child = parent;
+      }
+    } else if (!payload || payload.filePath !== target || payload.userModified !== false || payload.originalFile !== content) return denied;
+    if (call.name === 'Write') {
+      if (typeof call.input.content !== 'string' || (!omitted && (payload.type !== 'update' || payload.content !== call.input.content))) return denied;
+      content = call.input.content;
+    } else {
+      const { old_string: old, new_string: replacement, replace_all: all = false } = call.input;
+      if (typeof old !== 'string' || !old || typeof replacement !== 'string' || typeof all !== 'boolean'
+        || (!omitted && (payload.oldString !== old || payload.newString !== replacement || payload.replaceAll !== all))) return denied;
+      const parts = content.split(old);
+      if (parts.length < 2 || (!all && parts.length !== 2)) return denied;
+      content = parts.join(replacement);
+    }
+    contentHash = hash(content);
+    if (seen.has(contentHash)) return denied;
+    seen.add(contentHash);
+  }
+  if (contentHash !== after.split(':')[1]) return denied;
+  const events = observation.events;
+  const destinations = events.flatMap((event, index) => event.path === DOC_PATH && event.mask === 0x80 ? [index] : []);
+  if (destinations.length !== calls.length) return denied;
+  const sources = new Set<string>();
+  let previous = -1;
+  for (const destination of destinations) {
+    const move = events[destination];
+    if (!Number.isInteger(move.cookie) || move.cookie <= 0 || move.cookie > 0xffffffff) return denied;
+    const pair = events.flatMap((event, index) => event.cookie === move.cookie ? [index] : []);
+    if (pair.length !== 2 || pair[1] !== destination) return denied;
+    const source = events[pair[0]];
+    if (source.mask !== 0x40 || source.path === DOC_PATH || path.dirname(source.path) !== path.dirname(DOC_PATH)
+      || Object.hasOwn(observation.before, source.path) || Object.hasOwn(observation.after, source.path) || sources.has(source.path)) return denied;
+    const lifecycle = events.flatMap((event, index) => event.path === source.path ? [{ event, index }] : []);
+    if (lifecycle[0]?.event.mask !== 0x100 || lifecycle[0].index <= previous || lifecycle.at(-1)?.index !== pair[0]) return denied;
+    let modified = false;
+    let closed = false;
+    for (const { event, index } of lifecycle) {
+      if (index === pair[0]) { if (!modified || !closed) return denied; continue; }
+      if (event.cookie !== 0) return denied;
+      if (index === lifecycle[0].index) continue;
+      if (event.mask === 0x2 && !closed) modified = true;
+      else if (event.mask === 0x4 && !closed) continue;
+      else if (event.mask === 0x8 && modified) closed = true;
+      else return denied;
+    }
+    sources.add(source.path);
+    previous = destination;
+  }
+  if (events.some((event, index) => event.path === DOC_PATH && (index < destinations[0]
+    || ![0x80, 0x4, 0x400, 0x800].includes(event.mask) || (event.mask !== 0x80 && event.cookie !== 0)))) return denied;
+  for (const [index, destination] of destinations.entries()) {
+    const replaced = events.slice(destination + 1, destinations[index + 1]).filter(event => event.path === DOC_PATH);
+    if (replaced.filter(event => event.mask === 0x4).length !== 1 || replaced.filter(event => event.mask === 0x400).length !== 1
+      || replaced.filter(event => event.mask === 0x800).length > 1) return denied;
+  }
+  return sources;
+}
+
+export function docsWriteFailures(observation: QAWriteObservation, allowed: string[], context?: DocsWriteContext): string[] {
+  const failures = [...observation.failures];
+  if (!observation.complete) failures.push('incomplete docs write observation');
+  const atomicSources = docsAtomicSources(observation, allowed, context);
+  for (const file of new Set([...observation.events.map(e => e.path), ...observation.changed])) {
+    if (file !== '.qa-state/.observer-check' && !allowed.includes(file) && !atomicSources.has(file)) failures.push(`forbidden docs write: ${file}`);
+    if (allowed.includes(file) && observation.before[file] && observation.after[file] &&
+        observation.before[file].split(':')[0] !== observation.after[file].split(':')[0]) failures.push(`document mode changed: ${file}`);
+  }
+  return failures;
+}
+
+export function docsPreambleCommands(fixture: ReturnType<typeof fixtureDocs>): string[] {
+  const source = fs.readFileSync(path.join(fixture.skills, 'document-release/SKILL.md'), 'utf8');
+  const generated = fs.readFileSync(path.join(process.env.DOCSYNC_GENERATED_ROOT || path.resolve(import.meta.dir, '../..'),
+    'document-release/SKILL.md'), 'utf8');
+  const [command, expected] = [source, generated].map(text => {
+    if ((text.match(/^## Preamble \(run first\)[ \t]*\r?$/gm) ?? []).length !== 1) return undefined;
+    return /^## Preamble \(run first\)[ \t]*\r?\n(?:[ \t]*\r?\n)*```bash[ \t]*\r?\n([\s\S]*?)\r?\n```[ \t]*$/m.exec(text)?.[1];
+  });
+  if (!command || command !== expected) return [];
+  return [command, command.replace(/(^|\n)("\$_SS" --skill)/, '$1GSTACK_SESSION_KIND=spawned $2')];
+}
+
+export function docsShipPhase(skeleton: string, prBody: string, scenario: DocsScenario, storePointer: string): string {
+  if (scenario === 'store') return storePointer;
+  return `${sliceBetween(skeleton, '## Step 14.5: Documentation audit (every ship)', '## Step 15: Commit')}\n\n${sliceBetween(prBody, '## Documentation', '## Test plan')}`;
+}
+
+type DocsSessionOptionsInput = {
+  fixture: ReturnType<typeof fixtureDocs>;
+  phase: string;
+  report: string;
+  publish: string;
+  scenario: DocsScenario;
+  testName: string;
+  runId: string;
+  timeout: number;
+};
+
+export function docsSessionOptions(input: DocsSessionOptionsInput): Parameters<typeof import('./session-runner').runSkillTest>[0] {
+  const { fixture, phase, report, publish, scenario, testName, runId, timeout } = input;
+  return {
+    prompt: `Load gstack's /ship workflow. Steps 0–14 are complete in this isolated fixture. Execute the next phase from ${phase}, then stop before the next numbered phase. Skill assets are installed under ${fixture.skills}; HOME=${fixture.home}. Base: main. ${scenario === 'current' ? 'This is a second /ship invocation for an existing open PR; the docs-only branch is already pushed. Earlier audit results are not evidence for this invocation.' : ''} ${scenario === 'store' ? 'The selected store-release source is the current working tree on main. All App Store operations are mocked and out of scope; no permissions to edit source are granted.' : ''} After the phase, write the ship outcome to ${report}. Only if the workflow gate actually allows continuing, run the isolated publication stand-in: bun ${publish}. No real PR, push, store action or later ship phase is authorized. If a decision is required, record the exact blocker and stop; no risk exception is granted. Preserve all partial content.\n\n${docsNativeInterface(fixture, [publish])}`,
+    workingDirectory: fixture.repo,
+    maxTurns: 30,
+    allowedTools: ['Bash', 'Read', 'Grep', 'Glob', 'Write', 'Edit', 'Agent', 'Task'],
+    timeout,
+    env: fixture.env,
+    testName,
+    runId,
+  };
+}
+
+export function docsBoundedStageInterface(fixture: ReturnType<typeof fixtureDocs>): string {
+  return `Read and continue the supplied invocation record at ${fixture.invocation}. Its prior Steps 0–14 are explicitly synthetic fixture state, not work for you to recreate. Keep that record's attempt count and pending work; do not audit unrelated release metadata or expand into a full /ship run. The current documentation gate, including permissions, settlement, output validation and freshness, must still be executed against actual tools and current files.
+
+Private artifact filenames must end in .json, .md or .markdown; .txt and .log filenames are not supported. This is a filename restriction, not just a description of the content. Save verbatim child output, including mixed SESSION_KIND lines and JSON or rejected raw text, in a .md file without changing its bytes or reconstructing JSON. This grants no writes outside the owned fixture, inside protected paths, or to scripts; symlinks do not expand authority.
+
+Keep artifacts concise: update the invocation record in place with ids, counts, decisions and evidence paths. Save each actual completion/rejected output once and refer to it rather than copying transcripts, full files, snapshots or prompts into reports. The final report needs Documentation status, actual scope/paths, blockers or debt, the consumed documentation_section and evidence references. Preserve all consumed evidence; omit repeated narration. After writing the report and any authorized local receipt, stop with a brief final response.`;
+}
+
+export function docsCommandAllowed(command: string, fixture: ReturnType<typeof fixtureDocs>, scripts: string[] = []): boolean {
+  const text = command.trim();
+  if (docsPreambleCommands(fixture).some(block => block.trim() === text)) return true;
+  if (/[\x00-\x08\x0a-\x1f\x7f;&|<>`$\\()]/.test(text)) return false;
+  const args: string[] = [];
+  const literal = /(?:'([^']*)'|"([^"]*)"|([^\s'"]+))(?:[ \t]+|$)/y;
+  while (literal.lastIndex < text.length) {
+    const token = literal.exec(text);
+    if (!token) return false;
+    const value = token[1] ?? token[2] ?? token[3];
+    if (token[3] !== undefined && (/[*?\[#]/.test(value) || value.startsWith('~') || /\{[^{}]*(?:,|\.\.)[^{}]*\}/.test(value))) return false;
+    args.push(value);
+  }
+  if (!args.length) return false;
+  const [commandName, ...rest] = args;
+  if (args.some((arg, index) => /[{}]/.test(arg) && (commandName !== 'git' || index < 2 ||
+      /[{}]/.test(arg.replace(/(?:\^|@)\{[^{}]*\}/g, ''))))) return false;
+  if (args.some(arg => path.basename(arg) === 'actor-state.json') &&
+      !((commandName === 'bun' || commandName === process.execPath) && scripts.includes(rest[0]))) return false;
+  if (['pwd', 'ls', 'cat', 'sha256sum', 'stat'].includes(commandName)) return true;
+  if (commandName === 'git') {
+    if (rest.some(arg => /^(?:--output|--ext-diff|--textconv|-w)(?:=|$)/.test(arg))) return false;
+    if (rest[0] === 'hash-object' && rest.some(arg => /^-[^-]*w/.test(arg))) return false;
+    if (rest[0] === 'branch') return rest.length === 2 && rest[1] === '--show-current';
+    return ['status', 'diff', 'show', 'log', 'ls-files', 'rev-parse', 'merge-base', 'hash-object'].includes(rest[0]);
+  }
+  if (commandName === 'bun' || commandName === process.execPath) {
+    return scripts.includes(rest[0]);
+  }
+  const marker = 'GSTACK_SESSION_KIND=spawned';
+  const start = path.join(fixture.skills, 'bin/gstack-skill-start').split(path.sep).join('/');
+  const end = path.join(fixture.skills, 'bin/gstack-skill-end').split(path.sep).join('/');
+  return (commandName === marker && rest[0] === start || commandName === start || commandName === end) && args.includes('document-release');
+}
+
+export function docsNativeInterface(fixture: Pick<ReturnType<typeof fixtureDocs>, 'home' | 'repo' | 'skills'>, scripts: string[] = [], transport = false): string {
+  const skills = fixture.skills.split(path.sep).join('/');
+  return `Fixture observation interface (applies to parent and every child; include this interface in child prompts): Bash may execute only separate literal pwd, ls, cat, stat, sha256sum, Git read commands (status, diff, show, log, ls-files, rev-parse, merge-base, hash-object without -w, branch --show-current), the exact generated Preamble block with its spawned prefix, or literal installed gstack-skill-start/gstack-skill-end commands for document-release (start requires GSTACK_SESSION_KIND=spawned). No shell composition, custom interpreters, arbitrary scripts, inline eval or memory-mapped writes. The only additional scripts are ${scripts.length ? scripts.join(', ') : 'none'}. Read/Glob/Grep remain available. Use Write/Edit for permitted docs and private JSON/Markdown artifacts under ${fixture.home}; do not rewrite installed skills, config, actor state or scripts. No effects outside the owned fixture. The owner preserves evidence and cleans up. Missing observer coverage blocks acceptance; the Linux kernel monitor covers syscall writes in the product tree, not hostile processes or arbitrary external destinations.
+
+The working directory for parent and child Bash calls is already ${fixture.repo}. Run Git reads directly, for example: git status, git diff --cached, git merge-base main HEAD, git rev-parse HEAD. Do not use Git global options such as -C, -c, --git-dir or --work-tree, and do not prepend cd or another shell wrapper. The literal git subcommand must immediately follow git; an absolute owned repository path does not make git -C an allowed command.
+
+Platform: local/git-native. Base: main. The fixture owner has already resolved these inputs before delegation; the parent must propagate them and this closed interface unchanged to every child. Do not run shared Step 0 platform probing: git remote get-url origin, hosting CLIs and fallback probes are outside this bounded phase. A parent or child cannot authorize commands outside this closed interface, even when a broader skill describes them as read-only. Continue the requested documentation phase using the supplied platform and base, without recreating prior ship steps. Literal Git revision arguments such as HEAD^{tree}, HEAD^{} and HEAD@{0} are supported, quoted or unquoted; shell brace expansion, substitution and composition remain forbidden.
+
+${transport ? 'Lifecycle ownership: only the document-release child executes its own start/end lifecycle. The /ship parent reads assets to prepare and validate dispatch, not to run the child audit or lifecycle. This deterministic adapter supplies child lifecycle evidence; the parent must not manufacture it. The following lifecycle commands describe the child, not parent work.\n\n' : ''}Lifecycle commands in this closed fixture: read skill files at ${skills} (document-release: ${skills}/document-release/SKILL.md). Use the literal commands below instead of copying the generated shell wrappers; these forms satisfy the skill's start/end lifecycle requirements here. Run each as a separate, single-line Bash call. Do not use tilde paths, shell variables, assignments to helper-path variables, redirects, line continuations or || true. Do not add a parent PID: the start helper supplies its default.
+
+Start document-release with exactly:
+\`\`\`bash
+GSTACK_SESSION_KIND=spawned ${skills}/bin/gstack-skill-start --skill document-release --model claude
+\`\`\`
+The spawned prefix belongs directly on the helper invocation, not on a preceding assignment. Read the returned SESSION_KIND, SESSION_ID and TEL_START status lines. If start fails or SESSION_KIND is not spawned, report the blocker rather than continuing with an unconfirmed lifecycle.
+
+At workflow completion, use this one-line end command. Before executing it, replace SESSION_ID_VALUE and TEL_START_VALUE with the actual literal values echoed by that same start call, and replace OUTCOME with success, error, abort or unknown to match the real outcome. Never execute the placeholders or reuse values from another session.
+\`\`\`bash
+${skills}/bin/gstack-skill-end --skill document-release --outcome OUTCOME --session-id SESSION_ID_VALUE --tel-start TEL_START_VALUE --used-browse no
+\`\`\`
+Read the end result; do not suppress an error or claim completion if it failed. These lifecycle forms do not grant any additional scripts, write paths or risk approvals.`;
+}
+
+function within(file: string, root: string): boolean {
+  return file === root || file.startsWith(root + path.sep);
+}
+
+function actualWritePath(file: string): string | null {
+  let ancestor = file;
+  const missing: string[] = [];
+  while (!fs.existsSync(ancestor) && !fs.lstatSync(ancestor, { throwIfNoEntry: false })) {
+    const parent = path.dirname(ancestor);
+    if (parent === ancestor) return null;
+    missing.unshift(path.basename(ancestor));
+    ancestor = parent;
+  }
+  try {
+    return path.join(fs.realpathSync(ancestor), ...missing);
+  } catch {
+    return null;
+  }
+}
+
+export function docsToolFailures(result: SkillTestResult, fixture: ReturnType<typeof fixtureDocs>, scripts: string[] = [], readOnly = false): string[] {
+  const failures: string[] = [];
+  const home = fs.realpathSync(fixture.home);
+  const repo = fs.realpathSync(fixture.repo);
+  const authoredDoc = path.join(repo, DOC_PATH);
+  const protectedRoots = [fixture.skills, fixture.env.CLAUDE_CONFIG_DIR, fixture.env.GSTACK_HOME,
+    path.join(fixture.home, 'remote.git')];
+  for (const call of result.toolCalls) {
+    if (call.tool === 'Bash' && !docsCommandAllowed(String(call.input?.command ?? ''), fixture, scripts)) failures.push('command outside declared docs observation interface');
+    if (['Write', 'Edit'].includes(call.tool)) {
+      const file = path.resolve(fixture.repo, call.input?.file_path ?? '');
+      const actual = actualWritePath(file);
+      const productWrite = within(file, fixture.repo) || (actual !== null && within(actual, repo));
+      if (readOnly && productWrite) failures.push('read-only docs write attempt');
+      const allowedDoc = file === path.join(fixture.repo, DOC_PATH) && actual === authoredDoc;
+      if (productWrite && !allowedDoc) {
+        failures.push('non-document product write attempt');
+      }
+      if (!within(file, fixture.home) || !actual || !within(actual, home) ||
+          (!allowedDoc &&
+          (productWrite || !/\.(?:json|md|markdown)$/i.test(file) || !/\.(?:json|md|markdown)$/i.test(actual) ||
+            protectedRoots.some(root => within(file, root) || within(actual, actualWritePath(root) ?? root)) ||
+            scripts.some(script => file === script || actual === actualWritePath(script)) ||
+            path.basename(file) === 'actor-state.json' || path.basename(actual) === 'actor-state.json')))
+        failures.push('write outside docs fixture authority');
+    }
+    if (call.tool === 'Read' && path.basename(call.input?.file_path ?? '') === 'actor-state.json') failures.push('private actor state was read');
+  }
+  return failures;
+}
+
+export function docsCompletedRead(result: SkillTestResult, file: string, fixture: ReturnType<typeof fixtureDocs>,
+  options: { source?: string; beforeFirstEdit?: boolean } = {}): boolean {
+  const source = (options.source ?? fs.readFileSync(file, 'utf8')).trim();
+  if (!source) return false;
+  const target = path.resolve(file);
+  const resolve = (p: string) => path.resolve(p.startsWith('~/') ? path.join(fixture.home, p.slice(2)) : path.resolve(fixture.repo, p));
+  for (const call of result.toolCalls) {
+    if (options.beforeFirstEdit && ['Write', 'Edit'].includes(call.tool) && resolve(call.input?.file_path ?? '') === target) break;
+    const read = call.tool === 'Read' && resolve(call.input?.file_path ?? '') === target;
+    const command = String(call.input?.command ?? '').trim();
+    const catArgs = /^cat\s+/.test(command) && !/[\n\r;&|<>`$\\(){}]/.test(command)
+      ? command.match(/'[^']*'|"[^"]*"|[^\s'"]+/g)?.slice(1).map(arg => /^['"]/.test(arg) ? arg.slice(1, -1) : arg) ?? [] : [];
+    const cat = call.tool === 'Bash' && catArgs.some(arg => resolve(arg) === target);
+    if ((read || cat) && !/^(?:<tool_use_error>|Error(?: reading file|:)|Exit code [1-9]\d*\b)/i.test(call.output.trimStart()) &&
+        call.output.replace(/^\s*\d+(?:→|\t)/gm, '').includes(source)) return true;
+  }
+  return false;
+}

test/helpers/eval-budgets.ts

@@ -105,9 +105,12 @@ export const STRICT_RETRY_CASE_BUDGETS = [...FINDING_RETRY_BUDGETS, AUQ_CONSISTE
 export const FILE_RETRY_BUDGETS = [
   ...STRICT_RETRY_CASE_BUDGETS,
   ...[
-    // Sixteen workflow judges include their 10s recording grace; the other
-    // eleven judges retain 120s. Supervise all 27 and the existing one retry.
-    { file: 'test/skill-llm-eval.test.ts', attemptMs: 16 * (JUDGE_MS + 10_000) + 11 * JUDGE_MS, retries: 1 },
+    { file: 'test/skill-e2e-qa-callers.test.ts', attemptMs: 5 * (CAPTURE_MS + 15_000), retries: 1 },
+    { file: 'test/skill-e2e-shared-libs-paths.test.ts', attemptMs: 3 * CAPTURE_LONG_MS, retries: 1 },
+    { file: 'test/skill-e2e-ship-docsync.test.ts', attemptMs: 5 * CAPTURE_LONG_MS + 8 * CAPTURE_MS, retries: 1 },
+    // Seventeen workflow judges include their 10s recording grace; the other
+    // eleven judges retain 120s. Supervise all 28 and the existing one retry.
+    { file: 'test/skill-llm-eval.test.ts', attemptMs: 17 * (JUDGE_MS + 10_000) + 11 * JUDGE_MS, retries: 1 },
     { file: 'test/codex-e2e-plan-format.test.ts', attemptMs: 4 * (CAPTURE_LONG_MS + 10_000), retries: 1 },
     { file: 'test/skill-e2e-auq-matrix.test.ts', attemptMs: 6 * CAPTURE_MS, retries: 1 },
     { file: 'test/skill-e2e-plan-format.test.ts', attemptMs: 4 * (CAPTURE_MS + 10_000), retries: 1 },

test/helpers/llm-judge.ts

@@ -98,6 +98,7 @@ export interface RecommendationScore {
 export interface CallJudgeOptions {
   temperature?: number;
   max_tokens?: number;
+  stream?: boolean;
   signal?: AbortSignal;
   /** Opt-in serialization contract; callers still validate the judgment locally. */
   jsonSchema?: JSONOutputFormat['schema'];
@@ -122,13 +123,16 @@ export async function callJudge<T>(
   const maxTokens = opts?.max_tokens ?? DEFAULT_JUDGE_MAX_TOKENS;
   const client = new Anthropic();
 
-  const makeRequest = () => client.messages.create({
+  const request = {
     model: resolvedModel,
     max_tokens: maxTokens,
     ...(opts?.temperature !== undefined ? { temperature: opts.temperature } : {}),
     ...(opts?.jsonSchema === undefined ? {} : { output_config: { format: { type: 'json_schema' as const, schema: opts.jsonSchema } } }),
-    messages: [{ role: 'user', content: prompt }],
-  }, signal ? { signal } : undefined);
+    messages: [{ role: 'user' as const, content: prompt }],
+  };
+  const makeRequest = () => opts?.stream
+    ? client.messages.stream(request, signal ? { signal } : undefined).finalMessage()
+    : client.messages.create(request, signal ? { signal } : undefined);
 
   // 429s under CI concurrency: jittered exponential backoff over 3 retries
   // (~1s/4s/16s + jitter), honoring the server's retry-after when present.
@@ -156,14 +160,14 @@ export async function callJudge<T>(
     }
   }
 
-  if (response.stop_reason === 'max_tokens') {
-    throw new Error(`Judge response truncated at max_tokens=${maxTokens} (model=${resolvedModel})`);
-  }
   const text = response.content
     .filter(block => block.type === 'text')
     .map(block => block.text)
     .join('\n');
   try {
+    if (response.stop_reason === 'max_tokens') {
+      throw new Error(`Judge response truncated at max_tokens=${maxTokens} (model=${resolvedModel})`);
+    }
     if (response.stop_reason === 'refusal') throw new JudgeRefusalError(response);
     if (opts?.jsonSchema !== undefined) {
       if (response.stop_reason !== 'end_turn') throw new Error(`Structured judge did not complete: stop_reason=${response.stop_reason}`);

test/helpers/outside-voice-fixture.ts

@@ -13,7 +13,7 @@ export function installOutsideReviewFixture(rendered: string, host: 'claude' | '
   const head = extractSkillSections(source, ['Step 0: Detect platform and base branch', 'Step 3: Get the diff']);
   const sectionPath = join(source, 'sections', 'adversarial.md');
   const section = existsSync(sectionPath) ? readFileSync(sectionPath, 'utf8')
-    : extractSkillSections(source, ['Step 5.7: Adversarial review (always-on)']).replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n/, '');
+    : extractSkillSections(source, ['Step 4.8: Adversarial review (always-on)']).replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n/, '');
   if (!section.includes('Adversarial review (always-on)')) throw new Error(`Missing adversarial workflow: ${source}`);
   // Runtime paths are the only fixture substitution. Provider selection,
   // caller controls, prompt, probes, and execution code stay generated verbatim.

test/helpers/plan-seed-submission.ts

@@ -158,7 +158,12 @@ export async function submitPlanSeed(session: SeedSession, seed: string, opts: {
     const rows = owned.rows.slice(before);
     const users = rows.filter(r => r.type === 'user' && content(r).some(c => c.type === 'text'));
     if (!users.length) return false;
-    if (users.length !== 1 || content(users[0]).length !== 1 || content(users[0])[0].text !== seed) throw new Error('Plan seed was fused, duplicated, or changed');
+    const received = content(users[0]);
+    const text = received[0]?.text;
+    const nativePaste = typeof text === 'string'
+      ? /^\n\n<pasted_content id="([0-9a-f]+)">\n([\s\S]*)<\/pasted_content id="\1">\n$/.exec(text)?.[2]
+      : undefined;
+    if (users.length !== 1 || received.length !== 1 || (text !== seed && nativePaste !== seed)) throw new Error('Plan seed was fused, duplicated, or changed');
     const after = rows.slice(rows.indexOf(users[0]) + 1);
     const pending = new Set<string>();
     let complete = false;

test/helpers/pty-screen.ts

@@ -44,13 +44,16 @@ export interface PtyScreenFrame {
 
 export interface PtyScreen {
   write(text: string): void;
-  read(): Promise<string>;
-  readFrame(): Promise<PtyScreenFrame>;
+  read(deadlineAt?: number): Promise<string>;
+  readFrame(deadlineAt?: number): Promise<PtyScreenFrame>;
   dispose(): Promise<void>;
 }
 
 /** One terminal per session; read only the actual viewport, never scrollback. */
-export async function createPtyScreen(cols: number, rows: number): Promise<PtyScreen> {
+export async function createPtyScreen(cols: number, rows: number,
+  options: { deadlineAt?: number; signal?: AbortSignal } = {}): Promise<PtyScreen> {
+  const deadlineAt = options.deadlineAt ?? performance.now() + 5_000;
+  if (!Number.isFinite(deadlineAt)) throw new RangeError('PTY screen requires a finite absolute deadline.');
   const Terminal = await loadTerminal();
   const terminal = new Terminal({ cols, rows, scrollback: 0, allowProposedApi: true });
   // Match current CLI scalar column widths instead of xterm5's Unicode 6
@@ -70,10 +73,31 @@ export async function createPtyScreen(cols: number, rows: number): Promise<PtySc
   let final: PtyScreenFrame | undefined;
   let closing: Promise<void> | undefined;
   const waiting = new Set<() => void>();
-  const settled = () => { if (pending === 0) { for (const done of waiting) done(); waiting.clear(); } };
-  const drain = async () => {
-    while (pending > 0) await new Promise<void>(resolve => waiting.add(resolve));
-    if (failure) throw new Error('PTY screen parse failed.', { cause: failure });
+  const settled = () => { if (pending === 0 || failure) { for (const done of waiting) done(); waiting.clear(); } };
+  const fail = (error: unknown) => {
+    failure ??= new Error('PTY screen parse failed; viewport is incomplete.', { cause: error });
+    settled();
+  };
+  const drain = async (readDeadline = deadlineAt) => {
+    if (!Number.isFinite(readDeadline)) throw new RangeError('PTY screen requires a finite absolute deadline.');
+    while (pending > 0 && !failure) {
+      if (options.signal?.aborted) { fail(options.signal.reason); break; }
+      const remaining = Math.min(deadlineAt, readDeadline) - performance.now();
+      if (remaining <= 0) { fail(new Error('PTY screen write callback deadline exceeded.')); break; }
+      await new Promise<void>(resolve => {
+        const done = () => {
+          clearTimeout(timer);
+          options.signal?.removeEventListener('abort', abort);
+          waiting.delete(done);
+          resolve();
+        };
+        const abort = () => fail(options.signal?.reason);
+        const timer = setTimeout(() => fail(new Error('PTY screen write callback deadline exceeded.')), remaining);
+        waiting.add(done);
+        options.signal?.addEventListener('abort', abort, { once: true });
+      });
+    }
+    if (failure) throw failure;
   };
   const viewport = () => {
     const buffer = terminal.buffer.active;
@@ -94,9 +118,9 @@ export async function createPtyScreen(cols: number, rows: number): Promise<PtySc
     });
     return {text: lines.join('\n'), inputOffset, styledText};
   };
-  const readFrame = async () => {
+  const readFrame = async (readDeadline?: number) => {
+    await drain(readDeadline);
     if (closing) { await closing; return final!; }
-    await drain();
     return viewport();
   };
   return {
@@ -105,17 +129,22 @@ export async function createPtyScreen(cols: number, rows: number): Promise<PtySc
       if (!text) return;
       pending++;
       inputOffset += text.length;
-      try { terminal.write(text, () => { pending--; settled(); }); }
-      catch (error) { failure = error; pending--; settled(); }
+      let completed = false;
+      const complete = () => { if (!completed) { completed = true; pending--; settled(); } };
+      try { terminal.write(text, complete); }
+      catch (error) { fail(error); complete(); }
     },
-    async read() {
-      return (await readFrame()).text;
+    async read(readDeadline) {
+      return (await readFrame(readDeadline)).text;
     },
     readFrame,
     dispose() {
       return closing ??= (async () => {
         try { await drain(); final = viewport(); }
-        finally { terminal.dispose(); }
+        finally {
+          try { terminal.dispose(); }
+          catch (error) { if (!failure) throw error; }
+        }
       })();
     },
   };

test/helpers/qa-browser-deadline-evidence.ts

@@ -0,0 +1,248 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { isDeepStrictEqual } from 'node:util';
+import { nativeCalls, readQACheckpointFiles } from './qa-checkpoint-evidence';
+
+type Call = { tool: string; input: any; output: string };
+type Options = { directory: string; guard: string; browse: string; started: number; ended: number };
+
+const quote = (value: string) => `'${value.replaceAll("'", `'"'"'`)}'`;
+
+export function qaDeadlineShellPolicy(directory: string, guard: string, browse: string) {
+  const setup = fs.readFileSync(path.join(directory, 'qa/sections/browser-setup.md'), 'utf8');
+  const readiness = setup.match(/```bash\n(_gs_d\(\)[\s\S]*?)\n```/)?.[1];
+  if (!readiness) throw new Error('QA deadline: missing owned readiness block');
+  const allowed = [readiness, 'uname -s', 'date -u +%Y-%m-%dT%H:%M:%SZ',
+    `[ -x ${quote(browse)} ] && echo READY || echo NEEDS_SETUP`,
+    `ls -la ${quote(path.join(directory, 'qa-reports'))}`,
+    `git -C ${quote(directory)} status --short`,
+    `git -C ${quote(directory)} rev-parse HEAD`,
+    `git -C ${quote(directory)} rev-parse --short HEAD`,
+    `git -C ${quote(directory)} log -1 --format=%cI`,
+    `git -C ${quote(directory)} branch --show-current`];
+  const file = path.join(directory, 'qa-reports/deadline.json');
+  return { allowed, file, prompt: `This native fixture accepts a deliberately narrow executable outer form. Run the BROWSER SETUP Aside readiness bash block verbatim, as its own Bash call (no appended commands). The fallback binary is already supplied. Other than that block, these standalone setup/bookkeeping Bash calls are allowed:
+${allowed.slice(1).join('\n')}
+Use Read/Glob for local inspection and Write only inside ${path.join(directory, 'qa-reports')}; the report and screenshots directories already exist. Memory files and learning stores outside that directory are not authorized. Write the initial charters and final report to the same caller-owned file ${path.join(directory, 'qa-reports/qa-only-report.md')}, not a separate charter file.
+Every other Bash call must be exactly one invocation of bun ${quote(guard)}, with literal arguments, no outer assignments, substitutions, globs, pipes, redirects, prefixes, suffixes or shell operators. The exact runtime path ${quote(process.execPath)} may replace bun; no other launcher is accepted.
+Start exactly once with: bun ${quote(guard)} start ${quote(file)} 30
+Then use bun ${quote(guard)} status ${quote(file)} or bun ${quote(guard)} run ${quote(file)} -- COMMAND ARGS. Use the absolute guard path directly, not $G.
+For browser scripts, put all assignments, pipelines and scripts INSIDE the child: bun ${quote(guard)} run ${quote(file)} -- bash -c 'B="${browse}"; "$B" goto URL; "$B" snapshot -i'. Literal argv and single/double quoted literal arguments are accepted; expansions are only allowed inside the single-quoted child script.
+Do not write, reset, replace, chmod or remove deadline.json, invoke the guard recursively, or print QA_DEADLINE receipts yourself. Browser cleanup also goes inside the guard; after expiry only local report bookkeeping is allowed. Fallback screenshots must be saved directly in the owned screenshots directory; retain them and write the report after expiry without new browser calls. This fixture does not accept a separate post-expiry shell copy from Aside's session directory; mark that artifact unavailable rather than launching new browser work.
+An expired refusal is not an executed probe or a pass. Report unfinished coverage honestly; do not try to finish every page after expiry.` };
+}
+
+function literalArgv(command: string): string[] {
+  const words: string[] = [];
+  let rest = command.trim();
+  while (rest) {
+    const word = /^(?:'[^']*'|"[^"$`\\]*"|[a-zA-Z0-9_./:@%+,=!-])+(?=[ \t]|$)/.exec(rest)?.[0];
+    if (!word) throw new Error('QA deadline: unsupported outer shell composition');
+    words.push([...word.matchAll(/'([^']*)'|"([^"$`\\]*)"|([a-zA-Z0-9_./:@%+,=!-]+)/g)].map(part => part[1] ?? part[2] ?? part[3]).join(''));
+    rest = rest.slice(word.length).replace(/^[ \t]+/, '');
+  }
+  return words;
+}
+
+function owned(file: string, root: string) {
+  const resolved = path.resolve(root, file);
+  if (resolved !== root && !resolved.startsWith(root + path.sep)) throw new Error('QA deadline: artifact outside owned directory');
+  let current = resolved;
+  while (true) {
+    try {
+      if (fs.lstatSync(current).isSymbolicLink()) throw new Error('QA deadline: symlinked artifact path');
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
+    }
+    const parent = path.dirname(current);
+    if (current === parent) break;
+    current = parent;
+  }
+  return resolved;
+}
+
+function browserNativeCalls(transcript: unknown[]) {
+  const identities = new Set<string>();
+  for (const event of transcript as any[]) {
+    if (event?.type !== 'assistant' || !Array.isArray(event.message?.content)) continue;
+    for (const block of event.message.content) {
+      if (block?.type === 'tool_use' && ['Write', 'Bash'].includes(block.name)) {
+        identities.add(JSON.stringify([event.parent_tool_use_id ?? null, block.id]));
+      }
+    }
+  }
+  const relevant = (transcript as any[]).map(event => {
+    if (!Array.isArray(event?.message?.content)) return event;
+    return { ...event, message: { ...event.message, content: event.message.content.filter((block: any) => {
+      if (block?.type === 'tool_use') return ['Write', 'Bash'].includes(block.name);
+      return block?.type === 'tool_result' && identities.has(JSON.stringify([event.parent_tool_use_id ?? null, block.tool_use_id]));
+    }) } };
+  });
+  const failures: string[] = [];
+  const calls = nativeCalls(relevant, failures);
+  if (failures.length) throw new Error('QA preparation: ' + failures.join('; '));
+  return calls;
+}
+
+export function assertQaBrowserPreparation(transcript: unknown[], options: Pick<Options, 'directory' | 'guard'>) {
+  const { directory, guard } = options;
+  const reportRoot = path.join(directory, 'qa-reports');
+  const report = owned(path.join(reportRoot, 'qa-only-report.md'), reportRoot);
+  const state = path.join(reportRoot, 'deadline.json');
+  const calls = browserNativeCalls(transcript);
+  const firstGuard = calls.find(call => {
+    if (call.parent !== null || call.name !== 'Bash' || typeof call.input.command !== 'string') return false;
+    let argv: string[];
+    try { argv = literalArgv(call.input.command); } catch { return false; }
+    return ['bun', process.execPath].includes(argv[0]) && argv[1] === guard
+      && ['start', 'run'].includes(argv[2]) && argv[3] === state;
+  });
+  if (!firstGuard) throw new Error('QA preparation: missing native guard boundary');
+  const prepared = calls.some(call => call.parent === null && call.name === 'Write'
+    && typeof call.input.file_path === 'string' && path.resolve(directory, call.input.file_path) === report
+    && typeof call.input.content === 'string' && call.input.content.trim().length > 0
+    && !call.failed && call.end > call.start && call.end < firstGuard.start);
+  if (!prepared) throw new Error('QA preparation: owned nonempty report Write must complete before guard start/baseline');
+}
+
+export function assertQaBrowserCheckpoints(transcript: unknown[], options: Pick<Options, 'directory' | 'guard'>) {
+  const fail = (reason: string): never => { throw new Error('QA checkpoint: ' + reason); };
+  const root = path.join(options.directory, 'qa-reports');
+  const files = readQACheckpointFiles(root);
+  const calls = browserNativeCalls(transcript);
+  const runs = calls.filter(call => {
+    if (call.parent !== null || call.name !== 'Bash' || typeof call.input.command !== 'string') return false;
+    let argv: string[];
+    try { argv = literalArgv(call.input.command); } catch { return false; }
+    return ['bun', process.execPath].includes(argv[0]) && argv[1] === options.guard
+      && argv[2] === 'run' && argv[3] === path.join(root, 'deadline.json');
+  });
+  const notes: Array<{ call: (typeof calls)[number]; value: any }> = [];
+  const written = new Set<string>();
+  for (const call of calls) {
+    if (call.name !== 'Write' || typeof call.input.file_path !== 'string') continue;
+    const target = path.resolve(options.directory, call.input.file_path);
+    const name = path.basename(target);
+    if (!/^exploration-\d{3}\.json$/.test(name)) continue;
+    if (call.parent !== null || path.dirname(target) !== root || call.failed || call.end <= call.start
+      || written.has(name) || typeof call.input.content !== 'string' || files[name] !== call.input.content) fail('unbound or rewritten checkpoint');
+    written.add(name);
+    let value: any;
+    try { value = JSON.parse(call.input.content); } catch { fail('invalid checkpoint JSON'); }
+    if (!value || Array.isArray(value) || !isDeepStrictEqual(Object.keys(value).sort(), ['hypothesis', 'nextCommand', 'observationCommand', 'observed'])
+      || typeof value.hypothesis !== 'string' || !value.hypothesis.trim() || typeof value.nextCommand !== 'string' || !value.nextCommand.trim()) fail('invalid checkpoint fields');
+    const previous = runs.filter(run => run.end < call.start).at(-1);
+    if (!previous || value.observationCommand !== previous.input.command) fail('observation does not name the last completed probe');
+    const lines = previous.output.split('\n');
+    const receipts = lines.flatMap((line, index) => {
+      if (!line.startsWith('QA_DEADLINE ')) return [];
+      try { return [{ index, value: JSON.parse(line.slice('QA_DEADLINE '.length)) }]; } catch { return fail('invalid guard receipt'); }
+    });
+    if (receipts.length !== 2 || receipts[0].value.event !== 'started' || receipts[1].value.event !== 'finished') fail('refused or incomplete probe is not an observation');
+    const text = lines.slice(receipts[0].index + 1, receipts[1].index).join('\n');
+    let observed: unknown = text;
+    try { observed = JSON.parse(text); } catch {}
+    if (!isDeepStrictEqual(value.observed, observed)) fail('observation differs from the verbatim child result');
+    notes.push({ call, value });
+  }
+  if (written.size !== Object.keys(files).length) fail('checkpoint lacks an acknowledged Write');
+  for (const [index, run] of runs.entries()) {
+    if (index === 0) continue;
+    const previous = runs[index - 1];
+    const matches = notes.filter(note => note.call.start > previous.end && note.call.end < run.start
+      && note.value.nextCommand === run.input.command);
+    if (matches.length !== 1) fail('follow-up lacks one acknowledged preceding checkpoint');
+  }
+}
+
+export function assertQaBrowserDeadline(calls: Call[], options: Options & { expectedBudgetMs?: number }) {
+  const fail = (reason: string): never => { throw new Error('QA deadline: ' + reason); };
+  const { directory, guard, browse, started, ended, expectedBudgetMs = 30000 } = options;
+  if (!Number.isSafeInteger(expectedBudgetMs) || expectedBudgetMs <= 0 || expectedBudgetMs > 2_147_483_647) fail('invalid expected deadline budget');
+  const { file, allowed } = qaDeadlineShellPolicy(directory, guard, browse);
+  const reportRoot = path.join(directory, 'qa-reports');
+  owned(file, reportRoot);
+  const stat = fs.lstatSync(file);
+  if (!stat.isFile() || stat.nlink !== 1 || stat.size > 4096 || (process.platform !== 'win32' && (stat.mode & 0o777) !== 0o400)) fail('state is not immutable native state');
+  const state = JSON.parse(fs.readFileSync(file, 'utf8'));
+  const timestamp = (value: unknown) => {
+    if (typeof value !== 'string' || !Number.isFinite(Date.parse(value)) || new Date(value).toISOString() !== value) return fail('invalid receipt time');
+    return Date.parse(value);
+  };
+  if (Object.keys(state).sort().join(',') !== 'budgetMs,deadlineAt,startedAt,version' || state.version !== 1 || state.budgetMs !== expectedBudgetMs
+    || timestamp(state.deadlineAt) !== timestamp(state.startedAt) + expectedBudgetMs
+    || timestamp(state.startedAt) < started || timestamp(state.startedAt) > ended) fail(`state is not this attempt’s expected ${expectedBudgetMs}ms deadline`);
+  let starts = 0, launches = 0, completed = 0, refused = 0, timedOut = 0, browserAttempts = 0, observed = timestamp(state.startedAt);
+  const checkStatus = (receipt: any) => {
+    if (Object.keys(receipt).sort().join(',') !== 'budgetMs,deadlineAt,event,expired,guard,observedAt,remainingMs,startedAt,version') fail('unexpected status receipt schema');
+    for (const key of ['version', 'startedAt', 'deadlineAt', 'budgetMs']) if (receipt[key] !== state[key]) fail('state reset or forged receipt');
+    const time = timestamp(receipt.observedAt);
+    if (time < observed || time > ended) fail('receipt time outside ordered attempt');
+    observed = time;
+    const remaining = Math.max(0, timestamp(state.deadlineAt) - time);
+    if (receipt.remainingMs !== remaining || receipt.expired !== (remaining === 0)) fail('inconsistent remaining budget');
+  };
+  for (const call of calls) {
+    if (call.tool === 'Edit') fail('Edit is forbidden');
+    if (call.tool === 'Write') {
+      if (typeof call.input?.file_path !== 'string') fail('missing artifact path');
+      const target = owned(path.resolve(directory, call.input.file_path), reportRoot);
+      if (target === file || target.startsWith(file + path.sep)) fail('reserved deadline path write');
+      continue;
+    }
+    if (['Read', 'Glob'].includes(call.tool)) continue;
+    if (call.tool !== 'Bash' || typeof call.input?.command !== 'string') fail('unsupported tool');
+    const command = call.input.command.trim();
+    if (allowed.includes(command)) {
+      if ((call.output ?? '').includes('QA_DEADLINE ')) fail('receipt outside trusted guard invocation');
+      continue;
+    }
+    const outer = literalArgv(command);
+    if (!['bun', process.execPath].includes(outer[0])) fail('untrusted runtime or unguarded command');
+    const argv = outer.slice(1);
+    if (argv[0] !== guard || argv[2] !== file) fail('unguarded command or untrusted guard/state path');
+    const receipts = (call.output ?? '').split('\n').filter(line => line.startsWith('QA_DEADLINE ')).map(line => {
+      try { return JSON.parse(line.slice('QA_DEADLINE '.length)); } catch { return fail('malformed receipt'); }
+    });
+    if (receipts.some(receipt => receipt.guard !== 'qa-deadline')) fail('untrusted receipt');
+    if (argv[1] === 'start') {
+      if (++starts !== 1 || argv.length !== 4 || argv[3] !== String(expectedBudgetMs / 1000) || receipts.length !== 1 || receipts[0].event !== 'start') fail('missing or repeated native start');
+      checkStatus(receipts[0]);
+      if (stat.mtimeMs >= observed + 1 || stat.ctimeMs >= observed + 1 || stat.birthtimeMs >= observed + 1) fail('state changed after native start');
+      continue;
+    }
+    if (starts !== 1) fail('guard used before native start');
+    if (argv[1] === 'status') {
+      if (argv.length !== 3 || receipts.length !== 1 || receipts[0].event !== 'status') fail('missing status receipt');
+      checkStatus(receipts[0]);
+      continue;
+    }
+    if (argv[1] !== 'run' || argv[3] !== '--' || argv.length < 5) fail('unsupported guard invocation');
+    if (argv.slice(4).some(arg => arg.includes('deadline.json') || arg.includes('QA_DEADLINE') || arg.includes('gstack-qa-deadline'))) fail('child touches reserved deadline evidence');
+    const browser = argv[4] === browse || argv[4] === 'aside'
+      || (['bash', '/bin/bash'].includes(argv[4]) && argv[5] === '-c' && argv.length === 7
+        && (argv[6].includes(browse) || /\baside\s+(?:repl|exec)\b/.test(argv[6])));
+    if (browser) browserAttempts++;
+    if (receipts.length === 1 && receipts[0].event === 'expired') {
+      checkStatus(receipts[0]);
+      if (!receipts[0].expired) fail('premature refusal');
+      refused++;
+      continue;
+    }
+    if (receipts.length !== 2 || receipts[0].event !== 'started' || receipts[1].event !== 'finished') fail('missing launch/completion receipts');
+    checkStatus(receipts[0]);
+    if (receipts[0].expired) fail('late launch');
+    launches++;
+    const finish = receipts[1], time = timestamp(finish.observedAt);
+    if (Object.keys(finish).sort().join(',') !== 'deadlineAt,event,exitCode,guard,observedAt,timedOut'
+      || finish.deadlineAt !== state.deadlineAt || time < observed || time > ended || !Number.isInteger(finish.exitCode)
+      || typeof finish.timedOut !== 'boolean' || (finish.timedOut && finish.exitCode !== 124)
+      || (finish.timedOut && time < timestamp(state.deadlineAt))
+      || (time >= timestamp(state.deadlineAt) && !finish.timedOut)) fail('inconsistent completion receipt');
+    observed = time;
+    if (finish.timedOut) timedOut++;
+    else if (finish.exitCode === 0) completed++;
+  }
+  if (starts !== 1 || launches + refused === 0 || browserAttempts === 0) fail('missing guarded browser attempt');
+  return { launchedRuns: launches, completedRuns: completed, refusedRuns: refused, timedOutRuns: timedOut };
+}

test/helpers/qa-callers-fixture.ts

@@ -0,0 +1,727 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { createHash } from 'node:crypto';
+import { spawnSync } from 'node:child_process';
+import { isDeepStrictEqual } from 'node:util';
+import { readQaDeadline } from '../../lib/qa-deadline';
+import { readQaCaptureRecord } from '../../lib/qa-evidence';
+import type { SkillTestResult } from './session-runner';
+import { runSkillTest, SESSION_DRAIN_GRACE_MS } from './session-runner';
+import { CAPTURE_MS } from './eval-budgets';
+import { refreshHermeticSkillRuntime } from './hermetic-skill-runtime';
+import { seedHermeticGstackHome } from './hermetic-env';
+import { observeQAWrites, type QAWriteObservation } from './qa-functional-observer';
+import { nativeCalls, readQACheckpointFiles, validateQACheckpoints } from './qa-checkpoint-evidence';
+import { ownedPath } from './qa-functional-fixture';
+import { qaEvidenceCommand, qaNativeCapture, qaProducerReceipt, type QaEvidenceContext } from './qa-evidence-producer';
+import { qaCaptureArtifacts } from './qa-functional-evidence';
+
+export type QaCaller = 'review' | 'ship';
+export const QA_CALLER_ROOT = path.resolve(import.meta.dir, '../..');
+
+export function callerExcerpt(source: string, start: string, end: string): string {
+  const first = source.indexOf(start);
+  const last = source.indexOf(end, first + start.length);
+  if (first < 0 || last < 0 || last <= first || source.indexOf(start, first + start.length) >= 0) {
+    throw new Error(`Missing or ambiguous caller excerpt boundary: ${start} -> ${end}`);
+  }
+  return source.slice(first, last);
+}
+
+export function qaCallerInstructions(caller: QaCaller, root = QA_CALLER_ROOT): string {
+  const read = (file: string) => fs.readFileSync(path.join(root, file), 'utf8');
+  const source = read(`${caller}/SKILL.md`);
+  const excerpt = caller === 'review'
+    ? callerExcerpt(source, '## Step 4: Critical pass (core review)', '## Step 5.8: Persist Eng Review result')
+    : callerExcerpt(source,
+      '> **STOP.** Before auditing plan completion, verification, and scope drift (Step 8),',
+      '> **STOP.** Before addressing Greptile review comments');
+  const review = caller === 'review' ? excerpt : read('ship/sections/review-army.md');
+  if (!review.includes(`### Step ${caller === 'review' ? '4.7' : '9.2.1'}: Exploratory QA (before Fix-First)`) || !review.includes('sections/exploratory.md')) {
+    throw new Error(`Generated /${caller} parent is missing the exploratory QA integration`);
+  }
+  const army = read(`${caller}/sections/review-army.md`);
+  if (!army.toLowerCase().includes('exploratory') || !army.includes('50')) {
+    throw new Error(`Generated /${caller} specialist bypass is missing its exploration handoff`);
+  }
+  for (const id of ['scope', 'exploratory', 'system-functional']) {
+    const body = read(`qa/sections/${id}.md`);
+    if (body.trim().length < 200 || /\{\{[A-Z_]+/.test(body)) {
+      throw new Error(`Incomplete generated QA resource: ${id}`);
+    }
+  }
+  if (caller === 'ship') {
+    const plan = read('ship/sections/plan-completion.md');
+    if (!plan.includes('## Step 8.1: Plan Verification') || plan.includes('### 3. Invoke /qa-only inline')) {
+      throw new Error('Generated plan verification has not been integrated');
+    }
+  }
+  return excerpt;
+}
+
+export interface CallerTool {
+  id: string;
+  parent: string | null;
+  name: string;
+  input: Record<string, unknown>;
+  output: string;
+  failed: boolean;
+  index: number;
+  resultIndex: number;
+  messageId?: string;
+  sessionId?: string;
+  handoffContent?: string;
+}
+
+const UNCHANGED_READ = 'Wasted call — file unchanged since your last Read. Refer to that earlier tool_result instead.';
+
+export function callerTools(transcript: unknown[]): CallerTool[] {
+  const failures: string[] = [];
+  const calls = nativeCalls(transcript, failures);
+  if (failures.length) throw new Error(failures.join('; '));
+  const tools: CallerTool[] = [];
+  for (const call of calls) {
+    const start = transcript[call.start] as any;
+    const event = transcript[call.end] as any;
+    const tool: CallerTool = { id: call.id, parent: call.parent, name: call.name, input: call.input,
+      output: call.output, failed: call.failed, index: call.start, resultIndex: call.end,
+      messageId: start.message.id, sessionId: start.session_id };
+    tools.push(tool);
+    const native = event.tool_use_result;
+    if (!tool.failed && tool.name === 'Read' && typeof tool.input.file_path === 'string'
+      && tool.input.file_path.endsWith('/HANDOFF.md') && Object.keys(tool.input).length === 1
+      && typeof tool.sessionId === 'string' && event.session_id === tool.sessionId
+      && event.message.content.length === 1 && native?.file?.filePath === tool.input.file_path) {
+      if (native.type === 'text' && typeof native.file.content === 'string') {
+        const lines = native.file.content.split('\n');
+        if (native.file.startLine === 1 && native.file.numLines === lines.length && native.file.totalLines === lines.length
+          && tool.output === lines.map((line: string, i: number) => `${i + 1}\t${line}`).join('\n')) {
+          tool.handoffContent = native.file.content;
+        }
+      } else if (native.type === 'file_unchanged' && tool.output === UNCHANGED_READ) {
+        const prior = tools.findLast(read => read.name === 'Read' && read.parent === tool.parent && read.sessionId === tool.sessionId
+          && read.input.file_path === tool.input.file_path
+          && read.resultIndex >= 0 && read.resultIndex < tool.index && (!tool.messageId || read.messageId !== tool.messageId));
+        tool.handoffContent = prior?.handoffContent;
+      }
+    }
+  }
+  return tools;
+}
+
+export interface CallerProbe {
+  id: string;
+  charter: string;
+  input: string;
+  snapshot: string;
+  status: 'pass' | 'fail' | 'blocked' | 'inconclusive';
+  stdout: string;
+  stderr: string;
+  exit: number | null;
+}
+
+export interface CallerReceipt {
+  status: 'pass' | 'fail' | 'blocked' | 'inconclusive';
+  probes: string[];
+  remaining: string[];
+}
+
+const literalCallerArgument = /(?:[^\s'"\\;&|<>`$(){}*?\[\]~#]+|'[^'\r\n]*'|"[^"\\$`\r\n]*")/.source;
+const literalCallerCLI = new RegExp(`^bun (?:scripts/probe\\.ts|cli\\.ts)(?: ${literalCallerArgument})?$`);
+const literalCallerProbe = new RegExp(`^bun scripts/probe\\.ts(?: ${literalCallerArgument})?$`);
+const literalDeadlineCommand = new RegExp(`^bun (${literalCallerArgument}) (start|status|run) (${literalCallerArgument})(?: (.*))?$`);
+const literalCallerListing = new RegExp(`^ls(?: -[la]+)?(?: --)?(?: ${literalCallerArgument})*$`);
+const callerDiffMode = '(--stat|--numstat|--name-only|--name-status)';
+const literalCallerDiff = new RegExp(`^git diff(?: ${callerDiffMode})?(?: (origin/main|"\\$DIFF_BASE"))?(?: ${callerDiffMode})?(?: --(?: ${literalCallerArgument})+)?$`);
+const callerDiffPreface = 'DIFF_BASE=$(git merge-base origin/main HEAD) && ';
+
+function literalCallerDiffAllowed(text: string): boolean {
+  const recomputedBase = text.startsWith(callerDiffPreface);
+  const diff = literalCallerDiff.exec(recomputedBase ? text.slice(callerDiffPreface.length) : text);
+  return !!diff && !(diff[1] && diff[3]) && recomputedBase === (diff[2] === '"$DIFF_BASE"');
+}
+
+function literalCallerListingAllowed(text: string): boolean {
+  if (!literalCallerListing.test(text)) return false;
+  const operands = text.match(new RegExp(literalCallerArgument, 'g'))!.slice(1);
+  if (operands[0]?.match(/^-[la]+$/)) operands.shift();
+  return operands[0] === '--' || operands.every(operand => !operand.replace(/^['"]/, '').startsWith('-'));
+}
+
+export interface CallerDeadlineContext {
+  runtime: string;
+  fixtureRoot: string;
+}
+
+function callerEvidenceContext(context?: CallerDeadlineContext): QaEvidenceContext | undefined {
+  return context ? { cwd: context.fixtureRoot, reportRoot: path.join(context.fixtureRoot, 'reports'), executable: path.join(context.runtime, 'bin/gstack-qa-evidence') } : undefined;
+}
+
+function callerEvidenceCommand(command: string, context?: CallerDeadlineContext) {
+  const parsed = qaEvidenceCommand(command, callerEvidenceContext(context));
+  if (!context || !parsed) return;
+  try {
+    if (!path.isAbsolute(context.fixtureRoot) || path.resolve(context.fixtureRoot) !== context.fixtureRoot
+      || context.runtime !== path.join(path.dirname(context.fixtureRoot), 'host/runtime')
+      || fs.realpathSync(context.runtime) !== context.runtime
+      || fs.realpathSync(path.join(context.runtime, 'bin/gstack-qa-evidence')) !== path.join(fs.realpathSync(QA_CALLER_ROOT), 'bin/gstack-qa-evidence')
+      || !fs.lstatSync(ownedPath(context.fixtureRoot, 'reports')).isDirectory()) return;
+    if (parsed.action !== 'capture') return parsed;
+    if (!literalCallerProbe.test(parsed.nativeCommand!)) return;
+    if (parsed.deadline === path.join(context.fixtureRoot, 'reports/deadline.json') || parsed.timeoutMs === 10000) return parsed;
+  } catch {}
+}
+
+function callerDeadlineCommand(command: string, context?: CallerDeadlineContext) {
+  if (!context) return;
+  const capture = callerEvidenceCommand(command, context);
+  if (capture?.action === 'capture' && capture.deadline) return { action: 'run', stateFile: capture.deadline };
+  const match = literalDeadlineCommand.exec(command.trim());
+  if (!match) return;
+  const literal = (value: string) => /^['"]/.test(value) ? value.slice(1, -1) : value;
+  const helper = path.join(context.runtime, 'bin/gstack-qa-deadline');
+  const stateFile = path.join(context.fixtureRoot, 'reports/deadline.json');
+  if (literal(match[1]) !== helper || literal(match[3]) !== stateFile) return;
+  try {
+    if (!path.isAbsolute(context.runtime) || path.resolve(context.runtime) !== context.runtime
+      || !path.isAbsolute(context.fixtureRoot) || path.resolve(context.fixtureRoot) !== context.fixtureRoot
+      || context.runtime !== path.join(path.dirname(context.fixtureRoot), 'host/runtime')
+      || fs.realpathSync(context.runtime) !== context.runtime
+      || ownedPath(context.fixtureRoot, 'reports/deadline.json') !== stateFile
+      || !fs.lstatSync(path.dirname(stateFile)).isDirectory()
+      || !fs.statSync(helper).isFile()
+      || fs.realpathSync(helper) !== path.join(fs.realpathSync(QA_CALLER_ROOT), 'bin/gstack-qa-deadline')) return;
+  } catch { return; }
+  const action = match[2];
+  const rest = match[4];
+  if (action === 'status' && rest === undefined) return { action, stateFile };
+  if (action === 'run' && rest?.startsWith('-- ') && literalCallerProbe.test(rest.slice(3))) {
+    return { action, stateFile };
+  }
+  if (action !== 'start' || rest === undefined) return;
+  const start = new RegExp(`^(0|[1-9]\\d*)(\\.\\d{1,3})?(?: (${literalCallerArgument}))?$`).exec(rest);
+  if (!start) return;
+  const seconds = Number(start[1] + (start[2] ?? ''));
+  if (!(seconds > 0 && seconds <= 300)) return;
+  const earlier = start[3] === undefined ? undefined : literal(start[3]);
+  if (earlier !== undefined) {
+    const time = Date.parse(earlier);
+    if (!Number.isFinite(time) || ![new Date(time).toISOString(), new Date(time).toISOString().replace('.000Z', 'Z')].includes(earlier)) return;
+  }
+  return { action, stateFile };
+}
+
+export function qaCallerCommandAllowed(command: string, workflowCommands: string[] = [], deadline?: CallerDeadlineContext): boolean {
+  const text = command.trim();
+  if (callerEvidenceCommand(text, deadline)) return true;
+  if (callerDeadlineCommand(text, deadline)) return true;
+  if (/\bgstack-qa-(?:deadline|evidence)\b/.test(text) && !literalCallerCLI.test(text)
+    && !literalCallerDiffAllowed(text) && !literalCallerListingAllowed(text)) return false;
+  if (workflowCommands.includes(text)) return true;
+  if (literalCallerCLI.test(text)) return true;
+  if (literalCallerDiffAllowed(text)) return true;
+  if (literalCallerListingAllowed(text)) return true;
+  let normalizedRecord = text;
+  const substitutedFields: string[] = [];
+  for (const [field, command] of [['timestamp', 'date -u +%Y-%m-%dT%H:%M:%SZ'], ['commit', 'git rev-parse --short HEAD']]) {
+    const fragment = `"${field}":"'"$(${command})"'"`;
+    if (!normalizedRecord.includes(fragment)) continue;
+    if (normalizedRecord.split(fragment).length !== 2) return false;
+    normalizedRecord = normalizedRecord.replace(fragment, `"${field}":"native-${field}"`);
+    substitutedFields.push(field);
+  }
+  const reviewRecord = normalizedRecord.match(/^\/?[\w./-]+\/bin\/gstack-review-log '([^'\r\n]+)'(?: --finish ([a-zA-Z0-9._:-]+))?$/);
+  if (reviewRecord) {
+    try {
+      const record = JSON.parse(reviewRecord[1]);
+      if (substitutedFields.some(field => record[field] !== `native-${field}`)) return false;
+      if (record?.skill === 'review') return !!reviewRecord[2];
+      return record?.skill === 'adversarial-review'
+        && (!!reviewRecord[2] || record.completed === false && record.converged === false);
+    } catch { return false; }
+  }
+  if (/[\n\r;&|<>`$\\(){}]/.test(text)) return false;
+  return /^(?:pwd|ls(?: -la)?|bun --version|date -u \+%Y-%m-%dT%H:%M:%SZ|bun (?:run test|test(?: cli\.test\.ts)?))$/.test(text)
+    || /^git (?:status --(?:short|porcelain)|branch --show-current|rev-parse (?:--short )?HEAD|merge-base origin\/main HEAD|ls-files(?: --others --exclude-standard)?)$/.test(text)
+    || /^\/?[\w./-]+\/bin\/gstack-review-log --start (?:review|adversarial-review)$/.test(text)
+    || /^\/?[\w./-]+\/bin\/gstack-(?:review-read|specialist-stats)$/.test(text);
+}
+
+export function validateCallerEvidence(input: {
+  caller: QaCaller;
+  result: Pick<SkillTestResult, 'transcript' | 'exitReason'>;
+  probes: CallerProbe[];
+  receipt: CallerReceipt;
+  currentSnapshot: string;
+  requiredCharters: string[];
+  mutations: string[];
+  observerComplete: boolean;
+  workflowCommands?: string[];
+  fixtureRoot?: string;
+  runtime?: string;
+  requireGuardedSmoke?: boolean;
+  requireCapturedEvidence?: boolean;
+  reportRoot: string;
+  checkpointFiles: Record<string, string>;
+  reportMarkdown: string;
+}): string[] {
+  const errors: string[] = [];
+  const deadline = input.fixtureRoot && input.runtime ? { fixtureRoot: input.fixtureRoot, runtime: input.runtime } : undefined;
+  const producerContext = callerEvidenceContext(deadline);
+  if (deadline && input.reportRoot !== path.join(deadline.fixtureRoot, 'reports')) errors.push('deadline report root differs from the owned caller report root');
+  if (input.result.exitReason !== 'success') errors.push(`session did not complete: ${input.result.exitReason}`);
+  if (!input.observerComplete) errors.push('observer incomplete');
+  if (input.mutations.length) errors.push(...input.mutations.map(file => `unauthorized mutation: ${file}`));
+  let tools: CallerTool[];
+  try { tools = callerTools(input.result.transcript); } catch (error) {
+    return [...errors, (error as Error).message];
+  }
+  const reads = tools.filter(tool => tool.name === 'Read' && !tool.failed && tool.output.trim());
+  const captureOf = (tool: CallerTool) => qaNativeCapture({ ...tool, start: tool.index, end: tool.resultIndex }, producerContext);
+  const readOf = (suffix: string) => reads.find(tool => String(tool.input.file_path ?? '').endsWith(suffix));
+  for (const resource of ['/qa/sections/exploratory.md', '/qa/sections/system-functional.md']) {
+    if (!readOf(resource)) errors.push(`missing executed resource read: ${resource}`);
+  }
+  const parentRead = readOf(`/caller-${input.caller}.md`);
+  if (!parentRead) errors.push('missing parent entrypoint read');
+  if (input.caller === 'ship' && !readOf('/ship/sections/review-army.md')) errors.push('missing ship Step 9 read');
+  for (const tool of tools) {
+    const file = String(tool.input.file_path ?? '');
+    const guarded = tool.name === 'Bash' ? callerDeadlineCommand(String(tool.input.command), deadline) : undefined;
+    if (input.fixtureRoot && ['Write', 'Edit', 'MultiEdit'].includes(tool.name)) {
+      try {
+        const relative = path.relative(input.fixtureRoot, ownedPath(input.fixtureRoot, file));
+        if (!/^(?:reports|\.qa-state)\//.test(relative)) errors.push('write outside the declared report/fixture interface');
+        if (relative === 'reports/deadline.json' || /^reports\/\.qa-deadline-/.test(relative)) errors.push('actor attempted to replace reserved deadline state');
+        if (input.requireCapturedEvidence && /^reports\/exploration-\d{3}\.json$/.test(relative)) errors.push('actor transcribed or overwrote helper-owned checkpoint');
+      } catch { errors.push('write outside the declared report/fixture interface'); }
+    }
+    if (tool.name === 'Bash' && !qaCallerCommandAllowed(String(tool.input.command), input.workflowCommands, deadline)) {
+      errors.push('command outside declared caller observation interface');
+    }
+    if (tool.name === 'Read' && /\/(?:browse|devex-review)\/SKILL\.md$|\/qa\/sections\/(?:browser-[^/]+|qa-patterns)\.md$/.test(file)) {
+      errors.push(`unexpected browser/DX load: ${file}`);
+    }
+    if (tool.name === 'Skill' && /^(?:gstack-)?(?:qa|qa-only|review|ship)$/.test(String(tool.input.skill))) {
+      errors.push(`recursive full skill: ${tool.input.skill}`);
+    }
+    if (tool.name === 'Read' && /\/(?:qa|qa-only|review|ship)\/SKILL\.md$/.test(file)) {
+      errors.push(`recursive full skill read: ${file}`);
+    }
+    if (tool.name === 'Bash' && guarded?.action !== 'run' && !literalCallerCLI.test(String(tool.input.command).trim()) && !literalCallerDiffAllowed(String(tool.input.command).trim()) && !literalCallerListingAllowed(String(tool.input.command).trim()) && /\bgit\s+(?:(?:-C|-c)\s+\S+\s+)*(?:add|commit|push|stash|reset|checkout|restore|merge|rebase|cherry-pick)(?=\s|[;&|<>]|$)|\bgh\s+pr\s+(?:create|merge)\b/.test(String(tool.input.command))) {
+      errors.push('unauthorized git/publication action');
+    }
+    if (tool.parent && ['Write', 'Edit', 'MultiEdit'].includes(tool.name) && !/\/(?:reports|evidence|state)\//.test(file)) {
+      errors.push('discovery child attempted a product/test edit');
+    }
+  }
+  const seen = new Set<string>();
+  let guardedDiagnostics = 0;
+  const checkpointProbes: Array<{ command: string; observed: CallerProbe; index: number }> = [];
+  for (const probe of input.probes) {
+    const key = JSON.stringify([probe.charter, probe.input, probe.snapshot]);
+    if (seen.has(key) && probe.status === 'pass') errors.push(`duplicate unchanged passing probe: ${probe.id}`);
+    seen.add(key);
+    const tool = tools.find(tool => tool.name === 'Bash'
+      && (/^(?:\s*cd\s+[^\n&;]+\s*&&)?\s*(?:bun|[\w./-]+\/bun)\s+(?:run\s+)?(?:scripts\/probe\.ts|'scripts\/probe\.ts'|"scripts\/probe\.ts")(?:\s|$)/.test(String(tool.input.command))
+        || callerDeadlineCommand(String(tool.input.command), deadline)?.action === 'run'
+        || callerEvidenceCommand(String(tool.input.command), deadline)?.action === 'capture')
+      && (callerEvidenceCommand(String(tool.input.command), deadline)?.action === 'capture'
+        ? isDeepStrictEqual(captureOf(tool)?.captured.observed, probe)
+        : tool.output.split('\n').some(line => {
+          try { return JSON.stringify(JSON.parse(line)) === JSON.stringify(probe); } catch { return false; }
+        })));
+    if (!tool) errors.push(`probe missing native command/result: ${probe.id}`);
+    else {
+      checkpointProbes.push({ command: String(tool.input.command), observed: probe, index: tool.index });
+      if (parentRead && (tool.index <= parentRead.resultIndex || tool.messageId && tool.messageId === parentRead.messageId)) errors.push(`probe preceded parent entrypoint: ${probe.id}`);
+      for (const id of ['exploratory', 'system-functional']) {
+        const resource = readOf(`/qa/sections/${id}.md`);
+        if (resource && (tool.index <= resource.resultIndex || tool.messageId && tool.messageId === resource.messageId)) errors.push(`probe preceded resource read: ${id}`);
+      }
+      if (input.requireGuardedSmoke) {
+        const command = String(tool.input.command);
+        const guarded = callerDeadlineCommand(command, deadline);
+        const captured = captureOf(tool);
+        const requiredPlan = probe.charter === 'plan:nine' && probe.input === '9' && input.requiredCharters.includes('plan:nine')
+          && /^bun scripts\/probe\.ts (?:9|'9'|"9")$/.test(captured?.command.nativeCommand ?? command.trim());
+        if (guarded?.action !== 'run') {
+          if (!requiredPlan) errors.push(`smoke probe missing trusted deadline run: ${probe.id}`);
+        } else {
+          let valid = false;
+          try {
+            const receipts = captured?.captured.receipt.timing ?? tool.output.split('\n').filter(line => line.startsWith('QA_DEADLINE '))
+              .map(line => JSON.parse(line.slice('QA_DEADLINE '.length)));
+            const [started, finished] = receipts;
+            const state = readQaDeadline(guarded.stateFile);
+            const start = Date.parse(started.observedAt), end = Date.parse(finished.observedAt);
+            const limit = Date.parse(state.deadlineAt);
+            valid = receipts.length === 2 && state.budgetMs <= 300_000
+              && Number.isFinite(start) && Number.isFinite(end)
+              && new Date(start).toISOString() === started.observedAt && new Date(end).toISOString() === finished.observedAt
+              && start >= Date.parse(state.startedAt) && start < limit && end >= start && end < limit
+              && Number.isInteger(probe.exit) && probe.exit !== null && probe.exit >= 0 && probe.exit <= 255
+              && tool.failed === (probe.exit !== 0)
+              && isDeepStrictEqual(started, { guard: 'qa-deadline', event: 'started', ...state, observedAt: started.observedAt, remainingMs: limit - start, expired: false })
+              && isDeepStrictEqual(finished, { guard: 'qa-deadline', event: 'finished', observedAt: finished.observedAt, deadlineAt: state.deadlineAt, timedOut: false, exitCode: probe.exit });
+          } catch {}
+          if (valid) guardedDiagnostics++;
+          else errors.push(`smoke probe missing consistent deadline receipts: ${probe.id}`);
+        }
+      }
+    }
+    if (probe.status === 'pass' && probe.exit === null) errors.push(`unfinished probe reported pass: ${probe.id}`);
+  }
+  if (input.requireGuardedSmoke && !guardedDiagnostics) errors.push('no authenticated guarded diagnostic executed');
+  checkpointProbes.sort((a, b) => a.index - b.index);
+  if (input.requireCapturedEvidence && checkpointProbes.some(probe => qaEvidenceCommand(probe.command, producerContext)?.action !== 'capture')) errors.push('diagnostic probe bypassed production capture');
+  const expiredTargets = tools.flatMap(tool => {
+    if (tool.name !== 'Bash' || !tool.failed) return [];
+    const command = String(tool.input.command);
+    const guarded = callerDeadlineCommand(command, deadline);
+    if (guarded?.action !== 'run') return [];
+    try {
+      const completion = qaProducerReceipt({ ...tool, start: tool.index, end: tool.resultIndex }, producerContext, 'incomplete');
+      let diagnostics: any[];
+      if (completion?.command.action === 'capture' && producerContext) {
+        const capture = readQaCaptureRecord(input.reportRoot, completion.command.id!, completion.receipt.sha256);
+        if (capture.receipt.status !== 'incomplete' || capture.receipt.exitCode !== 124 || completion.receipt.exitCode !== 124
+          || capture.receipt.signal !== null || capture.receipt.cwd !== producerContext.cwd || capture.receipt.deadline !== guarded.stateFile
+          || !isDeepStrictEqual(capture.receipt.argv, completion.command.argv) || capture.stdout.length || capture.stderr.length) return [];
+        diagnostics = capture.receipt.timing;
+      } else diagnostics = tool.output.split('\n').filter(line => line.startsWith('QA_DEADLINE ')).map(line => JSON.parse(line.slice('QA_DEADLINE '.length)));
+      if (diagnostics.length !== 1) return [];
+      const receipt = diagnostics[0];
+      const state = readQaDeadline(guarded.stateFile);
+      const observed = Date.parse(receipt.observedAt);
+      if (state.budgetMs > 300_000 || !Number.isFinite(observed) || new Date(observed).toISOString() !== receipt.observedAt
+        || observed < Date.parse(state.startedAt) || observed < Date.parse(state.deadlineAt)
+        || !isDeepStrictEqual(receipt, { guard: 'qa-deadline', event: 'expired', ...state, observedAt: receipt.observedAt, remainingMs: 0, expired: true })
+        || tool.output.split('\n').some(line => { try { JSON.parse(line); return true; } catch { return false; } })) return [];
+      return [{ command, output: tool.output }];
+    } catch { return []; }
+  });
+  errors.push(...validateQACheckpoints({
+    transcript: input.result.transcript, reportRoot: input.reportRoot,
+    producer: producerContext,
+    probes: checkpointProbes, requiredProbes: checkpointProbes.slice(1),
+    additionalTargets: expiredTargets,
+    files: input.checkpointFiles, reportMarkdown: input.reportMarkdown,
+  }));
+  const selected = input.receipt.probes.map(id => input.probes.find(probe => probe.id === id));
+  if (selected.some(probe => !probe)) errors.push('receipt references an unobserved probe');
+  const currentProbes = selected.filter((probe): probe is CallerProbe => !!probe && probe.snapshot === input.currentSnapshot);
+  const boundary = currentProbes.find(probe => probe.charter === 'plan:nine' && probe.input === '9'
+    && probe.exit === 0 && probe.stdout === '18\n' && probe.stderr === '' && probe.status === 'pass');
+  const happyProof = currentProbes.find(probe => probe.charter === 'happy' && probe.status === 'pass') ?? boundary;
+  for (const charter of input.requiredCharters) {
+    const current = currentProbes.filter(probe => probe.charter === charter
+      || charter === 'happy' && probe === boundary
+      || charter === 'adverse' && probe === boundary && (!input.requiredCharters.includes('happy') || probe.id !== happyProof?.id));
+    if (!current.length && !input.receipt.remaining.length) errors.push(`missing current charter: ${charter}`);
+    if (input.receipt.status === 'pass' && !current.some(probe => probe.status === 'pass')) {
+      errors.push(`false green for charter: ${charter}`);
+    }
+  }
+  const handoffs = reads.filter(tool => String(tool.input.file_path ?? '').endsWith('/HANDOFF.md'));
+  for (const tool of tools) {
+    if (tool.name !== 'Bash' || !/gstack-review-log['"]?\s/.test(String(tool.input.command))
+      || !/"completed"\s*:\s*true/.test(String(tool.input.command))) continue;
+    if (handoffs.some(read => (read.resultIndex >= tool.index || tool.messageId && tool.messageId === read.messageId)
+      && !handoffs.some(prior => prior.input.file_path === read.input.file_path && prior.parent === read.parent && prior.sessionId === read.sessionId
+        && (read.output !== UNCHANGED_READ && prior.output === read.output
+          || read.handoffContent !== undefined && prior.handoffContent === read.handoffContent)
+        && prior.resultIndex < tool.index && (!tool.messageId || tool.messageId !== prior.messageId)))) {
+      errors.push('review completion preceded handoff freshness decision');
+    }
+  }
+  if (input.receipt.status === 'pass' && (input.receipt.remaining.length || selected.some(probe => probe?.status !== 'pass'))) {
+    errors.push('blocked, failing or incomplete coverage reported green');
+  }
+  return errors;
+}
+
+export function callerSnapshot(files: Record<string, string>): string {
+  return createHash('sha256').update(JSON.stringify(Object.entries(files).sort(([a], [b]) => a.localeCompare(b)))).digest('hex');
+}
+
+export const QA_CALLER_CASES = [
+  'review-exploratory-small-cli',
+  'ship-exploratory-small-cli',
+  'ship-exploratory-unavailable',
+  'ship-exploratory-plan-checks',
+  'ship-exploratory-late-input',
+] as const;
+
+export type QaCallerCase = typeof QA_CALLER_CASES[number];
+export const QA_CALLER_TEST_MS = CAPTURE_MS + SESSION_DRAIN_GRACE_MS + 10_000;
+const productFiles = ['scale.ts', 'cli.ts', 'cli.test.ts', 'README.md', 'package.json'];
+
+export interface QaCallerFixture {
+  root: string;
+  cwd: string;
+  state: string;
+  runtime: string;
+  config: string;
+  instructions: string;
+  caller: QaCaller;
+  caseId: QaCallerCase;
+  reviewStart?: string;
+  gitEnvironment: Record<'GIT_OBJECT_DIRECTORY' | 'GIT_ALTERNATE_OBJECT_DIRECTORIES', string>;
+  journal: string;
+  mutationEvents: string[];
+  observerErrors: string[];
+  observation?: QAWriteObservation;
+  workflowCommands: string[];
+  lateApplied: boolean;
+  snapshot(): string;
+  probes(): CallerProbe[];
+  observe(): Promise<void>;
+  close(): Promise<void>;
+}
+
+export function createQaCallerFixture(caseId: QaCallerCase, options: { instructions?: string; installRuntime?: boolean } = {}): QaCallerFixture {
+  const caller: QaCaller = caseId.startsWith('review-') ? 'review' : 'ship';
+  const instructions = options.instructions ?? qaCallerInstructions(caller);
+  const root = fs.mkdtempSync(path.join(fs.realpathSync(os.tmpdir()), 'qc-'));
+  const cwd = path.join(root, 'product');
+  const state = path.join(root, 'state');
+  for (const dir of [cwd, state, path.join(cwd, 'scripts'), path.join(cwd, 'reports'), path.join(cwd, '.qa-state')]) fs.mkdirSync(dir);
+  const runtimeParent = path.join(root, 'host');
+  fs.mkdirSync(runtimeParent);
+  const config = options.installRuntime === false ? '' : refreshHermeticSkillRuntime(QA_CALLER_ROOT, runtimeParent);
+  const runtime = path.join(runtimeParent, 'runtime');
+  const journal = path.join(root, 'probes.jsonl');
+  const fixtureInput = path.join(state, 'fixture.json');
+  fs.writeFileSync(journal, '', { mode: 0o600 });
+  seedHermeticGstackHome(state);
+  fs.appendFileSync(path.join(state, 'config.yaml'), 'cross_project_learnings: false\n');
+  fs.writeFileSync(fixtureInput, '{"locale":"C"}\n');
+  const base = 'export function scale(value: string) {\n  const n = Number(value);\n  if (!/^\\d+$/.test(value) || n > 9) throw new Error("integer required: 0..9");\n  return 2 * n;\n}\n';
+  fs.writeFileSync(path.join(cwd, 'scale.ts'), base);
+  fs.writeFileSync(path.join(cwd, 'cli.ts'), 'import { scale } from "./scale";\ntry { console.log(scale(process.argv[2] ?? "")); } catch (error) { console.error((error as Error).message); process.exit(2); }\n');
+  if (caseId === 'ship-exploratory-unavailable') {
+    fs.writeFileSync(path.join(cwd, 'cli.ts'), 'import "./vendor/native-engine.ts";\n' + fs.readFileSync(path.join(cwd, 'cli.ts'), 'utf8'));
+  }
+  fs.writeFileSync(path.join(cwd, 'cli.test.ts'), 'import { test, expect } from "bun:test";\nimport { scale } from "./scale";\ntest("double a positive number", () => expect(scale("3")).toBe(6));\n');
+  fs.writeFileSync(path.join(cwd, 'package.json'), JSON.stringify({ name: 'caller-scale', private: true, scripts: { test: 'bun test cli.test.ts' } }, null, 2) + '\n');
+  fs.writeFileSync(path.join(cwd, 'README.md'), `# Scale CLI\n\nThe CLI doubles an integer from 0 through 9 inclusive. Success exits 0 with the doubled integer and a newline on stdout, and empty stderr. Other inputs exit 2, with empty stdout and exactly \"integer required: 0..9\\n\" on stderr. It has no persistent business state or network effects.\n\nRun \`bun cli.ts <integer>\`. The repository's diagnostic client \`bun scripts/probe.ts <integer>\` launches that same CLI, records its separate streams and exit status, and prints a JSON receipt. The client preserves the command's exit status. Every diagnostic receipt field is synthetic, nonsecret evidence; snapshot identifies the owned source and fixture inputs. Its journal is owned temporary evidence outside the source tree. It is safe to use with arbitrary local input. Native tests: \`bun run test\`. No browser or service is used.\n`);
+  if (caseId === 'ship-exploratory-unavailable') {
+    fs.appendFileSync(path.join(cwd, 'README.md'), '\nThis target additionally requires the generated native-engine module at vendor/native-engine.ts. The module has not been built in this environment; no dependency generation, installation or substitute engine is authorized. Pure scale unit tests do not exercise that CLI prerequisite.\n');
+  }
+  const probeSource = `import * as fs from 'node:fs';
+import { createHash, randomUUID } from 'node:crypto';
+import { spawnSync } from 'node:child_process';
+const files = ${JSON.stringify(productFiles)};
+const snapshot = createHash('sha256').update(JSON.stringify([...files.map(file => [file, fs.readFileSync(file, 'utf8')]), ['fixture.json', fs.readFileSync(${JSON.stringify(fixtureInput)}, 'utf8')]].sort(([a], [b]) => a.localeCompare(b)))).digest('hex');
+const input = process.argv[2] ?? '';
+const n = Number(input), valid = /^\\d+$/.test(input) && n <= 9;
+const fixture = JSON.parse(fs.readFileSync(${JSON.stringify(fixtureInput)}, 'utf8'));
+const result = spawnSync(${JSON.stringify(process.execPath)}, ['cli.ts', input], { cwd: process.cwd(), env: { ...process.env, LC_ALL: fixture.locale }, encoding: 'utf8', timeout: 2000 });
+const stdout = result.stdout ?? '', stderr = result.stderr ?? result.error?.message ?? '';
+const exit = result.status ?? null;
+const expected = valid ? { exit: 0, stdout: String(n * 2) + '\\n', stderr: '' } : { exit: 2, stdout: '', stderr: 'integer required: 0..9\\n' };
+const missingPrerequisite = ${caseId === 'ship-exploratory-unavailable'} && !fs.existsSync('vendor/native-engine.ts');
+const status = result.error || missingPrerequisite && exit !== 0 ? 'blocked' : exit === expected.exit && stdout === expected.stdout && stderr === expected.stderr ? 'pass' : 'fail';
+const charter = input === '9' ? 'plan:nine' : valid && n > 0 ? 'happy' : 'adverse';
+const probe = { id: 'probe-' + randomUUID(), charter, input, snapshot, status, stdout, stderr, exit };
+fs.appendFileSync(${JSON.stringify(journal)}, JSON.stringify(probe) + '\\n');
+console.log(JSON.stringify(probe));
+process.exit(exit ?? 127);
+`;
+  fs.writeFileSync(path.join(cwd, 'scripts/probe.ts'), probeSource);
+  fs.writeFileSync(path.join(cwd, 'HANDOFF.md'), 'No concurrent input update.\n');
+  if (caseId === 'ship-exploratory-plan-checks') {
+    fs.writeFileSync(path.join(cwd, 'PLAN.md'), '# Scale change\n\n## Verification\n\nThe upper boundary is a required release check: run `bun scripts/probe.ts 9`; require exit 0, stdout `18\\n`, and empty stderr. Ordinary positive input is not a substitute for this check.\n');
+  }
+  const run = (...args: string[]) => {
+    const result = spawnSync('git', args, { cwd, encoding: 'utf8', timeout: 5000 });
+    if (result.status !== 0) throw new Error(`Caller fixture git ${args[0]} failed: ${result.stderr || result.error?.message}`);
+    return result.stdout.trim();
+  };
+  try {
+    run('init', '-b', 'main');
+    run('config', 'user.name', 'QA Caller Fixture');
+    run('config', 'user.email', 'qa-caller-fixture@gstack.test');
+    run('config', 'commit.gpgsign', 'false');
+    fs.writeFileSync(path.join(cwd, '.gitignore'), 'reports/\n.gstack/\n.qa-state/\ncaller-*.md\n');
+    run('add', '.');
+    run('commit', '-m', 'Seed caller fixture');
+    run('update-ref', 'refs/remotes/origin/main', 'HEAD');
+    run('checkout', '-b', 'caller-change');
+    fs.writeFileSync(path.join(cwd, 'scale.ts'), caseId === 'review-exploratory-small-cli'
+      ? base.replace('if (!/^', 'if (!n || !/^')
+      : base.replace('return 2 * n;', 'return n + n;'));
+    const numstat = run('diff', '--numstat', 'origin/main').split('\n').filter(Boolean);
+    if (numstat.reduce((sum, line) => sum + line.split('\t').slice(0, 2).reduce((n, value) => n + Number(value), 0), 0) >= 50) {
+      throw new Error('Caller fixture no longer exercises the small-diff bypass');
+    }
+    if (fs.realpathSync(cwd).startsWith(fs.realpathSync(QA_CALLER_ROOT) + path.sep)) throw new Error('Product fixture is inside source checkout');
+    if (run('rev-parse', '--show-toplevel') !== fs.realpathSync(cwd)) throw new Error('Wrong fixture repository root');
+    const instructionFile = path.join(cwd, `caller-${caller}.md`);
+    fs.writeFileSync(instructionFile, instructions.replace(/~\/\.claude\/skills\/gstack\b/g, runtime));
+    const gitEnvironment = {
+      GIT_OBJECT_DIRECTORY: path.join(state, 'git-objects'),
+      GIT_ALTERNATE_OBJECT_DIRECTORIES: '',
+    };
+    fs.cpSync(fs.realpathSync(path.join(cwd, '.git/objects')), gitEnvironment.GIT_OBJECT_DIRECTORY, { recursive: true });
+    let reviewStart: string | undefined;
+    if (caller === 'review') {
+      const start = spawnSync('bash', [path.join(QA_CALLER_ROOT, 'bin/gstack-review-log'), '--start', 'review'], {
+        cwd, env: { ...process.env, ...gitEnvironment, GSTACK_HOME: state, GSTACK_STATE_ROOT: state },
+        encoding: 'utf8', timeout: 5000,
+      });
+      if (start.status !== 0 || !/^[0-9a-f-]{36}$/.test(start.stdout.trim())) {
+        throw new Error(`Caller review start failed: ${start.stderr || start.error?.message}`);
+      }
+      reviewStart = start.stdout.trim();
+    }
+    const mutationEvents: string[] = [], observerErrors: string[] = [];
+    let observer: Awaited<ReturnType<typeof observeQAWrites>> | undefined;
+    const sources = [instructions, ...[
+      `${caller}/sections/review-army.md`, 'ship/sections/plan-completion.md',
+      'qa/sections/scope.md', 'qa/sections/exploratory.md', 'qa/sections/system-functional.md',
+      ...(caller === 'review' ? ['review/sections/adversarial.md'] : []),
+    ].map(file => fs.readFileSync(path.join(QA_CALLER_ROOT, file), 'utf8'))];
+    const workflowCommands = sources.flatMap(source => [...source.matchAll(/```bash\n([\s\S]*?)\n```/g)]
+      .map(match => match[1].replaceAll('~/.claude/skills/gstack', runtime).replaceAll('<base>', 'main').trim()));
+    if (caller === 'review') {
+      const native = fs.readFileSync(path.join(QA_CALLER_ROOT, 'review/sections/adversarial.md'), 'utf8');
+      for (const match of native.matchAll(/`([^`\n]+)`/g)) {
+        const command = match[1].replaceAll('<base>', 'main');
+        if (command.startsWith('DIFF_BASE=$(git merge-base origin/main HEAD) && git diff')) workflowCommands.push(command);
+        if (command.startsWith('git diff "$DIFF_BASE"')) {
+          workflowCommands.push(command, `DIFF_BASE=$(git merge-base origin/main HEAD) && ${command}`);
+        }
+      }
+    }
+    const snapshot = () => callerSnapshot({ ...Object.fromEntries(productFiles.map(file => [file, fs.readFileSync(path.join(cwd, file), 'utf8')])), 'fixture.json': fs.readFileSync(fixtureInput, 'utf8') });
+    const probes = () => fs.readFileSync(journal, 'utf8').split('\n').filter(Boolean).map(line => JSON.parse(line) as CallerProbe);
+    const fixture: QaCallerFixture = {
+      root, cwd, state, runtime, config, caller, caseId, instructions, journal, mutationEvents, observerErrors, workflowCommands, reviewStart, gitEnvironment,
+      lateApplied: false, snapshot, probes,
+      observe: async () => {
+        if (observer || fixture.observation) throw new Error('Caller observation cannot restart mid-capture');
+        observer = await observeQAWrites(cwd, { reportDirectory: 'reports', evidenceProducer: true });
+      },
+      close: async () => {
+        coordinator?.close();
+        if (!observer) return;
+        fixture.observation = observer.stop();
+        observer = undefined;
+        observerErrors.push(...fixture.observation.failures);
+        if (!fixture.observation.complete) observerErrors.push('incomplete caller write observation');
+        for (const file of new Set([...fixture.observation.events.map(event => event.path), ...fixture.observation.changed])) {
+          if (!/^(?:reports|\.qa-state)(?:\/|$)/.test(file)) mutationEvents.push(file);
+        }
+      },
+    };
+    const coordinator = caseId === 'ship-exploratory-late-input' ? fs.watch(journal, () => {
+      if (fixture.lateApplied || probes().length < 2) return;
+      fixture.lateApplied = true;
+      fs.writeFileSync(fixtureInput, '{"locale":"POSIX"}\n');
+      fs.writeFileSync(path.join(cwd, 'reports/HANDOFF.md'), `The fixture coordinator changed the selected native process locale from C to POSIX in ${fixtureInput}.\n`);
+    }) : undefined;
+    coordinator?.on('error', error => observerErrors.push(error.message));
+    return fixture;
+  } catch (error) {
+    fs.rmSync(root, { recursive: true, force: true });
+    throw error;
+  }
+}
+
+export function qaCallerSessionOptions(fixture: QaCallerFixture, runId: string): Parameters<typeof runSkillTest>[0] {
+  return {
+    prompt: `Load gstack's /${fixture.caller} supplied parent phase from caller-${fixture.caller}.md and resume it on the selected working-tree diff against origin/main. This excerpt comes from ${fixture.runtime}/${fixture.caller}/SKILL.md; resolve installed-relative references there, not from the excerpt file or product directory. That path identifies the asset base, not another entrypoint: do not read or invoke the full parent SKILL.md or rerun its preamble. Earlier preamble/branch/base setup is complete; use the existing local origin/main ref without fetch. Earlier-phase asset locators are ${fixture.runtime}/review/checklist.md and ${fixture.runtime}/qa/templates/functional-report-template.md. Read those files directly when referenced; recursive Glob does not follow the installed asset symlinks. Cross-project learnings are configured off in this owned fixture. ${fixture.reviewStart ? `The actual review-start helper already captured REVIEW_START=${fixture.reviewStart} for this unchanged core pass; retain that token. ` : ''} This fixture evaluates only the supplied parent phase, not later publication stages. Read README.md for the project contract and commands. Use diagnostic-client commands such as \`bun scripts/probe.ts <literal>\` for exploratory discoveries and their checkpoint evidence. A required \`bun run test\` is separate suite verification: report it as verification, never as a diagnostic observation or checkpoint anchor/target. Use the production evidence helper to publish each diagnostic checkpoint as \`reports/exploration-NNN.json\`, not inside a nested directory; do not transcribe its observed payload. ${fixture.caseId === 'ship-exploratory-plan-checks' ? 'The previously discovered plan is PLAN.md.' : 'No plan file was found.'} There is no remote service and no release publication is authorized. There is no interactive approver; do not invent answers or permission. Keep normal parent decision gates. Before every completion report or bookkeeping log, read HANDOFF.md and reports/HANDOFF.md if present for any concurrent collaborator update, await the results, and compare evidence with current inputs. A gstack-review-log completed:true record is a completion, not preliminary bookkeeping; a later handoff read cannot validate an earlier completion.\n\nDeadline bookkeeping additionally permits \`bun ${fixture.runtime}/bin/gstack-qa-deadline start ${fixture.cwd}/reports/deadline.json SECONDS [EARLIER_UTC]\`, \`bun ${fixture.runtime}/bin/gstack-qa-deadline status ${fixture.cwd}/reports/deadline.json\`, and \`bun ${fixture.runtime}/bin/gstack-qa-deadline run ${fixture.cwd}/reports/deadline.json -- bun scripts/probe.ts [literal]\`. These are closed literal forms: SECONDS must be positive and at most 300, EARLIER_UTC is the optional caller absolute deadline: use the section clock's Hard deadline UTC, never its Runner entry UTC, reserve-start time or a clock-read time. The child is only the existing diagnostic client with zero or one literal argument. Resolve these exact helper and state paths; do not use variables, another helper, another state file, nested wrappers, scripts, operators or substitutions. Only this helper may create or change reports/deadline.json and its .qa-deadline- temporary files; never use Write/Edit/MultiEdit on those paths. Record the full outer run command in checkpoints and evidence; keep the unchanged child JSON as observed, separate from prefixed guard diagnostics. A completed expired guard-run is not a probe or a pass: retain its unused checkpoint, report not-run coverage and do not restart the deadline. Keep the 12-probe smoke limit. Required suites and explicit plan checks are outside the bounded smoke budget, not permission to reset it.\n\nFunctional evidence uses the same production helper and existing diagnostic client: \`bun ${fixture.runtime}/bin/gstack-qa-evidence capture ${fixture.cwd}/reports NNN --public --deadline ${fixture.cwd}/reports/deadline.json -- bun scripts/probe.ts [literal]\`. These diagnostic receipts are declared public/synthetic, so --public is approved; a fresh three-digit ID is required each time. Explicit plan probes outside the smoke budget may replace --deadline with --timeout-ms 10000; this does not reset or bypass the smoke deadline. Publish causal intent with \`bun ${fixture.runtime}/bin/gstack-qa-evidence checkpoint ${fixture.cwd}/reports NNN CAPTURE_ID 'full prior capture command' 'causal hypothesis' 'full next capture command'\`; quote arguments literally. For complex quoting, Write only capture, observationCommand, hypothesis and nextCommand to reports/intent.json; publish with the same helper: checkpoint REPORT_ROOT NNN intent.json. Materialize is supported when evidence.json is required. Sources stay inside reports. Decide to execute the next probe before publishing its checkpoint, then await successful publication and dispatch that exact probe. If you defer an optional idea or stop exploration, do not publish a checkpoint for it; descri
Line truncated
+    appendSystemPrompt: `Caller execution scheduling (fixture contract):
+This session has at most 25 assistant turns, including required verification and final artifacts. The command boundary applies to each Bash call, not to the number of independent tool calls in an assistant turn.
+After required clock and approval prerequisites settle, issue independent source Reads and read-only discovery together as separate native tool calls once their paths and inputs are known. Wait for their results before decisions that depend on them.
+The completion reserve is for required verification, affected-input revalidation and artifacts, not an earlier deadline. Keep completing required work within the actual remaining deadline; reserve entry alone is not a reason to stop. Use each native probe's snapshot to distinguish current from superseded evidence before deciding which checks still need revalidation.
+Never group diagnostic probes, checkpoint publication with its next probe, or any action with the clock/status/approval result it needs. Shell composition remains forbidden outside the declared forms. Preserve every required Read, probe, verification, freshness check, approval and report field; the turn limit does not authorize skipping work or reporting incomplete work as passed.`,
+    workingDirectory: fixture.cwd,
+    timeout: CAPTURE_MS,
+    completionReserveMs: CAPTURE_MS / 4,
+    maxTurns: 25,
+    allowedTools: ['Read', 'Grep', 'Glob', 'Bash', 'Write', 'Edit', 'Agent', 'Skill', 'AskUserQuestion'],
+    testName: fixture.caseId,
+    runId,
+    publicStreamDiagnostics: true,
+    env: { CLAUDE_CONFIG_DIR: fixture.config, GSTACK_HOME: fixture.state, GSTACK_STATE_ROOT: fixture.state, GSTACK_HEADLESS: '1', GIT_OPTIONAL_LOCKS: '0', ...fixture.gitEnvironment },
+  };
+}
+
+export async function runQaCaller(fixture: QaCallerFixture, runId: string, runner = runSkillTest): Promise<SkillTestResult> {
+  const options = qaCallerSessionOptions(fixture, runId);
+  if (!options.env?.CLAUDE_CONFIG_DIR) throw new Error('Live caller capture requires the hermetic skill runtime');
+  return runner(options);
+}
+
+export function readCallerReceipt(fixture: QaCallerFixture): CallerReceipt {
+  const receipt = JSON.parse(fs.readFileSync(path.join(fixture.cwd, 'reports/receipt.json'), 'utf8'));
+  if (!receipt || !['pass', 'fail', 'blocked', 'inconclusive'].includes(receipt.status)
+    || !Array.isArray(receipt.probes) || !receipt.probes.every((id: unknown) => typeof id === 'string')
+    || !Array.isArray(receipt.remaining) || !receipt.remaining.every((name: unknown) => typeof name === 'string')) {
+    throw new Error('Malformed caller receipt');
+  }
+  return receipt;
+}
+
+export function retainQaCallerEvidence(fixture: QaCallerFixture, dir: string, result: SkillTestResult | undefined): void {
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  if (!fs.lstatSync(dir).isDirectory() || fs.realpathSync(dir) !== path.resolve(dir)) throw new Error('Evidence directory must be a real owned directory');
+  fs.chmodSync(dir, 0o700);
+  const handoffReads = new Set<string>();
+  const publicEvents = result?.transcript.flatMap(event => {
+    if (!['assistant', 'user'].includes(event.type)) return [];
+    const content = (event.message?.content ?? []).filter((block: any) => ['tool_use', 'tool_result'].includes(block.type));
+    for (const block of content) {
+      if (event.type === 'assistant' && block.type === 'tool_use' && block.name === 'Read'
+        && typeof block.input?.file_path === 'string' && block.input.file_path.endsWith('/HANDOFF.md')) {
+        handoffReads.add(JSON.stringify([event.parent_tool_use_id ?? null, block.id]));
+      }
+    }
+    const handoffResult = event.type === 'user' && content.length === 1 && content[0].type === 'tool_result'
+      && (handoffReads.has(JSON.stringify([event.parent_tool_use_id ?? null, content[0].tool_use_id]))
+        || /\/\.qa-evidence\/\d{3}\/observation\.json$/.test(event.tool_use_result?.file?.filePath ?? ''));
+    const metadata = handoffResult ? event.tool_use_result
+      : typeof event.tool_use_result?.interrupted === 'boolean' ? { interrupted: event.tool_use_result.interrupted } : undefined;
+    return content.length ? [{ type: event.type, parent_tool_use_id: event.parent_tool_use_id ?? null,
+      session_id: event.session_id, message: { id: event.message?.id, content },
+      ...(metadata ? { tool_use_result: metadata } : {}) }] : [];
+  }) ?? [];
+  const retain = (file: string, content: string) => {
+    const destination = path.join(dir, file);
+    if (fs.existsSync(destination)) throw new Error('Evidence capture must not overwrite an earlier attempt');
+    fs.writeFileSync(destination, content, { mode: 0o600, flag: 'wx' });
+  };
+  let captures: unknown;
+  let captureFailure: unknown;
+  try { captures = qaCaptureArtifacts(path.join(fixture.cwd, 'reports')); }
+  catch (error) { captureFailure = error; captures = { error: String(error) }; }
+  for (const [file, content] of Object.entries({
+    'native-events.json': JSON.stringify(publicEvents, null, 2),
+    'native-probes.jsonl': fs.readFileSync(fixture.journal, 'utf8'),
+    'captures.json': JSON.stringify(captures, null, 2),
+    'observer.json': JSON.stringify({ observation: fixture.observation, events: fixture.mutationEvents, errors: fixture.observerErrors, lateApplied: fixture.lateApplied, snapshot: fixture.snapshot(), exitReason: result?.exitReason ?? 'capture failed' }, null, 2),
+    'consumed-parent.md': fixture.instructions,
+    'report.md': fs.existsSync(path.join(fixture.cwd, 'reports/review.md')) ? fs.readFileSync(path.join(fixture.cwd, 'reports/review.md'), 'utf8') : 'No report produced.\n',
+    'receipt.json': fs.existsSync(path.join(fixture.cwd, 'reports/receipt.json')) ? fs.readFileSync(path.join(fixture.cwd, 'reports/receipt.json'), 'utf8') : 'null\n',
+  })) {
+    retain(file, content);
+  }
+  try {
+    const deadline = path.join(fixture.cwd, 'reports/deadline.json');
+    if (fs.lstatSync(deadline, { throwIfNoEntry: false })) retain('deadline.json', JSON.stringify(readQaDeadline(deadline)) + '\n');
+  } catch (error) {
+    retain('deadline-capture-error.txt', `Deadline capture failed: ${(error as Error).message}\n`);
+  }
+  let checkpoints: Record<string, string>;
+  try { checkpoints = readQACheckpointFiles(path.join(fixture.cwd, 'reports')); }
+  catch (error) {
+    retain('checkpoint-capture-error.txt', `Checkpoint capture failed: ${(error as Error).message}\n`);
+    return;
+  }
+  for (const [file, content] of Object.entries(checkpoints)) retain(file, content);
+  if (captureFailure) throw captureFailure;
+}

test/helpers/qa-checkpoint-evidence.ts

@@ -0,0 +1,222 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { isDeepStrictEqual } from 'node:util';
+import { qaEvidenceCommand, qaEvidenceHash, qaNativeCapture, qaProducerReceipt, type QaEvidenceContext } from './qa-evidence-producer';
+
+const checkpointName = /^exploration-\d{3}\.json$/;
+const object = (value: unknown): value is Record<string, any> => value !== null && typeof value === 'object' && !Array.isArray(value);
+
+function safeRoot(root: string): void {
+  if (!path.isAbsolute(root) || path.resolve(root) !== root || root === path.parse(root).root
+    || !fs.lstatSync(root).isDirectory() || fs.realpathSync(root) !== root) throw new Error('Unsafe checkpoint report root');
+}
+
+export function readQACheckpointFiles(reportRoot: string): Record<string, string> {
+  safeRoot(reportRoot);
+  const files: Record<string, string> = {};
+  for (const name of fs.readdirSync(reportRoot).filter(name => checkpointName.test(name)).sort()) {
+    const target = path.join(reportRoot, name);
+    const stat = fs.lstatSync(target);
+    if (!stat.isFile() || stat.nlink !== 1) throw new Error(`Unsafe checkpoint file: ${name}`);
+    const fd = fs.openSync(target, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+    try {
+      const opened = fs.fstatSync(fd);
+      if (!opened.isFile() || opened.nlink !== 1 || opened.dev !== stat.dev || opened.ino !== stat.ino) throw new Error(`Changed checkpoint file: ${name}`);
+      files[name] = fs.readFileSync(fd, 'utf8');
+    } finally { fs.closeSync(fd); }
+  }
+  return files;
+}
+
+type Probe = { command: string; observed: unknown };
+type Call = { id: string; parent: string | null; name: string; input: Record<string, any>; start: number; end: number; output: string; failed: boolean; file?: { path: string; content: string } };
+
+export function nativeCalls(transcript: unknown[], failures: string[]): Call[] {
+  const calls = new Map<string, Call>();
+  for (const [index, raw] of transcript.entries()) {
+    if (!object(raw)) { failures.push('Malformed native event'); continue; }
+    if (!['assistant', 'user'].includes(raw.type)) continue;
+    const parent = raw.parent_tool_use_id ?? null;
+    if (parent !== null && typeof parent !== 'string') { failures.push('Malformed native parent scope'); continue; }
+    if (!Array.isArray(raw.message?.content)) {
+      if (raw.message?.content != null && typeof raw.message.content !== 'string') failures.push('Malformed native message content');
+      continue;
+    }
+    for (const block of raw.message.content) {
+      if (!object(block)) { failures.push('Malformed native content block'); continue; }
+      if (raw.type === 'assistant' && block.type === 'tool_use') {
+        const key = JSON.stringify([parent, block.id]);
+        if (typeof block.id !== 'string' || !block.id || calls.has(key) || typeof block.name !== 'string' || !object(block.input)) {
+          failures.push('Missing or duplicate native tool identity');
+          continue;
+        }
+        calls.set(key, { id: block.id, parent, name: block.name, input: block.input, start: index, end: -1, output: '', failed: false });
+      } else if (raw.type === 'user' && block.type === 'tool_result') {
+        const call = calls.get(JSON.stringify([parent, block.tool_use_id]));
+        if (!call || call.end !== -1) { failures.push('Orphaned or duplicate native result'); continue; }
+        call.end = index;
+        call.failed = block.is_error === true || call.name === 'Bash' && raw.tool_use_result?.interrupted === true;
+        if (typeof block.content === 'string') call.output = block.content;
+        else if (Array.isArray(block.content) && block.content.every(part => object(part) && part.type === 'text' && typeof part.text === 'string')) {
+          call.output = block.content.map(part => part.text).join('\n');
+        } else { call.failed = true; failures.push('Unsupported native result content'); }
+        const file = raw.tool_use_result?.type === 'text' ? raw.tool_use_result.file : undefined;
+        if (call.name === 'Read' && !call.failed && object(file) && typeof call.input.file_path === 'string' && file.filePath === call.input.file_path && typeof file.content === 'string'
+          && file.startLine === 1 && file.numLines === file.content.split('\n').length && file.totalLines === file.numLines
+          && call.output === file.content.split('\n').map((line: string, index: number) => `${index + 1}\t${line}`).join('\n')) {
+          call.file = { path: file.filePath, content: file.content };
+        }
+      }
+    }
+  }
+  for (const call of calls.values()) {
+    if (call.end < 0) failures.push('Missing native tool completion');
+  }
+  return [...calls.values()];
+}
+
+function nativeJSON(output: string): unknown[] {
+  try { return [JSON.parse(output)]; } catch {}
+  return output.split('\n').flatMap(line => {
+    try { const value = JSON.parse(line); return object(value) || Array.isArray(value) ? [value] : []; } catch { return []; }
+  });
+}
+
+export function validateQACheckpoints(input: {
+  transcript: unknown[];
+  reportRoot: string;
+  probes: Probe[];
+  requiredProbes: Probe[];
+  additionalTargets?: Array<{ command: string; output: string }>;
+  files: Record<string, string>;
+  reportMarkdown: string;
+  producer?: QaEvidenceContext;
+}): string[] {
+  const failures: string[] = [];
+  let disk: Record<string, string>;
+  try { disk = readQACheckpointFiles(input.reportRoot); }
+  catch { return ['Unsafe or missing checkpoint report root/artifact']; }
+  if (!isDeepStrictEqual(disk, input.files)) failures.push('Checkpoint files differ from actual disk artifacts');
+  const calls = nativeCalls(input.transcript, failures);
+  const bound: Array<{ probe: Probe; call: Call }> = [];
+  for (const probe of input.probes) {
+    const matches = calls.filter(call => {
+      if (call.name !== 'Bash' || call.input.command !== probe.command || call.end <= call.start) return false;
+      const capture = qaNativeCapture(call, input.producer);
+      const produced = qaEvidenceCommand(call.input.command, input.producer) || /^bun \S*\/gstack-qa-evidence(?:\s|['"]\s)/.test(call.input.command)
+        || call.output.split('\n').some(line => line.startsWith('QA_EVIDENCE '));
+      return produced ? !!capture && isDeepStrictEqual(capture.captured.observed, probe.observed) : isDeepStrictEqual(nativeJSON(call.output), [probe.observed]);
+    });
+    if (matches.length !== 1 || bound.some(row => row.call === matches[0])) failures.push(`Unbound or ambiguous native probe: ${probe.command}`);
+    else bound.push({ probe, call: matches[0] });
+  }
+  bound.sort((a, b) => a.call.start - b.call.start);
+  const notes: Array<{ name: string; call: Call; value: Record<string, any>; intent?: Call }> = [];
+  const written = new Set<string>();
+  for (const call of calls) {
+    const producerCommand = call.name === 'Bash' ? qaEvidenceCommand(call.input.command, input.producer) : undefined;
+    let attempted = call.input.file_path;
+    let content = call.input.content;
+    let intent: Call | undefined;
+    if (producerCommand?.action === 'checkpoint') {
+      const producer = qaProducerReceipt(call, input.producer);
+      const name = `exploration-${producerCommand.id}.json`;
+      const writes = producerCommand.intent ? [call] : calls.filter(write => write.name === 'Write' && !write.failed && write.parent === call.parent
+        && write.end > write.start && write.end < call.start && write.input.file_path === producerCommand.source
+        && typeof write.input.content === 'string' && qaEvidenceHash(write.input.content) === producer?.receipt.intentSha256);
+      if (!producer || writes.length !== 1 || typeof disk[name] !== 'string' || qaEvidenceHash(disk[name]) !== producer.receipt.sha256) {
+        failures.push(`Checkpoint lacks completed native producer and intent: ${name}`);
+        continue;
+      }
+      intent = writes[0];
+      let decision: any;
+      let published: any;
+      const intentText = producerCommand.intent ? JSON.stringify(producerCommand.intent) : intent.input.content;
+      try { decision = JSON.parse(intentText); } catch {}
+      try { published = JSON.parse(disk[name]); } catch {}
+      const captures = bound.filter(row => row.call.parent === call.parent && row.call.end < intent!.start
+        && row.probe.command === decision?.observationCommand).map(row => ({ row, producer: qaNativeCapture(row.call, input.producer) }))
+        .filter(row => row.producer?.command.id === producer.receipt.capture && row.producer.receipt.sha256 === producer.receipt.captureSha256);
+      const capture = captures.length === 1 ? captures[0] : undefined;
+      const read = capture && (capture.producer!.command.publicOutput || calls.some(read => read.name === 'Read' && !read.failed && read.parent === call.parent
+        && read.start > capture.row.call.end && read.end > read.start && read.end < intent!.start
+        && read.file?.path === path.join(input.reportRoot, `.qa-evidence/${producer.receipt.capture}/observation.json`)
+        && read.file.content === capture.producer!.captured.observationText));
+      if (!capture || !read || !object(decision) || decision.capture !== producer.receipt.capture
+        || qaEvidenceHash(intentText) !== producer.receipt.intentSha256
+        || !isDeepStrictEqual(Object.keys(decision).sort(), ['capture', 'hypothesis', 'nextCommand', 'observationCommand'])
+        || !isDeepStrictEqual(published, { observationCommand: decision.observationCommand, observed: capture.row.probe.observed, hypothesis: decision.hypothesis, nextCommand: decision.nextCommand })
+        || producerCommand.source && calls.some(change => ['Write', 'Edit'].includes(change.name) && change.input.file_path === producerCommand.source
+          && change.start > intent!.end && change.start < call.end)) {
+        failures.push(`Checkpoint intent lacks its completed observation read: ${name}`);
+        continue;
+      }
+      attempted = path.join(input.reportRoot, name);
+      content = disk[name];
+    }
+    if (call.name === 'Bash' && producerCommand?.action !== 'checkpoint' && typeof call.input.command === 'string' && /exploration-\d+\.json/.test(call.input.command)) {
+      failures.push('Unsupported checkpoint Bash interaction');
+    }
+    if (typeof attempted !== 'string' || !path.basename(attempted).startsWith('exploration-')) continue;
+    if (call.name === 'Read') continue;
+    const name = path.basename(attempted);
+    if ((call.name !== 'Write' && !intent) || !checkpointName.test(name) || attempted !== path.join(input.reportRoot, name)) {
+      failures.push(`Unsupported checkpoint write/path: ${attempted}`);
+      continue;
+    }
+    if (written.has(name)) failures.push(`Reused or overwritten checkpoint: ${name}`);
+    written.add(name);
+    if (call.failed || call.end <= call.start) { failures.push(`Checkpoint Write did not complete successfully: ${name}`); continue; }
+    if (typeof content !== 'string' || !Object.hasOwn(disk, name) || disk[name] !== content) {
+      failures.push(`Checkpoint artifact differs from captured Write: ${name}`);
+      continue;
+    }
+    const destinations = [...input.reportMarkdown.matchAll(/\[[^\]\n]*\]\(([^\s)]+)(?:\s+"[^"]*")?\)/g)].map(match => match[1]);
+    if (!destinations.some(destination => destination === name || destination === `./${name}` || destination === path.join(input.reportRoot, name))) {
+      failures.push(`Report does not link checkpoint: ${name}`);
+    }
+    let value: unknown;
+    try { value = JSON.parse(content); } catch {}
+    if (!object(value) || !isDeepStrictEqual(Object.keys(value).sort(), ['hypothesis', 'nextCommand', 'observationCommand', 'observed'])
+      || typeof value.hypothesis !== 'string' || value.hypothesis.trim().length <= 20
+      || !/[a-z]{3}/i.test(value.hypothesis) || typeof value.observationCommand !== 'string' || typeof value.nextCommand !== 'string') {
+      failures.push(`Invalid checkpoint schema: ${name}`);
+      continue;
+    }
+    notes.push({ name, call, value, ...(intent ? { intent } : {}) });
+  }
+  for (const name of Object.keys(disk)) if (!written.has(name)) failures.push(`Checkpoint has no public Write: ${name}`);
+  const additional: Array<{ command: string; call: Call }> = [];
+  for (const target of input.additionalTargets ?? []) {
+    if (!notes.some(note => note.value.nextCommand === target.command)) continue;
+    const matches = calls.filter(call => call.name === 'Bash' && call.input.command === target.command
+      && call.end > call.start && call.output === target.output);
+    if (matches.length !== 1 || bound.some(row => row.call === matches[0]) || additional.some(row => row.call === matches[0])) {
+      failures.push(`Unbound or ambiguous additional checkpoint target: ${target.command}`);
+    } else additional.push({ command: target.command, call: matches[0] });
+  }
+  const owners = new Map<Call, typeof notes>();
+  for (const target of [...bound.map(row => ({ command: row.probe.command, call: row.call })), ...additional]) {
+    const previous = bound.filter(row => row.call.parent === target.call.parent && row.call.start < target.call.start).at(-1);
+    owners.set(target.call, notes.filter(note => previous && note.call.parent === target.call.parent
+      && note.call.start > previous.call.end && note.call.end < target.call.start
+      && (!note.intent || note.intent.start > previous.call.end)
+      && note.value.observationCommand === previous.probe.command && isDeepStrictEqual(note.value.observed, previous.probe.observed)
+      && note.value.nextCommand === target.command
+      && !calls.some(call => call.name === 'Bash' && call.parent === target.call.parent && call.input.command === target.command
+        && call.start >= note.call.start && call.start < target.call.start)));
+  }
+  const targets = new Set<Call>();
+  for (const required of input.requiredProbes) {
+    const matches = bound.filter(row => row.probe.command === required.command && isDeepStrictEqual(row.probe.observed, required.observed));
+    if (matches.length !== 1 || targets.has(matches[0].call)) { failures.push(`Unbound or reused checkpoint target: ${required.command}`); continue; }
+    const target = matches[0];
+    targets.add(target.call);
+    if (owners.get(target.call)?.length !== 1) failures.push(`Missing unique completed checkpoint before probe: ${required.command}`);
+  }
+  for (const note of notes) {
+    const matches = [...owners.values()].filter(candidates => candidates.includes(note));
+    if (matches.length !== 1 || matches[0].length !== 1) failures.push(`Unrelated, reused or retrospective checkpoint: ${note.name}`);
+  }
+  return failures.map(failure => `QA checkpoint: ${failure}`);
+}

test/helpers/qa-evidence-producer.ts

@@ -0,0 +1,104 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { createHash } from 'node:crypto';
+import { isDeepStrictEqual } from 'node:util';
+import { readQaCapture } from '../../lib/qa-evidence';
+
+export const QA_EVIDENCE_RUNTIME = [
+  'bin/gstack-qa-evidence', 'bin/gstack-qa-deadline', 'lib/qa-evidence.ts', 'lib/qa-deadline.ts',
+  'lib/claude-code-windows-job.ts', 'lib/fs-atomic.ts', 'lib/redact-engine.ts', 'lib/redact-patterns.ts',
+];
+
+export function qaEvidenceRuntimeFiles(): Record<string, string> {
+  return Object.fromEntries(QA_EVIDENCE_RUNTIME.map(file => [file, fs.readFileSync(path.resolve(import.meta.dir, '../..', file), 'utf8')]));
+}
+
+export interface QaEvidenceContext {
+  cwd: string;
+  reportRoot: string;
+  executable: string;
+}
+
+export interface QaEvidenceCommand {
+  action: 'capture' | 'checkpoint' | 'materialize';
+  id?: string;
+  source?: string;
+  nativeCommand?: string;
+  argv?: string[];
+  deadline?: string;
+  timeoutMs?: number;
+  publicOutput?: boolean;
+  intent?: { capture: string; observationCommand: string; hypothesis: string; nextCommand: string };
+}
+
+export function qaEvidenceCommand(command: string, context?: QaEvidenceContext): QaEvidenceCommand | undefined {
+  if (!context || typeof command !== 'string' || /[\r\n]/.test(command)) return;
+  const matches = [...command.matchAll(/'[^'\r\n]*'|"[^"\\$`\r\n]*"|[^\s'"\\;&|<>`$(){}*?\[\]~#]+/g)];
+  if (!matches.length || command.slice(0, matches[0].index).trim() || command.slice(matches.at(-1)!.index! + matches.at(-1)![0].length).trim()) return;
+  for (let index = 1; index < matches.length; index++) {
+    if (!/^ +$/.test(command.slice(matches[index - 1].index! + matches[index - 1][0].length, matches[index].index))) return;
+  }
+  const tokens = matches.map(match => /^['"]/.test(match[0]) ? match[0].slice(1, -1) : match[0]);
+  if ([tokens[1], tokens[3]].some(value => value?.split(/[\\/]/).includes('..'))) return;
+  if (tokens[0] !== 'bun' || path.resolve(context.cwd, tokens[1] ?? '') !== context.executable
+    || path.resolve(context.cwd, tokens[3] ?? '') !== context.reportRoot) return;
+  const source = (value: string | undefined) => value && !value.split(/[\\/]/).includes('..')
+    && path.resolve(context.reportRoot, value).startsWith(context.reportRoot + path.sep) ? path.resolve(context.reportRoot, value) : undefined;
+  if (tokens[2] === 'materialize' && tokens.length === 5 && source(tokens[4])) return { action: 'materialize', source: source(tokens[4]) };
+  if (!/^\d{3}$/.test(tokens[4] ?? '')) return;
+  if (tokens[2] === 'checkpoint' && tokens.length === 6 && source(tokens[5])) return { action: 'checkpoint', id: tokens[4], source: source(tokens[5]) };
+  if (tokens[2] === 'checkpoint' && tokens.length === 9 && /^\d{3}$/.test(tokens[5])) return { action: 'checkpoint', id: tokens[4],
+    intent: { capture: tokens[5], observationCommand: tokens[6], hypothesis: tokens[7], nextCommand: tokens[8] } };
+  const publicOutput = tokens[5] === '--public';
+  const option = publicOutput ? 6 : 5;
+  if (tokens[2] !== 'capture' || tokens[option + 2] !== '--' || tokens.length < option + 4) return;
+  const deadline = tokens[option] === '--deadline' ? source(path.resolve(context.cwd, tokens[option + 1])) : undefined;
+  if (tokens[option] === '--deadline' && !deadline) return;
+  if (tokens[option] === '--timeout-ms' && (!/^[1-9]\d*$/.test(tokens[option + 1]) || Number(tokens[option + 1]) > 2_147_483_647)) return;
+  if (!['--deadline', '--timeout-ms'].includes(tokens[option])) return;
+  return { action: 'capture', id: tokens[4], publicOutput, argv: tokens.slice(option + 3), nativeCommand: command.slice(matches[option + 3].index).trim(),
+    ...(tokens[option] === '--deadline' ? { deadline } : { timeoutMs: Number(tokens[option + 1]) }) };
+}
+
+export type QaProducerCall = { name: string; input: Record<string, any>; output: string; failed: boolean; start: number; end: number };
+
+export function qaProducerReceipt(call: QaProducerCall, context?: QaEvidenceContext, status: 'complete' | 'incomplete' = 'complete') {
+  if (call.name !== 'Bash' || call.end <= call.start) return;
+  const command = qaEvidenceCommand(call.input.command, context);
+  if (!command) return;
+  try {
+    const lines = call.output.split('\n').filter(line => line.startsWith('QA_EVIDENCE '));
+    if (lines.length !== 1) return;
+    const receipt = JSON.parse(lines[0].slice('QA_EVIDENCE '.length));
+    const exitCode = call.failed ? Number(/^Exit code (\d+)\n/.exec(call.output)?.[1]) : 0;
+    if (receipt.producer !== 'gstack-qa-evidence' || receipt.version !== 1 || receipt.action !== command.action
+      || receipt.status !== status || !/^[a-f0-9]{64}$/.test(receipt.sha256)
+      || receipt.exitCode !== exitCode
+      || (command.id !== undefined && receipt.id !== command.id)
+      || (call.failed && (command.action !== 'capture' || receipt.exitCode === 0))) return;
+    return { command, receipt };
+  } catch { return; }
+}
+
+export function qaNativeCapture(call: QaProducerCall, context?: QaEvidenceContext) {
+  const producer = qaProducerReceipt(call, context);
+  if (!context || producer?.command.action !== 'capture') return;
+  try {
+    const captured = readQaCapture(context.reportRoot, producer.command.id!, producer.receipt.sha256);
+    if (captured.receipt.cwd !== context.cwd || !isDeepStrictEqual(captured.receipt.argv, producer.command.argv)
+      || captured.receipt.exitCode !== producer.receipt.exitCode || captured.receipt.signal !== producer.receipt.signal
+      || captured.receipt.publicOutput !== producer.command.publicOutput || captured.receipt.publicOutput !== producer.receipt.publicOutput
+      || (producer.command.deadline !== undefined && captured.receipt.deadline !== producer.command.deadline)) return;
+    if (producer.command.publicOutput && call.output.split('\n').filter(line => line === JSON.stringify(captured.observed)).length !== 1) return;
+    if (producer.command.timeoutMs !== undefined) {
+      const deadline = JSON.parse(fs.readFileSync(path.join(context.reportRoot, `.qa-evidence/${producer.command.id}/deadline.json`), 'utf8'));
+      if (captured.receipt.deadline !== path.join(context.reportRoot, `.qa-evidence/${producer.command.id}/deadline.json`)
+        || deadline.budgetMs !== producer.command.timeoutMs) return;
+    }
+    return { ...producer, captured };
+  } catch { return; }
+}
+
+export function qaEvidenceHash(bytes: string): string {
+  return createHash('sha256').update(bytes).digest('hex');
+}

test/helpers/qa-functional-eval.ts

@@ -0,0 +1,174 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { createHash, randomUUID } from 'node:crypto';
+import { CAPTURE_MS } from './eval-budgets';
+import { runSkillTest, SESSION_DRAIN_GRACE_MS, type SkillTestResult } from './session-runner';
+import { ROOT, runId, copyDirSync, logCost } from './e2e-helpers';
+import { getProjectEvalDir, type EvalCollector } from './eval-store';
+import { extractSkillBody } from './skill-fixture';
+import { runRecordedOfficeHoursAttempt, OFFICE_HOURS_BUN_GRACE_MS } from './office-hours-attempt';
+import { resolveEvalModel } from '../../lib/eval-model';
+import { createQAFunctionalFixture, fixtureGit, ownedPath, qaFixtureActor, QA_TOOLS, type QAFamily, type QAMode } from './qa-functional-fixture';
+import { observeQAWrites, type QAWriteObservation } from './qa-functional-observer';
+import { qaFunctionalVerdict, verifyQANativeRegression, preserveQAArtifact, qaCaptureArtifacts } from './qa-functional-evidence';
+import { QA_EVIDENCE_RUNTIME, qaEvidenceCommand, qaProducerReceipt, qaEvidenceHash } from './qa-evidence-producer';
+import { nativeCalls } from './qa-checkpoint-evidence';
+
+export const QA_FUNCTIONAL_CASES = [
+  { id: 'qa-functional-cli-report', family: 'cli', mode: 'qa-only' },
+  { id: 'qa-functional-webhook-report', family: 'webhook', mode: 'qa-only' },
+  { id: 'qa-functional-cli-fix', family: 'cli', mode: 'qa' },
+  { id: 'qa-functional-webhook-fix', family: 'webhook', mode: 'qa' },
+] as const;
+
+export const QA_FUNCTIONAL_INPUTS = [
+  ...QA_EVIDENCE_RUNTIME, 'test/helpers/qa-evidence-producer.ts', 'test/qa-evidence.test.ts', 'test/qa-evidence-producer.test.ts',
+  'qa/SKILL.md.tmpl', 'qa-only/SKILL.md.tmpl',
+  'qa/sections/', 'qa-only/sections/', 'qa/templates/',
+  'scripts/resolvers/qa.ts', 'scripts/resolvers/utility.ts', 'scripts/resolvers/sections.ts',
+  'scripts/gen-skill-docs.ts', 'test/helpers/qa-functional-fixture.ts',
+  'test/helpers/qa-functional-observer.ts', 'test/helpers/qa-functional-evidence.ts',
+  'test/helpers/qa-checkpoint-evidence.ts',
+  'test/helpers/qa-functional-eval.ts', 'test/helpers/session-runner.ts',
+  'test/helpers/hermetic-env.ts', 'test/helpers/skill-fixture.ts',
+];
+
+export function qaFunctionalPrompt(entry: { family: QAFamily; mode: QAMode }): string {
+  return `Read ${entry.mode}/SKILL.md, qa/sections/scope.md, ${entry.mode}/sections/exploratory.md and qa/sections/system-functional.md in full to load gstack's /${entry.mode} functional workflow for this repository with ${entry.mode === 'qa' ? 'Full exploration and the Standard fix tier' : 'Full report-only exploration'}. All four reads are required before probing in this fixture, even when its surfaces and isolation are already established. This is a CLI/webhook product, not a browser or DX request. The generated local skill copies are the current evaluation inputs; all their installed-root references resolve inside this fixture. The common preamble alone was removed using the repository extractor.
+
+The fixture README and AGENTS define intended contracts, native tests and owned state. Investigate behavior without assuming implementation correctness. Establish a happy path${entry.family === 'cli' ? ' with a successful apply; balance alone is not enough' : ''}. Choose adverse probes from observations, reproduce discoveries, and obey the skill's mutation authority. Use the production capture/checkpoint helper for every native probe and checkpoint: you supply causal intent; it preserves complete unchanged native JSON in observed. Tests, source edits and clock reads do not replace that observation; put red/green test output in the report, not in observed. Retain each note under qa-reports, wait for successful checkpoint publication before the next probe, and link the notes in the final report; write no checkpoint when there is no next probe. No defect is disclosed here. On discovering a defect, replay the exact native child command from the same initial fixture state before repair, with a fresh capture ID, then minimize it; a different input or a regression test is not that replay. Test documented cancellation and unavailable dependency paths too.
+
+${qaFixtureActor(entry.mode)}${entry.mode === 'qa' ? `
+
+This is a fix run, not an optional report-only handoff: a reproduced in-tier defect requires the authorized native regression, repair and verification. Complete these stages in order:
+1. Prove the regression red with a new native test under test/; existing tests remain read-only. Freeze all test files after red, repair only src/${entry.family === 'cli' ? 'cli' : 'worker'}.ts, and prove the unchanged regression green.
+2. On the repaired source, run the original failing probe, an adjacent happy-path probe, cancellation and the unavailable-dependency probe.${entry.family === 'webhook' ? ' Complete required webhook coverage: `happy`, `reject`, `duplicate`, `partial`, `concurrent-ab`, `concurrent-ba`, `cancel`, `dependency`. Run every still-unobserved scenario and recheck earlier scenarios affected by the repair. None of these scenarios is optional exploration. All eight scenarios are required coverage; a replay does not replace another scenario.' : ''} Preserve their actual JSON and checkpoints. A green test suite does not substitute for these native probes. Expected dependency blockage stays blocked, never pass.
+3. Save the evidence and Markdown artifacts, then return their paths and the actual completion status.
+
+The completion reserve is for both required verification and artifacts, not a signal to stop stage 2: the completion reserve does not end required coverage. Stop only exploration beyond the required contracts to protect that work. If required verification remains unfinished at the hard deadline, report incomplete; do not call it complete with a caveat.` : ''}
+
+Use one causal sentence per checkpoint hypothesis (English, more than 20 characters) and compact JSON formatting, preserving every field and value. Keep the Markdown report compact (aim under 400 words, excluding actual test output): retain its headings and required fields, but link to evidence.json and checkpoints for details already recorded there. Include the diagnosis, ${entry.mode === 'qa' ? 'red/green test results' : 'proposed test stubs'} and coverage limits; do not repeat the evidence table or add a second PR summary. After saving both artifacts, return only their paths and the actual completion status, not another copy of the report. Never shorten native JSON or omit a required probe, check or field to meet this presentation target.
+
+Fixture execution boundary:
+- No prior plans, global learnings, remote or cross-session artifact store. Branch/base are main, with a clean successful seed commit. Do not run global setup, telemetry, plan discovery, base-detection scripts or learning writes.
+- Reports belong only in existing qa-reports. Retain fixture state; the owner cleans it after preserving evidence. Authorized source/test edits use Write/Edit. Read/Glob/Grep support arbitrary read-only discovery, including directory/path inventory.
+- Bash accepts separate literal commands only: no shell composition, scripts or added path operands. Read-only forms are pwd, ls, ls -la, git status --short, git status --porcelain, git branch --show-current, git diff, git diff --stat, git rev-parse HEAD, bun --version, and exactly date -u +%Y-%m-%dT%H:%M:%SZ. Native tests use bun test with optional named test/*.test.ts selectors.
+- These are complete command forms, not general shell examples. For inventory inside a named directory, use Read/Glob/Grep; the listed ls forms inspect only the working directory. Do not add operands or flags beyond the declared forms, even for read-only discovery.
+- The installed production helper is bin/gstack-qa-evidence (absolute owned path also accepted). Probe outputs are declared public/synthetic, so capture with: bun bin/gstack-qa-evidence capture qa-reports NNN --public --timeout-ms 10000 -- NATIVE_PROBE. The child must be one of the observation forms below. Each execution/replay gets a fresh three-digit ID. The helper does not authorize another command, interpreter, path, pipeline or redirect.
+- Publish causal intent from the most recent completed native probe with bun bin/gstack-qa-evidence checkpoint qa-reports NNN CAPTURE_ID 'full prior capture command' 'causal hypothesis' 'full next capture command'; quote each argument literally. For complex quoting, Write only capture, observationCommand, hypothesis and nextCommand to qa-reports/intent.json, then use bun bin/gstack-qa-evidence checkpoint qa-reports NNN intent.json. Wait for successful publication before dispatching the exact next command. Only the helper writes observed fields.
+- Write annotations.json inside qa-reports, then run bun bin/gstack-qa-evidence materialize qa-reports annotations.json to produce evidence.json before writing Markdown. Annotations have revision, runtime, cwd, evidence rows {capture,command,contract,expected,classification}, learning (selected checkpoint IDs) and limits; omit observed, which the helper supplies from captures. In each evidence row, capture is the three-digit capture ID and command is the exact full outer capture invocation, including that ID and all wrapper options, not just the native child command after --. This same full-command definition applies to observationCommand and nextCommand. Select a checkpoint whose next native command differs, not a same-command replay with a new capture ID. Retain all required safe observations and every executed probe.
+- ${entry.family === 'cli' ? 'CLI observation forms: bun run probe -- balance; bun run probe -- export; bun run probe -- apply with zero to three literal arguments; bun cancel.ts. The equivalent bun run cli commands may be diagnostic but do not emit probe JSON. Arguments use ASCII letters/digits/._+- or quoted forms including spaces. The generic wrapper does NOT support wait: the only bounded wait/cancellation interface is bun cancel.ts.' : `Webhook observation form: bun run probe -- followed by one of happy, reject, duplicate, partial, concurrent-ab, concurrent-ba, cancel, dependency. ${entry.mode === 'qa-only' ? 'All eight scenarios are required coverage; a replay does not replace another scenario. ' : ''}Choose their order from observations after the happy path. bun cancel.ts is a CLI-only entrypoint, not part of this fixture.`}
+Actions outside this interface are unsupported and fail acceptance; they are not implicitly approved.
+
+Materialize qa-reports/evidence.json first, then write a concise qa-reports/report.md using the functional report structure. Link the evidence and checkpoint files rather than repeating full probe payloads in Markdown. Both artifacts are required before completion. The resulting evidence.json schema is:
+{ "revision": "<git HEAD>", "runtime": "bun <version>", "cwd": "<working directory>", "evidence": [{"command":"<exact full outer capture invocation>","contract":"README.md","expected":"<declared expected behavior>","classification":"pass|product-defect|setup-blocked|inconclusive","observed":<complete unchanged JSON emitted by the native probe>}], "learning":[{"observationCommand":"<earlier full capture invocation>","hypothesis":"<what it taught you to challenge>","nextCommand":"<later full capture invocation>"}], "limits":["<untested or blocked coverage>"] }
+Evidence rows contain ONLY complete JSON actually emitted by native probes, including failures and repeats; retain pre-repair results alongside green results. Never synthesize JSON from a tool error or raw test output. Put tests, raw CLI diagnostics, launch failures and timeouts in Markdown with their actual output and limits. The learning array is a summary: choose one completed checkpoint where an observation motivated a different later command, not the required same-command replay. Select that checkpoint ID in annotations.learning; the production helper copies its observationCommand, hypothesis and nextCommand. Both commands must name exact captured probes with different native child commands, never a combined command list or a replay distinguished only by capture ID. This selects existing exploration evidence, not another probe or a duplicate of the complete checkpoint ledger. Preserve every checkpoint and link every checkpoint in Markdown; keep every executed probe and its complete JSON in evidence, including the required replay. Missing dependencies remain setup blockers, not repairs. No browser installation or execution is needed.`;
+}
+
+export async function runQAFunctionalCase(entry: { id: string; family: QAFamily; mode: QAMode }, collector: EvalCollector | null) {
+  if (!process.env.EVALS_RUN_ID) throw new Error('Functional QA acceptance requires EVALS_RUN_ID from the documented detached runner');
+  const deadlineAt = Date.now() + CAPTURE_MS - OFFICE_HOURS_BUN_GRACE_MS;
+  const fixture = createQAFunctionalFixture(entry.family, { deadlineAt });
+  const inputs: Record<string, string> = Object.fromEntries(QA_EVIDENCE_RUNTIME.map(file => [file, createHash('sha256').update(fixture.files[file]).digest('hex')]));
+  let observer: Awaited<ReturnType<typeof observeQAWrites>> | undefined;
+  let observation: QAWriteObservation | undefined;
+  let result: SkillTestResult | undefined;
+  let report: unknown;
+  let verification: unknown;
+  let failure: unknown;
+  let passed = false;
+  const artifactRoot = path.join(process.env.GSTACK_EVAL_DIR || getProjectEvalDir(), 'qa-functional', process.env.EVALS_RUN_ID, `${entry.id}-${randomUUID()}`);
+  try {
+    for (const skill of ['qa', 'qa-only']) {
+      copyDirSync(path.join(ROOT, skill), ownedPath(fixture.root, skill));
+      fs.writeFileSync(ownedPath(fixture.root, `${skill}/SKILL.md`), extractSkillBody(path.join(ROOT, skill)));
+      const rewrite = (relative: string) => {
+        for (const item of fs.readdirSync(ownedPath(fixture.root, relative), { withFileTypes: true })) {
+          const child = path.join(relative, item.name);
+          if (item.isDirectory()) rewrite(child);
+          else if (item.name.endsWith('.md')) {
+            const file = ownedPath(fixture.root, child);
+            const text = fs.readFileSync(file, 'utf8').replaceAll('~/.claude/skills/gstack/', fixture.root + '/');
+            fs.writeFileSync(file, text);
+            inputs[child] = createHash('sha256').update(text).digest('hex');
+          }
+        }
+      };
+      rewrite(skill);
+    }
+    for (const asset of ['qa/sections/scope.md', 'qa/sections/system-functional.md', 'qa/sections/exploratory.md', 'qa/templates/functional-report-template.md']) {
+      if (!inputs[asset]) throw new Error(`Missing integrated functional instruction asset: ${asset}`);
+    }
+    fixtureGit(fixture.root, ['add', 'qa', 'qa-only']);
+    fixtureGit(fixture.root, ['commit', '-m', 'Bind current QA instructions to fixture']);
+    fixture.revision = fixtureGit(fixture.root, ['rev-parse', 'HEAD']);
+    if (fixtureGit(fixture.root, ['status', '--porcelain'])) throw new Error('QA fixture must start clean');
+    observer = await observeQAWrites(fixture.root, { evidenceProducer: true });
+    await runRecordedOfficeHoursAttempt({
+      collector, name: entry.id, suite: 'Functional QA native E2E',
+      model: process.env.EVALS_MODEL ?? resolveEvalModel('capture'),
+      budgetMs: Math.max(1, deadlineAt - Date.now()),
+      run: async signal => {
+        const timeout = Math.max(1, deadlineAt - Date.now() - SESSION_DRAIN_GRACE_MS);
+        result = await runSkillTest({
+          prompt: qaFunctionalPrompt(entry),
+          workingDirectory: fixture.root, maxTurns: 40, allowedTools: QA_TOOLS, tools: QA_TOOLS,
+          timeout, completionReserveMs: timeout / 4,
+          testName: entry.id, runId, signal, env: { CLAUDE_CONFIG_DIR: fixture.config,
+            GIT_OPTIONAL_LOCKS: '0', QA_STATE_ROOT: path.join(fixture.root, '.qa-state') },
+        });
+        return result;
+      },
+      validate: captured => {
+        logCost(entry.id, captured);
+        observation = observer!.stop();
+        observer = undefined;
+        const reportFile = ownedPath(fixture.root, 'qa-reports/report.md');
+        if (!fs.existsSync(reportFile) || !fs.readFileSync(reportFile, 'utf8').trim()) throw new Error('Missing functional Markdown report');
+        report = JSON.parse(fs.readFileSync(ownedPath(fixture.root, 'qa-reports/evidence.json'), 'utf8'));
+        const functionalPath = 'qa/sections/system-functional.md';
+        const failures = qaFunctionalVerdict(fixture, entry.mode, captured, observation, report,
+          { path: functionalPath, content: fs.readFileSync(ownedPath(fixture.root, functionalPath), 'utf8') }, fs.readFileSync(reportFile, 'utf8'));
+        const context = { cwd: fixture.root, reportRoot: path.join(fixture.root, 'qa-reports'), executable: path.join(fixture.root, 'bin/gstack-qa-evidence') };
+        const calls = nativeCalls(captured.transcript, failures);
+        for (const action of ['capture', 'checkpoint', 'materialize']) {
+          if (!calls.some(call => qaProducerReceipt(call, context)?.command.action === action)) failures.push(`missing completed production ${action}`);
+        }
+        if (!calls.some(call => {
+          const producer = qaProducerReceipt(call, context);
+          return producer?.command.action === 'materialize' && producer.receipt.sha256 === qaEvidenceHash(fs.readFileSync(ownedPath(fixture.root, 'qa-reports/evidence.json'), 'utf8'));
+        })) failures.push('final evidence differs from completed production materialization');
+        if (calls.some(call => ['Write', 'Edit'].includes(call.name) && /(?:exploration-\d{3}|evidence)\.json$/.test(call.input.file_path ?? ''))) failures.push('actor transcribed or overwrote helper-owned evidence');
+        if (calls.some(call => call.name === 'Bash' && /^bun (?:run probe -- |cancel\.ts$)/.test(call.input.command ?? '')
+          && !qaEvidenceCommand(call.input.command, context))) failures.push('native probe bypassed the production capture boundary');
+        for (const relative of [`${entry.mode}/SKILL.md`, `${entry.mode}/sections/exploratory.md`, 'qa/sections/scope.md']) {
+          const content = fs.readFileSync(ownedPath(fixture.root, relative), 'utf8').trim();
+          if (!captured.toolCalls.some(call => call.tool === 'Read' && call.input?.file_path?.endsWith(relative)
+            && call.output.replace(/^\s*\d+(?:→|\t)/gm, '').includes(content))) failures.push(`missing completed instruction read: ${relative}`);
+        }
+        if (failures.length) throw new Error(failures.join('; '));
+        if (entry.mode === 'qa') verification = verifyQANativeRegression(fixture, false, deadlineAt);
+        passed = true;
+      },
+    });
+  } catch (error) { passed = false; failure = error; throw error; }
+  finally {
+    if (observer) observation = observer.stop();
+    const reports: Record<string, string> = {};
+    try {
+      for (const name of fs.readdirSync(ownedPath(fixture.root, 'qa-reports'))) {
+        const file = ownedPath(fixture.root, `qa-reports/${name}`);
+        if (fs.lstatSync(file).isFile()) reports[name] = fs.readFileSync(file, 'utf8');
+      }
+    } catch (error) { failure ??= error; passed = false; }
+    let captures: unknown;
+    let captureFailure: unknown;
+    try { captures = qaCaptureArtifacts(ownedPath(fixture.root, 'qa-reports')); }
+    catch (error) { captureFailure = error; failure ??= error; passed = false; captures = { error: String(error) }; }
+    try {
+      preserveQAArtifact(artifactRoot, 'captures.json', captures);
+      preserveQAArtifact(artifactRoot, 'attempt.json', { case: entry, passed, revision: fixture.revision, inputs, observation, report, reports, verification, result, error: failure instanceof Error ? failure.message : failure });
+    } finally { fixture.cleanup(); }
+    if (captureFailure) throw captureFailure;
+  }
+}

test/helpers/qa-functional-evidence.ts

@@ -0,0 +1,243 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { createQAFunctionalFixture, fixtureCommand, ownedPath, QA_PRIVATE_SENTINEL, type QAFunctionalFixture, type QAMode } from './qa-functional-fixture';
+import { qaCommandAllowed, qaWriteAllowed, qaWriteVerdict, type QAWriteObservation } from './qa-functional-observer';
+import type { SkillTestResult } from './session-runner';
+import { readQACheckpointFiles, validateQACheckpoints } from './qa-checkpoint-evidence';
+import { nativeCalls } from './qa-checkpoint-evidence';
+import { qaNativeCapture } from './qa-evidence-producer';
+
+const canonical = (value: any): string => JSON.stringify(value && typeof value === 'object'
+  ? Array.isArray(value) ? value.map(item => JSON.parse(canonical(item)))
+    : Object.fromEntries(Object.keys(value).sort().map(key => [key, JSON.parse(canonical(value[key]))])) : value) ?? 'null';
+const failureOutput = (text: string) => /\b[1-9]\d* fail\b/.test(text) && !/SyntaxError|Cannot find module|ModuleNotFound|error:.*(?:import|resolve)/.test(text);
+const passingOutput = (text: string) => /\b[1-9]\d* pass\b/.test(text) && /\b0 fail\b/.test(text);
+
+export function qaNativeProbes(result: Pick<SkillTestResult, 'toolCalls'> & Partial<Pick<SkillTestResult, 'transcript'>>, root?: string) {
+  const calls = root && result.transcript ? nativeCalls(result.transcript, []) : [];
+  return result.toolCalls.flatMap<{ index: number; command: string; nativeCommand?: string; observed: any }>((call, index) => {
+    if (root && call.tool === 'Bash') {
+      const native = calls.filter(native => native.name === 'Bash' && native.input.command === call.input?.command && native.output === call.output);
+      const producer = native.length === 1 ? qaNativeCapture(native[0], { cwd: root, reportRoot: path.join(root, 'qa-reports'), executable: path.join(root, 'bin/gstack-qa-evidence') }) : undefined;
+      if (producer && /^bun (?:run probe -- |cancel\.ts$)/.test(producer.command.nativeCommand!)) {
+        const observed = producer.captured.observed as any;
+        if (observed && (Array.isArray(observed.args) || typeof observed.scenario === 'string'
+          || producer.command.nativeCommand === 'bun cancel.ts' && Object.hasOwn(observed, 'exit'))) return [{ index, command: call.input.command, nativeCommand: producer.command.nativeCommand!, observed }];
+      }
+    }
+    if (call.tool !== 'Bash' || !/^bun (?:run probe -- |cancel\.ts$)/.test(call.input?.command ?? '')) return [];
+    for (const line of call.output.split('\n')) {
+      try {
+        const observed = JSON.parse(line);
+        if (observed && (Array.isArray(observed.args) || typeof observed.scenario === 'string'
+          || call.input.command === 'bun cancel.ts' && Object.hasOwn(observed, 'exit'))) return [{ index, command: call.input.command, observed }];
+      } catch {}
+    }
+    return [];
+  });
+}
+
+export function qaProbeClassification(observed: any): 'pass' | 'product-defect' | 'setup-blocked' | 'inconclusive' {
+  const emptyState = canonical({ jobs: {}, effects: [] });
+  if (observed?.exit === 69 || observed?.scenario === 'dependency' || observed?.args?.[0] === 'export') {
+    const expected = 'SETUP_BLOCKED: optional qa-fixture-exporter-unavailable is not installed\n';
+    return observed.exit === 69 && observed.stdout === '' && observed.stderr === expected
+      && canonical(observed.state) === emptyState
+      && (observed.scenario === 'dependency' || canonical(observed.args) === '["export"]') ? 'setup-blocked' : 'product-defect';
+  }
+  if (Array.isArray(observed?.args)) {
+    if (observed.args[0] === 'apply') {
+      const [, id, amount] = observed.args;
+      const validId = typeof id === 'string' && /^[a-z][a-z0-9-]*$/.test(id);
+      const validAmount = typeof amount === 'string' && /^[0-9]+$/.test(amount) && Number.isSafeInteger(Number(amount)) && Number(amount) > 0;
+      if (observed.args.length !== 3 || !validId || !validAmount) {
+        const explanation = observed.args.length !== 3
+          ? /\b(?:apply|id|cents|amount|arguments?|parameters?)\b/i.test(observed.stderr)
+            && /\b(?:usage|syntax|requires?|required|expects?|expected|missing|provide)\b/i.test(observed.stderr)
+          : !validId ? /\b(?:id|identifier|lowercase|letters?)\b/i.test(observed.stderr)
+            && /\b(?:invalid|malformed|must|requires?|required|expected|only|start)\b/i.test(observed.stderr)
+            : /\b(?:amount|cents|integers?|digits?|numeric|numbers?|whole|fractions?|decimals?)\b/i.test(observed.stderr)
+              && /\b(?:invalid|must|positive|requires?|required|expected|only|not|no|reject(?:s|ed)?)\b/i.test(observed.stderr);
+        return observed.exit === 2 && observed.stdout === '' && typeof observed.stderr === 'string'
+          && observed.stderr.trim().length > 0 && explanation
+          && canonical(observed.state) === emptyState ? 'pass' : 'product-defect';
+      }
+      return observed.exit === 0 && observed.stdout === `balance=${Number(amount)}\n` && observed.stderr === ''
+        && canonical(observed.state) === canonical({ jobs: {}, effects: [{ id, cents: Number(amount) }] }) ? 'pass' : 'product-defect';
+    }
+    if (observed.args[0] === 'balance') return observed.args.length === 1 && observed.exit === 0
+      && observed.stdout === 'balance=0\n' && observed.stderr === '' && canonical(observed.state) === emptyState ? 'pass' : 'product-defect';
+    return 'inconclusive';
+  }
+  if (observed?.stateRoot && !observed.args && !observed.scenario) return observed.exit === 130
+    && observed.stdout === 'READY: awaiting cancellation\n' && observed.stderr === 'cancelled: no effect\n'
+    && canonical(observed.state) === emptyState ? 'pass' : 'product-defect';
+  if (observed.scenario === 'reject') return canonical(observed.requests?.map(request => request.status)) === '[401,422]'
+    && canonical(observed.state) === canonical({ jobs: {}, effects: [] }) ? 'pass' : 'product-defect';
+  if (observed.scenario === 'cancel') return observed.interrupted === 'cancelled before worker claim'
+    && canonical(observed.state) === canonical({ jobs: { delivery: { cents: 7, status: 'pending', attempts: 0 } }, effects: [] }) ? 'pass' : 'product-defect';
+  if (['happy', 'duplicate', 'partial', 'concurrent-ab', 'concurrent-ba'].includes(observed.scenario)) {
+    const expectedRequests = ['duplicate', 'partial'].includes(observed.scenario) ? 2 : 1;
+    const attempts = observed.state?.jobs?.delivery?.attempts;
+    const expectedOrder = observed.scenario === 'concurrent-ab' ? ['a', 'b'] : observed.scenario === 'concurrent-ba' ? ['b', 'a'] : [];
+    return canonical(observed.requests?.map(request => request.status)) === canonical(Array(expectedRequests).fill(202))
+      && Number.isSafeInteger(attempts) && attempts > 0
+      && canonical(observed.state) === canonical({ jobs: { delivery: { cents: 7, status: 'complete', attempts } }, effects: [{ id: 'delivery', cents: 7 }] })
+      && canonical(observed.order) === canonical(expectedOrder)
+      && (observed.scenario !== 'partial' || canonical(observed.stateAfterInterruption) === canonical({ jobs: { delivery: { cents: 7, status: 'pending', attempts: 1 } }, effects: [{ id: 'delivery', cents: 7 }] }))
+      && observed.interrupted === (observed.scenario === 'partial' ? 'injected worker interruption after effect' : '') ? 'pass' : 'product-defect';
+  }
+  return 'inconclusive';
+}
+
+export function qaFunctionalVerdict(fixture: QAFunctionalFixture, mode: QAMode, result: SkillTestResult, observation: QAWriteObservation, report: any, functionalSection: { path: string; content: string }, reportMarkdown = ''): string[] {
+  const failures = qaWriteVerdict(observation, mode);
+  const repairSource = `src/${fixture.family === 'cli' ? 'cli' : 'worker'}.ts`;
+  if (mode === 'qa' && observation.changed.some(file => file.startsWith('src/') && file !== repairSource)) failures.push('repair changed unrelated product source');
+  if (result.exitReason !== 'success') failures.push(`session did not complete: ${result.exitReason}`);
+  for (const call of result.toolCalls) {
+    if (call.tool === 'Bash' && !qaCommandAllowed(call.input?.command ?? '', fixture.root)) failures.push('command outside declared observation interface');
+    if (!['Read', 'Glob', 'Grep', 'Bash', 'Write', 'Edit'].includes(call.tool)) failures.push(`unsupported actor interaction: ${call.tool}`);
+    if (/browse|devex-review|browser-setup|browser-verif(?:y|ication)|test-bootstrap|qa-patterns/.test(call.input?.file_path ?? '')) failures.push('functional run loaded browser or DX instructions');
+    if (call.tool === 'Write' || call.tool === 'Edit') {
+      const attempted = call.input?.file_path;
+      let relative: string;
+      try {
+        if (typeof attempted !== 'string') throw new Error('missing attempted path');
+        relative = path.relative(fixture.root, ownedPath(fixture.root, attempted));
+      } catch {
+        failures.push('attempted write outside owned fixture');
+        continue;
+      }
+      if (!qaWriteAllowed(relative, mode) || mode === 'qa' && (relative.startsWith('src/') && relative !== repairSource
+        || relative.startsWith('test/') && Object.hasOwn(fixture.files, relative))) {
+        failures.push(mode === 'qa-only' ? 'report-only attempted a product/test write' : 'attempted write outside authorized repair/test paths');
+      }
+    }
+  }
+  if (!functionalSection.content.trim() || !result.toolCalls.some(call => call.tool === 'Read' && call.input?.file_path?.endsWith(functionalSection.path)
+    && call.output.replace(/^\s*\d+(?:→|\t)/gm, '').includes(functionalSection.content.trim()))) failures.push('no completed functional instruction read');
+  const firstEdit = result.toolCalls.findIndex(call => ['Edit', 'Write'].includes(call.tool) && path.relative(fixture.root, path.resolve(fixture.root, call.input?.file_path ?? '')).startsWith('src/'));
+  const probes = qaNativeProbes(result, fixture.root);
+  const nativeCommand = (probe: typeof probes[number]) => probe.nativeCommand ?? probe.command;
+  const defect = probes.find(probe => qaProbeClassification(probe.observed) === 'product-defect');
+  if (!defect) failures.push('no observed unannounced defect');
+  if (!probes.some(probe => qaProbeClassification(probe.observed) === 'setup-blocked')) failures.push('missing setup-blocked observation');
+  const cancellations = probes.filter(probe => fixture.family === 'cli' ? nativeCommand(probe) === 'bun cancel.ts' : probe.observed.scenario === 'cancel');
+  if (!cancellations.length) failures.push('missing cancellation observation');
+  if (fixture.family === 'webhook') {
+    for (const scenario of ['happy', 'reject', 'duplicate', 'partial', 'concurrent-ab', 'concurrent-ba']) {
+      if (!probes.some(probe => probe.observed.scenario === scenario)) failures.push(`missing native ${scenario} probe`);
+    }
+  } else if (!probes.some(probe => probe.observed.args?.[0] === 'apply' && qaProbeClassification(probe.observed) === 'pass')) failures.push('missing adjacent valid CLI apply');
+  if (defect && !probes.some(probe => probe.index < defect.index && qaProbeClassification(probe.observed) === 'pass')) failures.push('no successful observation before adversarial exploration');
+  if (defect && probes.filter(probe => (firstEdit < 0 || probe.index < firstEdit)
+    && nativeCommand(probe) === nativeCommand(defect) && qaProbeClassification(probe.observed) === 'product-defect').length < 2) failures.push('failure was not reproduced before repair');
+  const reportRoot = ownedPath(fixture.root, 'qa-reports');
+  let checkpointFiles: Record<string, string> = {};
+  try {
+    checkpointFiles = readQACheckpointFiles(reportRoot);
+    failures.push(...validateQACheckpoints({
+      transcript: result.transcript, reportRoot, probes,
+      producer: { cwd: fixture.root, reportRoot, executable: path.join(fixture.root, 'bin/gstack-qa-evidence') },
+      requiredProbes: probes.filter(probe => firstEdit < 0 || probe.index < firstEdit).slice(1),
+      additionalTargets: result.toolCalls.filter(call => call.tool === 'Bash' && /^bun test(?: |$)/.test(call.input?.command ?? '')
+        && qaCommandAllowed(call.input.command) && (failureOutput(call.output) || passingOutput(call.output))
+        && /\nRan [1-9]\d* tests? across [1-9]\d* files?\. \[[^\]\n]+\]\s*$/.test(call.output))
+        .map(call => ({ command: call.input.command, output: call.output })),
+      files: checkpointFiles, reportMarkdown,
+    }));
+  } catch (error) { failures.push(`checkpoint artifact failure: ${error instanceof Error ? error.message : error}`); }
+  if (!report || report.revision !== fixture.revision || report.runtime !== `bun ${Bun.version}` || report.cwd !== fixture.root) failures.push('report lacks exact revision/runtime/cwd');
+  if (!Array.isArray(report?.limits) || report.limits.length === 0) failures.push('report lacks coverage limits');
+  if (!Array.isArray(report?.evidence) || report.evidence.length < probes.length) failures.push('report omitted executed probe evidence');
+  for (const probe of probes) {
+    if (!report?.evidence?.some(row => row.command === probe.command && row.contract === 'README.md' && typeof row.expected === 'string' && row.expected.trim()
+      && row.classification === qaProbeClassification(probe.observed) && canonical(row.observed) === canonical(probe.observed))) failures.push(`missing exact sanitized evidence for ${probe.command}`);
+  }
+  for (const row of report?.evidence ?? []) {
+    if (!probes.some(probe => row.command === probe.command && canonical(row.observed) === canonical(probe.observed))) failures.push('report invented an executed probe');
+  }
+  if (!report?.learning?.some(row => typeof row.hypothesis === 'string' && row.hypothesis.trim().length > 20
+    && probes.some(previous => previous.command === row.observationCommand && probes.some(next => next.index > previous.index && next.command === row.nextCommand && nativeCommand(next) !== nativeCommand(previous))))) failures.push('missing observation-to-next-hypothesis evidence');
+  const publicText = JSON.stringify(report) + result.output + reportMarkdown + JSON.stringify(checkpointFiles);
+  if (publicText.includes(QA_PRIVATE_SENTINEL)) failures.push('private sentinel leaked into published evidence');
+  if (mode === 'qa' && defect) {
+    const red = result.toolCalls.findIndex(call => call.tool === 'Bash' && /^bun test(?: |$)/.test(call.input?.command ?? '') && failureOutput(call.output));
+    const green = result.toolCalls.findIndex((call, index) => index > firstEdit && call.tool === 'Bash' && /^bun test(?: |$)/.test(call.input?.command ?? '') && passingOutput(call.output));
+    if (firstEdit < 0 || red < defect.index || red >= firstEdit || green <= firstEdit) failures.push('missing native regression red-before-fix and green-after sequence');
+    if (red >= 0 && result.toolCalls.slice(red + 1).some(call => ['Write', 'Edit'].includes(call.tool)
+      && path.relative(fixture.root, path.resolve(fixture.root, call.input?.file_path ?? '')).startsWith('test/'))) failures.push('regression changed after its red proof');
+    if (!probes.some(probe => probe.index > firstEdit && nativeCommand(probe) === nativeCommand(defect) && qaProbeClassification(probe.observed) === 'pass')) failures.push('original failing probe was not green after fix');
+    if (!probes.some(probe => probe.index > firstEdit && nativeCommand(probe) !== nativeCommand(defect) && qaProbeClassification(probe.observed) === 'pass')) failures.push('adjacent happy path was not green after fix');
+    if (!cancellations.some(probe => probe.index > firstEdit && qaProbeClassification(probe.observed) === 'pass')) failures.push('cancellation was not green after fix');
+    if (!probes.some(probe => probe.index > firstEdit && qaProbeClassification(probe.observed) === 'setup-blocked')) failures.push('dependency blockage was not rechecked after fix');
+  }
+  return failures;
+}
+
+export function verifyQANativeRegression(fixture: QAFunctionalFixture, healthyControl = false, deadlineAt = Infinity) {
+  const run = (root: string, args: string[]) => {
+    const remaining = Math.min(10_000, deadlineAt - Date.now());
+    if (remaining <= 0) throw new Error('Native regression verification deadline exhausted');
+    return fixtureCommand(root, args, remaining);
+  };
+  const tests = fs.readdirSync(ownedPath(fixture.root, 'test')).filter(name => name.endsWith('.test.ts') && !fixture.files[`test/${name}`]);
+  if (!tests.length) throw new Error('No permanent native regression test was added');
+  for (const [relative, content] of Object.entries(fixture.files)) {
+    if (relative.startsWith('test/') && fs.readFileSync(ownedPath(fixture.root, relative), 'utf8') !== content) throw new Error('Existing test was changed');
+  }
+  const copies: QAFunctionalFixture[] = [];
+  try {
+    for (const healthy of [healthyControl, healthyControl, true]) copies.push(createQAFunctionalFixture(fixture.family, { healthy, deadlineAt }));
+    const [before, after, knownGood] = copies as [QAFunctionalFixture, QAFunctionalFixture, QAFunctionalFixture];
+    for (const target of [before, after, knownGood]) {
+      for (const name of tests) fs.copyFileSync(ownedPath(fixture.root, `test/${name}`), ownedPath(target.root, `test/${name}`));
+    }
+    for (const name of fs.readdirSync(ownedPath(fixture.root, 'src'))) fs.copyFileSync(ownedPath(fixture.root, `src/${name}`), ownedPath(after.root, `src/${name}`));
+    const args = ['test', ...tests.map(name => `test/${name}`)];
+    const red = run(before.root, args);
+    const green = run(after.root, ['test']);
+    const contract = run(knownGood.root, args);
+    if (healthyControl ? red.exit !== 0 || !passingOutput(red.stderr) : red.exit === 0 || !failureOutput(red.stderr)) throw new Error('Regression does not distinguish the original defect');
+    if (green.exit !== 0 || !passingOutput(green.stderr)) throw new Error('Regression or adjacent existing test fails with candidate repair');
+    if (contract.exit !== 0 || !passingOutput(contract.stderr)) throw new Error('Invalid regression rejects the declared healthy contract');
+    const commands = fixture.family === 'cli' ? [['probe.ts', 'apply', 'replay', '7junk'], ['probe.ts', 'apply', 'adjacent', '7'], ['probe.ts', 'export'], ['cancel.ts']]
+      : ['happy', 'reject', 'duplicate', 'partial', 'concurrent-ab', 'concurrent-ba', 'cancel', 'dependency'].map(scenario => ['probe.ts', scenario]);
+    const rechecks = commands.map(args => JSON.parse(run(after.root, args).stdout));
+    if (rechecks.some(probe => qaProbeClassification(probe) !== (probe.exit === 69 ? 'setup-blocked' : 'pass'))) throw new Error('Candidate repair fails original or adjacent contract');
+    return { tests, red, green, contract, rechecks };
+  } finally { for (const copy of copies) copy.cleanup(); }
+}
+
+export function preserveQAArtifact(directory: string, name: string, value: unknown): string {
+  fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
+  if (fs.realpathSync(directory) !== path.resolve(directory)) throw new Error('Artifact directory must not be linked');
+  fs.chmodSync(directory, 0o700);
+  const target = ownedPath(directory, name);
+  const text = JSON.stringify(value, null, 2).replaceAll(QA_PRIVATE_SENTINEL, '<redacted synthetic private payload>');
+  fs.writeFileSync(target, text + '\n', { mode: 0o600 });
+  fs.chmodSync(target, 0o600);
+  return target;
+}
+
+export function qaCaptureArtifacts(reportRoot: string) {
+  const files: Record<string, string> = {};
+  const visit = (relative: string) => {
+    const file = ownedPath(reportRoot, relative);
+    const stat = fs.lstatSync(file, { throwIfNoEntry: false });
+    if (!stat) return;
+    if (stat.isDirectory()) {
+      for (const name of fs.readdirSync(file)) visit(path.join(relative, name));
+      return;
+    }
+    const fd = fs.openSync(file, fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW ?? 0) | (fs.constants.O_NONBLOCK ?? 0));
+    try {
+      const opened = fs.fstatSync(fd);
+      if (!opened.isFile() || opened.nlink !== 1 || opened.dev !== stat.dev || opened.ino !== stat.ino) throw new Error('Capture artifact changed while retaining it');
+      files[relative] = fs.readFileSync(fd).toString('base64');
+    } finally { fs.closeSync(fd); }
+  };
+  visit('.qa-evidence');
+  return { encoding: 'base64', files };
+}

test/helpers/qa-functional-fixture.ts

@@ -0,0 +1,298 @@
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { qaEvidenceRuntimeFiles } from './qa-evidence-producer';
+
+export type QAFamily = 'cli' | 'webhook';
+export type QAMode = 'qa' | 'qa-only';
+export const QA_SYNTHETIC_AUTH = 'fixture-local-only';
+export const QA_PRIVATE_SENTINEL = 'synthetic-private-payload-do-not-publish';
+export const QA_TOOLS = ['Bash', 'Read', 'Write', 'Edit', 'Glob', 'Grep'];
+
+export function ownedPath(root: string, relative: string): string {
+  const canonical = fs.realpathSync(root);
+  const target = path.resolve(root, relative);
+  if (canonical !== path.resolve(root) || !target.startsWith(canonical + path.sep)) throw new Error('Fixture path escapes its owned root');
+  let cursor = canonical;
+  for (const part of path.relative(canonical, target).split(path.sep)) {
+    cursor = path.join(cursor, part);
+    const entry = fs.lstatSync(cursor, { throwIfNoEntry: false });
+    if (entry?.isSymbolicLink() || (entry?.isFile() && entry.nlink !== 1)) throw new Error('Fixture path traverses a link');
+  }
+  return target;
+}
+
+export function fixtureCommand(root: string, args: string[], timeout = 10_000) {
+  const result = spawnSync(process.execPath, args, {
+    cwd: root, encoding: 'utf8', timeout,
+    env: { ...process.env, QA_STATE_ROOT: path.join(root, '.qa-state'), GIT_OPTIONAL_LOCKS: '0' },
+  });
+  if (result.error) throw result.error;
+  return { exit: result.status, stdout: result.stdout, stderr: result.stderr, signal: result.signal };
+}
+
+export function fixtureGit(root: string, args: string[], timeout = 10_000): string {
+  const result = spawnSync('git', args, {
+    cwd: root, encoding: 'utf8', timeout, env: { ...process.env, GIT_OPTIONAL_LOCKS: '0' },
+  });
+  if (result.error || result.status !== 0) throw new Error(`Fixture git ${args[0]} failed: ${result.error ?? result.stderr}`);
+  return result.stdout.trim();
+}
+
+const storage = `import * as fs from 'node:fs';
+import * as path from 'node:path';
+export function stateRoot() {
+  const root = path.resolve(process.env.QA_STATE_ROOT || '.qa-state');
+  const owned = path.resolve('.qa-state');
+  if (root !== owned && !root.startsWith(owned + path.sep)) throw new Error('unowned state root');
+  let cursor = process.cwd();
+  for (const part of path.relative(cursor, root).split(path.sep)) {
+    cursor = path.join(cursor, part);
+    if (fs.lstatSync(cursor, { throwIfNoEntry: false })?.isSymbolicLink()) throw new Error('linked state root');
+    fs.mkdirSync(cursor, { recursive: true });
+  }
+  return root;
+}
+export function readState() {
+  const file = path.join(stateRoot(), 'ledger.json');
+  if (fs.lstatSync(file, { throwIfNoEntry: false })?.isSymbolicLink()) throw new Error('linked state file');
+  return fs.existsSync(file) ? JSON.parse(fs.readFileSync(file, 'utf8')) : { jobs: {}, effects: [] };
+}
+export function writeState(value) {
+  const root = stateRoot();
+  for (const name of ['ledger.json', 'ledger.tmp']) {
+    const entry = fs.lstatSync(path.join(root, name), { throwIfNoEntry: false });
+    if (entry?.isSymbolicLink() || (entry?.isFile() && entry.nlink !== 1)) throw new Error('linked state file');
+  }
+  fs.writeFileSync(path.join(root, 'ledger.tmp'), JSON.stringify(value));
+  fs.renameSync(path.join(root, 'ledger.tmp'), path.join(root, 'ledger.json'));
+}
+`;
+
+function cliSource(healthy: boolean): string {
+  return `import { readState, writeState } from './storage';
+export function amount(value: string) {
+  const number = ${healthy ? '/^[0-9]+$/.test(value) ? Number(value) : NaN' : 'parseInt(value, 10)'};
+  if (!Number.isSafeInteger(number) || number <= 0) throw new Error('amount must be a positive integer');
+  return number;
+}
+export function apply(id: string, input: string) {
+  if (!/^[a-z][a-z0-9-]*$/.test(id)) throw new Error('invalid id');
+  const cents = amount(input);
+  const state = readState();
+  if (!state.effects.some(effect => effect.id === id)) {
+    state.effects.push({ id, cents });
+    writeState(state);
+  }
+  return state.effects.reduce((sum, effect) => sum + effect.cents, 0);
+}
+export async function main(args: string[]) {
+  try {
+    if (args[0] === 'balance' && args.length === 1) {
+      console.log('balance=' + readState().effects.reduce((sum, effect) => sum + effect.cents, 0));
+    } else if (args[0] === 'apply' && args.length === 3) {
+      console.log('balance=' + apply(args[1], args[2]));
+    } else if (args[0] === 'wait' && args.length === 3) {
+      amount(args[2]);
+      process.on('SIGTERM', () => { console.error('cancelled: no effect'); process.exit(130); });
+      console.log('READY: awaiting cancellation');
+      await new Promise(() => { setInterval(() => {}, 1000); });
+    } else if (args[0] === 'export' && args.length === 1) {
+      if (Bun.which('qa-fixture-exporter-unavailable')) throw new Error('unexpected optional exporter on PATH; do not invoke it');
+      console.error('SETUP_BLOCKED: optional qa-fixture-exporter-unavailable is not installed');
+      process.exitCode = 69;
+    } else throw new Error('usage: apply <id> <cents> | balance | wait <id> <cents> | export');
+  } catch (error) { console.error(error.message); process.exitCode = 2; }
+}
+if (import.meta.main) await main(process.argv.slice(2));
+`;
+}
+
+function workerSource(healthy: boolean): string {
+  return `import { readState, writeState } from './storage';
+export async function processJob(id: string, options: { gate?: () => Promise<void>; failAfterEffect?: boolean } = {}) {
+  const before = readState();
+  if (before.jobs[id]?.status === 'complete') return;
+  if (!before.jobs[id]) throw new Error('unknown job');
+  if (options.gate) await options.gate();
+  const state = readState();
+  ${healthy ? 'if (!state.effects.some(effect => effect.id === id)) ' : ''}state.effects.push({ id, cents: state.jobs[id].cents });
+  state.jobs[id].attempts++;
+  writeState(state);
+  if (options.failAfterEffect) throw new Error('injected worker interruption after effect');
+  state.jobs[id].status = 'complete';
+  writeState(state);
+}
+export function startService() {
+  return Bun.serve({ hostname: '127.0.0.1', port: 0, async fetch(request) {
+    if (new URL(request.url).pathname !== '/events' || request.method !== 'POST') return new Response('not found', { status: 404 });
+    if (request.headers.get('Authorization') !== 'Bearer ${QA_SYNTHETIC_AUTH}') return new Response('unauthorized', { status: 401 });
+    let event;
+    try { event = await request.json(); } catch { return new Response('invalid JSON', { status: 400 }); }
+    if (!/^[a-z][a-z0-9-]*$/.test(event?.id) || !Number.isSafeInteger(event?.cents) || event.cents <= 0) return new Response('invalid event', { status: 422 });
+    const state = readState();
+    if (!state.jobs[event.id]) state.jobs[event.id] = { cents: event.cents, status: 'pending', attempts: 0 };
+    writeState(state);
+    return Response.json({ accepted: event.id }, { status: 202 });
+  }});
+}
+`;
+}
+
+const webhookProbe = `import { processJob, startService } from './src/worker';
+import { readState } from './src/storage';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+const scenario = process.argv[2];
+if (!['happy', 'reject', 'duplicate', 'partial', 'concurrent-ab', 'concurrent-ba', 'cancel', 'dependency'].includes(scenario)) throw new Error('unknown scenario');
+process.env.QA_STATE_ROOT = fs.mkdtempSync(path.join(path.resolve('.qa-state'), scenario + '-'));
+if (scenario === 'dependency') {
+  if (Bun.which('qa-fixture-exporter-unavailable')) throw new Error('unexpected optional exporter on PATH; do not invoke it');
+  const stderr = 'SETUP_BLOCKED: optional qa-fixture-exporter-unavailable is not installed\\n';
+  console.log(JSON.stringify({ scenario, exit: 69, stdout: '', stderr, state: readState(), stateRoot: process.env.QA_STATE_ROOT }));
+  console.error(stderr.trim());
+  process.exit(69);
+}
+const server = startService();
+const url = 'http://127.0.0.1:' + server.port + '/events';
+const requests = [];
+const send = async (id, cents, auth = '${QA_SYNTHETIC_AUTH}') => {
+  const body = { id, cents };
+  const response = await fetch(url, { method: 'POST', headers: { Authorization: 'Bearer ' + auth, 'Content-Type': 'application/json' }, body: JSON.stringify(body) });
+  requests.push({ method: 'POST', path: '/events', auth: auth === '${QA_SYNTHETIC_AUTH}' ? '$QA_SYNTHETIC_AUTH' : '<invalid>', body, status: response.status, response: await response.text() });
+};
+const releases = {};
+const arrivals = {};
+const barrier = label => {
+  let arrived;
+  arrivals[label] = new Promise(resolve => { arrived = resolve; });
+  return () => { arrived(); return new Promise(resolve => { releases[label] = resolve; }); };
+};
+const order = [];
+let interrupted = '';
+let stateAfterInterruption;
+try {
+  if (scenario === 'reject') {
+    await send('reject-auth', 7, 'invalid');
+    await send('reject-input', 0);
+  } else {
+    await send('delivery', 7);
+    if (scenario === 'partial') {
+      try { await processJob('delivery', { failAfterEffect: true }); } catch (error) { interrupted = error.message; }
+      stateAfterInterruption = readState();
+      await send('delivery', 7);
+      await processJob('delivery');
+    } else if (scenario.startsWith('concurrent-')) {
+      const a = processJob('delivery', { gate: barrier('a') });
+      const b = processJob('delivery', { gate: barrier('b') });
+      await Promise.all([arrivals.a, arrivals.b]);
+      for (const label of scenario.endsWith('ab') ? ['a', 'b'] : ['b', 'a']) {
+        order.push(label); releases[label](); await (label === 'a' ? a : b);
+      }
+    } else if (scenario === 'cancel') {
+      interrupted = 'cancelled before worker claim';
+    } else {
+      await processJob('delivery');
+      if (scenario === 'duplicate') { await send('delivery', 7); await processJob('delivery'); }
+    }
+  }
+  console.log(JSON.stringify({ scenario, requests, order, interrupted, stateAfterInterruption, state: readState(), stateRoot: process.env.QA_STATE_ROOT }));
+} finally { server.stop(true); }
+`;
+
+export function createQAFunctionalFixture(family: QAFamily, options: { healthy?: boolean; parent?: string; deadlineAt?: number } = {}) {
+  const remaining = () => {
+    const time = Math.min(10_000, (options.deadlineAt ?? Infinity) - Date.now());
+    if (time <= 0) throw new Error('Functional fixture deadline exhausted');
+    return time;
+  };
+  remaining();
+  const parent = fs.realpathSync(options.parent ?? os.tmpdir());
+  const checkout = fs.realpathSync(path.resolve(import.meta.dir, '../..'));
+  if (parent === checkout || parent.startsWith(checkout + path.sep)) throw new Error('Fixture repositories must be outside the checkout');
+  const root = fs.mkdtempSync(path.join(parent, 'qaf-'));
+  fs.chmodSync(root, 0o700);
+  const config = fs.mkdtempSync(path.join(parent, 'qac-'));
+  fs.chmodSync(config, 0o700);
+  const hook = [process.execPath, path.join(import.meta.dir, 'qa-functional-observer.ts'), root]
+    .map(value => `'${value.replaceAll("'", "'\\''")}'`).join(' ');
+  const files: Record<string, string> = {
+    ...qaEvidenceRuntimeFiles(),
+    '.gitignore': '.qa-state/\nqa-reports/\n',
+    'package.json': JSON.stringify({ name: 'qa-functional-fixture', private: true, type: 'module', scripts: family === 'cli' ? { cli: 'bun src/cli.ts', probe: 'bun probe.ts', test: 'bun test' } : { probe: 'bun probe.ts', test: 'bun test' } }, null, 2) + '\n',
+    'src/storage.ts': storage,
+    'README.md': family === 'cli' ? `# Ledger CLI contract\nNative commands: bun run cli -- apply <id> <cents>; bun run cli -- balance; bun run cli -- wait <id> <cents>; bun run cli -- export.\nIDs match [a-z][a-z0-9-]*. Amounts contain only ASCII digits and represent a positive safe integer. Invalid input exits 2, stdout is empty, stderr explains the rejection, and durable state does not change.\nSuccess exits 0 with exactly balance=<integer> followed by a newline on stdout and empty stderr. Repeated IDs have one effect.\nwait emits READY, then SIGTERM exits 130 with stderr 'cancelled: no effect' and no durable write. The native cancellation probe is bun cancel.ts.\nexport requires an optional unavailable exporter: exit 69, no stdout, SETUP_BLOCKED on stderr, no effect. Do not install it.\nThe ledger is .qa-state/ledger.json; inspect durable effects as well as output. bun test runs the existing native suite.\n` : `# Local delivery contract\nPOST /events requires Authorization: Bearer ${QA_SYNTHETIC_AUTH} (synthetic local credential). JSON is {id,cents}; IDs match [a-z][a-z0-9-]* and cents is a positive safe integer. Unauthorized is 401, invalid is 422, neither writes state. Valid acceptance is 202, not completion.\nA completed job has status complete. One logical delivery ID has exactly one durable effect, including duplicate delivery, retry after interruption and concurrent workers. Workers may stop after the effect but before marking completion.\nNative command: bun run probe -- <scenario>. Scenarios: happy, reject, duplicate, partial, concurrent-ab, concurrent-ba, cancel, dependency. Each creates its own .qa-state/<scenario>-* store, binds only 127.0.0.1 and closes the server before exit. Its JSON prints exact sanitized requests, responses, durable state, barrier release order and stateRoot.\nBoth concurrent scenarios wait until both workers have read the same pending job before releasing a then b, or b then a. cancel stops before claim: pending job, zero effects. dependency exits 69 with SETUP_BLOCKED for the unavailable optional exporter; do not install it.\nbun test runs the existing native suite.\n`,
+    'AGENTS.md': `This is an owned, offline fixture repository. Only .qa-state/ and qa-reports/ are disposable. Do not write through links. No external services, package installs, browser or developer-experience audit is authorized. The optional exporter is deliberately unavailable; report setup blockage, do not create a replacement. private.txt contains synthetic private data and must never appear in a report.\n`,
+    'private.txt': QA_PRIVATE_SENTINEL + '\n',
+  };
+  if (family === 'cli') {
+    files['src/cli.ts'] = cliSource(!!options.healthy);
+    files['README.md'] += 'For a self-contained replay with separate exit/stdout/stderr and durable state, use bun run probe -- <CLI arguments>. Each invocation owns a fresh .qa-state/cli-* store. The probe calls the real CLI without a shell.\n';
+    files['probe.ts'] = `import { spawnSync } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+const args = process.argv.slice(2);
+const stateRoot = fs.mkdtempSync(path.join(path.resolve('.qa-state'), 'cli-'));
+const result = spawnSync(process.execPath, ['src/cli.ts', ...args], { encoding: 'utf8', timeout: 5000, env: { ...process.env, QA_STATE_ROOT: stateRoot } });
+if (result.error) throw result.error;
+const stateFile = path.join(stateRoot, 'ledger.json');
+console.log(JSON.stringify({ args, exit: result.status, stdout: result.stdout, stderr: result.stderr, state: fs.existsSync(stateFile) ? JSON.parse(fs.readFileSync(stateFile, 'utf8')) : { jobs: {}, effects: [] }, stateRoot }));
+`;
+    files['test/smoke.test.ts'] = `import { test, expect } from 'bun:test';\nimport { amount } from '../src/cli';\ntest('positive whole amount', () => expect(amount('7')).toBe(7));\n`;
+    files['cancel.ts'] = `import { spawn } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+const stateRoot = fs.mkdtempSync(path.join(path.resolve('.qa-state'), 'cancel-'));
+const child = spawn(process.execPath, ['src/cli.ts', 'wait', 'cancelled', '7'], { stdio: ['ignore', 'pipe', 'pipe'], env: { ...process.env, QA_STATE_ROOT: stateRoot } });
+let stdout = '', stderr = '';
+const timer = setTimeout(() => child.kill('SIGKILL'), 5000);
+child.stdout.on('data', data => { stdout += data; if (stdout.includes('READY: awaiting cancellation')) child.kill('SIGTERM'); });
+child.stderr.on('data', data => { stderr += data; });
+const exit = await new Promise(resolve => child.once('close', resolve));
+clearTimeout(timer);
+const ledger = path.join(stateRoot, 'ledger.json');
+console.log(JSON.stringify({ exit, stdout, stderr, state: fs.existsSync(ledger) ? JSON.parse(fs.readFileSync(ledger, 'utf8')) : { jobs: {}, effects: [] }, stateRoot }));
+if (exit !== 130) process.exitCode = 1;
+`;
+  } else {
+    files['src/worker.ts'] = workerSource(!!options.healthy);
+    files['probe.ts'] = webhookProbe;
+    files['test/smoke.test.ts'] = `import { test, expect } from 'bun:test';
+import { spawnSync } from 'node:child_process';
+test('successful delivery', () => {
+  const result = spawnSync(process.execPath, ['probe.ts', 'happy'], { encoding: 'utf8', timeout: 10000 });
+  expect(result.status).toBe(0);
+  expect(JSON.parse(result.stdout).state.effects).toEqual([{ id: 'delivery', cents: 7 }]);
+});
+`;
+  }
+  try {
+    fs.writeFileSync(path.join(config, 'settings.json'), JSON.stringify({ hooks: { PreToolUse: [{ matcher: '^Bash$',
+      hooks: [{ type: 'command', command: hook, timeout: 5 }] }] } }) + '\n', { mode: 0o600 });
+    for (const dir of ['src', 'test', 'bin', 'lib', '.qa-state', 'qa-reports']) fs.mkdirSync(ownedPath(root, dir));
+    for (const [relative, content] of Object.entries(files)) fs.writeFileSync(ownedPath(root, relative), content);
+    fixtureGit(root, ['init', '-b', 'main'], remaining());
+    fixtureGit(root, ['config', 'user.name', 'QA Fixture'], remaining());
+    fixtureGit(root, ['config', 'user.email', 'qa-fixture@gstack.test'], remaining());
+    fixtureGit(root, ['config', 'commit.gpgsign', 'false'], remaining());
+    fixtureGit(root, ['add', '.'], remaining());
+    fixtureGit(root, ['commit', '-m', 'Seed owned functional QA fixture'], remaining());
+    const revision = fixtureGit(root, ['rev-parse', 'HEAD'], remaining());
+    return { root, config, family, revision, files, cleanup: () => {
+      if (fs.realpathSync(root) !== root || fs.realpathSync(config) !== config) throw new Error('Fixture root moved before cleanup');
+      fs.rmSync(root, { recursive: true, force: true });
+      fs.rmSync(config, { recursive: true, force: true });
+    } };
+  } catch (error) {
+    fs.rmSync(root, { recursive: true, force: true });
+    fs.rmSync(config, { recursive: true, force: true });
+    throw error;
+  }
+}
+
+export type QAFunctionalFixture = ReturnType<typeof createQAFunctionalFixture>;
+
+export function qaFixtureActor(mode: QAMode): string {
+  return `The fixture actor grants only isolated .qa-state/ probes and qa-reports/ evidence writes. ${mode === 'qa' ? 'You may add native regression tests and repair a reproduced product defect in src/. Do not commit; the caller retains all Git authority.' : 'Report only. Product, tests, dependencies, configuration and Git writes are forbidden, including temporary edits restored later.'} No external action, install, destructive cleanup, permission expansion or unrelated task is approved. If a question exceeds this declared interface, report blocked rather than assuming consent. Mutation-capable Bash, Write and Edit tools remain available. Use Read/Glob/Grep for discovery, Write/Edit for authorized file changes, and separate literal Bash commands from the documented native interface. The exact command date -u +%Y-%m-%dT%H:%M:%SZ is permitted for a read-only completion clock. No shell pipelines, redirects or custom interpreters are part of the actor interface.`;
+}

test/helpers/qa-functional-observer.ts

@@ -0,0 +1,294 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { createHash } from 'node:crypto';
+import { ownedPath, type QAMode } from './qa-functional-fixture';
+import { qaEvidenceCommand } from './qa-evidence-producer';
+
+export const QA_OBSERVER_LIMITS = [
+  'Linux inotify only; unavailable kernel monitoring blocks acceptance.',
+  'Kernel events detect write syscalls, links, renames, removals and Git writes, not memory-mapped writes or remote filesystems.',
+  'A closed native-command interface rejects unobserved interpreters and shell composition; this is not a hostile-process sandbox.',
+  'The observer covers the owned fixture tree, not arbitrary external paths or network destinations.',
+];
+
+export function qaWriteAllowed(relative: string, mode: QAMode): boolean {
+  if (/^(?:\.qa-state|qa-reports)(?:\/|$)/.test(relative)) return true;
+  return mode === 'qa' && /^(?:src|test)\//.test(relative);
+}
+
+function pathFailure(root: string, relative: string, error: unknown): Error {
+  let cursor = root;
+  let detail = 'missing';
+  for (const part of relative.split(path.sep)) {
+    cursor = path.join(cursor, part);
+    try {
+      const entry = fs.lstatSync(cursor, { throwIfNoEntry: false });
+      detail = entry ? `dev=${entry.dev} ino=${entry.ino} nlink=${entry.nlink} mode=${(entry.mode & 0o777).toString(8)}` : 'missing';
+      if (!entry || entry.isSymbolicLink() || (entry.isFile() && entry.nlink !== 1)) break;
+    } catch { detail = 'stat unavailable'; break; }
+  }
+  return new Error(`${String(error)} [path=${relative} entry=${cursor} ${detail}]`);
+}
+
+export function qaTreeSnapshot(root: string): Record<string, string> {
+  const result: Record<string, string> = {};
+  const visit = (relative: string) => {
+    let file: string;
+    try { file = relative ? ownedPath(root, relative) : root; }
+    catch (error) { throw pathFailure(root, relative, error); }
+    const entry = fs.lstatSync(file);
+    if (entry.isDirectory()) {
+      if (relative) result[relative] = `directory:${entry.mode & 0o777}`;
+      for (const name of fs.readdirSync(file).sort()) visit(path.join(relative, name));
+    } else if (entry.isFile()) {
+      result[relative] = `${entry.mode & 0o777}:${createHash('sha256').update(fs.readFileSync(file)).digest('hex')}`;
+    } else throw new Error(`Unsupported fixture entry: ${relative}`);
+  };
+  visit('');
+  return result;
+}
+
+export function decodeQAInotify(buffer: Buffer): Array<{ wd: number; mask: number; cookie: number; name: string }> {
+  const records: Array<{ wd: number; mask: number; cookie: number; name: string }> = [];
+  let offset = 0;
+  while (offset < buffer.length) {
+    if (buffer.length - offset < 16) throw new Error('truncated kernel event');
+    const length = buffer.readUInt32LE(offset + 12);
+    if (offset + 16 + length > buffer.length) throw new Error('truncated kernel event name');
+    records.push({ wd: buffer.readInt32LE(offset), mask: buffer.readUInt32LE(offset + 4), cookie: buffer.readUInt32LE(offset + 8),
+      name: buffer.subarray(offset + 16, offset + 16 + length).toString().replace(/\0.*$/s, '') });
+    offset += 16 + length;
+  }
+  return records;
+}
+
+export interface QAWriteObservation {
+  complete: boolean;
+  failures: string[];
+  events: Array<{ path: string; mask: number; cookie: number; at: number }>;
+  changed: string[];
+  before: Record<string, string>;
+  after: Record<string, string>;
+  limits: string[];
+}
+
+export async function observeQAWrites(root: string, options: { reportDirectory?: string; evidenceProducer?: boolean } = {}) {
+  if (process.platform !== 'linux') throw new Error('QA write observer unavailable: Linux inotify required');
+  if (fs.realpathSync(root) !== root) throw new Error('Observer root must be canonical');
+  let reportDirectory: string | undefined;
+  if (options.reportDirectory !== undefined) {
+    const directory = ownedPath(root, options.reportDirectory);
+    if (!fs.lstatSync(directory).isDirectory()) throw new Error('Observer report path must be an owned directory');
+    reportDirectory = path.relative(root, directory);
+  }
+  const transientFile = (relative: string) => qaWriteAllowed(relative, 'qa-only')
+    || (reportDirectory !== undefined && relative.startsWith(reportDirectory + path.sep));
+  const before = qaTreeSnapshot(root);
+  const { dlopen, FFIType, ptr } = await import('bun:ffi');
+  const libc = dlopen('libc.so.6', {
+    inotify_init1: { args: [FFIType.i32], returns: FFIType.i32 },
+    inotify_add_watch: { args: [FFIType.i32, FFIType.ptr, FFIType.u32], returns: FFIType.i32 },
+  });
+  const fd = libc.symbols.inotify_init1(0x800 | 0x80000);
+  if (fd < 0) { libc.close(); throw new Error('inotify initialization failed'); }
+  const watches = new Map<number, { relative: string; directory: boolean }>();
+  const events: QAWriteObservation['events'] = [];
+  const failures: string[] = [];
+  const publications = new Map<string, { temporary: string; dev: number; ino: number; bytes: string; parentDev: number; parentIno: number; mode: number }>();
+  let stopped = false;
+  const observedPath = (relative: string, knownPair = false): string => {
+    try {
+      if (knownPair) throw new Error('Fixture path traverses a link');
+      return relative ? ownedPath(root, relative) : root;
+    } catch (error) {
+      const basename = path.basename(relative);
+      const deadlineTemporary = /^\.qa-deadline-[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+      const evidence = options.evidenceProducer && relative.startsWith((reportDirectory ?? 'qa-reports') + path.sep)
+        ? /^(exploration-\d{3}\.json|evidence\.json|receipt\.json)(?:\.tmp\.[1-9]\d*\.[a-f0-9]{8})?$/.exec(basename) : null;
+      const isDeadline = basename === 'deadline.json' || deadlineTemporary.test(basename);
+      const targetName = isDeadline ? 'deadline.json' : evidence?.[1];
+      const mode = isDeadline ? 0o400 : 0o600;
+      const temporaryName = isDeadline ? deadlineTemporary : new RegExp(`^${targetName?.replaceAll('.', '\\.')}\\.tmp\\.[1-9]\\d*\\.[a-f0-9]{8}$`);
+      if (!/^(?:reports|qa-reports|\.qa-state)\//.test(relative)
+        || !targetName || (!isDeadline && targetName === 'receipt.json' && !/\/\.qa-evidence\/\d{3}\//.test(relative))) throw error;
+      const parent = ownedPath(root, path.dirname(relative));
+      const parentStat = fs.lstatSync(parent);
+      const target = path.join(parent, targetName);
+      let receipt: number | undefined;
+      try {
+        receipt = fs.openSync(target, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK);
+        const entry = fs.fstatSync(receipt);
+        if (!parentStat.isDirectory() || parentStat.uid !== fs.lstatSync(root).uid
+          || !entry.isFile() || entry.uid !== parentStat.uid || entry.nlink !== 2
+          || (entry.mode & 0o777) !== mode || entry.size > (isDeadline ? 4096 : 8 * 1024 * 1024)) throw error;
+        const aliases = fs.readdirSync(parent).filter(name => {
+          if (!temporaryName.test(name)) return false;
+          const alias = fs.lstatSync(path.join(parent, name), { throwIfNoEntry: false });
+          return alias?.isFile() && alias.dev === entry.dev && alias.ino === entry.ino && alias.nlink === 2;
+        });
+        if (aliases.length !== 1 || (basename !== targetName && basename !== aliases[0])) throw error;
+        const bytes = fs.readFileSync(receipt, 'utf8');
+        const state = JSON.parse(bytes);
+        const canonicalUTC = (value: unknown) => typeof value === 'string' && Number.isFinite(Date.parse(value))
+          && [new Date(value).toISOString(), new Date(value).toISOString().replace('.000Z', 'Z')].includes(value);
+        if (isDeadline && (!state || Object.keys(state).sort().join(',') !== 'budgetMs,deadlineAt,startedAt,version'
+          || state.version !== 1 || !Number.isSafeInteger(state.budgetMs) || state.budgetMs <= 0 || state.budgetMs > 2_147_483_647
+          || !canonicalUTC(state.startedAt) || !canonicalUTC(state.deadlineAt)
+          || Date.parse(state.deadlineAt) > Date.parse(state.startedAt) + state.budgetMs)) throw error;
+        if (!isDeadline && (!state || typeof state !== 'object' || Array.isArray(state))) throw error;
+        if (targetName.startsWith('exploration-') && Object.keys(state).sort().join(',') !== 'hypothesis,nextCommand,observationCommand,observed') throw error;
+        if (targetName === 'receipt.json' && (state.version !== 1 || !/^\d{3}$/.test(state.id) || !['complete', 'incomplete', 'sensitive'].includes(state.status))) throw error;
+        if (targetName === 'evidence.json' && (!Array.isArray(state.evidence) || !Array.isArray(state.limits))) throw error;
+        const final = fs.lstatSync(target);
+        if (!final.isFile() || final.dev !== entry.dev || final.ino !== entry.ino || ![1, 2].includes(final.nlink)
+          || (final.mode & 0o777) !== mode) throw error;
+        const relativeTarget = path.relative(root, target);
+        const publication = { temporary: path.join(path.dirname(relative), aliases[0]), dev: entry.dev, ino: entry.ino,
+          bytes, parentDev: parentStat.dev, parentIno: parentStat.ino, mode };
+        const previous = publications.get(relativeTarget);
+        if (previous && JSON.stringify(previous) !== JSON.stringify(publication)) throw error;
+        publications.set(relativeTarget, publication);
+        return target;
+      } catch (publicationError) {
+        try { return ownedPath(root, relative); } catch { throw publicationError; }
+      } finally { if (receipt !== undefined) fs.closeSync(receipt); }
+    }
+  };
+  const add = (relative: string, fileHint = false) => {
+    if (fileHint && transientFile(relative)) {
+      const parent = ownedPath(root, path.dirname(relative));
+      const entry = fs.lstatSync(path.join(parent, path.basename(relative)), { throwIfNoEntry: false });
+      if (entry?.isSymbolicLink() || (entry?.isFile() && entry.nlink > 2)) throw new Error('Fixture path traverses a link');
+      if (entry?.isFile() && entry.nlink === 2) observedPath(relative, true);
+      return;
+    }
+    const file = observedPath(relative);
+    const entry = fs.lstatSync(file);
+    if (entry.isFile() && transientFile(relative)) return;
+    const name = Buffer.from(file + '\0');
+    const wd = libc.symbols.inotify_add_watch(fd, ptr(name), 0x00000fce);
+    if (wd < 0) throw new Error(`Could not watch ${relative}`);
+    watches.set(wd, { relative: path.relative(root, file), directory: entry.isDirectory() });
+    if (entry.isDirectory()) for (const child of fs.readdirSync(file, { withFileTypes: true })) {
+      add(path.join(relative, child.name), child.isFile());
+    }
+  };
+  const consume = (records: ReturnType<typeof decodeQAInotify>) => {
+    for (const record of records) {
+      if (record.mask & 0x4000) { failures.push('kernel queue overflow'); continue; }
+      const watched = watches.get(record.wd);
+      if (!watched) { failures.push('event for unknown watch'); continue; }
+      const relative = path.join(watched.relative, record.name);
+      if (record.mask & 0x8000) {
+        if (watched.directory) failures.push(`directory watch lost: ${relative}`);
+        watches.delete(record.wd);
+        continue;
+      }
+      events.push({ path: relative === '.' ? '' : relative, mask: record.mask, cookie: record.cookie, at: Date.now() });
+      if ((record.mask & 0x2000) || (watched.directory && (record.mask & 0x800))) failures.push(`watch target moved or unmounted: ${relative}`);
+      if (record.mask & (0x100 | 0x80)) {
+        try {
+          const directory = !!(record.mask & 0x40000000);
+          if (!directory && transientFile(relative)) add(relative, true);
+          else {
+            const target = observedPath(relative);
+            if (fs.existsSync(target)) add(path.relative(root, target), !directory);
+            else if (directory) failures.push(`new directory vanished before watch: ${relative}`);
+          }
+        } catch (error) { failures.push(String(pathFailure(root, relative, error))); }
+      }
+    }
+  };
+  const drain = () => {
+    const buffer = Buffer.alloc(64 * 1024);
+    try {
+      for (;;) {
+        let count: number;
+        try { count = fs.readSync(fd, buffer, 0, buffer.length, null); }
+        catch (error) { if ((error as NodeJS.ErrnoException).code === 'EAGAIN') break; throw error; }
+        if (!count) throw new Error('kernel event stream closed');
+        consume(decodeQAInotify(buffer.subarray(0, count)));
+      }
+    } catch (error) { failures.push(String(error)); }
+  };
+  try { add(''); } catch (error) { fs.closeSync(fd); libc.close(); throw error; }
+  const timer = setInterval(drain, 10);
+  const checkpoint = ownedPath(root, '.qa-state/.observer-check');
+  fs.writeFileSync(checkpoint, 'start');
+  drain();
+  if (!events.some(event => event.path === '.qa-state/.observer-check')) failures.push('start marker was not observed');
+  return {
+    drain,
+    injectKernelRecordsForTest: (bytes: Buffer) => {
+      try { consume(decodeQAInotify(bytes)); } catch (error) { failures.push(String(error)); }
+    },
+    stop(): QAWriteObservation {
+      if (stopped) throw new Error('Observer already stopped');
+      stopped = true;
+      clearInterval(timer);
+      const previous = events.length;
+      try { fs.writeFileSync(checkpoint, 'stop'); } catch (error) { failures.push(String(error)); }
+      drain();
+      if (!events.slice(previous).some(event => event.path === '.qa-state/.observer-check')) failures.push('stop marker was not observed');
+      for (const [relative, publication] of publications) {
+        try {
+          const target = ownedPath(root, relative);
+          const temporary = ownedPath(root, publication.temporary);
+          const parent = fs.lstatSync(ownedPath(root, path.dirname(relative)));
+          const entry = fs.lstatSync(target);
+          if (fs.existsSync(temporary) || entry.dev !== publication.dev || entry.ino !== publication.ino || entry.nlink !== 1
+            || (entry.mode & 0o777) !== publication.mode || parent.dev !== publication.parentDev || parent.ino !== publication.parentIno
+            || fs.readFileSync(target, 'utf8') !== publication.bytes) throw new Error('Evidence publication did not settle unchanged');
+        } catch (error) { failures.push(String(pathFailure(root, relative, error))); }
+      }
+      let after: Record<string, string> = {};
+      try { after = qaTreeSnapshot(root); } catch (error) { failures.push(String(error)); }
+      fs.closeSync(fd);
+      libc.close();
+      const changed = [...new Set([...Object.keys(before), ...Object.keys(after)])].filter(file => before[file] !== after[file]);
+      return { complete: failures.length === 0, failures, events, changed, before, after, limits: [...QA_OBSERVER_LIMITS] };
+    },
+  };
+}
+
+export function qaWriteVerdict(observation: QAWriteObservation, mode: QAMode): string[] {
+  const failures = [...observation.failures];
+  if (!observation.complete) failures.push('incomplete write observation');
+  for (const file of new Set([...observation.events.map(event => event.path), ...observation.changed])) {
+    if (!qaWriteAllowed(file, mode)) failures.push(`forbidden ${mode} write: ${file}`);
+  }
+  return failures;
+}
+
+export function qaCommandAllowed(command: string, root?: string): boolean {
+  const producer = root ? qaEvidenceCommand(command, { cwd: root, reportRoot: path.join(root, 'qa-reports'), executable: path.join(root, 'bin/gstack-qa-evidence') }) : undefined;
+  if (producer) {
+    try { ownedPath(root!, 'bin/gstack-qa-evidence'); } catch { return false; }
+    return producer.action !== 'capture' || producer.timeoutMs === 10000 && /^bun (?:run probe -- |cancel\.ts$)/.test(producer.nativeCommand!) && qaCommandAllowed(producer.nativeCommand!);
+  }
+  if (/[\n\r;&|<>`$\\(){}]/.test(command)) return false;
+  if (command === 'date -u +%Y-%m-%dT%H:%M:%SZ') return true;
+  const text = command.trim();
+  return /^(?:pwd|ls(?: -la)?|git (?:status --(?:short|porcelain)|branch --show-current|diff(?: --stat)?|rev-parse HEAD)|bun (?:--version|cancel\.ts|test(?: test\/[a-zA-Z0-9_.-]+\.test\.ts)*))$/.test(text)
+    || /^bun run (?:cli|probe) -- (?:balance|export|apply(?: (?:[a-zA-Z0-9_.+-]+|'[a-zA-Z0-9_.+ -]*'|"[a-zA-Z0-9_.+ -]*")){0,3})$/.test(text)
+    || /^bun run probe -- (?:happy|reject|duplicate|partial|concurrent-ab|concurrent-ba|cancel|dependency)$/.test(text);
+}
+
+export function qaCommandPermission(root: string, event: any) {
+  let allowed = false;
+  try {
+    allowed = path.isAbsolute(root) && fs.realpathSync(root) === root
+      && event?.hook_event_name === 'PreToolUse' && event.cwd === root && event.tool_name === 'Bash'
+      && typeof event.tool_input?.command === 'string'
+      && [undefined, false].includes(event.tool_input.run_in_background)
+      && qaCommandAllowed(event.tool_input.command, root);
+  } catch {}
+  return { hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: allowed ? 'allow' : 'deny',
+    ...(!allowed ? { permissionDecisionReason: 'Only foreground commands from the owned functional fixture interface are authorized.' } : {}) } };
+}
+
+if (import.meta.main) {
+  let event: unknown;
+  try { event = JSON.parse(await Bun.stdin.text()); } catch {}
+  console.log(JSON.stringify(qaCommandPermission(process.argv[2], event)));
+}

test/helpers/qa-only-cleanup.ts

@@ -0,0 +1,140 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { isProcessAlive } from '../../browse/src/error-handling';
+import { readPidCmdline, readPidStartTime } from '../../browse/src/xvfb';
+import { isAgentRecordGone, isOurAgent, readAgentRecord } from '../../browse/src/terminal-agent-control';
+
+export async function stopQaOnlyBrowser(directory: string, timeoutMs: number): Promise<void> {
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 100) throw new Error('QA-only browser cleanup: no settlement budget remains; retaining fixture');
+  const worker = Bun.spawn([process.execPath, import.meta.path, directory, String(timeoutMs - 100)], {
+    stdout: 'ignore', stderr: 'pipe',
+  });
+  let timedOut = false;
+  const timer = setTimeout(() => { timedOut = true; worker.kill('SIGKILL'); }, timeoutMs);
+  const stderr = new Response(worker.stderr).text();
+  try {
+    const code = await worker.exited;
+    const error = await stderr;
+    if (timedOut) throw new Error('QA-only browser cleanup: owned worker settlement deadline exceeded; retaining fixture');
+    if (code !== 0) throw new Error(error.trim() || `QA-only browser cleanup: worker exited ${code}; retaining fixture`);
+  } finally { clearTimeout(timer); }
+}
+
+async function settleOwnedBrowser(directory: string, timeoutMs: number): Promise<void> {
+  const started = performance.now();
+  const deadline = started + timeoutMs;
+  let pending = ['identity verification'];
+  const fail = (message: string): never => { throw new Error(`QA-only browser cleanup: ${message}`); };
+  const remaining = () => {
+    const ms = Math.floor(deadline - performance.now());
+    if (ms <= 0) fail(`owned process settlement deadline exceeded (${pending.join(', ')}); retaining fixture`);
+    return ms;
+  };
+  if (fs.lstatSync(directory).isSymbolicLink()) fail('fixture directory is a link');
+  const root = fs.realpathSync(directory);
+  const stateDir = path.join(root, '.gstack');
+  if (!fs.existsSync(stateDir)) return;
+  if (fs.lstatSync(stateDir).isSymbolicLink()) fail('state directory is a link');
+  const stateFile = path.join(stateDir, 'browse.json');
+  const agentFile = path.join(stateDir, 'terminal-agent-pid');
+  for (const file of [stateFile, agentFile]) {
+    if (fs.existsSync(file) && !fs.lstatSync(file).isFile()) fail('state record is not a regular file');
+  }
+  if (!fs.existsSync(stateFile)) {
+    if (fs.existsSync(agentFile)) fail('terminal record has no daemon state');
+    return;
+  }
+  const raw = fs.readFileSync(stateFile, 'utf8');
+  const state = JSON.parse(raw);
+  if (!Number.isSafeInteger(state.pid) || state.pid <= 1
+    || typeof state.instanceId !== 'string' || !state.instanceId) fail('invalid daemon identity');
+  const agentRaw = fs.existsSync(agentFile) ? fs.readFileSync(agentFile, 'utf8') : undefined;
+  const agent = readAgentRecord(stateDir);
+  if (!agentRaw || !agent) fail('terminal identity is unavailable');
+  if (!isProcessAlive(state.pid)) fail('daemon exited before its owned processes could be identified');
+  const daemonStart = readPidStartTime(state.pid);
+  const command = readPidCmdline(state.pid);
+  if (!daemonStart || !(typeof state.serverPath === 'string' && command.includes(state.serverPath)
+    || command.includes('--server') && /browse/.test(command))) fail('daemon identity is unavailable');
+  let cwd: string;
+  if (process.platform === 'linux') cwd = fs.realpathSync(`/proc/${state.pid}/cwd`);
+  else {
+    const result = spawnSync('lsof', ['-a', '-p', String(state.pid), '-d', 'cwd', '-Fn'], {
+      encoding: 'utf8', timeout: Math.min(1000, remaining()),
+    });
+    if (result.error || result.status !== 0) fail('daemon working directory is unavailable');
+    cwd = result.stdout.split('\n').find(line => line.startsWith('n'))?.slice(1) ?? '';
+  }
+  if (cwd !== root) fail('daemon belongs to another fixture');
+  if (agent && (agent.ownerPid !== state.pid || agent.ownerStartTime !== daemonStart
+    || !isAgentRecordGone(agent) && !isOurAgent(agent, state.pid))) fail('terminal ownership is unconfirmed');
+  const processes = spawnSync('ps', ['-eo', 'pid=,ppid='], {
+    encoding: 'utf8', timeout: Math.min(1000, remaining()),
+  });
+  if (processes.error || processes.status !== 0) fail('owned child identities are unavailable');
+  const rows = processes.stdout.trim().split('\n').map(line => line.trim().split(/\s+/).map(Number));
+  const descendants = new Set<number>([state.pid]);
+  for (let previous = 0; previous !== descendants.size;) {
+    previous = descendants.size;
+    for (const [pid, parent] of rows) if (descendants.has(parent)) descendants.add(pid);
+  }
+  const chromium = [...descendants].filter(pid => pid !== state.pid && /chrom|headless_shell/i.test(readPidCmdline(pid)))
+    .map(pid => ({ pid, start: readPidStartTime(pid) }));
+  if (!chromium.length || chromium.some(child => !child.start)) fail('Chromium identity is unavailable');
+  if (state.chromiumPid !== undefined && !chromium.some(child => child.pid === state.chromiumPid
+    && child.start === state.chromiumStartTime)) fail('Chromium ownership is unconfirmed');
+  const unchanged = () => {
+    if (fs.existsSync(stateFile) && fs.readFileSync(stateFile, 'utf8') !== raw) fail('daemon state was replaced');
+    if (fs.existsSync(agentFile) && fs.readFileSync(agentFile, 'utf8') !== agentRaw) fail('terminal state was replaced');
+  };
+  unchanged();
+  if (readPidStartTime(state.pid) !== daemonStart || readPidCmdline(state.pid) !== command) fail('daemon identity changed before stop');
+  unchanged();
+  remaining();
+  try { process.kill(state.pid, 'SIGINT'); }
+  catch (error) { if ((error as NodeJS.ErrnoException).code !== 'ESRCH') throw error; }
+  const settled = (pid: number, start: string) => {
+    if (!isProcessAlive(pid)) return true;
+    const actual = readPidStartTime(pid);
+    if (actual && actual !== start) return true;
+    if (process.platform === 'linux') {
+      try { return fs.readFileSync(`/proc/${pid}/stat`, 'utf8').match(/^\d+ \(.*\) ([A-Z])/u)?.[1] === 'Z'; }
+      catch { return !isProcessAlive(pid); }
+    }
+    const result = spawnSync('ps', ['-p', String(pid), '-o', 'stat='], {
+      encoding: 'utf8', timeout: Math.min(1000, remaining()),
+    });
+    return result.status === 0 && result.stdout.trim().startsWith('Z');
+  };
+  for (;;) {
+    unchanged();
+    remaining();
+    pending = [
+      ...(!settled(state.pid, daemonStart) ? [`daemon ${state.pid}`] : []),
+      ...chromium.filter(child => !settled(child.pid, child.start)).map(child => `Chromium ${child.pid}`),
+      ...(agent && !isAgentRecordGone(agent) ? [`terminal ${agent.pid}`] : []),
+    ];
+    if (!pending.length) {
+      unchanged();
+      remaining();
+      return;
+    }
+    if (pending.length === 1 && pending[0] === `daemon ${state.pid}`
+      && performance.now() - started >= Math.min(1000, timeoutMs / 2)) {
+      if (readPidStartTime(state.pid) !== daemonStart || readPidCmdline(state.pid) !== command) fail('daemon identity changed before final termination');
+      unchanged();
+      try { process.kill(state.pid, 'SIGKILL'); }
+      catch (error) { if ((error as NodeJS.ErrnoException).code !== 'ESRCH') throw error; }
+    }
+    await Bun.sleep(Math.min(25, remaining()));
+  }
+}
+
+if (import.meta.main) {
+  try { await settleOwnedBrowser(process.argv[2], Number(process.argv[3])); }
+  catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+}

test/helpers/scratch-repo.ts

@@ -29,8 +29,8 @@ export function gitIn(repoDir: string, args: string): string {
 }
 
 /** Argv-array variant for callers that avoid shell quoting. */
-export function gitArgvIn(repoDir: string, args: string[], timeout = 5000) {
-  return spawnSync('git', [...GIT_HERMETIC_ARGS, ...args], { cwd: repoDir, timeout });
+export function gitArgvIn(repoDir: string, args: string[], timeout = 5000, env?: NodeJS.ProcessEnv) {
+  return spawnSync('git', [...GIT_HERMETIC_ARGS, ...args], { cwd: repoDir, timeout, env });
 }
 
 /** Create a scratch repo (mkdtemp) with an initial commit; caller cleans up. */

test/helpers/session-drain-policy.ts

@@ -0,0 +1 @@
+export const SESSION_DRAIN_GRACE_MS = 5_000;

test/helpers/session-runner.ts

@@ -65,14 +65,15 @@ export const STARTUP_GRACE_MS = 90_000;
  *  Pinned by test/session-runner-startup-grace.test.ts. */
 export const STARTUP_GRACE_CI_FLOOR_MS = 300_000;
 /** Existing pipe-drain allowance; never adds model work time. */
-export const SESSION_DRAIN_GRACE_MS = 5_000;
+export { SESSION_DRAIN_GRACE_MS } from './session-drain-policy';
+import { SESSION_DRAIN_GRACE_MS } from './session-drain-policy';
 
 const BROWSE_ERROR_PATTERNS = [
   /Unknown command: \w+/,
   /Unknown snapshot flag: .+/,
   /ERROR: browse binary not found/,
   /Server failed to start/,
-  /no such file or directory.*browse/i,
+  /no such file or directory.*\bbrowse(?:\.exe)?(?=$|[\s'":),])/i,
 ];
 
 // --- Testable NDJSON parser ---
@@ -247,6 +248,10 @@ export async function runSkillTest(options: {
   startupGraceMs?: number;
   /** Cancel the owned process group when an enclosing attempt expires. */
   signal?: AbortSignal;
+  nativeLifecycle?: {
+    onSpawn(pid: number): void;
+    onSettled(input: { deadline: number; exited: boolean }): Promise<void>;
+  };
 }): Promise<SkillTestResult> {
   const startTime = Date.now();
   options.signal?.throwIfAborted();
@@ -461,7 +466,7 @@ Before source Reads and after each saved checkpoint, use Bash to run exactly \`d
   phaseTimer = setTimeout(() => killRun(true), Math.max(0, startTime + startupGraceMs - Date.now()));
   proc.stdin!.on('error', () => { /* exit handling reports early child failure */ });
   if (signal?.aborted || Date.now() >= deadline) onAbort();
-  else proc.stdin!.end(prompt);
+  else if (!options.nativeLifecycle) proc.stdin!.end(prompt);
   /** Called once by the read loop on the first NDJSON byte. */
   const armWorkPhase = (elapsedMs: number): void => {
     clearTimeout(phaseTimer);
@@ -481,8 +486,11 @@ Before source Reads and after each saved checkpoint, use Bash to run exactly \`d
   const decoder = new TextDecoder();
   let buf = '';
   const projectLine = options.publicStreamDiagnostics ? publicStreamProjection(startTime) : (line: string) => line;
+  let lifecycleFailure: unknown;
 
   try {
+    options.nativeLifecycle?.onSpawn(proc.pid!);
+    if (options.nativeLifecycle && !signal?.aborted && Date.now() < deadline) proc.stdin!.end(prompt);
     try {
       while (true) {
         const { done, value } = await reader.read();
@@ -574,7 +582,36 @@ Before source Reads and after each saved checkpoint, use Bash to run exactly \`d
     }
 
     await Promise.race([Promise.all([procExited, stderrClosed]), forcedDrain]);
+  } catch (error) {
+    lifecycleFailure = error;
+    throw error;
   } finally {
+    if (options.nativeLifecycle) {
+      killProcessGroup(proc, 'SIGKILL');
+      closePipes();
+      armDrain();
+      try {
+        await Promise.race([procExited, forcedDrain]);
+        let hookTimer: ReturnType<typeof setTimeout> | undefined;
+        try {
+          await Promise.race([
+            options.nativeLifecycle.onSettled({ deadline: drainDeadline, exited: exitCode !== undefined && !processError }),
+            new Promise<never>((_, reject) => {
+              hookTimer = setTimeout(() => reject(new Error('native lifecycle settlement deadline exceeded')), Math.max(0, drainDeadline - Date.now()));
+            }),
+          ]);
+        } finally { clearTimeout(hookTimer); }
+      } catch (error) {
+        if (lifecycleFailure) throw new AggregateError([lifecycleFailure, error], 'native lifecycle failed');
+        throw error;
+      } finally {
+        clearTimeout(phaseTimer);
+        clearTimeout(drainTimer);
+        signal?.removeEventListener('abort', onAbort);
+        proc.removeListener('exit', onExit);
+        proc.stderr!.removeListener('data', onStderr);
+      }
+    }
     clearTimeout(phaseTimer);
     clearTimeout(drainTimer);
     signal?.removeEventListener('abort', onAbort);
@@ -605,8 +642,7 @@ Before source Reads and after each saved checkpoint, use Bash to run exactly \`d
   const { transcript, resultLine, toolCalls } = parsed;
   const browseErrors: string[] = [];
 
-  // Scan transcript + stderr for browse errors
-  const allText = transcript.map(e => JSON.stringify(e)).join('\n') + '\n' + stderr;
+  const allText = toolCalls.filter(call => call.tool === 'Bash').map(call => call.output).join('\n') + '\n' + stderr;
   for (const pattern of BROWSE_ERROR_PATTERNS) {
     const match = allText.match(pattern);
     if (match) {

test/helpers/shared-libs-eval-fixture.ts

@@ -6,6 +6,8 @@ import { createHash } from 'node:crypto';
 import { execFileSync } from 'node:child_process';
 import { extractSkillSections, sliceBetween } from './skill-fixture';
 import type { EvalCollector, EvalTestEntry } from './eval-store';
+import type { HookCallback } from '@anthropic-ai/claude-agent-sdk';
+import { SESSION_DRAIN_GRACE_MS } from './session-drain-policy';
 
 export const SHARED_LIBS_ROOT = path.resolve(import.meta.dir, '../..');
 export const SHARED_INTERACTIVE_MAX_TURNS = 30;
@@ -14,6 +16,8 @@ const nodeBin = Bun.which('node') || '/usr/bin/node';
 export const shellQuote = (value: string) => `'${value.replaceAll("'", "'\\''")}'`;
 
 export interface SharedCaptureAttempt {
+  readonly signal: AbortSignal;
+  remainingMs(): number;
   add(scenario: string, entry: EvalTestEntry): void;
 }
 
@@ -26,7 +30,9 @@ interface SharedAttemptState {
   error?: string;
   contractErrors: string[];
   deadline: number;
-  stopped?: 'deadline' | 'superseded';
+  controller: AbortController;
+  timer?: ReturnType<typeof setTimeout>;
+  stopped?: 'deadline' | 'superseded' | 'finalized';
 }
 
 /** Keep scenario groups within their test invocation; Bun retries are separate attempts. */
@@ -35,7 +41,13 @@ export class SharedCaptureAccumulator {
   private finalized = false;
 
   private expire(state: SharedAttemptState): void {
-    if (!state.closed && !state.stopped && performance.now() >= state.deadline) state.stopped = 'deadline';
+    if (!state.closed && !state.stopped && performance.now() >= state.deadline) this.stop(state, 'deadline');
+  }
+
+  private stop(state: SharedAttemptState, reason: NonNullable<SharedAttemptState['stopped']>): void {
+    state.stopped ??= reason;
+    clearTimeout(state.timer);
+    state.controller.abort(new Error(`Shared capture attempt ${state.name} stopped: ${state.stopped}`));
   }
 
   async runAttempt<T>(name: string, expected: readonly string[], timeoutMs: number,
@@ -47,12 +59,14 @@ export class SharedCaptureAccumulator {
     for (const previous of this.attempts) {
       if (previous.name === name && !previous.closed) {
         this.expire(previous);
-        previous.stopped ??= 'superseded';
+        this.stop(previous, 'superseded');
       }
     }
     const state: SharedAttemptState = { name, expected: [...expected], rows: [], closed: false,
-      rejected: false, contractErrors: [], deadline: performance.now() + timeoutMs };
+      rejected: false, contractErrors: [], controller: new AbortController(),
+      deadline: performance.now() + timeoutMs - Math.min(SESSION_DRAIN_GRACE_MS, timeoutMs / 10) };
     this.attempts.push(state);
+    state.timer = setTimeout(() => this.stop(state, 'deadline'), Math.max(0, state.deadline - performance.now()));
     const checkActive = () => {
       this.expire(state);
       if (state.closed || this.finalized || state.stopped) {
@@ -62,7 +76,9 @@ export class SharedCaptureAccumulator {
     let result: T;
     let thrown: unknown;
     try {
-      result = await work({ add: (scenario, entry) => {
+      result = await work({ signal: state.controller.signal,
+        remainingMs: () => { checkActive(); return Math.max(0, state.deadline - performance.now()); },
+        add: (scenario, entry) => {
         checkActive();
         const duplicate = state.rows.some(row => row.scenario === scenario);
         state.rows.push({ scenario, entry });
@@ -87,6 +103,8 @@ export class SharedCaptureAccumulator {
     } finally {
       this.expire(state);
       state.closed = true;
+      clearTimeout(state.timer);
+      state.controller.abort(new Error(`Shared capture attempt ${name} closed`));
     }
     // Bun owns the timeout verdict and detaches that invocation's promise.
     // A late rejection becomes an unrelated error even with a catch attached.
@@ -106,6 +124,10 @@ export class SharedCaptureAccumulator {
   async finalize(collector: EvalCollector | null): Promise<void> {
     if (this.finalized) return;
     this.finalized = true;
+    for (const state of this.attempts) {
+      this.expire(state);
+      if (!state.closed) this.stop(state, 'finalized');
+    }
     if (!collector) return;
     for (const state of this.attempts) {
       this.expire(state);
@@ -126,7 +148,7 @@ export class SharedCaptureAccumulator {
         output: rows.map((row, index) => `Scenario ${index + 1} (${row.passed ? 'passed' : 'failed'}):\n${row.output || ''}`).join('\n\n'),
         error: [...new Set(errors)].join('\n') || undefined,
         exit_reason: passed ? 'success' : state.stopped === 'deadline' ? 'timeout'
-          : state.stopped === 'superseded' || !state.closed ? 'attempt_incomplete' : state.contractErrors.length ? 'capture_contract'
+          : state.stopped || !state.closed ? 'attempt_incomplete' : state.contractErrors.length ? 'capture_contract'
           : failed ? (failed.exit_reason === 'success' ? 'assertion_failed' : failed.exit_reason || 'capture_threw')
           : state.rejected ? 'fixture_threw' : 'attempt_incomplete',
       });
@@ -146,10 +168,14 @@ export interface SharedLibsFixture {
   env: Record<string, string>;
 }
 
+function fixtureGitConfig(f: SharedLibsFixture): string {
+  return process.platform === 'win32' ? path.join(f.root, 'gitconfig') : os.devNull;
+}
+
 export function fixtureGit(f: SharedLibsFixture, ...args: string[]): string {
   return execFileSync(gitBin, ['-c', 'core.fsmonitor=false', ...args], {
     cwd: f.repo, encoding: 'utf8', timeout: 10_000,
-    env: { ...process.env, GIT_CONFIG_NOSYSTEM: '1', GIT_CONFIG_GLOBAL: os.devNull },
+    env: { ...process.env, GIT_CONFIG_NOSYSTEM: '1', GIT_CONFIG_GLOBAL: fixtureGitConfig(f) },
     stdio: ['ignore', 'pipe', 'pipe'],
   }).trim();
 }
@@ -168,6 +194,7 @@ export function createSharedLibsFixture(label: string): SharedLibsFixture {
     hookTrace: path.join(root, 'hooks.log'), tip: '', env: {},
   };
   for (const dir of [f.repo, f.state, f.bin]) fs.mkdirSync(dir);
+  if (process.platform === 'win32') fs.writeFileSync(fixtureGitConfig(f), '', { mode: 0o600 });
   fixtureGit(f, 'init', '-b', 'main');
   fixtureGit(f, 'config', 'user.name', 'Shared Libs Fixture');
   fixtureGit(f, 'config', 'user.email', 'shared-libs@example.invalid');
@@ -180,7 +207,7 @@ export function createSharedLibsFixture(label: string): SharedLibsFixture {
   f.env = {
     PATH: `${f.bin}${path.delimiter}${process.env.PATH || ''}`,
     GSTACK_HOME: f.state,
-    GIT_CONFIG_NOSYSTEM: '1', GIT_CONFIG_GLOBAL: os.devNull,
+    GIT_CONFIG_NOSYSTEM: '1', GIT_CONFIG_GLOBAL: fixtureGitConfig(f),
     GH_PROMPT_DISABLED: '1', NO_COLOR: '1',
   };
   return f;
@@ -464,7 +491,7 @@ export function installSourceShims(f: SharedLibsFixture, opts: {
     fixtureGit(f, 'add', 'src/retry-worker.ts', 'docs');
     execFileSync(gitBin, ['-c', 'core.fsmonitor=false', 'commit', '-m', 'reuse the existing parser in retry worker'], {
       cwd: f.repo, encoding: 'utf8', timeout: 30_000, stdio: ['ignore', 'pipe', 'pipe'],
-      env: { ...process.env, GIT_CONFIG_NOSYSTEM: '1', GIT_CONFIG_GLOBAL: os.devNull,
+      env: { ...process.env, GIT_CONFIG_NOSYSTEM: '1', GIT_CONFIG_GLOBAL: fixtureGitConfig(f),
         GIT_AUTHOR_DATE: '2020-01-01T00:00:00Z', GIT_COMMITTER_DATE: '2020-01-01T00:00:00Z' },
     });
     prHead = fixtureGit(f, 'rev-parse', 'HEAD');
@@ -485,19 +512,26 @@ const r=cp.spawnSync(${JSON.stringify(gitBin)},a,{stdio:'inherit',env:process.en
 `, { mode: 0o755 });
   const sourceAt = (revision: string) => {
     const files: Record<string, string> = {}, blobs: Record<string, string> = {};
-    for (const entry of fixtureGit(f, 'ls-tree', '-r', revision).split('\n')) {
-      const match = entry.match(/^\d+ blob ([a-f0-9]+)\t(.+)$/);
-      if (!match) continue;
-      const [, blob, file] = match;
-      // Contents API returns the exact committed blob, including whitespace and
-      // final-newline state. Its sha field identifies that blob, not its commit.
-      const bytes = execFileSync(gitBin, ['-c', 'core.fsmonitor=false', '-c', 'log.showSignature=false', 'cat-file', 'blob', blob], {
-        cwd: f.repo, timeout: 10_000, stdio: ['ignore', 'pipe', 'pipe'],
-        env: { ...process.env, GIT_CONFIG_NOSYSTEM: '1', GIT_CONFIG_GLOBAL: os.devNull },
-      });
+    const entries = fixtureGit(f, 'ls-tree', '-r', revision).split('\n')
+      .flatMap(entry => { const match = entry.match(/^\d+ blob ([a-f0-9]+)\t(.+)$/); return match ? [[match[1], match[2]]] : []; });
+    const batch = entries.length ? execFileSync(gitBin, ['-c', 'core.fsmonitor=false', '-c', 'log.showSignature=false', 'cat-file', '--batch'], {
+      cwd: f.repo, timeout: 10_000, input: entries.map(([blob]) => blob).join('\n') + '\n',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: { ...process.env, GIT_CONFIG_NOSYSTEM: '1', GIT_CONFIG_GLOBAL: fixtureGitConfig(f) },
+    }) : Buffer.alloc(0);
+    let offset = 0;
+    for (const [blob, file] of entries) {
+      const headerEnd = batch.indexOf(10, offset);
+      const header = batch.subarray(offset, headerEnd).toString().split(' ');
+      const size = Number(header[2]);
+      if (headerEnd < offset || header[0] !== blob || header[1] !== 'blob' || !Number.isSafeInteger(size)
+        || size < 0 || batch[headerEnd + 1 + size] !== 10) throw new Error('Invalid fixture blob batch');
+      const bytes = batch.subarray(headerEnd + 1, headerEnd + 1 + size);
+      offset = headerEnd + 2 + size;
       files[file] = bytes.toString('base64');
       blobs[file] = blob;
     }
+    if (offset !== batch.length) throw new Error('Unexpected fixture blob batch remainder');
     return { files, blobs };
   };
   const sources = Object.fromEntries([...new Set([f.tip, prHead, branchHead])]
@@ -575,7 +609,7 @@ export function installHostileGitConfig(f: SharedLibsFixture): void {
   const signedCommit = commit.replace('\n\n', '\ngpgsig -----BEGIN PGP SIGNATURE-----\n dummy\n -----END PGP SIGNATURE-----\n\n') + '\n';
   const signedTip = execFileSync(gitBin, ['hash-object', '-t', 'commit', '-w', '--stdin'], {
     cwd: f.repo, input: signedCommit, encoding: 'utf8', timeout: 10_000,
-    env: { ...process.env, GIT_CONFIG_NOSYSTEM: '1', GIT_CONFIG_GLOBAL: os.devNull },
+    env: { ...process.env, GIT_CONFIG_NOSYSTEM: '1', GIT_CONFIG_GLOBAL: fixtureGitConfig(f) },
   }).trim();
   fixtureGit(f, 'update-ref', 'HEAD', signedTip);
   refreshFixtureTip(f);
@@ -664,12 +698,10 @@ export function reviewLifecycleInstructions(f: SharedLibsFixture): string {
   ]);
   const army = fs.readFileSync(path.join(root, 'review/sections/review-army.md'), 'utf8');
   const merge = sliceBetween(army, '### Step 4.6: Collect and merge findings', '### Red Team dispatch');
-  const adversarial = fs.readFileSync(path.join(root, 'review/sections/adversarial.md'), 'utf8');
-  const completion = adversarial.slice(adversarial.indexOf('### Before persisting Eng Review (Step 5.8)'));
-  if (!completion.startsWith('### Before persisting')) throw new Error('Missing actual review completion rules');
+  if (!core.includes('snapshot_covered_paths') || !core.includes('COMPLETED')
+    || !core.includes('--finish REVIEW_START')) throw new Error('Missing actual review completion rules');
   // Insert the actual merge text before Fix-First, retaining core ownership for tiny diffs.
   const text = core.replace('## Step 5: Fix-First Review', `${merge}\n\n## Step 5: Fix-First Review`)
-    .replace('## Step 5.8: Persist Eng Review result', `${completion}\n\n## Step 5.8: Persist Eng Review result`)
     .replaceAll('~/.claude/skills/gstack', root)
     .replaceAll('$HOME/.claude/skills/gstack', root)
     .replaceAll('origin/<base>', 'origin/main');
@@ -715,57 +747,95 @@ export function specialistFixture(f: SharedLibsFixture): string {
   return file;
 }
 
-export function reviewPrompt(f: SharedLibsFixture, instructions: string, specialistInput: string): string {
+export interface SharedReviewResume {
+  input: string;
+  checkCommand: string;
+}
+
+export interface SharedReviewStageActor {
+  actorCommand: string;
+  hooks: { PreToolUse: Array<{ hooks: HookCallback[] }> };
+  history(): any[];
+  verify(events: any[]): boolean;
+}
+
+export function reviewPrompt(f: SharedLibsFixture, instructions: string, specialistInput: string, resumed?: SharedReviewResume | Pick<SharedReviewStageActor, 'actorCommand'>): string {
+  const scope = resumed && 'actorCommand' in resumed ? `This is an edit-capable component replay with an explicitly declared SYNTHETIC prerequisite actor, not an end-to-end QA/adversarial evaluation. Completed maintainability findings are supplied in ${specialistInput}; verify them against real source.
+Component scope override for every pass:
+1. Execute the real core/checklist, source/identity/snapshot checks, merge, Fix-First decisions, approved source edits, re-review with a new REVIEW_START, zero-edit convergence and final persistence yourself. Preserve the workflow's permissions and decision questions.
+2. The actor invocation below replaces the entire Step 4.7 QA and Step 4.8 native adversarial stages, not just an extra prerequisite after executing them. This replacement also covers Step 4's early QA selection/method-loading prerequisites and Step 5.8's QA report requirement. Do not perform QA scope/method asset loads, browser setup, charters, exploratory probes, checkpoints or QA reports in this component replay. Do not dispatch native reviewers, other specialists or outside providers. Existing tests and caller/import checks needed to verify your source fixes still run; they are not simulated, but do not restart exploratory QA or require QA artifacts.
+3. After core review and merge, before Fix-First on each review pass, invoke the following as the sole command in its Bash call. The registered fixture actor checks fixture isolation and authored evidence/identity and returns a NEW synthetic result bound to that exact current state and tool-use ID. It never executes target code. Read and consume the complete returned JSON, not a previously saved receipt.
+\`\`\`sh
+${resumed.actorCommand}
+\`\`\`
+4. All prior receipts are preserved. Source-changing cycles invalidate earlier results: after edits, repeat the core review and invoke the actor again on the new zero-edit pass before final persistence. Never refresh an old receipt's hashes or relabel it as a new invocation. Missing, failed, stale or wrong-state results require noncompletion. The actor cannot complete core/checklist review, approve edits, answer decision questions or establish convergence for you. Apply the production COMPLETED/CONVERGED rules to your own work plus the current supplied results; never ask the question actor to override completion.
+5. In the final QA/verification summary, identify the actor results as simulated fixture-stage interactions, not actual QA or native adversarial execution; they receive no actual native coverage credit. Report any real post-fix verification separately. Separate genuine QA/native evaluations remain required; this component replay cannot satisfy them.`
+    : resumed ? `This is a bounded, no-edit resumed-stage fixture. The completed maintainability result is supplied in ${specialistInput}; verify its findings against real source. Read ${resumed.input}: it supplies clearly labeled SYNTHETIC settled Step 4.7 QA and Step 4.8 native adversarial prerequisite results for this isolated fixture state, not evidence that this model executed those stages and never actual native coverage credit. Other specialists and outside providers are not dispatched in this fixture. Do not dispatch or rerun them.
+Execute the core/checklist, merge, Fix-First decisions, source/identity/snapshot checks and final persistence yourself. Do not edit target source or Git index flags. A finding that requires edits blocks this bounded replay: report it honestly, without suppressing it or claiming completion. Before final persistence, after your final source checks, run this fixture prerequisite check as the sole command in its Bash call and inspect the entire JSON result:
+\`\`\`sh
+${resumed.checkCommand}
+\`\`\`
+Only a current result with settled:true supplies the required QA and native adversarial prerequisites; it does not complete your own remaining work. Apply the workflow's unchanged COMPLETED and CONVERGED rules to that combined evidence. Missing, failed, blocked, malformed or stale prerequisites require noncompletion, never an override based on scope. Any source, branch, base, index or configuration change invalidates these supplied results and blocks this bounded no-edit replay; do not regenerate them or claim completion. In the final summary identify QA and native adversarial results as synthetic fixture inputs, not stages you executed.`
+    : `This is a fixture of the core, merge, Fix-First, and final persistence stages. Specialist input for the merge stage is supplied in ${specialistInput}; verify it against the real source. Do not dispatch additional specialists or outside providers. Never claim that omitted stages completed.
+Required reviewer coverage for this scoped replay is the core/checklist review plus the supplied completed maintainability result. Verify the supplied findings against actual source. Other specialist and provider stages are outside this invocation's scope, not unavailable required reviewers. If a required stage or its result actually fails or is missing, preserve the workflow's non-completion rules.`;
   return `Read the fixture workflow at ${instructions} first. Review this repository's current diff against origin/main using that workflow and the actual checklist at ${SHARED_LIBS_ROOT}/review/checklist.md.
-This is a fixture of the core, merge, Fix-First, and final persistence stages. Specialist input for the merge stage is supplied in ${specialistInput}; verify it against the real source. Do not dispatch additional specialists or outside providers. Never claim that omitted stages completed.
-Required reviewer coverage for this scoped replay is the core/checklist review plus the supplied completed maintainability result. Verify the supplied findings against actual source. Other specialist and provider stages are outside this invocation's scope, not unavailable required reviewers. If a required stage or its result actually fails or is missing, preserve the workflow's non-completion rules.
-The installed gstack helpers under ${SHARED_LIBS_ROOT}/bin and ${SHARED_LIBS_ROOT}/lib, plus the provider wrappers under ${f.bin}, are trusted harness infrastructure. Invoke their required interfaces; auditing their implementation or the fixture request logs is outside the target review. Still inspect target repository source, Git configuration and attributes, actual snapshot coverage, and prior/final persisted review records as the workflow requires.
-Execute the included workflow, including its real start captures, decision questions, any approved edits, convergence checks and final review record. The user will answer AskUserQuestion. This is a code review, not a standalone recent-history audit. Return the final review summary in conversation.`;
+${scope}
+The trusted harness infrastructure is fixed; do not rediscover it:
+- Trusted asset roots: the installed review skill is ${SHARED_LIBS_ROOT}/review (checklist ${SHARED_LIBS_ROOT}/review/checklist.md, sections ${SHARED_LIBS_ROOT}/review/sections/). Resolve any path the workflow gives relative to the installed /review SKILL.md directory under ${SHARED_LIBS_ROOT}, so ../qa/sections/<name>.md is ${SHARED_LIBS_ROOT}/qa/sections/<name>.md. The gstack helpers are under ${SHARED_LIBS_ROOT}/bin and ${SHARED_LIBS_ROOT}/lib; the provider wrappers git, gh and curl are under ${f.bin}.
+- Documented helper interfaces, used as-is: \`gstack-review-log --start review\`; \`gstack-review-log --check-shared-libs REVIEW_START\` with the finding on stdin; \`gstack-review-log '<record>' --finish REVIEW_START\`; and \`gstack-review-read\`.
+- Out of scope: do not audit helper or lib implementations, read the fixture request logs, enumerate the bin/lib/review/qa roots, probe --help or other CLI options, or review unrelated history.
+- Still inspect the target repository source, Git configuration and attributes, actual snapshot coverage, and the prior and final persisted review records the workflow requires.
+- To stay within the turn budget, batch independent reads into as few Read or Bash calls as correctness allows, but keep receipt-ordered commands separate and in order: capture the start token before reading the diff, and run --start, the checker and any declared stage-actor invocation each as its own sole command. The only combined receipt call is the final persistence: run \`gstack-review-log '<record>' --finish REVIEW_START\` and, only after it succeeds, its full \`gstack-review-read\` read-back in that same call.
+Execute the included workflow, including its real start captures, decision questions, ${resumed && !('actorCommand' in resumed) ? 'zero-edit convergence checks' : 'any approved edits, convergence checks'} and final review record. The user will answer AskUserQuestion. This is a code review, not a standalone recent-history audit. Return the final review summary in conversation.`;
 }
 
 /** The revalidation replay measures the review lifecycle, not helper CLI discovery. */
-export function reviewRevalidationPrompt(f: SharedLibsFixture, instructions: string, specialistInput: string): string {
+export function reviewRevalidationPrompt(f: SharedLibsFixture, instructions: string, specialistInput: string, resumed?: SharedReviewResume): string {
   const startRecord = path.join(f.state, 'projects/fixture-shared-libs/.review-starts/<REVIEW_START>.json');
-  return `${reviewPrompt(f, instructions, specialistInput)}
+  return `${reviewPrompt(f, instructions, specialistInput, resumed)}
 
 Revalidation fixture execution contract:
-- The runtime allows ${SHARED_INTERACTIVE_MAX_TURNS} assistant turns. Batch independent required source reads, Git configuration/attribute checks, and snapshot checks within each phase. Preserve every required evidence check and dependency: capture the real start token before reading the diff, and complete final evidence verification before persistence.
-- The trusted start-record location is ${startRecord}. Replace <REVIEW_START> with the token actually returned by --start. Read that token's record in a separate, successful Read tool call or a single cat command before continuing. Verify its repo, branch, working tree and start time. Do not combine the record read with --start, the diff or other diagnostic commands whose failure could invalidate the read; if the read fails, retry it before proceeding. Use the supplied helper interfaces; discovering helper CLI options is outside this replay.
-- After final verification, combine successful --finish persistence and one complete, untruncated read-back through gstack-review-read in the same tool invocation. Read back only after persistence succeeds, inspect the full current record and binding, then return the final review summary in conversation.
+The runtime allows ${SHARED_INTERACTIVE_MAX_TURNS} assistant turns. Batch independent required source reads and other Git/configuration/attribute inspections only outside the receipt commands below. Preserve every required evidence check and dependency. This is a closed transport interface, not permission to omit workflow stages.
+
+1. Gather base metadata first. From the target repo, run the following as the sole command in its Bash call. Its stdout must contain only the token: no echo, labels, status, diff or other commands. Do not read the diff until step 2 verifies the start record; preserve Step 3's start-before-diff order.
+
+\`\`\`bash
+${shellQuote(path.join(SHARED_LIBS_ROOT, 'bin/gstack-review-log'))} --start review
+\`\`\`
+
+2. The trusted start-record location is ${startRecord}. Replace <REVIEW_START> with the token actually returned by --start. Read that token's record in a separate, successful Read tool call or a single cat command before continuing. Verify its repo, branch, working tree and start time. Do not combine the record read with --start, the diff or other diagnostic commands whose failure could invalidate the read; if the read fails, retry it before proceeding. Then read the diff in a subsequent call.
+
+3. Before checking reuse, directly read every supplied authored evidence path and the helper destination, including the changed worker even when its body appeared in the diff. Use native Read with explicit file paths, or cat/sed with literal path operands. These independent reads may be batched together, but their successful results must return before the checker. No path-variable loops, globs or process substitutions for these required reads. Other required inspections and structural fingerprinting can batch separately from receipt commands.
+
+4. The checker also reads and verifies that record without consuming it. Replace REVIEW_START below with that same literal token and CURRENT_FINDING_JSON with the current finding as literal JSON, retaining the quoted delimiter. Run this as the sole command in its Bash call from the target repo; stdout must be only one JSON value, with no preceding reads/fingerprinting or trailing output. Inspect reusable, review_start, fingerprint and snapshot.covered_paths before any later --finish invocation. This mechanical proof does not replace authored-source review. Use the supplied helper interfaces; discovering helper CLI options is outside this replay.
+
+\`\`\`bash
+${shellQuote(path.join(SHARED_LIBS_ROOT, 'bin/gstack-review-log'))} --check-shared-libs REVIEW_START <<'GSTACK_REVALIDATION_FINDING'
+CURRENT_FINDING_JSON
+GSTACK_REVALIDATION_FINDING
+\`\`\`
+
+5. Act on the checker result under the supplied finding's own evidence_paths/helper_target identity, exactly as the production shared-code-reuse rule requires:
+   - Suppress only when reusable:true AND your own reads independently confirm every supplied evidence path and the helper destination are unchanged, first-party authored source. Then the prior Skip carries forward. Ask no new decision question, exclude this advisory from the current pass's findings, and note it in the summary only as a suppressed prior decision. Do not re-persist it as a current finding or record a new disposition for it.
+   - Otherwise the prior decision does not carry forward. This covers reusable:false, a checker that failed or returned unreadable output, and reusable:true whose independent authored/current-source verification does not hold. Perform a fresh authored-source review and make an actual new decision for the current finding, preserving its evidence identity. Snapshot-ineligible supporting paths may be excluded from migration, savings and computed coverage; that does not silently remove them from the identity being revalidated. A materially revised proposal is a separate finding, never a replacement for the supplied finding's disposition. Do not make an unsupported proposal look worthwhile or mark it skipped without its actual explicit decision.
+   - An unsupported or unfinished supplied finding stays blocked and fails this replay regardless of the checker result; report it honestly and never force a new Skip on invalid evidence.
+
+6. Complete final evidence verification and assemble all record metadata in earlier calls. Replace FINAL_REVIEW_JSON below with the complete, shell-quoted literal record and REVIEW_START with the actual literal token. No preliminary commands, metadata substitutions or extra output in this final Bash call: combine successful --finish persistence and one complete, untruncated read-back through gstack-review-read in the same tool invocation exactly as below. Read back only after persistence succeeds, inspect the full current record and binding, then return the final review summary in conversation.
+
+\`\`\`bash
+${shellQuote(path.join(SHARED_LIBS_ROOT, 'bin/gstack-review-log'))} 'FINAL_REVIEW_JSON' --finish REVIEW_START && ${shellQuote(path.join(SHARED_LIBS_ROOT, 'bin/gstack-review-read'))}
+\`\`\`
+
 - Failed persistence or verification remains a failure. Late source changes still require the workflow's normal re-review; never skip checks, questions, or convergence rules to finish within the bound.`;
 }
 
 /** Seed a real, bound skipped advisory in an earlier review; never fabricate a verified binding. */
 export async function seedSkippedAdvisory(f: SharedLibsFixture): Promise<any> {
-  const { sharedLibsFingerprint } = await import('../../lib/review-evidence');
   const finding: any = { severity: 'INFORMATIONAL', confidence: 9,
     path: 'src/retry-worker.ts', line: 2, category: 'shared-libs',
     summary: 'Reuse the tested parser', advisory: true, action: 'skipped',
     evidence_paths: ['src/retry-worker.ts', 'src/retry-route.ts', 'lib/retry-after.ts'],
     helper_target: { path: 'lib/retry-after.ts', symbol: 'retrySeconds' } };
-  finding.fingerprint = sharedLibsFingerprint(finding);
-  const tree = fixtureWorkingTree(f);
-  let ordinaryCoverage = true;
-  try {
-    const autocrlf = (() => { try { return fixtureGit(f, 'config', '--get', 'core.autocrlf'); } catch { return ''; } })();
-    if (autocrlf && autocrlf !== 'false') ordinaryCoverage = false;
-    const algorithm = fixtureGit(f, 'rev-parse', '--show-object-format');
-    for (const relative of finding.evidence_paths) {
-      let location = f.repo;
-      for (const component of relative.split('/')) {
-        location = path.join(location, component);
-        if (fs.lstatSync(location).isSymbolicLink()) ordinaryCoverage = false;
-      }
-      if (!fs.lstatSync(location).isFile()) ordinaryCoverage = false;
-      if (!/^H /.test(fixtureGit(f, 'ls-files', '-v', '--', relative))) ordinaryCoverage = false;
-      const attributes = fixtureGit(f, 'check-attr', 'filter', 'working-tree-encoding', 'ident', 'text', 'eol', '--', relative);
-      if (attributes.split('\n').some(line => !line.endsWith(': unspecified'))) ordinaryCoverage = false;
-      const bytes = fs.readFileSync(location);
-      const rawBlob = createHash(algorithm).update(Buffer.from(`blob ${bytes.length}\0`)).update(bytes).digest('hex');
-      if (fixtureGit(f, 'rev-parse', `${tree}:${relative}`) !== rawBlob) ordinaryCoverage = false;
-    }
-  } catch { ordinaryCoverage = false; }
-  finding.snapshot_covered_paths = ordinaryCoverage ? [...finding.evidence_paths] : [];
   const log = path.join(SHARED_LIBS_ROOT, 'bin/gstack-review-log');
   const env = { ...process.env, ...f.env, PATH: process.env.PATH, GSTACK_HOME: f.state };
   const token = execFileSync(log, ['--start', 'review'], { cwd: f.repo, env, encoding: 'utf8', timeout: 30_000 }).trim();
@@ -773,7 +843,7 @@ export async function seedSkippedAdvisory(f: SharedLibsFixture): Promise<any> {
     status: 'clean', issues_found: 0, critical: 0, informational: 0, quality_score: 10,
     findings: [finding], completed: true, converged: true, cycles: 0 }), '--finish', token],
   { cwd: f.repo, env, encoding: 'utf8', timeout: 30_000 });
-  return finding;
+  return reviewRecords(f).filter(row => row.skill === 'review').at(-1).findings[0];
 }
 
 export function reviewRecords(f: SharedLibsFixture): any[] {
@@ -806,13 +876,14 @@ export function installNormalizingFilter(f: SharedLibsFixture): void {
 }
 
 export function fixtureWorkingTree(f: SharedLibsFixture): string {
-  return execFileSync(path.join(SHARED_LIBS_ROOT, 'bin/gstack-wtree'), [], {
+  const script = path.join(SHARED_LIBS_ROOT, 'bin/gstack-wtree');
+  return execFileSync(process.platform === 'win32' ? 'bash' : script, process.platform === 'win32' ? [script] : [], {
     cwd: f.repo, encoding: 'utf8', timeout: 30_000,
     env: { ...process.env, ...f.env, PATH: process.env.PATH },
   }).trim();
 }
 
-export async function runSharedCapture(f: SharedLibsFixture, testName: string, prompt: string) {
+export async function runSharedCapture(f: SharedLibsFixture, testName: string, prompt: string, attempt: SharedCaptureAttempt) {
   const { runSkillTest } = await import('./session-runner');
   const { CAPTURE_MS } = await import('./eval-budgets');
   // Keep harness startup outside the target: its own Git probes are not skill actions.
@@ -820,7 +891,7 @@ export async function runSharedCapture(f: SharedLibsFixture, testName: string, p
     prompt: `The target repository is ${f.repo}. Audit that explicit directory.\n${prompt}`, testName,
     allowedTools: ['Bash', 'Read', 'Write', 'Edit', 'Glob', 'Grep'],
     tools: ['Bash', 'Read', 'Write', 'Edit', 'Glob', 'Grep'],
-    env: f.env, maxTurns: 24, timeout: CAPTURE_MS,
+    env: f.env, maxTurns: 24, signal: attempt.signal, timeout: Math.min(CAPTURE_MS, attempt.remainingMs()),
   });
   return Object.assign(result, { providerRequests: readRequests(f) });
 }
@@ -844,7 +915,9 @@ function skippedReviewOption(question: any): any {
     const describedRetention = !!preservedObject
       && !/^\w+ing\b/i.test(preservedObject)
       && (/^(?:(?:duplicated|original|prior|tracked|untracked)\s+)*(?:(?:index|skip-worktree|assume-unchanged)\s+)?(?:flags?|code|source|implementations?|copies|copy|files?|routes?|workers?|helpers?|parsers?|changes?|contents?|state|branches|branch|worktrees?)$/i.test(preservedObject)
-        || qualifiedIndexState.test(preservedObject));
+        || qualifiedIndexState.test(preservedObject)
+        || /^bits?$/i.test(preservedObject) && /\bbits?\s+set\s*$/i.test(preservation?.[1] ?? '')
+          && /\b(?:git|index|skip-worktree|assume-unchanged)\b[^?.!]*\b(?:bits?|flags?)\b/i.test(question.question ?? ''));
     const description = (option.description ?? '').replace(/[‘’]/g, "'").trim();
     const declinesChange = /^(?:do not|don't)\s+(?:apply|change|edit|fix|refactor|extract|modify|touch|clear|remove|update|replace|add|migrate|implement|reuse|import)\b/i;
     const inapplicable = /^not applicable$/i.test(label)
@@ -869,12 +942,16 @@ function skippedReviewOption(question: any): any {
       word.replace(/(?:ed|ing)$/, 'e'), word.replace(/(?:ies|ied)$/, 'y'),
       word.replace(/([a-z])\1(?:ed|ing)$/, '$1')].some(form => actions.has(form));
     const changes = commitment.toLowerCase().split(/[,;\n]|[.!?](?:\s|$)|\b(?:and|but|then|while)\b/).some(part => {
-      const clause = part.replace(/^[^a-z]+/, '')
+      const text = part.replace(/^[^a-z]+/, '');
+      const nominal = /^(?:the\s+)?(?:source|code|route|worker|helper|parser|index(?:\s+flag)?)\s+([a-z]+(?:-[a-z]+)*)\s+(?:stays?|remains?)\s+(?:unchanged|untouched|unapplied|hidden|invisible|excluded)\b([\s\S]*)$/.exec(text);
+      if (nominal && isAction(nominal[1])) return (nominal[2].match(/[a-z]+(?:-[a-z]+)*/g) ?? []).some(isAction);
+      const clause = text
         .replace(/^(?:the\s+)?(?:review|reuse|snapshot)\s+coverage\s+(?=(?:will|would|should|must|can|may|does|do)\b)/, '')
         .replace(/^(?:(?:this|that|the|selected|chosen)\s+(?:option|choice|selection)|i|we|you|it|(?:the\s+)?(?:source|code|route|worker|helper|parser|index(?:\s+flag)?))\s+/, '')
         .replace(/^(?:will|would|should|must|can|may|does|do)\s+/, '')
         .replace(/^(?:(?:please|also|still|just|now|be)\s+)+/, '');
       if (/^(?:not|does not|don't|doesn't|won't|without|no)\b/.test(clause)) return false;
+      if (/\bgit\s+update-index\b/.test(clause)) return true;
       const first = clause.match(/^[a-z]+(?:-[a-z]+)*/)?.[0];
       const futureMatch = clause.match(/\b(?:will|would|should|must|can|may)\s+(?:(?:still|also|now|just|[a-z]+ly)\s+)*(?:be\s+)?(?:(?:still|also|now|just|[a-z]+ly)\s+)*([a-z]+(?:-[a-z]+)*)/);
       const future = futureMatch?.[1];
@@ -887,7 +964,13 @@ function skippedReviewOption(question: any): any {
       const futureSubject = clause.slice(0, futureMatch?.index ?? 0).trim();
       const passiveDecision = /\b(?:review\s+(?:log|record)|decision|advisory|snapshot|ledger)$/.test(futureSubject)
         || /\b(?:review\s+(?:log|record)|decision|advisory|snapshot|ledger)\b(?:(?!\b(?:source|code|route|worker|helper|parser|file|flag)\b).)*\bit$/.test(futureSubject);
-      const futureDecision = /\b(?:can|will|would|should|must|may)\s+(?:(?:still|also|now|just|[a-z]+ly)\s+)*reuse\s+(?:(?:this|the|prior|recorded|existing)\s+)*(?:review\s+(?:log|record)|decision|advisory|snapshot|ledger)\b/.test(clause);
+      const metadataReference = [...futureSubject.matchAll(/\b(?:review\s+(?:logs?|records?)|decisions?|advisor(?:y|ies)|findings?|snapshots?|ledgers?)\b/g)].at(-1)?.index ?? -1;
+      const productReference = [...futureSubject.matchAll(/\b(?:sources?|code|routes?|workers?|helpers?|parsers?|files?|flags?|index|bits?|implementations?|copies|copy)\b/g)].at(-1)?.index ?? -1;
+      const futureObject = clause.slice((futureMatch?.index ?? 0) + (futureMatch?.[0].length ?? 0)).trim();
+      const referentialDecision = /\b(?:review|pass)$/.test(futureSubject)
+        && metadataReference > productReference
+        && /^(?:it|this|that|them|these|those)(?:\s+(?:later|again))?[.!?)]*$/.test(futureObject);
+      const futureDecision = referentialDecision || /\b(?:can|will|would|should|must|may)\s+(?:(?:still|also|now|just|[a-z]+ly)\s+)*reuse\s+(?:(?:this|the|prior|recorded|existing)\s+)*(?:review\s+(?:log|record)|decision|advisory|snapshot|ledger)\b/.test(clause);
       const purpose = [...clause.matchAll(/\b(?:to|by|through|via)\s+(?:[a-z]+ly\s+)*([a-z]+(?:-[a-z]+)*)/g)]
         .some(match => isAction(match[1]));
       return (isAction(future) && !(future === 'reused' && passiveDecision) && !(future === 'reuse' && futureDecision)) || method || purpose
@@ -944,13 +1027,14 @@ export function createSharedInteractiveToolHandler(choose: 'approve' | 'skip' |
 }
 
 /** A real SDK capture supplies actual AskUserQuestion answers; no response/decision prose is forged. */
-export async function runSharedInteractive(f: SharedLibsFixture, testName: string, prompt: string, choose: 'approve' | 'skip' | SharedQuestionSelector) {
+export async function runSharedInteractive(f: SharedLibsFixture, testName: string, prompt: string, choose: 'approve' | 'skip' | SharedQuestionSelector,
+  fixtureOptions: { attempt: SharedCaptureAttempt; stageActor?: SharedReviewStageActor; prerequisiteSource?: 'synthetic-fixture-input' }) {
   // Keep the real review fetch step hermetic while preserving all actual local Git/record operations.
   installSourceShims(f);
   const { runAgentSdkTest, passThroughNonAskUserQuestion, resolveClaudeBinary } = await import('./agent-sdk-runner');
   const { query } = await import('@anthropic-ai/claude-agent-sdk');
   const { CAPTURE_MS } = await import('./eval-budgets');
-  const abortController = new AbortController();
+  let abortController: AbortController | undefined;
   let timer: ReturnType<typeof setTimeout> | undefined;
   let actorFailure: Error | undefined;
   let captureStartedAt = 0;
@@ -966,14 +1050,19 @@ export async function runSharedInteractive(f: SharedLibsFixture, testName: strin
       userPrompt: prompt, workingDirectory: f.repo, testName, env: f.env,
       pathToClaudeCodeExecutable: claudeBinary,
       settingSources: [], maxTurns: SHARED_INTERACTIVE_MAX_TURNS, maxRetries: 0,
+      signal: fixtureOptions.attempt.signal,
       allowedTools: ['Read', 'Bash', 'Write', 'Edit', 'Glob', 'Grep', 'AskUserQuestion'],
       queryProvider: args => {
-        // The SDK runner admits this request through its semaphore before calling
-        // the provider. Queue time must not consume an actual capture's deadline.
-        timer = setTimeout(() => abortController.abort(), CAPTURE_MS);
+        fixtureOptions.attempt.signal.throwIfAborted();
+        const remaining = fixtureOptions.attempt.remainingMs();
+        if (remaining <= 0) throw new Error('Shared capture attempt expired before admission');
+        abortController = args.options?.abortController;
+        if (!abortController) throw new Error('SDK capture lacks its owned abort controller');
+        timer = setTimeout(() => abortController!.abort(), Math.min(CAPTURE_MS, remaining));
         captureStartedAt = Date.now();
         fs.mkdirSync(diagnosticDirectory, { recursive: true });
-        const source = query({ ...args, options: { ...args.options, abortController } });
+        const source = query({ ...args, options: { ...args.options,
+          ...(fixtureOptions?.stageActor ? { hooks: fixtureOptions.stageActor.hooks } : {}) } });
         return new Proxy(source, {
           get(target, key) {
             if (key === Symbol.asyncIterator) return async function* () {
@@ -994,7 +1083,7 @@ export async function runSharedInteractive(f: SharedLibsFixture, testName: strin
         onAnswer: (input, answers) => {
           fs.appendFileSync(diagnostic, JSON.stringify({ type: 'fixture_answer', input, answers }) + '\n');
         },
-        onRefusal: error => { actorFailure = error; abortController.abort(); },
+        onRefusal: error => { actorFailure = error; abortController?.abort(); },
       }),
     });
     // The SDK converts callback throws to tool-control errors. Refusal must fail
@@ -1003,6 +1092,8 @@ export async function runSharedInteractive(f: SharedLibsFixture, testName: strin
     return { result: Object.assign(result, {
       providerRequests: readRequests(f),
       costKnown: streamed.some(event => event.type === 'result' && typeof event.total_cost_usd === 'number'),
+      ...(fixtureOptions ? { fixturePrerequisiteSource: fixtureOptions.stageActor ? 'synthetic-fixture-stage-actor' : fixtureOptions.prerequisiteSource } : {}),
+      ...(fixtureOptions?.stageActor ? { fixtureStageReceipts: fixtureOptions.stageActor.history() } : {}),
     }), questions };
   } catch (cause) {
     const assistantTurns = streamed.filter(event => event.type === 'assistant');
@@ -1012,11 +1103,13 @@ export async function runSharedInteractive(f: SharedLibsFixture, testName: strin
       events: streamed,
       toolCalls: blocks.filter(block => block.type === 'tool_use').map(block => ({ tool: block.name, input: block.input, output: '' })),
       output: blocks.filter(block => block.type === 'text').map(block => block.text).join('\n'),
-      exitReason: actorFailure ? 'actor_contract' : abortController.signal.aborted ? 'timeout' : 'capture_threw',
+      exitReason: actorFailure ? 'actor_contract' : fixtureOptions.attempt.signal.aborted || abortController?.signal.aborted ? 'timeout' : 'capture_threw',
       turnsUsed: assistantTurns.length, durationMs: captureStartedAt ? Date.now() - captureStartedAt : 0,
       costUsd: terminal?.total_cost_usd ?? 0, costKnown: typeof terminal?.total_cost_usd === 'number',
       model: assistantTurns.find(event => event.message?.model)?.message.model,
       providerRequests: readRequests(f),
+      ...(fixtureOptions ? { fixturePrerequisiteSource: fixtureOptions.stageActor ? 'synthetic-fixture-stage-actor' : fixtureOptions.prerequisiteSource } : {}),
+      ...(fixtureOptions?.stageActor ? { fixtureStageReceipts: fixtureOptions.stageActor.history() } : {}),
     };
     const error = actorFailure ?? (cause instanceof Error ? cause : new Error(String(cause)));
     Object.assign(error, { sharedCapture: { result: partial, questions, diagnostic } });

test/helpers/shared-libs-path-fixture.ts

@@ -2,10 +2,11 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { execFileSync } from 'node:child_process';
+import { createHash, randomUUID } from 'node:crypto';
 import { sharedLibsFingerprint } from '../../lib/review-evidence';
 import {
   SHARED_LIBS_ROOT, commitFixture, createSharedLibsFixture, fixtureGit, fixtureWrite,
-  fixtureWorkingTree, seedReviewSources, shellQuote, type SharedLibsFixture,
+  fixtureWorkingTree, seedReviewSources, shellQuote, snapshotFixture, type SharedLibsFixture, type SharedReviewResume, type SharedReviewStageActor,
 } from './shared-libs-eval-fixture';
 
 export type PathEligibilityCase = 'symlinks' | 'submodule' | 'ignored' | 'legacy' | 'assume-unchanged' | 'skip-worktree' | 'removed-filter';
@@ -15,6 +16,158 @@ export interface PathEligibilityFixture {
   beforeTree: string;
   sourcePaths: string[];
   rawPaths: string[];
+  resumed: SharedReviewResume;
+}
+
+function pathReviewState(f: SharedLibsFixture) {
+  const root = fs.realpathSync(f.root), repo = fs.realpathSync(f.repo), state = fs.realpathSync(f.state);
+  if (repo !== path.join(root, 'repo') || state !== path.join(root, 'state')) throw new Error('Foreign path fixture state');
+  const raw = Object.fromEntries(Object.entries(snapshotFixture(repo)).filter(([file, value]) =>
+    !file.split(path.sep).includes('.git') || /(?:^|\/)(?:config|info\/(?:attributes|exclude))$/.test(file)
+      || path.basename(file) === '.git' && !value.startsWith('dir:')));
+  return { root, repo, state, branch: fixtureGit(f, 'symbolic-ref', '--short', 'HEAD'),
+    head: fixtureGit(f, 'rev-parse', 'HEAD'), base: fixtureGit(f, 'rev-parse', 'origin/main'),
+    wtree: fixtureWorkingTree(f), index: fixtureGit(f, 'ls-files', '--stage', '-v'), raw };
+}
+
+export function seedPathReviewPrerequisites(f: SharedLibsFixture): SharedReviewResume {
+  const input = path.join(f.root, 'resumed-review-prerequisites.json');
+  const changedLines = fixtureGit(f, 'diff', '--numstat', 'origin/main').split('\n')
+    .reduce((sum, line) => sum + line.split('\t').slice(0, 2).reduce((n, value) => n + Number(value || 0), 0), 0);
+  if (!Number.isFinite(changedLines) || changedLines >= 50) throw new Error('Resumed path fixture requires a tiny no-edit diff');
+  const context = { kind: 'synthetic-path-review-prerequisites', synthetic: true, native_coverage: false,
+    binding: pathReviewState(f),
+    qa: { settled: true, required_probes: [{ id: 'retry-contract', status: 'passed',
+      result: 'Synthetic fixture input: Retry-After seconds/date parsing, ceiling and fallback probes passed.' }], findings: [] },
+    native_adversarial: { settled: true, status: 'completed', findings: [],
+      result: 'Synthetic fixture input: native adversarial review returned no findings.' },
+    structured_review: { required: false, reason: 'Tiny diff; no full-review, structured-review or P1 override requested.' } };
+  fs.writeFileSync(input, JSON.stringify(context, null, 2) + '\n', { mode: 0o600 });
+  return { input, checkCommand: `bun ${shellQuote(path.join(SHARED_LIBS_ROOT, 'test/helpers/shared-libs-path-fixture.ts'))} --check-review-prerequisites ${shellQuote(input)}` };
+}
+
+export function checkPathReviewPrerequisites(f: SharedLibsFixture, input: string) {
+  try {
+    if (input !== path.join(f.root, 'resumed-review-prerequisites.json')) throw new Error('Foreign prerequisite file');
+    const text = fs.readFileSync(input, 'utf8'), context = JSON.parse(text);
+    const current = JSON.stringify(context.binding) === JSON.stringify(pathReviewState(f));
+    const settled = current && context.kind === 'synthetic-path-review-prerequisites'
+      && context.synthetic === true && context.native_coverage === false
+      && context.qa?.settled === true && Array.isArray(context.qa.required_probes) && context.qa.required_probes.length === 1
+      && context.qa.required_probes.every((probe: any) => probe.id === 'retry-contract' && probe.status === 'passed'
+        && typeof probe.result === 'string' && probe.result.length > 0)
+      && Array.isArray(context.qa.findings) && context.qa.findings.length === 0
+      && context.native_adversarial?.settled === true && context.native_adversarial.status === 'completed'
+      && Array.isArray(context.native_adversarial.findings) && context.native_adversarial.findings.length === 0
+      && typeof context.native_adversarial.result === 'string' && context.native_adversarial.result.length > 0
+      && context.structured_review?.required === false;
+    return { synthetic: true, native_coverage: false, settled, current,
+      input_sha256: createHash('sha256').update(text).digest('hex'), context };
+  } catch {
+    return { synthetic: true, native_coverage: false, settled: false, current: false };
+  }
+}
+
+export function hasPathReviewPrerequisiteReceipt(events: any[], command: string, expected: ReturnType<typeof checkPathReviewPrerequisites>): boolean {
+  if (!expected.settled) return false;
+  const calls = new Set<string>();
+  let verified = false;
+  for (const event of events) for (const block of Array.isArray(event.message?.content) ? event.message.content : []) {
+    if (event.type === 'assistant' && block.type === 'tool_use' && block.name === 'Bash') {
+      if (block.input?.command === command) calls.add(block.id);
+      if (String(block.input?.command).includes('--finish')) return verified;
+    }
+    if (event.type !== 'user' || block.type !== 'tool_result' || block.is_error === true || !calls.has(block.tool_use_id)) continue;
+    const text = typeof block.content === 'string' ? block.content : Array.isArray(block.content)
+      ? block.content.filter((part: any) => part.type === 'text').map((part: any) => part.text).join('\n') : '';
+    try { verified = JSON.stringify(JSON.parse(text)) === JSON.stringify(expected); } catch { verified = false; }
+  }
+  return false;
+}
+
+export function createLifecyclePrerequisiteActor(f: SharedLibsFixture): SharedReviewStageActor {
+  const directory = path.join(fs.realpathSync(f.root), 'synthetic-stage-receipts');
+  fs.mkdirSync(directory, { mode: 0o700 });
+  const output = path.join(directory, 'current.json');
+  const actorCommand = `cat ${shellQuote(output)}`;
+  let state = pathReviewState(f), generation = 0;
+  const isolation = [state.root, state.repo, state.state];
+  const issued = new Map<string, { text: string; file: string; generation: number; settled: boolean }>();
+  const finishes = new Map<string, { command: string; generation: number }>();
+  const observe = () => {
+    const current = pathReviewState(f);
+    if (JSON.stringify([current.root, current.repo, current.state]) !== JSON.stringify(isolation)) throw new Error('Rebound synthetic stage fixture');
+    if (JSON.stringify(current) !== JSON.stringify(state)) { generation++; state = current; }
+    return current;
+  };
+  const beforeTool: SharedReviewStageActor['hooks']['PreToolUse'][number]['hooks'][number] = async (input, toolUseID) => {
+    if (input.hook_event_name !== 'PreToolUse') return {};
+    const current = observe();
+    const command = input.tool_name === 'Bash' ? (input.tool_input as any)?.command : undefined;
+    if (command === actorCommand) {
+      const id = input.tool_use_id;
+      if (fs.realpathSync(input.cwd) !== current.repo || !id || toolUseID !== undefined && id !== toolUseID || issued.has(id)
+        || fs.realpathSync(directory) !== directory || fs.existsSync(output) && fs.lstatSync(output).isSymbolicLink()) {
+        return { hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny', permissionDecisionReason: 'Invalid synthetic stage invocation' } };
+      }
+      const evidence_paths = ['src/retry-worker.ts', 'src/retry-route.ts', 'lib/retry-after.ts'];
+      const fingerprint = sharedLibsFingerprint({ evidence_paths, helper_target: { path: 'lib/retry-after.ts', symbol: 'retrySeconds' } });
+      const changedLines = fixtureGit(f, 'diff', '--numstat', 'origin/main').split('\n')
+        .reduce((sum, line) => sum + line.split('\t').slice(0, 2).reduce((n, value) => n + Number(value || 0), 0), 0);
+      const tinyDiff = Number.isFinite(changedLines) && changedLines < 50;
+      const authoredEvidence = !!fingerprint && evidence_paths.every(source => {
+        const file = path.join(current.repo, source);
+        try { return fs.realpathSync(file) === file && fs.lstatSync(file).isFile() && fs.statSync(file).size > 0; }
+        catch { return false; }
+      });
+      const supported = tinyDiff && authoredEvidence;
+      const receipt = { kind: 'synthetic-lifecycle-stage-result', id: randomUUID(), tool_use_id: id,
+        synthetic: true, native_coverage: false, generation, binding: current,
+        deterministic_checks: { fixture_isolation: true, tiny_diff: tinyDiff, authored_evidence: authoredEvidence, fingerprint },
+        qa: { settled: supported, required_probes: [{ id: 'retry-contract', status: supported ? 'passed' : 'blocked',
+          result: 'Simulated fixture QA outcome, not execution of target tests.' }], findings: [] },
+        native_adversarial: { settled: supported, status: supported ? 'completed' : 'blocked', findings: [],
+          result: 'Simulated fixture adversarial outcome, not an actual native review.' },
+        ...(tinyDiff ? { structured_review: { required: false, reason: 'Tiny diff; no full-review override in this fixture.' } } : {}),
+        settled: supported };
+      const text = JSON.stringify(receipt), file = path.join(directory, `${receipt.id}.json`);
+      fs.writeFileSync(file, text, { flag: 'wx', mode: 0o600 });
+      fs.writeFileSync(output, text, { mode: 0o600 });
+      issued.set(id, { text, file, generation, settled: supported });
+      return { hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'allow' } };
+    }
+    if (typeof command === 'string' && command.includes('gstack-review-log') && command.includes('--finish')) {
+      finishes.set(input.tool_use_id, { command, generation });
+    }
+    return {};
+  };
+  return { actorCommand, hooks: { PreToolUse: [{ hooks: [beforeTool] }] },
+    history: () => [...issued.values()].map(receipt => JSON.parse(receipt.text)),
+    verify(events) {
+      try {
+        observe();
+        if (!issued.size || [...issued.values()].some(receipt => fs.readFileSync(receipt.file, 'utf8') !== receipt.text)) return false;
+        const calls = new Map<string, string>();
+        let consumed: string | undefined, final: string | undefined, finalReceipt: string | undefined, finished = false;
+        for (const event of events) for (const block of Array.isArray(event.message?.content) ? event.message.content : []) {
+          if (event.type === 'assistant' && block.type === 'tool_use' && block.name === 'Bash') {
+            calls.set(block.id, block.input?.command);
+            if (finishes.get(block.id)?.command === block.input?.command) { final = block.id; finalReceipt = consumed; finished = false; }
+          }
+          if (event.type !== 'user' || block.type !== 'tool_result') continue;
+          if (block.tool_use_id === final) finished = block.is_error !== true;
+          if (calls.get(block.tool_use_id) !== actorCommand) continue;
+          const receipt = issued.get(block.tool_use_id);
+          const text = typeof block.content === 'string' ? block.content : Array.isArray(block.content)
+            ? block.content.filter((part: any) => part.type === 'text').map((part: any) => part.text).join('\n') : '';
+          consumed = receipt && receipt.settled && block.is_error !== true
+            && JSON.stringify(JSON.parse(text)) === receipt.text ? block.tool_use_id : undefined;
+        }
+        const receipt = finalReceipt ? issued.get(finalReceipt) : undefined;
+        return !!receipt && finished && finalReceipt === [...issued.keys()].at(-1)
+          && final === [...finishes.keys()].at(-1) && receipt.generation === generation && finishes.get(final!)?.generation === generation;
+      } catch { return false; }
+    } };
 }
 
 function seedBoundSkip(f: SharedLibsFixture, finding: Record<string, any>): void {
@@ -150,9 +303,17 @@ export function preparePathEligibilityFixture(kind: PathEligibilityCase): PathEl
         + `\n// Authored caller changed after the prior decision (${kind}).\n`);
     }
     if (fixtureWorkingTree(f) !== beforeTree) throw new Error(`${kind}: fixture must retain the parent Git tree`);
-    return { fixture, current, beforeTree, sourcePaths, rawPaths };
+    return { fixture, current, beforeTree, sourcePaths, rawPaths, resumed: seedPathReviewPrerequisites(f) };
   } catch (error) {
     fs.rmSync(f.root, { recursive: true, force: true });
     throw error;
   }
 }
+
+if (import.meta.main) {
+  const [flag, input] = process.argv.slice(2);
+  if (flag !== '--check-review-prerequisites' || !input || !process.env.GSTACK_HOME) process.exit(2);
+  const f = { root: path.dirname(input), repo: process.cwd(), state: process.env.GSTACK_HOME,
+    env: { GSTACK_HOME: process.env.GSTACK_HOME } } as SharedLibsFixture;
+  console.log(JSON.stringify(checkPathReviewPrerequisites(f, input)));
+}

test/helpers/shared-libs-review-start-evidence.ts

@@ -1,5 +1,6 @@
 import * as path from 'node:path';
 import { createHash } from 'node:crypto';
+import { sharedLibsFingerprint } from '../../lib/review-evidence';
 
 interface StartContext {
   repo: string;
@@ -422,7 +423,7 @@ function inspectsFile(source: string, file: string, returnedPath: boolean, expec
 }
 
 /** Inspect native public tool blocks only; narration and instruction contents are not evidence. */
-export function hasTrustedReviewStartRead(events: unknown[], expected: StartContext): boolean {
+function nativeToolPairs(events: unknown[]) {
   const pending = new Map<string, { tool: string; input: any; at: number }>();
   const pairs: { tool: string; input: any; at: number; returnedAt: number; text: string }[] = [];
   let position = 0;
@@ -443,6 +444,107 @@ export function hasTrustedReviewStartRead(events: unknown[], expected: StartCont
     }
   }
 
+  return pairs;
+}
+
+interface CheckerContext extends StartContext {
+  helper: string;
+  finding: any;
+  reusable: boolean;
+  coveredPaths: string[];
+}
+
+export function hasTrustedSharedLibsCheck(events: unknown[], expected: CheckerContext): boolean {
+  const identity = sharedLibsFingerprint(expected.finding);
+  const paths = sourcePaths(expected.repo);
+  const samePaths = (left: unknown, right: unknown): boolean => Array.isArray(left) && Array.isArray(right)
+    && left.every(value => typeof value === 'string') && right.every(value => typeof value === 'string')
+    && new Set(left).size === left.length && new Set(right).size === right.length
+    && left.length === right.length && left.every(value => right.includes(value));
+  if (!identity || !Array.isArray(expected.coveredPaths)
+    || !expected.coveredPaths.every(file => expected.finding.evidence_paths.includes(file))
+    || expected.reusable && !samePaths(expected.coveredPaths, expected.finding.evidence_paths)) return false;
+  const environment = new Map([['GSTACK_HOME', expected.state], ['SLUG', expected.slug]]);
+  const invocations = (source: string) => {
+    const calls = withDirectories(commands(source), paths.normalize(expected.repo), paths, environment);
+    return calls.filter((call, index) => {
+      const executable = expandVariables(call.words[0], call.variables);
+      if (!executable || literalPath(executable, call.cwd, paths) !== paths.normalize(expected.helper)
+        || call.cwd !== paths.normalize(expected.repo) || call.variables.get('GSTACK_HOME') !== expected.state
+        || ['|', '&', '||', ')'].includes(call.after)
+        || call.before === '&&' && calls[index - 1]?.words[0] !== 'cd') return false;
+      return calls.slice(0, index).every((prefix, offset) => {
+        if (prefix.substitutions.length || ['||', '&', '(', ')'].includes(prefix.before)) return false;
+        if (prefix.words[0] === 'cd') return prefix.after === ';' || prefix.after === '&&';
+        if (prefix.words.every(word => /^[A-Za-z_]\w*=/.test(word))) return prefix.after === ';';
+        return offset === index - 1 && prefix.after === '|' && ['cat', 'printf', 'echo'].includes(prefix.words[0]);
+      });
+    }).map(call => ({ ...call, last: call === calls.at(-1),
+      words: call.words.map(word => expandVariables(word, call.variables) ?? word) }));
+  };
+  const pairs = nativeToolPairs(events);
+  const bash = pairs.filter(pair => pair.tool === 'Bash' && typeof pair.input?.command === 'string');
+  for (const start of bash) {
+    const direct = invocations(start.input.command).some(call => call.last && call.words.length === 3
+      && call.words[1] === '--start' && call.words[2] === 'review');
+    const startCalls = commands(start.input.command);
+    const base = startCalls.length === 3 && startCalls[0].words.length === 1
+      ? /^DIFF_BASE=\$\(([\s\S]*)\)$/.exec(startCalls[0].words[0]) : null;
+    const baseCalls = base ? commands(base[1]) : [];
+    const batched = baseCalls.length === 1 && baseCalls[0].words.length === 4
+      && baseCalls[0].before === '' && baseCalls[0].after === ''
+      && baseCalls[0].words[0] === 'git' && baseCalls[0].words[1] === 'merge-base'
+      && /^origin\/[A-Za-z0-9_./-]+$/.test(baseCalls[0].words[2]) && baseCalls[0].words[3] === 'HEAD'
+      && startCalls[0].before === '' && startCalls[0].after === ';' && startCalls[1].after === ';'
+      && ['', ';'].includes(startCalls[2].after)
+      && startCalls[1].words.length === 3
+      && literalPath(startCalls[1].words[0], expected.repo, paths) === paths.normalize(expected.helper)
+      && startCalls[1].words[1] === '--start' && startCalls[1].words[2] === 'review'
+      && startCalls[2].words.length === 3 && startCalls[2].words[0] === 'git'
+      && startCalls[2].words[1] === 'diff' && startCalls[2].words[2] === '$DIFF_BASE';
+    const assigned = startCalls.length === 2 && startCalls[0].words.length === 1
+      ? /^([A-Za-z_]\w*)=\$\(([\s\S]*)\)$/.exec(startCalls[0].words[0]) : null;
+    const echoed = assigned && startCalls[0].after === ';' && startCalls[1].words.length === 2
+      && startCalls[1].words[0] === 'echo' && startCalls[1].words[1] === `$${assigned[1]}`
+      && invocations(assigned[2]).some(call => call.words.length === 3
+        && call.words[1] === '--start' && call.words[2] === 'review');
+    if (!direct && !echoed && !batched) continue;
+    const printed = batched ? start.text.trim().split('\n')[0] : start.text.trim();
+    const token = /^(?:[A-Za-z_]\w*=)?([0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12})$/.exec(printed)?.[1];
+    if (!token) continue;
+    for (const check of bash) {
+      if (check.at <= start.returnedAt) continue;
+      const invocation = invocations(check.input.command).find(call => call.last && call.words[1] === '--check-shared-libs'
+        && call.words[2] === token && (call.words.length === 3 || call.words.length === 5 && call.words[3] === '<'
+          && literalPath(call.words[4], call.cwd, paths)) && ['', ';'].includes(call.after));
+      if (!invocation) continue;
+      let receipt: any;
+      try { receipt = JSON.parse(check.text); } catch { continue; }
+      const record = receipt?.review_start;
+      const snapshot = receipt?.snapshot;
+      if (receipt?.reusable !== expected.reusable || receipt.fingerprint !== identity
+        || record?.skill !== 'review' || record.repo !== expected.repo || record.branch !== expected.branch
+        || record.wtree !== expected.wtree || typeof expected.startedAt !== 'string'
+        || record.started_at !== expected.startedAt || snapshot?.wtree !== expected.wtree
+        || snapshot.branch_id !== createHash('sha256').update(expected.branch).digest('hex')
+        || !samePaths(snapshot.covered_paths, expected.coveredPaths)) continue;
+      const reads = pairs.filter(pair => pair.at > start.returnedAt && pair.returnedAt < check.at && pair.text.trim());
+      if (!expected.finding.evidence_paths.every((relative: string) => {
+        const file = paths.join(expected.repo, relative);
+        return reads.some(read => read.tool === 'Read' && typeof read.input?.file_path === 'string'
+          && literalPath(read.input.file_path, expected.repo, paths) === file
+          || read.tool === 'Bash' && typeof read.input?.command === 'string'
+          && inspectsFile(read.input.command, file, containsPath(read.text, file), expected));
+      })) continue;
+      if (bash.some(finish => finish.at > check.returnedAt && invocations(finish.input.command).some(call =>
+        call.words.length === 4 && call.words[2] === '--finish' && call.words[3] === token))) return true;
+    }
+  }
+  return false;
+}
+
+export function hasTrustedReviewStartRead(events: unknown[], expected: StartContext): boolean {
+  const pairs = nativeToolPairs(events);
   for (const start of pairs) {
     if (start.tool !== 'Bash' || typeof start.input?.command !== 'string'
       || !topLevelCommands(commands(start.input.command)).some(call => {

test/helpers/ship-skip-actor.ts

@@ -0,0 +1,420 @@
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { createHash, randomUUID } from 'node:crypto';
+import { spawnSync } from 'node:child_process';
+import { isDeepStrictEqual } from 'node:util';
+import type { CanUseTool, HookCallback, SDKMessage } from '@anthropic-ai/claude-agent-sdk';
+import type { AgentSdkResult, QueryProvider } from './agent-sdk-runner';
+import type { EvalTestEntry } from './eval-store';
+import { CAPTURE_MS } from './eval-budgets';
+import { createSharedInteractiveToolHandler, SHARED_INTERACTIVE_MAX_TURNS } from './shared-libs-eval-fixture';
+import { runGeneration } from '../../scripts/gen-skill-docs';
+import { gitArgvIn } from './scratch-repo';
+
+export const SHIP_SKIP_CASE = 'ship-skipped-queued-finding';
+export const SHIP_SKIP_QUESTION = { questions: [{ header: 'Invoice auth', multiSelect: false,
+  question: 'Fix invoice.ts authorization so only the invoice owner is accepted?',
+  options: [{ label: 'Fix', description: 'Enforce the owner check.' },
+    { label: 'Skip', description: 'Leave the source unchanged and retain the unresolved defect.' }] }] };
+const UNCHANGED_READ = 'Wasted call — file unchanged since your last Read. Refer to that earlier tool_result instead.';
+const ROOT = path.resolve(import.meta.dir, '../..');
+const quote = (value: string) => `'${value.replaceAll("'", "'\"'\"'")}'`;
+const digest = (value: string) => createHash('sha256').update(value).digest('hex');
+const read = (file: string) => fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : '';
+const json = (file: string) => JSON.parse(fs.readFileSync(file, 'utf8'));
+const write = (file: string, value: unknown) => fs.writeFileSync(file, JSON.stringify(value, null, 2) + '\n', { mode: 0o600 });
+
+function command(repo: string, env: NodeJS.ProcessEnv, executable: string, args: string[], deadline = Infinity) {
+  const remaining = deadline - Date.now();
+  if (remaining <= 0) throw new Error('Ship Skip case deadline exhausted during setup');
+  const result = spawnSync(executable, args, { cwd: repo, env, encoding: 'utf8', timeout: Math.min(10_000, remaining) });
+  if (result.status !== 0 || result.error) throw new Error(result.error?.message ?? result.stderr);
+  return result.stdout.trim();
+}
+
+function section(text: string, first: string, last?: string) {
+  const start = text.indexOf(first);
+  const end = last ? text.indexOf(last, start + first.length) : text.length;
+  if (start < 0 || end < start || text.indexOf(first, start + first.length) >= 0) throw new Error(`Ambiguous workflow boundary: ${first}`);
+  return text.slice(start, end).trim();
+}
+
+export async function shipSkipWorkflow() {
+  const rendered = fs.mkdtempSync(path.join(fs.realpathSync(os.tmpdir()), 'sskip-render-'));
+  try {
+    const generated = await runGeneration({ host: 'claude', outputRoot: rendered, contentLinkRoot: null, log: () => {} });
+    if (generated.exitCode !== 0) throw new Error('Ship fixture generation failed');
+    const army = read(path.join(rendered, 'ship/sections/review-army.md'));
+    const adversarial = read(path.join(rendered, 'ship/sections/adversarial.md'));
+    return section(army, '### Step 9.3:', '### Decide whether to repeat Step 9')
+      + '\n\n' + section(adversarial, '### Finish the adversarial phase', '\n---');
+  } finally { fs.rmSync(rendered, { recursive: true, force: true }); }
+}
+
+export function createShipSkipFixture(workflow: string, root = fs.mkdtempSync(path.join(fs.realpathSync(os.tmpdir()), 'sskip-')), deadline = Infinity) {
+  const routing = ['GIT_DIR', 'GIT_WORK_TREE', 'GIT_COMMON_DIR', 'GIT_INDEX_FILE', 'GIT_OBJECT_DIRECTORY', 'GIT_ALTERNATE_OBJECT_DIRECTORIES']
+    .filter(key => process.env[key] !== undefined);
+  if (routing.length) throw new Error(`Refusing ambient Git routing: ${routing.join(', ')}`);
+  fs.mkdirSync(root, { recursive: true, mode: 0o700 });
+  fs.chmodSync(root, 0o700);
+  const repo = path.join(root, 'project');
+  const home = path.join(root, 'home');
+  const state = path.join(root, 'state');
+  const assets = path.join(root, 'assets');
+  for (const dir of [repo, home, state, assets]) fs.mkdirSync(dir, { mode: 0o700 });
+  const env = { HOME: home, GSTACK_HOME: state, GSTACK_STATE_ROOT: state, CLAUDE_PLUGIN_DATA: '',
+    CLAUDE_CONFIG_DIR: path.join(root, 'claude-config'), GIT_CONFIG_GLOBAL: '/dev/null', GIT_CONFIG_SYSTEM: '/dev/null',
+    GIT_CONFIG_NOSYSTEM: '1', GIT_CONFIG_COUNT: '0', PATH: `${path.dirname(process.execPath)}:${process.env.PATH ?? ''}` };
+  const git = (...args: string[]) => {
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) throw new Error('Ship Skip case deadline exhausted during setup');
+    const result = gitArgvIn(repo, args, Math.min(10_000, remaining), env);
+    if (result.status !== 0 || result.error) throw new Error(result.error?.message ?? result.stderr.toString());
+  };
+  git('init', '-q', '-b', 'main');
+  const product = path.join(repo, 'invoice.ts');
+  fs.writeFileSync(product, 'export const canReadInvoice = (owner: string, viewer: string) => owner === viewer;\n', { mode: 0o644 });
+  git('add', 'invoice.ts');
+  git('commit', '-qm', 'Seed invoice authorization');
+  git('update-ref', 'refs/remotes/origin/main', 'HEAD');
+  git('checkout', '-qb', 'fixture/queued-finding');
+  fs.writeFileSync(product, 'export const canReadInvoice = (_owner: string, _viewer: string) => true;\n');
+  git('add', 'invoice.ts');
+  git('commit', '-qm', 'Seed the reviewed authorization defect');
+  const bytes = read(product);
+  const evidence = { path: 'invoice.ts', sha256: digest(bytes) };
+  const finding = { fingerprint: 'invoice.ts:1:authorization', path: 'invoice.ts', line: 1,
+    severity: 'CRITICAL', category: 'authorization', classification: 'FIXABLE',
+    problem: 'Invoice authorization accepts a different viewer than the owner.', decision_evidence: evidence };
+  const workflowPath = path.join(assets, 'workflow.md');
+  fs.writeFileSync(workflowPath, workflow, { mode: 0o600 });
+  const checklistPath = path.join(assets, 'checklist.md');
+  fs.copyFileSync(path.join(ROOT, 'review/checklist.md'), checklistPath);
+  const inputPath = path.join(assets, 'finding.json');
+  write(inputPath, { source: 'synthetic native-review fixture result', native_completed: true, finding,
+    review_coverage: 'not_executed', probes: [], release_eligible: false });
+  const draft = path.join(root, 'review-record.json');
+  const receipts = path.join(root, 'receipts.jsonl');
+  const answersPath = path.join(root, 'owner-answer.json');
+  const token = command(repo, { ...process.env, ...env }, path.join(ROOT, 'bin/gstack-review-log'), ['--start', 'review'], deadline);
+  const startFiles = fs.readdirSync(state, { recursive: true }).filter(file => String(file).endsWith(`/${token}.json`));
+  if (startFiles.length !== 1) throw new Error('Expected one owned real review-start receipt');
+  const start = json(path.join(state, String(startFiles[0])));
+  if (start.repo !== repo || start.branch !== 'fixture/queued-finding') throw new Error('Review-start receipt has foreign ownership');
+  const commands = Object.fromEntries(['read', 'persist', 'rediscover', 'advance', 'repeat'].map(action =>
+    [action, `${quote(process.execPath)} ${quote(import.meta.path)} --fixture ${quote(root)} ${action}`]));
+  write(path.join(root, 'fixture.json'), { repo, env, product, evidence, finding, token, draft, receipts, answersPath });
+  const executions: Array<{ tool: string; input: Record<string, unknown>; allowed: boolean; phase: string }> = [];
+  const answers: Array<{ toolUseId: string; input: Record<string, unknown>; answers: Record<string, string> }> = [];
+  let questionId = '';
+  const refusals: string[] = [];
+  const phase = () => read(receipts).includes('"action":"rediscover"') ? 'rediscovered' : 'initial';
+  const readable = new Set([workflowPath, checklistPath, inputPath, product]);
+  const invalid = (tool: string, input: Record<string, unknown>) => {
+    if (/"action":"(?:advance|repeat)"/.test(read(receipts))) return 'Queue boundary already selected';
+    if (tool === 'Read') return typeof input.file_path === 'string' && readable.has(path.resolve(repo, input.file_path))
+      && Object.keys(input).every(key => key === 'file_path') ? undefined : 'Only declared full-file reads are supported';
+    if (tool === 'Write') return input.file_path === draft && typeof input.content === 'string' && input.content.length <= 16_384 ? undefined : 'Write outside review record';
+    if (tool === 'Bash') return typeof input.command === 'string' && !input.run_in_background && Object.values(commands).includes(input.command.trim()) ? undefined : 'Bash outside fixture interface';
+    if (tool === 'AskUserQuestion') {
+      if (answers.length) return 'Repeated Skip question';
+      const questions = input.questions;
+      if (Object.keys(input).some(key => key !== 'questions') || !Array.isArray(questions) || questions.length !== 1) return 'Only the declared finding disposition is supported';
+      const question = questions[0];
+      const expected = SHIP_SKIP_QUESTION.questions[0];
+      return question && Object.keys(question).length === 4 && question.header === expected.header
+        && question.question === expected.question && question.multiSelect === false && Array.isArray(question.options)
+        && question.options.length === 2 && question.options.every((option: any, index: number) => option
+          && Object.keys(option).length === 2 && option.label === expected.options[index].label
+          && option.description === expected.options[index].description) ? undefined : 'Only the declared finding disposition is supported';
+    }
+    return 'Undeclared tool';
+  };
+  const handler = createSharedInteractiveToolHandler('skip', {
+    nonQuestion: (_name, input) => ({ behavior: 'allow', updatedInput: input }),
+    onQuestion: input => { const reason = invalid('AskUserQuestion', input); if (reason) throw new Error(reason); },
+    onAnswer: (input, selected) => { answers.push({ toolUseId: questionId, input, answers: selected }); write(answersPath, { toolUseId: questionId, input, answers: selected, evidence }); },
+    onRefusal: error => { refusals.push(error.message); },
+  });
+  const canUseTool: CanUseTool = async (tool, input, options) => {
+    const reason = invalid(tool, input);
+    if (reason) { refusals.push(reason); return { behavior: 'deny', message: reason }; }
+    questionId = options.toolUseID;
+    if (tool === 'AskUserQuestion' && !questionId) { refusals.push('Missing native question ID'); return { behavior: 'deny', message: 'Missing native question ID' }; }
+    try { return await handler(tool, input); }
+    catch (error) { const message = String(error); refusals.push(message); return { behavior: 'deny', message }; }
+  };
+  const preToolUse: HookCallback = async input => {
+    if (input.hook_event_name !== 'PreToolUse') throw new Error('Unexpected hook');
+    const toolInput = input.tool_input as Record<string, unknown>;
+    const reason = invalid(input.tool_name, toolInput);
+    executions.push({ tool: input.tool_name, input: toolInput, allowed: !reason, phase: phase() });
+    return { hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: reason ? 'deny' : input.tool_name === 'AskUserQuestion' ? 'ask' : 'allow',
+      ...(reason ? { permissionDecisionReason: reason } : {}),
+      ...(input.tool_name === 'Bash' && !reason ? { updatedInput: { command: toolInput.command, timeout: 10000, run_in_background: false } } : {}) } };
+  };
+  const prompt = `Load gstack's bounded /ship decision path from ${workflowPath}. The queued Step 11 finding is in ${inputPath}; verify it against ${product}. The referenced checklist is ${checklistPath}. Execute Step 9.3 and Step 9.4 through persistence, then obtain the unchanged rediscovery and apply the supplied Step 11 finish rules. This is not full /ship: earlier reviewers and the rediscovery are explicitly synthetic fixture inputs. No QA/probes/full review ran; persist completed:false and converged:false and never claim passing verification or release clearance. The native-completion bit refers only to the supplied synthetic result. Stop after selecting the next queue boundary; do not execute Step 11.5 or release work.
+
+Supported interactions, declared before launch:
+- Read only the four absolute files above, using file_path alone: no offset, limit, pages or other fields. After the rediscover command's result is acknowledged, issue a new full Read with exactly ${JSON.stringify({ file_path: product })}. Receive its actual tool result before issuing either routing command (advance or repeat), even when the result is file_unchanged and refers to the earlier full delivery. A Read before rediscovery or a prose claim of unchanged source does not satisfy this step.
+- One native AskUserQuestion with exactly this declared finding-disposition input: ${JSON.stringify(SHIP_SKIP_QUESTION)}. The owner chooses the no-change option. No other permission, combined request or risk-acceptance question is authorized.
+- Write only ${draft}, as the actual Step 9.4 JSON review record. Include the finding's fingerprint, severity, disposition and decision_evidence; preserve honest unresolved counts. Copy the canonical decision_evidence object from ${inputPath} unchanged, with exactly its path and sha256 fields and values; put any annotations outside decision_evidence. The adapter holds the original real REVIEW_START token, captured before source inspection. The record is outside the product checkout.
+- Bash accepts exactly these single commands, without chaining, redirection or backgrounding:
+  ${commands.read} invokes the real gstack-review-read in this fixture's owned state.
+  ${commands.persist} passes the written record to the real gstack-review-log with the original token.
+  ${commands.rediscover} returns the same completed synthetic Step 11 finding after the owner response and persistence, without changing source.
+  ${commands.advance} records selection of the Step 11.5 boundary and stops this fixture.
+  ${commands.repeat} records selection of another 9→10→11 review pass and stops this fixture.
+Use these bound adapters for the generated helper command examples. Choose the routing command from the workflow, not as a claim that shipping is cleared. The adapters do not decide which boundary you should select. Memory updates are outside this fixture. No product writes, direct receipt/config access, new start token, full reviewer dispatch, other commands, commits or publication are supported. Report the skipped defect and incomplete verification truthfully.`;
+  const snapshot = () => ({ product: read(product), originalProduct: bytes, evidence, start, answers, refusals, executions,
+    receipts: read(receipts).trim().split('\n').filter(Boolean).map(line => JSON.parse(line)),
+    workflowSha256: digest(workflow), promptSha256: digest(prompt),
+    stateRoot: state, repo, input: json(inputPath), persisted: read(path.join(root, 'persisted.json')) ? json(path.join(root, 'persisted.json')) : null });
+  return { root, repo, env, workflowPath, inputPath, product, draft, commands, prompt, preToolUse, canUseTool, snapshot,
+    readContents: new Map([...readable].map(file => [file, read(file)])) };
+}
+
+export function shipSkipFailures(fixture: ReturnType<typeof createShipSkipFixture>, result: Pick<AgentSdkResult, 'exitReason' | 'events'>) {
+  const evidence = fixture.snapshot();
+  const failures: string[] = [];
+  const check = (ok: boolean, message: string) => { if (!ok) failures.push(message); };
+  check(result.exitReason === 'success', `actor ended: ${result.exitReason}`);
+  check(evidence.product === evidence.originalProduct, 'product bytes changed');
+  check(evidence.answers.length === 1 && evidence.refusals.length === 0, 'expected exactly one captured owner Skip');
+  check(!evidence.executions.some(event => !event.allowed), 'undeclared or repeated interaction');
+  const calls = new Map<string, { tool: string; input: Record<string, unknown> }>();
+  const completed: Array<{ id: string; tool: string; input: Record<string, unknown>; output: string; index: number; fullRead?: string }> = [];
+  const delivered = new Set<string>();
+  for (const [index, event] of result.events.entries()) {
+    if (event.type !== 'assistant' && event.type !== 'user') continue;
+    for (const block of event.message.content) {
+      if (typeof block === 'string') continue;
+      if (event.type === 'assistant' && block.type === 'tool_use') calls.set(block.id, { tool: block.name, input: block.input as Record<string, unknown> });
+      if (event.type === 'user' && block.type === 'tool_result' && !block.is_error) {
+        const call = calls.get(block.tool_use_id);
+        if (call) {
+          const output = typeof block.content === 'string' ? block.content : Array.isArray(block.content)
+            && block.content.every(part => part.type === 'text') ? block.content.map(part => (part as { text: string }).text).join('\n') : '';
+          let fullRead: string | undefined;
+          if (call.tool === 'Read' && typeof call.input.file_path === 'string' && Object.keys(call.input).length === 1) {
+            const file = path.resolve(fixture.repo, call.input.file_path);
+            const expected = fixture.readContents.get(file);
+            const native = (event as SDKMessage & { tool_use_result?: { type: string; file: { filePath: string; content?: string; startLine?: number; numLines?: number; totalLines?: number } } }).tool_use_result;
+            if (expected !== undefined && native?.file?.filePath === file) {
+              const lines = expected.split('\n');
+              if (native.type === 'text' && native.file.content === expected && native.file.startLine === 1
+                && native.file.numLines === lines.length && native.file.totalLines === lines.length
+                && output === lines.map((line, i) => `${i + 1}\t${line}`).join('\n')) {
+                delivered.add(file); fullRead = file;
+              } else if (native.type === 'file_unchanged' && output === UNCHANGED_READ && delivered.has(file)
+                && read(file) === expected) fullRead = file;
+            }
+          }
+          completed.push({ id: block.tool_use_id, ...call, output, index, fullRead });
+        }
+      }
+    }
+  }
+  const answer = evidence.answers[0];
+  check([...calls.values()].filter(call => call.tool === 'AskUserQuestion').length === 1, 'expected one native decision question');
+  const acknowledged = answer && completed.find(call => call.tool === 'AskUserQuestion' && call.id === answer.toolUseId
+    && isDeepStrictEqual(call.input.questions, answer.input.questions)
+    && Object.values(answer.answers).every(label => call.output.includes(label)));
+  check(!!acknowledged, 'native Skip response was not acknowledged');
+  check(!!acknowledged && completed.some(call => call.fullRead === fixture.workflowPath && call.index < acknowledged.index), 'complete workflow was not delivered before the decision');
+  check(!!acknowledged && [fixture.product, fixture.inputPath].every(file => completed.some(call => call.fullRead === file
+    && call.index < acknowledged.index)), 'owner decision lacks complete source and finding delivery');
+  const rediscovery = completed.find(call => call.tool === 'Bash' && String(call.input.command).trim() === fixture.commands.rediscover);
+  const advance = completed.find(call => call.tool === 'Bash' && String(call.input.command).trim() === fixture.commands.advance);
+  check(!!rediscovery && !!advance && completed.some(call => call.fullRead === fixture.product
+    && call.index > rediscovery.index && call.index < advance.index), 'source not re-read before routing');
+  check(!!advance, 'advancement command did not complete');
+  const actions = evidence.receipts.map(row => row.action);
+  check(JSON.stringify(actions.filter(action => action !== 'read')) === JSON.stringify(['persist', 'rediscover', 'advance']), 'expected persistence, rediscovery and advancement without requeue');
+  const row = evidence.persisted;
+  check(row?.skill === 'review' && row?.via === 'ship' && row?.status === 'issues_found'
+    && row?.issues_found === 1 && row?.critical === 1 && row?.informational === 0, 'skipped defect was silently cleared');
+  check(row?.completed === false && row?.converged === false && row?.cycles === 0, 'synthetic coverage was marked complete');
+  check(row?.review_binding?.state === 'incomplete' && row.review_binding.start_wtree === evidence.start.wtree
+    && row.review_binding.end_wtree === evidence.start.wtree && row.review_binding.started_at === evidence.start.started_at
+    && row.review_binding.branch_id === digest(evidence.start.branch), 'review record lost its owned unchanged incomplete binding');
+  check(row?.findings?.length === 1 && row.findings[0].fingerprint === 'invoice.ts:1:authorization'
+    && row.findings[0].action === 'skipped' && row.findings[0].severity === 'CRITICAL'
+    && row.findings[0].advisory !== true && isDeepStrictEqual(row.findings[0].decision_evidence, evidence.evidence), 'persisted Skip lost its identity or source evidence');
+  check(!row?.VERIFY_RESULT && !row?.verify_result && !row?.probes?.length, 'invented a passing probe or verification result');
+  return { failures, evidence };
+}
+
+export async function runShipSkipActor(record: (entry: EvalTestEntry) => void, injectedQuery?: QueryProvider, artifactDirectory?: string) {
+  const started = Date.now();
+  const deadline = started + CAPTURE_MS - 20000;
+  const artifacts = artifactDirectory ?? process.env.GSTACK_EVAL_DIR;
+  const evidenceFile = artifacts ? path.join(artifacts, `${SHIP_SKIP_CASE}-${randomUUID()}.json`) : undefined;
+  const roots: string[] = [];
+  type Fixture = ReturnType<typeof createShipSkipFixture>;
+  const attempts: Array<{ fixture: Fixture; events: SDKMessage[]; evidence?: ReturnType<Fixture['snapshot']>;
+    active: boolean; closed: boolean; drained: boolean; lateCallbacks: string[]; closeError?: string;
+    close?: () => void; finish?: () => Promise<void> }> = [];
+  let workflow = '';
+  let fixture: Fixture | undefined;
+  let result: AgentSdkResult | undefined;
+  let failure: unknown;
+  let passed = false;
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const remaining = () => {
+    const ms = deadline - Date.now();
+    if (ms <= 0) throw new Error('Ship Skip case deadline exhausted before query launch');
+    return ms;
+  };
+  const setup = () => {
+    remaining();
+    const root = fs.mkdtempSync(path.join(fs.realpathSync(os.tmpdir()), 'sskip-'));
+    roots.push(root);
+    const owned = createShipSkipFixture(workflow, root, deadline);
+    remaining();
+    return owned;
+  };
+  try {
+    if (!artifacts) throw new Error('Ship Skip actor requires GSTACK_EVAL_DIR for durable evidence');
+    fs.mkdirSync(artifacts, { recursive: true, mode: 0o700 });
+    const { query } = await import('@anthropic-ai/claude-agent-sdk');
+    const { runAgentSdkTest, resolveClaudeBinary } = await import('./agent-sdk-runner');
+    workflow = await shipSkipWorkflow();
+    fixture = setup();
+    const binary = injectedQuery ? undefined : resolveClaudeBinary();
+    if (!injectedQuery && !binary) throw new Error('Native ship Skip actor requires the pinned Claude CLI');
+    const controller = new AbortController();
+    const expired = new Promise<never>((_resolve, reject) => {
+      timer = setTimeout(() => { const error = new Error('Ship Skip case deadline exhausted'); controller.abort(error); reject(error); }, remaining());
+    });
+    const running = runAgentSdkTest({ systemPrompt: { type: 'preset', preset: 'claude_code' }, userPrompt: fixture.prompt,
+      workingDirectory: fixture.repo, env: fixture.env, maxTurns: SHARED_INTERACTIVE_MAX_TURNS,
+      signal: controller.signal, allowedTools: ['Read', 'Write', 'Bash', 'AskUserQuestion'],
+      settingSources: [], testName: SHIP_SKIP_CASE, pathToClaudeCodeExecutable: binary ?? undefined,
+      canUseTool: fixture.canUseTool,
+      queryProvider: options => {
+        remaining();
+        if (attempts.length) fixture = setup();
+        const owned = fixture!;
+        const attempt: typeof attempts[number] = { fixture: owned, events: [], active: true, closed: false, drained: false, lateCallbacks: [] };
+        attempts.push(attempt);
+        const expiredCallback = (tool: string) => {
+          if (attempt.active && Date.now() < deadline) return false;
+          attempt.lateCallbacks.push(tool); return true;
+        };
+        let stream: ReturnType<QueryProvider>;
+        try {
+          stream = (injectedQuery ?? query)({ ...options, prompt: owned.prompt, options: { ...options.options,
+            cwd: owned.repo, env: { ...options.options?.env, ...owned.env }, allowedTools: [],
+            canUseTool: (...args) => expiredCallback(args[0]) ? Promise.resolve({ behavior: 'deny' as const, message: 'Attempt is closed or expired' }) : owned.canUseTool(...args),
+            hooks: { PreToolUse: [{ hooks: [(...args) => expiredCallback(args[0].hook_event_name)
+              ? Promise.resolve({ hookSpecificOutput: { hookEventName: 'PreToolUse' as const, permissionDecision: 'deny' as const, permissionDecisionReason: 'Attempt is closed or expired' } })
+              : owned.preToolUse(...args)] }] } } });
+        } catch (error) { attempt.active = false; attempt.closed = true; attempt.drained = true; throw error; }
+        const iterator = stream[Symbol.asyncIterator]();
+        attempt.close = () => {
+          attempt.active = false;
+          if (attempt.closed) return;
+          attempt.closed = true;
+          try { stream.close(); } catch (error) { attempt.closeError = String(error); }
+        };
+        let finishing: Promise<void> | undefined;
+        attempt.finish = () => finishing ??= (async () => {
+          attempt.close!();
+          try { await iterator.return?.(); attempt.drained = !attempt.closeError; }
+          catch (error) { attempt.closeError ??= String(error); throw error; }
+          finally { attempt.evidence = owned.snapshot(); }
+        })();
+        return new Proxy(stream, { get(target, property) {
+          if (property === 'close') return attempt.close;
+          if (property === Symbol.asyncIterator) return async function* () {
+            try {
+              while (true) {
+                const next = await iterator.next();
+                if (next.done) break;
+                attempt.events.push(next.value); yield next.value;
+              }
+            } finally { await attempt.finish!(); }
+          };
+          const value = Reflect.get(target, property, target);
+          return typeof value === 'function' ? value.bind(target) : value;
+        } });
+      },
+    });
+    result = await Promise.race([running, expired]);
+    const verdict = shipSkipFailures(fixture!, result);
+    if (verdict.failures.length) throw new Error(verdict.failures.join('; '));
+    passed = true;
+  } catch (error) { failure = error; }
+  finally {
+    clearTimeout(timer);
+    try {
+      for (const attempt of attempts) attempt.close?.();
+      let drainTimer: ReturnType<typeof setTimeout> | undefined;
+      try {
+        await Promise.race([Promise.all(attempts.map(attempt => attempt.finish?.())), new Promise<never>((_resolve, reject) => {
+          drainTimer = setTimeout(() => reject(new Error('Native query did not drain before the artifact deadline')), Math.max(1, started + CAPTURE_MS - 1000 - Date.now()));
+        })]);
+        const closeError = attempts.find(attempt => attempt.closeError)?.closeError;
+        if (closeError) throw new Error(closeError);
+      } catch (error) { failure ??= error; passed = false; }
+      finally { clearTimeout(drainTimer); }
+      const retainedRoots = attempts.filter(attempt => !attempt.drained).map(attempt => attempt.fixture.root);
+      const snapshots = attempts.map(({ fixture: owned, events, evidence, active, closed, drained, lateCallbacks, closeError }) => ({
+        events, evidence: evidence ?? owned.snapshot(), prompt: owned.prompt, environment: owned.env,
+        active, closed, drained, lateCallbacks, closeError }));
+      const charges = attempts.map(({ events, drained }) => {
+        const terminal = events.findLast(event => event.type === 'result');
+        const costUsd = typeof terminal?.total_cost_usd === 'number' && Number.isFinite(terminal.total_cost_usd)
+          && terminal.total_cost_usd >= 0 ? terminal.total_cost_usd : null;
+        return { costUsd, costKnown: costUsd !== null && drained };
+      });
+      const costKnown = charges.every(charge => charge.costKnown);
+      const billing = { knownCostUsd: charges.reduce((sum, charge) => sum + (charge.costUsd ?? 0), 0), costKnown,
+        status: !attempts.length ? 'not_started' : costKnown ? 'complete' : 'incomplete', attempts: charges };
+      const billingNote = costKnown ? '' : 'Terminal billing is incomplete; actual total cost is unknown. Only known charges are summed; all attempt events are retained.';
+      const output = JSON.stringify({ error: failure === undefined ? undefined : String(failure),
+        prompt: fixture?.prompt, workflow, evidence: fixture?.snapshot(), attempts: snapshots, output: result?.output,
+        started, deadline, roots, retainedRoots, billing });
+      if (evidenceFile) fs.writeFileSync(evidenceFile, output + '\n', { mode: 0o600 });
+      record({ name: SHIP_SKIP_CASE, suite: 'ship-skip-boundary', tier: 'e2e', passed, duration_ms: Date.now() - started,
+        cost_usd: billing.knownCostUsd, transcript: [{ type: 'fixture_billing', cost_known: costKnown, billing }, ...attempts.flatMap(attempt => attempt.events)],
+        prompt: fixture?.prompt, turns_used: result?.turnsUsed, model: result?.model, output,
+        error: [failure === undefined ? '' : String(failure), billingNote].filter(Boolean).join('\n') || undefined,
+        exit_reason: passed ? 'success' : result?.exitReason === 'success' ? 'assertion_failed' : result?.exitReason ?? 'runner_error' });
+    } finally {
+      for (const root of roots) if (!attempts.some(attempt => attempt.fixture.root === root && !attempt.drained)) fs.rmSync(root, { recursive: true, force: true });
+    }
+  }
+  if (failure !== undefined) throw failure;
+  return evidenceFile!;
+}
+
+if (import.meta.main && process.argv[2] === '--fixture') {
+  const root = fs.realpathSync(process.argv[3]);
+  const config = json(path.join(root, 'fixture.json'));
+  const action = process.argv[4];
+  const env = { ...process.env, ...config.env };
+  const helper = (name: string, args: string[]) => command(config.repo, env, path.join(ROOT, 'bin', name), args);
+  const rows = () => helper('gstack-review-read', []).split('---CONFIG---')[0].trim().split('\n').filter(Boolean).map(line => JSON.parse(line));
+  const receipts = read(config.receipts).trim().split('\n').filter(Boolean).map(line => JSON.parse(line));
+  let output: unknown;
+  if (action === 'read') output = helper('gstack-review-read', []);
+  else if (action === 'persist') {
+    if (!fs.existsSync(config.answersPath) || receipts.some(row => row.action === 'persist')) throw new Error('Persistence requires one real owner answer and an unconsumed token');
+    helper('gstack-review-log', [JSON.stringify(json(config.draft)), '--finish', config.token]);
+    const persisted = rows().at(-1);
+    write(path.join(root, 'persisted.json'), persisted);
+    output = persisted;
+  } else if (action === 'rediscover') {
+    if (!receipts.some(row => row.action === 'persist') || digest(read(config.product)) !== config.evidence.sha256) throw new Error('Rediscovery requires persistence and unchanged source');
+    output = { source: 'synthetic native-review fixture result', native_completed: true, finding: config.finding,
+      review_coverage: 'not_executed', probes: [], release_eligible: false };
+  } else if (action === 'advance' || action === 'repeat') {
+    if (!receipts.some(row => row.action === 'rediscover')) throw new Error('Routing requires the rediscovered finding');
+    output = { boundary: action === 'advance' ? '11.5' : '9→10→11', release_eligible: false };
+  } else throw new Error('Unknown fixture action');
+  fs.appendFileSync(config.receipts, JSON.stringify({ action, evidence: config.evidence }) + '\n', { mode: 0o600 });
+  console.log(typeof output === 'string' ? output : JSON.stringify(output));
+}

test/helpers/skill-fixture.ts

@@ -151,7 +151,7 @@ function splitFrontmatter(raw: string, file: string): { frontmatter: string; bod
  * Standalone generated STOP-Read blocks between horizontal rules replace
  * entire carved steps and end the preceding H2. Nested pointers stay inside it.
  */
-function scanH2Sections(bodyLines: string[]): H2Section[] {
+function scanH2Sections(bodyLines: string[], stopAtH1 = false): H2Section[] {
   const sections: H2Section[] = [];
   let fence: { ch: string; len: number } | null = null;
 
@@ -170,6 +170,7 @@ function scanH2Sections(bodyLines: string[]): H2Section[] {
     }
     if (!fence) {
       const heading = line.startsWith('## ');
+      const title = stopAtH1 && /^ {0,3}#(?:[ \t]|$)/.test(line);
       let carvedStep = /^> \*\*STOP\.\*\* Before .+, Read `[^`]+\/sections\/[^`]+\.md` and execute it$/.test(line)
         && bodyLines[i + 1] === '> in full. Do not work from memory — that section is the source of truth for this step.';
       if (carvedStep) {
@@ -179,7 +180,7 @@ function scanH2Sections(bodyLines: string[]): H2Section[] {
         while (following < bodyLines.length && !bodyLines[following].trim()) following++;
         carvedStep = bodyLines[preceding] === '---' && bodyLines[following] === '---';
       }
-      if (heading || carvedStep) {
+      if (heading || title || carvedStep) {
         const previous = sections.at(-1);
         if (previous) previous.end = Math.min(previous.end, i);
         if (heading) sections.push({ heading: line.slice(3).trim(), start: i, end: bodyLines.length });
@@ -189,7 +190,7 @@ function scanH2Sections(bodyLines: string[]): H2Section[] {
   return sections;
 }
 
-function loadSkill(skillDirOrFile: string): {
+function loadSkill(skillDirOrFile: string, stopAtH1 = false): {
   file: string;
   frontmatter: string;
   bodyLines: string[];
@@ -198,7 +199,7 @@ function loadSkill(skillDirOrFile: string): {
   const file = resolveSkillMd(skillDirOrFile);
   const raw = fs.readFileSync(file, 'utf-8');
   const { frontmatter, bodyLines } = splitFrontmatter(raw, file);
-  return { file, frontmatter, bodyLines, sections: scanH2Sections(bodyLines) };
+  return { file, frontmatter, bodyLines, sections: scanH2Sections(bodyLines, stopAtH1) };
 }
 
 function findSection(sections: H2Section[], name: string, file: string): H2Section {
@@ -240,7 +241,7 @@ export function extractSkillSections(skillDir: string, sections: string[]): stri
  * ~780-line shared generated preamble and nothing else.
  */
 export function extractSkillBody(skillDir: string): string {
-  const { file, frontmatter, bodyLines, sections: all } = loadSkill(skillDir);
+  const { file, frontmatter, bodyLines, sections: all } = loadSkill(skillDir, true);
   const boundary = (names: string[]): H2Section => {
     const matches = all.filter(section => names.includes(section.heading));
     const label = names.map(name => `"## ${name}"`).join(' or ');

test/helpers/touchfiles-data.ts

@@ -21,21 +21,53 @@
  * Each test lists the file patterns that, if changed, require the test to run.
  */
 export const E2E_TOUCHFILES: Record<string, string[]> = {
+  'ship-skipped-queued-finding': [
+    'package.json', 'bun.lock', '.github/docker/Dockerfile.ci',
+    'scripts/resolvers/review.ts', 'scripts/resolvers/sections.ts', 'scripts/resolvers/index.ts',
+    'scripts/resolvers/types.ts', 'scripts/gen-skill-docs.ts', 'scripts/host-config.ts',
+    'scripts/discover-skills.ts', 'hosts/claude.ts', 'hosts/index.ts', 'hosts/define-host.ts',
+    'ship/sections/review-army.md*', 'ship/sections/adversarial.md*', 'ship/sections/manifest.json',
+    'review/checklist.md', 'bin/gstack-review-log', 'bin/gstack-review-read', 'bin/gstack-wtree',
+    'bin/gstack-slug', 'bin/gstack-config', 'bin/gstack-brain-enqueue',
+    'lib/review-evidence.ts', 'lib/claude-bin.ts', 'lib/eval-model.ts',
+    'test/helpers/ship-skip-actor.ts', 'test/ship-skip-actor.test.ts', 'test/ship-skip-selection.test.ts',
+    'test/helpers/scratch-repo.ts',
+    'test/skill-e2e-ship-skip.test.ts', 'test/helpers/shared-libs-eval-fixture.ts',
+    'test/helpers/agent-sdk-runner.ts', 'test/helpers/hermetic-env.ts',
+    'test/helpers/e2e-gate.ts', 'test/helpers/eval-budgets.ts',
+  ],
   'investigate-owned-completion': ['investigate/**', 'freeze/**', 'guard/**', 'unfreeze/**', 'careful/bin/hook-extract.sh', 'scripts/gen-skill-docs.ts', 'test/helpers/agent-sdk-runner.ts', 'test/helpers/hermetic-env.ts', 'test/helpers/workflow-boundaries-fixture.ts', 'test/workflow-boundaries-fixture.test.ts', 'test/skill-e2e-investigate-owned-completion.test.ts'],
   'investigate-owned-abort': ['investigate/**', 'freeze/**', 'guard/**', 'unfreeze/**', 'careful/bin/hook-extract.sh', 'scripts/gen-skill-docs.ts', 'test/helpers/agent-sdk-runner.ts', 'test/helpers/hermetic-env.ts', 'test/helpers/workflow-boundaries-fixture.ts', 'test/workflow-boundaries-fixture.test.ts', 'test/skill-e2e-investigate-owned-termination.test.ts'],
   'investigate-owned-ending-error': ['investigate/**', 'freeze/**', 'guard/**', 'unfreeze/**', 'careful/bin/hook-extract.sh', 'scripts/gen-skill-docs.ts', 'test/helpers/agent-sdk-runner.ts', 'test/helpers/hermetic-env.ts', 'test/helpers/workflow-boundaries-fixture.ts', 'test/workflow-boundaries-fixture.test.ts', 'test/skill-e2e-investigate-owned-termination.test.ts'],
-  'shared-libs-review-path-eligibility': ['review/**', 'scripts/resolvers/shared-libs.ts', 'scripts/resolvers/review.ts', 'scripts/resolvers/review-army.ts', 'lib/review-evidence.ts', 'bin/gstack-review-log', 'bin/gstack-review-read', 'bin/gstack-wtree', 'test/helpers/shared-libs-eval-fixture.ts', 'test/skill-e2e-shared-libs-paths.test.ts', 'test/helpers/shared-libs-path-fixture.ts', 'test/shared-libs-fixture.test.ts', 'test/helpers/e2e-gate.ts', 'scripts/gen-skill-docs.ts', 'test/helpers/agent-sdk-runner.ts', 'lib/claude-bin.ts', 'lib/eval-model.ts', 'test/fixtures/shared-libs-index-flags-*.json', 'test/shared-libs-revalidation-prompt.test.ts', 'test/shared-libs-source-reads.test.ts', 'test/fixtures/shared-libs-resolved-reads-public.json'],
-  'shared-libs-review-index-flags': ['review/**', 'scripts/resolvers/shared-libs.ts', 'scripts/resolvers/review.ts', 'scripts/resolvers/review-army.ts', 'lib/review-evidence.ts', 'bin/gstack-review-log', 'bin/gstack-review-read', 'bin/gstack-wtree', 'test/helpers/shared-libs-eval-fixture.ts', 'test/skill-e2e-shared-libs-paths.test.ts', 'test/helpers/shared-libs-path-fixture.ts', 'test/shared-libs-fixture.test.ts', 'test/helpers/e2e-gate.ts', 'scripts/gen-skill-docs.ts', 'test/helpers/agent-sdk-runner.ts', 'lib/claude-bin.ts', 'lib/eval-model.ts', 'test/fixtures/shared-libs-index-flags-*.json', 'test/shared-libs-revalidation-prompt.test.ts', 'test/fixtures/shared-libs-paths-max-turns-public.json', 'test/shared-libs-source-reads.test.ts', 'test/fixtures/shared-libs-resolved-reads-public.json'],
-  'shared-libs-review-prior-coverage': ['review/**', 'scripts/resolvers/shared-libs.ts', 'scripts/resolvers/review.ts', 'scripts/resolvers/review-army.ts', 'lib/review-evidence.ts', 'bin/gstack-review-log', 'bin/gstack-review-read', 'bin/gstack-wtree', 'test/helpers/shared-libs-eval-fixture.ts', 'test/skill-e2e-shared-libs-paths.test.ts', 'test/helpers/shared-libs-path-fixture.ts', 'test/shared-libs-fixture.test.ts', 'test/helpers/e2e-gate.ts', 'scripts/gen-skill-docs.ts', 'test/helpers/agent-sdk-runner.ts', 'lib/claude-bin.ts', 'lib/eval-model.ts', 'test/fixtures/shared-libs-index-flags-*.json', 'test/shared-libs-revalidation-prompt.test.ts', 'test/shared-libs-source-reads.test.ts', 'test/fixtures/shared-libs-resolved-reads-public.json'],
+  'shared-libs-review-path-eligibility': ['review/**', 'scripts/resolvers/shared-libs.ts', 'scripts/resolvers/review.ts', 'scripts/resolvers/review-army.ts', 'lib/review-evidence.ts', 'bin/gstack-review-log', 'bin/gstack-review-read', 'bin/gstack-wtree', 'test/helpers/shared-libs-eval-fixture.ts', 'test/shared-libs-cancellation.test.ts', 'test/skill-e2e-shared-libs-paths.test.ts', 'test/helpers/shared-libs-path-fixture.ts', 'test/shared-libs-fixture.test.ts', 'test/helpers/e2e-gate.ts', 'scripts/gen-skill-docs.ts', 'test/helpers/agent-sdk-runner.ts', 'lib/claude-bin.ts', 'lib/eval-model.ts', 'test/fixtures/shared-libs-index-flags-*.json', 'test/shared-libs-revalidation-prompt.test.ts', 'test/shared-libs-source-reads.test.ts', 'test/fixtures/shared-libs-resolved-reads-public.json', 'test/shared-libs-checker-interface-evidence.test.ts'],
+  'shared-libs-review-index-flags': ['review/**', 'scripts/resolvers/shared-libs.ts', 'scripts/resolvers/review.ts', 'scripts/resolvers/review-army.ts', 'lib/review-evidence.ts', 'bin/gstack-review-log', 'bin/gstack-review-read', 'bin/gstack-wtree', 'test/helpers/shared-libs-eval-fixture.ts', 'test/shared-libs-cancellation.test.ts', 'test/skill-e2e-shared-libs-paths.test.ts', 'test/helpers/shared-libs-path-fixture.ts', 'test/shared-libs-fixture.test.ts', 'test/helpers/e2e-gate.ts', 'scripts/gen-skill-docs.ts', 'test/helpers/agent-sdk-runner.ts', 'lib/claude-bin.ts', 'lib/eval-model.ts', 'test/fixtures/shared-libs-index-flags-*.json', 'test/shared-libs-revalidation-prompt.test.ts', 'test/fixtures/shared-libs-paths-max-turns-public.json', 'test/shared-libs-source-reads.test.ts', 'test/fixtures/shared-libs-resolved-reads-public.json', 'test/shared-libs-checker-interface-evidence.test.ts'],
+  'shared-libs-review-prior-coverage': ['review/**', 'scripts/resolvers/shared-libs.ts', 'scripts/resolvers/review.ts', 'scripts/resolvers/review-army.ts', 'lib/review-evidence.ts', 'bin/gstack-review-log', 'bin/gstack-review-read', 'bin/gstack-wtree', 'test/helpers/shared-libs-eval-fixture.ts', 'test/shared-libs-cancellation.test.ts', 'test/skill-e2e-shared-libs-paths.test.ts', 'test/helpers/shared-libs-path-fixture.ts', 'test/shared-libs-fixture.test.ts', 'test/helpers/e2e-gate.ts', 'scripts/gen-skill-docs.ts', 'test/helpers/agent-sdk-runner.ts', 'lib/claude-bin.ts', 'lib/eval-model.ts', 'test/fixtures/shared-libs-index-flags-*.json', 'test/shared-libs-revalidation-prompt.test.ts', 'test/shared-libs-source-reads.test.ts', 'test/fixtures/shared-libs-resolved-reads-public.json', 'test/shared-libs-checker-interface-evidence.test.ts'],
   'shared-libs-codex-read-only': ['deslop-shared-libs/**', 'scripts/resolvers/shared-libs.ts', 'scripts/resolvers/index.ts', 'scripts/gen-skill-docs.ts', 'test/helpers/shared-libs-eval-fixture.ts', 'test/helpers/codex-session-runner.ts', 'test/helpers/skill-fixture.ts', 'test/helpers/hermetic-env.ts', 'test/helpers/eval-budgets.ts', 'test/codex-e2e-shared-libs.test.ts', 'test/shared-libs-fixture.test.ts', 'test/helpers/e2e-gate.ts', 'hosts/codex.ts', 'hosts/define-host.ts', 'scripts/resolvers/constants.ts', 'test/fixtures/shared-libs-readonly-substitution-ci16358.json'],
   // Shared-code audit and scoped review lifecycle
-  'shared-libs-read-only': ['deslop-shared-libs/**', 'scripts/resolvers/shared-libs.ts', 'scripts/resolvers/index.ts', 'test/helpers/shared-libs-eval-fixture.ts', 'test/skill-e2e-shared-libs.test.ts', 'test/shared-libs-fixture.test.ts', 'test/helpers/e2e-gate.ts', 'scripts/gen-skill-docs.ts', 'lib/claude-bin.ts', 'lib/eval-model.ts', 'test/fixtures/shared-libs-readonly-substitution-ci16358.json'],
-  'shared-libs-unsupported-git': ['deslop-shared-libs/**', 'scripts/resolvers/shared-libs.ts', 'scripts/resolvers/index.ts', 'test/helpers/shared-libs-eval-fixture.ts', 'test/skill-e2e-shared-libs.test.ts', 'test/shared-libs-fixture.test.ts', 'test/helpers/e2e-gate.ts', 'scripts/gen-skill-docs.ts', 'lib/claude-bin.ts', 'lib/eval-model.ts', 'test/fixtures/shared-libs-readonly-substitution-ci16358.json'],
-  'shared-libs-review-lifecycle': ['deslop-shared-libs/**', 'scripts/resolvers/shared-libs.ts', 'scripts/resolvers/index.ts', 'test/helpers/shared-libs-eval-fixture.ts', 'review/**', 'scripts/resolvers/review.ts', 'scripts/resolvers/review-army.ts', 'lib/review-evidence.ts', 'bin/gstack-review-log', 'bin/gstack-review-read', 'bin/gstack-wtree', 'test/skill-e2e-shared-libs.test.ts', 'test/shared-libs-fixture.test.ts', 'test/helpers/e2e-gate.ts', 'scripts/gen-skill-docs.ts', 'test/helpers/agent-sdk-runner.ts', 'lib/claude-bin.ts', 'lib/eval-model.ts', 'test/fixtures/shared-libs-index-flags-*.json'],
-  'shared-libs-review-revalidation': ['deslop-shared-libs/**', 'scripts/resolvers/shared-libs.ts', 'scripts/resolvers/index.ts', 'test/helpers/shared-libs-eval-fixture.ts', 'review/**', 'scripts/resolvers/review.ts', 'scripts/resolvers/review-army.ts', 'lib/review-evidence.ts', 'bin/gstack-review-log', 'bin/gstack-review-read', 'bin/gstack-wtree', 'test/skill-e2e-shared-libs.test.ts', 'test/shared-libs-fixture.test.ts', 'test/helpers/e2e-gate.ts', 'scripts/gen-skill-docs.ts', 'test/helpers/agent-sdk-runner.ts', 'lib/claude-bin.ts', 'lib/eval-model.ts', 'test/helpers/shared-libs-review-start-evidence.ts', 'test/shared-libs-review-start-evidence.test.ts', 'test/fixtures/shared-libs-review-start-public.json', 'test/shared-libs-revalidation-prompt.test.ts', 'test/fixtures/shared-libs-revalidation-max-turns-public.json', 'test/fixtures/shared-libs-index-flags-*.json'],
-  'shared-libs-opportunity-judgment': ['deslop-shared-libs/**', 'scripts/resolvers/shared-libs.ts', 'scripts/resolvers/index.ts', 'test/helpers/shared-libs-eval-fixture.ts', 'test/skill-e2e-shared-libs-periodic.test.ts', 'test/shared-libs-fixture.test.ts', 'test/helpers/e2e-gate.ts', 'scripts/gen-skill-docs.ts', 'test/helpers/llm-judge.ts', 'lib/claude-bin.ts', 'lib/eval-model.ts', 'test/fixtures/shared-libs-readonly-substitution-ci16358.json'],
-  'shared-libs-pr-coverage': ['deslop-shared-libs/**', 'scripts/resolvers/shared-libs.ts', 'scripts/resolvers/index.ts', 'test/helpers/shared-libs-eval-fixture.ts', 'test/skill-e2e-shared-libs-periodic.test.ts', 'test/shared-libs-fixture.test.ts', 'test/helpers/e2e-gate.ts', 'scripts/gen-skill-docs.ts', 'test/helpers/llm-judge.ts', 'lib/claude-bin.ts', 'lib/eval-model.ts', 'test/fixtures/shared-libs-readonly-substitution-ci16358.json'],
-  'shared-libs-plan-callers': ['test/helpers/shared-libs-plan-actor.ts', 'test/shared-libs-plan-actor.test.ts', 'scripts/resolvers/confidence.ts', 'test/helpers/shared-libs-plan-excerpt.ts', 'test/shared-libs-rendering.test.ts', 'scripts/resolvers/preamble/generate-ask-user-format.ts', 'deslop-shared-libs/**', 'scripts/resolvers/shared-libs.ts', 'scripts/resolvers/index.ts', 'test/helpers/shared-libs-eval-fixture.ts', 'plan-eng-review/**', 'test/skill-e2e-shared-libs-periodic.test.ts', 'test/eng-scope-entry-ap.test.ts', 'test/plan-scope-recovery-av.test.ts', 'test/fixtures/plan-scope-recovery-av.json', 'test/review-entry-and-design-clarity-au.test.ts', 'scripts/resolvers/preamble/generate-preamble-bash.ts', 'scripts/resolvers/preamble/generate-completion-status.ts', 'test/shared-libs-fixture.test.ts', 'test/helpers/e2e-gate.ts', 'scripts/gen-skill-docs.ts', 'test/helpers/agent-sdk-runner.ts', 'test/helpers/llm-judge.ts', 'lib/claude-bin.ts', 'lib/eval-model.ts'],
+  'shared-libs-read-only': ['deslop-shared-libs/**', 'scripts/resolvers/shared-libs.ts', 'scripts/resolvers/index.ts', 'test/helpers/shared-libs-eval-fixture.ts', 'test/shared-libs-cancellation.test.ts', 'test/skill-e2e-shared-libs.test.ts', 'test/shared-libs-fixture.test.ts', 'test/helpers/e2e-gate.ts', 'scripts/gen-skill-docs.ts', 'lib/claude-bin.ts', 'lib/eval-model.ts', 'test/fixtures/shared-libs-readonly-substitution-ci16358.json'],
+  'shared-libs-unsupported-git': ['deslop-shared-libs/**', 'scripts/resolvers/shared-libs.ts', 'scripts/resolvers/index.ts', 'test/helpers/shared-libs-eval-fixture.ts', 'test/shared-libs-cancellation.test.ts', 'test/skill-e2e-shared-libs.test.ts', 'test/shared-libs-fixture.test.ts', 'test/helpers/e2e-gate.ts', 'scripts/gen-skill-docs.ts', 'lib/claude-bin.ts', 'lib/eval-model.ts', 'test/fixtures/shared-libs-readonly-substitution-ci16358.json'],
+  'shared-libs-review-lifecycle': ['deslop-shared-libs/**', 'scripts/resolvers/shared-libs.ts', 'scripts/resolvers/index.ts', 'test/helpers/shared-libs-eval-fixture.ts', 'test/shared-libs-cancellation.test.ts', 'review/**', 'scripts/resolvers/review.ts', 'scripts/resolvers/review-army.ts', 'lib/review-evidence.ts', 'bin/gstack-review-log', 'bin/gstack-review-read', 'bin/gstack-wtree', 'test/skill-e2e-shared-libs.test.ts', 'test/shared-libs-fixture.test.ts', 'test/helpers/e2e-gate.ts', 'scripts/gen-skill-docs.ts', 'test/helpers/agent-sdk-runner.ts', 'lib/claude-bin.ts', 'lib/eval-model.ts', 'test/fixtures/shared-libs-index-flags-*.json', 'test/helpers/shared-libs-path-fixture.ts', 'test/shared-libs-stage-actor.test.ts', 'test/fixtures/shared-libs-lifecycle-r59-stage-scope-public.json', 'test/shared-libs-revalidation-prompt.test.ts'],
+  'shared-libs-review-revalidation': ['deslop-shared-libs/**', 'scripts/resolvers/shared-libs.ts', 'scripts/resolvers/index.ts', 'test/helpers/shared-libs-eval-fixture.ts', 'test/shared-libs-cancellation.test.ts', 'review/**', 'scripts/resolvers/review.ts', 'scripts/resolvers/review-army.ts', 'lib/review-evidence.ts', 'bin/gstack-review-log', 'bin/gstack-review-read', 'bin/gstack-wtree', 'test/skill-e2e-shared-libs.test.ts', 'test/shared-libs-fixture.test.ts', 'test/helpers/e2e-gate.ts', 'scripts/gen-skill-docs.ts', 'test/helpers/agent-sdk-runner.ts', 'lib/claude-bin.ts', 'lib/eval-model.ts', 'test/helpers/shared-libs-review-start-evidence.ts', 'test/shared-libs-review-start-evidence.test.ts', 'test/fixtures/shared-libs-review-start-public.json', 'test/shared-libs-revalidation-prompt.test.ts', 'test/fixtures/shared-libs-revalidation-max-turns-public.json', 'test/fixtures/shared-libs-index-flags-*.json', 'test/shared-libs-checker-interface-evidence.test.ts', 'test/helpers/shared-libs-path-fixture.ts', 'test/shared-libs-stage-actor.test.ts'],
+  'shared-libs-opportunity-judgment': ['deslop-shared-libs/**', 'scripts/resolvers/shared-libs.ts', 'scripts/resolvers/index.ts', 'test/helpers/shared-libs-eval-fixture.ts', 'test/shared-libs-cancellation.test.ts', 'test/skill-e2e-shared-libs-periodic.test.ts', 'test/shared-libs-fixture.test.ts', 'test/helpers/e2e-gate.ts', 'scripts/gen-skill-docs.ts', 'test/helpers/llm-judge.ts', 'lib/claude-bin.ts', 'lib/eval-model.ts', 'test/fixtures/shared-libs-readonly-substitution-ci16358.json'],
+  'shared-libs-pr-coverage': ['deslop-shared-libs/**', 'scripts/resolvers/shared-libs.ts', 'scripts/resolvers/index.ts', 'test/helpers/shared-libs-eval-fixture.ts', 'test/shared-libs-cancellation.test.ts', 'test/skill-e2e-shared-libs-periodic.test.ts', 'test/shared-libs-fixture.test.ts', 'test/helpers/e2e-gate.ts', 'scripts/gen-skill-docs.ts', 'test/helpers/llm-judge.ts', 'lib/claude-bin.ts', 'lib/eval-model.ts', 'test/fixtures/shared-libs-readonly-substitution-ci16358.json'],
+  'shared-libs-plan-callers': ['test/helpers/shared-libs-plan-actor.ts', 'test/shared-libs-plan-actor.test.ts', 'scripts/resolvers/confidence.ts', 'test/helpers/shared-libs-plan-excerpt.ts', 'test/shared-libs-rendering.test.ts', 'scripts/resolvers/preamble/generate-ask-user-format.ts', 'deslop-shared-libs/**', 'scripts/resolvers/shared-libs.ts', 'scripts/resolvers/index.ts', 'test/helpers/shared-libs-eval-fixture.ts', 'test/shared-libs-cancellation.test.ts', 'plan-eng-review/**', 'test/skill-e2e-shared-libs-periodic.test.ts', 'test/eng-scope-entry-ap.test.ts', 'test/plan-scope-recovery-av.test.ts', 'test/fixtures/plan-scope-recovery-av.json', 'test/review-entry-and-design-clarity-au.test.ts', 'scripts/resolvers/preamble/generate-preamble-bash.ts', 'scripts/resolvers/preamble/generate-completion-status.ts', 'test/shared-libs-fixture.test.ts', 'test/helpers/e2e-gate.ts', 'scripts/gen-skill-docs.ts', 'test/helpers/agent-sdk-runner.ts', 'test/helpers/llm-judge.ts', 'lib/claude-bin.ts', 'lib/eval-model.ts'],
+  'ship-docsync-missing-marker': ['ship/**', 'document-release/**', 'scripts/resolvers/sections.ts', 'scripts/resolvers/preamble.ts', 'scripts/resolvers/testing.ts', 'scripts/gen-skill-docs.ts', 'bin/gstack-skill-start', 'bin/gstack-session-kind', 'test/helpers/docsync-*.ts', 'test/helpers/qa-functional-*.ts', 'test/helpers/session-runner.ts', 'test/helpers/hermetic-env.ts', 'test/skill-e2e-ship-docsync.test.ts', 'test/helpers/qa-checkpoint-evidence.ts', 'test/qa-checkpoint-evidence.test.ts', 'test/docsync-atomic-writes.test.ts', 'test/docsync-nested-writes.test.ts', 'test/docsync-lifecycle-interface.test.ts'],
+  'ship-docsync-missing-asset': ['ship/**', 'document-release/**', 'scripts/resolvers/sections.ts', 'scripts/resolvers/preamble.ts', 'scripts/resolvers/testing.ts', 'scripts/gen-skill-docs.ts', 'bin/gstack-skill-start', 'bin/gstack-session-kind', 'test/helpers/docsync-*.ts', 'test/helpers/qa-functional-*.ts', 'test/helpers/session-runner.ts', 'test/helpers/hermetic-env.ts', 'test/skill-e2e-ship-docsync.test.ts', 'test/helpers/qa-checkpoint-evidence.ts', 'test/qa-checkpoint-evidence.test.ts', 'test/docsync-atomic-writes.test.ts', 'test/docsync-nested-writes.test.ts', 'test/docsync-lifecycle-interface.test.ts'],
+  'ship-docsync-launch-failure': ['ship/**', 'document-release/**', 'scripts/resolvers/sections.ts', 'scripts/resolvers/preamble.ts', 'scripts/resolvers/testing.ts', 'scripts/gen-skill-docs.ts', 'bin/gstack-skill-start', 'bin/gstack-session-kind', 'test/helpers/docsync-*.ts', 'test/helpers/qa-functional-*.ts', 'test/helpers/session-runner.ts', 'test/helpers/hermetic-env.ts', 'test/skill-e2e-ship-docsync.test.ts', 'test/helpers/qa-checkpoint-evidence.ts', 'test/qa-checkpoint-evidence.test.ts', 'test/docsync-atomic-writes.test.ts', 'test/docsync-nested-writes.test.ts', 'test/docsync-lifecycle-interface.test.ts'],
+  'ship-docsync-timeout-unsettled': ['ship/**', 'document-release/**', 'scripts/resolvers/sections.ts', 'scripts/resolvers/preamble.ts', 'scripts/resolvers/testing.ts', 'scripts/gen-skill-docs.ts', 'bin/gstack-skill-start', 'bin/gstack-session-kind', 'test/helpers/docsync-*.ts', 'test/helpers/qa-functional-*.ts', 'test/helpers/session-runner.ts', 'test/helpers/hermetic-env.ts', 'test/skill-e2e-ship-docsync.test.ts', 'test/helpers/qa-checkpoint-evidence.ts', 'test/qa-checkpoint-evidence.test.ts', 'test/docsync-atomic-writes.test.ts', 'test/docsync-nested-writes.test.ts', 'test/docsync-lifecycle-interface.test.ts'],
+  'ship-docsync-late-result': ['ship/**', 'document-release/**', 'scripts/resolvers/sections.ts', 'scripts/resolvers/preamble.ts', 'scripts/resolvers/testing.ts', 'scripts/gen-skill-docs.ts', 'bin/gstack-skill-start', 'bin/gstack-session-kind', 'test/helpers/docsync-*.ts', 'test/helpers/qa-functional-*.ts', 'test/helpers/session-runner.ts', 'test/helpers/hermetic-env.ts', 'test/skill-e2e-ship-docsync.test.ts', 'test/helpers/qa-checkpoint-evidence.ts', 'test/qa-checkpoint-evidence.test.ts', 'test/docsync-atomic-writes.test.ts', 'test/docsync-nested-writes.test.ts', 'test/docsync-lifecycle-interface.test.ts'],
+  'ship-docsync-stale-before': ['ship/**', 'document-release/**', 'scripts/resolvers/sections.ts', 'scripts/resolvers/preamble.ts', 'scripts/resolvers/testing.ts', 'scripts/gen-skill-docs.ts', 'bin/gstack-skill-start', 'bin/gstack-session-kind', 'test/helpers/docsync-*.ts', 'test/helpers/qa-functional-*.ts', 'test/helpers/session-runner.ts', 'test/helpers/hermetic-env.ts', 'test/skill-e2e-ship-docsync.test.ts', 'test/helpers/qa-checkpoint-evidence.ts', 'test/qa-checkpoint-evidence.test.ts', 'test/docsync-atomic-writes.test.ts', 'test/docsync-nested-writes.test.ts', 'test/docsync-lifecycle-interface.test.ts'],
+  'ship-docsync-stale-after': ['ship/**', 'document-release/**', 'scripts/resolvers/sections.ts', 'scripts/resolvers/preamble.ts', 'scripts/resolvers/testing.ts', 'scripts/gen-skill-docs.ts', 'bin/gstack-skill-start', 'bin/gstack-session-kind', 'test/helpers/docsync-*.ts', 'test/helpers/qa-functional-*.ts', 'test/helpers/session-runner.ts', 'test/helpers/hermetic-env.ts', 'test/skill-e2e-ship-docsync.test.ts', 'test/helpers/qa-checkpoint-evidence.ts', 'test/qa-checkpoint-evidence.test.ts', 'test/docsync-atomic-writes.test.ts', 'test/docsync-nested-writes.test.ts', 'test/docsync-lifecycle-interface.test.ts'],
+  'ship-docsync-recovery': ['ship/**', 'document-release/**', 'scripts/resolvers/sections.ts', 'scripts/resolvers/preamble.ts', 'scripts/resolvers/testing.ts', 'scripts/gen-skill-docs.ts', 'bin/gstack-skill-start', 'bin/gstack-session-kind', 'test/helpers/docsync-*.ts', 'test/helpers/qa-functional-*.ts', 'test/helpers/session-runner.ts', 'test/helpers/hermetic-env.ts', 'test/skill-e2e-ship-docsync.test.ts', 'test/helpers/qa-checkpoint-evidence.ts', 'test/qa-checkpoint-evidence.test.ts', 'test/docsync-atomic-writes.test.ts', 'test/docsync-nested-writes.test.ts', 'test/docsync-lifecycle-interface.test.ts'],
+  'review-exploratory-small-cli': ['bin/gstack-qa-evidence', 'lib/qa-evidence.ts', 'lib/fs-atomic.ts', 'lib/redact-engine.ts', 'lib/redact-patterns.ts', 'test/helpers/qa-evidence-producer.ts', 'test/helpers/qa-functional-evidence.ts', 'test/qa-evidence.test.ts', 'test/qa-evidence-producer.test.ts', 'test/qa-evidence-selection.test.ts', 'bin/gstack-qa-deadline', 'lib/qa-deadline.ts', 'lib/claude-code-windows-job.ts', 'test/qa-deadline.test.ts', 'test/qa-deadline-selection.test.ts', 'review/**', 'ship/**', 'qa/**', 'scripts/resolvers/qa.ts', 'scripts/resolvers/review.ts', 'scripts/resolvers/review-army.ts', 'scripts/resolvers/sections.ts', 'scripts/gen-skill-docs.ts', 'test/helpers/qa-callers-fixture.ts', 'test/helpers/qa-functional-observer.ts', 'test/helpers/qa-checkpoint-evidence.ts', 'test/qa-checkpoint-evidence.test.ts', 'test/helpers/qa-functional-fixture.ts', 'test/helpers/hermetic-skill-runtime.ts', 'test/helpers/session-runner.ts', 'test/qa-exploratory-callers.test.ts', 'test/skill-e2e-qa-callers.test.ts', 'scripts/resolvers/testing.ts', 'test/hermetic-skill-runtime.test.ts'],
+  'ship-exploratory-small-cli': ['bin/gstack-qa-evidence', 'lib/qa-evidence.ts', 'lib/fs-atomic.ts', 'lib/redact-engine.ts', 'lib/redact-patterns.ts', 'test/helpers/qa-evidence-producer.ts', 'test/helpers/qa-functional-evidence.ts', 'test/qa-evidence.test.ts', 'test/qa-evidence-producer.test.ts', 'test/qa-evidence-selection.test.ts', 'bin/gstack-qa-deadline', 'lib/qa-deadline.ts', 'lib/claude-code-windows-job.ts', 'test/qa-deadline.test.ts', 'test/qa-deadline-selection.test.ts', 'review/**', 'ship/**', 'qa/**', 'scripts/resolvers/qa.ts', 'scripts/resolvers/review.ts', 'scripts/resolvers/review-army.ts', 'scripts/resolvers/sections.ts', 'scripts/gen-skill-docs.ts', 'test/helpers/qa-callers-fixture.ts', 'test/helpers/qa-functional-observer.ts', 'test/helpers/qa-checkpoint-evidence.ts', 'test/qa-checkpoint-evidence.test.ts', 'test/helpers/qa-functional-fixture.ts', 'test/helpers/hermetic-skill-runtime.ts', 'test/helpers/session-runner.ts', 'test/qa-exploratory-callers.test.ts', 'test/skill-e2e-qa-callers.test.ts', 'scripts/resolvers/testing.ts', 'test/hermetic-skill-runtime.test.ts'],
+  'ship-exploratory-unavailable': ['bin/gstack-qa-evidence', 'lib/qa-evidence.ts', 'lib/fs-atomic.ts', 'lib/redact-engine.ts', 'lib/redact-patterns.ts', 'test/helpers/qa-evidence-producer.ts', 'test/helpers/qa-functional-evidence.ts', 'test/qa-evidence.test.ts', 'test/qa-evidence-producer.test.ts', 'test/qa-evidence-selection.test.ts', 'bin/gstack-qa-deadline', 'lib/qa-deadline.ts', 'lib/claude-code-windows-job.ts', 'test/qa-deadline.test.ts', 'test/qa-deadline-selection.test.ts', 'review/**', 'ship/**', 'qa/**', 'scripts/resolvers/qa.ts', 'scripts/resolvers/review.ts', 'scripts/resolvers/review-army.ts', 'scripts/resolvers/sections.ts', 'scripts/gen-skill-docs.ts', 'test/helpers/qa-callers-fixture.ts', 'test/helpers/qa-functional-observer.ts', 'test/helpers/qa-checkpoint-evidence.ts', 'test/qa-checkpoint-evidence.test.ts', 'test/helpers/qa-functional-fixture.ts', 'test/helpers/hermetic-skill-runtime.ts', 'test/helpers/session-runner.ts', 'test/qa-exploratory-callers.test.ts', 'test/skill-e2e-qa-callers.test.ts', 'scripts/resolvers/testing.ts', 'test/hermetic-skill-runtime.test.ts'],
+  'ship-exploratory-plan-checks': ['bin/gstack-qa-evidence', 'lib/qa-evidence.ts', 'lib/fs-atomic.ts', 'lib/redact-engine.ts', 'lib/redact-patterns.ts', 'test/helpers/qa-evidence-producer.ts', 'test/helpers/qa-functional-evidence.ts', 'test/qa-evidence.test.ts', 'test/qa-evidence-producer.test.ts', 'test/qa-evidence-selection.test.ts', 'bin/gstack-qa-deadline', 'lib/qa-deadline.ts', 'lib/claude-code-windows-job.ts', 'test/qa-deadline.test.ts', 'test/qa-deadline-selection.test.ts', 'review/**', 'ship/**', 'qa/**', 'scripts/resolvers/qa.ts', 'scripts/resolvers/review.ts', 'scripts/resolvers/review-army.ts', 'scripts/resolvers/sections.ts', 'scripts/gen-skill-docs.ts', 'test/helpers/qa-callers-fixture.ts', 'test/helpers/qa-functional-observer.ts', 'test/helpers/qa-checkpoint-evidence.ts', 'test/qa-checkpoint-evidence.test.ts', 'test/helpers/qa-functional-fixture.ts', 'test/helpers/hermetic-skill-runtime.ts', 'test/helpers/session-runner.ts', 'test/qa-exploratory-callers.test.ts', 'test/skill-e2e-qa-callers.test.ts', 'scripts/resolvers/testing.ts', 'test/hermetic-skill-runtime.test.ts', 'test/ship-plan-completion-invariants.test.ts'],
+  'ship-exploratory-late-input': ['bin/gstack-qa-evidence', 'lib/qa-evidence.ts', 'lib/fs-atomic.ts', 'lib/redact-engine.ts', 'lib/redact-patterns.ts', 'test/helpers/qa-evidence-producer.ts', 'test/helpers/qa-functional-evidence.ts', 'test/qa-evidence.test.ts', 'test/qa-evidence-producer.test.ts', 'test/qa-evidence-selection.test.ts', 'bin/gstack-qa-deadline', 'lib/qa-deadline.ts', 'lib/claude-code-windows-job.ts', 'test/qa-deadline.test.ts', 'test/qa-deadline-selection.test.ts', 'review/**', 'ship/**', 'qa/**', 'scripts/resolvers/qa.ts', 'scripts/resolvers/review.ts', 'scripts/resolvers/review-army.ts', 'scripts/resolvers/sections.ts', 'scripts/gen-skill-docs.ts', 'test/helpers/qa-callers-fixture.ts', 'test/helpers/qa-functional-observer.ts', 'test/helpers/qa-checkpoint-evidence.ts', 'test/qa-checkpoint-evidence.test.ts', 'test/helpers/qa-functional-fixture.ts', 'test/helpers/hermetic-skill-runtime.ts', 'test/helpers/session-runner.ts', 'test/qa-exploratory-callers.test.ts', 'test/skill-e2e-qa-callers.test.ts', 'scripts/resolvers/testing.ts', 'test/hermetic-skill-runtime.test.ts'],
+  'qa-functional-cli-report': ['bin/gstack-qa-evidence', 'bin/gstack-qa-deadline', 'lib/qa-evidence.ts', 'lib/qa-deadline.ts', 'lib/claude-code-windows-job.ts', 'lib/fs-atomic.ts', 'lib/redact-engine.ts', 'lib/redact-patterns.ts', 'test/helpers/qa-evidence-producer.ts', 'test/helpers/qa-functional-evidence.ts', 'test/qa-evidence.test.ts', 'test/qa-evidence-producer.test.ts', 'test/qa-evidence-selection.test.ts', 'test/qa-deadline.test.ts', 'test/qa-deadline-selection.test.ts', 'qa/**', 'qa-only/**', 'scripts/resolvers/qa.ts', 'scripts/resolvers/utility.ts', 'scripts/resolvers/sections.ts', 'scripts/gen-skill-docs.ts', 'test/helpers/qa-functional-*.ts', 'test/helpers/qa-checkpoint-evidence.ts', 'test/qa-checkpoint-evidence.test.ts', 'test/fixtures/qa-functional-cli-learning-ci-36516246523.json', 'test/helpers/session-runner.ts', 'test/helpers/hermetic-env.ts', 'test/helpers/skill-fixture.ts', 'test/skill-e2e-qa-functional.test.ts'],
+  'qa-functional-webhook-report': ['bin/gstack-qa-evidence', 'bin/gstack-qa-deadline', 'lib/qa-evidence.ts', 'lib/qa-deadline.ts', 'lib/claude-code-windows-job.ts', 'lib/fs-atomic.ts', 'lib/redact-engine.ts', 'lib/redact-patterns.ts', 'test/helpers/qa-evidence-producer.ts', 'test/helpers/qa-functional-evidence.ts', 'test/qa-evidence.test.ts', 'test/qa-evidence-producer.test.ts', 'test/qa-evidence-selection.test.ts', 'test/qa-deadline.test.ts', 'test/qa-deadline-selection.test.ts', 'qa/**', 'qa-only/**', 'scripts/resolvers/qa.ts', 'scripts/resolvers/utility.ts', 'scripts/resolvers/sections.ts', 'scripts/gen-skill-docs.ts', 'test/helpers/qa-functional-*.ts', 'test/helpers/qa-checkpoint-evidence.ts', 'test/qa-checkpoint-evidence.test.ts', 'test/fixtures/qa-webhook-r85-checkpoints.json', 'test/fixtures/qa-functional-ci-36505065023.json', 'test/helpers/session-runner.ts', 'test/helpers/hermetic-env.ts', 'test/helpers/skill-fixture.ts', 'test/skill-e2e-qa-functional.test.ts'],
+  'qa-functional-cli-fix': ['bin/gstack-qa-evidence', 'bin/gstack-qa-deadline', 'lib/qa-evidence.ts', 'lib/qa-deadline.ts', 'lib/claude-code-windows-job.ts', 'lib/fs-atomic.ts', 'lib/redact-engine.ts', 'lib/redact-patterns.ts', 'test/helpers/qa-evidence-producer.ts', 'test/helpers/qa-functional-evidence.ts', 'test/qa-evidence.test.ts', 'test/qa-evidence-producer.test.ts', 'test/qa-evidence-selection.test.ts', 'test/qa-deadline.test.ts', 'test/qa-deadline-selection.test.ts', 'qa/**', 'qa-only/**', 'scripts/resolvers/qa.ts', 'scripts/resolvers/utility.ts', 'scripts/resolvers/sections.ts', 'scripts/gen-skill-docs.ts', 'test/helpers/qa-functional-*.ts', 'test/helpers/qa-checkpoint-evidence.ts', 'test/qa-checkpoint-evidence.test.ts', 'test/helpers/session-runner.ts', 'test/helpers/hermetic-env.ts', 'test/helpers/skill-fixture.ts', 'test/skill-e2e-qa-functional-fix.test.ts'],
+  'qa-functional-webhook-fix': ['bin/gstack-qa-evidence', 'bin/gstack-qa-deadline', 'lib/qa-evidence.ts', 'lib/qa-deadline.ts', 'lib/claude-code-windows-job.ts', 'lib/fs-atomic.ts', 'lib/redact-engine.ts', 'lib/redact-patterns.ts', 'test/helpers/qa-evidence-producer.ts', 'test/helpers/qa-functional-evidence.ts', 'test/qa-evidence.test.ts', 'test/qa-evidence-producer.test.ts', 'test/qa-evidence-selection.test.ts', 'test/qa-deadline.test.ts', 'test/qa-deadline-selection.test.ts', 'qa/**', 'qa-only/**', 'scripts/resolvers/qa.ts', 'scripts/resolvers/utility.ts', 'scripts/resolvers/sections.ts', 'scripts/gen-skill-docs.ts', 'test/helpers/qa-functional-*.ts', 'test/helpers/qa-checkpoint-evidence.ts', 'test/qa-checkpoint-evidence.test.ts', 'test/helpers/session-runner.ts', 'test/helpers/hermetic-env.ts', 'test/helpers/skill-fixture.ts', 'test/skill-e2e-qa-functional-fix.test.ts'],
   // Browse core (+ test-server dependency)
   'browse-basic':    ['test/session-runner-stream-lifecycle.test.ts', 'browse/src/**', 'browse/test/test-server.ts', 'test/skill-e2e-bws.test.ts'],
   'browse-snapshot': ['test/session-runner-stream-lifecycle.test.ts', 'browse/src/**', 'browse/test/test-server.ts', 'test/skill-e2e-bws.test.ts'],
@@ -44,9 +76,7 @@ export const E2E_TOUCHFILES: Record<string, string[]> = {
   // primary browser (test/skill-e2e-aside.test.ts self-skips without a running Aside)
   'aside-browse-basic':  ['test/session-runner-stream-lifecycle.test.ts', 'browse/**', 'scripts/resolvers/browse.ts', 'scripts/resolvers/aside.ts', 'browse/test/test-server.ts', 'browse/test/fixtures/basic.html', 'test/helpers/aside-available.ts', 'test/skill-e2e-aside.test.ts'],
   'aside-browse-flow':   ['test/session-runner-stream-lifecycle.test.ts', 'browse/**', 'scripts/resolvers/browse.ts', 'scripts/resolvers/aside.ts', 'browse/test/test-server.ts', 'browse/test/fixtures/forms.html', 'test/helpers/aside-available.ts', 'test/skill-e2e-aside.test.ts'],
-  'aside-qa-quick':      ['test/session-runner-stream-lifecycle.test.ts', 'qa/**', 'scripts/resolvers/browse.ts', 'scripts/resolvers/aside.ts', 'browse/test/test-server.ts', 'browse/test/fixtures/basic.html', 'test/helpers/aside-available.ts', 'test/skill-e2e-aside.test.ts',
-    'scripts/resolvers/testing.ts'
-  ],
+  'aside-qa-quick': ['test/session-runner-stream-lifecycle.test.ts', 'qa/**', 'scripts/resolvers/browse.ts', 'scripts/resolvers/aside.ts', 'browse/test/test-server.ts', 'browse/test/fixtures/basic.html', 'test/helpers/aside-available.ts', 'test/skill-e2e-aside.test.ts'],
   'aside-scrape-json':   ['test/session-runner-stream-lifecycle.test.ts', 'scrape/**', 'scripts/resolvers/aside.ts', 'browse/test/test-server.ts', 'browse/test/fixtures/basic.html', 'test/helpers/aside-available.ts', 'test/skill-e2e-aside.test.ts'],
   'aside-canary-quick':  ['test/session-runner-stream-lifecycle.test.ts', 'canary/**', 'scripts/resolvers/aside.ts', 'browse/test/test-server.ts', 'browse/test/fixtures/basic.html', 'test/helpers/aside-available.ts', 'test/skill-e2e-aside.test.ts'],
 
@@ -71,29 +101,20 @@ export const E2E_TOUCHFILES: Record<string, string[]> = {
 
   // QA (+ test-server dependency). /qa drives Aside first (the resolver) and
   // the browse binary as fallback (browse/src), so both are deps.
-  'qa-quick':       ['test/session-runner-stream-lifecycle.test.ts', 'qa/**', 'scripts/resolvers/browse.ts', 'scripts/resolvers/aside.ts', 'browse/src/**', 'browse/test/test-server.ts', 'test/skill-e2e-qa-workflow.test.ts',
-    'scripts/resolvers/testing.ts'
-  ],
-  'qa-b6-static':   ['test/session-runner-stream-lifecycle.test.ts', 'qa/**', 'scripts/resolvers/aside.ts', 'browse/src/**', 'browse/test/test-server.ts', 'test/helpers/llm-judge.ts', 'browse/test/fixtures/qa-eval.html', 'test/fixtures/qa-eval-ground-truth.json', 'test/skill-e2e-qa-bugs.test.ts',
-    'scripts/resolvers/testing.ts'
-  ],
-  'qa-b7-spa':      ['test/session-runner-stream-lifecycle.test.ts', 'qa/**', 'scripts/resolvers/aside.ts', 'browse/src/**', 'browse/test/test-server.ts', 'test/helpers/llm-judge.ts', 'browse/test/fixtures/qa-eval-spa.html', 'test/fixtures/qa-eval-spa-ground-truth.json', 'test/skill-e2e-qa-bugs.test.ts',
-    'scripts/resolvers/testing.ts'
-  ],
-  'qa-b8-checkout': ['test/session-runner-stream-lifecycle.test.ts', 'qa/**', 'scripts/resolvers/aside.ts', 'browse/src/**', 'browse/test/test-server.ts', 'test/helpers/llm-judge.ts', 'browse/test/fixtures/qa-eval-checkout.html', 'test/fixtures/qa-eval-checkout-ground-truth.json', 'test/skill-e2e-qa-bugs.test.ts',
-    'scripts/resolvers/testing.ts'
-  ],
-  'qa-only-no-fix': ['test/qa-only-capability.test.ts', 'test/session-runner-stream-lifecycle.test.ts', 'qa-only/**', 'qa/templates/**', 'scripts/resolvers/aside.ts', 'browse/src/**', 'browse/test/test-server.ts', 'test/skill-e2e-qa-workflow.test.ts'],
-  'qa-fix-loop':    ['test/session-runner-stream-lifecycle.test.ts', 'qa/**', 'scripts/resolvers/aside.ts', 'browse/src/**', 'browse/test/test-server.ts', 'test/skill-e2e-qa-workflow.test.ts',
-    'test/qa-fix-loop-fixture.test.ts', 'scripts/resolvers/testing.ts'
-  ],
-  'qa-bootstrap':   ['test/session-runner-stream-lifecycle.test.ts', 'qa/**', 'ship/**', 'test/skill-e2e-qa-workflow.test.ts',
+  'qa-quick': ['bin/gstack-qa-deadline', 'lib/qa-deadline.ts', 'lib/claude-code-windows-job.ts', 'test/qa-deadline.test.ts', 'test/qa-deadline-selection.test.ts', 'test/session-runner-stream-lifecycle.test.ts', 'qa/**', 'scripts/resolvers/browse.ts', 'scripts/resolvers/aside.ts', 'browse/src/**', 'browse/test/test-server.ts', 'test/skill-e2e-qa-workflow.test.ts'],
+  'qa-b6-static': ['test/session-runner-stream-lifecycle.test.ts', 'qa/**', 'scripts/resolvers/aside.ts', 'browse/src/**', 'browse/test/test-server.ts', 'test/helpers/llm-judge.ts', 'browse/test/fixtures/qa-eval.html', 'test/fixtures/qa-eval-ground-truth.json', 'test/skill-e2e-qa-bugs.test.ts', 'test/qa-bugs-fixture.test.ts'],
+  'qa-b7-spa': ['test/session-runner-stream-lifecycle.test.ts', 'qa/**', 'scripts/resolvers/aside.ts', 'browse/src/**', 'browse/test/test-server.ts', 'test/helpers/llm-judge.ts', 'browse/test/fixtures/qa-eval-spa.html', 'test/fixtures/qa-eval-spa-ground-truth.json', 'test/skill-e2e-qa-bugs.test.ts', 'test/qa-bugs-fixture.test.ts'],
+  'qa-b8-checkout': ['test/session-runner-stream-lifecycle.test.ts', 'qa/**', 'scripts/resolvers/aside.ts', 'browse/src/**', 'browse/test/test-server.ts', 'test/helpers/llm-judge.ts', 'browse/test/fixtures/qa-eval-checkout.html', 'test/fixtures/qa-eval-checkout-ground-truth.json', 'test/skill-e2e-qa-bugs.test.ts', 'test/qa-bugs-fixture.test.ts'],
+  'qa-only-no-fix': ['test/helpers/qa-only-cleanup.ts', 'test/qa-only-cleanup.test.ts', 'test/helpers/qa-checkpoint-evidence.ts', 'test/qa-checkpoint-evidence.test.ts', 'test/fixtures/qa-only-observation-public.json', 'test/fixtures/qa-only-charter-public.json', 'test/fixtures/qa-only-browser-probe.ts', 'browse/test/fixtures/qa-only.html', 'test/qa-only-browser-probe.test.ts', 'test/helpers/qa-browser-deadline-evidence.ts', 'test/qa-browser-deadline-evidence.test.ts', 'bin/gstack-qa-deadline', 'lib/qa-deadline.ts', 'lib/claude-code-windows-job.ts', 'test/qa-deadline.test.ts', 'test/qa-deadline-selection.test.ts', 'test/qa-only-capability.test.ts', 'test/qa-only-fixture.test.ts', 'test/session-runner-stream-lifecycle.test.ts', 'qa-only/**', 'qa/sections/**', 'qa/templates/**', 'scripts/resolvers/aside.ts', 'browse/src/**', 'browse/test/test-server.ts', 'test/skill-e2e-qa-workflow.test.ts'],
+  'qa-fix-loop': ['bin/gstack-qa-deadline', 'lib/qa-deadline.ts', 'lib/claude-code-windows-job.ts', 'test/qa-deadline.test.ts', 'test/qa-deadline-selection.test.ts', 'test/session-runner-stream-lifecycle.test.ts', 'qa/**', 'scripts/resolvers/aside.ts', 'browse/src/**', 'browse/test/test-server.ts', 'test/skill-e2e-qa-workflow.test.ts',
+    'test/qa-fix-loop-fixture.test.ts'],
+  'qa-bootstrap':   ['test/helpers/bootstrap-retention.ts', 'test/bootstrap-retention.test.ts', 'test/bootstrap-session-lifecycle.test.ts', 'test/bootstrap-retention-shard.test.ts', 'test/session-runner-stream-lifecycle.test.ts', 'qa/**', 'ship/**', 'test/skill-e2e-qa-workflow.test.ts',
     'scripts/resolvers/testing.ts'
   ],
 
   // Review
   'review-sql-injection':     ['test/session-runner-stream-lifecycle.test.ts', 'review/**', 'test/fixtures/review-eval-vuln.rb', 'test/skill-e2e-review.test.ts',
-    'test/review-finalization-budget.test.ts'
+    'test/review-finalization-budget.test.ts', 'test/session-runner-browse-errors.test.ts', 'test/fixtures/review-browse-error-ci-36516246523.json'
   ],
   'review-enum-completeness': ['test/session-runner-stream-lifecycle.test.ts', 'review/**', 'test/fixtures/review-eval-enum*.rb', 'test/skill-e2e-review.test.ts', 'test/review-enum-lifecycle.test.ts',
     'test/review-finalization-budget.test.ts'
@@ -107,7 +128,7 @@ export const E2E_TOUCHFILES: Record<string, string[]> = {
   'review-army-migration-safety': ['test/session-runner-stream-lifecycle.test.ts', 'review/**', 'scripts/resolvers/review-army.ts', 'bin/gstack-diff-scope', 'test/skill-e2e-review-army.test.ts'],
   'review-army-perf-n-plus-one':  ['test/session-runner-stream-lifecycle.test.ts', 'review/**', 'scripts/resolvers/review-army.ts', 'bin/gstack-diff-scope', 'test/skill-e2e-review-army.test.ts', 'test/review-army-budget.test.ts', 'test/review-n-plus-one-contract.test.ts', 'test/fixtures/review-n-plus-one-dispatch.json'],
   'review-army-delivery-audit':   ['test/session-runner-stream-lifecycle.test.ts', 'review/**', 'scripts/resolvers/review.ts', 'scripts/resolvers/review-army.ts', 'test/skill-e2e-review-army.test.ts'],
-  'review-army-quality-score':    ['test/session-runner-stream-lifecycle.test.ts', 'review/**', 'scripts/resolvers/review-army.ts', 'test/skill-e2e-review-army.test.ts'],
+  'review-army-quality-score':    ['test/session-runner-stream-lifecycle.test.ts', 'review/**', 'scripts/resolvers/review-army.ts', 'test/skill-e2e-review-army.test.ts', 'test/review-quality-provenance.test.ts'],
   'review-army-json-findings':    ['test/session-runner-stream-lifecycle.test.ts', 'review/**', 'scripts/resolvers/review-army.ts', 'test/skill-e2e-review-army.test.ts'],
   'review-army-red-team':         ['test/session-runner-stream-lifecycle.test.ts', 'review/**', 'scripts/resolvers/review-army.ts', 'test/skill-e2e-review-army.test.ts',
     'test/helpers/office-hours-attempt.ts', 'test/office-hours-attempt.test.ts', 'test/review-army-budget.test.ts'
@@ -176,7 +197,7 @@ export const E2E_TOUCHFILES: Record<string, string[]> = {
   // include question-tuning.ts and generate-ask-user-format.ts because the
   // AUTO_DECIDE preamble injection lives there and changes can flip the
   // regression test outcome between 'asked' and 'auto_decided'.
-  'plan-ceo-review-plan-mode':    [
+  'plan-ceo-review-plan-mode':    ['test/pty-screen-supervision.test.ts',
     'test/ceo-plan-mode-fixture.test.ts',
     'test/helpers/plan-count-fixture.ts',
     'test/plan-count-fixture.test.ts',
@@ -195,7 +216,7 @@ export const E2E_TOUCHFILES: Record<string, string[]> = {
     "test/fixtures/eng-option-b-scope-al.json",
     'test/pty-workspace-trust.test.ts', 'test/fixtures/pty-companion-cli.ts', 'lib/fs-atomic.ts', 'test/helpers/pty-current-screen.ts', 'test/pty-current-screen.test.ts', 'test/fixtures/native-viewport.ts', 'test/helpers/plan-skill-questions.ts', 'test/fixtures/eng-auq-validation-error.json', 'test/fixtures/bash-directory-permission.json', 'test/fixtures/design-tasks-bash-permission.json', 'test/plan-skill-read-permission.test.ts', 'test/fixtures/read-permission.json', 'test/pty-numbered-option-indent-native.test.ts', 'test/fixtures/ceo-split-e5-numbered-description-491.json', 'test/plan-skill-questions.test.ts', 'test/helpers/plan-skill-question-events.ts', 'test/plan-skill-question-events.test.ts', 'test/helpers/plan-skill-question-hook-scope.ts', 'test/helpers/skill-census.ts', 'test/plan-skill-question-hook-scope.test.ts', 'scripts/resolvers/tasks-section.ts'
   ],
-  'plan-eng-review-plan-mode':    [
+  'plan-eng-review-plan-mode':    ['test/pty-screen-supervision.test.ts',
     'lib/claude-public-transcript.ts',
     'test/auto-decide-recommendation-scope.test.ts',
     'test/fixtures/auto-decide-recommendation-361c.json',
@@ -219,7 +240,7 @@ export const E2E_TOUCHFILES: Record<string, string[]> = {
     "test/review-entry-and-design-clarity-au.test.ts", "scripts/resolvers/preamble/generate-preamble-bash.ts",
     'test/pty-workspace-trust.test.ts', 'test/fixtures/pty-companion-cli.ts', 'test/helpers/plan-seed-submission.ts', 'test/plan-seed-submission.test.ts', 'test/fixtures/plan-seed-cli.ts', 'test/helpers/owned-claude-transcript.ts', 'lib/fs-atomic.ts', 'test/helpers/pty-current-screen.ts', 'test/pty-current-screen.test.ts', 'test/fixtures/native-viewport.ts', 'test/helpers/plan-skill-questions.ts', 'test/fixtures/eng-auq-validation-error.json', 'test/fixtures/bash-directory-permission.json', 'test/fixtures/design-tasks-bash-permission.json', 'test/plan-skill-read-permission.test.ts', 'test/fixtures/read-permission.json', 'test/pty-numbered-option-indent-native.test.ts', 'test/fixtures/ceo-split-e5-numbered-description-491.json', 'test/plan-skill-questions.test.ts', 'test/helpers/plan-skill-question-events.ts', 'test/plan-skill-question-events.test.ts', 'test/helpers/plan-skill-question-hook-scope.ts', 'test/helpers/skill-census.ts', 'test/plan-skill-question-hook-scope.test.ts', 'scripts/resolvers/testing.ts', 'test/helpers/plan-mode-evidence.ts', 'test/plan-mode-evidence.test.ts', 'lib/redact-engine.ts', 'lib/redact-patterns.ts', 'test/plan-review-cases.test.ts'
   ],
-  'plan-design-review-plan-mode': ['test/session-runner-stream-lifecycle.test.ts',
+  'plan-design-review-plan-mode': ['test/pty-screen-supervision.test.ts', 'test/session-runner-stream-lifecycle.test.ts',
     'lib/claude-public-transcript.ts',
     'test/auto-decide-recommendation-scope.test.ts',
     'test/fixtures/auto-decide-recommendation-361c.json',
@@ -246,7 +267,7 @@ export const E2E_TOUCHFILES: Record<string, string[]> = {
     "test/review-entry-and-design-clarity-au.test.ts", "scripts/resolvers/preamble/generate-preamble-bash.ts",
     'test/pty-workspace-trust.test.ts', 'test/fixtures/pty-companion-cli.ts', 'test/helpers/plan-seed-submission.ts', 'test/plan-seed-submission.test.ts', 'test/fixtures/plan-seed-cli.ts', 'test/helpers/owned-claude-transcript.ts', 'lib/fs-atomic.ts', 'test/helpers/pty-current-screen.ts', 'test/pty-current-screen.test.ts', 'test/fixtures/native-viewport.ts', 'test/helpers/plan-skill-questions.ts', 'test/fixtures/eng-auq-validation-error.json', 'test/fixtures/bash-directory-permission.json', 'test/fixtures/design-tasks-bash-permission.json', 'test/plan-skill-read-permission.test.ts', 'test/fixtures/read-permission.json', 'test/pty-numbered-option-indent-native.test.ts', 'test/fixtures/ceo-split-e5-numbered-description-491.json', 'test/plan-skill-questions.test.ts', 'test/helpers/plan-skill-question-events.ts', 'test/plan-skill-question-events.test.ts', 'test/helpers/plan-skill-question-hook-scope.ts', 'test/helpers/skill-census.ts', 'test/plan-skill-question-hook-scope.test.ts', 'test/helpers/plan-mode-evidence.ts', 'test/plan-mode-evidence.test.ts', 'lib/redact-engine.ts', 'lib/redact-patterns.ts'
   ],
-  'plan-devex-review-plan-mode':  [
+  'plan-devex-review-plan-mode':  ['test/pty-screen-supervision.test.ts',
     'test/auto-decide-recommendation-scope.test.ts',
     'test/fixtures/auto-decide-recommendation-361c.json',
     'test/auto-decide-target-identity.test.ts',
@@ -268,7 +289,7 @@ export const E2E_TOUCHFILES: Record<string, string[]> = {
   // (--max-concurrency + --retry 1), so worst-case cost is ~2x a single
   // pass of each, sharing the API budget with sibling tests — not the
   // sequential ~+10min a local read suggests.
-  'plan-mode-no-op':              [
+  'plan-mode-no-op':              ['test/pty-screen-supervision.test.ts',
     'test/auto-decide-recommendation-scope.test.ts',
     'test/fixtures/auto-decide-recommendation-361c.json',
     'test/auto-decide-target-identity.test.ts',
@@ -300,7 +321,7 @@ export const E2E_TOUCHFILES: Record<string, string[]> = {
   // INSIDE the existing 4 plan-X-review-plan-mode test files (covered
   // transitively by the entries above). Two new standalone files exist for
   // skills with no prior plan-mode test:
-  'office-hours-auto-mode':       [
+  'office-hours-auto-mode':       ['test/pty-screen-supervision.test.ts',
     'test/auto-decide-recommendation-scope.test.ts',
     'test/fixtures/auto-decide-recommendation-361c.json',
     'test/auto-decide-target-identity.test.ts',
@@ -315,7 +336,7 @@ export const E2E_TOUCHFILES: Record<string, string[]> = {
   // written a never-ask preference, AUQ should still auto-decide rather than
   // surfacing the question. Touches the question-tuning + preference
   // infrastructure plus the resolvers that own the AUTO_DECIDE preamble.
-  'auto-decide-preserved':        [
+  'auto-decide-preserved':        ['test/pty-screen-supervision.test.ts',
     'lib/claude-public-transcript.ts',
     'test/auto-decide-recommendation-scope.test.ts',
     'test/fixtures/auto-decide-recommendation-361c.json',
@@ -334,7 +355,7 @@ export const E2E_TOUCHFILES: Record<string, string[]> = {
   // Conductor → prose decision brief (Conductor signal makes prose the default;
   // the PreToolUse hook denies the flaky tool). Touches the resolver that owns
   // the Conductor rule, the preamble signal, the hook, and the detection helper.
-  'conductor-prose':              [
+  'conductor-prose':              ['test/pty-screen-supervision.test.ts',
     'lib/claude-public-transcript.ts',
     'test/auto-decide-recommendation-scope.test.ts',
     'test/fixtures/auto-decide-recommendation-361c.json',
@@ -361,7 +382,7 @@ export const E2E_TOUCHFILES: Record<string, string[]> = {
     'test/workflow-excerpt.test.ts', 'test/session-runner-tools.test.ts',
     'scripts/resolvers/tasks-section.ts'
   ],
-  'plan-ceo-mode-routing':       [
+  'plan-ceo-mode-routing':       ['test/pty-screen-supervision.test.ts',
     'lib/claude-public-transcript.ts',
     'test/plan-review-native-default.test.ts',
     'test/fixtures/eng-omitted-select-361c.json',
@@ -379,7 +400,7 @@ export const E2E_TOUCHFILES: Record<string, string[]> = {
     'test/pty-workspace-trust.test.ts', 'test/fixtures/pty-companion-cli.ts', 'lib/fs-atomic.ts', 'test/ceo-mode-routing-fixture.test.ts', 'test/helpers/ceo-finding-fixture.ts', 'test/ceo-finding-fixture.test.ts', 'test/helpers/claude-pty-runner.unit.test.ts', 'test/helpers/plan-skill-questions.ts', 'test/fixtures/eng-auq-validation-error.json', 'test/fixtures/bash-directory-permission.json', 'test/fixtures/design-tasks-bash-permission.json', 'test/plan-skill-read-permission.test.ts', 'test/fixtures/read-permission.json', 'test/pty-numbered-option-indent-native.test.ts', 'test/fixtures/ceo-split-e5-numbered-description-491.json', 'test/plan-skill-questions.test.ts', 'test/helpers/plan-skill-question-events.ts', 'test/plan-skill-question-events.test.ts', 'test/helpers/plan-skill-question-hook-scope.ts', 'test/helpers/skill-census.ts', 'test/plan-skill-question-hook-scope.test.ts', 'test/helpers/owned-claude-transcript.ts', 'test/helpers/pty-current-screen.ts', 'test/pty-current-screen.test.ts', 'test/fixtures/native-viewport.ts', 'scripts/resolvers/tasks-section.ts',
     'test/fixtures/ceo-expansion-pacing-77.json',
   ],
-  'plan-design-with-ui-scope':   [
+  'plan-design-with-ui-scope':   ['test/pty-screen-supervision.test.ts', 'test/helpers/pty-screen.ts',
     'lib/claude-public-transcript.ts',
     'test/autoplan-public-narration.test.ts', 'test/fixtures/autoplan-public-narration-ad.json',
     'test/helpers/plan-count-fixture.ts', 'test/plan-count-fixture.test.ts',
@@ -394,7 +415,7 @@ export const E2E_TOUCHFILES: Record<string, string[]> = {
     "test/review-entry-and-design-clarity-au.test.ts", "scripts/resolvers/preamble/generate-preamble-bash.ts", "scripts/resolvers/preamble/generate-completion-status.ts",
     'test/pty-workspace-trust.test.ts', 'test/fixtures/pty-companion-cli.ts', 'lib/fs-atomic.ts', 'test/plan-design-with-ui-fixture.test.ts', 'test/helpers/ceo-finding-fixture.ts', 'test/helpers/plan-review-cases.ts', 'test/helpers/plan-review-board-feedback.ts', 'test/plan-review-board-feedback.test.ts', 'test/fixtures/design-board-questions.json', 'test/fixtures/design-outside-voices-question.json', 'design/src/daemon-state.ts', 'design/src/daemon.ts', 'design/test/daemon-tests-fixtures.ts', 'design/src/daemon-client.ts', 'test/helpers/owned-claude-transcript.ts', 'test/helpers/plan-skill-completion.ts', 'test/helpers/pty-current-screen.ts', 'test/pty-current-screen.test.ts', 'test/fixtures/native-viewport.ts', 'test/helpers/plan-skill-questions.ts', 'test/fixtures/eng-auq-validation-error.json', 'test/fixtures/bash-directory-permission.json', 'test/fixtures/design-tasks-bash-permission.json', 'test/plan-skill-read-permission.test.ts', 'test/fixtures/read-permission.json', 'test/pty-numbered-option-indent-native.test.ts', 'test/fixtures/ceo-split-e5-numbered-description-491.json', 'test/plan-skill-questions.test.ts', 'test/helpers/plan-skill-question-events.ts', 'test/plan-skill-question-events.test.ts', 'test/helpers/plan-skill-question-hook-scope.ts', 'test/helpers/skill-census.ts', 'test/plan-skill-question-hook-scope.test.ts', 'scripts/resolvers/preamble/generate-ask-user-format.ts', 'bin/gstack-paths', 'bin/gstack-slug', 'scripts/resolvers/design.ts'
   ],
-  'ship-idempotency-pty':        ['ship/**', 'bin/gstack-next-version', 'bin/gstack-version-bump', 'scripts/resolvers/sections.ts', 'lib/worktree.ts', 'test/helpers/claude-pty-runner.ts', 'test/plan-count-design-ui-recovery.test.ts', 'test/fixtures/design-ui-boxed-question.json', 'test/helpers/hermetic-skill-runtime.ts', 'test/hermetic-skill-runtime.test.ts', 'test/helpers/pty-trust-dialog.ts', 'test/pty-trust-dialog.test.ts', 'test/skill-e2e-ship-idempotency.test.ts', 'test/plan-count-truncated-border.test.ts', 'test/fixtures/eng-d2-truncated-border-0bcd.json', 'test/plan-count-truncated-question.test.ts', 'test/plan-count-clipped-elision.test.ts', 'test/fixtures/eng-d1-clipped-elision-1579.json', 'test/fixtures/eng-d2-planning-prelude-4d.json', 'test/fixtures/ceo-approach-z-call.json', 'test/fixtures/ceo-approach-z-screen.txt',
+  'ship-idempotency-pty':        ['test/pty-screen-supervision.test.ts', 'ship/**', 'bin/gstack-next-version', 'bin/gstack-version-bump', 'scripts/resolvers/sections.ts', 'lib/worktree.ts', 'test/helpers/claude-pty-runner.ts', 'test/plan-count-design-ui-recovery.test.ts', 'test/fixtures/design-ui-boxed-question.json', 'test/helpers/hermetic-skill-runtime.ts', 'test/hermetic-skill-runtime.test.ts', 'test/helpers/pty-trust-dialog.ts', 'test/pty-trust-dialog.test.ts', 'test/skill-e2e-ship-idempotency.test.ts', 'test/plan-count-truncated-border.test.ts', 'test/fixtures/eng-d2-truncated-border-0bcd.json', 'test/plan-count-truncated-question.test.ts', 'test/plan-count-clipped-elision.test.ts', 'test/fixtures/eng-d1-clipped-elision-1579.json', 'test/fixtures/eng-d2-planning-prelude-4d.json', 'test/fixtures/ceo-approach-z-call.json', 'test/fixtures/ceo-approach-z-screen.txt',
     'test/pty-workspace-trust.test.ts', 'test/fixtures/pty-companion-cli.ts', 'lib/fs-atomic.ts', 'test/helpers/pty-current-screen.ts', 'test/pty-current-screen.test.ts', 'test/fixtures/native-viewport.ts', 'test/helpers/plan-skill-questions.ts', 'test/fixtures/eng-auq-validation-error.json', 'test/fixtures/bash-directory-permission.json', 'test/fixtures/design-tasks-bash-permission.json', 'test/plan-skill-read-permission.test.ts', 'test/fixtures/read-permission.json', 'test/pty-numbered-option-indent-native.test.ts', 'test/fixtures/ceo-split-e5-numbered-description-491.json', 'test/plan-skill-questions.test.ts', 'test/helpers/plan-skill-question-events.ts', 'test/plan-skill-question-events.test.ts', 'test/helpers/plan-skill-question-hook-scope.ts', 'test/helpers/skill-census.ts', 'test/plan-skill-question-hook-scope.test.ts', 'scripts/resolvers/testing.ts'
   ],
   'tpa-present':                 ['test/session-runner-stream-lifecycle.test.ts', 'scripts/resolvers/third-party-actions.ts', 'ship/SKILL.md.tmpl', 'ship/sections/apple-release.md.tmpl', 'scripts/gen-skill-docs.ts', 'test/helpers/session-runner.ts', 'test/skill-e2e-third-party-actions.test.ts', 'test/helpers/third-party-actions.ts',
@@ -437,7 +458,7 @@ export const E2E_TOUCHFILES: Record<string, string[]> = {
     "test/review-entry-and-design-clarity-au.test.ts", "scripts/resolvers/preamble/generate-preamble-bash.ts", "scripts/resolvers/preamble/generate-completion-status.ts",
     'test/section-capture-native-tools.test.ts', 'test/carve-section-loading*.test.ts', 'test/helpers/carve-section-case.ts', 'test/codex-carve-fixture.test.ts', 'test/carve-section-sharding.test.ts', 'test/carve-section-loading-browse.test.ts', 'test/carve-section-loading-codex.test.ts', 'test/carve-section-loading-design-consultation.test.ts', 'test/carve-section-loading-design-html.test.ts', 'test/carve-section-loading-design-shotgun.test.ts', 'test/carve-section-loading-document-release.test.ts', 'test/carve-section-loading-land-and-deploy.test.ts', 'test/carve-section-loading-plan-design-review.test.ts', 'test/carve-section-loading-plan-devex-review.test.ts', 'test/carve-section-loading-plan-eng-review.test.ts', 'test/carve-section-loading-qa.test.ts', 'test/carve-section-loading-retro.test.ts', 'test/carve-section-loading-review.test.ts', 'test/carve-section-loading-setup-gbrain.test.ts', 'test/carve-section-loading-spec.test.ts', 'test/design-html-section-completion.test.ts', 'test/fixtures/design-html-section-complete.md', 'scripts/resolvers/testing.ts', 'test/helpers/carve-plan-fixture.ts', 'test/carve-plan-fixture.test.ts', 'test/fixtures/carve-existing-repository/**', 'scripts/resolvers/review.ts', 'scripts/resolvers/preamble/generate-ask-user-format.ts', 'test/plan-review-cases.test.ts'
   ],
-  'autoplan-chain-pty':          [
+  'autoplan-chain-pty':          ['test/pty-screen-supervision.test.ts',
     'lib/claude-public-transcript.ts', 'lib/autoplan-phase-publication.ts', 'autoplan/bin/phase-publication-hook.ts', 'test/autoplan-publication-guard.test.ts', 'test/autoplan-publication-hook.test.ts', 'test/autoplan-publication-generation.test.ts', 'test/fixtures/autoplan-publication-boundary-361c.json', 'test/fixtures/autoplan-phase-consumption-491.json',
     'test/fixtures/autoplan-home-phase-entry-fb10.json',
     'test/autoplan-amend-input.test.ts', 'test/fixtures/autoplan-amend-input-77.json',
@@ -482,7 +503,7 @@ export const E2E_TOUCHFILES: Record<string, string[]> = {
   // Each test drives its skill end-to-end; touchfiles include preamble +
   // completion-status resolvers because they affect question cadence and
   // terminal output (the regression surface this test catches).
-  'plan-ceo-finding-count':      [
+  'plan-ceo-finding-count':      ['test/pty-screen-supervision.test.ts',
     'lib/claude-public-transcript.ts', 'test/plan-create-prepublication.test.ts', 'test/fixtures/plan-create-prepublication-491.json', 'test/plan-create-combined-permission.test.ts', 'test/fixtures/plan-create-combined-permission-70b.json',
     'test/plan-create-permission.test.ts',
     'test/fixtures/plan-create-permission-361c.json',
@@ -529,7 +550,7 @@ export const E2E_TOUCHFILES: Record<string, string[]> = {
     "test/ceo-transaction-contract-ar.test.ts", "test/fixtures/ceo-transaction-contract-ar.json", "test/ceo-section-declarative-ar.test.ts", "test/fixtures/ceo-section-declarative-ar.json",
     'test/pty-workspace-trust.test.ts', 'test/fixtures/pty-companion-cli.ts', 'test/helpers/autoplan-phase-order.ts', 'test/autoplan-phase-observation.test.ts', 'lib/fs-atomic.ts', 'test/helpers/owned-claude-transcript.ts', 'test/helpers/plan-skill-completion.ts', 'test/plan-skill-completion.test.ts', 'test/eval-budgets-policy.test.ts', 'test/fixtures/webfetch-permission.json', 'test/plan-skill-webfetch-permission.test.ts', 'test/helpers/ceo-finding-fixture.ts', 'test/ceo-finding-fixture.test.ts', 'test/helpers/plan-skill-questions.ts', 'test/fixtures/eng-auq-validation-error.json', 'test/fixtures/bash-directory-permission.json', 'test/fixtures/design-tasks-bash-permission.json', 'test/plan-skill-read-permission.test.ts', 'test/fixtures/read-permission.json', 'test/pty-numbered-option-indent-native.test.ts', 'test/fixtures/ceo-split-e5-numbered-description-491.json', 'test/plan-skill-questions.test.ts', 'test/helpers/plan-skill-question-events.ts', 'test/plan-skill-question-events.test.ts', 'test/helpers/plan-skill-question-hook-scope.ts', 'test/helpers/skill-census.ts', 'test/plan-skill-question-hook-scope.test.ts', 'test/skill-e2e-plan-ceo-finding-count.test.ts', 'test/helpers/pty-current-screen.ts', 'test/pty-current-screen.test.ts', 'test/fixtures/native-viewport.ts', 'test/helpers/plan-review-decisions.ts', 'test/plan-review-decisions.test.ts', 'test/helpers/plan-review-cases.ts', 'test/plan-review-cases.test.ts', 'test/helpers/llm-judge.ts', 'lib/eval-model.ts', 'test/skill-e2e-plan-decision-classification.test.ts', 'test/fixtures/plan-decision-classification.ts', 'test/plan-review-calibration.test.ts', 'test/helpers/ceo-paired-fixture.ts', 'test/ceo-paired-payment-fixture.test.ts', 'test/fixtures/ceo-paired-option-values.json', 'test/fixtures/paired-payment/**', 'test/fixtures/ceo-existing-payment/**', 'scripts/resolvers/review.ts', 'scripts/resolvers/tasks-section.ts'
   ],
-  'plan-eng-finding-count':      [
+  'plan-eng-finding-count':      ['test/pty-screen-supervision.test.ts',
     'test/helpers/eng-count-question-policy.ts', 'test/eng-count-question-policy.test.ts', 'test/fixtures/eng-count-actor-491.json',
     'lib/claude-public-transcript.ts', 'test/plan-create-prepublication.test.ts', 'test/fixtures/plan-create-prepublication-491.json', 'test/plan-create-combined-permission.test.ts', 'test/fixtures/plan-create-combined-permission-70b.json',
     'test/plan-create-permission.test.ts',
@@ -614,7 +635,7 @@ export const E2E_TOUCHFILES: Record<string, string[]> = {
     "test/eng-required-parity-au.test.ts", "test/fixtures/eng-required-parity-au.md", "test/helpers/eng-retained-corpus.ts", "test/eng-retained-corpus-au.test.ts", "test/fixtures/eng-retained-corpus-au.md", "test/eng-annotated-cache-au.test.ts", "test/fixtures/eng-annotated-cache-au.json", "test/review-entry-and-design-clarity-au.test.ts", "scripts/resolvers/preamble/generate-preamble-bash.ts",
     'test/pty-workspace-trust.test.ts', 'test/fixtures/pty-companion-cli.ts', 'test/helpers/autoplan-phase-order.ts', 'test/autoplan-phase-observation.test.ts', 'lib/fs-atomic.ts', 'test/helpers/owned-claude-transcript.ts', 'test/helpers/plan-skill-completion.ts', 'test/plan-skill-completion.test.ts', 'test/eval-budgets-policy.test.ts', 'test/fixtures/webfetch-permission.json', 'test/plan-skill-webfetch-permission.test.ts', 'test/helpers/plan-skill-questions.ts', 'test/fixtures/eng-auq-validation-error.json', 'test/fixtures/bash-directory-permission.json', 'test/fixtures/design-tasks-bash-permission.json', 'test/plan-skill-read-permission.test.ts', 'test/fixtures/read-permission.json', 'test/pty-numbered-option-indent-native.test.ts', 'test/fixtures/ceo-split-e5-numbered-description-491.json', 'test/plan-skill-questions.test.ts', 'test/helpers/plan-skill-question-events.ts', 'test/plan-skill-question-events.test.ts', 'test/helpers/plan-skill-question-hook-scope.ts', 'test/helpers/skill-census.ts', 'test/plan-skill-question-hook-scope.test.ts', 'test/helpers/ceo-finding-fixture.ts', 'test/ceo-finding-fixture.test.ts', 'test/helpers/pty-current-screen.ts', 'test/pty-current-screen.test.ts', 'test/fixtures/native-viewport.ts', 'test/helpers/plan-review-decisions.ts', 'test/plan-review-decisions.test.ts', 'test/helpers/plan-review-cases.ts', 'test/plan-review-cases.test.ts', 'test/helpers/llm-judge.ts', 'lib/eval-model.ts', 'test/skill-e2e-plan-decision-classification.test.ts', 'test/fixtures/plan-decision-classification.ts', 'test/plan-review-calibration.test.ts', 'scripts/resolvers/testing.ts', 'test/helpers/eng-finding-fixture.ts', 'test/eng-finding-fixture.test.ts', 'test/fixtures/eng-existing-auth/**', 'scripts/resolvers/review.ts'
   ],
-  'plan-design-finding-count':   [
+  'plan-design-finding-count':   ['test/pty-screen-supervision.test.ts',
     'test/helpers/design-count-fixture.ts', 'test/design-count-fixture.test.ts', 'test/fixtures/design-count-sep20-calls.json', 'test/fixtures/design-count-sep21-first-call.json', 'test/fixtures/design-count-sep21-confirm-first-call.json',
     'test/design-count-primary-facts.test.ts', 'test/fixtures/design-count-sep21-declared-first-call.json', 'test/fixtures/design-count-sep21-header-first-call.json',
     'lib/claude-public-transcript.ts', 'test/plan-create-prepublication.test.ts', 'test/fixtures/plan-create-prepublication-491.json', 'test/plan-create-combined-permission.test.ts', 'test/fixtures/plan-create-combined-permission-70b.json',
@@ -665,7 +686,7 @@ export const E2E_TOUCHFILES: Record<string, string[]> = {
     "test/review-entry-and-design-clarity-au.test.ts", "scripts/resolvers/preamble/generate-preamble-bash.ts",
     'test/pty-workspace-trust.test.ts', 'test/fixtures/pty-companion-cli.ts', 'test/helpers/autoplan-phase-order.ts', 'test/autoplan-phase-observation.test.ts', 'lib/fs-atomic.ts', 'test/helpers/owned-claude-transcript.ts', 'test/helpers/plan-skill-completion.ts', 'test/plan-skill-completion.test.ts', 'test/eval-budgets-policy.test.ts', 'test/fixtures/webfetch-permission.json', 'test/plan-skill-webfetch-permission.test.ts', 'test/helpers/plan-skill-questions.ts', 'test/fixtures/eng-auq-validation-error.json', 'test/fixtures/bash-directory-permission.json', 'test/fixtures/design-tasks-bash-permission.json', 'test/plan-skill-read-permission.test.ts', 'test/fixtures/read-permission.json', 'test/pty-numbered-option-indent-native.test.ts', 'test/fixtures/ceo-split-e5-numbered-description-491.json', 'test/plan-skill-questions.test.ts', 'test/helpers/plan-skill-question-events.ts', 'test/plan-skill-question-events.test.ts', 'test/helpers/plan-skill-question-hook-scope.ts', 'test/helpers/skill-census.ts', 'test/plan-skill-question-hook-scope.test.ts', 'test/helpers/ceo-finding-fixture.ts', 'test/ceo-finding-fixture.test.ts', 'test/helpers/pty-current-screen.ts', 'test/pty-current-screen.test.ts', 'test/fixtures/native-viewport.ts', 'test/helpers/plan-review-decisions.ts', 'test/plan-review-decisions.test.ts', 'test/helpers/plan-review-cases.ts', 'test/helpers/plan-review-board-feedback.ts', 'test/plan-review-board-feedback.test.ts', 'test/fixtures/design-board-questions.json', 'design/src/daemon-state.ts', 'design/src/daemon.ts', 'design/test/daemon-tests-fixtures.ts', 'design/src/daemon-client.ts', 'test/plan-review-cases.test.ts', 'test/helpers/llm-judge.ts', 'lib/eval-model.ts', 'test/skill-e2e-plan-decision-classification.test.ts', 'test/fixtures/plan-decision-classification.ts', 'test/plan-review-calibration.test.ts', 'test/design-finding-fixture.test.ts', 'scripts/resolvers/review.ts', 'bin/gstack-paths', 'bin/gstack-slug', 'scripts/resolvers/design.ts'
   ],
-  'plan-devex-finding-count':    [
+  'plan-devex-finding-count':    ['test/pty-screen-supervision.test.ts',
     'test/fixtures/devex-seed-sep21-calls.json',
     'lib/claude-public-transcript.ts', 'test/plan-create-prepublication.test.ts', 'test/fixtures/plan-create-prepublication-491.json', 'test/plan-create-combined-permission.test.ts', 'test/fixtures/plan-create-combined-permission-70b.json',
     'test/plan-create-permission.test.ts',
@@ -702,7 +723,7 @@ export const E2E_TOUCHFILES: Record<string, string[]> = {
   // review-phase AskUserQuestion). Uses runPlanSkillFloorCheck — minimal
   // "did agent fire ANY AUQ?" observer that exits early on first non-permission
   // numbered-option render. ~1-3 min typical wall time per test, ~$2-6 total.
-  'plan-eng-finding-floor':      [
+  'plan-eng-finding-floor':      ['test/pty-screen-supervision.test.ts', 'test/helpers/pty-screen.ts',
     'lib/claude-public-transcript.ts', 'test/plan-create-prepublication.test.ts', 'test/fixtures/plan-create-prepublication-491.json', 'test/plan-create-combined-permission.test.ts', 'test/fixtures/plan-create-combined-permission-70b.json', 'test/fixtures/plan-floor-quote-70b.json',
     'test/plan-create-permission.test.ts',
     'test/fixtures/plan-create-permission-361c.json',
@@ -719,7 +740,7 @@ export const E2E_TOUCHFILES: Record<string, string[]> = {
     "test/review-entry-and-design-clarity-au.test.ts", "scripts/resolvers/preamble/generate-preamble-bash.ts",
     'test/pty-workspace-trust.test.ts', 'test/fixtures/pty-companion-cli.ts', 'lib/fs-atomic.ts', 'test/helpers/pty-current-screen.ts', 'test/pty-current-screen.test.ts', 'test/fixtures/native-viewport.ts', 'test/helpers/plan-skill-questions.ts', 'test/fixtures/eng-auq-validation-error.json', 'test/fixtures/bash-directory-permission.json', 'test/fixtures/design-tasks-bash-permission.json', 'test/plan-skill-read-permission.test.ts', 'test/fixtures/read-permission.json', 'test/pty-numbered-option-indent-native.test.ts', 'test/fixtures/ceo-split-e5-numbered-description-491.json', 'test/plan-skill-questions.test.ts', 'test/helpers/plan-skill-question-events.ts', 'test/plan-skill-question-events.test.ts', 'test/helpers/plan-skill-question-hook-scope.ts', 'test/helpers/skill-census.ts', 'test/plan-skill-question-hook-scope.test.ts', 'scripts/resolvers/testing.ts', 'test/plan-review-cases.test.ts'
   ],
-  'plan-ceo-finding-floor':      [
+  'plan-ceo-finding-floor':      ['test/pty-screen-supervision.test.ts', 'test/helpers/pty-screen.ts',
     'lib/claude-public-transcript.ts', 'test/plan-create-prepublication.test.ts', 'test/fixtures/plan-create-prepublication-491.json', 'test/plan-create-combined-permission.test.ts', 'test/fixtures/plan-create-combined-permission-70b.json', 'test/fixtures/plan-floor-quote-70b.json',
     'test/plan-create-permission.test.ts',
     'test/fixtures/plan-create-permission-361c.json',
@@ -732,7 +753,7 @@ export const E2E_TOUCHFILES: Record<string, string[]> = {
     "test/ceo-transaction-contract-ar.test.ts", "test/fixtures/ceo-transaction-contract-ar.json", "test/ceo-section-declarative-ar.test.ts", "test/fixtures/ceo-section-declarative-ar.json",
     'test/pty-workspace-trust.test.ts', 'test/fixtures/pty-companion-cli.ts', 'lib/fs-atomic.ts', 'test/helpers/pty-current-screen.ts', 'test/pty-current-screen.test.ts', 'test/fixtures/native-viewport.ts', 'test/helpers/plan-skill-questions.ts', 'test/fixtures/eng-auq-validation-error.json', 'test/fixtures/bash-directory-permission.json', 'test/fixtures/design-tasks-bash-permission.json', 'test/plan-skill-read-permission.test.ts', 'test/fixtures/read-permission.json', 'test/pty-numbered-option-indent-native.test.ts', 'test/fixtures/ceo-split-e5-numbered-description-491.json', 'test/plan-skill-questions.test.ts', 'test/helpers/plan-skill-question-events.ts', 'test/plan-skill-question-events.test.ts', 'test/helpers/plan-skill-question-hook-scope.ts', 'test/helpers/skill-census.ts', 'test/plan-skill-question-hook-scope.test.ts', 'scripts/resolvers/tasks-section.ts'
   ],
-  'plan-design-finding-floor':   [
+  'plan-design-finding-floor':   ['test/pty-screen-supervision.test.ts', 'test/helpers/pty-screen.ts',
     'test/paid-retry-supervision.test.ts',
     'lib/claude-public-transcript.ts', 'test/plan-create-prepublication.test.ts', 'test/fixtures/plan-create-prepublication-491.json', 'test/plan-create-combined-permission.test.ts', 'test/fixtures/plan-create-combined-permission-70b.json', 'test/fixtures/plan-floor-quote-70b.json',
     'test/plan-create-permission.test.ts',
@@ -750,7 +771,7 @@ export const E2E_TOUCHFILES: Record<string, string[]> = {
     "test/review-entry-and-design-clarity-au.test.ts", "scripts/resolvers/preamble/generate-preamble-bash.ts",
     'test/pty-workspace-trust.test.ts', 'test/fixtures/pty-companion-cli.ts', 'lib/fs-atomic.ts', 'test/helpers/pty-current-screen.ts', 'test/pty-current-screen.test.ts', 'test/fixtures/native-viewport.ts', 'test/helpers/plan-skill-questions.ts', 'test/fixtures/eng-auq-validation-error.json', 'test/fixtures/bash-directory-permission.json', 'test/fixtures/design-tasks-bash-permission.json', 'test/plan-skill-read-permission.test.ts', 'test/fixtures/read-permission.json', 'test/pty-numbered-option-indent-native.test.ts', 'test/fixtures/ceo-split-e5-numbered-description-491.json', 'test/plan-skill-questions.test.ts', 'test/helpers/plan-skill-question-events.ts', 'test/plan-skill-question-events.test.ts', 'test/helpers/plan-skill-question-hook-scope.ts', 'test/helpers/skill-census.ts', 'test/plan-skill-question-hook-scope.test.ts', 'test/helpers/ceo-finding-fixture.ts', 'test/ceo-finding-fixture.test.ts', 'test/plan-design-floor-fixture.test.ts'
   ],
-  'plan-devex-finding-floor':    [
+  'plan-devex-finding-floor':    ['test/pty-screen-supervision.test.ts', 'test/helpers/pty-screen.ts',
     'test/plan-floor-dx-actor.test.ts', 'test/fixtures/plan-floor-dx-custom-491.json', 'test/fixtures/plan-floor-dx-editor-hint.json',
     'test/paid-retry-supervision.test.ts',
     'lib/claude-public-transcript.ts', 'test/plan-create-prepublication.test.ts', 'test/fixtures/plan-create-prepublication-491.json', 'test/plan-create-combined-permission.test.ts', 'test/fixtures/plan-create-combined-permission-70b.json', 'test/fixtures/plan-floor-quote-70b.json', 'test/fixtures/plan-floor-product-type-70b.json',
@@ -769,7 +790,7 @@ export const E2E_TOUCHFILES: Record<string, string[]> = {
   // a model fires one AUQ then batches the rest into a "## Decisions to
   // confirm" plan write. runPlanSkillFloorCheck cannot detect that shape
   // (it exits on first AUQ); runPlanSkillCounting can.
-  'plan-eng-multi-finding-batching': [
+  'plan-eng-multi-finding-batching': ['test/pty-screen-supervision.test.ts',
     'lib/claude-public-transcript.ts', 'test/plan-create-prepublication.test.ts', 'test/fixtures/plan-create-prepublication-491.json', 'test/plan-create-combined-permission.test.ts', 'test/fixtures/plan-create-combined-permission-70b.json',
     'test/plan-create-permission.test.ts',
     'test/fixtures/plan-create-permission-361c.json',
@@ -809,7 +830,7 @@ export const E2E_TOUCHFILES: Record<string, string[]> = {
     "test/review-entry-and-design-clarity-au.test.ts", "scripts/resolvers/preamble/generate-preamble-bash.ts",
     'test/pty-workspace-trust.test.ts', 'test/fixtures/pty-companion-cli.ts', 'test/helpers/autoplan-phase-order.ts', 'test/autoplan-phase-observation.test.ts', 'lib/fs-atomic.ts', 'test/helpers/owned-claude-transcript.ts', 'test/helpers/plan-skill-completion.ts', 'test/plan-skill-completion.test.ts', 'test/eval-budgets-policy.test.ts', 'test/fixtures/webfetch-permission.json', 'test/plan-skill-webfetch-permission.test.ts', 'test/helpers/plan-skill-questions.ts', 'test/fixtures/eng-auq-validation-error.json', 'test/fixtures/bash-directory-permission.json', 'test/fixtures/design-tasks-bash-permission.json', 'test/plan-skill-read-permission.test.ts', 'test/fixtures/read-permission.json', 'test/pty-numbered-option-indent-native.test.ts', 'test/fixtures/ceo-split-e5-numbered-description-491.json', 'test/plan-skill-questions.test.ts', 'test/helpers/plan-skill-question-events.ts', 'test/plan-skill-question-events.test.ts', 'test/helpers/plan-skill-question-hook-scope.ts', 'test/helpers/skill-census.ts', 'test/plan-skill-question-hook-scope.test.ts', 'test/helpers/ceo-finding-fixture.ts', 'test/ceo-finding-fixture.test.ts', 'test/helpers/pty-current-screen.ts', 'test/pty-current-screen.test.ts', 'test/fixtures/native-viewport.ts', 'test/helpers/plan-review-decisions.ts', 'test/plan-review-decisions.test.ts', 'test/helpers/plan-review-cases.ts', 'test/plan-review-cases.test.ts', 'test/helpers/llm-judge.ts', 'lib/eval-model.ts', 'test/skill-e2e-plan-decision-classification.test.ts', 'test/fixtures/plan-decision-classification.ts', 'test/plan-review-calibration.test.ts', 'scripts/resolvers/testing.ts', 'test/fixtures/eng-file-permission-repaint.json'
   ],
-  'plan-ceo-split-overflow': [
+  'plan-ceo-split-overflow': ['test/pty-screen-supervision.test.ts',
     'lib/claude-public-transcript.ts', 'test/plan-create-prepublication.test.ts', 'test/fixtures/plan-create-prepublication-491.json', 'test/plan-create-combined-permission.test.ts', 'test/fixtures/plan-create-combined-permission-70b.json',
     'test/plan-create-permission.test.ts',
     'test/fixtures/plan-create-permission-361c.json',
@@ -1108,22 +1129,29 @@ export const E2E_TOUCHFILES: Record<string, string[]> = {
     'scripts/resolvers/testing.ts'
   ],
   'ship-docsync': ['test/session-runner-stream-lifecycle.test.ts', 'ship/**', 'document-release/**', 'scripts/gen-skill-docs.ts', 'scripts/resolvers/sections.ts', 'test/skill-e2e-ship-docsync.test.ts',
-    'scripts/resolvers/testing.ts'
+    'scripts/resolvers/testing.ts', 'test/helpers/docsync-*.ts', 'bin/gstack-skill-start', 'bin/gstack-session-kind', 'test/helpers/qa-checkpoint-evidence.ts', 'test/qa-checkpoint-evidence.test.ts', 'test/docsync-atomic-writes.test.ts', 'test/docsync-nested-writes.test.ts', 'test/helpers/qa-functional-observer.ts', 'test/docsync-lifecycle-interface.test.ts'
   ],
+  'ship-docsync-completion': ['ship/**', 'document-release/**', 'test/skill-e2e-ship-docsync.test.ts', 'test/helpers/docsync-*.ts', 'test/helpers/session-runner.ts', 'test/helpers/hermetic-env.ts', 'bin/gstack-skill-start', 'bin/gstack-session-kind', 'scripts/resolvers/sections.ts', 'scripts/resolvers/preamble/generate-ask-user-format.ts', 'scripts/gen-skill-docs.ts', 'scripts/resolvers/testing.ts', 'test/helpers/qa-checkpoint-evidence.ts', 'test/qa-checkpoint-evidence.test.ts', 'test/docsync-atomic-writes.test.ts', 'test/docsync-nested-writes.test.ts', 'test/helpers/qa-functional-observer.ts', 'test/docsync-lifecycle-interface.test.ts'],
+  'ship-docsync-current': ['ship/**', 'document-release/**', 'test/skill-e2e-ship-docsync.test.ts', 'test/helpers/docsync-*.ts', 'test/helpers/session-runner.ts', 'test/helpers/hermetic-env.ts', 'bin/gstack-skill-start', 'bin/gstack-session-kind', 'scripts/resolvers/sections.ts', 'scripts/resolvers/preamble/generate-ask-user-format.ts', 'scripts/gen-skill-docs.ts', 'scripts/resolvers/testing.ts', 'test/helpers/qa-checkpoint-evidence.ts', 'test/qa-checkpoint-evidence.test.ts', 'test/docsync-atomic-writes.test.ts', 'test/docsync-nested-writes.test.ts', 'test/helpers/qa-functional-observer.ts', 'test/docsync-lifecycle-interface.test.ts'],
+  'ship-docsync-failure': ['ship/**', 'document-release/**', 'test/skill-e2e-ship-docsync.test.ts', 'test/helpers/docsync-*.ts', 'test/helpers/session-runner.ts', 'test/helpers/hermetic-env.ts', 'bin/gstack-skill-start', 'bin/gstack-session-kind', 'scripts/resolvers/sections.ts', 'scripts/resolvers/preamble/generate-ask-user-format.ts', 'scripts/gen-skill-docs.ts', 'scripts/resolvers/testing.ts', 'test/helpers/qa-checkpoint-evidence.ts', 'test/qa-checkpoint-evidence.test.ts', 'test/docsync-atomic-writes.test.ts', 'test/docsync-nested-writes.test.ts', 'test/helpers/qa-functional-observer.ts', 'test/docsync-lifecycle-interface.test.ts'],
+  'ship-docsync-store': ['ship/**', 'document-release/**', 'test/skill-e2e-ship-docsync.test.ts', 'test/helpers/docsync-*.ts', 'test/helpers/session-runner.ts', 'test/helpers/hermetic-env.ts', 'bin/gstack-skill-start', 'bin/gstack-session-kind', 'scripts/resolvers/sections.ts', 'scripts/resolvers/preamble/generate-ask-user-format.ts', 'scripts/gen-skill-docs.ts', 'scripts/resolvers/testing.ts', 'test/helpers/qa-checkpoint-evidence.ts', 'test/qa-checkpoint-evidence.test.ts', 'test/docsync-atomic-writes.test.ts', 'test/docsync-nested-writes.test.ts', 'test/helpers/qa-functional-observer.ts', 'test/docsync-lifecycle-interface.test.ts'],
   // #2733 behavioral proof: the JSON contract survives a firing gate inside a
   // spawned-marked subagent. Deps name every behavior under test — the
   // session-kind override, the skill-start gates, both hooks + the shared
   // directive, and the AUQ prose rule — so changing any of them selects it.
   'docsync-spawned': ['test/session-runner-stream-lifecycle.test.ts',
-    'document-release/**',
     'ship/sections/pr-body.md',
+    'document-release/**',
+    'ship/sections/documentation.md',
+    'ship/sections/documentation.md.tmpl',
+    'test/helpers/docsync-*.ts',
     'bin/gstack-session-kind',
     'bin/gstack-skill-start',
     'hosts/claude/hooks/question-preference-hook.ts',
     'hosts/claude/hooks/auq-error-fallback-hook.ts',
     'hosts/claude/hooks/spawned-directive.ts',
     'scripts/resolvers/preamble/generate-ask-user-format.ts',
-    'test/skill-e2e-docsync-spawned.test.ts',
+    'test/skill-e2e-docsync-spawned.test.ts', 'test/helpers/qa-checkpoint-evidence.ts', 'test/qa-checkpoint-evidence.test.ts', 'test/docsync-atomic-writes.test.ts', 'test/docsync-nested-writes.test.ts', 'test/helpers/qa-functional-observer.ts', 'test/docsync-lifecycle-interface.test.ts',
   ],
 
   // Design
@@ -1433,6 +1461,7 @@ export const E2E_TOUCHFILES: Record<string, string[]> = {
  * Must have exactly the same keys as E2E_TOUCHFILES.
  */
 export const E2E_TIERS: Record<string, 'gate' | 'periodic'> = {
+  'ship-skipped-queued-finding': 'gate',
   'investigate-owned-completion': 'gate',
   'investigate-owned-abort': 'gate',
   'investigate-owned-ending-error': 'gate',
@@ -1482,6 +1511,15 @@ export const E2E_TIERS: Record<string, 'gate' | 'periodic'> = {
   'qa-only-no-fix': 'gate',     // CRITICAL guardrail: Edit tool forbidden
   'qa-fix-loop': 'periodic',
   'qa-bootstrap': 'gate',
+  'review-exploratory-small-cli': 'gate',
+  'ship-exploratory-small-cli': 'gate',
+  'ship-exploratory-unavailable': 'gate',
+  'ship-exploratory-plan-checks': 'gate',
+  'ship-exploratory-late-input': 'gate',
+  'qa-functional-cli-report': 'gate',
+  'qa-functional-webhook-report': 'gate',
+  'qa-functional-cli-fix': 'gate',
+  'qa-functional-webhook-fix': 'gate',
 
   // Review — gate for functional/guardrails, periodic for quality
   'review-sql-injection': 'gate',     // Security guardrail
@@ -1661,6 +1699,18 @@ export const E2E_TIERS: Record<string, 'gate' | 'periodic'> = {
   'ship-coverage-audit': 'gate',
   'ship-triage': 'gate',
   'ship-docsync': 'gate',
+  'ship-docsync-missing-marker': 'gate',
+  'ship-docsync-missing-asset': 'gate',
+  'ship-docsync-launch-failure': 'gate',
+  'ship-docsync-timeout-unsettled': 'gate',
+  'ship-docsync-late-result': 'gate',
+  'ship-docsync-stale-before': 'gate',
+  'ship-docsync-stale-after': 'gate',
+  'ship-docsync-recovery': 'gate',
+  'ship-docsync-completion': 'gate',
+  'ship-docsync-current': 'gate',
+  'ship-docsync-failure': 'gate',
+  'ship-docsync-store': 'gate',
   'docsync-spawned': 'gate',   // #2733 JSON-contract-through-a-firing-gate proof (deterministic safety)
   // (merge note: main's side also re-added ship-plan-completion /
   // ship-plan-verification here — phantom keys with no declaring test,
@@ -1799,24 +1849,25 @@ export const E2E_TIERS: Record<string, 'gate' | 'periodic'> = {
  * LLM-judge test touchfiles — keyed by test description string.
  */
 export const LLM_JUDGE_TOUCHFILES: Record<string, string[]> = {
+  'review/SKILL.md workflow': ['review/**', 'qa/**', 'scripts/resolvers/qa.ts', 'scripts/resolvers/review-army.ts', 'scripts/resolvers/review.ts', 'scripts/resolvers/sections.ts', 'test/skill-llm-eval.test.ts', 'test/helpers/workflow-judge-input.ts', 'test/helpers/workflow-judge-cache.ts', 'test/workflow-judge-input.test.ts'],
   'setup-browser-cookies/SKILL.md workflow': ['setup-browser-cookies/SKILL.md.tmpl', 'setup-browser-cookies/SKILL.md', 'BROWSER.md', 'test/helpers/cookie-workflow-judge-input.ts', 'test/cookie-workflow-judge-input.test.ts', 'test/helpers/cookie-workflow-manual-review.ts', 'test/cookie-workflow-manual-review.test.ts', 'test/helpers/manual-judge-review-fixture.ts', '.github/cookie-workflow-manual-review.json', 'test/helpers/workflow-judge-input.ts', 'test/skill-llm-eval.test.ts'],
   'command reference table':          ['browse/sections/**', 'SKILL.md', 'SKILL.md.tmpl', 'browse/src/commands.ts', 'gstack/llms.txt', 'test/skill-llm-eval.test.ts'],
   'snapshot flags reference':         ['browse/sections/**', 'SKILL.md', 'SKILL.md.tmpl', 'browse/src/snapshot.ts', 'test/skill-llm-eval.test.ts'],
   'browse/SKILL.md reference':        ['browse/sections/**', 'browse/SKILL.md', 'browse/SKILL.md.tmpl', 'browse/src/**', 'test/skill-llm-eval.test.ts'],
   'setup block':                      ['browse/SKILL.md', 'browse/SKILL.md.tmpl', 'scripts/resolvers/aside.ts', 'scripts/resolvers/browse.ts', 'test/skill-llm-eval.test.ts'],
   'regression vs baseline':           ['browse/sections/**', 'SKILL.md', 'SKILL.md.tmpl', 'browse/src/commands.ts', 'test/fixtures/eval-baselines.json', 'test/skill-llm-eval.test.ts'],
-  'qa/SKILL.md workflow':             ['qa/sections/**', 'qa/SKILL.md', 'qa/SKILL.md.tmpl', 'test/skill-llm-eval.test.ts'],
+  'qa/SKILL.md workflow':             ['qa/**', 'qa/sections/**', 'qa/SKILL.md', 'qa/SKILL.md.tmpl', 'scripts/resolvers/qa.ts', 'scripts/resolvers/utility.ts', 'scripts/resolvers/sections.ts', 'test/helpers/workflow-judge-input.ts', 'test/skill-llm-eval.test.ts'],
   'qa/SKILL.md health rubric':        ['qa/sections/**', 'qa/SKILL.md', 'qa/SKILL.md.tmpl', 'test/skill-llm-eval.test.ts'],
   'qa/SKILL.md anti-refusal':         ['qa/sections/**', 'qa/SKILL.md', 'qa/SKILL.md.tmpl', 'qa-only/SKILL.md', 'qa-only/SKILL.md.tmpl', 'test/skill-llm-eval.test.ts'],
   'cross-skill greptile consistency': ['review/SKILL.md', 'review/SKILL.md.tmpl', 'ship/SKILL.md', 'ship/SKILL.md.tmpl', 'review/greptile-triage.md', 'retro/SKILL.md', 'retro/SKILL.md.tmpl', 'test/skill-llm-eval.test.ts'],
   'baseline score pinning':           ['browse/sections/**', 'SKILL.md', 'SKILL.md.tmpl', 'test/fixtures/eval-baselines.json', 'test/skill-llm-eval.test.ts'],
 
   // Ship & Release
-  'ship/SKILL.md workflow':               ['ship/SKILL.md', 'ship/SKILL.md.tmpl', 'test/skill-llm-eval.test.ts', 'test/helpers/workflow-judge-input.ts', 'test/helpers/workflow-judge-cache.ts', 'test/workflow-judge-cache.test.ts', 'scripts/eval-input-cache.ts', 'test/eval-input-cache.test.ts', 'test/workflow-judge-input.test.ts', 'test/helpers/workflow-excerpt.ts',
-    'test/ship-workflow-clarity.test.ts', 'scripts/resolvers/review.ts',
-    'scripts/resolvers/testing.ts', 'ship/sections/**'
+  'ship/SKILL.md workflow':               ['ship/SKILL.md', 'ship/SKILL.md.tmpl', 'test/skill-llm-eval.test.ts', 'test/helpers/workflow-judge-input.ts', 'test/helpers/workflow-judge-cache.ts', 'test/workflow-judge-cache.test.ts', 'test/llm-judge-stream.test.ts', 'scripts/eval-input-cache.ts', 'test/eval-input-cache.test.ts', 'test/workflow-judge-input.test.ts', 'test/helpers/workflow-excerpt.ts',
+    'test/ship-control-flow.test.ts', 'test/ship-workflow-clarity.test.ts', 'test/ship-plan-completion-invariants.test.ts', 'scripts/resolvers/review.ts',
+    'scripts/resolvers/testing.ts', 'ship/sections/**', 'qa/**', 'scripts/resolvers/qa.ts', 'scripts/resolvers/review-army.ts', 'test/ship-publication-gates.test.ts'
   ],
-  'document-release/SKILL.md workflow':   ['document-release/SKILL.md', 'document-release/SKILL.md.tmpl', 'test/skill-llm-eval.test.ts', 'test/helpers/workflow-judge-input.ts', 'test/helpers/workflow-judge-cache.ts', 'test/workflow-judge-cache.test.ts', 'scripts/eval-input-cache.ts', 'test/eval-input-cache.test.ts', 'test/workflow-judge-input.test.ts', 'test/helpers/workflow-excerpt.ts'],
+  'document-release/SKILL.md workflow':   ['document-release/**', 'document-release/SKILL.md', 'document-release/SKILL.md.tmpl', 'scripts/resolvers/sections.ts', 'test/skill-llm-eval.test.ts', 'test/helpers/workflow-judge-input.ts', 'test/helpers/workflow-judge-cache.ts', 'test/workflow-judge-cache.test.ts', 'scripts/eval-input-cache.ts', 'test/eval-input-cache.test.ts', 'test/workflow-judge-input.test.ts', 'test/helpers/workflow-excerpt.ts'],
 
   // Plan Reviews
   'plan-ceo-review/SKILL.md modes':       ['plan-ceo-review/sections/**', 'plan-ceo-review/SKILL.md', 'plan-ceo-review/SKILL.md.tmpl', 'test/skill-llm-eval.test.ts', 'test/helpers/workflow-judge-input.ts', 'test/helpers/workflow-judge-cache.ts', 'test/workflow-judge-cache.test.ts', 'scripts/eval-input-cache.ts', 'test/eval-input-cache.test.ts', 'test/workflow-judge-input.test.ts', 'test/helpers/workflow-excerpt.ts',
@@ -1854,7 +1905,7 @@ export const LLM_JUDGE_TOUCHFILES: Record<string, string[]> = {
 
   // Other skills
   'retro/SKILL.md instructions':          ['retro/sections/**', 'retro/SKILL.md', 'retro/SKILL.md.tmpl', 'test/skill-llm-eval.test.ts', 'test/helpers/workflow-judge-input.ts', 'test/helpers/workflow-judge-cache.ts', 'test/workflow-judge-cache.test.ts', 'scripts/eval-input-cache.ts', 'test/eval-input-cache.test.ts', 'test/workflow-judge-input.test.ts', 'test/helpers/workflow-excerpt.ts'],
-  'qa-only/SKILL.md workflow':            ['qa-only/SKILL.md', 'qa-only/SKILL.md.tmpl', 'test/skill-llm-eval.test.ts', 'test/helpers/workflow-judge-input.ts', 'test/helpers/workflow-judge-cache.ts', 'test/workflow-judge-cache.test.ts', 'scripts/eval-input-cache.ts', 'test/eval-input-cache.test.ts', 'test/workflow-judge-input.test.ts', 'test/helpers/workflow-excerpt.ts'],
+  'qa-only/SKILL.md workflow':            ['qa-only/**', 'qa-only/SKILL.md', 'qa-only/SKILL.md.tmpl', 'qa/**', 'scripts/resolvers/qa.ts', 'scripts/resolvers/utility.ts', 'scripts/resolvers/sections.ts', 'test/skill-llm-eval.test.ts', 'test/helpers/workflow-judge-input.ts', 'test/helpers/workflow-judge-cache.ts', 'test/workflow-judge-cache.test.ts', 'scripts/eval-input-cache.ts', 'test/eval-input-cache.test.ts', 'test/workflow-judge-input.test.ts', 'test/helpers/workflow-excerpt.ts'],
   'gstack-upgrade/SKILL.md upgrade flow': ['gstack-upgrade/SKILL.md', 'gstack-upgrade/SKILL.md.tmpl', 'test/skill-llm-eval.test.ts', 'test/helpers/workflow-judge-input.ts', 'test/helpers/workflow-judge-cache.ts', 'test/workflow-judge-cache.test.ts', 'scripts/eval-input-cache.ts', 'test/eval-input-cache.test.ts', 'test/workflow-judge-input.test.ts', 'test/helpers/workflow-excerpt.ts'],
   'sync-gbrain/SKILL.md read-only readiness': ['sync-gbrain/SKILL.md', 'sync-gbrain/SKILL.md.tmpl', 'bin/gstack-gbrain-read-capability.ts', 'test/skill-llm-eval.test.ts', 'test/helpers/workflow-judge-input.ts', 'test/helpers/workflow-judge-cache.ts', 'test/workflow-judge-cache.test.ts', 'scripts/eval-input-cache.ts', 'test/eval-input-cache.test.ts', 'test/workflow-judge-input.test.ts'],
 
@@ -1877,6 +1928,7 @@ export const GLOBAL_TOUCHFILES = [
   'test/helpers/eval-budgets.ts',
 
   'test/helpers/session-runner.ts',  // All E2E tests use this runner
+  'test/helpers/session-drain-policy.ts',
   'test/helpers/hermetic-env.ts',    // Changes every E2E child's environment
   'test/helpers/eval-store.ts',      // All E2E tests store results here
   'test/helpers/test-selection.ts',  // Selection logic itself — a bug here mis-selects every test

test/helpers/workflow-judge-cache.ts

@@ -6,7 +6,7 @@ import { spawnSync } from 'node:child_process';
 import { DEFAULT_JUDGE_MAX_TOKENS, resolveEvalModel } from '../../lib/eval-model';
 import { JUDGE_MS } from './eval-budgets';
 import type { JudgeScore } from './llm-judge';
-import { readWorkflowJudgeInput, buildWorkflowJudgePrompt } from './workflow-judge-input';
+import { readWorkflowJudgeInput, buildWorkflowJudgePrompt, WORKFLOW_JUDGE_RESPONSE_SCHEMA, WORKFLOW_JUDGE_REASONING_WORD_LIMIT } from './workflow-judge-input';
 import { buildEvalInputIdentity, lookupEvalInputCache, storeEvalInputCache,
   type EvalCacheValue, type EvalInputIdentity, type EvalPassingProof } from '../../scripts/eval-input-cache';
 
@@ -14,6 +14,11 @@ type Thresholds = { clarity: number; completeness: number; actionability: number
 export interface WorkflowCacheOptions {
   root: string; testName: string; skillPath: string; startMarker: string; endMarker: string | null;
   judgeContext: string; judgeGoal: string; model?: string; thresholds: Thresholds; prompt: string; attempt: number;
+  references?: readonly string[];
+  agentCapability?: 'frontier';
+  structuredResponse?: boolean;
+  maxTokens?: number;
+  stream?: boolean;
   env?: NodeJS.ProcessEnv;
 }
 export interface WorkflowJudgeReuse {
@@ -60,10 +65,12 @@ export function workflowJudgeDependencies(root: string, documents: string[]): st
   return [...seen].sort();
 }
 
-export function validWorkflowJudgeScore(value: EvalCacheValue, thresholds: Thresholds): value is JudgeScore & EvalCacheValue {
+export function validWorkflowJudgeScore(value: EvalCacheValue, thresholds: Thresholds, structuredResponse = false): value is JudgeScore & EvalCacheValue {
   if (!value || typeof value !== 'object' || Array.isArray(value)
     || Object.keys(value).sort().join(',') !== 'actionability,clarity,completeness,reasoning'
-    || typeof value.reasoning !== 'string') return false;
+    || typeof value.reasoning !== 'string'
+    || (structuredResponse && (!value.reasoning.trim()
+      || value.reasoning.trim().split(/\s+/).length >= WORKFLOW_JUDGE_REASONING_WORD_LIMIT))) return false;
   return (['clarity', 'completeness', 'actionability'] as const).every(key =>
     typeof value[key] === 'number' && Number.isInteger(value[key]) && value[key] >= thresholds[key] && value[key] <= 5);
 }
@@ -98,8 +105,11 @@ export function prepareWorkflowJudgeCache(opts: WorkflowCacheOptions): {
         coverage: { dependencies: 'complete', prompts: 'complete', environment: 'complete' }, unknownDependencies: [],
         files: workflowJudgeDependencies(opts.root, input.files.map(file => file.path)),
         prompts: { [opts.testName]: prompt },
-        parameters: { rootPackage, thresholds: opts.thresholds, max_tokens: DEFAULT_JUDGE_MAX_TOKENS, temperature: null, budget_ms: JUDGE_MS,
-          request: 'messages.create/user', retries: 1 },
+        parameters: { rootPackage, thresholds: opts.thresholds, max_tokens: opts.maxTokens ?? DEFAULT_JUDGE_MAX_TOKENS, temperature: null, budget_ms: JUDGE_MS,
+          request: opts.stream ? 'messages.stream/user' : 'messages.create/user', retries: 1,
+          ...(opts.stream ? { stream: true } : {}),
+          ...(opts.structuredResponse ? { output_config: { format: { type: 'json_schema', schema: WORKFLOW_JUDGE_RESPONSE_SCHEMA } },
+            response_validation: { reasoning_words_below: WORKFLOW_JUDGE_REASONING_WORD_LIMIT } } : {}) },
         runtime: { image: env.EVALS_CACHE_RUNTIME_ID!, bun: Bun.version, node: process.versions.node,
           platform: process.platform, arch: process.arch, judge: resolveEvalModel('judge', opts.model, env),
           anthropic_base_url: env.ANTHROPIC_BASE_URL ?? 'https://api.anthropic.com',
@@ -116,14 +126,14 @@ export function prepareWorkflowJudgeCache(opts: WorkflowCacheOptions): {
   return {
     lookup() {
       const result = lookupEvalInputCache({ ...common, identity: before,
-        validateResult: value => validWorkflowJudgeScore(value, opts.thresholds) });
+        validateResult: value => validWorkflowJudgeScore(value, opts.thresholds, opts.structuredResponse) });
       return result.status === 'reused'
         ? { scores: result.result as JudgeScore, reuse: { key: result.key, source: result.source } } : null;
     },
     publish(scores, isActive = () => true) {
       // Caller reaches here ONLY after its actual assertions passed. A later
       // failed case in the file does not erase this independently completed case.
-      if (!isActive() || !validWorkflowJudgeScore(scores as unknown as EvalCacheValue, opts.thresholds)) return;
+      if (!isActive() || !validWorkflowJudgeScore(scores as unknown as EvalCacheValue, opts.thresholds, opts.structuredResponse)) return;
       const after = currentIdentity();
       const runId = env.GITHUB_RUN_ID ? `${env.GITHUB_RUN_ID}/${env.GITHUB_RUN_ATTEMPT ?? '1'}` : env.EVALS_RUN_ID;
       if (!after || !runId || !isActive()) return;

test/helpers/workflow-judge-input.ts

@@ -4,7 +4,7 @@ import * as path from 'node:path';
 
 export interface WorkflowJudgeFile {
   path: string;
-  kind: 'entrypoint' | 'section';
+  kind: 'entrypoint' | 'section' | 'reference';
   content: string;
   startLine: number;
   endLine: number;
@@ -15,15 +15,55 @@ export interface WorkflowJudgeInput {
   text: string;
 }
 
-/** Exact existing rubric/request text; extraction must not resample a new prompt. */
-export function buildWorkflowJudgePrompt(opts: { judgeContext: string; judgeGoal: string }, input: WorkflowJudgeInput): string {
+export const QA_DISCOVERY_REFERENCES = [
+  'qa/sections/scope.md',
+  'qa/sections/exploratory.md',
+  'qa/sections/system-functional.md',
+  'qa/sections/browser-setup.md',
+  'qa/sections/qa-patterns.md',
+  'qa/templates/functional-report-template.md',
+];
+
+export const WORKFLOW_JUDGE_REASONING_WORD_LIMIT = 150;
+
+export const WORKFLOW_JUDGE_RESPONSE_SCHEMA = {
+  type: 'object',
+  properties: {
+    clarity: { type: 'integer', enum: [1, 2, 3, 4, 5] },
+    completeness: { type: 'integer', enum: [1, 2, 3, 4, 5] },
+    actionability: { type: 'integer', enum: [1, 2, 3, 4, 5] },
+    reasoning: { type: 'string',
+      description: `Under ${WORKFLOW_JUDGE_REASONING_WORD_LIMIT} words with at most two decisive examples, evaluating the complete supplied workflow.` },
+  },
+  required: ['clarity', 'completeness', 'actionability', 'reasoning'],
+  additionalProperties: false,
+};
+
+export function buildWorkflowJudgePrompt(opts: {
+  judgeContext: string;
+  judgeGoal: string;
+  agentCapability?: 'frontier';
+}, input: WorkflowJudgeInput): string {
   return `You are evaluating the quality of ${opts.judgeContext} for an AI coding agent.
 
 The agent reads these source files to learn ${opts.judgeGoal}. Shared preamble definitions and
 external tools/files are documented separately; do not penalize their absence from this bundle.
 On-demand sections retain their original file boundaries and Read instructions; the section
 index refers to those files, not duplicate work. The bundle order is not execution order.
-Judge the actual instructions, including contradictory ordering or missing decisions.
+Judge the actual instructions, including contradictory ordering or missing decisions.${opts.agentCapability === 'frontier' ? `
+
+Target reader: a frontier coding agent with GPT-5.6 Sol-level capability or stronger.
+Assume it can follow explicit cross-references, track saved state and a bounded work list,
+and distinguish conditional branches. Length, technical vocabulary and multiple explicit recovery paths alone are not clarity defects.
+Do not invent missing policies, permissions or evidence to make a workflow executable.
+
+Clarity 4 means the target agent can determine the next permitted action on each applicable path;
+5 additionally means those paths are easy to locate and understand.
+Score clarity 3 or lower when execution still requires guessing because of
+conflicting order, undefined decisions, unclear authority or missing input/output handling.
+Evaluate the whole workflow, but keep the JSON reasoning under 150 words with at most two decisive examples.
+For a clarity defect, cite the specific file/step and explain the competing actions or missing decision.
+Keep completeness and actionability independent: reader capability does not supply missing requirements.` : ''}
 
 Rate on three dimensions (1-5 scale):
 - **clarity** (1-5): Can an agent follow the instructions without ambiguity?
@@ -43,6 +83,7 @@ export function readWorkflowJudgeInput(opts: {
   skillPath: string;
   startMarker: string;
   endMarker: string | null;
+  references?: readonly string[];
 }): WorkflowJudgeInput {
   const sources = [{
     path: opts.skillPath,
@@ -59,7 +100,12 @@ export function readWorkflowJudgeInput(opts: {
         content: fs.readFileSync(path.join(sectionRoot, name), 'utf8'),
       }))
     : [];
-  const allSources = [...sources, ...sections];
+  const references = [...new Set(opts.references ?? [])].map(file => {
+    const resolved = path.resolve(opts.root, file);
+    if (!resolved.startsWith(path.resolve(opts.root) + path.sep)) throw new Error(`Reference outside root: ${file}`);
+    return { path: file, kind: 'reference' as const, content: fs.readFileSync(resolved, 'utf8') };
+  }).filter(file => ![...sources, ...sections].some(source => source.path === file.path));
+  const allSources = [...sources, ...sections, ...references];
 
   // Preserve the existing marker window, including markers that moved into
   // section files. Offsets identify the source of each slice; prose prefixes
@@ -76,8 +122,8 @@ export function readWorkflowJudgeInput(opts: {
     // Every section was already supplied in full by the old judge input. Keep
     // that coverage, but include each file once even when the marker window
     // also covers part of it. Only the entrypoint retains the requested slice.
-    const from = file.kind === 'section' ? 0 : Math.max(0, start - offset);
-    const to = file.kind === 'section' ? file.content.length : Math.min(file.content.length, end - offset);
+    const from = file.kind !== 'entrypoint' ? 0 : Math.max(0, start - offset);
+    const to = file.kind !== 'entrypoint' ? file.content.length : Math.min(file.content.length, end - offset);
     if (from < to) {
       files.push({
         ...file,
@@ -93,7 +139,7 @@ export function readWorkflowJudgeInput(opts: {
   const context = [
     'The material below is a bundle of source-file excerpts, with each original file and line range labeled.',
     'SKILL.md is the entry point; the labeled ranges identify which excerpts are supplied.',
-    ...(sections.length > 0 ? [
+    ...(sections.length + references.length > 0 ? [
       'The section files remain separate on disk and are read at the points and conditions specified by the skill\'s Read directives.',
       'They are supplied here as on-demand references; their order in this bundle is not execution order.',
     ] : []),