@patronage/software-factory 0.20.0

package/dist/schemas.d.ts

@@ -0,0 +1,1430 @@
+import { z } from "zod";
+
+//#region src/boundary-review-proof.d.ts
+declare const boundaryReviewProofBaseSchema: z.ZodObject<{
+  boundary: z.ZodString;
+  coveredSet: z.ZodArray<z.ZodObject<{
+    headSha: z.ZodOptional<z.ZodString>;
+    issue: z.ZodOptional<z.ZodNumber>;
+    mergedSha: z.ZodOptional<z.ZodString>;
+    pr: z.ZodNumber;
+    state: z.ZodEnum<{
+      merged: "merged";
+      open: "open";
+    }>;
+    wave: z.ZodOptional<z.ZodString>;
+  }, z.core.$loose>>;
+  dispositions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+  findings: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    blockingAfterCap: z.ZodOptional<z.ZodBoolean>;
+    category: z.ZodOptional<z.ZodString>;
+    disposition: z.ZodOptional<z.ZodString>;
+    title: z.ZodString;
+  }, z.core.$loose>>>;
+  kind: z.ZodLiteral<"boundary-review-proof">;
+  manifestHash: z.ZodObject<{
+    algo: z.ZodLiteral<"sha256">;
+    scope: z.ZodOptional<z.ZodString>;
+    value: z.ZodString;
+  }, z.core.$loose>;
+  outcome: z.ZodEnum<{
+    pass: "pass";
+    fail: "fail";
+  }>;
+  producer: z.ZodString;
+  rung: z.ZodEnum<{
+    "independent-model": "independent-model";
+    oracle: "oracle";
+    human: "human";
+  }>;
+  schemaVersion: z.ZodLiteral<1>;
+  sessionId: z.ZodOptional<z.ZodString>;
+  specHash: z.ZodOptional<z.ZodObject<{
+    algo: z.ZodLiteral<"sha256">;
+    scope: z.ZodOptional<z.ZodString>;
+    value: z.ZodString;
+  }, z.core.$loose>>;
+}, z.core.$loose>;
+type BoundaryReviewProof = z.infer<typeof boundaryReviewProofBaseSchema>;
+//#endregion
+//#region src/follow-up.d.ts
+interface FollowUpAction {
+  /**
+   * Machine-safe argv-style array for the obvious next action, e.g.
+   * ["gh","pr","merge","513","--squash"]. Same shape and field name that
+   * `factory:delegate --print` emits, so an orchestrating agent can spawn the
+   * next command without reconstructing a shell string. argv[0] is the
+   * executable; the rest are literal, already-split arguments.
+   */
+  argv: string[];
+  /**
+   * Human-readable rendering of {@link argv} for logs and operators. Additive
+   * to argv, never a substitute for it — argv is the source of truth.
+   */
+  command: string;
+}
+//#endregion
+//#region src/diff-classification.d.ts
+declare const DIFF_CLASSIFICATIONS: readonly ["docs/process-only", "trivial", "non-trivial"];
+type DiffClassification = (typeof DIFF_CLASSIFICATIONS)[number];
+//#endregion
+//#region src/pr-verify-mode.d.ts
+/**
+ * The verification mode `pr:verify` resolved for a run.
+ *
+ * Canonically declared here rather than inside `pr-readiness/` so that modules
+ * on either side of that boundary — the readiness proof shape and the durable
+ * check-run payload — can name the same union without importing each other.
+ */
+type ResolvedPrVerifyMode = "docs-only" | "trivial" | "full";
+//#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";
+  /** 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/packages/review-prompt-sections/schema.d.ts
+declare const reviewPromptSectionSchema: z.ZodObject<{
+  provenance: z.ZodEnum<{
+    "prior-review-ledger": "prior-review-ledger";
+    "profile-standing-checklist": "profile-standing-checklist";
+    "issue-review-focus": "issue-review-focus";
+  }>;
+  source: z.ZodString;
+  text: z.ZodString;
+}, z.core.$strict>;
+type ReviewPromptSection = z.infer<typeof reviewPromptSectionSchema>;
+//#endregion
+//#region src/review-ladder-policy.d.ts
+type ReviewFindingCategory = "correctness" | "safety" | "coordination" | "maintainability" | "unknown";
+declare const FINDING_DISPOSITIONS: readonly ["open", "fixed-in-thread", "follow-up-filed", "waived", "stale-repeat", "rerun-noise"];
+type FindingDisposition = (typeof FINDING_DISPOSITIONS)[number];
+interface ReviewFindingAttributes {
+  blockingAfterCap?: boolean;
+  category?: string;
+  citedSpan?: string;
+  file?: string;
+  prescribedAction?: string;
+  priority?: string;
+  supersedes?: {
+    file?: string;
+    title: string;
+  };
+  title: string;
+}
+//#endregion
+//#region src/review-ladder-ledger.d.ts
+type LadderCycleStage = "interior" | "gate";
+type LadderFindingReport = ReviewFindingAttributes;
+type DeclarableFindingDisposition = Exclude<FindingDisposition, "open" | "stale-repeat" | "rerun-noise">;
+interface LadderDispositionDeclaration {
+  disposition: DeclarableFindingDisposition;
+  finding: {
+    file?: string;
+    title: string;
+  };
+  findingReport?: LadderFindingReport;
+  reference?: string;
+}
+//#endregion
+//#region src/review-ladder.d.ts
+interface LadderSessionAttribution {
+  orchestrationMode?: "autonomous" | "manual";
+  resumedSession?: boolean;
+  runtime?: string;
+  sessionId?: string;
+}
+interface LadderUsageReport {
+  estimatedCostUsd?: number;
+  source?: string;
+  totalTokens?: number;
+}
+interface ReviewLadderCycle {
+  dispositions?: LadderDispositionDeclaration[];
+  engine?: string;
+  findings: LadderFindingReport[];
+  identity?: {
+    headSha: string;
+    patchId: string;
+  };
+  model?: string;
+  correlatedRerun?: boolean;
+  session?: LadderSessionAttribution;
+  stage: LadderCycleStage;
+  usage?: LadderUsageReport;
+}
+//#endregion
+//#region src/pr-readiness/ladder-proof-state.d.ts
+interface PrReviewLadderState {
+  cycles: ReviewLadderCycle[];
+}
+//#endregion
+//#region src/pr-readiness/review-proof-types.d.ts
+type PrReviewKind = "correctness" | "security";
+type PrReviewOutcome = "passed" | "failed" | "error";
+//#endregion
+//#region src/pr-readiness/review-proof-shape.d.ts
+interface PrReviewFinding extends ReviewFindingAttributes {
+  body: string;
+  category?: ReviewFindingCategory;
+  line?: number;
+  protocolFinding?: true;
+}
+interface PrReviewResult {
+  kind: PrReviewKind;
+  startedAt: string;
+  endedAt: string;
+  durationMs: number;
+  model?: string;
+  producer?: string;
+  rung?: EvidenceReviewRung;
+  sessionId?: string;
+  outcome: PrReviewOutcome;
+  issuesFlagged: number;
+  summary: string;
+  findings: PrReviewFinding[];
+  typedVerdict?: boolean;
+  verdictSource?: "footer" | "recovered";
+  promptSections?: ReviewPromptSection[];
+}
+interface PrReviewProof {
+  schemaVersion: 2;
+  findingProvenanceVersion: 1;
+  base: string;
+  headSha: string;
+  patchId: string;
+  reviewCycle?: number;
+  maxReviewCycles?: number;
+  changedFiles: string[];
+  cleanedPaths: string[];
+  ladder?: PrReviewLadderState;
+  reviewRequirement?: {
+    reason: "docs-only-profile-bypass";
+    status: "not-required";
+  };
+  reviews: PrReviewResult[];
+}
+//#endregion
+//#region src/pr-readiness/readiness-ledger.d.ts
+declare const readinessRepairSchema: z.ZodObject<{
+  action: z.ZodString;
+  code: z.ZodEnum<{
+    "undraft-pr": "undraft-pr";
+    "render-pr-body-sections": "render-pr-body-sections";
+    "await-post-undraft-checks": "await-post-undraft-checks";
+  }>;
+  command: z.ZodString;
+}, z.core.$strip>;
+declare const managedReadinessLedgerSchema: z.ZodObject<{
+  baseSha: z.ZodString;
+  blockingReasons: z.ZodArray<z.ZodString>;
+  classification: z.ZodEnum<{
+    "docs/process-only": "docs/process-only";
+    trivial: "trivial";
+    "non-trivial": "non-trivial";
+  }>;
+  externalChecks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    checkType: z.ZodEnum<{
+      review: "review";
+      verify: "verify";
+    }>;
+    inScope: z.ZodBoolean;
+    name: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+    scope: z.ZodOptional<z.ZodObject<{
+      classifications: z.ZodOptional<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<{
+      satisfied: "satisfied";
+      unmet: "unmet";
+      "out-of-scope": "out-of-scope";
+    }>;
+  }, z.core.$strip>>>;
+  finalReviewPoint: z.ZodBoolean;
+  github: z.ZodObject<{
+    currentWithBase: z.ZodBoolean;
+    draft: z.ZodBoolean;
+    mergeStateStatus: z.ZodString;
+    mergeable: z.ZodString;
+    requiredChecks: z.ZodEnum<{
+      unknown: "unknown";
+      passed: "passed";
+      failed: "failed";
+      pending: "pending";
+      none: "none";
+    }>;
+    unresolvedReviewThreads: z.ZodNumber;
+  }, z.core.$strip>;
+  handledCommentsProducer: z.ZodOptional<z.ZodObject<{
+    identity: z.ZodString;
+    mode: z.ZodEnum<{
+      app: "app";
+      "commit-status": "commit-status";
+    }>;
+  }, z.core.$strip>>;
+  handledHumanComments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    clearedAt: z.ZodOptional<z.ZodString>;
+    sessionId: z.ZodOptional<z.ZodString>;
+    source: z.ZodEnum<{
+      cli: "cli";
+      "check-run": "check-run";
+    }>;
+    url: z.ZodString;
+  }, z.core.$strip>>>;
+  headSha: z.ZodString;
+  mergeBaseSha: z.ZodOptional<z.ZodString>;
+  patchId: z.ZodString;
+  postReadinessHumanComments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    author: z.ZodString;
+    createdAt: z.ZodString;
+    summary: z.ZodString;
+    url: z.ZodString;
+  }, z.core.$strip>>>;
+  postReadinessHumanReviews: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    author: z.ZodString;
+    createdAt: z.ZodString;
+    summary: z.ZodString;
+    url: z.ZodString;
+  }, z.core.$strip>>>;
+  pr: z.ZodNumber;
+  previewDeploy: z.ZodOptional<z.ZodObject<{
+    adminUrl: z.ZodOptional<z.ZodString>;
+    apiHealthUrl: z.ZodOptional<z.ZodString>;
+    headSha: z.ZodOptional<z.ZodString>;
+    localPreviewProof: z.ZodOptional<z.ZodUnknown>;
+    localProofPath: z.ZodOptional<z.ZodString>;
+    proofSource: z.ZodOptional<z.ZodEnum<{
+      "github-actions": "github-actions";
+      "local-self-certified": "local-self-certified";
+    }>>;
+    publicUrl: z.ZodOptional<z.ZodString>;
+    seedStatus: z.ZodEnum<{
+      unknown: "unknown";
+      passed: "passed";
+      failed: "failed";
+      skipped: "skipped";
+    }>;
+    stage: z.ZodOptional<z.ZodString>;
+    timingsMs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodOptional<z.ZodNumber>>>;
+    workflowRunUrl: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  previewDeployRequired: z.ZodBoolean;
+  repairs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    action: z.ZodString;
+    code: z.ZodEnum<{
+      "undraft-pr": "undraft-pr";
+      "render-pr-body-sections": "render-pr-body-sections";
+      "await-post-undraft-checks": "await-post-undraft-checks";
+    }>;
+    command: z.ZodString;
+  }, z.core.$strip>>>;
+  reviewCycleState: z.ZodOptional<z.ZodObject<{
+    autoBlockingFindings: z.ZodNumber;
+    countsBySeverity: z.ZodObject<{
+      critical: z.ZodNumber;
+      high: z.ZodNumber;
+      low: z.ZodNumber;
+      medium: z.ZodNumber;
+      unknown: z.ZodNumber;
+    }, z.core.$strip>;
+    highestBlockingSeverity: z.ZodOptional<z.ZodEnum<{
+      unknown: "unknown";
+      low: "low";
+      medium: "medium";
+      high: "high";
+      critical: "critical";
+    }>>;
+    highestOpenSeverity: z.ZodOptional<z.ZodEnum<{
+      unknown: "unknown";
+      low: "low";
+      medium: "medium";
+      high: "high";
+      critical: "critical";
+    }>>;
+    maxReviewCycles: z.ZodOptional<z.ZodNumber>;
+    nonBlockingFindings: z.ZodNumber;
+    openFindings: z.ZodNumber;
+    reviewCycle: z.ZodOptional<z.ZodNumber>;
+    staleRepeatFindings: z.ZodOptional<z.ZodNumber>;
+    windowExhausted: z.ZodBoolean;
+  }, z.core.$strip>>;
+  reviewLadder: z.ZodOptional<z.ZodObject<{
+    cycleCounts: z.ZodObject<{
+      gate: z.ZodNumber;
+      interior: z.ZodNumber;
+    }, z.core.$strip>;
+    forcedTransition: z.ZodOptional<z.ZodEnum<{
+      "gate-cap-exhausted": "gate-cap-exhausted";
+      "interior-cap-reached": "interior-cap-reached";
+    }>>;
+    nextAction: z.ZodEnum<{
+      "run-interior-cycle": "run-interior-cycle";
+      "advance-to-gate": "advance-to-gate";
+      "run-gate-cycle": "run-gate-cycle";
+      "accept-nonblocking-findings": "accept-nonblocking-findings";
+      "escalate-to-triage": "escalate-to-triage";
+      "ready-for-human": "ready-for-human";
+    }>;
+    stage: z.ZodEnum<{
+      gate: "gate";
+      interior: "interior";
+      "interior-complete": "interior-complete";
+    }>;
+  }, z.core.$strip>>;
+  reviewRuns: z.ZodOptional<z.ZodArray<z.ZodType<PrReviewResult, unknown, z.core.$ZodTypeInternals<PrReviewResult, unknown>>>>;
+  reviewTerminalState: z.ZodOptional<z.ZodEnum<{
+    blocked: "blocked";
+    "accepted-with-findings": "accepted-with-findings";
+    clean: "clean";
+  }>>;
+  reviews: z.ZodObject<{
+    correctness: z.ZodObject<{
+      docsOnlyDeltaAccepted: z.ZodOptional<z.ZodBoolean>;
+      required: z.ZodBoolean;
+      reviewedHeadSha: z.ZodOptional<z.ZodString>;
+      reviewedPatchId: z.ZodOptional<z.ZodString>;
+      status: z.ZodEnum<{
+        "not-required": "not-required";
+        blocked: "blocked";
+        current: "current";
+        stale: "stale";
+        missing: "missing";
+      }>;
+    }, z.core.$strip>;
+    security: z.ZodOptional<z.ZodObject<{
+      docsOnlyDeltaAccepted: z.ZodOptional<z.ZodBoolean>;
+      required: z.ZodBoolean;
+      reviewedHeadSha: z.ZodOptional<z.ZodString>;
+      reviewedPatchId: z.ZodOptional<z.ZodString>;
+      status: z.ZodEnum<{
+        "not-required": "not-required";
+        blocked: "blocked";
+        current: "current";
+        stale: "stale";
+        missing: "missing";
+      }>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>;
+  schemaVersion: z.ZodLiteral<1>;
+  stackRole: z.ZodEnum<{
+    single: "single";
+    slice: "slice";
+    rollup: "rollup";
+    "merge-gate prerequisite": "merge-gate prerequisite";
+  }>;
+  verification: z.ZodObject<{
+    command: z.ZodLiteral<"patronage-factory pr:verify">;
+    docsOnlyDeltaAccepted: z.ZodOptional<z.ZodBoolean>;
+    docsOnlyVerifiedHeadSha: z.ZodOptional<z.ZodString>;
+    prVerify: z.ZodEnum<{
+      passed: "passed";
+      stale: "stale";
+      missing: "missing";
+    }>;
+    trivialDeltaAccepted: z.ZodOptional<z.ZodBoolean>;
+    trivialVerifiedHeadSha: z.ZodOptional<z.ZodString>;
+    verifiedHeadSha: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+type ReadinessRepair = z.infer<typeof readinessRepairSchema>;
+type ReadinessStatus = "ready" | "blocked" | "slice-ready/not-final";
+type ManagedReadinessLedger = z.infer<typeof managedReadinessLedgerSchema>;
+//#endregion
+//#region src/pr-ready.d.ts
+interface PrReadyProof {
+  schemaVersion: 1;
+  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.
+   */
+  followUp?: FollowUpAction;
+  /**
+   * `ledger.headSha` is the evaluated head SHA: the GitHub `pr.headRefOid`
+   * captured at evaluation time (not a local git read), recorded explicitly
+   * so merge-time identity checks are a pure comparison against the live
+   * pushed HEAD, not a re-derivation. See the ledger schema.
+   */
+  ledger: ManagedReadinessLedger;
+  /** Committed profile blob evaluated by readiness. Required for merge. */
+  profileBlobSha?: string;
+  /** Checkout-relative committed profile path evaluated by readiness. */
+  profilePath?: string;
+  repairs: ReadinessRepair[];
+  /** Trusted checkout repository used for all GitHub reads and writes. */
+  repository?: string;
+  status: ReadinessStatus;
+}
+//#endregion
+//#region src/pr-readiness/external-evidence.d.ts
+declare const evidenceEnvelopeBaseSchema: z.ZodObject<{
+  check: z.ZodString;
+  checkType: z.ZodEnum<{
+    review: "review";
+    verify: "verify";
+  }>;
+  findingsPointer: z.ZodOptional<z.ZodString>;
+  headSha: z.ZodString;
+  mergeBaseSha: z.ZodString;
+  model: z.ZodOptional<z.ZodString>;
+  outcome: z.ZodEnum<{
+    pass: "pass";
+    fail: "fail";
+  }>;
+  patchId: z.ZodString;
+  policyVersion: z.ZodOptional<z.ZodString>;
+  producer: z.ZodString;
+  requestId: z.ZodOptional<z.ZodString>;
+  rung: z.ZodOptional<z.ZodEnum<{
+    "independent-model": "independent-model";
+    oracle: "oracle";
+    human: "human";
+  }>>;
+  schemaVersion: z.ZodLiteral<1>;
+  sessionId: z.ZodOptional<z.ZodString>;
+  timestamp: z.ZodOptional<z.ZodISODateTime>;
+}, z.core.$loose>;
+type EvidenceEnvelope = z.infer<typeof evidenceEnvelopeBaseSchema>;
+//#endregion
+//#region src/pr-readiness/verification-proof.d.ts
+declare const SUPPORTED_PR_VERIFY_SCHEMA_VERSIONS$1: readonly [1, 2, 3, 4];
+type PrVerifySchemaVersion = (typeof SUPPORTED_PR_VERIFY_SCHEMA_VERSIONS$1)[number];
+interface PrVerifyCommandResult {
+  command: string;
+  description: string;
+  name: string;
+  scope: "always" | "docs-only" | "trivial" | "full";
+}
+interface PrVerifyExecutedCommand {
+  command: string;
+  counts?: {
+    testFiles?: number;
+    tests?: number;
+  };
+  durationMs: number;
+  exitCode: number;
+  name: string;
+  scope: "always" | "docs-only" | "trivial" | "full";
+}
+interface PrVerifyProof {
+  schemaVersion: PrVerifySchemaVersion;
+  authoringSession?: string;
+  base: string;
+  baselineFullProofs?: {
+    base: string;
+    changedFiles: string[];
+    headSha: string;
+    profilePath: string;
+    projectKey: string;
+    repository: string;
+  }[];
+  changedFiles: string[];
+  classification: DiffClassification;
+  classificationReasons: string[];
+  command: "patronage-factory pr:verify";
+  durationMs: number;
+  endedAt: string;
+  executedCommands?: PrVerifyExecutedCommand[];
+  headSha: string;
+  mode: ResolvedPrVerifyMode;
+  mergeBaseSha?: string;
+  outcome?: "aborted" | "passed";
+  patchId?: string;
+  profilePath: string;
+  projectKey: string;
+  repository: string;
+  startedAt: string;
+  verificationCommands: PrVerifyCommandResult[];
+}
+//#endregion
+//#region src/closeout-artifact.d.ts
+/** Strict, bounded runtime transport contract emitted by factory:closeout. */
+declare const closeoutArtifactSchema: z.ZodObject<{
+  boundaryThermo: z.ZodObject<{
+    owner: z.ZodString;
+    runs: z.ZodNumber;
+    waived: z.ZodBoolean;
+    waiverRationale: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>;
+  budget: z.ZodObject<{
+    interiorSourcesConsumed: z.ZodNumber;
+    note: z.ZodString;
+    scoping: z.ZodOptional<z.ZodObject<{
+      epic: z.ZodString;
+      issueFilter: z.ZodOptional<z.ZodNumber>;
+      prFilter: z.ZodOptional<z.ZodNumber>;
+      repo: z.ZodString;
+      scopedByEpicIssueSet: z.ZodBoolean;
+      window: z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+      }, z.core.$strict>;
+    }, z.core.$strict>>;
+    tier: z.ZodLiteral<"overseer">;
+  }, z.core.$strict>;
+  couldNotSee: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    note: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>>;
+  epic: z.ZodString;
+  generatedAt: z.ZodISODateTime;
+  ledgerRows: z.ZodArray<z.ZodObject<{
+    detail: z.ZodOptional<z.ZodString>;
+    epic: z.ZodString;
+    generatedAt: z.ZodISODateTime;
+    key: z.ZodString;
+    landingSpot: z.ZodOptional<z.ZodEnum<{
+      CLI: "CLI";
+      profile: "profile";
+      skill: "skill";
+      ADR: "ADR";
+    }>>;
+    repo: z.ZodString;
+    rowType: z.ZodEnum<{
+      metric: "metric";
+      lesson: "lesson";
+      blindspot: "blindspot";
+    }>;
+    schemaVersion: z.ZodLiteral<3>;
+    source: z.ZodString;
+    unit: z.ZodOptional<z.ZodString>;
+    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodNull]>;
+  }, z.core.$strict>>;
+  lessons: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    landingSpot: z.ZodEnum<{
+      CLI: "CLI";
+      profile: "profile";
+      skill: "skill";
+      ADR: "ADR";
+    }>;
+    lesson: z.ZodString;
+    rationale: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodObject<{
+      detail: z.ZodString;
+      kind: z.ZodEnum<{
+        "interior-telemetry": "interior-telemetry";
+        "boundary-thermo-attestation": "boundary-thermo-attestation";
+      }>;
+    }, z.core.$strict>>;
+  }, z.core.$strict>>;
+  metrics: z.ZodArray<z.ZodObject<{
+    label: z.ZodString;
+    metric: z.ZodString;
+    source: z.ZodObject<{
+      detail: z.ZodString;
+      kind: z.ZodEnum<{
+        "interior-telemetry": "interior-telemetry";
+        "boundary-thermo-attestation": "boundary-thermo-attestation";
+      }>;
+    }, z.core.$strict>;
+    unit: z.ZodEnum<{
+      boolean: "boolean";
+      text: "text";
+      tokens: "tokens";
+      usd: "usd";
+      count: "count";
+      ratio: "ratio";
+    }>;
+    value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>;
+  }, z.core.$strict>>;
+  repo: z.ZodString;
+  schemaVersion: z.ZodLiteral<3>;
+}, z.core.$strict>;
+type CloseoutArtifact = z.infer<typeof closeoutArtifactSchema>;
+//#endregion
+//#region src/schemas.d.ts
+declare const EVIDENCE_ENVELOPE_SCHEMA_VERSION = 1;
+declare const evidenceEnvelopeSchema: z.ZodObject<{
+  check: z.ZodString;
+  checkType: z.ZodEnum<{
+    review: "review";
+    verify: "verify";
+  }>;
+  findingsPointer: z.ZodOptional<z.ZodString>;
+  headSha: z.ZodString;
+  mergeBaseSha: z.ZodString;
+  model: z.ZodOptional<z.ZodString>;
+  outcome: z.ZodEnum<{
+    pass: "pass";
+    fail: "fail";
+  }>;
+  patchId: z.ZodString;
+  policyVersion: z.ZodOptional<z.ZodString>;
+  producer: z.ZodString;
+  requestId: z.ZodOptional<z.ZodString>;
+  rung: z.ZodOptional<z.ZodEnum<{
+    "independent-model": "independent-model";
+    oracle: "oracle";
+    human: "human";
+  }>>;
+  schemaVersion: z.ZodLiteral<1>;
+  sessionId: z.ZodOptional<z.ZodString>;
+  timestamp: z.ZodOptional<z.ZodISODateTime>;
+}, z.core.$loose>;
+declare const SUPPORTED_PR_VERIFY_SCHEMA_VERSIONS: readonly [1, 2, 3, 4];
+declare const prVerifyProofSchema: z.ZodObject<{
+  authoringSession: z.ZodOptional<z.ZodString>;
+  base: z.ZodString;
+  baselineFullProofs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    base: z.ZodString;
+    changedFiles: z.ZodArray<z.ZodString>;
+    headSha: z.ZodString;
+    profilePath: z.ZodString;
+    projectKey: z.ZodString;
+    repository: z.ZodString;
+  }, z.core.$strip>>>;
+  changedFiles: z.ZodArray<z.ZodString>;
+  classification: z.ZodEnum<{
+    "docs/process-only": "docs/process-only";
+    trivial: "trivial";
+    "non-trivial": "non-trivial";
+  }>;
+  classificationReasons: z.ZodArray<z.ZodString>;
+  command: z.ZodLiteral<"patronage-factory pr:verify">;
+  durationMs: z.ZodNumber;
+  endedAt: z.ZodISODateTime;
+  executedCommands: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    command: z.ZodString;
+    counts: z.ZodOptional<z.ZodObject<{
+      testFiles: z.ZodOptional<z.ZodNumber>;
+      tests: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    durationMs: z.ZodNumber;
+    exitCode: z.ZodNumber;
+    name: z.ZodString;
+    scope: z.ZodEnum<{
+      trivial: "trivial";
+      always: "always";
+      "docs-only": "docs-only";
+      full: "full";
+    }>;
+  }, z.core.$strip>>>;
+  headSha: z.ZodString;
+  mergeBaseSha: z.ZodOptional<z.ZodString>;
+  mode: z.ZodEnum<{
+    trivial: "trivial";
+    "docs-only": "docs-only";
+    full: "full";
+  }>;
+  outcome: z.ZodOptional<z.ZodEnum<{
+    aborted: "aborted";
+    passed: "passed";
+  }>>;
+  patchId: z.ZodOptional<z.ZodString>;
+  profilePath: z.ZodString;
+  projectKey: z.ZodString;
+  repository: z.ZodString;
+  schemaVersion: z.ZodNumber & z.ZodType<1 | 2 | 3 | 4, number, z.core.$ZodTypeInternals<1 | 2 | 3 | 4, number>>;
+  startedAt: z.ZodISODateTime;
+  verificationCommands: z.ZodArray<z.ZodObject<{
+    command: z.ZodString;
+    description: z.ZodString;
+    name: z.ZodString;
+    scope: z.ZodEnum<{
+      trivial: "trivial";
+      always: "always";
+      "docs-only": "docs-only";
+      full: "full";
+    }>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const PR_REVIEW_SCHEMA_VERSION = 2;
+declare const prReviewProofSchema: z.ZodObject<{
+  base: z.ZodString;
+  changedFiles: z.ZodArray<z.ZodString>;
+  cleanedPaths: z.ZodArray<z.ZodString>;
+  findingProvenanceVersion: z.ZodLiteral<1>;
+  headSha: z.ZodString;
+  ladder: z.ZodOptional<z.ZodObject<{
+    cycles: z.ZodArray<z.ZodObject<{
+      dispositions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        disposition: z.ZodEnum<{
+          "fixed-in-thread": "fixed-in-thread";
+          "follow-up-filed": "follow-up-filed";
+          waived: "waived";
+        }>;
+        finding: z.ZodObject<{
+          file: z.ZodOptional<z.ZodString>;
+          title: z.ZodString;
+        }, z.core.$strip>;
+        reference: z.ZodOptional<z.ZodString>;
+      }, z.core.$loose>>>;
+      findings: z.ZodArray<z.ZodObject<{
+        citedSpan: z.ZodOptional<z.ZodString>;
+        file: z.ZodOptional<z.ZodString>;
+        prescribedAction: z.ZodOptional<z.ZodString>;
+        supersedes: z.ZodOptional<z.ZodObject<{
+          file: z.ZodOptional<z.ZodString>;
+          title: z.ZodString;
+        }, z.core.$strip>>;
+        title: z.ZodString;
+      }, z.core.$loose>>;
+    }, z.core.$loose>>;
+  }, z.core.$strip>>;
+  maxReviewCycles: z.ZodOptional<z.ZodNumber>;
+  patchId: z.ZodString;
+  reviewCycle: z.ZodOptional<z.ZodNumber>;
+  reviewRequirement: z.ZodOptional<z.ZodObject<{
+    reason: z.ZodLiteral<"docs-only-profile-bypass">;
+    status: z.ZodLiteral<"not-required">;
+  }, z.core.$strict>>;
+  reviews: z.ZodArray<z.ZodObject<{
+    command: z.ZodOptional<z.ZodString>;
+    durationMs: z.ZodNumber;
+    endedAt: z.ZodString;
+    exitCode: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    findings: z.ZodArray<z.ZodObject<{
+      blockingAfterCap: z.ZodOptional<z.ZodBoolean>;
+      body: z.ZodString;
+      category: z.ZodOptional<z.ZodEnum<{
+        unknown: "unknown";
+        correctness: "correctness";
+        safety: "safety";
+        coordination: "coordination";
+        maintainability: "maintainability";
+      }>>;
+      citedSpan: z.ZodOptional<z.ZodString>;
+      file: z.ZodOptional<z.ZodString>;
+      line: z.ZodOptional<z.ZodNumber>;
+      prescribedAction: z.ZodOptional<z.ZodString>;
+      priority: z.ZodOptional<z.ZodString>;
+      protocolFinding: z.ZodOptional<z.ZodLiteral<true>>;
+      supersedes: z.ZodOptional<z.ZodObject<{
+        file: z.ZodOptional<z.ZodString>;
+        title: z.ZodString;
+      }, z.core.$strip>>;
+      title: z.ZodString;
+    }, z.core.$strip>>;
+    issuesFlagged: z.ZodNumber;
+    kind: z.ZodEnum<{
+      correctness: "correctness";
+      security: "security";
+    }>;
+    model: z.ZodOptional<z.ZodString>;
+    outcome: z.ZodEnum<{
+      error: "error";
+      passed: "passed";
+      failed: "failed";
+    }>;
+    producer: z.ZodOptional<z.ZodString>;
+    promptSections: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      provenance: z.ZodEnum<{
+        "prior-review-ledger": "prior-review-ledger";
+        "profile-standing-checklist": "profile-standing-checklist";
+        "issue-review-focus": "issue-review-focus";
+      }>;
+      source: z.ZodString;
+      text: z.ZodString;
+    }, z.core.$strict>>>;
+    rung: z.ZodOptional<z.ZodEnum<{
+      "independent-model": "independent-model";
+      oracle: "oracle";
+      human: "human";
+    }>>;
+    sessionId: z.ZodOptional<z.ZodString>;
+    stageResolution: z.ZodOptional<z.ZodObject<{
+      effort: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        xhigh: "xhigh";
+      }>>;
+      engine: z.ZodString;
+      layerSource: z.ZodEnum<{
+        cli: "cli";
+        operatorSessionGlobal: "operatorSessionGlobal";
+        operatorSessionKind: "operatorSessionKind";
+        profilePin: "profilePin";
+        stageConfig: "stageConfig";
+        userConfig: "userConfig";
+      }>;
+      model: z.ZodString;
+      rung: z.ZodOptional<z.ZodEnum<{
+        oracle: "oracle";
+        independentModel: "independentModel";
+      }>>;
+    }, z.core.$strip>>;
+    startedAt: z.ZodString;
+    summary: z.ZodString;
+    typedVerdict: z.ZodOptional<z.ZodBoolean>;
+    verdictSource: z.ZodOptional<z.ZodEnum<{
+      footer: "footer";
+      recovered: "recovered";
+    }>>;
+  }, z.core.$strip>>;
+  schemaVersion: z.ZodLiteral<2>;
+}, z.core.$loose>;
+declare const BOUNDARY_REVIEW_PROOF_KIND = "boundary-review-proof";
+declare const boundaryReviewProofSchema: z.ZodObject<{
+  boundary: z.ZodString;
+  coveredSet: z.ZodArray<z.ZodObject<{
+    headSha: z.ZodOptional<z.ZodString>;
+    issue: z.ZodOptional<z.ZodNumber>;
+    mergedSha: z.ZodOptional<z.ZodString>;
+    pr: z.ZodNumber;
+    state: z.ZodEnum<{
+      merged: "merged";
+      open: "open";
+    }>;
+    wave: z.ZodOptional<z.ZodString>;
+  }, z.core.$loose>>;
+  dispositions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+  findings: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    blockingAfterCap: z.ZodOptional<z.ZodBoolean>;
+    category: z.ZodOptional<z.ZodString>;
+    disposition: z.ZodOptional<z.ZodString>;
+    title: z.ZodString;
+  }, z.core.$loose>>>;
+  kind: z.ZodLiteral<"boundary-review-proof">;
+  manifestHash: z.ZodObject<{
+    algo: z.ZodLiteral<"sha256">;
+    scope: z.ZodOptional<z.ZodString>;
+    value: z.ZodString;
+  }, z.core.$loose>;
+  outcome: z.ZodEnum<{
+    pass: "pass";
+    fail: "fail";
+  }>;
+  producer: z.ZodString;
+  rung: z.ZodEnum<{
+    "independent-model": "independent-model";
+    oracle: "oracle";
+    human: "human";
+  }>;
+  schemaVersion: z.ZodLiteral<1>;
+  sessionId: z.ZodOptional<z.ZodString>;
+  specHash: z.ZodOptional<z.ZodObject<{
+    algo: z.ZodLiteral<"sha256">;
+    scope: z.ZodOptional<z.ZodString>;
+    value: z.ZodString;
+  }, z.core.$loose>>;
+}, z.core.$loose>;
+declare const BOUNDARY_CHECK_SCHEMA_VERSION = 1;
+declare const boundaryCheckProofSchema: z.ZodObject<{
+  blockingReasons: z.ZodArray<z.ZodString>;
+  boundary: z.ZodOptional<z.ZodString>;
+  command: z.ZodLiteral<"patronage-factory boundary:check">;
+  coveredSet: z.ZodArray<z.ZodObject<{
+    issue: z.ZodOptional<z.ZodNumber>;
+    pr: z.ZodNumber;
+    sha: z.ZodString;
+    state: z.ZodEnum<{
+      merged: "merged";
+      open: "open";
+    }>;
+    wave: z.ZodString;
+  }, z.core.$strip>>;
+  demandedRung: z.ZodOptional<z.ZodEnum<{
+    "independent-model": "independent-model";
+    oracle: "oracle";
+    human: "human";
+  }>>;
+  epicIssue: z.ZodNumber;
+  manifestHash: z.ZodOptional<z.ZodObject<{
+    algo: z.ZodLiteral<"sha256">;
+    value: z.ZodString;
+  }, z.core.$strip>>;
+  notices: z.ZodArray<z.ZodString>;
+  repo: z.ZodString;
+  reviewProof: z.ZodOptional<z.ZodObject<{
+    commentId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    commentUrl: z.ZodOptional<z.ZodString>;
+    producer: z.ZodString;
+    rung: z.ZodEnum<{
+      "independent-model": "independent-model";
+      oracle: "oracle";
+      human: "human";
+    }>;
+    sessionId: z.ZodOptional<z.ZodString>;
+    specHash: z.ZodOptional<z.ZodObject<{
+      algo: z.ZodLiteral<"sha256">;
+      scope: z.ZodOptional<z.ZodString>;
+      value: z.ZodString;
+    }, z.core.$loose>>;
+  }, z.core.$strip>>;
+  schemaVersion: z.ZodLiteral<1>;
+  specHash: z.ZodOptional<z.ZodObject<{
+    algo: z.ZodLiteral<"sha256">;
+    value: z.ZodString;
+  }, z.core.$strip>>;
+  status: z.ZodEnum<{
+    ready: "ready";
+    blocked: "blocked";
+  }>;
+}, 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";
+  }>;
+  worktreeHeldBranch: z.ZodOptional<z.ZodObject<{
+    branch: z.ZodString;
+    worktreePath: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const PR_READY_SCHEMA_VERSION = 1;
+declare const prReadyProofSchema: z.ZodObject<{
+  blockingReasons: z.ZodArray<z.ZodString>;
+  command: z.ZodLiteral<"patronage-factory pr:ready">;
+  followUp: z.ZodOptional<z.ZodObject<{
+    argv: z.ZodArray<z.ZodString>;
+    command: z.ZodString;
+  }, z.core.$strict>>;
+  humanBlockingReasons: z.ZodDefault<z.ZodArray<z.ZodString>>;
+  ledger: z.ZodObject<{
+    baseSha: z.ZodString;
+    blockingReasons: z.ZodArray<z.ZodString>;
+    classification: z.ZodEnum<{
+      "docs/process-only": "docs/process-only";
+      trivial: "trivial";
+      "non-trivial": "non-trivial";
+    }>;
+    externalChecks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      checkType: z.ZodEnum<{
+        review: "review";
+        verify: "verify";
+      }>;
+      inScope: z.ZodBoolean;
+      name: z.ZodString;
+      reason: z.ZodOptional<z.ZodString>;
+      scope: z.ZodOptional<z.ZodObject<{
+        classifications: z.ZodOptional<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<{
+        satisfied: "satisfied";
+        unmet: "unmet";
+        "out-of-scope": "out-of-scope";
+      }>;
+    }, z.core.$strip>>>;
+    finalReviewPoint: z.ZodBoolean;
+    github: z.ZodObject<{
+      currentWithBase: z.ZodBoolean;
+      draft: z.ZodBoolean;
+      mergeStateStatus: z.ZodString;
+      mergeable: z.ZodString;
+      requiredChecks: z.ZodEnum<{
+        unknown: "unknown";
+        passed: "passed";
+        failed: "failed";
+        pending: "pending";
+        none: "none";
+      }>;
+      unresolvedReviewThreads: z.ZodNumber;
+    }, z.core.$strip>;
+    handledCommentsProducer: z.ZodOptional<z.ZodObject<{
+      identity: z.ZodString;
+      mode: z.ZodEnum<{
+        app: "app";
+        "commit-status": "commit-status";
+      }>;
+    }, z.core.$strip>>;
+    handledHumanComments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      clearedAt: z.ZodOptional<z.ZodString>;
+      sessionId: z.ZodOptional<z.ZodString>;
+      source: z.ZodEnum<{
+        cli: "cli";
+        "check-run": "check-run";
+      }>;
+      url: z.ZodString;
+    }, z.core.$strip>>>;
+    headSha: z.ZodString;
+    mergeBaseSha: z.ZodOptional<z.ZodString>;
+    patchId: z.ZodString;
+    postReadinessHumanComments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      author: z.ZodString;
+      createdAt: z.ZodString;
+      summary: z.ZodString;
+      url: z.ZodString;
+    }, z.core.$strip>>>;
+    pr: z.ZodNumber;
+    previewDeploy: z.ZodOptional<z.ZodObject<{
+      adminUrl: z.ZodOptional<z.ZodString>;
+      apiHealthUrl: z.ZodOptional<z.ZodString>;
+      headSha: z.ZodOptional<z.ZodString>;
+      localPreviewProof: z.ZodOptional<z.ZodUnknown>;
+      localProofPath: z.ZodOptional<z.ZodString>;
+      proofSource: z.ZodOptional<z.ZodEnum<{
+        "github-actions": "github-actions";
+        "local-self-certified": "local-self-certified";
+      }>>;
+      publicUrl: z.ZodOptional<z.ZodString>;
+      seedStatus: z.ZodEnum<{
+        unknown: "unknown";
+        passed: "passed";
+        failed: "failed";
+        skipped: "skipped";
+      }>;
+      stage: z.ZodOptional<z.ZodString>;
+      timingsMs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodOptional<z.ZodNumber>>>;
+      workflowRunUrl: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    previewDeployRequired: z.ZodBoolean;
+    repairs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+      action: z.ZodString;
+      code: z.ZodEnum<{
+        "undraft-pr": "undraft-pr";
+        "render-pr-body-sections": "render-pr-body-sections";
+        "await-post-undraft-checks": "await-post-undraft-checks";
+      }>;
+      command: z.ZodString;
+    }, z.core.$strip>>>;
+    reviewCycleState: z.ZodOptional<z.ZodObject<{
+      autoBlockingFindings: z.ZodNumber;
+      countsBySeverity: z.ZodObject<{
+        critical: z.ZodNumber;
+        high: z.ZodNumber;
+        low: z.ZodNumber;
+        medium: z.ZodNumber;
+        unknown: z.ZodNumber;
+      }, z.core.$strip>;
+      highestBlockingSeverity: z.ZodOptional<z.ZodEnum<{
+        unknown: "unknown";
+        low: "low";
+        medium: "medium";
+        high: "high";
+        critical: "critical";
+      }>>;
+      highestOpenSeverity: z.ZodOptional<z.ZodEnum<{
+        unknown: "unknown";
+        low: "low";
+        medium: "medium";
+        high: "high";
+        critical: "critical";
+      }>>;
+      maxReviewCycles: z.ZodOptional<z.ZodNumber>;
+      nonBlockingFindings: z.ZodNumber;
+      openFindings: z.ZodNumber;
+      reviewCycle: z.ZodOptional<z.ZodNumber>;
+      staleRepeatFindings: z.ZodOptional<z.ZodNumber>;
+      windowExhausted: z.ZodBoolean;
+    }, z.core.$strip>>;
+    reviewLadder: z.ZodOptional<z.ZodObject<{
+      cycleCounts: z.ZodObject<{
+        gate: z.ZodNumber;
+        interior: z.ZodNumber;
+      }, z.core.$strip>;
+      forcedTransition: z.ZodOptional<z.ZodEnum<{
+        "gate-cap-exhausted": "gate-cap-exhausted";
+        "interior-cap-reached": "interior-cap-reached";
+        "interior-takeover": "interior-takeover";
+      }>>;
+      nextAction: z.ZodEnum<{
+        "run-interior-cycle": "run-interior-cycle";
+        "advance-to-gate": "advance-to-gate";
+        "run-gate-cycle": "run-gate-cycle";
+        "accept-nonblocking-findings": "accept-nonblocking-findings";
+        "escalate-to-triage": "escalate-to-triage";
+        "ready-for-human": "ready-for-human";
+      }>;
+      stage: z.ZodEnum<{
+        gate: "gate";
+        interior: "interior";
+        "interior-takeover": "interior-takeover";
+        "interior-complete": "interior-complete";
+      }>;
+    }, z.core.$strip>>;
+    reviewRuns: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      command: z.ZodOptional<z.ZodString>;
+      durationMs: z.ZodNumber;
+      endedAt: z.ZodString;
+      exitCode: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+      findings: z.ZodArray<z.ZodObject<{
+        blockingAfterCap: z.ZodOptional<z.ZodBoolean>;
+        body: z.ZodString;
+        category: z.ZodOptional<z.ZodEnum<{
+          unknown: "unknown";
+          correctness: "correctness";
+          safety: "safety";
+          coordination: "coordination";
+          maintainability: "maintainability";
+        }>>;
+        citedSpan: z.ZodOptional<z.ZodString>;
+        file: z.ZodOptional<z.ZodString>;
+        line: z.ZodOptional<z.ZodNumber>;
+        prescribedAction: z.ZodOptional<z.ZodString>;
+        priority: z.ZodOptional<z.ZodString>;
+        protocolFinding: z.ZodOptional<z.ZodLiteral<true>>;
+        supersedes: z.ZodOptional<z.ZodObject<{
+          file: z.ZodOptional<z.ZodString>;
+          title: z.ZodString;
+        }, z.core.$strip>>;
+        title: z.ZodString;
+      }, z.core.$strip>>;
+      issuesFlagged: z.ZodNumber;
+      kind: z.ZodEnum<{
+        correctness: "correctness";
+        security: "security";
+      }>;
+      model: z.ZodOptional<z.ZodString>;
+      outcome: z.ZodEnum<{
+        error: "error";
+        passed: "passed";
+        failed: "failed";
+      }>;
+      producer: z.ZodOptional<z.ZodString>;
+      promptSections: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        provenance: z.ZodEnum<{
+          "prior-review-ledger": "prior-review-ledger";
+          "profile-standing-checklist": "profile-standing-checklist";
+          "issue-review-focus": "issue-review-focus";
+        }>;
+        source: z.ZodString;
+        text: z.ZodString;
+      }, z.core.$strict>>>;
+      rung: z.ZodOptional<z.ZodEnum<{
+        "independent-model": "independent-model";
+        oracle: "oracle";
+        human: "human";
+      }>>;
+      sessionId: z.ZodOptional<z.ZodString>;
+      stageResolution: z.ZodOptional<z.ZodObject<{
+        effort: z.ZodOptional<z.ZodEnum<{
+          low: "low";
+          medium: "medium";
+          high: "high";
+          xhigh: "xhigh";
+        }>>;
+        engine: z.ZodString;
+        layerSource: z.ZodEnum<{
+          cli: "cli";
+          operatorSessionGlobal: "operatorSessionGlobal";
+          operatorSessionKind: "operatorSessionKind";
+          profilePin: "profilePin";
+          stageConfig: "stageConfig";
+          userConfig: "userConfig";
+        }>;
+        model: z.ZodString;
+        rung: z.ZodOptional<z.ZodEnum<{
+          oracle: "oracle";
+          independentModel: "independentModel";
+        }>>;
+      }, z.core.$strip>>;
+      startedAt: z.ZodString;
+      summary: z.ZodString;
+      typedVerdict: z.ZodOptional<z.ZodBoolean>;
+      verdictSource: z.ZodOptional<z.ZodEnum<{
+        footer: "footer";
+        recovered: "recovered";
+      }>>;
+    }, z.core.$strip>>>;
+    reviewTerminalState: z.ZodOptional<z.ZodEnum<{
+      blocked: "blocked";
+      "accepted-with-findings": "accepted-with-findings";
+      clean: "clean";
+    }>>;
+    reviews: z.ZodObject<{
+      correctness: z.ZodObject<{
+        docsOnlyDeltaAccepted: z.ZodOptional<z.ZodBoolean>;
+        required: z.ZodBoolean;
+        reviewedHeadSha: z.ZodOptional<z.ZodString>;
+        reviewedPatchId: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+          "not-required": "not-required";
+          blocked: "blocked";
+          current: "current";
+          stale: "stale";
+          missing: "missing";
+        }>;
+      }, z.core.$strip>;
+      security: z.ZodOptional<z.ZodObject<{
+        docsOnlyDeltaAccepted: z.ZodOptional<z.ZodBoolean>;
+        required: z.ZodBoolean;
+        reviewedHeadSha: z.ZodOptional<z.ZodString>;
+        reviewedPatchId: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+          "not-required": "not-required";
+          blocked: "blocked";
+          current: "current";
+          stale: "stale";
+          missing: "missing";
+        }>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+    schemaVersion: z.ZodLiteral<1>;
+    stackRole: z.ZodEnum<{
+      single: "single";
+      slice: "slice";
+      rollup: "rollup";
+      "merge-gate prerequisite": "merge-gate prerequisite";
+    }>;
+    verification: z.ZodObject<{
+      command: z.ZodLiteral<"patronage-factory pr:verify">;
+      docsOnlyDeltaAccepted: z.ZodOptional<z.ZodBoolean>;
+      docsOnlyVerifiedHeadSha: z.ZodOptional<z.ZodString>;
+      prVerify: z.ZodEnum<{
+        passed: "passed";
+        stale: "stale";
+        missing: "missing";
+      }>;
+      trivialDeltaAccepted: z.ZodOptional<z.ZodBoolean>;
+      trivialVerifiedHeadSha: z.ZodOptional<z.ZodString>;
+      verifiedHeadSha: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+  }, z.core.$strip>;
+  profileBlobSha: z.ZodOptional<z.ZodString>;
+  profilePath: z.ZodOptional<z.ZodString>;
+  repairs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    action: z.ZodString;
+    code: z.ZodEnum<{
+      "undraft-pr": "undraft-pr";
+      "render-pr-body-sections": "render-pr-body-sections";
+      "await-post-undraft-checks": "await-post-undraft-checks";
+    }>;
+    command: z.ZodString;
+  }, z.core.$strip>>>;
+  repository: z.ZodOptional<z.ZodString>;
+  schemaVersion: z.ZodLiteral<1>;
+  status: z.ZodEnum<{
+    ready: "ready";
+    blocked: "blocked";
+    "slice-ready/not-final": "slice-ready/not-final";
+  }>;
+}, 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 PrMergeCheckProof, type PrReadyProof, type PrReviewProof, type PrVerifyProof, SUPPORTED_PR_VERIFY_SCHEMA_VERSIONS, boundaryCheckProofSchema, boundaryReviewProofSchema, closeoutArtifactSchema, evidenceEnvelopeSchema, prMergeCheckProofSchema, prReadyProofSchema, prReviewProofSchema, prVerifyProofSchema };