@patronage/software-factory 0.25.0 → 0.30.0-alpha.1

package/dist/schemas.d.ts

@@ -109,105 +109,6 @@ interface FollowUpAction {
   command: string;
 }
 //#endregion
-//#region src/merge-preflight/worktree-held-branch.d.ts
-/**
- * Detects when a PR head branch is checked out in a local git worktree.
- *
- * `gh pr merge --delete-branch` fails when the local branch is held by a
- * worktree (git refuses to delete a checked-out branch), which previously
- * broke the auto-merge lane mid-merge (patronage/internal#284). The merge
- * preflight surfaces this as an actionable notice — not a hard fail — so the
- * operator merges without `--delete-branch` (or prunes the worktree first)
- * and defers local branch cleanup to closeout.
- */
-interface WorktreeHeldBranch {
-  branch: string;
-  worktreePath: string;
-}
-//#endregion
-//#region src/pr-readiness/merge-identity.d.ts
-interface PostProofCommit {
-  sha: string;
-  subject: string;
-}
-type MergeIdentityResult = {
-  kind: "match";
-  headSha: string;
-} | {
-  kind: "diverged";
-  liveHeadSha: string;
-  postProofCommits?: PostProofCommit[];
-  proofHeadSha: string;
-};
-type MergeGuardIdentity = MergeIdentityResult | {
-  kind: "live-head-invalid";
-  pr: number;
-  received: string;
-} | {
-  kind: "ready-proof-missing";
-  errorDetail?: string;
-  readyProofPath: string;
-} | {
-  kind: "ready-proof-pr-mismatch";
-  proofPr: number;
-  requestedPr: number;
-} | {
-  kind: "ready-proof-not-ready";
-  blockingReasons: string[];
-  status: string;
-};
-//#endregion
-//#region src/review-rungs.d.ts
-declare const EVIDENCE_REVIEW_RUNGS: readonly ["independent-model", "oracle", "human"];
-type EvidenceReviewRung = (typeof EVIDENCE_REVIEW_RUNGS)[number];
-//#endregion
-//#region src/pr-merge-check.d.ts
-interface PrMergeCheckProof {
-  schemaVersion: 1;
-  blockingReasons: string[];
-  boundary?: {
-    autoMerge: boolean;
-    epic: number;
-    review: EvidenceReviewRung;
-    wave: string;
-  };
-  command: "patronage-factory pr:merge-check";
-  /**
-   * Machine-safe arg array for the obvious next action (#523): on `pass`, the
-   * remote-only GitHub merge API invocation for this PR; on `fail`, the re-run that clears the
-   * block (`pr:ready`, or `pr:verify` then `pr:ready` after a head
-   * divergence). Same `argv` shape `factory:delegate --print` emits. Optional
-   * and purely additive — existing consumers ignore it.
-   */
-  followUp?: FollowUpAction;
-  identity: MergeGuardIdentity;
-  /**
-   * The pushed PR head SHA fetched from GitHub at check time. Absent only
-   * when GitHub returned no usable 40-hex head (identity kind
-   * "live-head-invalid"), which is itself a fail-closed blocking state.
-   */
-  liveHeadSha?: string;
-  /**
-   * Actionable operational notices that do not block the merge, e.g. a PR
-   * head branch held by a local worktree, which makes
-   * `gh pr merge --delete-branch` fail (patronage/internal#284).
-   */
-  notices?: string[];
-  pr: number;
-  status: "pass" | "fail";
-  /**
-   * Demands that were in force, were NOT met, and were waived by the operator
-   * (#354). Each entry carries the demand's refusals verbatim, so a waived
-   * demand can never read as a met one; the merge proceeds on the recorded
-   * operator act, not on evidence.
-   */
-  waivedDemands?: WaivedDemand[];
-  /** Present when the PR head branch is checked out in a local worktree. */
-  worktreeHeldBranch?: WorktreeHeldBranch;
-  /** All merge-relevant branches held by local worktrees (head and default). */
-  worktreeHeldBranches?: WorktreeHeldBranch[];
-}
-//#endregion
 //#region src/diff-classification.d.ts
 declare const DIFF_CLASSIFICATIONS: readonly ["docs/process-only", "trivial", "non-trivial"];
 type DiffClassification = (typeof DIFF_CLASSIFICATIONS)[number];
@@ -252,6 +153,10 @@ interface ReviewFindingAttributes {
   title: string;
 }
 //#endregion
+//#region src/review-rungs.d.ts
+declare const EVIDENCE_REVIEW_RUNGS: readonly ["independent-model", "oracle", "human"];
+type EvidenceReviewRung = (typeof EVIDENCE_REVIEW_RUNGS)[number];
+//#endregion
 //#region src/review-ladder-ledger.d.ts
 type LadderCycleStage = "interior" | "gate";
 type LadderFindingReport = ReviewFindingAttributes;
@@ -371,12 +276,11 @@ declare const managedReadinessLedgerSchema: z.ZodObject<{
     name: z.ZodString;
     reason: z.ZodOptional<z.ZodString>;
     scope: z.ZodOptional<z.ZodObject<{
-      classifications: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+      classifications: z.ZodArray<z.ZodEnum<{
         "docs/process-only": "docs/process-only";
         trivial: "trivial";
         "non-trivial": "non-trivial";
-      }>>>;
-      labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      }>>;
     }, z.core.$strict>>;
     scopeReason: z.ZodString;
     status: z.ZodEnum<{
@@ -577,7 +481,20 @@ type ManagedReadinessLedger = z.infer<typeof managedReadinessLedgerSchema>;
 //#endregion
 //#region src/pr-ready.d.ts
 interface PrReadyProof {
-  schemaVersion: 2;
+  schemaVersion: 3;
+  /**
+   * What GitHub actually did when this run armed native auto-merge (#477).
+   * Present exactly when readiness passed and the arming ran; read back from
+   * the PR rather than inferred from the invocation, because `gh pr merge
+   * --auto` arms, merges, or does nothing with the same exit code and the same
+   * empty output. `not-armed` means the candidate is admitted but nothing will
+   * merge it, and `followUp` carries the re-dispatch.
+   */
+  arming?: {
+    detail?: string;
+    headSha: string;
+    outcome: "armed" | "merged" | "not-armed";
+  };
   /**
    * Why this run blocked, one entry per refusing demand (#391): `code` is the
    * demand key from the resolver's vocabulary, `detail` the one-sentence
@@ -590,11 +507,12 @@ interface PrReadyProof {
   humanBlockingReasons: string[];
   command: "patronage-factory pr:ready";
   /**
-   * Machine-safe arg array for the obvious next action (#523): when `ready`,
-   * the `pr:merge-check` that must precede a merge; otherwise the `pr:verify`
-   * re-run that the blocking reasons name (re-verify the head, then re-run
-   * pr:ready). Same `argv` shape `factory:delegate --print` emits. Optional
-   * and purely additive.
+   * Machine-safe arg array for the obvious next action (#523): when `ready`
+   * but arming did not take effect, a `pr:ready` re-dispatch (idempotent on
+   * an unchanged head); otherwise the `gh pr ready` undraft repair or the
+   * `pr:verify` re-run that the blocking reasons name (re-verify the head,
+   * then re-run pr:ready). Same `argv` shape `factory:delegate --print`
+   * emits. Optional and purely additive.
    */
   followUp?: FollowUpAction;
   /**
@@ -604,6 +522,12 @@ interface PrReadyProof {
    * pushed HEAD, not a re-derivation. See the ledger schema.
    */
   ledger: ManagedReadinessLedger;
+  /**
+   * Actionable facts that did not block (#477): a settling merge-freeze
+   * generation that armed with a notice, and how each waived demand reads to a
+   * human. Absent when there are none.
+   */
+  notices?: string[];
   /** Committed profile blob evaluated by readiness. Required for merge. */
   profileBlobSha?: string;
   /** Checkout-relative committed profile path evaluated by readiness. */
@@ -612,6 +536,13 @@ interface PrReadyProof {
   /** Trusted checkout repository used for all GitHub reads and writes. */
   repository?: string;
   status: ReadinessStatus;
+  /**
+   * Demands that were in force, were NOT met, and were waived by the operator
+   * (#354, moved here from the merge-time proof by #477). Each entry carries
+   * the demand's refusals verbatim, so a waived demand can never read as a met
+   * one; the arming proceeds on the recorded operator act, not on evidence.
+   */
+  waivedDemands?: WaivedDemand[];
 }
 //#endregion
 //#region src/pr-readiness/external-evidence.d.ts
@@ -1296,64 +1227,24 @@ declare const boundaryCheckProofSchema: z.ZodObject<{
   }>;
 }, z.core.$strip>;
 type BoundaryCheckProofRecord = z.infer<typeof boundaryCheckProofSchema>;
-declare const PR_MERGE_CHECK_SCHEMA_VERSION = 1;
-declare const prMergeCheckProofSchema: z.ZodObject<{
-  blockingReasons: z.ZodArray<z.ZodString>;
-  command: z.ZodLiteral<"patronage-factory pr:merge-check">;
-  followUp: z.ZodOptional<z.ZodObject<{
-    argv: z.ZodArray<z.ZodString>;
-    command: z.ZodString;
-  }, z.core.$strict>>;
-  identity: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    headSha: z.ZodString;
-    kind: z.ZodLiteral<"match">;
-  }, z.core.$strip>, z.ZodObject<{
-    kind: z.ZodLiteral<"diverged">;
-    liveHeadSha: z.ZodString;
-    postProofCommits: z.ZodOptional<z.ZodArray<z.ZodObject<{
-      sha: z.ZodString;
-      subject: z.ZodString;
-    }, z.core.$strip>>>;
-    proofHeadSha: z.ZodString;
-  }, z.core.$strip>, z.ZodObject<{
-    kind: z.ZodLiteral<"live-head-invalid">;
-    pr: z.ZodNumber;
-    received: z.ZodString;
-  }, z.core.$strip>, z.ZodObject<{
-    errorDetail: z.ZodOptional<z.ZodString>;
-    kind: z.ZodLiteral<"ready-proof-missing">;
-    readyProofPath: z.ZodString;
-  }, z.core.$strip>, z.ZodObject<{
-    kind: z.ZodLiteral<"ready-proof-pr-mismatch">;
-    proofPr: z.ZodNumber;
-    requestedPr: z.ZodNumber;
-  }, z.core.$strip>, z.ZodObject<{
-    blockingReasons: z.ZodArray<z.ZodString>;
-    kind: z.ZodLiteral<"ready-proof-not-ready">;
-    status: z.ZodString;
-  }, z.core.$strip>], "kind">;
-  liveHeadSha: z.ZodOptional<z.ZodString>;
-  notices: z.ZodOptional<z.ZodArray<z.ZodString>>;
-  pr: z.ZodNumber;
-  schemaVersion: z.ZodLiteral<1>;
-  status: z.ZodEnum<{
-    pass: "pass";
-    fail: "fail";
-  }>;
-  waivedDemands: z.ZodOptional<z.ZodArray<z.ZodType<WaivedDemand, unknown, z.core.$ZodTypeInternals<WaivedDemand, unknown>>>>;
-  worktreeHeldBranch: z.ZodOptional<z.ZodObject<{
-    branch: z.ZodString;
-    worktreePath: z.ZodString;
-  }, z.core.$strip>>;
-}, z.core.$strip>;
-declare const PR_READY_SCHEMA_VERSION = 2;
+declare const PR_READY_SCHEMA_VERSION = 3;
 /**
- * The pr:ready proof versions a reader still accepts. `pr:ready` emits v2 only
- * (#391) — one current contract — but v1 events were spooled before the bump
- * and HQ must ingest them without degrading, so the wire schema parses both.
+ * 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.
  */
-declare const SUPPORTED_PR_READY_SCHEMA_VERSIONS: readonly [1, 2];
+declare const SUPPORTED_PR_READY_SCHEMA_VERSIONS: readonly [1, 2, 3];
 declare const prReadyProofSchema: z.ZodObject<{
+  arming: z.ZodOptional<z.ZodObject<{
+    detail: z.ZodOptional<z.ZodString>;
+    headSha: z.ZodString;
+    outcome: z.ZodEnum<{
+      merged: "merged";
+      armed: "armed";
+      "not-armed": "not-armed";
+    }>;
+  }, z.core.$strip>>;
   blockedReasons: z.ZodOptional<z.ZodArray<z.ZodObject<{
     code: z.ZodString;
     detail: z.ZodString;
@@ -1382,12 +1273,11 @@ declare const prReadyProofSchema: z.ZodObject<{
       name: z.ZodString;
       reason: z.ZodOptional<z.ZodString>;
       scope: z.ZodOptional<z.ZodObject<{
-        classifications: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        classifications: z.ZodArray<z.ZodEnum<{
           "docs/process-only": "docs/process-only";
           trivial: "trivial";
           "non-trivial": "non-trivial";
-        }>>>;
-        labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }>>;
       }, z.core.$strict>>;
       scopeReason: z.ZodString;
       status: z.ZodEnum<{
@@ -1661,6 +1551,7 @@ declare const prReadyProofSchema: z.ZodObject<{
       verifiedHeadSha: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
   }, z.core.$strip>;
+  notices: z.ZodOptional<z.ZodArray<z.ZodString>>;
   profileBlobSha: z.ZodOptional<z.ZodString>;
   profilePath: z.ZodOptional<z.ZodString>;
   repairs: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -1673,12 +1564,13 @@ declare const prReadyProofSchema: z.ZodObject<{
     command: z.ZodString;
   }, z.core.$strip>>>;
   repository: z.ZodOptional<z.ZodString>;
-  schemaVersion: z.ZodNumber & z.ZodType<1 | 2, number, z.core.$ZodTypeInternals<1 | 2, number>>;
+  schemaVersion: z.ZodNumber & z.ZodType<1 | 2 | 3, number, z.core.$ZodTypeInternals<1 | 2 | 3, number>>;
   status: z.ZodEnum<{
     ready: "ready";
     blocked: "blocked";
     "slice-ready/not-final": "slice-ready/not-final";
   }>;
+  waivedDemands: z.ZodOptional<z.ZodArray<z.ZodType<WaivedDemand, unknown, z.core.$ZodTypeInternals<WaivedDemand, unknown>>>>;
 }, z.core.$strip>;
 //#endregion
-export { BLOCKED_REASONS_MAX, BLOCKED_REASON_DETAIL_MAX, BOUNDARY_CHECK_SCHEMA_VERSION, BOUNDARY_REVIEW_PROOF_KIND, type BlockedReason, BoundaryCheckProofRecord, type BoundaryReviewProof, type CloseoutArtifact, EVIDENCE_ENVELOPE_SCHEMA_VERSION, type EvidenceEnvelope, PR_MERGE_CHECK_SCHEMA_VERSION, PR_READY_SCHEMA_VERSION, PR_REVIEW_SCHEMA_VERSION, type ParsedRetroEnvelope, type PrMergeCheckProof, type PrReadyProof, type PrReviewProof, type PrVerifyProof, RETRO_ENVELOPE_SCHEMA_VERSION, RETRO_ENVELOPE_VALIDATORS, RETRO_ENVELOPE_WIRE_BOUNDS, type RetroEnvelope, SUPPORTED_PR_READY_SCHEMA_VERSIONS, SUPPORTED_PR_VERIFY_SCHEMA_VERSIONS, SUPPORTED_RETRO_ENVELOPE_SCHEMA_VERSIONS, type WaivedDemand, blockedReasonSchema, blockedReasonsSchema, boundaryCheckProofSchema, boundaryReviewProofSchema, closeoutArtifactSchema, evidenceEnvelopeSchema, prMergeCheckProofSchema, prReadyProofSchema, prReviewProofSchema, prVerifyProofSchema, retroEnvelopeV1Schema, retroEpicReference, waivedDemandSchema };
+export { BLOCKED_REASONS_MAX, BLOCKED_REASON_DETAIL_MAX, BOUNDARY_CHECK_SCHEMA_VERSION, BOUNDARY_REVIEW_PROOF_KIND, type BlockedReason, BoundaryCheckProofRecord, type BoundaryReviewProof, type CloseoutArtifact, EVIDENCE_ENVELOPE_SCHEMA_VERSION, type EvidenceEnvelope, PR_READY_SCHEMA_VERSION, PR_REVIEW_SCHEMA_VERSION, type ParsedRetroEnvelope, type PrReadyProof, type PrReviewProof, type PrVerifyProof, RETRO_ENVELOPE_SCHEMA_VERSION, RETRO_ENVELOPE_VALIDATORS, RETRO_ENVELOPE_WIRE_BOUNDS, type RetroEnvelope, SUPPORTED_PR_READY_SCHEMA_VERSIONS, SUPPORTED_PR_VERIFY_SCHEMA_VERSIONS, SUPPORTED_RETRO_ENVELOPE_SCHEMA_VERSIONS, type WaivedDemand, blockedReasonSchema, blockedReasonsSchema, boundaryCheckProofSchema, boundaryReviewProofSchema, closeoutArtifactSchema, evidenceEnvelopeSchema, prReadyProofSchema, prReviewProofSchema, prVerifyProofSchema, retroEnvelopeV1Schema, retroEpicReference, waivedDemandSchema };

package/dist/schemas.js

@@ -10,6 +10,13 @@ Object.fromEntries(EVIDENCE_REVIEW_RUNGS$1.map((rung, index) => [rung, index]));
 //#region src/demand-keys.ts
 /** The demands that exist at most once per candidate. */
 const DEMAND_KEYS = {
+	/**
+	* The boundary wave that authorizes this candidate's merge schedule (#477).
+	* In force exactly when GitHub already has auto-merge enabled: a live
+	* schedule with no wave demand resolved is an unauthorized merge waiting to
+	* happen.
+	*/
+	boundaryWave: "boundary-wave",
 	/** The PR is still a draft. */
 	draft: "draft",
 	/** The candidate is not the intended final human review point. */
@@ -24,6 +31,12 @@ const DEMAND_KEYS = {
 	mergeFreeze: "merge-freeze",
 	/** GitHub's mergeability / merge-state rollup. */
 	mergeState: "merge-state",
+	/**
+	* A native GitHub approval, demanded when the boundary wave in force does
+	* not authorize machine merge (#477). "Green = authorized to merge" is then
+	* a property of the branded required check itself.
+	*/
+	nativeApproval: "native-approval",
 	/** The PR body's required rendered sections. */
 	prBodySections: "pr-body-sections",
 	/** A current, head-bound, passing typed `pr:verify` proof. */
@@ -54,7 +67,7 @@ const percentEncode = (character) => {
 * demand nobody waived, and make HQ count two causes as one.
 *
 * Deterministic in both directions of use: the key a `pr:ready` proof records
-* is the key a `pr:merge-check` waiver matches.
+* is the key a `pr:ready` waiver matches.
 */
 const demandQualifier = (value) => value.replaceAll(/[^A-Za-z0-9._/-]/gu, percentEncode);
 const FIXED_DEMAND_KEYS = Object.values(DEMAND_KEYS);
@@ -132,7 +145,7 @@ const demandKeySchema = z.string().refine((value) => {
 * reason codes must come from. A waiver store is durable operator evidence
 * written before today's vocabulary existed, so tightening its validation
 * would make an existing record parse as no waiver and let the next write drop
-* it. A waiver naming a key nobody resolves is already inert — `pr:merge-check`
+* it. A waiver naming a key nobody resolves is already inert — `pr:ready`
 * reports it as an unapplied waiver — so nothing is admitted by accepting it.
 */
 const waiverDemandKeySchema = z.string().regex(/^[a-z][a-z0-9-]*(?::[A-Za-z0-9._%/-]+)?$/u, "A demand key is a lowercase family, optionally qualified by its resolved value (e.g. review-rung:human).");
@@ -979,67 +992,7 @@ const boundaryCheckProofSchema = z.object({
 	}).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"]),
-	waivedDemands: z.array(waivedDemandSchema).optional(),
-	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 requiredCheckScopeSchema = z.object({ classifications: z.array(z.enum(DIFF_CLASSIFICATIONS)).min(1) }).strict();
 const readinessRepairSchema = z.object({
 	action: z.string().min(1),
 	code: z.enum([
@@ -1214,21 +1167,36 @@ const managedReadinessLedgerSchema = z.object({
 		verifiedHeadSha: z.string().optional()
 	})
 });
-const PR_READY_SCHEMA_VERSION = 2;
+const PR_READY_SCHEMA_VERSION = 3;
 /**
-* The pr:ready proof versions a reader still accepts. `pr:ready` emits v2 only
-* (#391) — one current contract — but v1 events were spooled before the bump
-* and HQ must ingest them without degrading, so the wire schema parses both.
+* 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.
 */
-const SUPPORTED_PR_READY_SCHEMA_VERSIONS = [1, 2];
+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 prReadyProofSchema = z.object({
+	arming: z.object({
+		detail: z.string().min(1).optional(),
+		headSha: z.string().regex(/^[0-9a-f]{40}$/u),
+		outcome: z.enum([
+			"armed",
+			"merged",
+			"not-armed"
+		])
+	}).optional(),
 	blockedReasons: blockedReasonsSchema.optional(),
 	blockingReasons: z.array(z.string()),
 	command: z.literal("patronage-factory pr:ready"),
 	followUp: followUpActionSchema.optional(),
 	humanBlockingReasons: z.array(z.string()).default([]),
 	ledger: managedReadinessLedgerSchema,
+	notices: z.array(z.string().min(1)).optional(),
 	profileBlobSha: z.string().regex(/^[0-9a-f]{40}$/u).optional(),
 	profilePath: z.string().min(1).optional(),
 	repairs: z.array(readinessRepairSchema).default([]),
@@ -1238,7 +1206,8 @@ const prReadyProofSchema = z.object({
 		"ready",
 		"blocked",
 		"slice-ready/not-final"
-	])
+	]),
+	waivedDemands: z.array(waivedDemandSchema).optional()
 }).superRefine((proof, context) => {
 	if (proof.schemaVersion < 2) {
 		if (proof.blockedReasons !== void 0) context.addIssue({
@@ -1254,4 +1223,4 @@ const prReadyProofSchema = z.object({
 	})) 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_MERGE_CHECK_SCHEMA_VERSION, PR_READY_SCHEMA_VERSION, PR_REVIEW_SCHEMA_VERSION, RETRO_ENVELOPE_SCHEMA_VERSION, RETRO_ENVELOPE_VALIDATORS, RETRO_ENVELOPE_WIRE_BOUNDS, SUPPORTED_PR_READY_SCHEMA_VERSIONS, SUPPORTED_PR_VERIFY_SCHEMA_VERSIONS, SUPPORTED_RETRO_ENVELOPE_SCHEMA_VERSIONS, blockedReasonSchema, blockedReasonsSchema, boundaryCheckProofSchema, boundaryReviewProofSchema, closeoutArtifactSchema, evidenceEnvelopeSchema, prMergeCheckProofSchema, prReadyProofSchema, prReviewProofSchema, prVerifyProofSchema, retroEnvelopeV1Schema, retroEpicReference, 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, RETRO_ENVELOPE_SCHEMA_VERSION, RETRO_ENVELOPE_VALIDATORS, RETRO_ENVELOPE_WIRE_BOUNDS, SUPPORTED_PR_READY_SCHEMA_VERSIONS, SUPPORTED_PR_VERIFY_SCHEMA_VERSIONS, SUPPORTED_RETRO_ENVELOPE_SCHEMA_VERSIONS, blockedReasonSchema, blockedReasonsSchema, boundaryCheckProofSchema, boundaryReviewProofSchema, closeoutArtifactSchema, evidenceEnvelopeSchema, prReadyProofSchema, prReviewProofSchema, prVerifyProofSchema, retroEnvelopeV1Schema, retroEpicReference, waivedDemandSchema };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@patronage/software-factory",
-  "version": "0.25.0",
+  "version": "0.30.0-alpha.1",
   "description": "Shared Patronage software factory CLI and project-profile validation tools",
   "license": "MIT",
   "repository": {