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

package/dist/schemas.d.ts

@@ -19,6 +19,32 @@ interface WaivedDemand {
 }
 declare const waivedDemandSchema: z.ZodType<WaivedDemand>;
 //#endregion
+//#region src/blocked-reasons.d.ts
+/**
+ * The wire bound on one `detail`. A blocked proof carries one short sentence
+ * per demand, never a transcript: HQ's ingest cap is 256 KB and this field
+ * must stay far under it even when a candidate blocks on every gate at once.
+ */
+declare const BLOCKED_REASON_DETAIL_MAX = 280;
+/**
+ * The wire bound on how many demands one proof may name. Well past any real
+ * candidate (there are a dozen fixed demands plus the profile's checks and the
+ * live human blockers) and, with the detail bound, keeps the whole field two
+ * orders of magnitude under the ingest cap. Bounded here rather than trimmed
+ * downstream: HQ rejects an over-long list loudly instead of storing a quietly
+ * truncated one.
+ */
+declare const BLOCKED_REASONS_MAX = 100;
+declare const blockedReasonSchema: z.ZodObject<{
+  code: z.ZodString;
+  detail: z.ZodString;
+}, z.core.$strip>;
+declare const blockedReasonsSchema: z.ZodArray<z.ZodObject<{
+  code: z.ZodString;
+  detail: z.ZodString;
+}, z.core.$strip>>;
+type BlockedReason = z.infer<typeof blockedReasonSchema>;
+//#endregion
 //#region src/boundary-review-proof.d.ts
 declare const boundaryReviewProofBaseSchema: z.ZodObject<{
   boundary: z.ZodString;
@@ -83,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];
@@ -226,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;
@@ -345,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<{
@@ -551,16 +481,38 @@ type ManagedReadinessLedger = z.infer<typeof managedReadinessLedgerSchema>;
 //#endregion
 //#region src/pr-ready.d.ts
 interface PrReadyProof {
-  schemaVersion: 1;
+  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
+   * refusal. Same refusals as `blockingReasons`, in the same order — the
+   * analyzable projection of a flat string list, so a wall of blocked proofs
+   * on one PR can be counted by cause. Absent when nothing blocked.
+   */
+  blockedReasons?: BlockedReason[];
   blockingReasons: string[];
   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;
   /**
@@ -570,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. */
@@ -578,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
@@ -1262,58 +1227,28 @@ 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<{
+declare 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.
+ */
+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;
-    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;
+    outcome: z.ZodEnum<{
+      merged: "merged";
+      armed: "armed";
+      "not-armed": "not-armed";
+    }>;
   }, z.core.$strip>>;
-}, z.core.$strip>;
-declare const PR_READY_SCHEMA_VERSION = 1;
-declare const prReadyProofSchema: z.ZodObject<{
+  blockedReasons: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    code: z.ZodString;
+    detail: z.ZodString;
+  }, z.core.$strip>>>;
   blockingReasons: z.ZodArray<z.ZodString>;
   command: z.ZodLiteral<"patronage-factory pr:ready">;
   followUp: z.ZodOptional<z.ZodObject<{
@@ -1338,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<{
@@ -1617,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<{
@@ -1629,12 +1564,13 @@ declare const prReadyProofSchema: z.ZodObject<{
     command: z.ZodString;
   }, z.core.$strip>>>;
   repository: z.ZodOptional<z.ZodString>;
-  schemaVersion: z.ZodLiteral<1>;
+  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 { BOUNDARY_CHECK_SCHEMA_VERSION, BOUNDARY_REVIEW_PROOF_KIND, 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_VERIFY_SCHEMA_VERSIONS, SUPPORTED_RETRO_ENVELOPE_SCHEMA_VERSIONS, type WaivedDemand, 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 };