@patronage/software-factory 1.0.0-alpha.31 → 1.0.0-alpha.32

package/dist/index.js

@@ -4,7 +4,8 @@ import path from "node:path";
 import crypto, { createHash, randomBytes, randomUUID } from "node:crypto";
 import { z } from "zod";
 import { execFileSync, spawnSync } from "node:child_process";
-import { appendFileSync, constants, cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import * as nodeFs from "node:fs";
+import { appendFileSync, closeSync, constants, cpSync, existsSync, fsyncSync, mkdirSync, mkdtempSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { Buffer as Buffer$1 } from "node:buffer";
 import picomatch from "picomatch";
 import { link, lstat, mkdir, open, readFile, readdir, realpath, rename, stat, unlink } from "node:fs/promises";
@@ -19,7 +20,7 @@ import http from "node:http";
 import { pathToFileURL } from "node:url";
 //#region package.json
 var name = "@patronage/software-factory";
-var version = "1.0.0-alpha.31";
+var version = "1.0.0-alpha.32";
 //#endregion
 //#region src/cli-entry.ts
 /**
@@ -1648,20 +1649,854 @@ const authorizeDemandWaiver = ({ authenticatedLogin, session }) => {
 	} };
 };
 //#endregion
+//#region src/sha256-hex.ts
+const ROUND_CONSTANTS = new Uint32Array([
+	1116352408,
+	1899447441,
+	3049323471,
+	3921009573,
+	961987163,
+	1508970993,
+	2453635748,
+	2870763221,
+	3624381080,
+	310598401,
+	607225278,
+	1426881987,
+	1925078388,
+	2162078206,
+	2614888103,
+	3248222580,
+	3835390401,
+	4022224774,
+	264347078,
+	604807628,
+	770255983,
+	1249150122,
+	1555081692,
+	1996064986,
+	2554220882,
+	2821834349,
+	2952996808,
+	3210313671,
+	3336571891,
+	3584528711,
+	113926993,
+	338241895,
+	666307205,
+	773529912,
+	1294757372,
+	1396182291,
+	1695183700,
+	1986661051,
+	2177026350,
+	2456956037,
+	2730485921,
+	2820302411,
+	3259730800,
+	3345764771,
+	3516065817,
+	3600352804,
+	4094571909,
+	275423344,
+	430227734,
+	506948616,
+	659060556,
+	883997877,
+	958139571,
+	1322822218,
+	1537002063,
+	1747873779,
+	1955562222,
+	2024104815,
+	2227730452,
+	2361852424,
+	2428436474,
+	2756734187,
+	3204031479,
+	3329325298
+]);
+const INITIAL_STATE = new Uint32Array([
+	1779033703,
+	3144134277,
+	1013904242,
+	2773480762,
+	1359893119,
+	2600822924,
+	528734635,
+	1541459225
+]);
+const BLOCK_BYTES = 64;
+const LENGTH_FIELD_BYTES = 8;
+const WORD_BITS = 32;
+const rotateRight = (value, bits) => (value >>> bits | value << WORD_BITS - bits) >>> 0;
+/** Message bytes plus the FIPS 180-4 padding and 64-bit length suffix. */
+const padMessage = (message) => {
+	const paddedLength = Math.ceil((message.length + 1 + LENGTH_FIELD_BYTES) / BLOCK_BYTES) * BLOCK_BYTES;
+	const padded = new Uint8Array(paddedLength);
+	padded.set(message);
+	padded[message.length] = 128;
+	const bitLength = BigInt(message.length) * 8n;
+	new DataView(padded.buffer).setBigUint64(paddedLength - LENGTH_FIELD_BYTES, bitLength);
+	return padded;
+};
+const ROUNDS = 64;
+const SCHEDULE_SEED_WORDS = 16;
+const STATE_WORDS = 8;
+const wordAt = (words, index) => words[index];
+/** One 64-byte block folded into the running state, in place. */
+const compress = (state, view, offset) => {
+	const schedule = new Uint32Array(ROUNDS);
+	for (let index = 0; index < SCHEDULE_SEED_WORDS; index += 1) schedule[index] = view.getUint32(offset + index * 4);
+	for (let index = SCHEDULE_SEED_WORDS; index < ROUNDS; index += 1) {
+		const previous = wordAt(schedule, index - 15);
+		const recent = wordAt(schedule, index - 2);
+		const sigma0 = rotateRight(previous, 7) ^ rotateRight(previous, 18) ^ previous >>> 3;
+		const sigma1 = rotateRight(recent, 17) ^ rotateRight(recent, 19) ^ recent >>> 10;
+		schedule[index] = wordAt(schedule, index - 16) + sigma0 + wordAt(schedule, index - 7) + sigma1 >>> 0;
+	}
+	const working = new Uint32Array(state);
+	for (let index = 0; index < ROUNDS; index += 1) {
+		const a = wordAt(working, 0);
+		const b = wordAt(working, 1);
+		const c = wordAt(working, 2);
+		const d = wordAt(working, 3);
+		const e = wordAt(working, 4);
+		const f = wordAt(working, 5);
+		const g = wordAt(working, 6);
+		const h = wordAt(working, 7);
+		const sum1 = rotateRight(e, 6) ^ rotateRight(e, 11) ^ rotateRight(e, 25);
+		const choose = e & f ^ ~e & g;
+		const temp1 = h + sum1 + choose + wordAt(ROUND_CONSTANTS, index) + wordAt(schedule, index) >>> 0;
+		const sum0 = rotateRight(a, 2) ^ rotateRight(a, 13) ^ rotateRight(a, 22);
+		const majority = a & b ^ a & c ^ b & c;
+		working[7] = g;
+		working[6] = f;
+		working[5] = e;
+		working[4] = d + temp1 >>> 0;
+		working[3] = c;
+		working[2] = b;
+		working[1] = a;
+		working[0] = temp1 + (sum0 + majority >>> 0) >>> 0;
+	}
+	for (let index = 0; index < STATE_WORDS; index += 1) state[index] = wordAt(state, index) + wordAt(working, index) >>> 0;
+};
+const toHex = (state) => {
+	let hex = "";
+	for (const word of state) hex += word.toString(16).padStart(8, "0");
+	return hex;
+};
+/** The lowercase hex SHA-256 digest of a UTF-8 string. */
+const sha256Hex = (input) => {
+	const padded = padMessage(new TextEncoder().encode(input));
+	const view = new DataView(padded.buffer);
+	const state = new Uint32Array(INITIAL_STATE);
+	for (let offset = 0; offset < padded.length; offset += BLOCK_BYTES) compress(state, view, offset);
+	return toHex(state);
+};
+//#endregion
+//#region src/review-finding-identity.ts
+const normalizeCitedSpan = (text) => text.split(/\r?\n/u).map((line) => line.trim().replaceAll(/\s+/gu, " ")).filter((line) => line.length > 0).join("\n");
+const PRESCRIBED_ACTION_STOPWORDS = new Set([
+	"a",
+	"an",
+	"the",
+	"to",
+	"of",
+	"in",
+	"on",
+	"and",
+	"or",
+	"is",
+	"are",
+	"be",
+	"this",
+	"that",
+	"it",
+	"for",
+	"with",
+	"as",
+	"by",
+	"from",
+	"at",
+	"into",
+	"should",
+	"must",
+	"will",
+	"would",
+	"can",
+	"could",
+	"not",
+	"but",
+	"so",
+	"if",
+	"then",
+	"than",
+	"when",
+	"which",
+	"who",
+	"whom",
+	"its",
+	"their",
+	"there",
+	"here",
+	"also",
+	"use",
+	"using",
+	"instead",
+	"rather",
+	"over",
+	"up",
+	"out",
+	"have",
+	"has",
+	"had",
+	"been"
+]);
+const tokenizePrescribedAction = (text) => {
+	const words = text.toLowerCase().replaceAll(/[^a-z0-9\s]/gu, " ").split(/\s+/u).filter((word) => word.length > 0 && !PRESCRIBED_ACTION_STOPWORDS.has(word));
+	return [...new Set(words)].toSorted();
+};
+const normalizeTitle = (title) => title.trim().toLowerCase().replaceAll(/\s+/gu, " ");
+const normalizeFile = (file) => file.trim();
+const findingKey = (finding) => {
+	const path = finding.file ?? "";
+	const normalizedSpan = normalizeCitedSpan(finding.citedSpan ?? "");
+	const actionTokens = tokenizePrescribedAction(finding.prescribedAction ?? "");
+	const legacyDiscriminator = normalizedSpan.length > 0 || actionTokens.length > 0 ? "" : normalizeTitle(finding.title ?? "");
+	return sha256Hex(`${path}\0${sha256Hex(normalizedSpan)}\0${actionTokens.join(" ")}\0${legacyDiscriminator}`);
+};
+const declarationMatchesEntry = (entry, target) => normalizeTitle(entry.title) === normalizeTitle(target.title) && (target.file === void 0 || entry.file !== void 0 && normalizeFile(entry.file) === normalizeFile(target.file));
+//#endregion
+//#region src/review-ladder-policy.ts
+const REVIEW_SEVERITIES = [
+	"critical",
+	"high",
+	"medium",
+	"low",
+	"unknown"
+];
+const REVIEW_CATEGORIES = [
+	"correctness",
+	"safety",
+	"coordination",
+	"maintainability",
+	"unknown"
+];
+const resolveReviewFindingSeverity = (priority) => {
+	const normalized = priority?.trim().toLowerCase();
+	if (!normalized) return "unknown";
+	if ([
+		"p0",
+		"critical",
+		"crit",
+		"blocker",
+		"blocking"
+	].includes(normalized)) return "critical";
+	if ([
+		"p1",
+		"high",
+		"severe",
+		"major"
+	].includes(normalized)) return "high";
+	if ([
+		"p2",
+		"medium",
+		"moderate",
+		"normal",
+		"refinement"
+	].includes(normalized)) return "medium";
+	if ([
+		"p3",
+		"p4",
+		"low",
+		"minor",
+		"info",
+		"informational"
+	].includes(normalized)) return "low";
+	return "unknown";
+};
+const countFindingsBySeverity = (findings) => {
+	const counts = {
+		critical: 0,
+		high: 0,
+		low: 0,
+		medium: 0,
+		unknown: 0
+	};
+	for (const finding of findings) counts[resolveReviewFindingSeverity(finding.priority)] += 1;
+	return counts;
+};
+const resolveReviewFindingCategory = (category) => REVIEW_CATEGORIES.find((value) => value === category?.trim().toLowerCase()) ?? "unknown";
+const resolveFindingBlocking = (finding, disposition = "open") => {
+	if (disposition !== "open") return false;
+	if (resolveReviewFindingCategory(finding.category) !== "maintainability") return true;
+	if (finding.blockingAfterCap !== void 0) return finding.blockingAfterCap;
+	const severity = resolveReviewFindingSeverity(finding.priority);
+	return severity === "critical" || severity === "high" || severity === "unknown";
+};
+const FACTORY_REVIEW_CYCLE_CAP = 5;
+const resolveReviewLadderPolicy = () => ({ gate: { cap: FACTORY_REVIEW_CYCLE_CAP } });
+//#endregion
+//#region src/review-ladder-ledger.ts
+const OCCURRENCE_ADDRESS_PATTERN = /^c[1-9][0-9]*f[1-9][0-9]*$/u;
+const occurrenceAddress = (cycle, finding) => `c${cycle}f${finding}`;
+/** The 1-based recording position an address names. */
+const cycleOfAddress = (address) => Number(/^c(?<cycle>\d+)f/u.exec(address)?.groups?.cycle);
+const POLICY_DECLARATION_RULES = [
+	"cycle-2-severity-floor",
+	"identity-repeat",
+	"schema-2-import"
+];
+const definedAttributes = (finding) => Object.fromEntries([
+	"blockingAfterCap",
+	"category",
+	"citedSpan",
+	"file",
+	"prescribedAction",
+	"priority"
+].flatMap((attribute) => finding[attribute] === void 0 ? [] : [[attribute, finding[attribute]]]));
+const toLadderFindingReport = (finding) => ({
+	...definedAttributes(finding),
+	...finding.supersedes ? { supersedes: finding.supersedes } : {},
+	title: finding.title
+});
+const AUTHORITY_RANK = {
+	operator: 3,
+	policy: 1,
+	reviewer: 2
+};
+const outranked = (occurrence, declaration) => occurrence.authority !== void 0 && AUTHORITY_RANK[occurrence.authority] > AUTHORITY_RANK[declaration.authority];
+const IDENTITY_REPEAT_DISPOSITION = {
+	"fixed-in-thread": void 0,
+	"follow-up-filed": "stale-repeat",
+	open: void 0,
+	"policy-accepted": "stale-repeat",
+	"stale-repeat": "stale-repeat",
+	waived: "stale-repeat"
+};
+const projectedGroupDisposition = (members) => members.some((member) => member.disposition === "open") ? "open" : members.at(-1)?.disposition ?? "open";
+const invalid = (message) => {
+	throw new TypeError(`Invalid ladder history: ${message}`);
+};
+const entryFor = (members, reopenedCount) => {
+	const [root] = members;
+	const latest = members.at(-1);
+	if (!root || !latest) return invalid("a finding group has no members.");
+	const disposition = projectedGroupDisposition(members);
+	const settled = members.findLast((member) => member.disposition !== "stale-repeat" && member.disposition !== "open");
+	const referenced = disposition === "open" ? void 0 : settled ?? latest;
+	return {
+		...definedAttributes(latest.finding),
+		address: root.address,
+		disposition,
+		firstFlagged: root.cycle,
+		flagCount: members.length,
+		lastFlagged: latest.cycle,
+		occurrences: [...members],
+		...disposition === "stale-repeat" && settled ? { priorDisposition: settled.disposition } : {},
+		...referenced === void 0 ? {} : { reference: referenced.reference ?? referenced.rule },
+		reopenedCount,
+		staleRepeatCount: members.filter((member) => member.disposition === "stale-repeat").length,
+		title: root.finding.title.trim()
+	};
+};
+const recordOccurrences = (cycle, cycleIndex, ref, occurrences, recordedIn, groups, reopened) => {
+	const { recording } = cycle;
+	if (!recording) return invalid(`cycle ${cycleIndex + 1} carries no recording; the ledger reads recorded occurrences and declarations only.`);
+	if (recording.occurrences.length !== cycle.findings.length) return invalid(`cycle ${cycleIndex + 1} records ${recording.occurrences.length} occurrence(s) for ${cycle.findings.length} finding(s).`);
+	for (const [findingIndex, record] of recording.occurrences.entries()) {
+		const address = occurrenceAddress(cycleIndex + 1, findingIndex + 1);
+		const finding = cycle.findings[findingIndex];
+		if (record.address !== address || finding === void 0) return invalid(`cycle ${cycleIndex + 1} finding ${findingIndex + 1} is recorded at ${record.address}, not ${address}.`);
+		let root = address;
+		if (record.repeatOf !== void 0) {
+			const target = occurrences.get(record.repeatOf);
+			if (!target || (recordedIn.get(record.repeatOf) ?? cycleIndex) >= cycleIndex) return invalid(`${address} repeats ${record.repeatOf}, which names no occurrence recorded in an earlier cycle.`);
+			({root} = target);
+		}
+		const members = groups.get(root) ?? [];
+		if (members.length > 0 && projectedGroupDisposition(members) === "fixed-in-thread") reopened.set(root, (reopened.get(root) ?? 0) + 1);
+		const occurrence = {
+			address,
+			cycle: ref,
+			disposition: "open",
+			finding,
+			historical: cycle.historical === true,
+			root
+		};
+		occurrences.set(address, occurrence);
+		recordedIn.set(address, cycleIndex);
+		groups.set(root, [...members, occurrence]);
+	}
+};
+const applyDeclaration = (declaration, cycleIndex, occurrences) => {
+	const target = occurrences.get(declaration.target);
+	if (!target) return invalid(`cycle ${cycleIndex + 1} declares ${declaration.disposition} on ${declaration.target}, which names no occurrence recorded at or before that cycle.`);
+	if (outranked(target, declaration)) return;
+	target.disposition = declaration.disposition;
+	target.authority = declaration.authority;
+	if (declaration.authority === "policy") {
+		target.rule = declaration.rule;
+		delete target.reference;
+	} else {
+		delete target.rule;
+		if (declaration.reference === void 0) delete target.reference;
+		else target.reference = declaration.reference;
+	}
+};
+const foldLedger = (cycles, refs) => {
+	const occurrences = /* @__PURE__ */ new Map();
+	const recordedIn = /* @__PURE__ */ new Map();
+	const groups = /* @__PURE__ */ new Map();
+	const reopened = /* @__PURE__ */ new Map();
+	for (const [cycleIndex, cycle] of cycles.entries()) {
+		const ref = refs[cycleIndex];
+		if (!ref) return invalid(`cycle ${cycleIndex + 1} has no ladder position.`);
+		const declarations = cycle.recording?.declarations ?? [];
+		for (const declaration of declarations) if (cycleOfAddress(declaration.target) <= cycleIndex) applyDeclaration(declaration, cycleIndex, occurrences);
+		recordOccurrences(cycle, cycleIndex, ref, occurrences, recordedIn, groups, reopened);
+		for (const declaration of declarations) if (cycleOfAddress(declaration.target) > cycleIndex) applyDeclaration(declaration, cycleIndex, occurrences);
+	}
+	const ledger = /* @__PURE__ */ new Map();
+	for (const [root, members] of groups) ledger.set(root, entryFor(members, reopened.get(root) ?? 0));
+	return {
+		ledger,
+		occurrences: [...occurrences.values()]
+	};
+};
+const openLadderFindings = (ledger) => ledger.filter((entry) => entry.disposition === "open");
+const occurrenceBlocks = (occurrence) => occurrence.disposition === "open" && resolveFindingBlocking(occurrence.finding, "open");
+const blockingLadderFindings = (ledger) => ledger.filter((entry) => entry.occurrences.some(occurrenceBlocks));
+const staleRepeatLadderFindings = (ledger) => ledger.filter((entry) => entry.disposition === "stale-repeat");
+//#endregion
+//#region src/review-recording-schema.ts
+const ABSENT_PROOF_DIGEST = "absent";
+const sha256Pattern = /^[0-9a-f]{64}$/u;
+const occurrenceAddressSchema$1 = z.string().regex(OCCURRENCE_ADDRESS_PATTERN);
+const declarationRecordSchema = z.union([z.object({
+	authority: z.enum(["operator", "reviewer"]),
+	disposition: z.enum([
+		"fixed-in-thread",
+		"follow-up-filed",
+		"waived"
+	]),
+	reference: z.string().min(1).optional(),
+	target: occurrenceAddressSchema$1
+}).strict(), z.object({
+	authority: z.literal("policy"),
+	disposition: z.enum(["policy-accepted", "stale-repeat"]),
+	rule: z.enum(POLICY_DECLARATION_RULES),
+	target: occurrenceAddressSchema$1
+}).strict()]);
+const recordsShape = {
+	declarations: z.array(declarationRecordSchema),
+	occurrences: z.array(z.object({
+		address: occurrenceAddressSchema$1,
+		declaredCycle: z.number().int().positive(),
+		repeatOf: occurrenceAddressSchema$1.optional()
+	}).strict())
+};
+const reviewCycleRecordingSchema = z.union([z.object({
+	...recordsShape,
+	appliedTo: z.union([z.string().regex(sha256Pattern), z.literal(ABSENT_PROOF_DIGEST)]),
+	base: z.object({
+		ref: z.string().min(1),
+		sha: z.string().regex(/^[0-9a-f]{40}$/u)
+	}).strict(),
+	dispositionsDigest: z.string().regex(sha256Pattern).optional(),
+	findingsDigest: z.string().regex(sha256Pattern),
+	recordingId: z.string().regex(sha256Pattern)
+}).strict(), z.object({
+	...recordsShape,
+	imported: z.object({
+		proofDigest: z.string().regex(sha256Pattern),
+		schemaVersion: z.literal(2)
+	}).strict()
+}).strict()]);
+//#endregion
+//#region src/review-recording.ts
+/**
+* The occurrences of the cycles already on the ladder, in recording order,
+* with the write-time key each carries for grouping the next cycle. A cycle
+* whose `repeatOf` is unknown indexes every occurrence as its own root.
+*/
+const occurrenceIndexFor = (cycles) => cycles.flatMap((cycle, cycleIndex) => cycle.findings.map((finding, findingIndex) => {
+	const address = occurrenceAddress(cycleIndex + 1, findingIndex + 1);
+	return {
+		address,
+		finding,
+		key: findingKey(finding),
+		root: cycle.recording?.occurrences[findingIndex]?.repeatOf ?? address
+	};
+}));
+const soleRoot = (candidates) => {
+	const roots = new Set(candidates.map((candidate) => candidate.root));
+	return roots.size === 1 ? [...roots][0] : void 0;
+};
+/**
+* The occurrence records for a cycle about to be recorded at position
+* `cycleIndex` (1-based), grouped against the prior cycles once, at write
+* time, by the contract's two identity arms: exact `findingKey` equality,
+* then an explicit `supersedes` citation matched on title and file. A
+* citation that names occurrences from more than one group is ignored — the
+* occurrence becomes its own root — rather than guessed at. Span overlap is
+* never consulted (decision 3).
+*/
+const occurrencesForCycle = ({ cycleIndex, declaredCycle, findings, priorCycles }) => {
+	const prior = occurrenceIndexFor(priorCycles);
+	return findings.map((finding, findingIndex) => {
+		const key = findingKey(finding);
+		const { supersedes } = finding;
+		const exact = prior.filter((candidate) => candidate.key === key);
+		const cited = exact.length === 0 && supersedes !== void 0 ? prior.filter((candidate) => declarationMatchesEntry(candidate.finding, supersedes)) : [];
+		const repeatOf = soleRoot(exact.length > 0 ? exact : cited);
+		return {
+			address: occurrenceAddress(cycleIndex, findingIndex + 1),
+			declaredCycle,
+			...repeatOf === void 0 ? {} : { repeatOf }
+		};
+	});
+};
+const occurrenceAddressSchema = z.string().regex(OCCURRENCE_ADDRESS_PATTERN);
+const declarableDisposition = z.enum([
+	"fixed-in-thread",
+	"follow-up-filed",
+	"waived"
+]);
+/**
+* Wire schema for `pr:review --dispositions`. A declaration names one
+* occurrence by address (`target`), or, as a convenience for the readout
+* operators have used so far, a finding by title and file; the latter is
+* translated to addresses at recording time and refused when it is ambiguous.
+*/
+const dispositionDeclarationsFileSchema = z.array(z.union([z.object({
+	disposition: declarableDisposition,
+	reference: z.string().min(1).optional(),
+	target: occurrenceAddressSchema
+}).strict(), z.object({
+	disposition: declarableDisposition,
+	finding: z.object({
+		file: z.string().min(1).optional(),
+		title: z.string().min(1)
+	}).strict(),
+	reference: z.string().min(1).optional()
+}).strict()]));
+const describeOccurrences = (occurrences) => occurrences.map((occurrence) => `${occurrence.address} (${occurrence.finding.title}${occurrence.finding.file === void 0 ? "" : ` in ${occurrence.finding.file}`})`).join("; ");
+/**
+* Translate this recording's declarations into the records it stores.
+* `index` covers the prior cycles and, for a historical recording, this
+* cycle's own findings (#1099). An address must name a recorded occurrence.
+* A title-plus-file declaration must resolve to exactly one repeat group; it
+* is then stored once per occurrence in that group, which is what an
+* entry-wide disposition means in the contract's per-occurrence vocabulary.
+* More than one group is the ambiguity decision 7 refuses, and the refusal
+* prints the candidate addresses so the operator can name one.
+*/
+const resolveDeclaredDispositions = ({ declarations, index, resolutions }) => {
+	const records = [];
+	const available = () => index.length === 0 ? "no occurrence is recorded" : describeOccurrences(index);
+	const assertAddress = (target, what) => {
+		if (!index.some((candidate) => candidate.address === target)) throw new Error(`${what} targets ${target}, which names no recorded occurrence. Recorded occurrences: ${available()}.`);
+	};
+	for (const declaration of declarations) {
+		const reference = declaration.reference === void 0 ? {} : { reference: declaration.reference };
+		if ("target" in declaration) {
+			assertAddress(declaration.target, "--dispositions entry");
+			records.push({
+				authority: "operator",
+				disposition: declaration.disposition,
+				...reference,
+				target: declaration.target
+			});
+			continue;
+		}
+		const matches = index.filter((candidate) => declarationMatchesEntry(candidate.finding, declaration.finding));
+		if (matches.length === 0) throw new Error(`--dispositions entry "${declaration.finding.title}" matches no recorded finding. Recorded occurrences: ${available()}.`);
+		if (soleRoot(matches) === void 0) throw new Error(`--dispositions entry "${declaration.finding.title}" names more than one recorded finding; name one by address instead. Candidates: ${describeOccurrences(matches)}.`);
+		for (const occurrence of matches) records.push({
+			authority: "operator",
+			disposition: declaration.disposition,
+			...reference,
+			target: occurrence.address
+		});
+	}
+	for (const resolution of resolutions) {
+		assertAddress(resolution.target, "findings resolution");
+		records.push({
+			authority: "reviewer",
+			disposition: "fixed-in-thread",
+			reference: resolution.reference,
+			target: resolution.target
+		});
+	}
+	return records;
+};
+//#endregion
 //#region src/pr-proof-io.ts
 const proofPathFor = (descriptor, cwd, filePath = descriptor.defaultPath) => path.resolve(cwd, filePath);
 const readProofFromPath = (parse, filePath) => parse(JSON.parse(readFileSync(filePath, "utf-8")));
-const readProofFor = (descriptor, cwd, filePath) => readProofFromPath(descriptor.parse, proofPathFor(descriptor, cwd, filePath));
+const readProofFor = (descriptor, cwd, filePath) => {
+	const target = proofPathFor(descriptor, cwd, filePath);
+	return descriptor.parseBytes ? descriptor.parseBytes(readFileSync(target, "utf-8")) : readProofFromPath(descriptor.parse, target);
+};
 const readOptionalProofFor = (descriptor, cwd, filePath) => readOptionalProof((p) => readProofFor(descriptor, cwd, filePath ?? p), proofPathFor(descriptor, cwd, filePath));
 const writeProofFor = (descriptor, cwd, value, filePath) => writeProofJson(value, proofPathFor(descriptor, cwd, filePath));
-function writeProofJson(proof, output) {
-	mkdirSync(path.dirname(output), { recursive: true });
-	writeFileSync(output, `${JSON.stringify(proof, null, 2)}\n`);
+const nodeProofWriteFileSystem = {
+	closeSync,
+	fsyncSync,
+	mkdirSync,
+	openSync,
+	readFileSync,
+	renameSync,
+	statSync,
+	unlinkSync,
+	writeFileSync
+};
+const fsyncPath = (fs, target) => {
+	const fd = fs.openSync(target, "r");
+	try {
+		fs.fsyncSync(fd);
+	} finally {
+		fs.closeSync(fd);
+	}
+};
+/**
+* Write a proof so that the canonical path is never observable half-written:
+* the bytes land in a sibling temp file, are fsynced, are renamed over the
+* target in one step, the directory entry is fsynced, and the target is read
+* back and compared to what was meant to be written (#1131). A fault at any
+* step leaves the previous file (or its absence) intact, removes the temp
+* file, and throws. A read-back mismatch throws too, so a "success" is never
+* reported for bytes that are not on disk.
+*
+* The temp file sits beside the target because rename is only atomic within
+* one file system. The directory fsync is skipped on Windows, which cannot
+* open a directory for fsync.
+*/
+function writeProofJson(proof, output, fs = nodeProofWriteFileSystem) {
+	const serialized = `${JSON.stringify(proof, null, 2)}\n`;
+	const directory = path.dirname(output);
+	const temp = path.join(directory, `.${path.basename(output)}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`);
+	fs.mkdirSync(directory, { recursive: true });
+	let renamed = false;
+	try {
+		fs.writeFileSync(temp, serialized);
+		fsyncPath(fs, temp);
+		fs.renameSync(temp, output);
+		renamed = true;
+		if (process.platform !== "win32") fsyncPath(fs, directory);
+	} finally {
+		if (!renamed) try {
+			fs.unlinkSync(temp);
+		} catch {}
+	}
+	const readBack = fs.readFileSync(output, "utf-8");
+	if (readBack !== serialized) throw new Error(`Proof write to ${output} did not read back as written (${readBack.length} bytes on disk, ${serialized.length} expected); the file cannot be trusted.`);
 }
 const writeProofToPaths = (writeOne, canonical, additional) => {
 	writeOne(canonical);
 	if (additional !== void 0 && additional !== canonical) writeOne(additional);
 };
+const readProofFileState = (filePath, fs = nodeProofWriteFileSystem) => {
+	try {
+		const bytes = fs.readFileSync(filePath, "utf-8");
+		return {
+			bytes,
+			digest: sha256Hex(bytes),
+			present: true
+		};
+	} catch (error) {
+		if (error?.code === "ENOENT") return {
+			digest: ABSENT_PROOF_DIGEST,
+			present: false
+		};
+		throw error;
+	}
+};
+/**
+* The retryable `concurrent-write` refusal: nothing was written, and the
+* recording must be retried against the current proof. Either the proof's
+* digest moved between the recording's read and its write, another writer
+* held the proof lock for the whole wait window, or this writer's lock was
+* removed or replaced before its rename (#1132).
+*/
+var ConcurrentProofWriteError = class extends Error {
+	constructor(output, cause) {
+		super(concurrentWriteMessage(output, cause));
+		this.name = "ConcurrentProofWriteError";
+	}
+};
+const concurrentWriteMessage = (output, cause) => {
+	if ("expected" in cause) return `concurrent-write: ${output} changed while this recording was being prepared (applied to proof state ${cause.expected}, found ${cause.found}). Nothing was written; retry the recording against the current proof.`;
+	if ("held" in cause) return `concurrent-write: ${describeHeldLock(cause.held)}; ${LOCK_REMOVAL_INSTRUCTION}. Nothing was written to ${output}.`;
+	return `concurrent-write: proof lock ${cause.lockPath} is no longer this writer's (it was removed or replaced while the recording was being written). Nothing was written to ${output}; retry the recording against the current proof.`;
+};
+/**
+* The operator step for a crashed writer's lock. It is the same sentence in
+* the refusal, the release report and the doctor preflight warning, so a
+* grep finds every place it is stated.
+*/
+const LOCK_REMOVAL_INSTRUCTION = "if that writer is gone, remove the file and retry";
+const DEFAULT_LOCK_WAIT_MS = 5e3;
+const LOCK_POLL_MS = 20;
+const errorCode = (error) => error?.code;
+const sleepSync = (ms) => {
+	Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+};
+const lockPathFor = (output) => `${output}.lock`;
+const lockContents = (token) => `${JSON.stringify({
+	at: (/* @__PURE__ */ new Date()).toISOString(),
+	pid: process.pid,
+	token
+})}\n`;
+const parseLockContents = (bytes) => {
+	try {
+		const parsed = JSON.parse(bytes);
+		if (parsed && typeof parsed === "object") {
+			const { pid, token } = parsed;
+			return {
+				pid: typeof pid === "number" ? String(pid) : "unknown",
+				token: typeof token === "string" && token !== "" ? token : "unknown"
+			};
+		}
+	} catch {}
+	return {
+		pid: "unknown",
+		token: "unknown"
+	};
+};
+const describeHeldLock = (held) => `proof lock ${held.lockPath} held since ${held.since} (token ${held.token}, pid ${held.pid})`;
+/**
+* The proof lock beside `output`, if one exists, as a holder description
+* (#1132). Used by the refusal message and by `doctor --preflight`, which
+* warns about a lock older than the wait window because no writer will ever
+* remove it on the operator's behalf. `undefined` when there is no lock.
+*/
+const describeHeldProofLock = (output, fs = nodeProofWriteFileSystem, now = Date.now()) => {
+	const lockPath = lockPathFor(output);
+	let mtimeMs;
+	try {
+		({mtimeMs} = fs.statSync(lockPath));
+	} catch (error) {
+		if (errorCode(error) === "ENOENT") return;
+		throw error;
+	}
+	let contents = "";
+	try {
+		contents = fs.readFileSync(lockPath, "utf-8");
+	} catch {}
+	return {
+		ageMs: Math.max(0, now - mtimeMs),
+		lockPath,
+		since: new Date(mtimeMs).toISOString(),
+		...parseLockContents(contents)
+	};
+};
+/** True when `doctor --preflight` should warn about this lock (#1132). */
+const proofLockOutlivesWait = (held) => held.ageMs > DEFAULT_LOCK_WAIT_MS;
+/**
+* Take the exclusive proof lock — a sibling `<proof>.lock` created with
+* O_EXCL and stamped with a fresh token, so exactly one writer holds it and
+* the holder can recognise its own file (#1132). A held lock is waited on for
+* `lockWaitMs`, then refused naming the holder. Nothing here ever removes a
+* lock it did not create. Returns the token and the release.
+*/
+const acquireProofLock = (output, fs, { lockWaitMs = DEFAULT_LOCK_WAIT_MS, report = (line) => process.stderr.write(`${line}\n`) }) => {
+	const lockPath = lockPathFor(output);
+	const deadline = Date.now() + lockWaitMs;
+	const created = () => {
+		try {
+			fs.closeSync(fs.openSync(lockPath, "wx"));
+			return true;
+		} catch (error) {
+			if (errorCode(error) !== "EEXIST") throw error;
+			return false;
+		}
+	};
+	while (!created()) if (Date.now() < deadline) sleepSync(LOCK_POLL_MS);
+	else {
+		const held = describeHeldProofLock(output, fs);
+		if (held !== void 0) throw new ConcurrentProofWriteError(output, { held });
+	}
+	const mine = lockContents(randomUUID());
+	fs.writeFileSync(lockPath, mine);
+	return {
+		mine,
+		release: () => {
+			let current;
+			try {
+				current = fs.readFileSync(lockPath, "utf-8");
+			} catch (error) {
+				report(errorCode(error) === "ENOENT" ? `pr-proof: lock ${lockPath} was removed by someone else before this writer released it; nothing to release.` : `pr-proof: lock ${lockPath} could not be read on release (${String(error)}); left in place.`);
+				return;
+			}
+			if (current !== mine) {
+				const { pid, token } = parseLockContents(current);
+				report(`pr-proof: lock ${lockPath} is not this writer's (token ${token}, pid ${pid}); left in place.`);
+				return;
+			}
+			try {
+				fs.unlinkSync(lockPath);
+			} catch (error) {
+				report(`pr-proof: lock ${lockPath} could not be removed on release (${String(error)}); ${LOCK_REMOVAL_INSTRUCTION}.`);
+			}
+		}
+	};
+};
+/**
+* The file system a locked write renames through: immediately before the
+* proof rename it re-reads the lock and refuses unless the contents are this
+* writer's token. Nothing is renamed on a mismatch, and `writeProofJson`
+* removes the temp file as for any other fault.
+*/
+const ownershipCheckedFileSystem = (fs, output, mine) => ({
+	...fs,
+	renameSync: (from, to) => {
+		if (to === output) {
+			let current;
+			try {
+				current = fs.readFileSync(lockPathFor(output), "utf-8");
+			} catch {
+				current = void 0;
+			}
+			if (current !== mine) throw new ConcurrentProofWriteError(output, {
+				lockPath: lockPathFor(output),
+				replaced: true
+			});
+		}
+		fs.renameSync(from, to);
+	}
+});
+/**
+* Compare-and-swap proof write (#1131, decision 6; serialized by #1132). The
+* file is re-read under an exclusive lock and replaced only when its bytes
+* still digest to `appliedTo`, the state the recording was computed against.
+* The lock covers read → compare → temp write → fsync → ownership check →
+* rename → directory fsync → read-back, so two writers that both read the
+* same prior state cannot both succeed: the second one in waits, then gets
+* the retryable `concurrent-write` refusal before any temp file exists.
+*
+* Scope: writers on one host sharing one file system (the O_EXCL create is
+* the mutual exclusion; no cross-host guarantee). A writer that dies holding
+* the lock leaves it behind, and every later writer refuses naming it: the
+* lock is removed by an operator, never reclaimed (see the invariants above).
+* The canonical path is never observable half-written (`writeProofJson`).
+*/
+function writeProofJsonApplied(proof, output, appliedTo, fs = nodeProofWriteFileSystem, options = {}) {
+	fs.mkdirSync(path.dirname(output), { recursive: true });
+	const { mine, release } = acquireProofLock(output, fs, options);
+	try {
+		const current = readProofFileState(output, fs);
+		if (current.digest !== appliedTo) throw new ConcurrentProofWriteError(output, {
+			expected: appliedTo,
+			found: current.digest
+		});
+		writeProofJson(proof, output, ownershipCheckedFileSystem(fs, output, mine));
+	} finally {
+		release();
+	}
+}
 function tryReadProof(read, filePath) {
 	try {
 		return { proof: read(filePath) };
@@ -1713,6 +2548,249 @@ function withPinnedNodeOnPath(command, nodeBinDir) {
 	return `export PATH=${singleQuote(nodeBinDir)}:"$PATH"\n${command}`;
 }
 //#endregion
+//#region src/github-issue-comments.ts
+const isCommentPage = (value) => Array.isArray(value[0]);
+const normalizeIssueComments = (value) => {
+	return (isCommentPage(value) ? value.flat() : value).map((comment) => ({
+		author: { login: comment.user?.login },
+		body: comment.body,
+		createdAt: comment.created_at,
+		id: comment.node_id,
+		updatedAt: comment.updated_at,
+		url: comment.html_url
+	}));
+};
+//#endregion
+//#region src/github-client.ts
+/**
+* Shared `gh` CLI client for the factory.
+*
+* Every factory `gh` invocation routes through {@link runCapture} so it inherits
+* the shared-stash and worker-control-checkout guards plus the git-env scrub,
+* and so spawn configuration + JSON parsing live in exactly one place. The
+* guards are inert for `gh` (they only trip on `git stash` / worker-checkout
+* mutations), and `runCapture`'s failure message is byte-identical to the
+* hand-rolled wrappers this module replaces (`gh <args> failed:\n<stderr>`).
+*
+* Field projections (`PR_VIEW_JSON_FIELDS`) and telemetry-wrapped GraphQL
+* queries deliberately stay with their consumers — they are per-consumer
+* shapes, not shared plumbing.
+*/
+const runGhCapture = (args, cwd = process.cwd(), acceptableExitCodes = [0]) => runCapture("gh", args, cwd, { acceptableExitCodes });
+const runGhJsonAt = (args, cwd) => JSON.parse(runGhCapture(args, cwd).stdout);
+const runGhJson = (args) => runGhJsonAt(args, process.cwd());
+const gitReferenceSchema = z.object({ object: z.object({ sha: z.string().regex(/^[0-9a-f]{40}$/u) }) });
+/** Parse GitHub's git-ref JSON (`GET .../git/ref/heads/<name>`). */
+const parseGitHubBranchTipResponse = (value) => gitReferenceSchema.parse(value).object.sha;
+const githubBranchTipApiPath = (repository, branch) => `/repos/${repository.owner}/${repository.name}/git/ref/heads/${encodeURIComponent(branch)}`;
+/**
+* Read a branch tip from GitHub rather than a checkout's cached remote ref.
+* `gh` is injectable so a test can hand the real read a fake GitHub.
+*/
+const fetchGitHubBranchTipSha = (repository, branch, cwd, gh = runGhJsonAt) => parseGitHubBranchTipResponse(gh(["api", githubBranchTipApiPath(repository, branch)], cwd));
+const repositoryFileSchema = z.object({
+	content: z.string(),
+	encoding: z.literal("base64"),
+	type: z.literal("file")
+});
+/**
+* Read one file's content at an exact commit from GitHub.
+*
+* #922: the authoritative base policy is the profile GitHub serves at the base
+* tip. A checkout is candidate-controlled, so it is not an authority for it.
+* There is exactly one implementation on purpose — no local-first read with an
+* API fallback, which would let a checkout answer the authority's question.
+*
+* Throws for every failure — an absent path, a directory, a file too large for
+* the contents endpoint to inline, an unreachable or unauthorized API. The
+* caller decides what an unreadable authority means; it is never an absent one.
+*/
+const fetchGitHubFileAtRef = (repository, filePath, ref, cwd) => {
+	const encodedPath = filePath.split("/").map((segment) => encodeURIComponent(segment)).join("/");
+	const response = repositoryFileSchema.parse(runGhJsonAt(["api", `/repos/${repository.owner}/${repository.name}/contents/${encodedPath}?ref=${encodeURIComponent(ref)}`], cwd));
+	return Buffer$1.from(response.content, "base64").toString("utf-8");
+};
+/**
+* Fetch and normalize the issue/PR comment thread for `<owner>/<repo>`.
+*
+* `--slurp` postdates gh 2.46; with `--paginate` alone gh returns a single
+* merged array. `normalizeIssueComments` accepts both the merged and slurped
+* (array-of-arrays) shapes, so behavior is identical on either gh version
+* (patronage/internal#380).
+*/
+const fetchIssueComments = (fullName, issueNumber) => normalizeIssueComments(runGhJson([
+	"api",
+	"--paginate",
+	`/repos/${fullName}/issues/${issueNumber}/comments`
+]));
+const livePullRequestBaseSchema = z.object({
+	baseRefName: z.string().min(1),
+	isCrossRepository: z.unknown(),
+	number: z.number().int().positive()
+});
+const failureText$3 = (error) => error instanceof Error ? error.message : String(error);
+/** `gh pr view` exits non-zero when the branch has no pull request (#323). */
+const isNoPullRequestYet$1 = (message) => /no pull requests found for branch/iu.test(message);
+/**
+* The pull request GitHub associates with the checkout's current branch.
+* Only its number, base ref name and fork status are read: the base SHA
+* comes from the live ref, never from this projection.
+*/
+const lookupLivePullRequestBase = (cwd, gh = runGhJsonAt) => {
+	try {
+		const parsed = livePullRequestBaseSchema.safeParse(gh([
+			"pr",
+			"view",
+			"--json",
+			"number,baseRefName,isCrossRepository"
+		], cwd));
+		return parsed.success ? {
+			pullRequest: parsed.data,
+			status: "found"
+		} : {
+			reason: `GitHub did not report a usable base ref for this branch's pull request (${parsed.error.issues.map((issue) => issue.message).join("; ")}).`,
+			status: "unavailable"
+		};
+	} catch (error) {
+		const message = failureText$3(error);
+		return isNoPullRequestYet$1(message) ? { status: "none" } : {
+			reason: `the pull request lookup for this branch failed: ${message}`,
+			status: "unavailable"
+		};
+	}
+};
+/**
+* The live tip of a base branch, read from GitHub for the trusted checkout's
+* repository through the reader `pr:ready` uses.
+*/
+const liveBranchTipSha = (cwd, branch, gh = runGhJsonAt, repository = checkoutRepository(cwd)) => fetchGitHubBranchTipSha(repository, branch, cwd, gh);
+const fetchOriginRef = (cwd, refName) => {
+	runCapture("git", [
+		"fetch",
+		"--no-tags",
+		"origin",
+		refName
+	], cwd);
+};
+const resolveCommitSha = (cwd, ref) => {
+	try {
+		return runCapture("git", [
+			"rev-parse",
+			"--verify",
+			`${ref}^{commit}`
+		], cwd).stdout.trim();
+	} catch {
+		return;
+	}
+};
+/**
+* The production dependencies, over one `gh` reader so a test can hand the
+* real lookups a fake GitHub and prove which read the binding trusts.
+*/
+const candidateBaseDependencies = ({ gh = runGhJsonAt, repository } = {}) => ({
+	fetchOriginRef,
+	liveBranchTipSha: (cwd, branch) => liveBranchTipSha(cwd, branch, gh, repository ?? checkoutRepository(cwd)),
+	lookupPullRequestBase: (cwd) => lookupLivePullRequestBase(cwd, gh),
+	resolveCommitSha
+});
+const ORIGIN_PREFIX = "origin/";
+/**
+* The GitHub branch a candidate base ref names. Proofs and `--base` carry the
+* local remote-tracking form (`origin/<branch>`); GitHub creates and compares
+* pull requests by `<branch>`. A ref without the remote qualifier is returned
+* as given.
+*/
+const candidateBaseBranch = (ref) => ref.startsWith(ORIGIN_PREFIX) ? ref.slice(7) : ref;
+const bindToPullRequest = ({ cwd, dependencies, pullRequest, requestedBase }) => {
+	const ref = `${ORIGIN_PREFIX}${pullRequest.baseRefName}`;
+	let tip;
+	try {
+		tip = dependencies.liveBranchTipSha(cwd, pullRequest.baseRefName);
+	} catch (error) {
+		throw new Error(`PR #${pullRequest.number} targets ${pullRequest.baseRefName}, but its live tip could not be read from GitHub: ${failureText$3(error)} pr:ready measures against that tip, so the candidate is not bound to a guessed base; restore ${pullRequest.baseRefName} or rerun once GitHub is reachable.`, { cause: error });
+	}
+	try {
+		dependencies.fetchOriginRef(cwd, pullRequest.baseRefName);
+	} catch {}
+	if (!dependencies.resolveCommitSha(cwd, tip)) throw new Error(`The live base of PR #${pullRequest.number} (${ref} at ${tip}) is not available locally; fetch it and rerun.`);
+	if (requestedBase !== void 0) {
+		const requestedSha = dependencies.resolveCommitSha(cwd, requestedBase);
+		if (requestedSha !== tip) throw new Error(`--base ${requestedBase} (${requestedSha ?? "unresolvable"}) does not resolve to the live base of PR #${pullRequest.number}, ${ref} at ${tip}. Omit --base to measure against the pull request's base, or pass ${ref}.`);
+	}
+	return {
+		ref,
+		sha: tip,
+		source: {
+			kind: "pull-request",
+			number: pullRequest.number
+		}
+	};
+};
+const bindToRef = ({ cwd, dependencies, pullRequest, ref }) => {
+	let fetched = false;
+	if (ref.startsWith(ORIGIN_PREFIX)) try {
+		dependencies.fetchOriginRef(cwd, ref.slice(7));
+		fetched = true;
+	} catch {}
+	const sha = dependencies.resolveCommitSha(cwd, ref);
+	if (!sha) throw new Error(`Base ${ref} does not resolve to a commit in this checkout; fetch it or pass --base <ref>.`);
+	return {
+		ref,
+		sha,
+		source: {
+			fetched,
+			kind: "ref",
+			pullRequest
+		}
+	};
+};
+/**
+* Bind the candidate to its base. A pull request for the branch wins and its
+* live tip is the base; a `requestedBase` that disagrees with it is refused.
+* Without one, the requested or default ref is fetched fresh and resolved.
+* A blank `requestedBase` asserts nothing: `pr:publish` forwards its own
+* omitted `--base` as the empty string to the stages it runs (#1132).
+*/
+const resolveCandidateBase = ({ cwd, dependencies = candidateBaseDependencies(), requestedBase: requestedBaseInput }) => {
+	const requestedBase = requestedBaseInput === void 0 || requestedBaseInput.trim() === "" ? void 0 : requestedBaseInput.trim();
+	const lookup = dependencies.lookupPullRequestBase(cwd);
+	return lookup.status === "found" ? bindToPullRequest({
+		cwd,
+		dependencies,
+		pullRequest: lookup.pullRequest,
+		requestedBase
+	}) : bindToRef({
+		cwd,
+		dependencies,
+		pullRequest: lookup,
+		ref: requestedBase ?? "origin/main"
+	});
+};
+/**
+* The policy-authority lookup, read from the pull request the base binding
+* already found (#1131): one GitHub read, one pull request, so the base the
+* candidate is measured against and the policy it is judged under can never
+* come from two different pull requests. `pr:review` and `pr:verify` both
+* feed `resolveStageReviewDemand` through this.
+*/
+const policyLookupFromBaseLookup = (lookup) => lookup.status === "found" ? {
+	pullRequest: {
+		baseRefName: lookup.pullRequest.baseRefName,
+		isCrossRepository: lookup.pullRequest.isCrossRepository
+	},
+	status: "found"
+} : {
+	reason: lookup.status === "none" ? "no pull request is open for this branch." : lookup.reason,
+	status: "unavailable"
+};
+/** One line stating which base was bound and why. */
+const describeCandidateBase = (binding) => {
+	if (binding.source.kind === "pull-request") return `base ${binding.ref} at ${binding.sha}, the live base of PR #${binding.source.number}`;
+	const fetched = binding.source.fetched ? "fetched from origin" : "local ref (origin not fetched)";
+	const pullRequest = binding.source.pullRequest.status === "none" ? "no pull request is open for this branch" : `the pull request lookup was unavailable, so no live PR base could be read (${binding.source.pullRequest.reason})`;
+	return `base ${binding.ref} at ${binding.sha}, ${fetched}; ${pullRequest}`;
+};
+//#endregion
 //#region src/candidate-identity.ts
 /**
 * The same fallback for a patch id taken at an explicit ref rather than at
@@ -1924,102 +3002,29 @@ function resolveCwdOption(cwd) {
 	return path.resolve(value);
 }
 function collectCwdOption(rawValue, previous) {
-	if (previous === void 0) return rawValue;
-	const previousResolved = resolveCwdOption(previous);
-	const currentResolved = resolveCwdOption(rawValue);
-	if (previousResolved !== currentResolved) throw new Error(`--cwd was passed multiple times with conflicting values: "${previous}" (resolves to ${previousResolved}) and "${rawValue}" (resolves to ${currentResolved})`);
-	return rawValue;
-}
-function markCwdOptionDefault(command) {
-	const option = command.options.find((candidate) => candidate.attributeName() === "cwd");
-	if (option) {
-		option.defaultValue = ".";
-		option.defaultValueDescription = ".";
-	}
-	return command;
-}
-function resolveCheckoutPath(cwd, target) {
-	return path.resolve(cwd, target);
-}
-function resolveProofOutputPaths(cwd, defaultPath, requested) {
-	return {
-		additional: requested ? resolveCheckoutPath(cwd, requested) : void 0,
-		canonical: resolveCheckoutPath(cwd, defaultPath)
-	};
-}
-//#endregion
-//#region src/github-issue-comments.ts
-const isCommentPage = (value) => Array.isArray(value[0]);
-const normalizeIssueComments = (value) => {
-	return (isCommentPage(value) ? value.flat() : value).map((comment) => ({
-		author: { login: comment.user?.login },
-		body: comment.body,
-		createdAt: comment.created_at,
-		id: comment.node_id,
-		updatedAt: comment.updated_at,
-		url: comment.html_url
-	}));
-};
-//#endregion
-//#region src/github-client.ts
-/**
-* Shared `gh` CLI client for the factory.
-*
-* Every factory `gh` invocation routes through {@link runCapture} so it inherits
-* the shared-stash and worker-control-checkout guards plus the git-env scrub,
-* and so spawn configuration + JSON parsing live in exactly one place. The
-* guards are inert for `gh` (they only trip on `git stash` / worker-checkout
-* mutations), and `runCapture`'s failure message is byte-identical to the
-* hand-rolled wrappers this module replaces (`gh <args> failed:\n<stderr>`).
-*
-* Field projections (`PR_VIEW_JSON_FIELDS`) and telemetry-wrapped GraphQL
-* queries deliberately stay with their consumers — they are per-consumer
-* shapes, not shared plumbing.
-*/
-const runGhCapture = (args, cwd = process.cwd(), acceptableExitCodes = [0]) => runCapture("gh", args, cwd, { acceptableExitCodes });
-const runGhJsonAt = (args, cwd) => JSON.parse(runGhCapture(args, cwd).stdout);
-const runGhJson = (args) => runGhJsonAt(args, process.cwd());
-const gitReferenceSchema = z.object({ object: z.object({ sha: z.string().regex(/^[0-9a-f]{40}$/u) }) });
-/** Parse GitHub's git-ref JSON (`GET .../git/ref/heads/<name>`). */
-const parseGitHubBranchTipResponse = (value) => gitReferenceSchema.parse(value).object.sha;
-const githubBranchTipApiPath = (repository, branch) => `/repos/${repository.owner}/${repository.name}/git/ref/heads/${encodeURIComponent(branch)}`;
-/** Read a branch tip from GitHub rather than a checkout's cached remote ref. */
-const fetchGitHubBranchTipSha = (repository, branch, cwd) => parseGitHubBranchTipResponse(runGhJsonAt(["api", githubBranchTipApiPath(repository, branch)], cwd));
-const repositoryFileSchema = z.object({
-	content: z.string(),
-	encoding: z.literal("base64"),
-	type: z.literal("file")
-});
-/**
-* Read one file's content at an exact commit from GitHub.
-*
-* #922: the authoritative base policy is the profile GitHub serves at the base
-* tip. A checkout is candidate-controlled, so it is not an authority for it.
-* There is exactly one implementation on purpose — no local-first read with an
-* API fallback, which would let a checkout answer the authority's question.
-*
-* Throws for every failure — an absent path, a directory, a file too large for
-* the contents endpoint to inline, an unreachable or unauthorized API. The
-* caller decides what an unreadable authority means; it is never an absent one.
-*/
-const fetchGitHubFileAtRef = (repository, filePath, ref, cwd) => {
-	const encodedPath = filePath.split("/").map((segment) => encodeURIComponent(segment)).join("/");
-	const response = repositoryFileSchema.parse(runGhJsonAt(["api", `/repos/${repository.owner}/${repository.name}/contents/${encodedPath}?ref=${encodeURIComponent(ref)}`], cwd));
-	return Buffer$1.from(response.content, "base64").toString("utf-8");
-};
-/**
-* Fetch and normalize the issue/PR comment thread for `<owner>/<repo>`.
-*
-* `--slurp` postdates gh 2.46; with `--paginate` alone gh returns a single
-* merged array. `normalizeIssueComments` accepts both the merged and slurped
-* (array-of-arrays) shapes, so behavior is identical on either gh version
-* (patronage/internal#380).
-*/
-const fetchIssueComments = (fullName, issueNumber) => normalizeIssueComments(runGhJson([
-	"api",
-	"--paginate",
-	`/repos/${fullName}/issues/${issueNumber}/comments`
-]));
+	if (previous === void 0) return rawValue;
+	const previousResolved = resolveCwdOption(previous);
+	const currentResolved = resolveCwdOption(rawValue);
+	if (previousResolved !== currentResolved) throw new Error(`--cwd was passed multiple times with conflicting values: "${previous}" (resolves to ${previousResolved}) and "${rawValue}" (resolves to ${currentResolved})`);
+	return rawValue;
+}
+function markCwdOptionDefault(command) {
+	const option = command.options.find((candidate) => candidate.attributeName() === "cwd");
+	if (option) {
+		option.defaultValue = ".";
+		option.defaultValueDescription = ".";
+	}
+	return command;
+}
+function resolveCheckoutPath(cwd, target) {
+	return path.resolve(cwd, target);
+}
+function resolveProofOutputPaths(cwd, defaultPath, requested) {
+	return {
+		additional: requested ? resolveCheckoutPath(cwd, requested) : void 0,
+		canonical: resolveCheckoutPath(cwd, defaultPath)
+	};
+}
 //#endregion
 //#region src/glob-match.ts
 function isValidGlob(pattern) {
@@ -2378,254 +3383,38 @@ function tryParseProfileContent(content) {
 	} catch {
 		return;
 	}
-}
-/**
-* Derive the HQ lane-permalink base (`<origin>/lanes/by-ref`) from an HQ ingest
-* endpoint. Reuses the same host the non-blocking gate sink already targets, so
-* branded factory check runs deep-link to HQ without a second config source.
-* Returns `undefined` for a malformed endpoint (callers keep the PR fallback).
-*/
-function hqLaneRefBaseUrl(endpoint) {
-	try {
-		return `${new URL(endpoint).origin}/lanes/by-ref`;
-	} catch {
-		return;
-	}
-}
-/**
-* The HQ lane-permalink base for a repository profile, or `undefined` when HQ is
-* not enabled/configured. Gated identically to the HQ gate sink
-* (`profile.hq.enabled`) so the check-run deep link and the ingest sink stay in
-* lockstep.
-*/
-function hqLaneRefBaseUrlFromProfile(profile) {
-	if (!profile?.hq?.enabled) return;
-	return hqLaneRefBaseUrl(profile.hq.endpoint);
-}
-function formatLegacyProfileError(profilePath, foundVersion, migration) {
-	return [`Profile is invalid: ${profilePath}: schemaVersion ${foundVersion} is not supported; migrate to schemaVersion 6 (ADR 0021).`, ...migration.map((line) => `  ${line}`)].join("\n");
-}
-function formatProfileError(profilePath, error) {
-	return `Profile is invalid: ${profilePath}: ${error.issues.map((issue) => {
-		return `${issue.path.length > 0 ? issue.path.join(".") : "root"}: ${issue.message}`;
-	}).join("; ")}`;
-}
-//#endregion
-//#region src/review-ladder-policy.ts
-const REVIEW_SEVERITIES = [
-	"critical",
-	"high",
-	"medium",
-	"low",
-	"unknown"
-];
-const REVIEW_CATEGORIES = [
-	"correctness",
-	"safety",
-	"coordination",
-	"maintainability",
-	"unknown"
-];
-const resolveReviewFindingSeverity = (priority) => {
-	const normalized = priority?.trim().toLowerCase();
-	if (!normalized) return "unknown";
-	if ([
-		"p0",
-		"critical",
-		"crit",
-		"blocker",
-		"blocking"
-	].includes(normalized)) return "critical";
-	if ([
-		"p1",
-		"high",
-		"severe",
-		"major"
-	].includes(normalized)) return "high";
-	if ([
-		"p2",
-		"medium",
-		"moderate",
-		"normal",
-		"refinement"
-	].includes(normalized)) return "medium";
-	if ([
-		"p3",
-		"p4",
-		"low",
-		"minor",
-		"info",
-		"informational"
-	].includes(normalized)) return "low";
-	return "unknown";
-};
-const countFindingsBySeverity = (findings) => {
-	const counts = {
-		critical: 0,
-		high: 0,
-		low: 0,
-		medium: 0,
-		unknown: 0
-	};
-	for (const finding of findings) counts[resolveReviewFindingSeverity(finding.priority)] += 1;
-	return counts;
-};
-const resolveReviewFindingCategory = (category) => REVIEW_CATEGORIES.find((value) => value === category?.trim().toLowerCase()) ?? "unknown";
-const resolveFindingBlocking = (finding, disposition = "open") => {
-	if (disposition !== "open") return false;
-	if (resolveReviewFindingCategory(finding.category) !== "maintainability") return true;
-	if (finding.blockingAfterCap !== void 0) return finding.blockingAfterCap;
-	const severity = resolveReviewFindingSeverity(finding.priority);
-	return severity === "critical" || severity === "high" || severity === "unknown";
-};
-const FACTORY_REVIEW_CYCLE_CAP = 5;
-const resolveReviewLadderPolicy = () => ({ gate: { cap: FACTORY_REVIEW_CYCLE_CAP } });
-//#endregion
-//#region src/sha256-hex.ts
-const ROUND_CONSTANTS = new Uint32Array([
-	1116352408,
-	1899447441,
-	3049323471,
-	3921009573,
-	961987163,
-	1508970993,
-	2453635748,
-	2870763221,
-	3624381080,
-	310598401,
-	607225278,
-	1426881987,
-	1925078388,
-	2162078206,
-	2614888103,
-	3248222580,
-	3835390401,
-	4022224774,
-	264347078,
-	604807628,
-	770255983,
-	1249150122,
-	1555081692,
-	1996064986,
-	2554220882,
-	2821834349,
-	2952996808,
-	3210313671,
-	3336571891,
-	3584528711,
-	113926993,
-	338241895,
-	666307205,
-	773529912,
-	1294757372,
-	1396182291,
-	1695183700,
-	1986661051,
-	2177026350,
-	2456956037,
-	2730485921,
-	2820302411,
-	3259730800,
-	3345764771,
-	3516065817,
-	3600352804,
-	4094571909,
-	275423344,
-	430227734,
-	506948616,
-	659060556,
-	883997877,
-	958139571,
-	1322822218,
-	1537002063,
-	1747873779,
-	1955562222,
-	2024104815,
-	2227730452,
-	2361852424,
-	2428436474,
-	2756734187,
-	3204031479,
-	3329325298
-]);
-const INITIAL_STATE = new Uint32Array([
-	1779033703,
-	3144134277,
-	1013904242,
-	2773480762,
-	1359893119,
-	2600822924,
-	528734635,
-	1541459225
-]);
-const BLOCK_BYTES = 64;
-const LENGTH_FIELD_BYTES = 8;
-const WORD_BITS = 32;
-const rotateRight = (value, bits) => (value >>> bits | value << WORD_BITS - bits) >>> 0;
-/** Message bytes plus the FIPS 180-4 padding and 64-bit length suffix. */
-const padMessage = (message) => {
-	const paddedLength = Math.ceil((message.length + 1 + LENGTH_FIELD_BYTES) / BLOCK_BYTES) * BLOCK_BYTES;
-	const padded = new Uint8Array(paddedLength);
-	padded.set(message);
-	padded[message.length] = 128;
-	const bitLength = BigInt(message.length) * 8n;
-	new DataView(padded.buffer).setBigUint64(paddedLength - LENGTH_FIELD_BYTES, bitLength);
-	return padded;
-};
-const ROUNDS = 64;
-const SCHEDULE_SEED_WORDS = 16;
-const STATE_WORDS = 8;
-const wordAt = (words, index) => words[index];
-/** One 64-byte block folded into the running state, in place. */
-const compress = (state, view, offset) => {
-	const schedule = new Uint32Array(ROUNDS);
-	for (let index = 0; index < SCHEDULE_SEED_WORDS; index += 1) schedule[index] = view.getUint32(offset + index * 4);
-	for (let index = SCHEDULE_SEED_WORDS; index < ROUNDS; index += 1) {
-		const previous = wordAt(schedule, index - 15);
-		const recent = wordAt(schedule, index - 2);
-		const sigma0 = rotateRight(previous, 7) ^ rotateRight(previous, 18) ^ previous >>> 3;
-		const sigma1 = rotateRight(recent, 17) ^ rotateRight(recent, 19) ^ recent >>> 10;
-		schedule[index] = wordAt(schedule, index - 16) + sigma0 + wordAt(schedule, index - 7) + sigma1 >>> 0;
-	}
-	const working = new Uint32Array(state);
-	for (let index = 0; index < ROUNDS; index += 1) {
-		const a = wordAt(working, 0);
-		const b = wordAt(working, 1);
-		const c = wordAt(working, 2);
-		const d = wordAt(working, 3);
-		const e = wordAt(working, 4);
-		const f = wordAt(working, 5);
-		const g = wordAt(working, 6);
-		const h = wordAt(working, 7);
-		const sum1 = rotateRight(e, 6) ^ rotateRight(e, 11) ^ rotateRight(e, 25);
-		const choose = e & f ^ ~e & g;
-		const temp1 = h + sum1 + choose + wordAt(ROUND_CONSTANTS, index) + wordAt(schedule, index) >>> 0;
-		const sum0 = rotateRight(a, 2) ^ rotateRight(a, 13) ^ rotateRight(a, 22);
-		const majority = a & b ^ a & c ^ b & c;
-		working[7] = g;
-		working[6] = f;
-		working[5] = e;
-		working[4] = d + temp1 >>> 0;
-		working[3] = c;
-		working[2] = b;
-		working[1] = a;
-		working[0] = temp1 + (sum0 + majority >>> 0) >>> 0;
-	}
-	for (let index = 0; index < STATE_WORDS; index += 1) state[index] = wordAt(state, index) + wordAt(working, index) >>> 0;
-};
-const toHex = (state) => {
-	let hex = "";
-	for (const word of state) hex += word.toString(16).padStart(8, "0");
-	return hex;
-};
-/** The lowercase hex SHA-256 digest of a UTF-8 string. */
-const sha256Hex = (input) => {
-	const padded = padMessage(new TextEncoder().encode(input));
-	const view = new DataView(padded.buffer);
-	const state = new Uint32Array(INITIAL_STATE);
-	for (let offset = 0; offset < padded.length; offset += BLOCK_BYTES) compress(state, view, offset);
-	return toHex(state);
-};
+}
+/**
+* Derive the HQ lane-permalink base (`<origin>/lanes/by-ref`) from an HQ ingest
+* endpoint. Reuses the same host the non-blocking gate sink already targets, so
+* branded factory check runs deep-link to HQ without a second config source.
+* Returns `undefined` for a malformed endpoint (callers keep the PR fallback).
+*/
+function hqLaneRefBaseUrl(endpoint) {
+	try {
+		return `${new URL(endpoint).origin}/lanes/by-ref`;
+	} catch {
+		return;
+	}
+}
+/**
+* The HQ lane-permalink base for a repository profile, or `undefined` when HQ is
+* not enabled/configured. Gated identically to the HQ gate sink
+* (`profile.hq.enabled`) so the check-run deep link and the ingest sink stay in
+* lockstep.
+*/
+function hqLaneRefBaseUrlFromProfile(profile) {
+	if (!profile?.hq?.enabled) return;
+	return hqLaneRefBaseUrl(profile.hq.endpoint);
+}
+function formatLegacyProfileError(profilePath, foundVersion, migration) {
+	return [`Profile is invalid: ${profilePath}: schemaVersion ${foundVersion} is not supported; migrate to schemaVersion 6 (ADR 0021).`, ...migration.map((line) => `  ${line}`)].join("\n");
+}
+function formatProfileError(profilePath, error) {
+	return `Profile is invalid: ${profilePath}: ${error.issues.map((issue) => {
+		return `${issue.path.length > 0 ? issue.path.join(".") : "root"}: ${issue.message}`;
+	}).join("; ")}`;
+}
 //#endregion
 //#region src/demand-resolution.ts
 /**
@@ -2835,46 +3624,6 @@ const authoritativePolicyResolution = ({ base, demand }) => ({
 	reviewPolicyChanged: demand.reviewPolicyChanged,
 	status: "authoritative"
 });
-const candidatePullRequestViewSchema = z.object({
-	baseRefName: z.string().min(1),
-	isCrossRepository: z.unknown()
-});
-/**
-* The pull request GitHub associates with the checkout's current branch.
-*
-* `pr:verify` and `pr:review` are handed a git ref, never a PR number, so this
-* is how they reach the authority at all. A checkout with no pull request open
-* is normal — verification runs before publication — so a failed lookup is
-* `unavailable` with the reason, never a throw.
-*
-* The lookup names no PR number, so GitHub resolves it from the branch. A
-* branch with more than one open pull request could therefore resolve a base
-* ref that is not the one readiness will use. That does not create a downgrade
-* path: readiness resolves the authority from the PR it was given and refuses
-* evidence whose recorded policy identity disagrees (`policyIdentityRefusal`).
-*/
-const lookupCandidatePullRequest = (cwd) => {
-	try {
-		const parsed = candidatePullRequestViewSchema.safeParse(runGhJsonAt([
-			"pr",
-			"view",
-			"--json",
-			"baseRefName,isCrossRepository"
-		], cwd));
-		return parsed.success ? {
-			pullRequest: parsed.data,
-			status: "found"
-		} : {
-			reason: `GitHub did not report a usable base ref for this branch's pull request (${parsed.error.issues.map((issue) => issue.message).join("; ")}).`,
-			status: "unavailable"
-		};
-	} catch (error) {
-		return {
-			reason: `no pull request could be read for this branch: ${failureText$2(error)}`,
-			status: "unavailable"
-		};
-	}
-};
 /**
 * The ONE way a factory stage resolves review demand (#922 Slice B).
 *
@@ -6153,6 +6902,33 @@ const exchangeFactoryAppInstallationToken = async (input) => {
 //#endregion
 //#region src/github-app-access.ts
 const NO_APP_SKIP_MESSAGE = "no factory GitHub App configured; skipping durable check-run republish.\n";
+/**
+* Fail-closed App credential mint/exchange that never completed. Distinct from
+* an evaluated candidate refusal: the branded check must stay unpublished
+* (#1125), while the command still exits nonzero (#949).
+*/
+var FactoryAppUnevaluableError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "FactoryAppUnevaluableError";
+	}
+};
+const FACTORY_APP_UNEVALUABLE_MARKERS = [
+	"Cursor OIDC mint",
+	"Factory App broker exchange",
+	"unable to mint Factory App token"
+];
+/**
+* True when the error is an App-credential miss — mint timeout, broker
+* exchange, or PEM mint — not a proof-chain refusal. `pr:ready` uses this to
+* skip a red `patronage-factory/pr-ready` that would read as evaluated-blocked
+* (#1125). Message markers cover injected doubles that throw a plain `Error`.
+*/
+const isFactoryAppUnevaluableError = (error) => {
+	if (error instanceof FactoryAppUnevaluableError || error instanceof CursorOidcMintError) return true;
+	const message = error instanceof Error ? error.message : String(error);
+	return FACTORY_APP_UNEVALUABLE_MARKERS.some((marker) => message.includes(marker));
+};
 const exchangeFromCursorVm = async (repository, dependencies, env, request, timeoutMs) => {
 	const mint = dependencies.mintCursorOidc ?? mintCursorOidcToken;
 	const exchange = dependencies.exchangeBroker ?? exchangeFactoryAppInstallationToken;
@@ -6339,7 +7115,7 @@ const isOutcome = (value) => OUTCOMES.includes(value);
 * comes from `verifyProofPassed`: a proof with no recorded outcome is
 * unfinished (fail closed).
 */
-const outcomeFor = (value) => isOutcome(value.outcome) ? value.outcome : "aborted";
+const outcomeFor$1 = (value) => isOutcome(value.outcome) ? value.outcome : "aborted";
 const asClassification = (value) => DIFF_CLASSIFICATIONS.includes(value) ? value : "unknown";
 /**
 * Project a local pr:verify proof onto the durable check-run payload. Accepts
@@ -6359,7 +7135,7 @@ const prVerifyCheckPayloadFor = (proof) => {
 		kind: PR_VERIFY_CHECK_PAYLOAD_KIND,
 		mode: value.mode,
 		...carriesReleases ? { notRequiredCommands: value.notRequiredCommands } : {},
-		outcome: outcomeFor(value),
+		outcome: outcomeFor$1(value),
 		proofSchemaVersion: typeof value.schemaVersion === "number" ? value.schemaVersion : 0,
 		schemaVersion: PR_VERIFY_CHECK_PAYLOAD_SCHEMA_VERSION,
 		...typeof value.patchId === "string" ? { patchId: value.patchId } : {},
@@ -6835,9 +7611,11 @@ async function confirmPublishedCheckRun({ config, createdId, dependencies, input
 * Never posts a commit-status fallback: the commit status is a human-readable
 * mirror, not a proof surface, so a caller that needs an App-verified check
 * run must be told plainly whether it got one. Returns `true` only when the
-* App-owned check run landed. Throws when Factory App access is fail-closed
-* (missing mint or Cursor OIDC exchange, #949): `pr:ready` must not notice
-* that miss and exit 0. An optional-App skip still returns `false`.
+* App-owned check run landed. Throws {@link FactoryAppUnevaluableError} when
+* Factory App access is fail-closed (missing mint or Cursor OIDC exchange,
+* #949): `pr:ready` must not notice that miss and exit 0, and must not publish
+* a red check that reads as candidate refusal (#1125). An optional-App skip
+* still returns `false`.
 *
 * "Landed" means GitHub serves it, not that the POST was accepted (#520). On
 * PR #519 the POST was accepted, `pr:ready` reported ready and armed, and the
@@ -6867,7 +7645,7 @@ async function ensureFactoryCheckRunPublished(input, dependencies = {}) {
 	const access = await resolveFactoryAppAccess(input, dependencies);
 	if (access.kind !== "ok") {
 		onDiagnostic?.(`${checkName}: ${access.message}`);
-		if (access.failClosed) throw new Error(`${checkName}: ${access.message.trim()}`);
+		if (access.failClosed) throw new FactoryAppUnevaluableError(`${checkName}: ${access.message.trim()}`);
 		return false;
 	}
 	try {
@@ -7498,6 +8276,7 @@ const prVerifySchemaVersionSchema = z.literal(4);
 const prVerifyProofSchema = z.object({
 	authoringSession: z.string().trim().min(1),
 	base: z.string().min(1),
+	baseSha: z.string().regex(/^[0-9a-f]{40}$/u).optional(),
 	baselineFullProofs: z.array(z.object({
 		base: z.string().min(1),
 		changedFiles: z.array(z.string()),
@@ -8115,8 +8894,10 @@ function defaultPrVerifyGit() {
 		changedFiles,
 		currentHeadSha,
 		emptyTreeHash,
+		fetchOriginRef,
 		mergeBaseSha,
 		recognizeCatchUp: recognizeCatchUpCandidate,
+		resolveCommitSha,
 		runVerificationCommand(command, cwd, env) {
 			return verificationOutcomeOf(runInheritedTee("bash", ["-lc", withPinnedNodeOnPath(command, path.dirname(process.execPath))], cwd, env));
 		},
@@ -8150,10 +8931,11 @@ function baselineFullProofsForDocsOnly({ previousProof, profilePath, projectKey,
 		seedFilter: matchesProfile
 	});
 }
-function buildPrVerifyProof({ authoringSession, base, baselineFullProofs, catchUpRecognition, classification, commands, endedAt, executedCommands, files, headSha, impactStamp, mode, mergeBaseSha: proofMergeBaseSha, notRequiredCommands, outcome, patchId, policyResolution, profilePath, projectKey, repository, startedAt }) {
+function buildPrVerifyProof({ authoringSession, base, baseSha, baselineFullProofs, catchUpRecognition, classification, commands, endedAt, executedCommands, files, headSha, impactStamp, mode, mergeBaseSha: proofMergeBaseSha, notRequiredCommands, outcome, patchId, policyResolution, profilePath, projectKey, repository, startedAt }) {
 	return {
 		authoringSession,
 		base,
+		baseSha,
 		...baselineFullProofs ? { baselineFullProofs } : {},
 		...catchUpRecognition ? { catchUpRecognition } : {},
 		changedFiles: files,
@@ -8245,18 +9027,30 @@ function runPrVerify(args, dependencies = {}) {
 		cwd,
 		profilePath: args.profilePath
 	});
-	const files = git.changedFiles(cwd, args.base);
+	const pullRequestLookup = (dependencies.lookupPullRequestBase ?? lookupLivePullRequestBase)(cwd);
+	const base = resolveCandidateBase({
+		cwd,
+		dependencies: {
+			fetchOriginRef: git.fetchOriginRef ?? fetchOriginRef,
+			liveBranchTipSha: dependencies.liveBranchTipSha ?? liveBranchTipSha,
+			lookupPullRequestBase: () => pullRequestLookup,
+			resolveCommitSha: git.resolveCommitSha ?? resolveCommitSha
+		},
+		requestedBase: args.base
+	});
+	console.log(`pr:verify ${describeCandidateBase(base)}`);
+	const files = git.changedFiles(cwd, base.sha);
 	const relativeProfile = repositoryRelativeProfilePath({
 		cwd,
 		profilePath
 	});
 	const { headSha, mergeBaseSha: proofMergeBaseSha, patchId } = resolveCandidateIdentity({
-		base: args.base,
+		base: base.sha,
 		cwd,
 		git
 	});
 	const catchUpRecognitionResult = (git.recognizeCatchUp ?? recognizeCatchUpCandidate)({
-		base: args.base,
+		base: base.sha,
 		cwd
 	});
 	const catchUpRecognition = catchUpRecognitionResult.recognized ? catchUpRecognitionResult.recognition : void 0;
@@ -8279,17 +9073,17 @@ function runPrVerify(args, dependencies = {}) {
 	});
 	const { policyResolution } = resolveStageReviewDemand({
 		authority: dependencies.basePolicy ?? defaultBaseReviewPolicyAuthority(),
-		callerBaseRef: args.base,
+		callerBaseRef: base.ref,
 		candidatePolicy: profile.review,
 		changedFiles: files,
 		cwd,
-		lookupPullRequest: dependencies.lookupPullRequest ?? lookupCandidatePullRequest,
+		lookupPullRequest: dependencies.lookupPullRequest ?? (() => policyLookupFromBaseLookup(pullRequestLookup)),
 		profilePath: relativeProfile,
 		readCheckoutRepository: git.checkoutRepository ?? checkoutRepository
 	});
 	const rootSharedGlobs = [...DEFAULT_ROOT_SHARED_GLOBS, relativeProfile];
 	const context = createVerificationRunContext({
-		baseRef: args.base,
+		baseRef: base.sha,
 		changedFiles: files,
 		fullSuiteBaseRef: git.emptyTreeHash(cwd),
 		rootSharedGlobs
@@ -8351,7 +9145,8 @@ function runPrVerify(args, dependencies = {}) {
 	};
 	const proofContext = {
 		authoringSession,
-		base: args.base,
+		base: base.ref,
+		baseSha: base.sha,
 		policyResolution,
 		...catchUpRecognition ? { catchUpRecognition } : {},
 		classification,
@@ -8464,7 +9259,7 @@ function runPrVerify(args, dependencies = {}) {
 			if (!command.requiredCheck) continue;
 			if (scopedOutNames.has(command.name)) continue;
 			runEvidenceEmit({
-				base: args.base,
+				base: base.sha,
 				check: command.requiredCheck,
 				cwd,
 				outcome: "pass",
@@ -8662,246 +9457,24 @@ const blockedReasonIssues = (proof) => {
 	if (named.length !== reasons.length) return blockedReasonIssue(`blockedReasons must name every blocking reason: ${reasons.length} reason(s), ${named.length} named`);
 	const drifted = named.findIndex((reason, index) => reason.detail !== blockedReasonDetail(reasons[index]));
 	return drifted === -1 ? [] : blockedReasonIssue(`blockedReasons[${drifted}] does not carry blocking reason ${drifted}; the two projections must tell one story`);
-};
-//#endregion
-//#region src/packages/review-prompt-sections/schema.ts
-const REVIEW_PROMPT_SECTION_PROVENANCES = [
-	"coding-standards",
-	"prior-review-ledger",
-	"issue-review-focus"
-];
-const nonBlankString$2 = z.string().refine((value) => value.trim().length > 0, { message: "must not be blank" });
-const reviewPromptSectionSchema = z.object({
-	provenance: z.enum(REVIEW_PROMPT_SECTION_PROVENANCES),
-	source: nonBlankString$2,
-	text: nonBlankString$2
-}).strict();
-const promptSectionRank = (section) => REVIEW_PROMPT_SECTION_PROVENANCES.indexOf(section.provenance);
-const hasDuplicateProvenance = (sections) => new Set(sections.map((section) => section.provenance)).size !== sections.length;
-const isOutOfAssemblyOrder = (sections) => sections.some((section, index) => index > 0 && promptSectionRank(section) < promptSectionRank(sections[index - 1]));
-const reviewPromptSectionsSchema = z.array(reviewPromptSectionSchema).min(1).refine((sections) => !hasDuplicateProvenance(sections) && !isOutOfAssemblyOrder(sections), { message: "prompt sections must be in assembly order without duplicates" });
-//#endregion
-//#region src/review-ladder-ledger.ts
-const CYCLE_2_SEVERITY_FLOOR_REFERENCE = "cycle-2-severity-floor";
-const normalizeCitedSpan = (text) => text.split(/\r?\n/u).map((line) => line.trim().replaceAll(/\s+/gu, " ")).filter((line) => line.length > 0).join("\n");
-const PRESCRIBED_ACTION_STOPWORDS = new Set([
-	"a",
-	"an",
-	"the",
-	"to",
-	"of",
-	"in",
-	"on",
-	"and",
-	"or",
-	"is",
-	"are",
-	"be",
-	"this",
-	"that",
-	"it",
-	"for",
-	"with",
-	"as",
-	"by",
-	"from",
-	"at",
-	"into",
-	"should",
-	"must",
-	"will",
-	"would",
-	"can",
-	"could",
-	"not",
-	"but",
-	"so",
-	"if",
-	"then",
-	"than",
-	"when",
-	"which",
-	"who",
-	"whom",
-	"its",
-	"their",
-	"there",
-	"here",
-	"also",
-	"use",
-	"using",
-	"instead",
-	"rather",
-	"than",
-	"over",
-	"up",
-	"out",
-	"have",
-	"has",
-	"had",
-	"been"
-]);
-const tokenizePrescribedAction = (text) => {
-	const words = text.toLowerCase().replaceAll(/[^a-z0-9\s]/gu, " ").split(/\s+/u).filter((word) => word.length > 0 && !PRESCRIBED_ACTION_STOPWORDS.has(word));
-	return [...new Set(words)].toSorted();
-};
-const normalizeTitle = (title) => title.trim().toLowerCase().replaceAll(/\s+/gu, " ");
-const normalizeFile = (file) => file.trim();
-const findingKey = (finding) => {
-	const path = finding.file ?? "";
-	const normalizedSpan = normalizeCitedSpan(finding.citedSpan ?? "");
-	const actionTokens = tokenizePrescribedAction(finding.prescribedAction ?? "");
-	const legacyDiscriminator = normalizedSpan.length > 0 || actionTokens.length > 0 ? "" : normalizeTitle(finding.title ?? "");
-	return sha256Hex(`${path}\0${sha256Hex(normalizedSpan)}\0${actionTokens.join(" ")}\0${legacyDiscriminator}`);
-};
-const declarationMatchesEntry = (entry, target) => normalizeTitle(entry.title) === normalizeTitle(target.title) && (target.file === void 0 || entry.file !== void 0 && normalizeFile(entry.file) === normalizeFile(target.file));
-const applyDisposition = (ledger, declaration) => {
-	const entry = declaration.findingReport ? resolveEntryForFinding([...ledger.values()], declaration.findingReport) : [...ledger.values()].find((candidate) => declarationMatchesEntry(candidate, declaration.finding));
-	if (!entry) return false;
-	entry.disposition = declaration.disposition;
-	entry.priorDisposition = void 0;
-	if (declaration.reference !== void 0) entry.reference = declaration.reference;
-	return true;
-};
-const definedAttributes = (finding) => Object.fromEntries([
-	"blockingAfterCap",
-	"category",
-	"citedSpan",
-	"file",
-	"prescribedAction",
-	"priority"
-].flatMap((attribute) => finding[attribute] === void 0 ? [] : [[attribute, finding[attribute]]]));
-const toLadderFindingReport = (finding) => ({
-	...definedAttributes(finding),
-	...finding.supersedes ? { supersedes: finding.supersedes } : {},
-	title: finding.title
-});
-const MIN_MEANINGFUL_OVERLAP_LINE_LENGTH = 20;
-const spansOverlap = (a, b) => {
-	if (a.length === 0 || b.length === 0) return false;
-	if (a === b || a.includes(b) || b.includes(a)) return true;
-	const linesA = new Set(a.split("\n").filter((line) => line.length >= MIN_MEANINGFUL_OVERLAP_LINE_LENGTH));
-	return b.split("\n").some((line) => line.length >= MIN_MEANINGFUL_OVERLAP_LINE_LENGTH && linesA.has(line));
-};
-const resolveEntryForFinding = (entries, finding) => {
-	const primaryKey = findingKey(finding);
-	const exact = entries.find((entry) => entry.key === primaryKey);
-	if (exact) return exact;
-	const { supersedes } = finding;
-	if (supersedes) {
-		const superseded = entries.find((entry) => declarationMatchesEntry(entry, supersedes));
-		if (superseded) return superseded;
-	}
-	if (finding.file !== void 0 && finding.citedSpan !== void 0) {
-		const candidateSpan = normalizeCitedSpan(finding.citedSpan);
-		if (candidateSpan.length > 0) {
-			const overlapping = entries.find((entry) => entry.disposition === "open" && entry.file === finding.file && entry.citedSpan !== void 0 && spansOverlap(normalizeCitedSpan(entry.citedSpan), candidateSpan));
-			if (overlapping) return overlapping;
-		}
-	}
-};
-const REFLAG_TRANSITIONS = {
-	"fixed-in-thread": (entry) => {
-		entry.disposition = "open";
-		entry.reopenedCount += 1;
-	},
-	"follow-up-filed": (entry) => {
-		entry.priorDisposition = entry.disposition;
-		entry.disposition = "stale-repeat";
-		entry.staleRepeatCount += 1;
-	},
-	open: () => {},
-	"rerun-noise": (entry) => {
-		entry.staleRepeatCount += 1;
-	},
-	"stale-repeat": (entry) => {
-		entry.staleRepeatCount += 1;
-	},
-	waived: (entry) => {
-		entry.priorDisposition = entry.disposition;
-		entry.disposition = "stale-repeat";
-		entry.staleRepeatCount += 1;
-	}
-};
-const applyFlag = (ledger, finding, ref, demoteNew) => {
-	const matched = resolveEntryForFinding([...ledger.values()], finding);
-	if (!matched) {
-		const key = findingKey(finding);
-		ledger.set(key, {
-			...definedAttributes(finding),
-			disposition: demoteNew ? "rerun-noise" : "open",
-			firstFlagged: ref,
-			flagCount: 1,
-			key,
-			lastFlagged: ref,
-			reopenedCount: 0,
-			staleRepeatCount: 0,
-			title: finding.title.trim()
-		});
-		return;
-	}
-	matched.flagCount += 1;
-	matched.lastFlagged = ref;
-	Object.assign(matched, definedAttributes(finding));
-	REFLAG_TRANSITIONS[matched.disposition](matched);
-};
-const findingKeySet = (findings) => new Set(findings.map((finding) => findingKey(finding)));
-const isSameHeadRerun = (previous, current) => previous?.identity !== void 0 && current.identity !== void 0 && evidenceFresh({
-	candidate: current.identity,
-	recorded: previous.identity,
-	rule: "patch-id"
-});
-const isDisjointSameHeadRerun = (previous, current) => {
-	if (current.correlatedRerun) return false;
-	if (!isSameHeadRerun(previous, current) || previous?.findings.length === 0 || current.findings.length === 0) return false;
-	const previousKeys = findingKeySet(previous?.findings ?? []);
-	return current.findings.every((finding) => !previousKeys.has(findingKey(finding)));
-};
-const foldLedger = (cycles, refs) => {
-	const ledger = /* @__PURE__ */ new Map();
-	const unmatchedDispositions = [];
-	for (const [index, entry] of cycles.entries()) {
-		const dispositions = entry.dispositions ?? [];
-		const severityFloorDispositions = dispositions.filter((declaration) => declaration.findingReport !== void 0);
-		for (const declaration of dispositions.filter((candidate) => candidate.findingReport === void 0)) if (!applyDisposition(ledger, declaration)) unmatchedDispositions.push(declaration);
-		const demoteNew = isDisjointSameHeadRerun(cycles[index - 1], entry);
-		for (const finding of entry.findings) applyFlag(ledger, finding, refs[index], demoteNew);
-		for (const declaration of severityFloorDispositions) if (!applyDisposition(ledger, declaration)) unmatchedDispositions.push(declaration);
-	}
-	return {
-		ledger,
-		unmatchedDispositions
-	};
-};
-const openLadderFindings = (ledger) => ledger.filter((entry) => entry.disposition === "open");
-const blockingLadderFindings = (ledger) => openLadderFindings(ledger).filter((entry) => resolveFindingBlocking(entry, entry.disposition));
-const staleRepeatLadderFindings = (ledger) => ledger.filter((entry) => entry.disposition === "stale-repeat");
-const inferFixedInThreadDispositions = (ledger, findings, options = {}) => {
-	if (options.sameHeadAsPriorCycle) return [];
-	const flaggedKeys = new Set(findings.map((finding) => {
-		const match = resolveEntryForFinding(ledger, finding);
-		return match ? match.key : findingKey(finding);
-	}));
-	return openLadderFindings(ledger).filter((entry) => !flaggedKeys.has(entry.key)).map((entry) => ({
-		disposition: "fixed-in-thread",
-		finding: {
-			title: entry.title,
-			...entry.file === void 0 ? {} : { file: entry.file }
-		}
-	}));
-};
-const ladderDispositionDeclarationsSchema = z.array(z.object({
-	disposition: z.enum([
-		"fixed-in-thread",
-		"follow-up-filed",
-		"waived"
-	]),
-	finding: z.object({
-		file: z.string().min(1).optional(),
-		title: z.string().min(1)
-	}).strict(),
-	reference: z.string().min(1).optional()
-}).strict());
+};
+//#endregion
+//#region src/packages/review-prompt-sections/schema.ts
+const REVIEW_PROMPT_SECTION_PROVENANCES = [
+	"coding-standards",
+	"prior-review-ledger",
+	"issue-review-focus"
+];
+const nonBlankString$2 = z.string().refine((value) => value.trim().length > 0, { message: "must not be blank" });
+const reviewPromptSectionSchema = z.object({
+	provenance: z.enum(REVIEW_PROMPT_SECTION_PROVENANCES),
+	source: nonBlankString$2,
+	text: nonBlankString$2
+}).strict();
+const promptSectionRank = (section) => REVIEW_PROMPT_SECTION_PROVENANCES.indexOf(section.provenance);
+const hasDuplicateProvenance = (sections) => new Set(sections.map((section) => section.provenance)).size !== sections.length;
+const isOutOfAssemblyOrder = (sections) => sections.some((section, index) => index > 0 && promptSectionRank(section) < promptSectionRank(sections[index - 1]));
+const reviewPromptSectionsSchema = z.array(reviewPromptSectionSchema).min(1).refine((sections) => !hasDuplicateProvenance(sections) && !isOutOfAssemblyOrder(sections), { message: "prompt sections must be in assembly order without duplicates" });
 //#endregion
 //#region src/review-ladder.ts
 const LADDER_NEXT_ACTION_KINDS = [
@@ -8963,7 +9536,7 @@ const resolveLadderPosition = ({ blockingFindings, gateCount, openFindings, poli
 	};
 	return {
 		forcedTransition: {
-			blockingFindings: blockingFindings.map((entry) => entry.key),
+			blockingFindings: blockingFindings.map((entry) => entry.address),
 			cap,
 			kind: "gate-cap-exhausted"
 		},
@@ -9001,7 +9574,7 @@ const eventFor = ({ cycles, openFindings, blockingFindings, position, staleRepea
 };
 const evaluateReviewLadder = ({ cycles, policy }) => {
 	const refs = ladderCycleRefsFor(cycles);
-	const { ledger, unmatchedDispositions } = foldLedger(cycles, refs);
+	const { ledger, occurrences } = foldLedger(cycles, refs);
 	const ledgerEntries = [...ledger.values()];
 	const openFindings = openLadderFindings(ledgerEntries);
 	const blockingFindings = blockingLadderFindings(ledgerEntries);
@@ -9029,18 +9602,349 @@ const evaluateReviewLadder = ({ cycles, policy }) => {
 			staleRepeats
 		}),
 		ledger: ledgerEntries,
-		unmatchedDispositions
+		occurrences
+	};
+};
+//#endregion
+//#region src/review-policy-declarations.ts
+const identityRepeatDeclarations = (occurrences, cycleIndex) => occurrences.flatMap((occurrence) => {
+	if (cycleOfAddress(occurrence.address) !== cycleIndex || occurrence.root === occurrence.address) return [];
+	const disposition = IDENTITY_REPEAT_DISPOSITION[projectedGroupDisposition(occurrences.filter((member) => member.root === occurrence.root && cycleOfAddress(member.address) < cycleIndex))];
+	return disposition === void 0 ? [] : [{
+		authority: "policy",
+		disposition,
+		rule: "identity-repeat",
+		target: occurrence.address
+	}];
+});
+const severityFloorDeclarations = (occurrences, liveCycleCount) => {
+	if (liveCycleCount < 2) return [];
+	return occurrences.flatMap((occurrence) => {
+		const severity = resolveReviewFindingSeverity(occurrence.finding.priority);
+		return occurrence.disposition === "open" && (severity === "medium" || severity === "low") ? [{
+			authority: "policy",
+			disposition: "policy-accepted",
+			rule: "cycle-2-severity-floor",
+			target: occurrence.address
+		}] : [];
+	});
+};
+//#endregion
+//#region src/review-proof-import.ts
+const REVIEW_PROOF_IMPORT_REFERENCE = "schema-2 import: declaration recorded without a reference";
+const CYCLE_2_SEVERITY_FLOOR_REFERENCE = "cycle-2-severity-floor";
+const legacyFindingSchema = z.object({
+	blockingAfterCap: z.boolean().optional(),
+	category: z.string().optional(),
+	citedSpan: z.string().optional(),
+	file: z.string().optional(),
+	prescribedAction: z.string().optional(),
+	priority: z.string().optional(),
+	supersedes: z.object({
+		file: z.string().optional(),
+		title: z.string()
+	}).passthrough().optional(),
+	title: z.string()
+}).passthrough();
+const legacyDeclarationSchema = z.object({
+	disposition: z.enum([
+		"fixed-in-thread",
+		"follow-up-filed",
+		"waived"
+	]),
+	finding: z.object({
+		file: z.string().optional(),
+		title: z.string()
+	}).passthrough(),
+	findingReport: legacyFindingSchema.optional(),
+	reference: z.string().optional()
+}).passthrough();
+const legacyCycleSchema = z.object({
+	correlatedRerun: z.boolean().optional(),
+	dispositions: z.array(legacyDeclarationSchema).optional(),
+	engine: z.string().optional(),
+	findings: z.array(legacyFindingSchema),
+	historical: z.literal(true).optional(),
+	identity: z.object({
+		headSha: z.string(),
+		patchId: z.string()
+	}).passthrough().optional(),
+	model: z.string().optional(),
+	session: z.record(z.string(), z.unknown()).optional(),
+	stage: z.enum(["interior", "gate"]),
+	usage: z.record(z.string(), z.unknown()).optional()
+}).passthrough();
+const legacyLadderSchema = z.object({ cycles: z.array(legacyCycleSchema) }).passthrough();
+const MIN_MEANINGFUL_OVERLAP_LINE_LENGTH = 20;
+const spansOverlap = (a, b) => {
+	if (a.length === 0 || b.length === 0) return false;
+	if (a === b || a.includes(b) || b.includes(a)) return true;
+	const linesA = new Set(a.split("\n").filter((line) => line.length >= MIN_MEANINGFUL_OVERLAP_LINE_LENGTH));
+	return b.split("\n").some((line) => line.length >= MIN_MEANINGFUL_OVERLAP_LINE_LENGTH && linesA.has(line));
+};
+const resolveLegacyEntry = (entries, finding) => {
+	const primaryKey = findingKey(finding);
+	const exact = entries.find((entry) => entry.key === primaryKey);
+	if (exact) return exact;
+	const { supersedes } = finding;
+	if (supersedes) {
+		const superseded = entries.find((entry) => declarationMatchesEntry(entry, supersedes));
+		if (superseded) return superseded;
+	}
+	if (finding.file !== void 0 && finding.citedSpan !== void 0) {
+		const candidateSpan = normalizeCitedSpan(finding.citedSpan);
+		if (candidateSpan.length > 0) return entries.find((entry) => entry.disposition === "open" && entry.file === finding.file && entry.citedSpan !== void 0 && spansOverlap(normalizeCitedSpan(entry.citedSpan), candidateSpan));
+	}
+};
+const LEGACY_REFLAG = {
+	"fixed-in-thread": "open",
+	"follow-up-filed": "stale-repeat",
+	open: "open",
+	"rerun-noise": "rerun-noise",
+	"stale-repeat": "stale-repeat",
+	waived: "stale-repeat"
+};
+const isDisjointSameHeadRerun = (previous, current) => {
+	if (current.correlatedRerun || previous?.identity === void 0 || current.identity === void 0 || previous.identity.patchId !== current.identity.patchId || previous.findings.length === 0 || current.findings.length === 0) return false;
+	const previousKeys = new Set(previous.findings.map((finding) => findingKey(finding)));
+	return current.findings.every((finding) => !previousKeys.has(findingKey(finding)));
+};
+const applyLegacyDeclaration = (entries, declaration) => {
+	const entry = declaration.findingReport ? resolveLegacyEntry(entries, declaration.findingReport) : entries.find((candidate) => declarationMatchesEntry(candidate, declaration.finding));
+	if (entry) entry.disposition = declaration.disposition;
+};
+const isFloorDeclaration = (declaration) => declaration.findingReport !== void 0 && declaration.reference === CYCLE_2_SEVERITY_FLOOR_REFERENCE;
+const outcomeFor = (entries, declaration) => {
+	const matches = entries.filter((entry) => declarationMatchesEntry(entry, declaration.finding));
+	if (matches.length !== 1) return {
+		candidates: matches.flatMap((entry) => entry.members),
+		kind: "refused",
+		reason: matches.length === 0 ? "title+file matches no entry" : `title+file matches ${matches.length} entries`
+	};
+	const [entry] = matches;
+	if (!entry) throw new Error("unreachable: one match");
+	if (entry.keys.size !== 1) return {
+		candidates: [...entry.members],
+		kind: "refused",
+		reason: `the matched entry absorbed ${entry.keys.size} distinct finding keys (${entry.members.join(", ")}); the schema-2 outcome was similarity-grounded`
+	};
+	return {
+		kind: "converted",
+		targets: [...entry.members]
+	};
+};
+const replayLegacyFold = (cycles) => {
+	const entries = [];
+	return cycles.map((cycle, cycleIndex) => {
+		const decided = [];
+		const stored = cycle.dispositions ?? [];
+		const beforeFlags = stored.filter((declaration) => declaration.findingReport === void 0);
+		const afterFlags = stored.filter((declaration) => declaration.findingReport !== void 0);
+		for (const declaration of beforeFlags) {
+			decided.push({
+				declaration,
+				outcome: outcomeFor(entries, declaration)
+			});
+			applyLegacyDeclaration(entries, declaration);
+		}
+		const demoteNew = isDisjointSameHeadRerun(cycles[cycleIndex - 1], cycle);
+		for (const [findingIndex, raw] of cycle.findings.entries()) {
+			const finding = toLadderFindingReport(raw);
+			const address = occurrenceAddress(cycleIndex + 1, findingIndex + 1);
+			const key = findingKey(finding);
+			const matched = resolveLegacyEntry(entries, finding);
+			if (matched) {
+				matched.members.push(address);
+				matched.keys.add(key);
+				if (finding.citedSpan !== void 0) matched.citedSpan = finding.citedSpan;
+				if (finding.file !== void 0) matched.file = finding.file;
+				matched.disposition = LEGACY_REFLAG[matched.disposition];
+				continue;
+			}
+			entries.push({
+				...finding.citedSpan === void 0 ? {} : { citedSpan: finding.citedSpan },
+				disposition: demoteNew ? "rerun-noise" : "open",
+				...finding.file === void 0 ? {} : { file: finding.file },
+				key,
+				keys: new Set([key]),
+				members: [address],
+				title: finding.title.trim()
+			});
+		}
+		for (const declaration of afterFlags) {
+			if (!isFloorDeclaration(declaration)) decided.push({
+				declaration,
+				outcome: outcomeFor(entries, declaration)
+			});
+			applyLegacyDeclaration(entries, declaration);
+		}
+		return { declarations: decided };
+	});
+};
+const convertedDeclaration = (declaration, target) => ({
+	authority: "operator",
+	disposition: declaration.disposition,
+	reference: declaration.reference ?? REVIEW_PROOF_IMPORT_REFERENCE,
+	target
+});
+const isUnattestedFix = (declaration) => declaration.disposition === "fixed-in-thread" && declaration.reference === void 0 && declaration.findingReport === void 0;
+const INFERRED_FIX_REASON = "a fixed-in-thread the schema-2 writer inferred from absence on a blocking-severity occurrence is not a verified fix";
+const unattestedFixOutcome = (target, finding) => {
+	const severity = resolveReviewFindingSeverity(finding?.priority);
+	return severity === "medium" || severity === "low" ? {
+		authority: "policy",
+		disposition: "policy-accepted",
+		rule: "schema-2-import",
+		target
+	} : void 0;
+};
+const recoveryItem = (declaration, cycle, outcome) => ({
+	candidates: outcome.candidates,
+	cycle,
+	declaration: {
+		disposition: declaration.disposition,
+		...declaration.finding.file === void 0 ? {} : { file: declaration.finding.file },
+		...declaration.reference === void 0 ? {} : { reference: declaration.reference },
+		title: declaration.finding.title
+	},
+	reason: outcome.reason
+});
+const convertCycles = (legacy, proofDigest) => {
+	const replay = replayLegacyFold(legacy);
+	const cycles = [];
+	const recovery = [];
+	let liveCycleCount = 0;
+	for (const [index, cycle] of legacy.entries()) {
+		const cycleIndex = index + 1;
+		if (!(cycle.historical === true)) liveCycleCount += 1;
+		const findings = cycle.findings.map((finding) => toLadderFindingReport(finding));
+		const occurrences = occurrencesForCycle({
+			cycleIndex,
+			declaredCycle: ladderCycleRefsFor([...cycles, { stage: cycle.stage }]).at(-1)?.cycle ?? cycleIndex,
+			findings,
+			priorCycles: cycles
+		});
+		const findingAt = (address) => {
+			const groups = /^c(?<cycle>\d+)f(?<finding>\d+)$/u.exec(address)?.groups;
+			const at = Number(groups?.cycle) - 1;
+			return (at === index ? findings : cycles[at]?.findings)?.[Number(groups?.finding) - 1];
+		};
+		const explicit = [];
+		for (const { declaration, outcome } of replay[index]?.declarations ?? []) {
+			if (outcome.kind === "refused") {
+				recovery.push(recoveryItem(declaration, cycleIndex, outcome));
+				continue;
+			}
+			for (const target of outcome.targets) {
+				if (!isUnattestedFix(declaration)) {
+					explicit.push(convertedDeclaration(declaration, target));
+					continue;
+				}
+				const accepted = unattestedFixOutcome(target, findingAt(target));
+				if (accepted) explicit.push(accepted);
+				else recovery.push(recoveryItem(declaration, cycleIndex, {
+					candidates: [target],
+					kind: "refused",
+					reason: INFERRED_FIX_REASON
+				}));
+			}
+		}
+		const cycleWith = (declarations) => {
+			const recording = {
+				declarations,
+				imported: {
+					proofDigest,
+					schemaVersion: 2
+				},
+				occurrences
+			};
+			const { correlatedRerun: _correlatedRerun, dispositions: _dispositions, findings: _findings, ...rest } = cycle;
+			return {
+				...rest,
+				findings,
+				recording
+			};
+		};
+		const foldWith = (candidate) => {
+			const all = [...cycles, candidate];
+			return foldLedger(all, ladderCycleRefsFor(all)).occurrences;
+		};
+		const repeats = identityRepeatDeclarations(foldWith(cycleWith(explicit)), cycleIndex);
+		const floor = severityFloorDeclarations(foldWith(cycleWith([...explicit, ...repeats])), liveCycleCount);
+		cycles.push(cycleWith([
+			...explicit,
+			...repeats,
+			...floor
+		]));
+	}
+	return {
+		cycles,
+		recovery
+	};
+};
+/**
+* The operator-facing readout of a proof's unconverted declarations: one line
+* per item naming the declaration, why it was refused and the candidate
+* addresses `pr:review --dispositions` can name. Printed by pr:review,
+* pr:ready and the admission preflight (doctor) alike.
+*/
+const describeRecoveryRequired = (items) => items.map((item) => `Recovery required: schema-2 declaration ${item.declaration.disposition} "${item.declaration.title}"${item.declaration.file === void 0 ? "" : ` in ${item.declaration.file}`} (cycle ${item.cycle}) needs re-declaring by address; candidates: ${item.candidates.length === 0 ? "none" : item.candidates.join(", ")}. It could not be converted: ${item.reason}. Use pr:review --dispositions on the next recording; the proof admits nothing until then.`);
+/** The digest of a proof as the factory serializes it. */
+const proofSerializationDigest = (raw) => sha256Hex(`${JSON.stringify(raw, null, 2)}\n`);
+/**
+* Convert a schema-2 proof value into the schema-3 shape. `proofDigest` names
+* the original bytes (retained by the recording path for audit); when the
+* caller holds no bytes, the digest of the factory serialization stands in.
+* The result still goes through the schema-3 validator.
+*/
+const importSchema2Proof = (raw, proofDigest = proofSerializationDigest(raw)) => {
+	const parsed = z.object({
+		ladder: legacyLadderSchema.optional(),
+		schemaVersion: z.literal(2)
+	}).passthrough().safeParse(raw);
+	if (!parsed.success) throw new TypeError(`Invalid pr:review proof JSON: schema-2 proof cannot be imported: ${parsed.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ")}`);
+	const { ladder, ...rest } = parsed.data;
+	if (!ladder) {
+		const { schemaVersion: _legacyVersion, ...fields } = rest;
+		return {
+			...fields,
+			schemaVersion: 3
+		};
+	}
+	const { cycles, recovery } = convertCycles(ladder.cycles, proofDigest);
+	evaluateReviewLadder({
+		cycles,
+		policy: { gate: { cap: 1 } }
+	});
+	const { schemaVersion: _legacyVersion, ...fields } = rest;
+	return {
+		...fields,
+		importedFrom: {
+			proofDigest,
+			schemaVersion: 2
+		},
+		ladder: { cycles },
+		recoveryRequired: recovery,
+		schemaVersion: 3
 	};
 };
 //#endregion
 //#region src/pr-readiness/ladder-proof-state.ts
-const prReviewLadderStateSchema = z.object({ cycles: z.array(z.custom()) }).superRefine((ladder, context) => {
+const persistedCycleSchema = z.custom((cycle) => typeof cycle === "object" && cycle !== null, "ladder cycle must be an object").superRefine((cycle, context) => {
+	const parsed = reviewCycleRecordingSchema.safeParse(cycle.recording);
+	if (!parsed.success) context.addIssue({
+		code: "custom",
+		message: `ladder cycle carries no valid recording (schema 3): ${parsed.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ")}`,
+		path: ["recording"]
+	});
+});
+const prReviewLadderStateSchema = z.object({ cycles: z.array(persistedCycleSchema) }).superRefine((ladder, context) => {
 	try {
 		ladderLedgerFor(ladder);
-	} catch {
+	} catch (error) {
 		context.addIssue({
 			code: "custom",
-			message: "ladder cycles do not fold into a valid disposition ledger"
+			message: `ladder cycles do not fold into a valid disposition ledger: ${error instanceof Error ? error.message : String(error)}`
 		});
 	}
 });
@@ -9102,13 +10006,12 @@ const openStateFromReviews = (reviews) => {
 		openEntries
 	};
 };
-const openStateForCycle = (proof, epoch, adjudicatedLedger) => {
-	if (adjudicatedLedger) return openStateFromLedger(adjudicatedLedger);
+const openStateForCycle = (proof, epoch) => {
 	if (epoch.kind === "ladder") return epoch.snapshot ? epoch.snapshot.cycleState : openStateFromLadder(epoch.ladder);
 	return openStateFromReviews(proof.reviews);
 };
-const reviewCycleStateForEpoch = (proof, epoch, adjudicatedLedger) => {
-	const openState = openStateForCycle(proof, epoch, adjudicatedLedger);
+const reviewCycleStateForEpoch = (proof, epoch) => {
+	const openState = openStateForCycle(proof, epoch);
 	const countsBySeverity = countFindingsBySeverity(openState.openEntries);
 	const highestOpenSeverity = REVIEW_SEVERITIES.find((severity) => countsBySeverity[severity] > 0);
 	const countsByBlockingSeverity = countFindingsBySeverity(openState.blockingEntries);
@@ -9128,7 +10031,7 @@ const reviewCycleStateForEpoch = (proof, epoch, adjudicatedLedger) => {
 		windowExhausted
 	};
 };
-const reviewCycleStateFor = (proof, policy, adjudicatedLedger) => reviewCycleStateForEpoch(proof, reviewEpochModeFor(proof, policy), adjudicatedLedger);
+const reviewCycleStateFor = (proof, policy) => reviewCycleStateForEpoch(proof, reviewEpochModeFor(proof, policy));
 const reviewAcceptedAfterCycleCap = (proof, review) => {
 	if (review.outcome !== "failed") return false;
 	const state = reviewCycleStateFor({
@@ -9137,51 +10040,40 @@ const reviewAcceptedAfterCycleCap = (proof, review) => {
 	});
 	return state.windowExhausted && state.autoBlockingFindings === 0;
 };
-const ladderRefoldDisagreement = (epoch) => {
-	if (epoch.kind !== "ladder") return {
-		autoBlockingFindings: 0,
-		unmatchedDispositions: 0
-	};
-	if (epoch.snapshot) return {
-		autoBlockingFindings: epoch.snapshot.cycleState.autoBlockingFindings,
-		unmatchedDispositions: epoch.snapshot.evaluation.unmatchedDispositions.length
-	};
-	const { ledger, unmatchedDispositions } = foldLedger(epoch.ladder.cycles, ladderCycleRefsFor(epoch.ladder.cycles));
-	return {
-		autoBlockingFindings: blockingLadderFindings([...ledger.values()]).length,
-		unmatchedDispositions: unmatchedDispositions.length
-	};
+const concealedBlockingFindings = (epoch) => {
+	if (epoch.kind !== "ladder") return 0;
+	if (epoch.snapshot) return epoch.snapshot.cycleState.autoBlockingFindings;
+	return blockingLadderFindings(ladderLedgerFor(epoch.ladder)).length;
 };
 const resolveReviewAcceptanceForEpoch = (proof, review, epoch) => {
-	if (review.outcome === "passed") {
-		const disagreement = ladderRefoldDisagreement(epoch);
-		if (disagreement.autoBlockingFindings > 0 || disagreement.unmatchedDispositions > 0) return "blocked";
-		return "accepted-clean";
-	}
+	if (proof.recoveryRequired !== void 0 && proof.recoveryRequired.length > 0) return "recovery-required";
+	if (review.outcome === "passed") return concealedBlockingFindings(epoch) > 0 ? "blocked" : "accepted-clean";
 	if (review.outcome !== "failed") return "blocked";
 	if (epoch.kind === "ladder" && epoch.snapshot && reviewAcceptedThroughSnapshot(epoch.snapshot)) return "accepted-through-ladder";
 	if (epoch.kind === "declared-window" && reviewAcceptedAfterCycleCap(proof, review)) return "accepted-after-cap";
 	return "blocked";
 };
 const resolveReviewAcceptance = (proof, review, policy) => resolveReviewAcceptanceForEpoch(proof, review, reviewEpochModeFor(proof, policy));
-const resolveReviewTerminalStateForEpoch = (proof, review, epoch, adjudicatedLedger) => {
+const resolveReviewTerminalStateForEpoch = (proof, review, epoch) => {
 	const acceptance = resolveReviewAcceptanceForEpoch(proof, review, epoch);
 	if (acceptance === "accepted-clean") return "clean";
-	const { autoBlockingFindings, openFindings } = reviewCycleStateForEpoch(proof, epoch, adjudicatedLedger);
-	if (acceptance === "blocked") {
-		if (ladderRefoldDisagreement(epoch).unmatchedDispositions > 0) return "blocked";
-		return openFindings === 0 && autoBlockingFindings === 0 ? "clean" : "blocked";
-	}
+	if (acceptance === "recovery-required") return "blocked";
+	const { autoBlockingFindings, openFindings } = reviewCycleStateForEpoch(proof, epoch);
+	if (acceptance === "blocked") return openFindings === 0 && autoBlockingFindings === 0 ? "clean" : "blocked";
 	return openFindings === 0 ? "clean" : "accepted-with-findings";
 };
 const resolveReviewTerminalState = (proof, review, policy) => resolveReviewTerminalStateForEpoch(proof, review, reviewEpochModeFor(proof, policy));
-const resolveReviewTerminalStateAcrossReviews = (proof, epoch, adjudicatedLedger) => {
-	const states = proof.reviews.map((review) => resolveReviewTerminalStateForEpoch(proof, review, epoch, adjudicatedLedger));
+const resolveReviewTerminalStateAcrossReviews = (proof, epoch) => {
+	const states = proof.reviews.map((review) => resolveReviewTerminalStateForEpoch(proof, review, epoch));
 	if (states.includes("blocked")) return "blocked";
 	if (states.includes("accepted-with-findings")) return "accepted-with-findings";
 	return states.length > 0 ? "clean" : void 0;
 };
 const resolveReviewTerminalStateAcrossReviewsForPolicy = (proof, policy) => resolveReviewTerminalStateAcrossReviews(proof, reviewEpochModeFor(proof, policy));
+const accepted = (proof, review, epoch) => {
+	const acceptance = resolveReviewAcceptanceForEpoch(proof, review, epoch);
+	return acceptance !== "blocked" && acceptance !== "recovery-required";
+};
 const reviewProofForEpoch = (proof, kind, epoch, current) => {
 	const review = proof?.reviews.find((entry) => entry.kind === kind);
 	if (proof && review && review.typedVerdict !== true) return {
@@ -9189,7 +10081,7 @@ const reviewProofForEpoch = (proof, kind, epoch, current) => {
 		reviewedPatchId: proof.patchId,
 		untypedVerdict: true
 	};
-	if (proof && review && resolveReviewAcceptanceForEpoch(proof, review, epoch) !== "blocked") {
+	if (proof && review && accepted(proof, review, epoch)) {
 		if (current && !evidenceFresh({
 			candidate: current,
 			recorded: { patchId: proof.patchId },
@@ -9216,8 +10108,9 @@ var review_proof_exports = /* @__PURE__ */ __exportAll({
 	PR_REVIEW_FINAL_READINESS_NOTICE: () => PR_REVIEW_FINAL_READINESS_NOTICE,
 	PR_REVIEW_FINDING_PROVENANCE_VERSION: () => 1,
 	PR_REVIEW_PROOF_DESCRIPTOR: () => PR_REVIEW_PROOF_DESCRIPTOR,
-	PR_REVIEW_SCHEMA_VERSION: () => 2,
+	PR_REVIEW_SCHEMA_VERSION: () => 3,
 	REVIEW_SEVERITIES: () => REVIEW_SEVERITIES,
+	parseReviewProofBytes: () => parseReviewProofBytes,
 	prReviewFindingSchema: () => prReviewFindingSchema,
 	prReviewProofSchema: () => prReviewProofSchema,
 	prReviewResultSchema: () => prReviewResultSchema,
@@ -9309,18 +10202,42 @@ const prReviewProofSchema = z.object({
 	cleanedPaths: z.array(z.string()),
 	findingProvenanceVersion: z.literal(1),
 	headSha: z.string().regex(/^[0-9a-f]{40}$/u),
+	importedFrom: z.object({
+		proofDigest: z.string().regex(/^[0-9a-f]{64}$/u),
+		schemaVersion: z.literal(2)
+	}).strict().optional(),
 	ladder: prReviewLadderStateSchema.optional(),
 	maxReviewCycles: z.number().int().positive().optional(),
 	patchId: z.string().regex(/^[0-9a-f]{40,64}$/u),
 	policyResolution: policyResolutionSchema.optional(),
+	recoveryRequired: z.array(z.object({
+		candidates: z.array(z.string().regex(OCCURRENCE_ADDRESS_PATTERN)),
+		cycle: z.number().int().positive(),
+		declaration: z.object({
+			disposition: z.enum([
+				"fixed-in-thread",
+				"follow-up-filed",
+				"waived"
+			]),
+			file: z.string().optional(),
+			reference: z.string().optional(),
+			title: z.string()
+		}).strict(),
+		reason: z.string().min(1)
+	}).strict()).optional(),
 	reviewCycle: z.number().int().positive().optional(),
 	reviewRequirement: z.object({
 		reason: z.enum(["no-applicable-mode", "faithful-merge"]),
 		status: z.literal("not-required")
 	}).strict().optional(),
 	reviews: z.array(prReviewResultSchema),
-	schemaVersion: z.literal(2)
+	schemaVersion: z.literal(3)
 }).passthrough().superRefine((proof, context) => {
+	if (proof.importedFrom !== void 0 && proof.recoveryRequired === void 0) context.addIssue({
+		code: "custom",
+		message: "a proof converted from schema 2 (importedFrom) must carry recoveryRequired, an array that may be empty",
+		path: ["recoveryRequired"]
+	});
 	if (proof.reviewRequirement && proof.reviews.length > 0) context.addIssue({
 		code: "custom",
 		message: "not-required review proofs must not contain review runs",
@@ -9337,20 +10254,23 @@ const validatePrReviewResult = (value) => {
 	if (!parsed.success) throw new TypeError("Invalid pr:review result JSON");
 	return parsed.data;
 };
-const validatePrReviewProof = (value) => {
-	if (!value || typeof value !== "object" || value.schemaVersion !== 2) throw new Error("Unsupported pr:review proof schemaVersion");
-	const parsed = prReviewProofSchema.safeParse(value);
+const validatePrReviewProof = (value, proofDigest) => {
+	const imported = value && typeof value === "object" && value.schemaVersion === 2 ? importSchema2Proof(value, proofDigest) : value;
+	if (!imported || typeof imported !== "object" || imported.schemaVersion !== 3) throw new Error("Unsupported pr:review proof schemaVersion");
+	const parsed = prReviewProofSchema.safeParse(imported);
 	if (!parsed.success) {
 		const inReviews = parsed.error.issues.some((issue) => issue.path[0] === "reviews");
-		throw new TypeError(inReviews ? "Invalid pr:review review entry" : "Invalid pr:review proof JSON");
+		throw new TypeError(inReviews ? "Invalid pr:review review entry" : `Invalid pr:review proof JSON: ${parsed.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ")}`);
 	}
 	return parsed.data;
 };
+const parseReviewProofBytes = (bytes) => validatePrReviewProof(JSON.parse(bytes), sha256Hex(bytes));
 const PR_REVIEW_PROOF_DESCRIPTOR = {
 	defaultPath: DEFAULT_PR_REVIEW_PROOF_PATH,
 	label: "pr:review proof",
 	parse: validatePrReviewProof,
-	schemaVersion: 2
+	parseBytes: parseReviewProofBytes,
+	schemaVersion: 3
 };
 //#endregion
 //#region src/review-proof-applicability.ts
@@ -13380,6 +14300,34 @@ function hqIngestCredentialCheck({ env, resolve = defaultSecretReferenceProbe, r
 //#endregion
 //#region src/admission-preflight.ts
 const errorMessage$1 = (error) => error instanceof Error ? error.message : String(error);
+/**
+* The base every row below measures against (#1131, #1121). Bound the same
+* way `pr:review` binds it, so doctor and publish read one candidate: the
+* live pull request base when a pull request exists, otherwise the requested
+* or default ref fetched fresh. A binding failure is reported here and leaves
+* the candidate unresolved, so every other row says so rather than measuring
+* against a guessed base.
+*/
+const candidateBaseCheck = (bound) => "binding" in bound ? {
+	message: `Candidate ${describeCandidateBase(bound.binding)}; pr:review and pr:publish measure against this same base.`,
+	name: "admission:candidate-base",
+	status: "ok"
+} : {
+	message: `Candidate base could not be bound: ${bound.error}`,
+	name: "admission:candidate-base",
+	status: "warning"
+};
+const bindCandidateBase$1 = ({ base, candidateBase, cwd }) => {
+	try {
+		return { binding: resolveCandidateBase({
+			cwd,
+			...candidateBase === void 0 ? {} : { dependencies: candidateBase },
+			...base === void 0 ? {} : { requestedBase: base }
+		}) };
+	} catch (error) {
+		return { error: errorMessage$1(error) };
+	}
+};
 const resolveCandidate = ({ base, cwd, verifyProof }) => {
 	try {
 		const files = changedFiles(cwd, base);
@@ -13456,11 +14404,38 @@ const verifyProofCheck = ({ candidate, candidateError, preread, verifyProofPath
 	};
 };
 /**
+* Why a review proof file yielded no proof: the file is absent, or it is
+* present and unreadable (#1121, #1131). The two are different diagnoses with
+* different repairs, so preflight never reports one as the other.
+*/
+const reviewProofReadFailure = (error, proofPath) => error?.code === "ENOENT" ? { kind: "absent" } : {
+	kind: "invalid",
+	message: `pr:review proof at ${proofPath} is present but invalid, not absent: ${errorMessage$1(error)}. A proof that fails to parse is treated by readiness as missing evidence; re-record it with pr:review --findings <path>.`
+};
+/**
+* A review-proof lock older than the write wait window (#1132). No writer
+* ever removes a lock it did not create, so a crashed writer's lock refuses
+* every later `pr:review` until an operator removes it; this row names the
+* step. Absent (no row) when there is no lock or it is young enough to be a
+* live writer's.
+*/
+const reviewProofLockCheck = (reviewProofPath) => {
+	const held = describeHeldProofLock(reviewProofPath);
+	if (held === void 0 || !proofLockOutlivesWait(held)) return [];
+	return [{
+		message: `pr:review proof lock ${held.lockPath} has been held for ${Math.round(held.ageMs / 1e3)}s since ${held.since} (token ${held.token}, pid ${held.pid}); every recording will refuse with concurrent-write until it is released: ${LOCK_REMOVAL_INSTRUCTION}.`,
+		name: "admission:review-proof-lock",
+		status: "warning"
+	}];
+};
+/**
 * Independent review proof. Requiredness comes from the profile-resolved review
 * modes; currency and acceptance come from the same identity and
-* terminal-state helpers `pr:publish` uses.
+* terminal-state helpers `pr:publish` uses. The proof is read through
+* `tryReadProof`, which keeps the read error: an unparseable file is reported
+* as invalid, never as absent (#1121).
 */
-const reviewProofCheck = ({ candidate, candidateError, proof, reviewModes }) => {
+const reviewProofCheck = ({ candidate, candidateError, read, reviewModes, reviewProofPath }) => {
 	const name = "admission:review-proof";
 	if (!candidate) return {
 		message: `Review proof state is unknown: no git candidate is resolvable here (${candidateError ?? "unknown error"}).`,
@@ -13472,21 +14447,44 @@ const reviewProofCheck = ({ candidate, candidateError, proof, reviewModes }) =>
 		name,
 		status: "ok"
 	};
+	const required = `${reviewModes.join(", ")} review(s) are required. Have an independent clean session write findings and pass them to pr:review --findings <path>.`;
+	if (read.proof === void 0) {
+		const failure = reviewProofReadFailure(read.error, reviewProofPath);
+		return {
+			message: failure.kind === "absent" ? `pr:review proof is absent: no file at ${reviewProofPath}. ${required}` : `${failure.message} ${required}`,
+			name,
+			status: "warning"
+		};
+	}
+	const { proof } = read;
+	const recorded = latestRecordingSentence(proof);
+	const recovery = describeRecoveryRequired(proof.recoveryRequired ?? []).map((line) => ` ${line}`).join("");
 	const status = reviewStatus({
 		headSha: candidate.headSha,
 		patchId: candidate.patchId,
 		required: true,
-		reviewedHeadSha: proof?.headSha,
-		reviewedPatchId: proof?.patchId
+		reviewedHeadSha: proof.headSha,
+		reviewedPatchId: proof.patchId
 	});
-	const terminal = proof ? resolveReviewTerminalStateAcrossReviewsForPolicy(proof, resolveReviewLadderPolicy()) : void 0;
-	const accepted = status === "current" && (terminal === "clean" || terminal === "accepted-with-findings");
+	const terminal = resolveReviewTerminalStateAcrossReviewsForPolicy(proof, resolveReviewLadderPolicy());
+	if (status === "current" && (terminal === "clean" || terminal === "accepted-with-findings")) return {
+		message: `pr:review proof is current for this candidate (${terminal}) across ${reviewModes.join(", ")}.${recorded}`,
+		name,
+		status: "ok"
+	};
 	return {
-		message: accepted ? `pr:review proof is current for this candidate (${terminal}) across ${reviewModes.join(", ")}.` : `pr:review proof is ${status}${terminal ? ` (${terminal})` : ""}; ${reviewModes.join(", ")} review(s) are required. Have an independent clean session write findings and pass them to pr:publish --findings <path>.`,
+		message: status === "stale" ? `pr:review proof is stale: it reviewed patch ${proof.patchId} at head ${proof.headSha}, and the candidate is patch ${candidate.patchId} at head ${candidate.headSha} (${terminal}).${recorded}${recovery} ${required}` : `pr:review proof is ${status} (${terminal}).${recorded}${recovery} ${required}`,
 		name,
-		status: accepted ? "ok" : "warning"
+		status: "warning"
 	};
 };
+const latestRecordingSentence = (proof) => {
+	const latest = proof.ladder?.cycles.at(-1)?.recording;
+	const cycle = proof.ladder?.cycles.length ?? 0;
+	if (latest === void 0) return "";
+	if ("recordingId" in latest) return ` Latest recording ${latest.recordingId} (cycle ${cycle}, base ${latest.base.ref} at ${latest.base.sha}).`;
+	return ` Latest cycle ${cycle} was imported from a schema-2 proof (${latest.imported.proofDigest}).`;
+};
 /**
 * Resolve the demand this candidate actually owes.
 *
@@ -13599,19 +14597,26 @@ const requiredCheckChecks = ({ candidate, candidateError, cwd, profile, profileP
 * requirement is reported by the doctor `github-app` check, which states the
 * consequence of its absence.
 */
-const admissionPreflightChecks = ({ base = "origin/main", cwd, env = process.env, hqIngestCredentials, profile, profilePath, reviewProofPath = DEFAULT_PR_REVIEW_PROOF_PATH, verifyProofPath = DEFAULT_PR_VERIFY_PROOF_PATH }) => {
+const admissionPreflightChecks = ({ base, candidateBase, cwd, env = process.env, hqIngestCredentials, profile, profilePath, reviewProofPath = DEFAULT_PR_REVIEW_PROOF_PATH, verifyProofPath = DEFAULT_PR_VERIFY_PROOF_PATH }) => {
 	const resolvedVerifyProofPath = path.resolve(cwd, verifyProofPath);
 	const preread = tryReadProof(readPrVerifyProof, resolvedVerifyProofPath);
-	const resolved = resolveCandidate({
+	const bound = bindCandidateBase$1({
 		base,
+		candidateBase,
+		cwd
+	});
+	const resolved = "binding" in bound ? resolveCandidate({
+		base: bound.binding.sha,
 		cwd,
 		verifyProof: preread.proof
-	});
+	}) : bound;
 	const candidate = "candidate" in resolved ? resolved.candidate : void 0;
 	const candidateError = "error" in resolved ? resolved.error : void 0;
-	const reviewProof = readOptionalProofFor(PR_REVIEW_PROOF_DESCRIPTOR, cwd, reviewProofPath);
+	const resolvedReviewProofPath = path.resolve(cwd, reviewProofPath);
+	const reviewRead = tryReadProof((proofPath) => readProofFor(PR_REVIEW_PROOF_DESCRIPTOR, cwd, proofPath), resolvedReviewProofPath);
 	return [
 		authoringSessionCheck(env),
+		candidateBaseCheck(bound),
 		verifyProofCheck({
 			candidate,
 			candidateError,
@@ -13621,9 +14626,11 @@ const admissionPreflightChecks = ({ base = "origin/main", cwd, env = process.env
 		reviewProofCheck({
 			candidate,
 			candidateError,
-			proof: reviewProof,
-			reviewModes: candidate ? resolveApplicableReviewModes(profile, candidate.files) : ["correctness"]
+			read: reviewRead,
+			reviewModes: candidate ? resolveApplicableReviewModes(profile, candidate.files) : ["correctness"],
+			reviewProofPath: resolvedReviewProofPath
 		}),
+		...reviewProofLockCheck(resolvedReviewProofPath),
 		...requiredCheckChecks({
 			candidate,
 			candidateError,
@@ -13875,7 +14882,7 @@ function repositoryUrlMatches(origin, profile) {
 //#endregion
 //#region src/commands/doctor.ts
 function createDoctorCommand(output) {
-	return markCwdOptionDefault(new Command("doctor").description("Validate a project profile without mutating GitHub or local files").option("--base <ref>", "base branch or ref for --preflight", "origin/main").option("--cwd <path>", "working directory to validate", collectCwdOption).option("--json", "print the doctor report as JSON").option("--preflight", "also list the pre-checkable admission requirements for the current candidate (read-only; never blocks); each required check states whether this candidate is demanded to satisfy it, resolved by candidate:impact; findings-file shape and wave membership have no read-only pre-check").option("--profile <path>", "path to the project profile JSON file").action(async (options) => {
+	return markCwdOptionDefault(new Command("doctor").description("Validate a project profile without mutating GitHub or local files").option("--base <ref>", "base ref to assert for --preflight. With a pull request open for this branch its live base is the base and a disagreeing value is reported; without one, this ref (default origin/main) is fetched fresh").option("--cwd <path>", "working directory to validate", collectCwdOption).option("--json", "print the doctor report as JSON").option("--preflight", "also list the pre-checkable admission requirements for the current candidate (read-only; never blocks); each required check states whether this candidate is demanded to satisfy it, resolved by candidate:impact; findings-file shape and wave membership have no read-only pre-check").option("--profile <path>", "path to the project profile JSON file").action(async (options) => {
 		const report = await doctorProjectProfile({
 			base: options.base,
 			cwd: resolveCwdOption(options.cwd),
@@ -15637,7 +16644,7 @@ const prVerifyEvaluation = ({ acceptedBaselineHeadShas, currentHeadSha, docsOnly
 		prVerifyStatus: "missing"
 	};
 };
-const addReviewBlockingReasons = ({ blockers, correctnessRequired, correctnessStatus, correctnessUntyped }) => {
+const addReviewBlockingReasons = ({ blockers, correctnessRequired, correctnessStatus, correctnessUntyped, recovering }) => {
 	const demand = reviewModeDemand("correctness");
 	if (correctnessRequired && correctnessUntyped) blockers.push({
 		demand,
@@ -15651,12 +16658,19 @@ const addReviewBlockingReasons = ({ blockers, correctnessRequired, correctnessSt
 		demand,
 		reason: "Correctness review proof is stale because the PR-owned patch-id changed."
 	});
-	else if (correctnessStatus === "blocked") blockers.push({
+	else if (correctnessStatus === "blocked" && !recovering) blockers.push({
 		demand,
 		reason: "Correctness review proof ran and explicitly failed (open blocking findings or errored run); resolve the findings and re-run pr:review."
 	});
 };
-const addSecurityBlockingReasons = ({ blockers, securityRequired, securityStatus, securityUntyped }) => {
+const recoveryPending = (reviewProof) => (reviewProof?.recoveryRequired?.length ?? 0) > 0;
+const addRecoveryBlockingReasons = ({ blockers, reviewProof }) => {
+	for (const reason of describeRecoveryRequired(reviewProof?.recoveryRequired ?? [])) blockers.push({
+		demand: reviewModeDemand("correctness"),
+		reason
+	});
+};
+const addSecurityBlockingReasons = ({ blockers, recovering, securityRequired, securityStatus, securityUntyped }) => {
 	const demand = reviewModeDemand("security");
 	if (securityRequired && securityUntyped) blockers.push({
 		demand,
@@ -15670,7 +16684,7 @@ const addSecurityBlockingReasons = ({ blockers, securityRequired, securityStatus
 		demand,
 		reason: "Security review proof is stale because the PR-owned patch-id changed."
 	});
-	else if (securityStatus === "blocked") blockers.push({
+	else if (securityStatus === "blocked" && !recovering) blockers.push({
 		demand,
 		reason: "Security review proof ran and explicitly failed (open blocking findings or errored run); resolve or disposition the findings and re-run pr:review."
 	});
@@ -15770,6 +16784,7 @@ const awaitPostUndraftChecksRepair = (input) => {
 };
 const collectBlockers = ({ correctnessRequired, correctnessStatus, correctnessUntyped, input, prVerifyStatus, verificationProof, securityRequired, securityStatus, securityUntyped }) => {
 	const blockers = [];
+	const recovering = recoveryPending(input.reviewProof);
 	if (prVerifyStatus === "missing") blockers.push({
 		demand: DEMAND_KEYS.prVerify,
 		reason: "Missing passing typed pr:verify proof for the current PR head."
@@ -15787,10 +16802,16 @@ const collectBlockers = ({ correctnessRequired, correctnessStatus, correctnessUn
 		blockers,
 		correctnessRequired,
 		correctnessStatus,
-		correctnessUntyped
+		correctnessUntyped,
+		recovering
+	});
+	addRecoveryBlockingReasons({
+		blockers,
+		reviewProof: input.reviewProof
 	});
 	addSecurityBlockingReasons({
 		blockers,
+		recovering,
 		securityRequired,
 		securityStatus,
 		securityUntyped
@@ -17027,6 +18048,40 @@ const armingNotice = (arming) => {
 	if (arming.outcome === "merged") return `This candidate merged during the arming call: ${arming.detail ?? "GitHub found it already mergeable."}`;
 	return `Native auto-merge was NOT armed for ${arming.headSha}: ${arming.detail ?? "unknown reason"} Nothing will merge this candidate until the recorded follow-up runs.`;
 };
+/**
+* #1125: a throw before the branded check is published used to POST a red
+* stub (`ledger head unknown`) even when the miss was Cursor OIDC mint or
+* broker exchange. That reads as evaluated-refused. Absence is the #1037
+* not-yet shape: the required check does not pass, and a retry is not a
+* candidate repair. Proof-chain refusals still publish red.
+*/
+const publishThrownFailureCheck = async (input) => {
+	const message = input.error instanceof Error ? input.error.message : String(input.error);
+	if (isFactoryAppUnevaluableError(input.error)) {
+		console.warn(`pr:ready could not evaluate; no ${FACTORY_CHECK_NAMES["pr-ready"]} check run was published for ${input.sha}. ${message.trim()} Retry. This is not a candidate refusal.`);
+		return;
+	}
+	const failureCheckInput = {
+		conclusion: "failure",
+		cwd: input.cwd,
+		gate: "pr-ready",
+		owner: input.owner,
+		pr: input.pr,
+		proof: {
+			blockingReasons: [message],
+			schemaVersion: 3,
+			status: "blocked"
+		},
+		repo: input.repo,
+		sha: input.sha
+	};
+	try {
+		if (!await (input.publishFinalCheckRun ? input.publishFinalCheckRun(failureCheckInput) : ensureFactoryCheckRunPublished(failureCheckInput, { onDiagnostic: (diagnostic) => process.stderr.write(diagnostic) }))) console.warn(`pr:ready could not publish the failing ${FACTORY_CHECK_NAMES["pr-ready"]} check run for ${input.sha}; the required check is absent rather than red.`);
+	} catch (publishError) {
+		const publishMessage = publishError instanceof Error ? publishError.message : String(publishError);
+		console.warn(`pr:ready could not publish the failing ${FACTORY_CHECK_NAMES["pr-ready"]} check run for ${input.sha}; the required check is absent rather than red. ${publishMessage}`);
+	}
+};
 async function runPrReady(args, dependencies = {}) {
 	const cwd = path.resolve(args.cwd ?? process.cwd());
 	const profilePath = readinessProfilePath(cwd, args.profilePath);
@@ -17309,27 +18364,15 @@ async function runPrReady(args, dependencies = {}) {
 	} catch (error) {
 		if (error instanceof UnreadableLiveBaseTipError && presentedHeadSha === void 0) presentedHeadSha = error.headRefOid;
 		if (!finalCheckPublished && presentedHeadSha) {
-			const message = error instanceof Error ? error.message : String(error);
-			const failureCheckInput = {
-				conclusion: "failure",
+			await publishThrownFailureCheck({
 				cwd,
-				gate: "pr-ready",
+				error,
 				owner: repository.owner,
 				pr: args.pr,
-				proof: {
-					blockingReasons: [message],
-					schemaVersion: 3,
-					status: "blocked"
-				},
+				publishFinalCheckRun: dependencies.publishFinalCheckRun,
 				repo: repository.name,
 				sha: presentedHeadSha
-			};
-			try {
-				if (!await (dependencies.publishFinalCheckRun ? dependencies.publishFinalCheckRun(failureCheckInput) : ensureFactoryCheckRunPublished(failureCheckInput, { onDiagnostic: (diagnostic) => process.stderr.write(diagnostic) }))) console.warn(`pr:ready could not publish the failing ${FACTORY_CHECK_NAMES["pr-ready"]} check run for ${presentedHeadSha}; the required check is absent rather than red.`);
-			} catch (publishError) {
-				const publishMessage = publishError instanceof Error ? publishError.message : String(publishError);
-				console.warn(`pr:ready could not publish the failing ${FACTORY_CHECK_NAMES["pr-ready"]} check run for ${presentedHeadSha}; the required check is absent rather than red. ${publishMessage}`);
-			}
+			});
 			await presentHud();
 		}
 		throw error;
@@ -17373,7 +18416,37 @@ const tryAppendReviewGateNotRequiredTraceEvent = ({ identity, proof, repoRoot })
 	}
 };
 //#endregion
-//#region src/review-findings-file.ts
+//#region src/review-fault-injection.ts
+const REVIEW_FAULT_ENV = "FACTORY_REVIEW_FAULT";
+const REVIEW_FAULT_POINTS = [
+	"after-retain",
+	"proof-rename",
+	"after-proof-write"
+];
+var InjectedReviewFaultError = class extends Error {
+	point;
+	constructor(point) {
+		super(`injected fault at ${point} (${REVIEW_FAULT_ENV})`);
+		this.name = "InjectedReviewFaultError";
+		this.point = point;
+	}
+};
+const isFaultPoint = (value) => REVIEW_FAULT_POINTS.includes(value);
+/**
+* The fault point this run injects, or undefined. Throws when the variable
+* is set but injection is not allowed, or names an unknown point.
+*/
+const resolveReviewFault = ({ allowFaultInjection = false, env = process.env } = {}) => {
+	const requested = env[REVIEW_FAULT_ENV];
+	if (requested === void 0 || requested === "") return;
+	if (env.NODE_ENV !== "test" && !allowFaultInjection) throw new Error(`${REVIEW_FAULT_ENV} is set (${requested}) but fault injection is test-only: unset it, or pass --allow-fault-injection to run the recoverable-recording demonstration deliberately.`);
+	if (!isFaultPoint(requested)) throw new Error(`${REVIEW_FAULT_ENV} names an unknown fault point "${requested}"; known points: ${REVIEW_FAULT_POINTS.join(", ")}.`);
+	return requested;
+};
+/** Throw the injected fault when this is its point. */
+const faultAt = (injected, point) => {
+	if (injected === point) throw new InjectedReviewFaultError(point);
+};
 const nonBlankString = z.string().trim().min(1);
 const reviewFindingSchema = z.object({
 	blockingAfterCap: z.boolean().optional(),
@@ -17413,13 +18486,22 @@ const findingsReviewSchema = z.object({
 		path: ["findings"]
 	});
 });
+const reviewResolutionSchema = z.object({
+	reference: nonBlankString,
+	target: z.string().regex(OCCURRENCE_ADDRESS_PATTERN)
+}).strict();
 const reviewFindingsFileSchema = z.object({
 	model: nonBlankString,
 	patchId: nonBlankString,
 	producer: nonBlankString.optional(),
+	resolutions: z.array(reviewResolutionSchema).optional(),
 	reviews: z.array(findingsReviewSchema),
 	rung: z.enum(EVIDENCE_REVIEW_RUNGS).optional(),
-	schemaVersion: z.union([z.literal(1), z.literal(2)]),
+	schemaVersion: z.union([
+		z.literal(1),
+		z.literal(2),
+		z.literal(3)
+	]),
 	sessionId: nonBlankString
 }).strict().superRefine((file, context) => {
 	if (file.schemaVersion === 1) {
@@ -17436,12 +18518,12 @@ const reviewFindingsFileSchema = z.object({
 	} else {
 		if (file.producer === void 0) context.addIssue({
 			code: "custom",
-			message: "schemaVersion 2 findings require producer",
+			message: `schemaVersion ${file.schemaVersion} findings require producer`,
 			path: ["producer"]
 		});
 		if (file.rung === void 0) context.addIssue({
 			code: "custom",
-			message: "schemaVersion 2 findings require rung",
+			message: `schemaVersion ${file.schemaVersion} findings require rung`,
 			path: ["rung"]
 		});
 	}
@@ -17460,13 +18542,92 @@ const reviewFindingsFileSchema = z.object({
 	}
 });
 const validateReviewFindingsFile = (value) => reviewFindingsFileSchema.parse(value);
-const parseReviewFindingsFile = (findingsPath, cwd = process.cwd()) => {
-	const resolved = path.resolve(cwd, findingsPath);
+const parseReviewFindingsBytes = (bytes, resolvedPath) => {
+	try {
+		return validateReviewFindingsFile(JSON.parse(bytes));
+	} catch (error) {
+		throw new Error(`--findings file is invalid: ${resolvedPath}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+	}
+};
+const exampleLeafValues = {
+	blockingAfterCap: true,
+	body: "<what is wrong, where, and how to reproduce it>",
+	category: "correctness",
+	citedSpan: "<the exact code text the finding is about, quoted verbatim from the diff>",
+	file: "<repository-relative path of the file the finding is about>",
+	issuesFlagged: 1,
+	kind: "correctness",
+	line: 12,
+	model: "<your model identifier>",
+	outcome: "failed",
+	patchId: "<the stable patch-id from Review scope above>",
+	prescribedAction: "<a concise, standalone statement of the required fix>",
+	priority: "P2",
+	producer: "<the engine and model that ran this review, for example codex-cli/gpt-5.6-sol>",
+	reference: "<why the named prior occurrence is resolved: the commit or the verified fix>",
+	sessionId: "<this session's id>",
+	summary: "<one concise sentence; use \"No actionable findings.\" only when issuesFlagged is 0>",
+	target: "c1f1",
+	title: "<short finding title>"
+};
+const exampleForSchema = (schema, key, overrides, omit) => {
+	if (schema instanceof z.ZodOptional) return exampleForSchema(schema.unwrap(), key, overrides, omit);
+	if (schema instanceof z.ZodObject) return Object.fromEntries(Object.entries(schema.shape).filter(([field]) => !omit.has(field)).map(([field, fieldSchema]) => [field, exampleForSchema(fieldSchema, field, overrides, omit)]));
+	if (schema instanceof z.ZodArray) return [exampleForSchema(schema.element, key, overrides, omit)];
+	const value = overrides[key] ?? exampleLeafValues[key];
+	if (value === void 0) throw new Error(`review-findings-file.ts: no example value for schema field "${key}"; add one beside the schema so the assembled prompt can print it.`);
+	return value;
+};
+/**
+* The findings file the assembled prompt asks a reviewer to write, rendered as
+* pretty-printed JSON derived from the schema above (#1131). It is a valid
+* instance, not a description: one failed review with one finding carrying
+* every optional attribute. `waveRung` selects schemaVersion 3 with that rung,
+* a producer and one resolution; absent, the schemaVersion 1 shape omits all
+* three (resolutions are still accepted at version 1; the version-3 example
+* is the one that shows the field).
+*/
+const renderReviewFindingsFileExample = (waveRung) => JSON.stringify(exampleForSchema(reviewFindingsFileSchema, "file", waveRung === void 0 ? { schemaVersion: 1 } : {
+	rung: waveRung,
+	schemaVersion: 3
+}, new Set(waveRung === void 0 ? [
+	"producer",
+	"resolutions",
+	"rung"
+] : [])), null, 2);
+//#endregion
+//#region src/review-findings-retention.ts
+const REVIEW_FINDINGS_RETENTION_DIR = ".factory-memory/review-findings";
+const REVIEW_PROOF_IMPORT_RETENTION_DIR = ".factory-memory/review-proof-imports";
+const retainReviewBytes = ({ bytes, cwd, directory: relativeDirectory = REVIEW_FINDINGS_RETENTION_DIR }) => {
+	const digest = sha256Hex(bytes);
+	const directory = path.resolve(cwd, relativeDirectory);
+	const target = path.join(directory, `${digest}.json`);
+	mkdirSync(directory, { recursive: true });
+	let existing;
+	try {
+		existing = readFileSync(target, "utf-8");
+	} catch {
+		existing = void 0;
+	}
+	if (existing === bytes) return {
+		digest,
+		path: target
+	};
+	const temp = path.join(directory, `.${digest}.${process.pid}.tmp`);
 	try {
-		return validateReviewFindingsFile(JSON.parse(readFileSync(resolved, "utf-8")));
+		writeFileSync(temp, bytes);
+		renameSync(temp, target);
 	} catch (error) {
-		throw new Error(`--findings file is invalid: ${resolved}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+		try {
+			unlinkSync(temp);
+		} catch {}
+		throw error;
 	}
+	return {
+		digest,
+		path: target
+	};
 };
 //#endregion
 //#region src/issue-body-sections.ts
@@ -17578,8 +18739,7 @@ const tryAppendReviewLadderStageTraceEvent = (input) => {
 const isReviewLineageContinuous = (prior, current, isAncestor) => prior.base === current.base && (prior.headSha === current.headSha || isAncestor(prior.headSha, current.headSha));
 //#endregion
 //#region src/review-ladder-proof.ts
-const priorLadderStateFor = ({ base, cwd, headSha, isAncestor, output }) => {
-	const prior = readOptionalProofFor(PR_REVIEW_PROOF_DESCRIPTOR, cwd, output);
+const priorLadderStateFor = ({ base, headSha, isAncestor, prior }) => {
 	if (!prior?.ladder) return;
 	return isReviewLineageContinuous({
 		base: prior.base,
@@ -17589,76 +18749,76 @@ const priorLadderStateFor = ({ base, cwd, headSha, isAncestor, output }) => {
 		headSha
 	}, isAncestor) ? prior.ladder : void 0;
 };
-const normalizedDispositionKey = ({ file, title }) => `(title=${JSON.stringify(normalizeTitle(title))}, file=${file === void 0 ? "<unspecified>" : JSON.stringify(normalizeFile(file))})`;
-const assertDeclaredDispositionsMatch = (priorLedger, declarations, currentFindings = []) => {
-	const unmatched = declarations.filter((declaration) => !priorLedger.some((entry) => declarationMatchesEntry(entry, declaration.finding)) && !currentFindings.some((finding) => declarationMatchesEntry(finding, declaration.finding)));
-	if (unmatched.length > 0) {
-		const unmatchedKeys = unmatched.map((declaration) => normalizedDispositionKey(declaration.finding)).join("; ");
-		const availableTargets = [...priorLedger.map((entry) => normalizedDispositionKey(entry)), ...currentFindings.map((finding) => normalizedDispositionKey(finding))];
-		const availableKeys = availableTargets.length === 0 ? "prior ledger is empty" : availableTargets.join("; ");
-		throw new Error(`--dispositions entries match no ledger finding. Unmatched normalized declaration keys: ${unmatchedKeys}. Available normalized ledger keys: ${availableKeys}. Declarations are keyed by normalized title plus file; check both against the persisted ladder ledger.`);
-	}
-};
-const declaredDispositionsFor = (dispositionsPath, cwd) => {
-	if (!dispositionsPath) return [];
+const readDeclaredDispositions = (dispositionsPath, cwd) => {
+	if (!dispositionsPath) return;
 	const resolved = path.resolve(cwd, dispositionsPath);
-	const parsed = ladderDispositionDeclarationsSchema.safeParse(JSON.parse(readFileSync(resolved, "utf-8")));
+	const bytes = readFileSync(resolved, "utf-8");
+	let parsed;
+	try {
+		parsed = dispositionDeclarationsFileSchema.safeParse(JSON.parse(bytes));
+	} catch (error) {
+		throw new Error(`--dispositions file is invalid: ${resolved}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+	}
 	if (!parsed.success) throw new Error(`--dispositions file is invalid: ${resolved}: ${parsed.error.issues.map((issue) => issue.message).join("; ")}`);
-	return parsed.data;
+	return {
+		bytes,
+		declarations: parsed.data
+	};
 };
 const priorLedgerFor = (priorLadder) => priorLadder ? ladderLedgerFor(priorLadder) : [];
-function ladderStateForRun({ declaredDispositions, cycle, historical, identity, model, policy, priorLadder, priorLedger, resumedSession, runs, sessionAttribution }) {
+const foldWith = (priorCycles, cycle) => {
+	const cycles = [...priorCycles, cycle];
+	return foldLedger(cycles, ladderCycleRefsFor(cycles)).occurrences;
+};
+function ladderStateForRun({ historical, identity, model, policy, priorLadder, recording, runs, sessionAttribution }) {
 	const findings = runs.flatMap((run) => run.review.findings.map((finding) => toLadderFindingReport(finding)));
 	const priorCycles = priorLadder?.cycles ?? [];
-	const inferenceSafe = historical !== true && runs.every((run) => run.review.outcome !== "error");
-	const sameHeadAsPriorCycle = isSameHeadRerun(priorCycles.at(-1), { identity });
+	const cycleIndex = priorCycles.length + 1;
+	const declaredCycle = ladderCycleRefsFor([...priorCycles, { stage: "gate" }]).at(-1)?.cycle ?? cycleIndex;
+	const liveCycleCount = priorCycles.filter((cycle) => cycle.historical !== true).length + (historical === true ? 0 : 1);
 	const session = {
-		...resumedSession === void 0 ? {} : { resumedSession },
 		...sessionAttribution?.sessionId ? { sessionId: sessionAttribution.sessionId } : {},
 		...sessionAttribution?.runtime ? { runtime: sessionAttribution.runtime } : {}
 	};
-	const sameCycleDeclared = historical === true ? declaredDispositions.flatMap((declaration) => {
-		const finding = findings.find((candidate) => declarationMatchesEntry(candidate, declaration.finding));
-		return finding === void 0 ? [] : [{
-			...declaration,
-			findingReport: finding
-		}];
-	}) : [];
-	const priorDeclared = historical === true ? declaredDispositions.filter((declaration) => !findings.some((candidate) => declarationMatchesEntry(candidate, declaration.finding))) : declaredDispositions;
-	const currentCycle = {
-		dispositions: [
-			...inferenceSafe ? inferFixedInThreadDispositions(priorLedger, findings, { sameHeadAsPriorCycle }) : [],
-			...priorDeclared,
-			...sameCycleDeclared,
-			...priorCycles.length >= 1 || (cycle ?? 1) >= 2 ? findings.filter((finding) => {
-				const severity = resolveReviewFindingSeverity(finding.priority);
-				return severity === "medium" || severity === "low";
-			}).map((finding) => ({
-				disposition: "follow-up-filed",
-				finding: {
-					...finding.file ? { file: finding.file } : {},
-					title: finding.title
-				},
-				findingReport: finding,
-				reference: CYCLE_2_SEVERITY_FLOOR_REFERENCE
-			})) : []
-		],
-		findings,
-		...historical === true ? { historical: true } : {},
-		identity,
-		model,
-		stage: "gate",
-		...Object.keys(session).length > 0 ? { session } : {},
-		...resumedSession ? { correlatedRerun: true } : {}
+	const cycleWith = (declarations) => {
+		const record = {
+			appliedTo: recording.appliedTo,
+			base: recording.base,
+			declarations,
+			...recording.dispositionsDigest === void 0 ? {} : { dispositionsDigest: recording.dispositionsDigest },
+			findingsDigest: recording.findingsDigest,
+			occurrences: occurrencesForCycle({
+				cycleIndex,
+				declaredCycle,
+				findings,
+				priorCycles
+			}),
+			recordingId: recording.recordingId
+		};
+		return {
+			findings,
+			...historical === true ? { historical: true } : {},
+			identity,
+			model,
+			recording: record,
+			stage: "gate",
+			...Object.keys(session).length > 0 ? { session } : {}
+		};
 	};
+	const explicit = recording.declarations;
+	const repeats = identityRepeatDeclarations(foldWith(priorCycles, cycleWith(explicit)), cycleIndex);
+	const floor = severityFloorDeclarations(foldWith(priorCycles, cycleWith([...explicit, ...repeats])), liveCycleCount);
+	const currentCycle = cycleWith([
+		...explicit,
+		...repeats,
+		...floor
+	]);
 	const cycles = [...priorCycles, currentCycle];
-	const evaluation = evaluateReviewLadder({
-		cycles,
-		policy
-	});
-	if (evaluation.unmatchedDispositions.length > 0) throw new Error(`Dispositions were dropped at fold time — they matched no flagged finding in the ladder history: ${evaluation.unmatchedDispositions.map((declaration) => declaration.finding.title).join("; ")}. The fold and the pre-run --dispositions validation disagree; nothing was persisted.`);
 	return {
-		evaluation,
+		evaluation: evaluateReviewLadder({
+			cycles,
+			policy
+		}),
 		ladder: { cycles }
 	};
 }
@@ -17680,7 +18840,7 @@ function emitLadderStageTrace({ cwd, evaluation, headSha, issue, patchId, profil
 //#endregion
 //#region src/review-contract.ts
 const SESSION_ID_RULE = `"sessionId" is this review session's own id. It must differ from the authoring session id the candidate was verified under (FACTORY_SESSION_ID): pr:review --findings refuses a findings file whose sessionId equals the authoring session.`;
-const authorityRule = (waveRung) => waveRung === void 0 ? `Emit schemaVersion 1 and omit "producer" and "rung": this candidate resolves no boundary-wave review rung. If your dispatch instructions do name a rung, emit schemaVersion 2 with that rung and with "producer" instead.` : `This candidate belongs to a boundary wave that demands the ${waveRung} review rung, so schemaVersion 2 is required. Record "rung": "${waveRung}" exactly as shown, and set "producer" to the engine and model that ran this review (for example "codex-cli/gpt-5.6-sol"). Findings without both fields are recorded without authority, and pr:publish then refuses with "no passing review at that authority".`;
+const authorityRule = (waveRung) => waveRung === void 0 ? `Emit schemaVersion 1 and omit "producer" and "rung": this candidate resolves no boundary-wave review rung. If your dispatch instructions do name a rung, emit schemaVersion 3 with that rung and with "producer" instead. "resolutions" is accepted at every schemaVersion: when the prior-review ledger below shows an open occurrence you verified fixed, add "resolutions": [{"target": "<its address, for example c1f1>", "reference": "<the commit or the verified fix>"}]; silence is not resolution, and an occurrence you do not name stays open.` : `This candidate belongs to a boundary wave that demands the ${waveRung} review rung, so schemaVersion 3 is required. Record "rung": "${waveRung}" exactly as shown, and set "producer" to the engine and model that ran this review (for example "codex-cli/gpt-5.6-sol"). Findings without both fields are recorded without authority, and pr:publish then refuses with "no passing review at that authority". "resolutions" is optional: when the prior-review ledger below shows an open occurrence you verified fixed, name it by its address (for example "c1f1") with a reference; silence is not resolution, and an occurrence you do not name stays open.`;
 /**
 * The findings-file instructions for one candidate.
 *
@@ -17688,23 +18848,9 @@ const authorityRule = (waveRung) => waveRung === void 0 ? `Emit schemaVersion 1
 * resolves one. It selects the findings schema version the gate will accept.
 */
 const reviewFooterInstructions = (waveRung) => {
-	const schemaVersion = waveRung === void 0 ? 1 : 2;
-	return `Do not print a machine-readable footer in your chat response. Write your findings to the typed findings file at the path given in your dispatch/task instructions (the file pr:review reads via --findings <path>); that file is the verdict. The file must be valid JSON matching review-findings-file.ts's schema (schemaVersion ${schemaVersion}):
-{
-  "schemaVersion": ${schemaVersion},
-${waveRung === void 0 ? "" : `  "producer": "<the engine and model that ran this review, for example codex-cli/gpt-5.6-sol>",\n  "rung": "${waveRung}",\n`}  "model": "<your model identifier>",
-  "sessionId": "<this session's id>",
-  "patchId": "<the stable patch-id from Review scope above>",
-  "reviews": [
-    {
-      "kind": "correctness" or "security" (this review's mode, matching the mode-floor instructions below),
-      "outcome": "passed" or "failed",
-      "issuesFlagged": an integer count of actionable findings (must equal findings.length),
-      "summary": one concise sentence; use "No actionable findings." only when issuesFlagged is 0,
-      "findings": [] when issuesFlagged is 0, otherwise an array of objects with title, body, and optional file, line, priority, category, blockingAfterCap, citedSpan, prescribedAction, and supersedes fields
-    }
-  ]
-}
+	return `Do not print a machine-readable footer in your chat response. Write your findings to the typed findings file at the path given in your dispatch/task instructions (the file pr:review reads via --findings <path>); that file is the verdict. The file must be valid JSON matching review-findings-file.ts's schema (schemaVersion ${waveRung === void 0 ? 1 : 3}). This example is printed from that schema and validates as written:
+${renderReviewFindingsFileExample(waveRung)}
+Field rules the validator enforces: "kind" is this review's mode ("correctness" or "security", matching the mode-floor instructions below); "outcome" is "passed" or "failed"; "issuesFlagged" must equal findings.length, so a passed review has "issuesFlagged": 0, "findings": [] and "summary": "No actionable findings."; a failed review has at least one finding. Each finding requires title and body; file, line, priority, category, blockingAfterCap, citedSpan, prescribedAction, and supersedes are optional. Do not add fields the example does not show.
 ${authorityRule(waveRung)}
 ${SESSION_ID_RULE}
 Use category "correctness", "safety", "coordination", or "maintainability"; set blockingAfterCap true for correctness, safety, or coordination findings. citedSpan must be the exact code text the finding is about, quoted verbatim from the diff (identity is derived from this, not from the title, so quote precisely). prescribedAction must be a concise, standalone statement of the required fix (identity is derived from this text too).`;
@@ -17785,21 +18931,26 @@ const issueFocusSegment = (focus) => ({
 	text: `Per-issue review focus (source: issue #${focus.issueNumber} "${REVIEW_FOCUS_SECTION}" section, appended verbatim):
 ${focus.text}`
 });
-const priorLedgerEntryLine = (entry) => {
-	const location = entry.file ? ` (${entry.file})` : "";
-	const reference = entry.reference ? ` — ${entry.reference}` : "";
-	return `- [${entry.disposition === "open" ? "open, unadjudicated" : entry.disposition}] "${entry.title}"${location}${reference} (flagged ${entry.flagCount}x)`;
-};
+const priorOccurrenceLine = (entry, occurrence) => {
+	const location = occurrence.finding.file ? ` (${occurrence.finding.file})` : "";
+	const repeat = occurrence.root === occurrence.address ? "" : ` — repeats ${occurrence.root}`;
+	const why = occurrence.reference ?? occurrence.rule;
+	const reference = why === void 0 ? "" : ` — ${why}`;
+	const disposition = occurrence.disposition === "open" ? "open, unadjudicated" : `${occurrence.disposition}, ${occurrence.authority ?? "recorded"}`;
+	const title = occurrence.finding.title.trim() || entry.title;
+	return `- ${occurrence.address} [${disposition}] "${title}"${location}${repeat}${reference}`;
+};
+const priorLedgerLines = (entries) => entries.flatMap((entry) => entry.occurrences.map((occurrence) => priorOccurrenceLine(entry, occurrence))).join("\n");
 const priorLedgerSegment = (entries) => ({
 	section: {
 		provenance: "prior-review-ledger",
 		source: "persisted pr:review disposition ledger (prior cycles, #233)",
-		text: entries.map(priorLedgerEntryLine).join("\n")
+		text: priorLedgerLines(entries)
 	},
-	text: `Prior review ledger (source: persisted pr:review disposition ledger from earlier cycles on this PR):
-${entries.map(priorLedgerEntryLine).join("\n")}
+	text: `Prior review ledger (source: persisted pr:review disposition ledger from earlier cycles on this PR; one line per recorded occurrence, by address):
+${priorLedgerLines(entries)}
 
-Open entries above are unadjudicated: they still need a disposition or a supersedes citation. Do not re-raise any already-adjudicated finding (waived, filed as a follow-up, or fixed in this thread) under a new title. If this finding is a restatement of a prior finding shown in this ledger, set supersedes to {"title": "<exact prior title>", "file": "<its file>"} instead of minting a new title for the same theme.`
+Open occurrences above are unadjudicated: each still needs a disposition. If your review verifies that an open occurrence is resolved at this patch, name it in the findings file's resolutions by address with the reason (resolutions are accepted at every findings schemaVersion); an occurrence you do not name stays open, because silence is never resolution. Do not re-raise any already-adjudicated occurrence (waived, filed as a follow-up, policy-accepted, or fixed in this thread) under a new title. If a finding restates a prior occurrence shown here, set supersedes to {"title": "<exact prior title>", "file": "<its file>"} instead of minting a new title for the same theme.`
 });
 const assembleReviewPrompt = ({ base, changedFiles, cwd = process.cwd(), headSha, issueFocus, kind, patchId, priorLedgerEntries, profile, waveRung }, dependencies = {}) => {
 	const priorLedger = priorLedgerEntries ?? [];
@@ -17836,6 +18987,20 @@ const assembleReviewPrompt = ({ base, changedFiles, cwd = process.cwd(), headSha
 	};
 };
 //#endregion
+//#region src/review-recording-id.ts
+const lengthPrefixed = (field) => `${Buffer.byteLength(field, "utf-8")}:${field}`;
+const reviewRecordingId = ({ baseSha, dispositionsBytes, findingsBytes, historical, model, patchId, producer, rung, sessionId }) => sha256Hex([
+	patchId,
+	baseSha,
+	sessionId,
+	producer ?? "",
+	rung ?? "",
+	model,
+	historical ? "1" : "0",
+	sha256Hex(findingsBytes),
+	sha256Hex(dispositionsBytes ?? "")
+].map((field) => lengthPrefixed(field)).join(""));
+//#endregion
 //#region src/pr-review.ts
 const DEFAULT_ASSEMBLED_REVIEW_PROMPT_PATH = ".factory-memory/pr-review-prompt.json";
 const MISSING_ASSEMBLED_PROMPT_NOTICE = "pr:review notice: assembled review prompt not found at .factory-memory/pr-review-prompt.json; accepting findings without promptSections.";
@@ -17966,7 +19131,7 @@ const emptyProof = (input) => ({
 	reviewCycle: input.cycle,
 	...input.reviewRequirement ? { reviewRequirement: input.reviewRequirement } : {},
 	reviews: [],
-	schemaVersion: 2
+	schemaVersion: 3
 });
 const assertIndependentSession = ({ headSha, patchId, reviewSessionId, verifyProof }) => {
 	if (reviewSessionId === "unknown") throw new Error("Review independence cannot be confirmed: findings sessionId is unknown.");
@@ -18021,7 +19186,12 @@ const reviewResults = (findingsFile, kinds, startedAt, endedAt) => {
 	});
 };
 const assertReviewOutcomes = (proof, policy, cycle, maxCycles) => {
-	if (!proof.reviews.some((review) => resolveReviewAcceptance(proof, review, policy) === "blocked")) return;
+	const acceptances = new Set(proof.reviews.map((review) => resolveReviewAcceptance(proof, review, policy)));
+	if (acceptances.has("recovery-required")) {
+		for (const line of describeRecoveryRequired(proof.recoveryRequired ?? [])) console.error(line);
+		throw new Error("pr:review recorded the cycle, but the proof requires recovery of a schema-2 declaration before it can admit.");
+	}
+	if (!acceptances.has("blocked")) return;
 	const state = reviewCycleStateFor(proof, policy);
 	if (proof.reviews.some((review) => review.outcome === "passed")) console.error(`Stored review outcome is passed, but a re-fold of persisted cycles yields ${state.autoBlockingFindings} auto-blocking finding(s) and ${state.openFindings} open finding(s). The stored pass and the ladder disagree.`);
 	else if (cycle >= maxCycles) console.error(`Review cycle limit reached (${cycle}/${maxCycles}). Stop and request human direction before rerunning.`);
@@ -18043,19 +19213,18 @@ const assembleGitDependencies = (git) => git.repositoryRoot !== void 0 && git.sh
 	repositoryRoot: git.repositoryRoot,
 	showFileAtRef: git.showFileAtRef
 } : void 0;
-const writeAssembledReviewPrompt = ({ args, cwd, fetchIssueBody, files, git, headSha, kinds, output, patchId, profile, waveRung }) => {
+const writeAssembledReviewPrompt = ({ args, baseRef, cwd, fetchIssueBody, files, git, headSha, kinds, output, patchId, profile, waveRung }) => {
 	const priorLedger = priorLedgerFor(priorLadderStateFor({
-		base: args.base,
-		cwd,
+		base: baseRef,
 		headSha,
 		isAncestor: (ancestor, descendant) => git.isAncestor(cwd, ancestor, descendant),
-		output
+		prior: readOptionalProofFor(PR_REVIEW_PROOF_DESCRIPTOR, cwd, output)
 	}));
 	const issueFocus = args.issue === void 0 ? void 0 : loadIssueFocus(args.issue, profile, fetchIssueBody);
 	const assembleGit = assembleGitDependencies(git);
 	const assembledReviews = kinds.map((kind) => {
 		const assembled = assembleReviewPrompt({
-			base: args.base,
+			base: baseRef,
 			changedFiles: files,
 			cwd,
 			headSha,
@@ -18129,13 +19298,13 @@ const withAssembledPromptSections = (reviews, sectionsByKind) => {
 * this, a candidate that removed `review` from its own profile briefed the
 * reviewer on correctness alone and then presented that evidence as complete.
 */
-const reviewPolicyIdentity = ({ args, changedFiles: files, cwd, dependencies, git, profile, profilePath }) => resolveStageReviewDemand({
+const reviewPolicyIdentity = ({ baseRef, changedFiles: files, cwd, dependencies, git, profile, profilePath, pullRequestLookup }) => resolveStageReviewDemand({
 	authority: dependencies.basePolicy ?? defaultBaseReviewPolicyAuthority(),
-	callerBaseRef: args.base,
+	callerBaseRef: baseRef,
 	candidatePolicy: profile.review,
 	changedFiles: files,
 	cwd,
-	lookupPullRequest: dependencies.lookupPullRequest ?? lookupCandidatePullRequest,
+	lookupPullRequest: dependencies.lookupPullRequest ?? (() => policyLookupFromBaseLookup(pullRequestLookup)),
 	profilePath: repositoryRelativeProfilePath({
 		cwd,
 		profilePath
@@ -18147,7 +19316,7 @@ const reviewPolicyIdentity = ({ args, changedFiles: files, cwd, dependencies, gi
 * nothing extra here; `pr:ready` is the stage that refuses on it (#922).
 */
 const demandedReviewKinds = (policy) => policy.status === "authoritative" ? policy.reviewModes : [];
-const resolveFindingsBinding = ({ args, cwd, findingsPatchId, git, headSha, patchId }) => {
+const resolveFindingsBinding = ({ args, base, cwd, findingsPatchId, git, headSha, patchId }) => {
 	const atCandidate = evidenceFresh({
 		candidate: {
 			headSha,
@@ -18162,20 +19331,19 @@ const resolveFindingsBinding = ({ args, cwd, findingsPatchId, git, headSha, patc
 	}
 	if (atCandidate) throw new Error(`--historical findings already match the candidate stable patch-id ${patchId}. Record them as the current cycle, without --historical.`);
 	const ancestors = resolveAncestorCandidatePatchIds({
-		base: args.base,
+		base: base.sha,
 		cwd,
 		firstParentCommits: git.firstParentCommits ?? firstParentCommits,
 		headSha,
 		stablePatchIdAtRef: git.stablePatchIdAtRef ?? defaultStablePatchIdAtRef
 	});
 	const matched = ancestors.find((ancestor) => ancestor.patchId === findingsPatchId);
-	if (!matched) throw new Error(`Review findings patchId ${findingsPatchId} matches no commit on this branch. The candidate stable patch-id is ${patchId}, and ${ancestors.length} earlier head(s) of this branch above ${args.base} were checked. A historical cycle must name a patch this branch really had; a commit a merge brought in from the base is not one of them. A cycle recorded against a different base cannot be matched here, because every patch-id is computed against ${args.base}.`);
+	if (!matched) throw new Error(`Review findings patchId ${findingsPatchId} matches no commit on this branch. The candidate stable patch-id is ${patchId}, and ${ancestors.length} earlier head(s) of this branch above ${base.ref} (${base.sha}) were checked. A historical cycle must name a patch this branch really had; a commit a merge brought in from the base is not one of them. A cycle recorded against a different base cannot be matched here, because every patch-id is computed against ${base.ref} at ${base.sha}.`);
 	return {
 		kind: "historical",
 		ref: matched.ref
 	};
 };
-const currentCycleDispositionTargets = (historical, findingsFile) => historical ? findingsFile.reviews.flatMap((review) => review.findings) : [];
 /** The flag combinations that describe no single run. */
 const assertReviewFlagsCombine = (args) => {
 	if (args.assemble === true && args.findings !== void 0) throw new Error("--assemble and --findings cannot be combined; they are sequential steps.");
@@ -18225,8 +19393,7 @@ const cycleRecordFor = ({ binding, cwd, findingsFile, identity, kinds, startedAt
 * with, cannot show which policy produced it: the verdict drops, exactly as the
 * other-patch case does.
 */
-const carriedVerdictFor = ({ cwd, output, patchId, policy }) => {
-	const prior = readOptionalProofFor(PR_REVIEW_PROOF_DESCRIPTOR, cwd, output);
+const carriedVerdictFor = ({ patchId, policy, prior }) => {
 	if (!prior || !evidenceFresh({
 		candidate: { patchId },
 		recorded: { patchId: prior.patchId },
@@ -18240,11 +19407,324 @@ const carriedVerdictFor = ({ cwd, output, patchId, policy }) => {
 		stage: "pr:review"
 	}) ? [] : prior.reviews;
 };
+/**
+* Bind the candidate to its base before anything is measured (#1131). A pull
+* request's live base wins and a disagreeing --base is refused; the SHA is
+* what every diff is computed against, the ref is what the proof records
+* (review-lineage keys on it). The pull request read here also serves the
+* policy-authority lookup, so one GitHub read answers both.
+*/
+const bindCandidateBase = ({ args, cwd, dependencies, git }) => {
+	const pullRequestLookup = (dependencies.lookupPullRequestBase ?? lookupLivePullRequestBase)(cwd);
+	const base = resolveCandidateBase({
+		cwd,
+		dependencies: {
+			fetchOriginRef: git.fetchOriginRef ?? fetchOriginRef,
+			liveBranchTipSha: dependencies.liveBranchTipSha ?? liveBranchTipSha,
+			lookupPullRequestBase: () => pullRequestLookup,
+			resolveCommitSha: git.resolveCommitSha ?? resolveCommitSha
+		},
+		requestedBase: args.base
+	});
+	console.log(`pr:review ${describeCandidateBase(base)}`);
+	return {
+		base,
+		pullRequestLookup
+	};
+};
+/**
+* The line that states a review cycle was recorded (#1131). Printed before
+* admission is judged, so "recorded" and "refused" are reported as two facts.
+*/
+const recordedReviewProofLine = ({ cycle, headSha, historical, output, patchId, recordingId }) => `pr:review recorded ${historical ? "historical " : ""}cycle ${cycle} findings for patch ${patchId} at ${headSha}: proof written to ${output} (recording ${recordingId}).`;
+/**
+* The line an identical retry prints (#1131, decision 6): the recording is
+* already on the ladder, so nothing is written and no cycle is consumed.
+*/
+const ALREADY_RECORDED_PREFIX = "already-recorded";
+const alreadyRecordedLine = ({ output, recordingId }) => `${ALREADY_RECORDED_PREFIX}: recording ${recordingId} is already on the ladder in ${output}; nothing written, no cycle consumed.`;
+/**
+* The findings file, read once as bytes and parsed from those bytes (#1131):
+* the recording identity digests, retains and records exactly what was
+* validated.
+*/
+const readFindingsInput = (findingsPath, cwd) => {
+	const resolved = path.resolve(cwd, findingsPath);
+	const bytes = readFileSync(resolved, "utf-8");
+	return {
+		bytes,
+		file: parseReviewFindingsBytes(bytes, resolved)
+	};
+};
+/**
+* The proof already on disk, parsed from the bytes whose digest this
+* recording is applied to. A file that does not parse is refused: recording
+* over it would replace history this run cannot read. A schema-2 proof is
+* converted here by the bounded import (#1068); its original bytes are
+* retained before the converted proof is written.
+*/
+const parsePriorProof = (bytes, output) => {
+	try {
+		return parseReviewProofBytes(bytes);
+	} catch (error) {
+		throw new Error(`pr:review refuses to record over an unreadable proof at ${output}: ${error instanceof Error ? error.message : String(error)} Move the file aside to start fresh ladder history, or re-record once it can be read.`, { cause: error });
+	}
+};
+/**
+* The --output copy is optional (decision 6): a failure is reported on its
+* own line and never unrecords the canonical proof.
+*/
+const writeOptionalProofCopy = (proof, additional, canonical) => {
+	if (additional === void 0 || additional === canonical) return;
+	try {
+		writeProofJson(proof, additional);
+	} catch (error) {
+		console.error(`pr:review optional copy not written to ${additional}: ${error instanceof Error ? error.message : String(error)}. The canonical proof at ${canonical} is recorded.`);
+	}
+};
+/**
+* A proof file system whose rename raises the injected fault (#1131): the
+* temp file is written and fsynced, the canonical path is never replaced.
+*/
+const faultingProofFileSystem = (point) => ({
+	closeSync: nodeFs.closeSync,
+	fsyncSync: nodeFs.fsyncSync,
+	mkdirSync: nodeFs.mkdirSync,
+	openSync: nodeFs.openSync,
+	readFileSync: nodeFs.readFileSync,
+	renameSync: () => {
+		throw new InjectedReviewFaultError(point);
+	},
+	statSync: nodeFs.statSync,
+	unlinkSync: nodeFs.unlinkSync,
+	writeFileSync: nodeFs.writeFileSync
+});
+/**
+* The cycle number to report on the recorded-proof line (#1131). This is the
+* ladder's own assignment — the same value `eventFor` in review-ladder.ts
+* stamps onto the trace event's `cycle` field — never a recomputation of it.
+* A requested `--cycle` can under-report when a prior ladder carries forward
+* onto this run, so it is only the fallback for the (practically unreachable)
+* case where a cycle was just appended but the evaluator emitted no event.
+*/
+const reportedLadderCycle = (evaluation, requestedCycle) => evaluation.event?.cycle ?? requestedCycle;
+/**
+* A schema-2 proof the bounded import just converted (#1068): its original
+* bytes are retained, content-addressed under the digest the converted proof
+* names, before that proof replaces them. Nothing is retained when the
+* lineage broke and the imported history is not being carried forward.
+*/
+const retainImportedProofBytes = ({ cwd, prior, priorLadder, proofState }) => {
+	if (priorLadder === void 0 || !prior?.importedFrom || !proofState.present) return;
+	retainReviewBytes({
+		bytes: proofState.bytes,
+		cwd,
+		directory: REVIEW_PROOF_IMPORT_RETENTION_DIR
+	});
+};
+/**
+* Import provenance rides with the imported history (#1068). Recovery items
+* ride too, until a recording carries an explicit --dispositions file: that
+* file is the operator's act after reading the candidate addresses, whatever
+* it declares.
+*/
+const importedHistoryFields = ({ declared, prior, priorLadder }) => {
+	if (priorLadder === void 0 || !prior?.importedFrom) return {};
+	const targets = new Set(declared.map((record) => record.target));
+	const remaining = (prior.recoveryRequired ?? []).filter((item) => !item.candidates.some((candidate) => targets.has(candidate)));
+	return {
+		importedFrom: prior.importedFrom,
+		recoveryRequired: remaining
+	};
+};
+/**
+* Record one review cycle (#1131). The recording is a separate fact from
+* admission: this returns what was recorded (or that it already was), and
+* the caller judges admission afterwards.
+*
+* Order: read the proof bytes once (their digest is the state the recording
+* is applied to; an unreadable proof is a refusal) → compute the recording
+* identity and answer an identical retry with `already-recorded`, writing
+* nothing → translate declarations → retain the reviewer's bytes → fold →
+* compare-and-swap write → recorded line → best-effort copies.
+*/
+const recordReviewCycle = ({ additionalOutput, args, base, cwd, dependencies, files, findingsInput, git, headSha, kinds, ladderPolicy, maxCycles, output, patchId, policy, profile, startedAt, verifyProof }) => {
+	const findingsFile = findingsInput.file;
+	const fault = resolveReviewFault({ allowFaultInjection: args.allowFaultInjection });
+	const binding = resolveFindingsBinding({
+		args,
+		base,
+		cwd,
+		findingsPatchId: findingsFile.patchId,
+		git,
+		headSha,
+		patchId
+	});
+	assertIndependentSession({
+		headSha,
+		patchId,
+		reviewSessionId: findingsFile.sessionId,
+		verifyProof
+	});
+	const proofState = readProofFileState(output);
+	const prior = proofState.present ? parsePriorProof(proofState.bytes, output) : void 0;
+	const historical = binding.kind === "historical";
+	const dispositionsInput = readDeclaredDispositions(args.dispositions, cwd);
+	const { identity, reviews } = cycleRecordFor({
+		binding,
+		cwd,
+		findingsFile,
+		identity: {
+			headSha,
+			patchId
+		},
+		kinds,
+		startedAt
+	});
+	const recordingId = reviewRecordingId({
+		baseSha: base.sha,
+		dispositionsBytes: dispositionsInput?.bytes,
+		findingsBytes: findingsInput.bytes,
+		historical,
+		model: findingsFile.model,
+		patchId: identity.patchId,
+		producer: findingsFile.producer,
+		rung: findingsFile.rung,
+		sessionId: findingsFile.sessionId
+	});
+	const alreadyRecorded = prior?.ladder?.cycles.find((cycle) => "recordingId" in cycle.recording && cycle.recording.recordingId === recordingId);
+	if (prior && alreadyRecorded) {
+		console.log(alreadyRecordedLine({
+			output,
+			recordingId
+		}));
+		return {
+			outcome: "already-recorded",
+			proof: prior
+		};
+	}
+	const priorLadder = priorLadderStateFor({
+		base: base.ref,
+		headSha,
+		isAncestor: (ancestor, descendant) => git.isAncestor(cwd, ancestor, descendant),
+		prior
+	});
+	const currentFindings = reviews.flatMap((review) => review.findings.map((finding) => toLadderFindingReport(finding)));
+	const declared = resolveDeclaredDispositions({
+		declarations: dispositionsInput?.declarations ?? [],
+		index: occurrenceIndexFor([...priorLadder?.cycles ?? [], ...historical ? [{ findings: currentFindings }] : []]),
+		resolutions: findingsFile.resolutions ?? []
+	});
+	retainImportedProofBytes({
+		cwd,
+		prior,
+		priorLadder,
+		proofState
+	});
+	const retainedFindings = retainReviewBytes({
+		bytes: findingsInput.bytes,
+		cwd
+	});
+	const retainedDispositions = dispositionsInput ? retainReviewBytes({
+		bytes: dispositionsInput.bytes,
+		cwd
+	}) : void 0;
+	faultAt(fault, "after-retain");
+	const runs = reviews.map((review) => ({ review }));
+	const { evaluation, ladder } = ladderStateForRun({
+		historical,
+		identity,
+		model: findingsFile.model,
+		policy: ladderPolicy,
+		priorLadder,
+		recording: {
+			appliedTo: proofState.digest,
+			base: {
+				ref: base.ref,
+				sha: base.sha
+			},
+			declarations: declared,
+			...retainedDispositions === void 0 ? {} : { dispositionsDigest: retainedDispositions.digest },
+			findingsDigest: retainedFindings.digest,
+			recordingId
+		},
+		runs,
+		sessionAttribution: { sessionId: findingsFile.sessionId }
+	});
+	const proof = {
+		base: base.ref,
+		changedFiles: files,
+		cleanedPaths: [],
+		findingProvenanceVersion: 1,
+		headSha,
+		...importedHistoryFields({
+			declared,
+			prior,
+			priorLadder
+		}),
+		ladder,
+		maxReviewCycles: maxCycles,
+		patchId,
+		policyResolution: policy.policyResolution,
+		reviewCycle: args.cycle,
+		reviews: historical ? carriedVerdictFor({
+			patchId,
+			policy,
+			prior
+		}) : reviews,
+		schemaVersion: 3
+	};
+	dependencies.beforeProofWrite?.();
+	writeProofJsonApplied(proof, output, proofState.digest, fault === "proof-rename" ? faultingProofFileSystem(fault) : void 0);
+	faultAt(fault, "after-proof-write");
+	console.log(recordedReviewProofLine({
+		cycle: reportedLadderCycle(evaluation, args.cycle),
+		headSha: identity.headSha,
+		historical,
+		output,
+		patchId: identity.patchId,
+		recordingId
+	}));
+	writeOptionalProofCopy(proof, additionalOutput, output);
+	enqueueHqIngest({
+		cwd,
+		kind: "pr-review-proof",
+		payload: proof,
+		payloadPath: output,
+		profile,
+		...args.issue === void 0 ? {} : { subject: { issueNumber: args.issue } }
+	}, dependencies.hq);
+	emitLadderStageTrace({
+		cwd,
+		evaluation,
+		headSha,
+		issue: args.issue,
+		patchId,
+		profile
+	});
+	if (binding.kind === "historical") {
+		console.error(`pr:review recorded a historical cycle for patch ${findingsFile.patchId} at commit ${binding.ref}. It renders no verdict of its own; admission needs a clean cycle at ${patchId}.`);
+		return {
+			outcome: "historical",
+			proof
+		};
+	}
+	return {
+		outcome: "recorded",
+		proof
+	};
+};
 async function runPrReview(args, dependencies = {}) {
 	assertReviewFlagsCombine(args);
 	const cwd = path.resolve(args.cwd ?? process.cwd());
 	const git = dependencies.git ?? defaultPrReviewGit();
-	const files = git.changedFiles(cwd, args.base);
+	const { base, pullRequestLookup } = bindCandidateBase({
+		args,
+		cwd,
+		dependencies,
+		git
+	});
+	const files = git.changedFiles(cwd, base.sha);
 	assertCleanWorktreeForProof({
 		changedFiles: files,
 		cwd,
@@ -18261,7 +19741,7 @@ async function runPrReview(args, dependencies = {}) {
 	const { headSha, patchId } = createCandidateIdentityResolver({
 		cwd,
 		git
-	})(args.base);
+	})(base.sha);
 	const { additional: additionalOutput, canonical: output } = resolveProofOutputPaths(cwd, DEFAULT_PR_REVIEW_PROOF_PATH, args.output);
 	const verifyProof = readOptionalProofFor(PR_VERIFY_PROOF_DESCRIPTOR$1, cwd, args.verifyProof ?? ".factory-memory/pr-verify.json");
 	const writeProofCopies = (proof) => {
@@ -18276,20 +19756,22 @@ async function runPrReview(args, dependencies = {}) {
 		}, dependencies.hq);
 	};
 	const startedAt = /* @__PURE__ */ new Date();
-	const findingsFile = args.findings ? parseReviewFindingsFile(args.findings, cwd) : void 0;
+	const findingsInput = args.findings ? readFindingsInput(args.findings, cwd) : void 0;
+	const findingsFile = findingsInput?.file;
 	const policy = reviewPolicyIdentity({
-		args,
+		baseRef: base.ref,
 		changedFiles: files,
 		cwd,
 		dependencies,
 		git,
 		profile,
-		profilePath
+		profilePath,
+		pullRequestLookup
 	});
 	const kinds = enabledKinds(profile, args.mode, files, findingsFile?.reviews.map((review) => review.kind) ?? [], demandedReviewKinds(policy));
 	if (args.assemble === true) {
 		const assembleProof = () => emptyProof({
-			base: args.base,
+			base: base.ref,
 			cycle: args.cycle,
 			files,
 			headSha,
@@ -18302,7 +19784,7 @@ async function runPrReview(args, dependencies = {}) {
 			return assembleProof();
 		}
 		if ((git.recognizeCatchUp ?? recognizeCatchUpCandidate)({
-			base: args.base,
+			base: base.sha,
 			cwd
 		}).recognized) {
 			console.log(ASSEMBLE_FAITHFUL_MERGE_NOTICE);
@@ -18311,6 +19793,7 @@ async function runPrReview(args, dependencies = {}) {
 		const fetchIssueBody = dependencies.fetchIssueBody ?? defaultFetchIssueBody;
 		writeAssembledReviewPrompt({
 			args,
+			baseRef: base.ref,
 			cwd,
 			fetchIssueBody,
 			files,
@@ -18333,7 +19816,7 @@ async function runPrReview(args, dependencies = {}) {
 	}
 	const mintNotRequiredProof = (reviewRequirement) => {
 		const proof = emptyProof({
-			base: args.base,
+			base: base.ref,
 			cycle: args.cycle,
 			files,
 			headSha,
@@ -18367,7 +19850,7 @@ async function runPrReview(args, dependencies = {}) {
 	});
 	if (!findingsFile) {
 		if ((git.recognizeCatchUp ?? recognizeCatchUpCandidate)({
-			base: args.base,
+			base: base.sha,
 			cwd
 		}).recognized) return mintNotRequiredProof({
 			reason: "faithful-merge",
@@ -18375,89 +19858,29 @@ async function runPrReview(args, dependencies = {}) {
 		});
 		throw new Error("--findings <path> is required when review kinds are enabled.");
 	}
-	const binding = resolveFindingsBinding({
+	const recorded = recordReviewCycle({
+		additionalOutput,
 		args,
+		base,
 		cwd,
-		findingsPatchId: findingsFile.patchId,
+		dependencies,
+		files,
+		findingsInput,
 		git,
 		headSha,
-		patchId
-	});
-	assertIndependentSession({
-		headSha,
-		patchId,
-		reviewSessionId: findingsFile.sessionId,
-		verifyProof
-	});
-	const priorLadder = priorLadderStateFor({
-		base: args.base,
-		cwd,
-		headSha,
-		isAncestor: (ancestor, descendant) => git.isAncestor(cwd, ancestor, descendant),
-		output
-	});
-	const priorLedger = priorLedgerFor(priorLadder);
-	const declaredDispositions = declaredDispositionsFor(args.dispositions, cwd);
-	const historical = binding.kind === "historical";
-	assertDeclaredDispositionsMatch(priorLedger, declaredDispositions, currentCycleDispositionTargets(historical, findingsFile));
-	const { identity, reviews } = cycleRecordFor({
-		binding,
-		cwd,
-		findingsFile,
-		identity: {
-			headSha,
-			patchId
-		},
 		kinds,
-		startedAt
-	});
-	const runs = reviews.map((review) => ({ review }));
-	const { evaluation, ladder } = ladderStateForRun({
-		cycle: args.cycle,
-		declaredDispositions,
-		historical,
-		identity,
-		model: findingsFile.model,
-		policy: ladderPolicy,
-		priorLadder,
-		priorLedger,
-		runs,
-		sessionAttribution: { sessionId: findingsFile.sessionId }
-	});
-	const proof = {
-		base: args.base,
-		changedFiles: files,
-		cleanedPaths: [],
-		findingProvenanceVersion: 1,
-		headSha,
-		ladder,
-		maxReviewCycles: maxCycles,
-		patchId,
-		policyResolution: policy.policyResolution,
-		reviewCycle: args.cycle,
-		reviews: historical ? carriedVerdictFor({
-			cwd,
-			output,
-			patchId,
-			policy
-		}) : reviews,
-		schemaVersion: 2
-	};
-	writeProofCopies(proof);
-	emitLadderStageTrace({
-		cwd,
-		evaluation,
-		headSha,
-		issue: args.issue,
+		ladderPolicy,
+		maxCycles,
+		output,
 		patchId,
-		profile
+		policy,
+		profile,
+		startedAt,
+		verifyProof
 	});
-	if (binding.kind === "historical") {
-		console.error(`pr:review recorded a historical cycle for patch ${findingsFile.patchId} at commit ${binding.ref}. It renders no verdict of its own; admission needs a clean cycle at ${patchId}.`);
-		return proof;
-	}
-	assertReviewOutcomes(proof, ladderPolicy, args.cycle, maxCycles);
-	return proof;
+	if (recorded.outcome !== "recorded") return recorded.proof;
+	assertReviewOutcomes(recorded.proof, ladderPolicy, args.cycle, maxCycles);
+	return recorded.proof;
 }
 //#endregion
 //#region src/pr-publish.ts
@@ -18518,16 +19941,52 @@ const defaultFollowUpRunner = (factoryCliInvocation) => (followUp, cwd) => {
 const prPublishCliInvocation = (explicit) => explicit ?? defaultFactoryCliInvocation(factoryCliEntry());
 const errorMessage = (error) => error instanceof Error ? error.message : String(error);
 /**
-* GitHub creates a pull request against a branch name, while the rest of the
-* publish transaction treats `--base` as an exact local Git-ref assertion.
-* Keep those representations separate: only the creation adapter drops the
-* canonical remote qualifier, and callers downstream retain the original ref.
+* The base one on-disk proof recorded, keeping the doctor's absent/invalid
+* split (#1121, #1151): no file is no recorded base, but a file that cannot
+* be read — a schema-version mismatch, corrupt JSON — refuses, because
+* reading it as absent would create the PR against the repository default,
+* the #1153 failure again.
 */
-function githubCreationBranchForBaseAssertion(base) {
-	return base.startsWith("origin/") ? base.slice(7) : base;
-}
-function discoverOrCreatePullRequestNumber({ args, branch, cwd, gh }) {
-	if (args.pr !== void 0) return args.pr;
+const recordedProofBase = (read, proofPath) => {
+	if (read.proof) return read.proof.base;
+	if (read.error?.code === "ENOENT") return;
+	throw new Error(`pr:publish refuses to create the pull request: the proof at ${proofPath} is present but cannot be read (${errorMessage(read.error)}), so the base it recorded is unknown. Re-record it with the current CLI, or remove the file to create against the repository default branch.`);
+};
+/**
+* The base a missing pull request is created against (#1153).
+*
+* `pr:verify` and `pr:review` record the base they measured on their proofs
+* as the local ref (`origin/<branch>`). Before this, publish created the PR
+* with no `--base` unless the operator repeated it, so every each-to-epic
+* member of #1130 opened against `main`, was measured against `main` (an
+* empty diff and a zero patch id), and had to be re-based by hand. The
+* precedence is: an explicit `--base` on publish, else the base the on-disk
+* proofs recorded, else no `--base` at all — GitHub then targets the
+* repository default branch. Two bases that disagree are refused with both
+* printed, before anything is created; agreement is by branch name, because
+* that is what GitHub creates the PR against.
+*/
+function pullRequestCreationBase({ args, cwd, reviewProofPath, verifyProofPath }) {
+	const verifyBase = recordedProofBase(tryReadProof((proofPath) => readProofFor(PR_VERIFY_PROOF_DESCRIPTOR$1, cwd, proofPath), verifyProofPath), verifyProofPath);
+	const reviewBase = recordedProofBase(tryReadProof((proofPath) => readProofFor(PR_REVIEW_PROOF_DESCRIPTOR, cwd, proofPath), reviewProofPath), reviewProofPath);
+	if (verifyBase !== void 0 && reviewBase !== void 0 && candidateBaseBranch(verifyBase) !== candidateBaseBranch(reviewBase)) throw new Error(`pr:publish refuses to create the pull request: the on-disk proofs disagree on the base — pr:verify recorded ${verifyBase} and pr:review recorded ${reviewBase}. Re-run the chain against one base, then publish.`);
+	let recorded;
+	if (verifyBase !== void 0) recorded = {
+		ref: verifyBase,
+		source: "the pr:verify proof"
+	};
+	else if (reviewBase !== void 0) recorded = {
+		ref: reviewBase,
+		source: "the pr:review proof"
+	};
+	if (args.base.length > 0) {
+		if (recorded && candidateBaseBranch(args.base) !== candidateBaseBranch(recorded.ref)) throw new Error(`pr:publish refuses to create the pull request: --base ${args.base} disagrees with the base recorded on ${recorded.source}, ${recorded.ref}. Omit --base to create against the recorded base, or re-run the chain against ${args.base}.`);
+		return candidateBaseBranch(args.base);
+	}
+	return recorded ? candidateBaseBranch(recorded.ref) : void 0;
+}
+function discoverOrCreatePullRequest({ args, branch, cwd, gh, reviewProofPath, verifyProofPath }) {
+	if (args.pr !== void 0) return { number: args.pr };
 	if (!branch) throw new Error("pr:publish cannot discover a PR from a detached HEAD; pass --pr.");
 	const lookupArgs = [
 		"pr",
@@ -18535,24 +19994,43 @@ function discoverOrCreatePullRequestNumber({ args, branch, cwd, gh }) {
 		"--head",
 		branch,
 		"--json",
-		"number",
+		"number,baseRefName",
 		"--limit",
 		"1"
 	];
-	const existing = JSON.parse(gh(lookupArgs, cwd));
-	if (existing[0]) return existing[0].number;
+	const lookup = () => JSON.parse(gh(lookupArgs, cwd));
+	const [existing] = lookup();
+	if (existing) return { number: existing.number };
+	const creationBase = pullRequestCreationBase({
+		args,
+		cwd,
+		reviewProofPath,
+		verifyProofPath
+	});
 	const createArgs = [
 		"pr",
 		"create",
 		"--draft",
 		"--fill"
 	];
-	if (args.base.length > 0) createArgs.push("--base", githubCreationBranchForBaseAssertion(args.base));
+	if (creationBase !== void 0) createArgs.push("--base", creationBase);
 	gh(createArgs, cwd);
-	const created = JSON.parse(gh(lookupArgs, cwd));
-	if (!created[0]) throw new Error(`gh pr create completed but no PR was found for branch ${branch}.`);
-	return created[0].number;
+	const [created] = lookup();
+	if (!created) throw new Error(`gh pr create completed but no PR was found for branch ${branch}.`);
+	const base = created.baseRefName ?? creationBase ?? "the repository default branch";
+	process.stderr.write(`${createdPullRequestLine({
+		base,
+		number: created.number
+	})}\n`);
+	return {
+		created: {
+			base,
+			number: created.number
+		},
+		number: created.number
+	};
 }
+const createdPullRequestLine = ({ base, number }) => `pr:publish created PR #${number} against ${base}`;
 const readOptionalVerifyProof = (cwd, proofPath) => readOptionalProofFor(PR_VERIFY_PROOF_DESCRIPTOR$1, cwd, proofPath);
 const followUpSummaryLine = (outcome) => {
 	if (outcome.status === "succeeded") return `Follow-up succeeded: ${outcome.action.command} — ${outcome.reason}.`;
@@ -18563,6 +20041,7 @@ const verificationReuseSummaryLine = (reuse) => reuse.reused ? `Verification reu
 const readySummaryLine = (handoff) => handoff.scheduled ? "pr:publish ready — the merge is on GitHub's schedule; no human actions owed." : "pr:publish admitted, not handed off — the candidate passed but nothing is scheduled to merge it. See the readiness proof's notices and follow-up.";
 const renderPublishSummary = (result) => {
 	const lines = result.handoff.status === "ready" ? [readySummaryLine(result.handoff)] : [`pr:publish blocked (${result.handoff.status}). Human actions owed:`, ...result.handoff.humanActions.length === 0 ? ["- Route-owned repairs remain; see readiness proof repairs."] : result.handoff.humanActions.map((action) => `- ${action}`)];
+	if (result.createdPullRequest) lines.unshift(createdPullRequestLine(result.createdPullRequest));
 	if (result.verificationReuse) lines.push(verificationReuseSummaryLine(result.verificationReuse));
 	lines.push(followUpSummaryLine(result.followUp));
 	const binding = result.verifyProofBinding ? verifyProofBindingSummaryLine(result.verifyProofBinding) : void 0;
@@ -18992,12 +20471,17 @@ async function runPrPublish(args, dependencies = {}) {
 		cwd,
 		profilePath: args.profilePath
 	});
-	const prNumber = discoverOrCreatePullRequestNumber({
+	const verifyProofPath = path.resolve(cwd, args.verifyProof ?? ".factory-memory/pr-verify.json");
+	const reviewProofPath = path.resolve(cwd, args.reviewProof ?? ".factory-memory/pr-review.json");
+	const discovered = discoverOrCreatePullRequest({
 		args,
 		branch: args.pr === void 0 ? (dependencies.currentBranch ?? currentBranchName)(cwd) : void 0,
 		cwd,
-		gh: dependencies.gh ?? defaultGhRunner$1
+		gh: dependencies.gh ?? defaultGhRunner$1,
+		reviewProofPath,
+		verifyProofPath
 	});
+	const prNumber = discovered.number;
 	const readyArgs = {
 		...args,
 		pr: prNumber
@@ -19020,8 +20504,6 @@ async function runPrPublish(args, dependencies = {}) {
 			pr: fetchPr()
 		})
 	};
-	const verifyProofPath = path.resolve(cwd, args.verifyProof ?? ".factory-memory/pr-verify.json");
-	const reviewProofPath = path.resolve(cwd, args.reviewProof ?? ".factory-memory/pr-review.json");
 	const headSha = (dependencies.git?.currentHeadSha ?? currentHeadSha)(cwd);
 	const verified = await ensureVerifyProof({
 		args: publishArgs,
@@ -19115,6 +20597,7 @@ async function runPrPublish(args, dependencies = {}) {
 			onFailure: (failed, error) => {
 				throw new PrPublishFollowUpError({
 					bodyPatched,
+					createdPullRequest: discovered.created,
 					followUp: failed,
 					handoff: initialHandoff,
 					proof: initialProof,
@@ -19140,6 +20623,7 @@ async function runPrPublish(args, dependencies = {}) {
 	const handoff = summarizeHumanHandoff(proof);
 	const result = {
 		bodyPatched,
+		createdPullRequest: discovered.created,
 		followUp,
 		handoff,
 		proof,
@@ -19247,7 +20731,7 @@ function assertForegroundGate({ gate, env = process.env }) {
 //#endregion
 //#region src/commands/pr-review.ts
 function createPrReviewCommand(output, action) {
-	return markCwdOptionDefault(new Command("pr:review").description("Assemble a factory-owned review prompt, or validate clean-session findings and write typed review proof").option("--base <ref>", "base branch or ref", "origin/main").option("--cwd <path>", "working directory to review", collectCwdOption).option("--cycle <number>", "review cycle number", positiveInteger$1("--cycle"), 1).option("--mode <mode>", "correctness, security, or all", "all").option("--assemble", "write the factory-owned review prompt for a clean session; do not validate findings").option("--epic <number>", "issue carrying the factory-boundary manifest, which may be the work issue itself; --assemble then asks the reviewer for the findings schema the wave-demanded review rung accepts (#1001)", positiveInteger$1("--epic")).option("--findings <path>", "typed clean-session findings JSON file").option("--historical", "record findings that read an earlier commit on this branch: the cycle joins the ladder as prior history and renders no verdict of its own, so it never admits. It leaves the candidate's recorded verdict untouched. This recording may carry --dispositions for the findings it flags; otherwise declare them on the next cycle once they are persisted ledger entries").option("--dispositions <path>", "JSON file of ladder disposition declarations (waived / follow-up-filed / fixed-in-thread) for previously flagged findings, or for the findings a --historical recording itself flags").option("--issue <number>", "issue number recorded on the review ladder trace; --assemble also loads Review focus from this issue", positiveInteger$1("--issue")).option("--output <path>", "write proof JSON to a file").option("--profile <path>", "path to the project profile JSON file").option("--verify-proof <path>", "pr:verify proof JSON path").action(withGateTiming({
+	return markCwdOptionDefault(new Command("pr:review").description("Assemble a factory-owned review prompt, or validate clean-session findings and write typed review proof").option("--base <ref>", "base ref to assert. With a pull request open for this branch its live base is the base and a disagreeing value is refused; without one, this ref (default origin/main) is fetched fresh and its SHA recorded").option("--cwd <path>", "working directory to review", collectCwdOption).option("--cycle <number>", "review cycle number", positiveInteger$1("--cycle"), 1).option("--mode <mode>", "correctness, security, or all", "all").option("--assemble", "write the factory-owned review prompt for a clean session; do not validate findings").option("--epic <number>", "issue carrying the factory-boundary manifest, which may be the work issue itself; --assemble then asks the reviewer for the findings schema the wave-demanded review rung accepts (#1001)", positiveInteger$1("--epic")).option("--findings <path>", "typed clean-session findings JSON file").option("--historical", "record findings that read an earlier commit on this branch: the cycle joins the ladder as prior history and renders no verdict of its own, so it never admits. It leaves the candidate's recorded verdict untouched. This recording may carry --dispositions for the findings it flags; otherwise declare them on the next cycle once they are persisted ledger entries").option("--dispositions <path>", "JSON file of ladder disposition declarations (waived / follow-up-filed / fixed-in-thread) for previously flagged findings, or for the findings a --historical recording itself flags").option("--issue <number>", "issue number recorded on the review ladder trace; --assemble also loads Review focus from this issue", positiveInteger$1("--issue")).option("--output <path>", "write proof JSON to a file").option("--allow-fault-injection", "test-only: honour FACTORY_REVIEW_FAULT (after-retain | proof-rename | after-proof-write) to interrupt the recording at that point and demonstrate that a retry resolves to already-recorded or a clean re-record (#1131)").option("--profile <path>", "path to the project profile JSON file").option("--verify-proof <path>", "pr:verify proof JSON path").action(withGateTiming({
 		gate: "pr:review",
 		resolveCycle: (options) => options.cycle,
 		resolveLedgerRoot: (options) => resolveCwdOption(options.cwd),
@@ -19260,8 +20744,9 @@ function createPrReviewCommand(output, action) {
 			"all"
 		].includes(options.mode)) throw new Error("--mode requires correctness, security, or all");
 		const args = {
+			...options.allowFaultInjection === true ? { allowFaultInjection: true } : {},
 			...options.assemble === true ? { assemble: true } : {},
-			base: options.base,
+			...options.base === void 0 ? {} : { base: options.base },
 			cwd: resolveCwdOption(options.cwd),
 			cycle: options.cycle,
 			dispositions: options.dispositions,
@@ -19280,7 +20765,7 @@ function createPrReviewCommand(output, action) {
 //#endregion
 //#region src/commands/pr-verify.ts
 function createPrVerifyCommand(output, action = runPrVerify) {
-	return markCwdOptionDefault(new Command("pr:verify").description("Run project-profile verification commands and write typed proof").option("--base <ref>", "base branch or ref", "origin/main").option("--cwd <path>", "working directory to verify", collectCwdOption).option("--docs-only", "run the docs/process verification gate").option("--full", "run the full verification gate").option("--authoring-session <id>", "explicit authoring session identity (required for review evidence)").option("--json", "print the proof as JSON after verification").option("--output <path>", "write proof JSON to a file").option("--profile <path>", "path to the project profile JSON file").option("--no-status", "skip posting the patronage-factory/pr-verify commit status").action(withGateTiming({
+	return markCwdOptionDefault(new Command("pr:verify").description("Run project-profile verification commands and write typed proof").option("--base <ref>", "base ref to assert. With a pull request open for this branch its live base is the base and a disagreeing value is refused; without one, this ref (default origin/main) is fetched fresh and its SHA recorded").option("--cwd <path>", "working directory to verify", collectCwdOption).option("--docs-only", "run the docs/process verification gate").option("--full", "run the full verification gate").option("--authoring-session <id>", "explicit authoring session identity (required for review evidence)").option("--json", "print the proof as JSON after verification").option("--output <path>", "write proof JSON to a file").option("--profile <path>", "path to the project profile JSON file").option("--no-status", "skip posting the patronage-factory/pr-verify commit status").action(withGateTiming({
 		gate: "pr:verify",
 		resolveLedgerRoot: (options) => resolveCwdOption(options.cwd),
 		stderr: output.stderr