gstack/bin/gstack-ship-receipt

#!/usr/bin/env -S bun --no-env-file --config=/dev/null
/**
 * gstack-ship-receipt — the handoff record, identifiers first (plan C5).
 *
 *   gstack-ship-receipt write [--pr <n>] [--head <sha>] [--base <ref>] [--version <X>] [--gated-tree <sha>]
 *                             [--predecessor <sha>] [--gate <json|@file>] [--ci <json|@file>] [--spend-usd <n>]
 *                             [--session-kind <k>] [--artifacts-consumed <n>/<m>] [--run <id>] [--thread <id>]
 *                             [--receipt <tree-receipt.json>] [--policy <label>] [--preregistration <text>] [--history <text>]
 *                             [--pregate <pregate.json>] [--issues <json|@file>] [--approval <line>]... [--approval-run <dir>]...
 *                             [--out <file>] [--body <pr-body.md>] [--json]
 *   gstack-ship-receipt read --pr <n> [--repo <owner/repo>] [--check-prose] [--json]
 *   gstack-ship-receipt read --body <file> [--json]
 *   gstack-ship-receipt result (--pr <n> [--repo <owner/repo>] | --body <file>) [--head <sha>] [--out <dir>] [--json]
 *   gstack-ship-receipt census --repo <owner/repo> --since <tag|YYYY-MM-DD> [--cohort <file>] [--limit <n>] [--json]
 *   gstack-ship-receipt carry (--pr <n> [--repo <owner/repo>] | --body <file>) [--base <ref>] [--head <sha>] [--pregate <pregate.json>] [--dry-run] [--out <dir>] [--json]
 *   gstack-ship-receipt docs-caps [--base <ref>] [--policy <ship-policy.json>] [--json]
 *
 * `write` validates against `gstack-artifact schema ship-receipt`, prints the
 * fenced block (and SHIP_RECEIPT: <identifiers> on stderr), writes it to --out,
 * and with --body makes it the first section of that PR body file.
 * `result` is /ship's terminal step: it binds the receipt to HEAD, writes the
 * run record under <state>/ship/runs/ (ship-run.json: a /ship record, not a
 * `run` v1 manifest, so `gstack-artifact validate` does not apply to it) and
 * prints GSTACK_RESULT: skill=ship. A gh failure prints status=incomplete.
 * `carry` rebinds an earlier head's receipt to HEAD when the product diff
 * against the base is unchanged (a conflict-only base merge, a test-only fix,
 * release metadata), records the evidence in the receipt's `carry` object,
 * posts the body and ends with the same terminal line; a product change is
 * RECEIPT_CARRY_PRODUCT_CHANGED and nothing is rewritten.
 * Query commands: no GSTACK_RESULT line. Logic: lib/ship-receipt.ts.
 */
import { spawnSync } from 'node:child_process';
import * as fs from 'node:fs';
import * as path from 'node:path';
import { EXIT, exitTableHelp, type ShipReceipt } from '../lib/headless-artifacts';
import { resultLine, resultLineWithDocs } from '../lib/result-codes';
import { versionAtRef } from '../lib/restamp';
import { readPregateFile, verifyPregate } from '../lib/pregate/index';
import { isUnavailable, loadPolicyFromBase, matchesAny, policyUnavailableLine, resolveBaseBranch, runningGstackVersion, stampFilesInTree, validatePolicy, type ShipPolicy } from '../lib/ship-policy';
import { approvalForReceipt } from '../lib/approval-citations';
import {
  CARRY_METADATA_GLOBS, CARRY_NAMED_PATHS, CARRY_TEST_GLOBS,
  bindReceipt, carryReceipt, classifyCarryPath, computeCensus, extractReceipt, missingIssueLines, orderReceipt, parseReviewLoop, placeReceiptFirst, planCarry, planTreeCarry,
  receiptIssuesFrom, receiptSummaryLine, renderCensus, renderReceiptBlock, validateReceipt, type CensusPr,
} from '../lib/ship-receipt';
import { checkDocsCaps, docsCapLine, docsExceptionLine, parseReceiptDocs } from '../lib/ship-receipt-docs';
import { deeper, depthBelow, exceptionProblems, parseReviewLoopException, receiptDepthAtHead, reviewLoopExceptionLine } from '../lib/ship-receipt-depth';
import { checkReceiptProse, proseLine } from '../lib/ship-receipt-prose';
import { resolveStateRoot } from '../lib/state-root';
import { isRegistryUnavailable, loadRegistryFromBase } from '../lib/regen';

const HELP = `gstack-ship-receipt — the \`\`\`gstack-ship-receipt\`\`\` block (docs/ship-policy.md#ship-receipt)

  write [flags]                       compose, validate and print the block; --body <file> puts it first in that PR body
  read --pr <n> [--repo <r>]          parse the block from the PR body through gh (RECEIPT_MISSING / RECEIPT_INVALID)
  read --body <file>                  parse the block from a file
  read … --check-prose                also compare every counter the body quotes (passes=2, 1 deferred, passed: 41)
                                      with the receipt's review_loop, gate and ci integers: RECEIPT_PROSE_MISMATCH (exit 1)
  result --pr <n> [--repo <r>] | --body <file> [--head <sha>] [--out <dir>]
                                      /ship's terminal line: binds the receipt to HEAD (QUEUE_RECEIPT_MISSING / QUEUE_RECEIPT_STALE),
                                      writes <state>/ship/runs/<utc>-<head12>/{ship-run.json,ship-receipt.md} and prints
                                      GSTACK_RESULT: skill=ship status=complete run=<dir> (refused: status=refused run=-)
  census --repo <r> --since <tag|date> [--cohort <file>]
                                      the P7 adoption number over merged PRs (deduplicated by run and thread)
  carry --pr <n> [--repo <r>] | --body <file> [--base <ref>] [--head <sha>] [--pregate <pregate.json>] [--dry-run] [--out <dir>]
                                      carry the receipt to HEAD when only a base merge, tests, release metadata or registered
                                      outputs the --pregate regen check proved (recreated them) changed since its head (product patch-id
                                      unchanged), or after a rebase onto a tree the receipt covers with the recorded product
                                      patch-id: rewrites the receipt with a \`carry\` record, posts the body (gh pr edit) and
                                      prints GSTACK_RESULT: skill=ship status=complete; RECEIPT_CARRY_PRODUCT_CHANGED /
                                      RECEIPT_CARRY_TREE_MISMATCH / RECEIPT_CARRY_REFUSED leave the body unchanged (exit 3);
                                      a receipt that records a pregate needs --pregate current for HEAD (RECEIPT_CARRY_PREGATE_STALE);
                                      needs git >= 2.39 (RECEIPT_GIT_TOO_OLD)
  docs-caps [--base <ref>]            /ship Step 14.5: one DOCS_CAP: <path> <bytes>/<max> ok|over line per docs.caps entry of the
                                      reviewed policy (origin/<base>'s .gstack/ship-policy.json; --policy <file> reads that file
                                      instead); any over (or absent) file exits 1 (DOCS_AUDIT_BLOCKED)

write flags: --pr --head --base --version --gated-tree --predecessor --gate <json|@file> --ci <json|@file> --spend-usd
  --session-kind --artifacts-consumed <n>/<m> --run --thread --receipt <tree-receipt.json> --policy --preregistration
  --history --queue-mode --pregate <pregate.json> (C8: refused unless current, green and every requires-remote obligation
  carries a receipt: PREGATE_STALE / PREGATE_LANE_FAILED / PREGATE_INCOMPLETE / PREGATE_REMOTE_UNCLEARED) --issues <json|@file>
  (C6: gstack-issue-links --out/--json; with --body, refused with ISSUE_LINKS_MISSING unless the body carries every Fixes/Refs/Flake/Related line)
  --approval <"Approved by <owner> <YYYY-MM-DD> via <ref> [for <class>@<digest12>]"> (repeatable; the --body file's lines count too)
  --review-loop <json|@file> ({passes, blocking_found, deferred[, noted, fixed, scope]}: gstack-review-scope summary --out)
  --docs <json|@file> ({status: updated|current|blocked, scope[, exception: {accepted_by, date, via, reason}]}: Step 14.5's outcome;
  blocked without an exception is DOCS_AUDIT_BLOCKED, and with --body the body must carry the exception line verbatim)
  --review-loop-exception <json|@file> ({accepted_by, date, via, reason, fix_check: {head, findings[, files]}}: the owner accepted a
  stop after a fix-check edit; needs --review-loop with fix_checks >= 1, fix_check.head an ancestor of the head, and with --body the
  "Review-loop exception: …" line verbatim; else REVIEW_LOOP_EXCEPTION_INVALID). Every receipt records gstack_version and
  review_depth: the depth HEAD needs, recomputed from the committed range (--head must be HEAD; a dirty checkout or an
  unreadable input records full).
  --approval-run <autoplan run dir> (repeatable; resolves plan-sha citations) (W2: a class declared in origin/<base>'s
  .gstack/approval-classes.json with hits needs a citation that resolves and binds to its effects: APPROVAL_CITATION_MISSING)
  --out <file> --body <pr-body.md>. Defaults: head=HEAD, base=origin/HEAD's branch, version=the
  version source at HEAD ("none" when HEAD has no version source, no policy stamp file and no CHANGELOG), session_kind=$GSTACK_SESSION_KIND (gstack-session-kind), tree/gate_reuse/gated_tree/predecessor
  from --receipt when given.
--json: JSON only on stdout.
${exitTableHelp()}`;

function flag(args: string[], name: string): string | undefined {
  const i = args.indexOf(name);
  return i >= 0 ? args[i + 1] : undefined;
}
function flags(args: string[], name: string): string[] {
  return args.flatMap((a, i) => (a === name && args[i + 1] !== undefined ? [args[i + 1]!] : []));
}
function jsonArg(raw: string | undefined): Record<string, unknown> | undefined {
  if (raw === undefined) return undefined;
  const text = raw.startsWith('@') ? fs.readFileSync(raw.slice(1), 'utf8') : raw;
  const parsed = JSON.parse(text);
  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) throw new Error('expected a JSON object');
  return parsed;
}
function git(args: string[], cwd?: string): string | undefined {
  const r = spawnSync('git', args, { cwd, encoding: 'utf8', timeout: 30_000 });
  return r.status === 0 ? r.stdout.trim() : undefined;
}
function gh(args: string[]): { ok: boolean; out: string; err: string } {
  const r = spawnSync('gh', args, { encoding: 'utf8', timeout: 120_000, maxBuffer: 64 * 1024 * 1024 });
  return { ok: r.status === 0, out: r.stdout ?? '', err: (r.stderr ?? '').trim() };
}

/**
 * The receipt's `version`: the version source at HEAD (the pinned path, else
 * VERSION, else package.json#version). A repository with none of those, no
 * policy stamp file and no CHANGELOG at HEAD has no release version to record,
 * and the receipt says so with `"none"` (docs/ship-policy.md#ship-receipt);
 * `read`, `result` and the queue accept it like any other version string.
 * Only an absent source is `"none"`: a VERSION that exists but holds no
 * parsable version, a pin that escapes the repository, or an unreadable base
 * policy keeps the existing no-version refusal.
 */
function receiptVersion(repoRoot: string, head: string, base: string): string | undefined {
  const atHead = versionAtRef(repoRoot, head);
  if ('version' in atHead) return atHead.version;
  if (!/ does not exist at /.test(atHead.error)) return undefined;
  const show = (rel: string) => git(['show', `${head}:${rel}`], repoRoot);
  try { const v = JSON.parse(show('package.json') ?? 'null')?.version; if (typeof v === 'string' && v.trim()) return v.trim(); } catch { /* not a manifest */ }
  const load = loadPolicyFromBase(repoRoot, base);
  if (isUnavailable(load)) return undefined;
  const changelogs = [...new Set([load.policy.changelog, 'CHANGELOG.md'].filter((p): p is string => !!p))];
  if (stampFilesInTree(repoRoot, head, load.policy.stamp_files).length || changelogs.some(p => show(p) !== undefined)) return undefined;
  return 'none';
}

/**
 * What a later carry across rewritten history compares: the head's tree and its
 * product patch-id against the base. Both are evidence, never a gate: a head
 * outside a checkout (or a base that does not resolve) records neither, and
 * such a receipt then carries only along its own history.
 */
function reviewedProduct(repoRoot: string, base: string, head: string, pregateFile: string | undefined): { head_tree?: string; product_patch_id?: string } {
  const tree = git(['rev-parse', '--verify', '--quiet', `${head}^{tree}`], repoRoot);
  if (!tree) return {};
  const baseRef = `origin/${base.replace(/^origin\//, '')}`;
  const id = productPatchAgainstBase(repoRoot, productRules(repoRoot, base, verifiedOutputs(repoRoot, base, pregateFile)), baseRef, head);
  return typeof id === 'string' ? { head_tree: tree, product_patch_id: id || 'none' } : { head_tree: tree };
}

function cmdWrite(rest: string[], json: boolean): number {
  const repoRoot = git(['rev-parse', '--show-toplevel']) ?? process.cwd();
  const checkedOut = git(['rev-parse', 'HEAD'], repoRoot);
  const head = flag(rest, '--head') ?? checkedOut;
  if (!head) { process.stderr.write('gstack-ship-receipt write: --head is required outside a git repository\n'); return EXIT.usage; }
  const headSha = git(['rev-parse', '--verify', '--quiet', `${head}^{commit}`], repoRoot);
  if (checkedOut && headSha !== checkedOut) {
    process.stderr.write(resultLine('gstack-ship-receipt write', 'RECEIPT_INVALID', `--head ${head.slice(0, 12)} is not the checked-out HEAD ${checkedOut.slice(0, 12)}; the receipt binds the reviewed tree, so check out ${head.slice(0, 12)} and write there; nothing written`) + '\n');
    return EXIT.fail;
  }
  const receiptFile = flag(rest, '--receipt');
  const tree = receiptFile ? JSON.parse(fs.readFileSync(receiptFile, 'utf8')) : null;
  let sessionKind = flag(rest, '--session-kind') ?? process.env.GSTACK_SESSION_KIND;
  if (!sessionKind) {
    const r = spawnSync(path.join(path.dirname(Bun.fileURLToPath(import.meta.url)), 'gstack-session-kind'), [], { encoding: 'utf8', timeout: 15_000 });
    sessionKind = r.status === 0 ? r.stdout.trim() || undefined : undefined;
  }
  let pregate: PregateField | undefined;
  const pregateFile = flag(rest, '--pregate');
  if (pregateFile) {
    const read = pregateFieldFor(repoRoot, pregateFile, head);
    if (!read.ok) { for (const e of read.errors) process.stderr.write(resultLine('gstack-ship-receipt write', e.code, `${e.message}; nothing written`) + '\n'); return EXIT.fail; }
    pregate = read.field;
  }
  const base = flag(rest, '--base') ?? resolveBaseBranch(repoRoot);
  const bodyFile = flag(rest, '--body');
  const bodyText = bodyFile && fs.existsSync(bodyFile) ? fs.readFileSync(bodyFile, 'utf8').replace(/```gstack-ship-receipt[\s\S]*?\n```/g, '') : '';
  let docs: ReturnType<typeof parseReceiptDocs> | undefined;
  if (flag(rest, '--docs') !== undefined) {
    try { docs = parseReceiptDocs(jsonArg(flag(rest, '--docs'))); } catch (e: any) { process.stderr.write(`gstack-ship-receipt write: --docs: ${e.message}\n`); return EXIT.usage; }
    if (!docs.ok) { process.stderr.write(resultLineWithDocs('gstack-ship-receipt write', docs.code, `${docs.message}; nothing written`) + '\n'); return docs.code === 'DOCS_AUDIT_BLOCKED' ? EXIT.refused : EXIT.fail; }
    const exceptionLine = docsExceptionLine(docs.docs);
    if (bodyFile && exceptionLine && !bodyText.split(/\r?\n/).some(l => l.trim() === exceptionLine)) {
      process.stderr.write(resultLineWithDocs('gstack-ship-receipt write', 'DOCS_AUDIT_BLOCKED', `${bodyFile} does not carry the exception line verbatim: ${JSON.stringify(exceptionLine)}; nothing written`) + '\n');
      return EXIT.refused;
    }
  }
  let loopException: ReturnType<typeof parseReviewLoopException> | undefined;
  if (flag(rest, '--review-loop-exception') !== undefined) {
    const refuse = (why: string) => { process.stderr.write(resultLineWithDocs('gstack-ship-receipt write', 'REVIEW_LOOP_EXCEPTION_INVALID', `${why}; nothing written`) + '\n'); return EXIT.fail; };
    try { loopException = parseReviewLoopException(jsonArg(flag(rest, '--review-loop-exception'))); } catch (e: any) { return refuse(`--review-loop-exception: ${e.message}`); }
    if (!loopException.ok) return refuse(loopException.message);
    let loop: unknown; try { loop = jsonArg(flag(rest, '--review-loop')); } catch {}
    if (!parseReviewLoop(loop)?.fix_checks) return refuse('--review-loop-exception needs --review-loop with fix_checks >= 1: the stop it accepts follows a fix-check');
    const fc = loopException.exception.fix_check.head;
    if (spawnSync('git', ['merge-base', '--is-ancestor', fc, head], { cwd: repoRoot }).status !== 0) return refuse(`fix_check.head ${fc.slice(0, 12)} is not ${head.slice(0, 12)} or an ancestor of it`);
    const line = reviewLoopExceptionLine(loopException.exception);
    if (bodyFile && !bodyText.split(/\r?\n/).some(l => l.trim() === line)) return refuse(`${bodyFile} does not carry the exception line verbatim: ${JSON.stringify(line)}`);
  }
  const reviewDepth = receiptDepthAtHead(repoRoot, base, path.dirname(Bun.fileURLToPath(import.meta.url)), headSha ?? head);
  const approval = approvalForReceipt({ repoRoot, base, head, citationText: [bodyText, ...flags(rest, '--approval')].join('\n'), runDirs: flags(rest, '--approval-run') });
  if (approval.kind === 'invalid') {
    for (const line of approval.lines) process.stderr.write(resultLine('gstack-ship-receipt write', 'APPROVAL_CLASSES_INVALID', line) + '\n');
    return EXIT.fail;
  }
  if (approval.kind === 'error' && approval.code) { process.stderr.write(resultLine('gstack-ship-receipt write', approval.code, `${approval.message}; nothing written`) + '\n'); return EXIT.fail; }
  if (approval.kind === 'error') { process.stderr.write(`gstack-ship-receipt write: approval classes: ${approval.message}; nothing written\n`); return EXIT.fail; }
  if (approval.kind === 'missing') {
    for (const m of approval.missing) process.stderr.write(resultLine('gstack-ship-receipt write', 'APPROVAL_CITATION_MISSING', `${m.class} (${m.token}; effects in ${m.files.join(', ')}): ${m.reasons.join('; ')}`) + '\n');
    process.stderr.write('gstack-ship-receipt write: nothing written\n');
    return EXIT.fail;
  }
  if (approval.kind === 'ok' && approval.note) process.stderr.write(approval.note + '\n');
  let input: Partial<ShipReceipt> & { docs?: unknown };
  try {
    const issuesFile = jsonArg(flag(rest, '--issues'));
    const loopRaw = jsonArg(flag(rest, '--review-loop'));
    const reviewLoop = loopRaw ? parseReviewLoop(loopRaw) : undefined;
    if (loopRaw && !reviewLoop) throw new Error('--review-loop needs integer passes, blocking_found and deferred (gstack-review-scope summary --out <file>, then @<file>)');
    input = {
      schema_version: 1, pr: flag(rest, '--pr') !== undefined ? Number(flag(rest, '--pr')) : undefined, head,
      version: flag(rest, '--version') ?? receiptVersion(repoRoot, head, base), base,
      gated_tree: flag(rest, '--gated-tree') ?? tree?.gated_tree, predecessor: flag(rest, '--predecessor') ?? tree?.predecessor?.recorded_head ?? undefined,
      tree: tree?.tree, gate_reuse: tree ? `${tree.gate_reuse} (${tree.gate_reuse_reason})` : undefined,
      gate: jsonArg(flag(rest, '--gate')), ci: jsonArg(flag(rest, '--ci')),
      spend_usd: flag(rest, '--spend-usd') !== undefined ? (Number.isFinite(Number(flag(rest, '--spend-usd'))) ? Number(flag(rest, '--spend-usd')) : flag(rest, '--spend-usd')) : undefined,
      session_kind: sessionKind, artifacts_consumed: flag(rest, '--artifacts-consumed'), run: flag(rest, '--run'), thread: flag(rest, '--thread'),
      policy: flag(rest, '--policy') ?? tree?.policy, queue_mode: flag(rest, '--queue-mode'), preregistration: flag(rest, '--preregistration'), history: flag(rest, '--history'),
      ...pregate, issues: issuesFile ? receiptIssuesFrom(issuesFile) : undefined, approval: approval.kind === 'ok' ? approval.approval : undefined,
      review_loop: reviewLoop, ...(docs?.ok ? { docs: docs.docs } : {}), ...reviewedProduct(repoRoot, base, head, pregateFile),
      gstack_version: runningGstackVersion(), review_depth: reviewDepth, review_loop_exception: loopException?.ok ? loopException.exception : undefined,
    };
  } catch (e: any) { process.stderr.write(`gstack-ship-receipt write: ${e.message}\n`); return EXIT.usage; }
  if (input.pr !== undefined && !Number.isInteger(input.pr)) { process.stderr.write('gstack-ship-receipt write: --pr must be an integer\n'); return EXIT.usage; }
  const receipt = orderReceipt(input);
  const errors = validateReceipt(receipt);
  if (errors.length) {
    for (const e of errors) process.stderr.write(resultLine('gstack-ship-receipt write', 'RECEIPT_INVALID', `${e.message} at ${e.path}`) + '\n');
    process.stderr.write('gstack-ship-receipt write: nothing written\n');
    return EXIT.fail;
  }
  const body = bodyFile;
  const missing = body && receipt.issues ? missingIssueLines(fs.existsSync(body) ? fs.readFileSync(body, 'utf8') : '', receipt.issues) : [];
  if (missing.length) {
    process.stderr.write(resultLineWithDocs('gstack-ship-receipt write', 'ISSUE_LINKS_MISSING', `${body} lacks ${missing.map(l => JSON.stringify(l)).join(', ')}`) + '\n');
    return EXIT.fail;
  }
  const block = renderReceiptBlock(receipt);
  const out = flag(rest, '--out');
  if (out) fs.writeFileSync(out, block);
  if (body) fs.writeFileSync(body, placeReceiptFirst(fs.existsSync(body) ? fs.readFileSync(body, 'utf8') : '', receipt));
  process.stderr.write(receiptSummaryLine(receipt) + '\n');
  process.stdout.write(json ? JSON.stringify(receipt) + '\n' : block);
  return EXIT.ok;
}

function cmdRead(rest: string[], json: boolean): number {
  const bodyFile = flag(rest, '--body');
  const pr = flag(rest, '--pr');
  let body: string;
  if (bodyFile) body = fs.readFileSync(bodyFile, 'utf8');
  else if (pr) {
    const repo = flag(rest, '--repo');
    const r = gh(['pr', 'view', pr, ...(repo ? ['--repo', repo] : []), '--json', 'body']);
    if (!r.ok) { process.stderr.write(`gstack-ship-receipt read: gh pr view failed: ${r.err}\n`); return EXIT.fail; }
    try { body = JSON.parse(r.out).body ?? ''; } catch { process.stderr.write('gstack-ship-receipt read: gh returned no JSON body\n'); return EXIT.fail; }
  } else { process.stderr.write(`gstack-ship-receipt read: --pr <n> or --body <file> is required\n${HELP}\n`); return EXIT.usage; }
  const ex = extractReceipt(body);
  if (!ex.found) {
    process.stderr.write(resultLine('gstack-ship-receipt read', 'RECEIPT_MISSING', pr ? `PR #${pr}` : bodyFile!) + '\n');
    if (json) process.stdout.write(JSON.stringify({ found: false, errors: [] }) + '\n');
    return EXIT.fail;
  }
  if (ex.errors.length) {
    for (const e of ex.errors) process.stderr.write(resultLine('gstack-ship-receipt read', 'RECEIPT_INVALID', `${e.message} at ${e.path}`) + '\n');
    if (json) process.stdout.write(JSON.stringify({ found: true, valid: false, errors: ex.errors, raw: ex.raw }) + '\n');
    return EXIT.fail;
  }
  process.stderr.write(receiptSummaryLine(ex.receipt!) + '\n');
  if (rest.includes('--check-prose')) {
    const prose = checkReceiptProse(ex.receipt as unknown as Record<string, unknown>, body);
    process.stderr.write(proseLine(prose) + '\n');
    if (prose.mismatches.length) {
      process.stderr.write(resultLineWithDocs('gstack-ship-receipt read', 'RECEIPT_PROSE_MISMATCH', prose.mismatches.map(m => `${m.field} body=${m.prose} receipt=${m.receipt}`).join(', ')) + '\n');
      if (json) process.stdout.write(JSON.stringify({ found: true, valid: true, receipt: ex.receipt, prose }) + '\n');
      return EXIT.fail;
    }
    if (json) { process.stdout.write(JSON.stringify({ found: true, valid: true, receipt: ex.receipt, prose }) + '\n'); return EXIT.ok; }
  }
  process.stdout.write(json ? JSON.stringify(ex.receipt) + '\n' : renderReceiptBlock(ex.receipt!));
  return EXIT.ok;
}

/**
 * /ship's terminal line (docs/unattended.md#the-terminal-line). The receipt in
 * the PR body (or the handoff file) must bind to HEAD: then the run record
 * goes under <state>/ship/runs/ with the head, the PR and the receipt, and
 * the last stdout line is GSTACK_RESULT: skill=ship status=complete run=<dir>.
 * A missing or stale receipt is status=refused run=- (exit 3), so a parent
 * never has to parse the PR body to know whether /ship finished at this head.
 */
function cmdResult(rest: string[], json: boolean): number {
  const bodyFile = flag(rest, '--body');
  const prFlag = flag(rest, '--pr');
  if (prFlag !== undefined && !/^[1-9]\d*$/.test(prFlag)) { process.stderr.write(`gstack-ship-receipt result: --pr must be a PR number, got ${JSON.stringify(prFlag.slice(0, 40))}\n`); return EXIT.usage; }
  const pr = prFlag;
  if (prFlag !== undefined && flag(rest, '--body') !== undefined) { process.stderr.write('gstack-ship-receipt result: pass --pr <n> (the PR body, checked against its pushed head) or --body <file> (the handoff receipt), not both\n'); return EXIT.usage; }
  const repoRoot = git(['rev-parse', '--show-toplevel']);
  const head = (flag(rest, '--head') ?? (repoRoot ? git(['rev-parse', 'HEAD'], repoRoot) : undefined))?.toLowerCase();
  const refused = (code: 'QUEUE_RECEIPT_MISSING' | 'QUEUE_RECEIPT_STALE', message: string) => {
    process.stderr.write(resultLineWithDocs('gstack-ship-receipt result', code, message) + '\n');
    process.stdout.write(json ? JSON.stringify({ skill: 'ship', status: 'refused', run: '-', code, message }) + '\n' : 'GSTACK_RESULT: skill=ship status=refused run=-\n');
    return EXIT.refused;
  };
  if (!head) { process.stderr.write('gstack-ship-receipt result: --head <sha> is required outside a git repository\n'); return EXIT.usage; }
  if (!/^[0-9a-f]{40,64}$/i.test(head)) { process.stderr.write(`gstack-ship-receipt result: --head must be a full hex commit id, got ${JSON.stringify(head.slice(0, 40))}\n`); return EXIT.usage; }
  const incomplete = (why: string) => {
    process.stderr.write(`gstack-ship-receipt result: ${why}\n`);
    process.stdout.write(json ? JSON.stringify({ skill: 'ship', status: 'incomplete', run: '-', message: why }) + '\n' : 'GSTACK_RESULT: skill=ship status=incomplete run=-\n');
    return EXIT.fail;
  };
  let body: string;
  let source: string;
  if (bodyFile) {
    if (!fs.existsSync(bodyFile)) return refused('QUEUE_RECEIPT_MISSING', `${bodyFile} does not exist; /ship did not write its receipt`);
    try { body = fs.readFileSync(bodyFile, 'utf8'); } catch (e) { return incomplete(`cannot read ${bodyFile}: ${e instanceof Error ? e.message : String(e)}`); }
    source = path.resolve(bodyFile);
  } else if (pr) {
    const repo = flag(rest, '--repo');
    const r = gh(['pr', 'view', pr, ...(repo ? ['--repo', repo] : []), '--json', 'body,headRefOid']);
    if (!r.ok) return incomplete(`gh pr view failed: ${r.err.trim()}`);
    let pushed: unknown;
    try { const v = JSON.parse(r.out); body = v.body ?? ''; pushed = v.headRefOid; } catch { return incomplete('gh returned no JSON body'); }
    if (typeof pushed !== 'string' || !/^[0-9a-f]{12,64}$/i.test(pushed)) return incomplete(`gh pr view returned no headRefOid for PR #${pr}`);
    if (!pushed.toLowerCase().startsWith(head.toLowerCase())) {
      return refused('QUEUE_RECEIPT_STALE', `HEAD ${head.slice(0, 12)} is not PR #${pr}'s pushed head ${pushed.slice(0, 12)}; push it, then rerun gstack-ship-receipt result`);
    }
    source = `PR #${pr}${repo ? ` (${repo})` : ''}`;
  } else { process.stderr.write(`gstack-ship-receipt result: --pr <n> or --body <file> is required\n${HELP}\n`); return EXIT.usage; }
  const bound = bindReceipt(body, pr, [head]);
  if (!bound.ok) return refused(bound.code, bound.message);
  return writeRunRecord({ receipt: bound.receipt, head, pr, source, repoRoot, out: flag(rest, '--out'), json, line: bound.line, incomplete });
}

/** The run record under <state>/ship/runs/ and the terminal line, shared by `result` and `carry`. */
function writeRunRecord(a: { receipt: ShipReceipt; head: string; pr: string | undefined; source: string; repoRoot: string | undefined; out: string | undefined; json: boolean; line: string; incomplete: (why: string) => number; extra?: Record<string, unknown> }): number {
  const stamp = new Date().toISOString().replace(/[:.]/g, '-');
  const dir = a.out ? path.resolve(a.out) : path.join(resolveStateRoot(), 'ship', 'runs', `${stamp}-${a.head.slice(0, 12)}`);
  const receiptPath = path.join(dir, 'ship-receipt.md');
  try {
    fs.mkdirSync(dir, { recursive: true });
    fs.writeFileSync(receiptPath, renderReceiptBlock(a.receipt));
  } catch (e) { return a.incomplete(`cannot write the run record under ${dir}: ${e instanceof Error ? e.message : String(e)}`); }
  const run = {
    schema_version: 1, skill: 'ship', status: 'complete', head: a.head, pr: a.receipt.pr ?? (a.pr ? Number(a.pr) : null), base: a.receipt.base, version: a.receipt.version ?? null,
    queue_mode: a.receipt.queue_mode ?? null, session_kind: a.receipt.session_kind ?? process.env.GSTACK_SESSION_KIND ?? null,
    receipt: receiptPath, receipt_source: a.source, branch: a.repoRoot ? git(['rev-parse', '--abbrev-ref', 'HEAD'], a.repoRoot) ?? null : null, created_at: new Date().toISOString(),
    ...(a.extra ?? {}),
  };
  try { fs.writeFileSync(path.join(dir, 'ship-run.json'), JSON.stringify(run, null, 2) + '\n'); } catch (e) { return a.incomplete(`cannot write ${path.join(dir, 'ship-run.json')}: ${e instanceof Error ? e.message : String(e)}`); }
  process.stderr.write(a.line + '\n');
  process.stdout.write(a.json ? JSON.stringify({ ...run, run: dir }) + '\n' : `GSTACK_RESULT: skill=ship status=complete run=${dir}\n`);
  return EXIT.ok;
}

/**
 * One diff's patch-id over a pathspec; empty when the diff is empty. `--verbatim`
 * keeps whitespace in the hash (the default and `--stable` strip it, so a space
 * moved in a shell line would read as the same patch) while still ignoring the
 * hunk line numbers a base merge shifts.
 */
function patchId(repoRoot: string, from: string, to: string, pathspec: string[]): string | { error: string } {
  const firstLine = (s: string | null | undefined, fallback: string) => (s ?? '').trim().split('\n')[0]?.slice(0, 200) || fallback;
  const diff = spawnSync('git', ['diff', '--no-color', '--no-ext-diff', '--full-index', from, to, '--', ...pathspec], { cwd: repoRoot, encoding: 'utf8', timeout: 120_000, maxBuffer: 256 * 1024 * 1024 });
  if (diff.status !== 0) return { error: `git diff ${from.slice(0, 12)} ${to.slice(0, 12)}: ${firstLine(diff.stderr, diff.signal ? `killed by ${diff.signal}` : `exit ${diff.status}`)}` };
  if (!diff.stdout.trim()) return '';
  const id = spawnSync('git', ['patch-id', '--verbatim'], { cwd: repoRoot, input: diff.stdout, encoding: 'utf8', timeout: 120_000, maxBuffer: 64 * 1024 * 1024 });
  if (id.status !== 0) return { error: `git patch-id --verbatim: ${firstLine(id.stderr, id.signal ? `killed by ${id.signal}` : `exit ${id.status}`)}` };
  return id.stdout.trim().split(/\s+/)[0] ?? '';
}

/** `git patch-id --verbatim` exists from git 2.39 (docs/ship-policy.md#receipt-carry); an older git is a named refusal, never a silent fallback to the whitespace-stripping default. */
const CARRY_MIN_GIT = '2.39';
function gitVersionBelow(repoRoot: string, minimum: string): string | null {
  const raw = git(['--version'], repoRoot) ?? '';
  const m = /(\d+)\.(\d+)(?:\.(\d+))?/.exec(raw);
  if (!m) return raw || 'unknown';
  const [minMajor, minMinor] = minimum.split('.').map(Number) as [number, number];
  const major = Number(m[1]); const minor = Number(m[2]);
  return major > minMajor || (major === minMajor && minor >= minMinor) ? null : m[0];
}

type PregateField = { pregate: string; requires_remote?: string[] };
/** A pregate result file → the receipt's pregate field, verified current for this checkout's tree (shared by write and carry). */
function pregateFieldFor(repoRoot: string, file: string, head: string): { ok: true; field: PregateField } | { ok: false; errors: Array<{ code: string; message: string }> } {
  const read = readPregateFile(file);
  if (!read.file) return { ok: false, errors: read.errors.map(e => ({ code: e.code, message: `${e.message} at ${e.path}` })) };
  const v = verifyPregate(repoRoot, read.file);
  if (!v.ok) return { ok: false, errors: [{ code: v.code!, message: v.message ?? 'pregate is not current' }] };
  const remote = read.file.requires_remote ?? [];
  return { ok: true, field: { pregate: `${read.file.verdict ?? 'pass'} @${read.file.tree.slice(0, 12)} (${read.file.checks.length} checks, current for ${head.slice(0, 12)})`, requires_remote: remote.length ? remote.map(r => `${r.lane}: ${r.receipt}`) : undefined } };
}

/**
 * Generated outputs the carry may set aside as metadata: the paths the pregate
 * passed for HEAD proved (its regen check deleted each touched output and the
 * entry's command recreated it byte-identically), when that check ran
 * origin/<base>'s `.gstack/generated.json` at the commit this carry reads and the
 * path is an output of an entry with a `command` there. A proven name with glob
 * syntax is product too: the carry uses these paths as pathspec globs.
 */
function verifiedOutputs(repoRoot: string, base: string, pregateFile: string | undefined): string[] {
  if (!pregateFile) return [];
  const regen = readPregateFile(pregateFile).file?.checks.find(c => c.id === 'regen');
  if (!regen || regen.status !== 'pass' || !regen.proven?.length) return [];
  const load = loadRegistryFromBase(repoRoot, base);
  if (isRegistryUnavailable(load) || load.errors.length || regen.inputs?.registry !== load.source.label) return [];
  const owned = load.registry.entries.filter(e => e.command).flatMap(e => e.outputs);
  return regen.proven.filter(p => !/[*?[\]\\]/.test(p) && matchesAny(owned, p));
}

interface ProductRules { extra: { metadata: string[]; outputs: readonly string[] }; metadata: string[]; templates: readonly string[] }
function productRules(repoRoot: string, base: string, outputs: readonly string[]): ProductRules {
  const load = loadPolicyFromBase(repoRoot, base);
  const policy: ShipPolicy | null = isUnavailable(load) ? null : load.policy;
  const extra = { metadata: [...(policy?.stamp_files ?? []), ...(policy?.stamp_paths ?? []), ...(policy?.release_outputs ?? []), ...(policy?.changelog ? [policy.changelog] : [])], outputs };
  return { extra, metadata: [...CARRY_METADATA_GLOBS, ...extra.metadata, ...outputs], templates: policy?.stamp_patterns ?? [] };
}

/**
 * The product pathspec between two commits: every path but tests and release
 * metadata, where a metadata-listed path whose change from `from` to `to` is
 * not a stamp stays product (every glob that matches it leaves the exclusion).
 */
function productSpec(repoRoot: string, rules: ProductRules, from: string, to: string): { changed: Array<{ path: string; class: ReturnType<typeof classifyCarryPath> }>; product: string[]; tests: string[] } | undefined {
  const changedRaw = git(['diff', '--name-only', from, to], repoRoot);
  if (changedRaw === undefined) return undefined;
  const blobAt = (ref: string, p: string): string | null => { const r = spawnSync('git', ['show', `${ref}:${p}`], { cwd: repoRoot, encoding: 'utf8', timeout: 30_000, maxBuffer: 16 * 1024 * 1024 }); return r.status === 0 ? r.stdout : null; };
  const versionAt = (ref: string): string | null => {
    const file = blobAt(ref, 'VERSION');
    if (file !== null) return file.trim() || null;
    try { const v = JSON.parse(blobAt(ref, 'package.json') ?? 'null')?.version; return typeof v === 'string' ? v : null; } catch { return null; }
  };
  const oldVersion = versionAt(from);
  const newVersion = versionAt(to);
  const changed = changedRaw.split('\n').filter(Boolean).map(p => ({ path: p, class: classifyCarryPath(p, rules.extra, matchesAny(rules.metadata, p) && !matchesAny(rules.extra.outputs, p) ? { before: blobAt(from, p), after: blobAt(to, p), oldVersion, newVersion, templates: rules.templates } : undefined) }));
  const excludeGlobs = (globs: readonly string[]) => globs.map(g => `:(exclude,glob)${g}`);
  const demoted = changed.filter(c => c.class === 'product' && matchesAny(rules.metadata, c.path)).map(c => c.path);
  const metadataGlobs = rules.metadata.filter(g => !demoted.some(p => matchesAny([g], p)));
  return { changed, product: ['.', ...excludeGlobs(CARRY_TEST_GLOBS), ...excludeGlobs(metadataGlobs)], tests: [...CARRY_TEST_GLOBS.map(g => `:(glob)${g}`), ...excludeGlobs(metadataGlobs)] };
}

/** A commit's product patch-id against its merge base with the base ('' for no product diff), as write records it and a rewritten-history carry recomputes it. */
function productPatchAgainstBase(repoRoot: string, rules: ProductRules, baseRef: string, commit: string): string | { error: string } {
  const mergeBase = git(['merge-base', baseRef, commit], repoRoot);
  if (!mergeBase) return { error: `cannot resolve the merge base of ${baseRef} and ${commit.slice(0, 12)}` };
  const spec = productSpec(repoRoot, rules, mergeBase, commit);
  if (!spec) return { error: `git diff ${mergeBase.slice(0, 12)} ${commit.slice(0, 12)} failed` };
  return patchId(repoRoot, mergeBase, commit, spec.product);
}

/**
 * The receipt follows HEAD when the reviewed product is unchanged
 * (docs/unattended.md#the-terminal-line; harness lane E row 3). Four Captains
 * reran a full /ship on identical product code after a base merge or a
 * test-only fix; the carry compares the product diff against the base at the
 * receipt's head and at HEAD by patch-id, classifies every changed path, and
 * records the range-diff as evidence in the receipt it rewrites. After a rebase
 * or force-push it carries only onto a tree the receipt covers whose product
 * patch-id against the current base is the recorded one (planTreeCarry).
 */
function cmdCarry(rest: string[], json: boolean): number {
  const bodyFile = flag(rest, '--body');
  const pr = flag(rest, '--pr');
  if (pr !== undefined && !/^[1-9]\d*$/.test(pr)) { process.stderr.write(`gstack-ship-receipt carry: --pr must be a PR number, got ${JSON.stringify(pr.slice(0, 40))}\n`); return EXIT.usage; }
  if ((pr === undefined) === (bodyFile === undefined)) { process.stderr.write(`gstack-ship-receipt carry: pass --pr <n> or --body <file>, not both\n${HELP}\n`); return EXIT.usage; }
  const repoRoot = git(['rev-parse', '--show-toplevel']);
  if (!repoRoot) { process.stderr.write('gstack-ship-receipt carry: run it inside the git checkout whose head carries the receipt\n'); return EXIT.usage; }
  const head = (flag(rest, '--head') ?? git(['rev-parse', 'HEAD'], repoRoot))?.toLowerCase();
  if (!head || !/^[0-9a-f]{40,64}$/.test(head)) { process.stderr.write('gstack-ship-receipt carry: cannot resolve HEAD\n'); return EXIT.usage; }
  const refused = (code: 'QUEUE_RECEIPT_MISSING' | 'RECEIPT_CARRY_REFUSED' | 'RECEIPT_CARRY_PRODUCT_CHANGED' | 'RECEIPT_CARRY_TREE_MISMATCH' | 'RECEIPT_GIT_TOO_OLD' | 'RECEIPT_CARRY_PREGATE_STALE', message: string) => {
    process.stderr.write(resultLineWithDocs('gstack-ship-receipt carry', code, message) + '\n');
    process.stdout.write(json ? JSON.stringify({ skill: 'ship', status: 'refused', run: '-', code, message }) + '\n' : `CARRY: refused (${code})\nGSTACK_RESULT: skill=ship status=refused run=-\n`);
    return EXIT.refused;
  };
  const incomplete = (why: string) => {
    process.stderr.write(`gstack-ship-receipt carry: ${why}\n`);
    process.stdout.write(json ? JSON.stringify({ skill: 'ship', status: 'incomplete', run: '-', message: why }) + '\n' : 'GSTACK_RESULT: skill=ship status=incomplete run=-\n');
    return EXIT.fail;
  };
  const repo = flag(rest, '--repo');
  let body: string;
  let source: string;
  if (bodyFile) {
    if (!fs.existsSync(bodyFile)) return refused('QUEUE_RECEIPT_MISSING', `${bodyFile} does not exist`);
    body = fs.readFileSync(bodyFile, 'utf8');
    source = path.resolve(bodyFile);
  } else {
    const r = gh(['pr', 'view', pr!, ...(repo ? ['--repo', repo] : []), '--json', 'body,headRefOid']);
    if (!r.ok) return incomplete(`gh pr view failed: ${r.err}`);
    let pushed: unknown;
    try { const v = JSON.parse(r.out); body = v.body ?? ''; pushed = v.headRefOid; } catch { return incomplete('gh returned no JSON body'); }
    if (typeof pushed === 'string' && /^[0-9a-f]{12,64}$/i.test(pushed) && !pushed.toLowerCase().startsWith(head)) {
      return refused('RECEIPT_CARRY_REFUSED', `HEAD ${head.slice(0, 12)} is not PR #${pr}'s pushed head ${pushed.slice(0, 12)}; push first, then carry`);
    }
    source = `PR #${pr}${repo ? ` (${repo})` : ''}`;
  }
  const ex = extractReceipt(body);
  if (!ex.found) return refused('QUEUE_RECEIPT_MISSING', `${source} carries no ship receipt; run /ship`);
  if (!ex.receipt || ex.errors.length) return refused('QUEUE_RECEIPT_MISSING', `${source}'s ship receipt is invalid (${ex.errors[0]?.message ?? 'invalid'}); run /ship`);
  const receipt = ex.receipt;
  if (pr !== undefined && receipt.pr !== undefined && String(receipt.pr) !== pr) return refused('RECEIPT_CARRY_REFUSED', `the receipt names pr=${receipt.pr}, not this PR`);
  const from = receipt.head.toLowerCase();
  if (!/^[0-9a-f]{40,64}$/.test(from)) return refused('RECEIPT_CARRY_REFUSED', `the receipt's head ${receipt.head.slice(0, 12)} is not a full commit id`);
  if (from === head) {
    process.stderr.write(receiptSummaryLine(receipt) + '\n');
    process.stdout.write(json ? JSON.stringify({ skill: 'ship', status: 'current', head, carry: null }) + '\n' : `CARRY: current (the receipt already names ${head.slice(0, 12)})\n`);
    return EXIT.ok;
  }
  const oldGit = gitVersionBelow(repoRoot, CARRY_MIN_GIT);
  if (oldGit) return refused('RECEIPT_GIT_TOO_OLD', `git ${oldGit} cannot run patch-id --verbatim; the carry needs git ${CARRY_MIN_GIT} or later`);
  // The carry binds HEAD alone: pending edits are not in the commits it compares, and a parent that stops at CARRY: carried would report them shipped.
  const status = spawnSync('git', ['status', '--porcelain', '--untracked-files=all'], { cwd: repoRoot, encoding: 'utf8', timeout: 30_000, maxBuffer: 16 * 1024 * 1024 });
  if (status.status !== 0) return refused('RECEIPT_CARRY_REFUSED', 'git status failed; the carry needs a readable working tree');
  const dirty = status.stdout.split('\n').filter(Boolean).map(l => l.slice(3).replace(/^.* -> /, ''));
  if (dirty.length) return refused('RECEIPT_CARRY_REFUSED', `the working tree has uncommitted changes (${dirty.slice(0, 5).join(', ')}${dirty.length > 5 ? ` +${dirty.length - 5} more` : ''}); commit them and carry at the new head, or run /ship`);
  const fromKnown = git(['cat-file', '-e', `${from}^{commit}`], repoRoot) !== undefined;
  const ancestor = fromKnown && spawnSync('git', ['merge-base', '--is-ancestor', from, head], { cwd: repoRoot, encoding: 'utf8', timeout: 30_000 }).status === 0;
  const fromTree = fromKnown ? git(['rev-parse', `${from}^{tree}`], repoRoot) : undefined;
  const covered = [...(receipt.head_tree ? [receipt.head_tree] : fromTree ? [fromTree] : []), ...(receipt.carry?.trees ?? [])];
  if (!ancestor && !covered.length) return refused('RECEIPT_CARRY_REFUSED', `the receipt's head ${from.slice(0, 12)} is not an ancestor of HEAD ${head.slice(0, 12)} (rebased or force-pushed), and the receipt records no tree to compare; merge the base in next time, and run /ship now`);
  const base = flag(rest, '--base') ?? receipt.base ?? resolveBaseBranch(repoRoot);
  const baseRef = `origin/${base.replace(/^origin\//, '')}`;
  const headBase = git(['merge-base', baseRef, head], repoRoot);
  if (!headBase) return refused('RECEIPT_CARRY_REFUSED', `cannot resolve the merge base of ${baseRef} (fetch it first)`);
  const rules = productRules(repoRoot, base, verifiedOutputs(repoRoot, base, flag(rest, '--pregate')));
  const headTree = git(['rev-parse', `${head}^{tree}`], repoRoot);
  if (!headTree) return refused('RECEIPT_CARRY_REFUSED', `git could not read the tree of HEAD ${head.slice(0, 12)}`);
  const headPatch = productPatchAgainstBase(repoRoot, rules, baseRef, head);
  if (typeof headPatch !== 'string') return refused('RECEIPT_CARRY_REFUSED', `git could not compute HEAD's product patch-id: ${headPatch.error}`);
  const reviewedBase = receipt.base.replace(/^origin\//, '');
  const retarget = reviewedBase !== base.replace(/^origin\//, '');
  let plan: ReturnType<typeof planCarry>;
  if (!ancestor) {
    // Rewritten history: the receipt follows only onto a tree it already covers, with the product diff it recorded.
    const recorded = receipt.product_patch_id !== undefined ? (receipt.product_patch_id === 'none' ? '' : receipt.product_patch_id) : fromKnown ? productPatchAgainstBase(repoRoot, rules, baseRef, from) : { error: 'the receipt records no product patch-id and its head is not in this clone' };
    if (typeof recorded !== 'string') return refused('RECEIPT_CARRY_REFUSED', `the reviewed product patch-id is unavailable: ${recorded.error}; run /ship on ${head.slice(0, 12)}`);
    plan = planTreeCarry({ from, head, headTree, coveredTrees: covered, productPatchId: { recorded, head: headPatch } });
  } else {
    const fromBase = git(['merge-base', baseRef, from], repoRoot);
    if (!fromBase) return refused('RECEIPT_CARRY_REFUSED', `cannot resolve the merge base of ${baseRef} (fetch it first)`);
    const spec = productSpec(repoRoot, rules, from, head);
    if (!spec) return refused('RECEIPT_CARRY_REFUSED', `git diff ${from.slice(0, 12)} ${head.slice(0, 12)} failed`);
    const { changed } = spec;
    const productFrom = patchId(repoRoot, fromBase, from, spec.product);
    const productHead = patchId(repoRoot, headBase, head, spec.product);
    const asId = (r: string | { error: string }) => (typeof r === 'string' ? r : '');
    const testFrom = asId(patchId(repoRoot, fromBase, from, spec.tests));
    const testHead = asId(patchId(repoRoot, headBase, head, spec.tests));
    for (const r of [productFrom, productHead]) if (typeof r !== 'string') return refused('RECEIPT_CARRY_REFUSED', `git could not compute the product patch-id at one of the heads: ${r.error}`);
    // A stacked child whose parent landed on the base (#3570): the receipt reviewed the child's own range against the
    // parent branch, and the PR now targets the base. That reviewed range (the recorded product patch-id, else the one
    // against origin/<receipt base> when it still resolves) must be HEAD's whole product diff against the base, computed
    // the way write records it (headPatch): the parent fully landed and the child is unchanged. Anything else fails closed.
    let reviewed = productFrom;
    if (retarget) {
      const parentRef = `origin/${reviewedBase}`;
      const recorded = receipt.product_patch_id !== undefined ? (receipt.product_patch_id === 'none' ? '' : receipt.product_patch_id)
        : git(['rev-parse', '--verify', '--quiet', `${parentRef}^{commit}`], repoRoot) ? productPatchAgainstBase(repoRoot, rules, parentRef, from) : { error: `the receipt records no product patch-id and ${parentRef} no longer resolves` };
      if (typeof recorded !== 'string') return refused('RECEIPT_CARRY_REFUSED', `the receipt was reviewed against ${reviewedBase}, not ${base}, and its reviewed product diff is unavailable: ${recorded.error}; run /ship on ${head.slice(0, 12)}`);
      reviewed = recorded;
    }
    const current = retarget ? headPatch : productHead;
    const changedProduct: string[] = [];
    if (retarget && reviewed !== current) changedProduct.push(`HEAD's product diff against ${base} is not the one reviewed against ${reviewedBase} (the parent has not fully landed on ${base}, or the branch changed since)`);
    else if (productFrom !== productHead && !retarget) {
      // planCarry names at most CARRY_NAMED_PATHS differing paths, so the per-path comparison (two patch-ids each) stops there,
      // and it walks only the paths the branch itself touched against the base at either head: a base merge brings in every
      // path the base changed, none of which can differ between the two base diffs.
      const touched = new Set([...(git(['diff', '--name-only', fromBase, from], repoRoot) ?? '').split('\n'), ...(git(['diff', '--name-only', headBase, head], repoRoot) ?? '').split('\n')].filter(Boolean));
      for (const p of [...touched].sort()) {
        if (changedProduct.length >= CARRY_NAMED_PATHS) break;
        const cls = changed.find(c => c.path === p)?.class ?? classifyCarryPath(p, rules.extra);
        if (cls !== 'product') continue;
        if (asId(patchId(repoRoot, fromBase, from, [p])) !== asId(patchId(repoRoot, headBase, head, [p]))) changedProduct.push(p);
      }
      if (!changedProduct.length) changedProduct.push('(a product path outside the branch\'s touched files; compare the two base diffs)');
    }
    const mergeCommits = (git(['rev-list', '--merges', '--count', `${from}..${head}`], repoRoot) ?? '0').trim();
    // Evidence for the record, never the decision: a slow range-diff is reported unavailable rather than waited for.
    const rangeRaw = spawnSync('git', ['range-diff', '--no-color', `${fromBase}..${from}`, `${headBase}..${head}`], { cwd: repoRoot, encoding: 'utf8', timeout: 15_000, maxBuffer: 64 * 1024 * 1024 });
    const rangeDiff = rangeRaw.status === 0 ? (rangeRaw.stdout.trim().split('\n').slice(0, 20).join('\n') || '(empty: identical ranges)') : `unavailable: ${(rangeRaw.stderr ?? '').trim().split('\n')[0] || (rangeRaw.signal ? `range-diff killed by ${rangeRaw.signal} after 15 s` : 'range-diff failed')}`;
    plan = planCarry({ from, head, changed, productPatchId: { from: reviewed as string, head: current as string }, testPatchId: { from: testFrom, head: testHead }, changedProduct, mergeCommits: Number(mergeCommits) || 0, rangeDiff, ...(retarget ? { retargetedFrom: reviewedBase } : {}) });
  }
  if (!plan.ok) return refused(plan.code, plan.message);
  // Eligibility is not publication: a receipt that recorded a pregate is rebound only with a pregate current for HEAD,
  // so a carried receipt never claims the old tree's checks (docs/ship-policy.md#receipt-carry).
  const pregateFile = flag(rest, '--pregate');
  let pregateField: PregateField | undefined;
  if (pregateFile) {
    const local = git(['rev-parse', 'HEAD'], repoRoot)?.trim();
    if (local !== head) return refused('RECEIPT_CARRY_PREGATE_STALE', `--pregate verifies this checkout's tree, but the checkout is at ${local?.slice(0, 12) ?? 'no commit'}, not the carried head ${head.slice(0, 12)}; check out ${head.slice(0, 12)} and run gstack-pregate there`);
    const read = pregateFieldFor(repoRoot, pregateFile, head);
    if (!read.ok) return refused('RECEIPT_CARRY_PREGATE_STALE', `--pregate ${pregateFile}: ${read.errors[0]?.code ?? 'invalid'} ${read.errors[0]?.message ?? ''}`.trim());
    pregateField = read.field;
  } else if (receipt.pregate && !rest.includes('--dry-run')) {
    return refused('RECEIPT_CARRY_PREGATE_STALE', `the receipt records a pregate for ${receipt.head.slice(0, 12)}; run gstack-pregate at HEAD ${head.slice(0, 12)} and pass --pregate <pregate.json>`);
  }
  let depthField: Partial<ShipReceipt> = {};
  const isAncestor = (commit: string) => !ancestor || spawnSync('git', ['merge-base', '--is-ancestor', commit, head], { cwd: repoRoot, timeout: 30_000 }).status === 0;
  const problems = exceptionProblems(body, receipt, isAncestor);
  if (problems.length) return refused('RECEIPT_CARRY_REFUSED', `the receipt's owner exception does not stand: ${problems.join('; ')}; run /ship on ${head.slice(0, 12)}`);
  if (receipt.review_depth || receipt.gstack_version) {
    if (!receipt.review_depth) return refused('RECEIPT_CARRY_REFUSED', `the receipt records gstack_version but no review_depth, so the queue would refuse it; run /ship on ${head.slice(0, 12)}`);
    const checkedOut = git(['rev-parse', 'HEAD'], repoRoot)?.toLowerCase();
    if (checkedOut !== head) return refused('RECEIPT_CARRY_REFUSED', `--head ${head.slice(0, 12)} is not the checked-out HEAD ${(checkedOut ?? 'none').slice(0, 12)}; the gate scan reads the checkout, so check out ${head.slice(0, 12)} and carry there`);
    const now = receiptDepthAtHead(repoRoot, base, path.dirname(Bun.fileURLToPath(import.meta.url)), head);
    if (depthBelow(receipt.review_depth.depth, now.depth)) return refused('RECEIPT_CARRY_REFUSED', `HEAD ${head.slice(0, 12)} needs ${now.depth} review depth (${now.reasons.join(', ')}), above the receipt's ${receipt.review_depth.depth}; run /ship on ${head.slice(0, 12)}`);
    depthField = { review_depth: { ...now, depth: deeper(receipt.review_depth.depth, now.depth) } };
  }
  // The rebound product_patch_id is HEAD's diff against the carry's base, so a retargeted receipt names that base from now on.
  const rebound = { ...receipt, ...(retarget ? { base: base.replace(/^origin\//, '') } : {}), ...(pregateField ?? {}), ...depthField };
  const carried = carryReceipt(rebound, head, plan.carry, { tree: headTree, fromTree, productPatchId: headPatch });
  const errors = validateReceipt(carried);
  if (errors.length) return refused('RECEIPT_CARRY_REFUSED', `the carried receipt does not validate: ${errors[0]!.message} at ${errors[0]!.path}`);
  const newBody = placeReceiptFirst(body, carried);
  const line = receiptSummaryLine(carried);
  if (rest.includes('--dry-run')) {
    process.stderr.write(line + '\n');
    process.stdout.write(json ? JSON.stringify({ skill: 'ship', status: 'dry-run', head, carry: plan.carry }) + '\n' : `CARRY: would carry from ${from.slice(0, 12)} to ${head.slice(0, 12)} (${plan.carry.reason}); nothing written\n`);
    return EXIT.ok;
  }
  if (bodyFile) fs.writeFileSync(bodyFile, newBody);
  else {
    const tmp = path.join(fs.mkdtempSync(path.join(process.env.TMPDIR ?? '/tmp', 'gstack-carry-')), 'body.md');
    fs.writeFileSync(tmp, newBody, { mode: 0o600 });
    const edit = gh(['pr', 'edit', pr!, ...(repo ? ['--repo', repo] : []), '--body-file', tmp]);
    fs.rmSync(path.dirname(tmp), { recursive: true, force: true });
    if (!edit.ok) return incomplete(`gh pr edit failed: ${edit.err}; the receipt was not carried`);
  }
  process.stdout.write(`CARRY: carried from ${from.slice(0, 12)} to ${head.slice(0, 12)} (${plan.carry.reason})\n`);
  return writeRunRecord({ receipt: carried, head, pr, source, repoRoot, out: flag(rest, '--out'), json, line, incomplete, extra: { carried_from: carried.carry!.from, carry_reason: carried.carry!.reason } });
}

function sinceDate(repo: string, since: string): string | undefined {
  if (/^\d{4}-\d{2}-\d{2}/.test(since)) return since.slice(0, 10);
  const local = git(['log', '-1', '--format=%cI', since]);
  if (local) return local.slice(0, 10);
  const r = gh(['api', `repos/${repo}/commits/${since}`, '--jq', '.commit.committer.date']);
  return r.ok && r.out.trim() ? r.out.trim().slice(0, 10) : undefined;
}

function cmdCensus(rest: string[], json: boolean): number {
  const repo = flag(rest, '--repo');
  const since = flag(rest, '--since');
  if (!repo || !since) { process.stderr.write(`gstack-ship-receipt census: --repo <owner/repo> and --since <tag|date> are required\n${HELP}\n`); return EXIT.usage; }
  const date = sinceDate(repo, since);
  if (!date) { process.stderr.write(`gstack-ship-receipt census: cannot resolve --since ${since} to a date (not a local tag, and gh could not read it)\n`); return EXIT.fail; }
  const limit = flag(rest, '--limit') ?? '500';
  const r = gh(['pr', 'list', '--repo', repo, '--state', 'merged', '--search', `merged:>=${date}`, '--limit', limit, '--json', 'number,body,mergedAt,title']);
  if (!r.ok) { process.stderr.write(`gstack-ship-receipt census: gh pr list failed: ${r.err}\n`); return EXIT.fail; }
  let prs: CensusPr[];
  try { prs = JSON.parse(r.out); } catch { process.stderr.write('gstack-ship-receipt census: gh returned no JSON\n'); return EXIT.fail; }
  const cohortFile = flag(rest, '--cohort');
  const cohort = cohortFile ? fs.readFileSync(cohortFile, 'utf8').split('\n').map(l => l.trim()).filter(l => l && !l.startsWith('#')) : null;
  const census = computeCensus(repo, date, prs, cohort);
  process.stdout.write(json ? JSON.stringify(census) + '\n' : renderCensus(census));
  return EXIT.ok;
}

/**
 * /ship Step 14.5's doc-cap check: every `docs.caps` entry of the reviewed
 * policy (origin/<base>'s .gstack/ship-policy.json, like every other policy
 * read here; the branch cannot raise its own cap) against the working tree,
 * one DOCS_CAP: line each; any `over` (an absent file counts) exits 1 so the
 * audit blocks before the verification gate. `--policy <file>` reads that
 * file instead, for a repository bootstrapping its policy.
 */
function cmdDocsCaps(rest: string[], json: boolean): number {
  const repoRoot = git(['rev-parse', '--show-toplevel']) ?? process.cwd();
  const policyFile = flag(rest, '--policy');
  let caps: NonNullable<ShipPolicy['docs']>['caps'] = [];
  let source: string;
  if (policyFile !== undefined) {
    if (!fs.existsSync(policyFile)) { process.stderr.write(`gstack-ship-receipt docs-caps: ${policyFile} does not exist\n`); return EXIT.usage; }
    let raw: unknown;
    try { raw = JSON.parse(fs.readFileSync(policyFile, 'utf8')); } catch (e: any) { process.stderr.write(`gstack-ship-receipt docs-caps: ${policyFile} is not JSON: ${e.message}\n`); return EXIT.fail; }
    const errors = validatePolicy(raw).filter(e => e.path === 'docs' || e.path.startsWith('docs.'));
    if (errors.length) { for (const e of errors) process.stderr.write(resultLine('gstack-ship-receipt docs-caps', e.code, `${e.message} at ${e.path}`) + '\n'); return EXIT.fail; }
    caps = (raw as Partial<ShipPolicy>).docs?.caps ?? [];
    source = policyFile;
  } else {
    const base = flag(rest, '--base') ?? resolveBaseBranch(repoRoot);
    const load = loadPolicyFromBase(repoRoot, base);
    if (isUnavailable(load)) { process.stderr.write(policyUnavailableLine('gstack-ship-receipt docs-caps', base, `${load.detail}; pass --policy <file> to check caps without the base`) + '\n'); return EXIT.refused; }
    const errors = load.errors.filter(e => e.path === 'docs' || e.path.startsWith('docs.'));
    if (errors.length) { for (const e of errors) process.stderr.write(resultLine('gstack-ship-receipt docs-caps', e.code, `${e.message} at ${e.path} (${load.source.label})`) + '\n'); return EXIT.fail; }
    caps = load.policy.docs?.caps ?? [];
    source = load.source.label;
  }
  const results = checkDocsCaps(caps, rel => { try { const st = fs.statSync(path.join(repoRoot, rel)); return st.isFile() ? st.size : null; } catch { return null; } });
  const over = results.filter(r => r.verdict === 'over');
  const lines = results.length ? results.map(docsCapLine) : ['DOCS_CAP: none declared'];
  process.stdout.write(json ? JSON.stringify({ policy: source, caps: results, over: over.length }) + '\n' : lines.join('\n') + '\n');
  if (!over.length) return EXIT.ok;
  process.stderr.write(resultLineWithDocs('gstack-ship-receipt docs-caps', 'DOCS_AUDIT_BLOCKED', `${over.length} of ${results.length} documentation cap${results.length === 1 ? '' : 's'} over: ${over.map(r => r.path).join(', ')}`) + '\n');
  return EXIT.fail;
}

function main(argv: string[]): number {
  const [cmd, ...rest] = argv;
  const json = rest.includes('--json');
  if (!cmd || cmd === '--help' || cmd === '-h' || cmd === 'help') { process.stdout.write(HELP + '\n'); return cmd ? EXIT.ok : EXIT.usage; }
  if (cmd === 'write') return cmdWrite(rest, json);
  if (cmd === 'read') return cmdRead(rest, json);
  if (cmd === 'result') return cmdResult(rest, json);
  if (cmd === 'census') return cmdCensus(rest, json);
  if (cmd === 'carry') return cmdCarry(rest, json);
  if (cmd === 'docs-caps') return cmdDocsCaps(rest, json);
  process.stderr.write(`gstack-ship-receipt: unknown command ${cmd}\n${HELP}\n`);
  return EXIT.usage;
}

process.exitCode = main(process.argv.slice(2));