@patronage/software-factory 1.0.0-alpha.21 → 1.0.0-alpha.23

package/dist/schemas.js

@@ -200,6 +200,11 @@ const blockedReasonIssues = (proof) => {
 	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`);
 };
+const sameHeadSha = (left, right) => {
+	if (!left || !right) return false;
+	if (Math.min(left.length, right.length) < 7) return false;
+	return left.startsWith(right) || right.startsWith(left);
+};
 //#endregion
 //#region src/demand-waiver.ts
 const DEMAND_WAIVER_SCHEMA_VERSION = 1;
@@ -229,6 +234,549 @@ const waivedDemandSchema = z.object({
 	unmetReasons: z.array(z.string().min(1)).min(1)
 });
 //#endregion
+//#region src/packages/review-prompt-sections/schema.ts
+const REVIEW_PROMPT_SECTION_PROVENANCES = ["prior-review-ledger", "issue-review-focus"];
+const nonBlankString$1 = 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$1,
+	text: nonBlankString$1
+}).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-policy.ts
+const REVIEW_CATEGORIES = [
+	"correctness",
+	"safety",
+	"coordination",
+	"maintainability",
+	"unknown"
+];
+//#endregion
+//#region src/evidence-freshness.ts
+const patchIdMatches = (recorded, candidate) => Boolean(recorded.patchId) && recorded.patchId === candidate.patchId;
+const headShaMatches = (recorded, candidate) => Boolean(recorded.headSha && candidate.headSha && sameHeadSha(candidate.headSha, recorded.headSha));
+/**
+* The one freshness decision. `true` means the recorded evidence still
+* describes the candidate.
+*
+* Time is not an input and never will be: adding one would contradict the
+* `freshness` definition in root `CONTEXT.md`.
+*/
+function evidenceFresh({ candidate, recorded, rule }) {
+	if (patchIdMatches(recorded, candidate)) return true;
+	return rule === "patch-id-or-head-sha" && headShaMatches(recorded, candidate);
+}
+//#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-ladder-ledger.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",
+	"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 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
+	};
+};
+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/review-ladder.ts
+const ladderCycleRefsFor = (cycles) => {
+	let interior = 0;
+	let gate = 0;
+	return cycles.map((entry) => {
+		if (entry.stage === "interior") {
+			if (gate > 0) throw new TypeError("Invalid ladder history: interior cycle recorded after the gate stage began.");
+			interior += 1;
+			return {
+				cycle: interior,
+				stage: "interior"
+			};
+		}
+		gate += 1;
+		return {
+			cycle: gate,
+			stage: "gate"
+		};
+	});
+};
+//#endregion
+//#region src/pr-readiness/ladder-proof-state.ts
+const prReviewLadderStateSchema = z.object({ cycles: z.array(z.custom()) }).superRefine((ladder, context) => {
+	try {
+		ladderLedgerFor(ladder);
+	} catch {
+		context.addIssue({
+			code: "custom",
+			message: "ladder cycles do not fold into a valid disposition ledger"
+		});
+	}
+});
+const ladderLedgerFor = (ladder) => [...foldLedger(ladder.cycles, ladderCycleRefsFor(ladder.cycles)).ledger.values()];
+//#endregion
+//#region src/pr-readiness/review-proof.ts
+const PR_REVIEW_SCHEMA_VERSION = 2;
+const nonBlankString = z.string().refine((value) => value.trim().length > 0, { message: "must not be blank" });
+const parseableDateString = z.string().refine((value) => Number.isFinite(Date.parse(value)), { message: "must be a parseable date string" });
+const findingSupersedesSchema = z.object({
+	file: z.string().optional(),
+	title: nonBlankString
+});
+const prReviewFindingSchema = z.object({
+	blockingAfterCap: z.boolean().optional(),
+	body: nonBlankString,
+	category: z.enum(REVIEW_CATEGORIES).optional(),
+	citedSpan: z.string().optional(),
+	file: z.string().optional(),
+	line: z.number().int().positive().optional(),
+	prescribedAction: z.string().optional(),
+	priority: z.string().optional(),
+	protocolFinding: z.literal(true).optional(),
+	supersedes: findingSupersedesSchema.optional(),
+	title: nonBlankString
+});
+const prReviewResultSchema = z.object({
+	durationMs: z.number().refine((value) => Number.isFinite(value) && value >= 0, { message: "durationMs must be a finite number >= 0" }),
+	endedAt: parseableDateString,
+	findings: z.array(prReviewFindingSchema),
+	issuesFlagged: z.number().int().nonnegative(),
+	kind: z.enum(["correctness", "security"]),
+	model: nonBlankString.optional(),
+	outcome: z.enum([
+		"passed",
+		"failed",
+		"error"
+	]),
+	producer: nonBlankString.optional(),
+	promptSections: reviewPromptSectionsSchema.optional(),
+	rung: z.enum(EVIDENCE_REVIEW_RUNGS$1).optional(),
+	sessionId: nonBlankString.optional(),
+	startedAt: parseableDateString,
+	summary: z.string().refine((value) => value.trim().length > 0 && value !== "<one sentence>", { message: "summary must not be blank or a placeholder" }),
+	typedVerdict: z.boolean().optional(),
+	verdictSource: z.enum(["footer", "recovered"]).optional()
+}).superRefine((review, context) => {
+	if (review.outcome === "passed") {
+		if (review.issuesFlagged !== 0) context.addIssue({
+			code: "custom",
+			message: "passed reviews must report zero issues flagged",
+			path: ["issuesFlagged"]
+		});
+		if (review.findings.length !== 0) context.addIssue({
+			code: "custom",
+			message: "passed reviews must not include findings",
+			path: ["findings"]
+		});
+	}
+	if (review.outcome !== "passed") {
+		if (review.findings.length === 0) context.addIssue({
+			code: "custom",
+			message: "non-passing reviews must include findings",
+			path: ["findings"]
+		});
+		if (review.findings.length !== review.issuesFlagged) context.addIssue({
+			code: "custom",
+			message: "issuesFlagged must match findings length",
+			path: ["issuesFlagged"]
+		});
+	}
+	if (review.producer === void 0 !== (review.rung === void 0)) context.addIssue({
+		code: "custom",
+		message: "producer and rung must be recorded together",
+		path: [review.producer === void 0 ? "producer" : "rung"]
+	});
+});
+const prReviewProofSchema = z.object({
+	base: z.string(),
+	changedFiles: z.array(z.string()),
+	cleanedPaths: z.array(z.string()),
+	findingProvenanceVersion: z.literal(1),
+	headSha: z.string().regex(/^[0-9a-f]{40}$/u),
+	ladder: prReviewLadderStateSchema.optional(),
+	maxReviewCycles: z.number().int().positive().optional(),
+	patchId: z.string().regex(/^[0-9a-f]{40,64}$/u),
+	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)
+}).passthrough().superRefine((proof, context) => {
+	if (proof.reviewRequirement && proof.reviews.length > 0) context.addIssue({
+		code: "custom",
+		message: "not-required review proofs must not contain review runs",
+		path: ["reviews"]
+	});
+	if (proof.reviewCycle !== void 0 && proof.maxReviewCycles !== void 0 && proof.reviewCycle > proof.maxReviewCycles) context.addIssue({
+		code: "custom",
+		message: "reviewCycle must not exceed maxReviewCycles",
+		path: ["reviewCycle"]
+	});
+});
+//#endregion
+//#region src/review-state.ts
+const reviewStateIssue = (message, field) => [{
+	code: "custom",
+	message,
+	path: [field]
+}];
+/**
+* The invariant both ledger schemas enforce, written once so the emitting
+* schema and the wire schema cannot drift. It is the producer's state machine:
+*
+* - a review that is not required is never `current` — `reviewStatus` returns
+*   `not-required` before it ever looks at the recorded proof;
+* - `current` means a proof was compared against the candidate delta, so the
+*   reviewed identity must be recorded;
+* - `missing` means no proof was found, so no reviewed identity can exist.
+*/
+const reviewStateIssues = (state) => {
+	const hasIdentity = Boolean(state.reviewedHeadSha || state.reviewedPatchId);
+	if (state.status === "current") {
+		if (!state.required) return reviewStateIssue("a review state that is not required cannot be current", "status");
+		if (!hasIdentity) return reviewStateIssue("a current review state must record the reviewed head sha or patch id", "reviewedPatchId");
+	}
+	if (state.status === "missing" && hasIdentity) return reviewStateIssue("a missing review state must record no reviewed head sha or patch id", "status");
+	return [];
+};
+//#endregion
 //#region src/catch-up-recognition-record.ts
 const objectShaSchema = z.string().regex(/^[0-9a-f]{40}$/u);
 const catchUpRecognitionSchema = z.object({
@@ -241,7 +789,8 @@ const catchUpRecognitionSchema = z.object({
 const impactStampTargetSchema = z.object({
 	basis: z.string().min(1),
 	impact: z.enum(["affected", "not-affected"]),
-	name: z.string().min(1)
+	name: z.string().min(1),
+	subscribedPaths: z.array(z.string())
 });
 /**
 * The recorded stamp. `targets` satisfies the completeness invariant: every
@@ -253,7 +802,7 @@ const impactStampSchema = z.object({
 	basis: z.enum(["target-scoped", "conservative"]),
 	inertPaths: z.array(z.string()).default([]),
 	reasons: z.array(z.string()),
-	stampVersion: z.literal(3),
+	stampVersion: z.literal(4),
 	targets: z.array(impactStampTargetSchema).superRefine((targets, context) => {
 		const names = targets.map((target) => target.name);
 		if (new Set(names).size !== names.length) context.addIssue({
@@ -299,8 +848,8 @@ const impactStampScopeDecision = ({ stamp, surface, targetName }) => {
 		reason: `no trusted identity-bound impact stamp covers this candidate; ${floor}`,
 		scoped: false
 	};
-	if (stamp.stampVersion !== 3) return {
-		reason: `impact stamp version ${String(stamp.stampVersion)} is not this build's version 3; ${floor}`,
+	if (stamp.stampVersion !== 4) return {
+		reason: `impact stamp version ${String(stamp.stampVersion)} is not this build's version 4; ${floor}`,
 		scoped: false
 	};
 	if (stamp.basis !== "target-scoped") return {
@@ -690,14 +1239,6 @@ const DIFF_CLASSIFICATIONS = [
 	"trivial",
 	"non-trivial"
 ];
-const REVIEW_CATEGORIES = [
-	"correctness",
-	"safety",
-	"coordination",
-	"maintainability",
-	"unknown"
-];
-const REVIEW_RUNGS = ["independentModel", "oracle"];
 const REVIEW_STATUS_VALUES = [
 	"not-required",
 	"current",
@@ -747,180 +1288,6 @@ const evidenceEnvelopeSchema = z.object({
 		});
 	}
 });
-const PR_REVIEW_SCHEMA_VERSION = 2;
-const PR_REVIEW_FINDING_PROVENANCE_VERSION = 1;
-const nonBlankString = z.string().refine((value) => value.trim().length > 0, { message: "must not be blank" });
-const parseableDateString = z.string().refine((value) => Number.isFinite(Date.parse(value)), { message: "must be a parseable date string" });
-const reviewPromptSectionProvenances = ["prior-review-ledger", "issue-review-focus"];
-const reviewPromptSectionSchema = z.object({
-	provenance: z.enum(reviewPromptSectionProvenances),
-	source: nonBlankString,
-	text: nonBlankString
-}).strict();
-const reviewPromptSectionsSchema = z.array(reviewPromptSectionSchema).min(1).refine((sections) => new Set(sections.map((section) => section.provenance)).size === sections.length && !sections.some((section, index) => index > 0 && reviewPromptSectionProvenances.indexOf(section.provenance) < reviewPromptSectionProvenances.indexOf(sections[index - 1].provenance)), { message: "prompt sections must be in assembly order without duplicates" });
-const findingSupersedesSchema = z.object({
-	file: z.string().optional(),
-	title: nonBlankString
-});
-const prReviewFindingSchema = z.object({
-	blockingAfterCap: z.boolean().optional(),
-	body: nonBlankString,
-	category: z.enum(REVIEW_CATEGORIES).optional(),
-	citedSpan: z.string().optional(),
-	file: z.string().optional(),
-	line: z.number().int().positive().optional(),
-	prescribedAction: z.string().optional(),
-	priority: z.string().optional(),
-	protocolFinding: z.literal(true).optional(),
-	supersedes: findingSupersedesSchema.optional(),
-	title: nonBlankString
-});
-const prReviewResultSchema = z.object({
-	command: z.string().refine((value) => value.trim().length > 0, { message: "command must not be blank" }).optional(),
-	durationMs: z.number().refine((value) => Number.isFinite(value) && value >= 0, { message: "durationMs must be a finite number >= 0" }),
-	endedAt: parseableDateString,
-	exitCode: z.number().nullable().optional(),
-	findings: z.array(prReviewFindingSchema),
-	issuesFlagged: z.number().int().nonnegative(),
-	kind: z.enum(["correctness", "security"]),
-	model: nonBlankString.optional(),
-	outcome: z.enum([
-		"passed",
-		"failed",
-		"error"
-	]),
-	producer: z.string().min(1).optional(),
-	promptSections: reviewPromptSectionsSchema.optional(),
-	rung: z.enum(EVIDENCE_REVIEW_RUNGS).optional(),
-	sessionId: nonBlankString.optional(),
-	stageResolution: z.object({
-		effort: z.enum([
-			"low",
-			"medium",
-			"high",
-			"xhigh"
-		]).optional(),
-		engine: z.string().min(1),
-		layerSource: z.enum([
-			"cli",
-			"operatorSessionGlobal",
-			"operatorSessionKind",
-			"profilePin",
-			"stageConfig",
-			"userConfig"
-		]),
-		model: z.string().min(1),
-		rung: z.enum(REVIEW_RUNGS).optional()
-	}).optional(),
-	startedAt: parseableDateString,
-	summary: z.string().refine((value) => value.trim().length > 0 && value !== "<one sentence>", { message: "summary must not be blank or a placeholder" }),
-	typedVerdict: z.boolean().optional(),
-	verdictSource: z.enum(["footer", "recovered"]).optional()
-}).superRefine((review, context) => {
-	if (review.outcome === "passed") {
-		if (review.issuesFlagged !== 0) context.addIssue({
-			code: "custom",
-			message: "passed reviews must report zero issues flagged",
-			path: ["issuesFlagged"]
-		});
-		if (review.findings.length !== 0) context.addIssue({
-			code: "custom",
-			message: "passed reviews must not include findings",
-			path: ["findings"]
-		});
-	}
-	if (review.outcome !== "passed") {
-		if (review.findings.length === 0) context.addIssue({
-			code: "custom",
-			message: "non-passing reviews must include findings",
-			path: ["findings"]
-		});
-		if (review.findings.length !== review.issuesFlagged) context.addIssue({
-			code: "custom",
-			message: "issuesFlagged must match findings length",
-			path: ["issuesFlagged"]
-		});
-	}
-	if (review.outcome === "failed" && review.exitCode !== void 0 && review.exitCode !== 0) context.addIssue({
-		code: "custom",
-		message: "failed reviews must exit with code 0",
-		path: ["exitCode"]
-	});
-	if (review.producer === void 0 !== (review.rung === void 0)) context.addIssue({
-		code: "custom",
-		message: "producer and rung must be recorded together",
-		path: [review.producer === void 0 ? "producer" : "rung"]
-	});
-});
-const ladderFindingSchema = z.object({
-	citedSpan: z.string().optional(),
-	file: z.string().optional(),
-	prescribedAction: z.string().optional(),
-	supersedes: z.object({
-		file: z.string().optional(),
-		title: z.string()
-	}).optional(),
-	title: z.string()
-}).passthrough();
-const ladderDispositionSchema = z.object({
-	disposition: z.enum([
-		"fixed-in-thread",
-		"follow-up-filed",
-		"waived"
-	]),
-	finding: z.object({
-		file: z.string().optional(),
-		title: z.string()
-	}),
-	reference: z.string().optional()
-}).passthrough();
-const ladderCycleSchema = z.object({
-	dispositions: z.array(ladderDispositionSchema).optional(),
-	findings: z.array(ladderFindingSchema)
-}).passthrough();
-const prReviewProofSchema = z.object({
-	base: z.string(),
-	changedFiles: z.array(z.string()),
-	cleanedPaths: z.array(z.string()),
-	findingProvenanceVersion: z.literal(PR_REVIEW_FINDING_PROVENANCE_VERSION),
-	headSha: z.string().regex(/^[0-9a-f]{40}$/u),
-	ladder: z.object({ cycles: z.array(ladderCycleSchema) }).superRefine((ladder, context) => {
-		let gateStarted = false;
-		try {
-			for (const cycle of ladder.cycles) {
-				const { stage } = cycle;
-				if (stage === "interior") {
-					if (gateStarted) throw new TypeError("interior cycle after gate");
-				} else gateStarted = true;
-			}
-		} catch {
-			context.addIssue({
-				code: "custom",
-				message: "ladder cycles do not fold into a valid disposition ledger"
-			});
-		}
-	}).optional(),
-	maxReviewCycles: z.number().int().positive().optional(),
-	patchId: z.string().regex(/^[0-9a-f]{40,64}$/u),
-	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)
-}).passthrough().superRefine((proof, context) => {
-	if (proof.reviewRequirement && proof.reviews.length > 0) context.addIssue({
-		code: "custom",
-		message: "not-required review proofs must not contain review runs",
-		path: ["reviews"]
-	});
-	if (proof.reviewCycle !== void 0 && proof.maxReviewCycles !== void 0 && proof.reviewCycle > proof.maxReviewCycles) context.addIssue({
-		code: "custom",
-		message: "reviewCycle must not exceed maxReviewCycles",
-		path: ["reviewCycle"]
-	});
-});
 const BOUNDARY_REVIEW_PROOF_KIND = "boundary-review-proof";
 const coveredSetEntrySchema = z.object({
 	headSha: evidenceShaSchema.optional(),
@@ -1019,12 +1386,15 @@ const readinessRepairSchema = z.object({
 	command: z.string().min(1)
 });
 const reviewStateSchema = z.object({
-	docsOnlyDeltaAccepted: z.boolean().optional(),
 	required: z.boolean(),
 	reviewedHeadSha: z.string().optional(),
 	reviewedPatchId: z.string().optional(),
 	status: z.enum(REVIEW_STATUS_VALUES)
+}).strict().superRefine((state, context) => {
+	for (const issue of reviewStateIssues(state)) context.addIssue(issue);
 });
+const verifyCommandSchema = z.literal("patronage-factory pr:verify");
+const verifiedShaSchema = z.string().min(1);
 const historicalPostReadinessCommentSchema = z.object({
 	author: z.string().min(1),
 	createdAt: z.string().min(1),
@@ -1043,7 +1413,6 @@ const managedReadinessLedgerSchema = z.object({
 	classification: z.enum(DIFF_CLASSIFICATIONS),
 	externalChecks: z.array(z.object({
 		checkType: z.enum(EVIDENCE_CHECK_TYPES),
-		inScope: z.boolean(),
 		name: z.string().min(1),
 		reason: z.string().optional(),
 		scope: requiredCheckScopeSchema.optional(),
@@ -1146,40 +1515,54 @@ const managedReadinessLedgerSchema = z.object({
 		correctness: reviewStateSchema,
 		security: reviewStateSchema.optional()
 	}),
-	schemaVersion: z.literal(1),
+	schemaVersion: z.literal(2),
 	stackRole: z.enum([
 		"single",
 		"slice",
 		"rollup",
 		"merge-gate prerequisite"
 	]).optional(),
-	verification: z.object({
-		command: z.literal("patronage-factory pr:verify"),
-		docsOnlyDeltaAccepted: z.boolean().optional(),
-		docsOnlyVerifiedHeadSha: z.string().optional(),
-		prVerify: z.enum([
-			"passed",
-			"missing",
-			"stale"
-		]),
-		trivialDeltaAccepted: z.boolean().optional(),
-		trivialVerifiedHeadSha: z.string().optional(),
-		verifiedHeadSha: z.string().optional()
-	})
+	verification: z.discriminatedUnion("prVerify", [
+		z.object({
+			command: verifyCommandSchema,
+			prVerify: z.literal("missing")
+		}).strict(),
+		z.object({
+			command: verifyCommandSchema,
+			prVerify: z.literal("stale"),
+			verifiedHeadSha: verifiedShaSchema
+		}).strict(),
+		z.object({
+			command: verifyCommandSchema,
+			prVerify: z.literal("passed-via-head"),
+			verifiedHeadSha: verifiedShaSchema
+		}).strict(),
+		z.object({
+			command: verifyCommandSchema,
+			docsOnlyVerifiedHeadSha: verifiedShaSchema,
+			prVerify: z.literal("docs-only-delta"),
+			verifiedHeadSha: verifiedShaSchema.optional()
+		}).strict(),
+		z.object({
+			command: verifyCommandSchema,
+			prVerify: z.literal("trivial-delta"),
+			trivialVerifiedHeadSha: verifiedShaSchema,
+			verifiedHeadSha: verifiedShaSchema.optional()
+		}).strict()
+	])
 });
 const PR_READY_SCHEMA_VERSION = 3;
 /**
-* The pr:ready proof versions a reader still accepts. `pr:ready` emits v3 only
-* (#477) — one current contract — but v1 and v2 events were spooled before the
-* bumps and HQ must ingest them without degrading, so the wire schema parses
-* all three.
+* The pr:ready proof versions a reader accepts: the current one only (#917
+* item 1). #894 narrowed the nested readiness ledger to `schemaVersion: 2` and
+* the `prVerify` tagged union, which no v1 or v2 pr:ready proof can satisfy.
+* Advertising 1 and 2 here therefore promised an acceptance the nested schema
+* already refused. Pre-1.0 posture applies: one current contract, no compat
+* reader. An alpha.22 consumer must adopt alpha.23 before HQ ingests its
+* pr:ready proofs.
 */
-const SUPPORTED_PR_READY_SCHEMA_VERSIONS = [
-	1,
-	2,
-	3
-];
-const prReadySchemaVersionSchema = z.number().refine((value) => SUPPORTED_PR_READY_SCHEMA_VERSIONS.includes(value), { message: `schemaVersion must be one of: ${SUPPORTED_PR_READY_SCHEMA_VERSIONS.join(", ")}` });
+const SUPPORTED_PR_READY_SCHEMA_VERSIONS = [3];
+const prReadySchemaVersionSchema = z.literal(3);
 const prReadyProofSchema = z.object({
 	arming: z.object({
 		detail: z.string().min(1).optional(),
@@ -1209,15 +1592,7 @@ const prReadyProofSchema = z.object({
 	]),
 	waivedDemands: z.array(waivedDemandSchema).optional()
 }).superRefine((proof, context) => {
-	if (proof.schemaVersion < 2) {
-		if (proof.blockedReasons !== void 0) context.addIssue({
-			code: "custom",
-			message: "blockedReasons is a schemaVersion 2 field; a v1 pr:ready proof must not carry it.",
-			path: ["blockedReasons"]
-		});
-		return;
-	}
 	for (const issue of blockedReasonIssues({ ...proof })) context.addIssue(issue);
 });
 //#endregion
-export { BLOCKED_REASONS_MAX, BLOCKED_REASON_DETAIL_MAX, BOUNDARY_CHECK_SCHEMA_VERSION, BOUNDARY_REVIEW_PROOF_KIND, EVIDENCE_ENVELOPE_SCHEMA_VERSION, PR_READY_SCHEMA_VERSION, PR_REVIEW_SCHEMA_VERSION, SUPPORTED_CLOSEOUT_SCHEMA_VERSIONS, SUPPORTED_PR_READY_SCHEMA_VERSIONS, SUPPORTED_PR_VERIFY_SCHEMA_VERSIONS, blockedReasonSchema, blockedReasonsSchema, boundaryCheckProofSchema, boundaryReviewProofSchema, closeoutArtifactSchema, evidenceEnvelopeSchema, prReadyProofSchema, prReviewProofSchema, prVerifyProofSchema, waivedDemandSchema };
+export { BLOCKED_REASONS_MAX, BLOCKED_REASON_DETAIL_MAX, BOUNDARY_CHECK_SCHEMA_VERSION, BOUNDARY_REVIEW_PROOF_KIND, EVIDENCE_ENVELOPE_SCHEMA_VERSION, PR_READY_SCHEMA_VERSION, PR_REVIEW_SCHEMA_VERSION, SUPPORTED_CLOSEOUT_SCHEMA_VERSIONS, SUPPORTED_PR_READY_SCHEMA_VERSIONS, SUPPORTED_PR_VERIFY_SCHEMA_VERSIONS, blockedReasonSchema, blockedReasonsSchema, boundaryCheckProofSchema, boundaryReviewProofSchema, closeoutArtifactSchema, evidenceEnvelopeSchema, prReadyProofSchema, prReviewFindingSchema, prReviewProofSchema, prReviewResultSchema, prVerifyProofSchema, reviewPromptSectionSchema, reviewPromptSectionsSchema, waivedDemandSchema };