@patronage/software-factory 0.20.0

package/dist/schemas.js

@@ -0,0 +1,771 @@
+import { z } from "zod";
+const MAX_CLOSEOUT_ROWS = 1e3;
+const IdentifierSchema = z.string().min(1).max(500);
+const NarrativeSchema = z.string().min(1).max(1e4);
+const RepoSchema = z.string().min(1).max(200);
+const IsoDateSchema = z.string().regex(/^\d{4}-\d{2}-\d{2}$/u);
+const CloseoutLandingSpotSchema = z.enum([
+	"CLI",
+	"profile",
+	"skill",
+	"ADR"
+]);
+const CloseoutSourceSchema = z.object({
+	detail: NarrativeSchema,
+	kind: z.enum(["interior-telemetry", "boundary-thermo-attestation"])
+}).strict();
+const CloseoutScopingSchema = z.object({
+	epic: IdentifierSchema,
+	issueFilter: z.number().int().positive().optional(),
+	prFilter: z.number().int().positive().optional(),
+	repo: RepoSchema,
+	scopedByEpicIssueSet: z.boolean(),
+	window: z.object({
+		from: IsoDateSchema,
+		to: IsoDateSchema
+	}).strict()
+}).strict();
+const CloseoutBudgetSchema = z.object({
+	interiorSourcesConsumed: z.number().int().nonnegative(),
+	note: NarrativeSchema,
+	scoping: CloseoutScopingSchema.optional(),
+	tier: z.literal("overseer")
+}).strict();
+const BoundaryThermoAttestationSchema = z.object({
+	owner: z.string().min(1).max(200),
+	runs: z.number().int().nonnegative(),
+	waived: z.boolean(),
+	waiverRationale: NarrativeSchema.optional()
+}).strict();
+const CloseoutMetricRowSchema = z.object({
+	label: IdentifierSchema,
+	metric: IdentifierSchema,
+	source: CloseoutSourceSchema,
+	unit: z.enum([
+		"tokens",
+		"usd",
+		"count",
+		"ratio",
+		"boolean",
+		"text"
+	]),
+	value: z.union([
+		z.number(),
+		NarrativeSchema,
+		z.boolean(),
+		z.null()
+	])
+}).strict();
+const CloseoutLessonSchema = z.object({
+	id: IdentifierSchema,
+	landingSpot: CloseoutLandingSpotSchema,
+	lesson: NarrativeSchema,
+	rationale: NarrativeSchema.optional(),
+	source: CloseoutSourceSchema.optional()
+}).strict();
+const CloseoutBlindspotSchema = z.object({
+	id: IdentifierSchema,
+	note: NarrativeSchema,
+	reason: NarrativeSchema.optional()
+}).strict();
+const CloseoutLedgerRowSchema = z.object({
+	detail: NarrativeSchema.optional(),
+	epic: IdentifierSchema,
+	generatedAt: z.iso.datetime(),
+	key: IdentifierSchema,
+	landingSpot: CloseoutLandingSpotSchema.optional(),
+	repo: RepoSchema,
+	rowType: z.enum([
+		"metric",
+		"lesson",
+		"blindspot"
+	]),
+	schemaVersion: z.literal(3),
+	source: NarrativeSchema,
+	unit: IdentifierSchema.optional(),
+	value: z.union([
+		NarrativeSchema,
+		z.number(),
+		z.null()
+	])
+}).strict();
+/** Strict, bounded runtime transport contract emitted by factory:closeout. */
+const closeoutArtifactSchema = z.object({
+	boundaryThermo: BoundaryThermoAttestationSchema,
+	budget: CloseoutBudgetSchema,
+	couldNotSee: z.array(CloseoutBlindspotSchema).min(1).max(MAX_CLOSEOUT_ROWS),
+	epic: IdentifierSchema,
+	generatedAt: z.iso.datetime(),
+	ledgerRows: z.array(CloseoutLedgerRowSchema).max(MAX_CLOSEOUT_ROWS),
+	lessons: z.array(CloseoutLessonSchema).max(MAX_CLOSEOUT_ROWS),
+	metrics: z.array(CloseoutMetricRowSchema).max(MAX_CLOSEOUT_ROWS),
+	repo: RepoSchema,
+	schemaVersion: z.literal(3)
+}).strict();
+//#endregion
+//#region src/schemas.ts
+const EVIDENCE_CHECK_TYPES = ["review", "verify"];
+const EVIDENCE_REVIEW_RUNGS = [
+	"independent-model",
+	"oracle",
+	"human"
+];
+const DIFF_CLASSIFICATIONS = [
+	"docs/process-only",
+	"trivial",
+	"non-trivial"
+];
+const REVIEW_CATEGORIES = [
+	"correctness",
+	"safety",
+	"coordination",
+	"maintainability",
+	"unknown"
+];
+const REVIEW_RUNGS = ["independentModel", "oracle"];
+const REVIEW_STATUS_VALUES = [
+	"not-required",
+	"current",
+	"stale",
+	"missing",
+	"blocked"
+];
+const followUpActionSchema = z.object({
+	argv: z.array(z.string()),
+	command: z.string()
+}).strict();
+const EVIDENCE_ENVELOPE_SCHEMA_VERSION = 1;
+const evidenceShaSchema = z.string().regex(/^[0-9a-f]{7,40}$/u, { message: "must be a 7-40 char lowercase hex git SHA" });
+const evidenceEnvelopeSchema = z.object({
+	check: z.string().min(1),
+	checkType: z.enum(EVIDENCE_CHECK_TYPES),
+	findingsPointer: z.string().min(1).optional(),
+	headSha: evidenceShaSchema,
+	mergeBaseSha: evidenceShaSchema,
+	model: z.string().min(1).optional(),
+	outcome: z.enum(["pass", "fail"]),
+	patchId: evidenceShaSchema,
+	policyVersion: z.string().min(1).optional(),
+	producer: z.string().min(1),
+	requestId: z.string().min(1).optional(),
+	rung: z.enum(EVIDENCE_REVIEW_RUNGS).optional(),
+	schemaVersion: z.literal(1),
+	sessionId: z.string().trim().min(1).optional(),
+	timestamp: z.iso.datetime().optional()
+}).passthrough().superRefine((envelope, context) => {
+	if (envelope.checkType === "review") {
+		if (envelope.rung === void 0) context.addIssue({
+			code: "custom",
+			message: "review-type evidence envelope requires a rung (ADR 0014 §3).",
+			path: ["rung"]
+		});
+	} else {
+		if (envelope.rung !== void 0) context.addIssue({
+			code: "custom",
+			message: "verify-type evidence envelope must not carry rung (review-type-only field, ADR 0014 §3).",
+			path: ["rung"]
+		});
+		if (envelope.model !== void 0) context.addIssue({
+			code: "custom",
+			message: "verify-type evidence envelope must not carry model (review-type-only field, ADR 0014 §3).",
+			path: ["model"]
+		});
+	}
+});
+const SUPPORTED_PR_VERIFY_SCHEMA_VERSIONS = [
+	1,
+	2,
+	3,
+	4
+];
+const executedCommandSchema = z.object({
+	command: z.string().min(1),
+	counts: z.object({
+		testFiles: z.number().nonnegative().optional(),
+		tests: z.number().nonnegative().optional()
+	}).optional(),
+	durationMs: z.number().nonnegative(),
+	exitCode: z.number(),
+	name: z.string().min(1),
+	scope: z.enum([
+		"always",
+		"docs-only",
+		"trivial",
+		"full"
+	])
+});
+const prVerifySchemaVersionSchema = z.number().refine((value) => SUPPORTED_PR_VERIFY_SCHEMA_VERSIONS.includes(value), { message: `schemaVersion must be one of: ${SUPPORTED_PR_VERIFY_SCHEMA_VERSIONS.join(", ")}` });
+const prVerifyProofSchema = z.object({
+	authoringSession: z.string().trim().min(1).optional(),
+	base: z.string().min(1),
+	baselineFullProofs: z.array(z.object({
+		base: z.string().min(1),
+		changedFiles: z.array(z.string()),
+		headSha: z.string().regex(/^[0-9a-f]{40}$/u),
+		profilePath: z.string().min(1),
+		projectKey: z.string().min(1),
+		repository: z.string().min(1)
+	})).optional(),
+	changedFiles: z.array(z.string()),
+	classification: z.enum(DIFF_CLASSIFICATIONS),
+	classificationReasons: z.array(z.string()),
+	command: z.literal("patronage-factory pr:verify"),
+	durationMs: z.number().nonnegative(),
+	endedAt: z.iso.datetime(),
+	executedCommands: z.array(executedCommandSchema).optional(),
+	headSha: z.string().regex(/^[0-9a-f]{40}$/u),
+	mergeBaseSha: z.string().regex(/^[0-9a-f]{40}$/u).optional(),
+	mode: z.enum([
+		"docs-only",
+		"trivial",
+		"full"
+	]),
+	outcome: z.enum(["aborted", "passed"]).optional(),
+	patchId: z.string().regex(/^[0-9a-f]{40}$/u).optional(),
+	profilePath: z.string().min(1),
+	projectKey: z.string().min(1),
+	repository: z.string().min(1),
+	schemaVersion: prVerifySchemaVersionSchema,
+	startedAt: z.iso.datetime(),
+	verificationCommands: z.array(z.object({
+		command: z.string().min(1),
+		description: z.string().min(1),
+		name: z.string().min(1),
+		scope: z.enum([
+			"always",
+			"docs-only",
+			"trivial",
+			"full"
+		])
+	}))
+}).superRefine((proof, context) => {
+	if (proof.schemaVersion >= 4 && proof.authoringSession === void 0) context.addIssue({
+		code: "custom",
+		message: "schemaVersion 4 pr:verify proof requires authoringSession (the recorded authoring identity, or the `unknown` sentinel).",
+		path: ["authoringSession"]
+	});
+	if (proof.schemaVersion < 4 && proof.authoringSession !== void 0) context.addIssue({
+		code: "custom",
+		message: "authoringSession is a schemaVersion>=4 field; a v1–v3 pr:verify proof must not carry it.",
+		path: ["authoringSession"]
+	});
+});
+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",
+	"profile-standing-checklist",
+	"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.literal("docs-only-profile-bypass"),
+		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(),
+	issue: z.number().int().positive().optional(),
+	mergedSha: evidenceShaSchema.optional(),
+	pr: z.number().int().positive(),
+	state: z.enum(["merged", "open"]),
+	wave: z.string().min(1).optional()
+}).passthrough().superRefine((entry, context) => {
+	if (entry.state === "merged" && entry.mergedSha === void 0) context.addIssue({
+		code: "custom",
+		message: "a merged covered-set entry must record mergedSha",
+		path: ["mergedSha"]
+	});
+	if (entry.state === "open" && entry.headSha === void 0) context.addIssue({
+		code: "custom",
+		message: "an open covered-set entry must record headSha",
+		path: ["headSha"]
+	});
+});
+const proofFindingSchema = z.object({
+	blockingAfterCap: z.boolean().optional(),
+	category: z.string().min(1).optional(),
+	disposition: z.string().min(1).optional(),
+	title: z.string().min(1)
+}).passthrough();
+const boundaryReviewProofSchema = z.object({
+	boundary: z.string().min(1),
+	coveredSet: z.array(coveredSetEntrySchema),
+	dispositions: z.array(z.unknown()).optional(),
+	findings: z.array(proofFindingSchema).default([]),
+	kind: z.literal(BOUNDARY_REVIEW_PROOF_KIND),
+	manifestHash: z.object({
+		algo: z.literal("sha256"),
+		scope: z.string().optional(),
+		value: z.string().regex(/^[0-9a-f]{64}$/u)
+	}).passthrough(),
+	outcome: z.enum(["pass", "fail"]),
+	producer: z.string().min(1),
+	rung: z.enum(EVIDENCE_REVIEW_RUNGS),
+	schemaVersion: z.literal(1),
+	sessionId: z.string().min(1).optional(),
+	specHash: z.object({
+		algo: z.literal("sha256"),
+		scope: z.string().optional(),
+		value: z.string().regex(/^[0-9a-f]{64}$/u)
+	}).passthrough().optional()
+}).passthrough();
+const BOUNDARY_CHECK_SCHEMA_VERSION = 1;
+const boundaryCheckProofSchema = z.object({
+	blockingReasons: z.array(z.string()),
+	boundary: z.string().min(1).optional(),
+	command: z.literal("patronage-factory boundary:check"),
+	coveredSet: z.array(z.object({
+		issue: z.number().int().positive().optional(),
+		pr: z.number().int().positive(),
+		sha: evidenceShaSchema,
+		state: z.enum(["merged", "open"]),
+		wave: z.string().min(1)
+	})),
+	demandedRung: z.enum(EVIDENCE_REVIEW_RUNGS).optional(),
+	epicIssue: z.number().int().positive(),
+	manifestHash: z.object({
+		algo: z.literal("sha256"),
+		value: z.string().regex(/^[0-9a-f]{64}$/u)
+	}).optional(),
+	notices: z.array(z.string()),
+	repo: z.string().min(1),
+	reviewProof: z.object({
+		commentId: z.union([z.string(), z.number()]).optional(),
+		commentUrl: z.string().optional(),
+		producer: z.string().min(1),
+		rung: z.enum(EVIDENCE_REVIEW_RUNGS),
+		sessionId: z.string().min(1).optional(),
+		specHash: z.object({
+			algo: z.literal("sha256"),
+			scope: z.string().optional(),
+			value: z.string().regex(/^[0-9a-f]{64}$/u)
+		}).passthrough().optional()
+	}).optional(),
+	schemaVersion: z.literal(1),
+	specHash: z.object({
+		algo: z.literal("sha256"),
+		value: z.string().regex(/^[0-9a-f]{64}$/u)
+	}).optional(),
+	status: z.enum(["ready", "blocked"])
+});
+const mergeGuardIdentitySchema = z.discriminatedUnion("kind", [
+	z.object({
+		headSha: z.string().regex(/^[0-9a-f]{40}$/u),
+		kind: z.literal("match")
+	}),
+	z.object({
+		kind: z.literal("diverged"),
+		liveHeadSha: z.string().regex(/^[0-9a-f]{40}$/u),
+		postProofCommits: z.array(z.object({
+			sha: z.string().min(1),
+			subject: z.string()
+		})).optional(),
+		proofHeadSha: z.string().regex(/^[0-9a-f]{40}$/u)
+	}),
+	z.object({
+		kind: z.literal("live-head-invalid"),
+		pr: z.number().int().positive(),
+		received: z.string()
+	}),
+	z.object({
+		errorDetail: z.string().optional(),
+		kind: z.literal("ready-proof-missing"),
+		readyProofPath: z.string().min(1)
+	}),
+	z.object({
+		kind: z.literal("ready-proof-pr-mismatch"),
+		proofPr: z.number().int().positive(),
+		requestedPr: z.number().int().positive()
+	}),
+	z.object({
+		blockingReasons: z.array(z.string()),
+		kind: z.literal("ready-proof-not-ready"),
+		status: z.string().min(1)
+	})
+]);
+const PR_MERGE_CHECK_SCHEMA_VERSION = 1;
+const prMergeCheckProofSchema = z.object({
+	blockingReasons: z.array(z.string()),
+	command: z.literal("patronage-factory pr:merge-check"),
+	followUp: followUpActionSchema.optional(),
+	identity: mergeGuardIdentitySchema,
+	liveHeadSha: z.string().regex(/^[0-9a-f]{40}$/u).optional(),
+	notices: z.array(z.string()).optional(),
+	pr: z.number().int().positive(),
+	schemaVersion: z.literal(1),
+	status: z.enum(["pass", "fail"]),
+	worktreeHeldBranch: z.object({
+		branch: z.string().min(1),
+		worktreePath: z.string().min(1)
+	}).optional()
+});
+const requiredCheckScopeSchema = z.object({
+	classifications: z.array(z.enum(DIFF_CLASSIFICATIONS)).min(1).optional(),
+	labels: z.array(z.string().min(1)).min(1).optional()
+}).strict().superRefine((scope, context) => {
+	if (scope.labels === void 0 && scope.classifications === void 0) context.addIssue({
+		code: "custom",
+		message: "requiredChecks scope must declare at least one condition (labels and/or classifications)."
+	});
+});
+const readinessRepairSchema = z.object({
+	action: z.string().min(1),
+	code: z.enum([
+		"undraft-pr",
+		"render-pr-body-sections",
+		"await-post-undraft-checks"
+	]),
+	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)
+});
+const managedReadinessLedgerSchema = z.object({
+	baseSha: z.string().regex(/^[0-9a-f]{40}$/u),
+	blockingReasons: z.array(z.string()),
+	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(),
+		scopeReason: z.string().min(1),
+		status: z.enum([
+			"satisfied",
+			"unmet",
+			"out-of-scope"
+		])
+	})).optional(),
+	finalReviewPoint: z.boolean(),
+	github: z.object({
+		currentWithBase: z.boolean(),
+		draft: z.boolean(),
+		mergeStateStatus: z.string(),
+		mergeable: z.string(),
+		requiredChecks: z.enum([
+			"passed",
+			"failed",
+			"pending",
+			"none",
+			"unknown"
+		]),
+		unresolvedReviewThreads: z.number().int().nonnegative()
+	}),
+	handledCommentsProducer: z.object({
+		identity: z.string().min(1),
+		mode: z.enum(["app", "commit-status"])
+	}).optional(),
+	handledHumanComments: z.array(z.object({
+		clearedAt: z.string().min(1).optional(),
+		sessionId: z.string().min(1).optional(),
+		source: z.enum(["check-run", "cli"]),
+		url: z.string().min(1)
+	})).optional(),
+	headSha: z.string().regex(/^[0-9a-f]{40}$/u),
+	mergeBaseSha: z.string().regex(/^[0-9a-f]{40}$/u).optional(),
+	patchId: z.string().regex(/^[0-9a-f]{40,64}$/u),
+	postReadinessHumanComments: z.array(z.object({
+		author: z.string().min(1),
+		createdAt: z.string().min(1),
+		summary: z.string().min(1),
+		url: z.string().min(1)
+	})).optional(),
+	pr: z.number().int().positive(),
+	previewDeploy: z.object({
+		adminUrl: z.string().optional(),
+		apiHealthUrl: z.string().optional(),
+		headSha: z.string().optional(),
+		localPreviewProof: z.unknown().optional(),
+		localProofPath: z.string().optional(),
+		proofSource: z.enum(["github-actions", "local-self-certified"]).optional(),
+		publicUrl: z.string().optional(),
+		seedStatus: z.enum([
+			"passed",
+			"failed",
+			"skipped",
+			"unknown"
+		]),
+		stage: z.string().optional(),
+		timingsMs: z.record(z.string(), z.number().optional()).optional(),
+		workflowRunUrl: z.string().optional()
+	}).optional(),
+	previewDeployRequired: z.boolean(),
+	repairs: z.array(readinessRepairSchema).default([]),
+	reviewCycleState: z.object({
+		autoBlockingFindings: z.number().int().nonnegative(),
+		countsBySeverity: z.object({
+			critical: z.number().int().nonnegative(),
+			high: z.number().int().nonnegative(),
+			low: z.number().int().nonnegative(),
+			medium: z.number().int().nonnegative(),
+			unknown: z.number().int().nonnegative()
+		}),
+		highestBlockingSeverity: z.enum([
+			"critical",
+			"high",
+			"medium",
+			"low",
+			"unknown"
+		]).optional(),
+		highestOpenSeverity: z.enum([
+			"critical",
+			"high",
+			"medium",
+			"low",
+			"unknown"
+		]).optional(),
+		maxReviewCycles: z.number().int().positive().optional(),
+		nonBlockingFindings: z.number().int().nonnegative(),
+		openFindings: z.number().int().nonnegative(),
+		reviewCycle: z.number().int().positive().optional(),
+		staleRepeatFindings: z.number().int().nonnegative().optional(),
+		windowExhausted: z.boolean()
+	}).optional(),
+	reviewLadder: z.object({
+		cycleCounts: z.object({
+			gate: z.number().int().nonnegative(),
+			interior: z.number().int().nonnegative()
+		}),
+		forcedTransition: z.enum([
+			"gate-cap-exhausted",
+			"interior-cap-reached",
+			"interior-takeover"
+		]).optional(),
+		nextAction: z.enum([
+			"run-interior-cycle",
+			"advance-to-gate",
+			"run-gate-cycle",
+			"accept-nonblocking-findings",
+			"escalate-to-triage",
+			"ready-for-human"
+		]),
+		stage: z.enum([
+			"interior",
+			"interior-takeover",
+			"interior-complete",
+			"gate"
+		])
+	}).optional(),
+	reviewRuns: z.array(prReviewResultSchema).optional(),
+	reviewTerminalState: z.enum([
+		"accepted-with-findings",
+		"blocked",
+		"clean"
+	]).optional(),
+	reviews: z.object({
+		correctness: reviewStateSchema,
+		security: reviewStateSchema.optional()
+	}),
+	schemaVersion: z.literal(1),
+	stackRole: z.enum([
+		"single",
+		"slice",
+		"rollup",
+		"merge-gate prerequisite"
+	]),
+	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()
+	})
+});
+const PR_READY_SCHEMA_VERSION = 1;
+const prReadyProofSchema = z.object({
+	blockingReasons: z.array(z.string()),
+	command: z.literal("patronage-factory pr:ready"),
+	followUp: followUpActionSchema.optional(),
+	humanBlockingReasons: z.array(z.string()).default([]),
+	ledger: managedReadinessLedgerSchema,
+	profileBlobSha: z.string().regex(/^[0-9a-f]{40}$/u).optional(),
+	profilePath: z.string().min(1).optional(),
+	repairs: z.array(readinessRepairSchema).default([]),
+	repository: z.string().regex(/^[^/\s]+\/[^/\s]+$/u).optional(),
+	schemaVersion: z.literal(1),
+	status: z.enum([
+		"ready",
+		"blocked",
+		"slice-ready/not-final"
+	])
+});
+//#endregion
+export { BOUNDARY_CHECK_SCHEMA_VERSION, BOUNDARY_REVIEW_PROOF_KIND, EVIDENCE_ENVELOPE_SCHEMA_VERSION, PR_MERGE_CHECK_SCHEMA_VERSION, PR_READY_SCHEMA_VERSION, PR_REVIEW_SCHEMA_VERSION, SUPPORTED_PR_VERIFY_SCHEMA_VERSIONS, boundaryCheckProofSchema, boundaryReviewProofSchema, closeoutArtifactSchema, evidenceEnvelopeSchema, prMergeCheckProofSchema, prReadyProofSchema, prReviewProofSchema, prVerifyProofSchema };