npm - @knpkv/control-center - Versions diffs - 0.1.0 - Mend

@knpkv/control-center 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (664) hide show

package/dist/server/server/persistence/repositories/readiness/assessments.d.ts ADDED Viewed

@@ -0,0 +1,2679 @@
+import * as DateTime from "effect/DateTime";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { type WorkspaceId } from "../../../../domain/identifiers.js";
+import { Database } from "../../Database.js";
+import type { ReadCurrentReadinessAssessmentRequest, ReadReadinessHistoryRequest } from "./contract.js";
+export declare const makeReadinessAssessments: Effect.Effect<{
+    commitEnvironment: (request: Schema.Struct.ReadonlySide<{
+        readonly expectedHeadRevision: Schema.NullOr<Schema.brand<Schema.Int, "ReadinessHeadRevision">>;
+        readonly invalidation: Schema.NullOr<Schema.Struct<{
+            readonly invalidationRevision: Schema.brand<Schema.Int, "ReadinessInvalidationRevision">;
+            readonly leaseOwner: Schema.brand<Schema.String, "ReadinessLeaseOwner">;
+            readonly leaseToken: Schema.brand<Schema.String, "ReadinessLeaseToken">;
+        }>>;
+        readonly assessment: Schema.Struct<{
+            readonly _tag: Schema.Literal<"environment">;
+            readonly candidate: Schema.Struct<{
+                readonly scope: Schema.TaggedStruct<"environment", {
+                    readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                    readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+                }>;
+                readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                readonly releaseRevision: Schema.Int;
+                readonly artifactRevision: Schema.String;
+                readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+            }>;
+            readonly inputComplete: Schema.Boolean;
+            readonly facts: Schema.$Array<Schema.Struct<{
+                readonly definition: Schema.Struct<{
+                    readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    readonly kind: Schema.Literals<readonly ["relationship", "approval", "check", "execution", "documentation", "deployment"]>;
+                    readonly requirement: Schema.Literals<readonly ["required", "advisory"]>;
+                }>;
+                readonly observation: Schema.NullOr<Schema.Struct<{
+                    readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    readonly state: Schema.TaggedUnion<{
+                        readonly relationship: Schema.TaggedStruct<"relationship", {
+                            readonly status: Schema.Literals<readonly ["missing", "inferred", "proposed", "verified", "governed", "rejected", "superseded"]>;
+                        }>;
+                        readonly approval: Schema.TaggedStruct<"approval", {
+                            readonly status: Schema.Literals<readonly ["missing", "pending", "approved", "rejected", "expired"]>;
+                        }>;
+                        readonly check: Schema.TaggedStruct<"check", {
+                            readonly status: Schema.Literals<readonly ["missing", "queued", "running", "passed", "failed", "cancelled"]>;
+                        }>;
+                        readonly execution: Schema.TaggedStruct<"execution", {
+                            readonly status: Schema.Literals<readonly ["missing", "queued", "running", "succeeded", "failed", "stopped"]>;
+                            readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                                readonly _tag: Schema.tag<"count">;
+                                readonly completed: Schema.Int;
+                                readonly total: Schema.Int;
+                            }>, Schema.TaggedStruct<"percent", {
+                                readonly value: Schema.Number;
+                            }>]>>;
+                        }>;
+                        readonly documentation: Schema.TaggedStruct<"documentation", {
+                            readonly status: Schema.Literals<readonly ["missing", "draft", "current", "stale", "superseded"]>;
+                        }>;
+                        readonly deployment: Schema.TaggedStruct<"deployment", {
+                            readonly status: Schema.Literals<readonly ["not-started", "pending", "deploying", "succeeded", "failed", "rolled-back"]>;
+                            readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                                readonly _tag: Schema.tag<"count">;
+                                readonly completed: Schema.Int;
+                                readonly total: Schema.Int;
+                            }>, Schema.TaggedStruct<"percent", {
+                                readonly value: Schema.Number;
+                            }>]>>;
+                        }>;
+                    }>;
+                    readonly evidence: Schema.$Array<Schema.Struct<{
+                        readonly evidenceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">;
+                        readonly source: Schema.TaggedUnion<{
+                            readonly plugin: Schema.TaggedStruct<"plugin", {
+                                readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                                readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                            }>;
+                            readonly local: Schema.TaggedStruct<"local", {
+                                readonly origin: Schema.Literals<readonly ["human", "agent", "system"]>;
+                            }>;
+                        }>;
+                        readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                        readonly validity: Schema.Literals<readonly ["valid", "expired"]>;
+                        readonly reevaluateAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                    }>>;
+                }>>;
+                readonly result: Schema.Literals<readonly ["verified", "pending", "failed", "gap", "advisory"]>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly requiredFactIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+            readonly verifiedFactIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+            readonly assessmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">;
+            readonly previousAssessmentId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">>;
+            readonly rule: Schema.Struct<{
+                readonly ruleId: Schema.String;
+                readonly version: Schema.brand<Schema.Int, "ReadinessRuleVersion">;
+                readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+            }>;
+            readonly derivationVersion: Schema.brand<Schema.Int, "ReadinessDerivationVersion">;
+            readonly evaluatedAt: Schema.DateTimeUtcFromString;
+            readonly nextEvaluationAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+            readonly verdict: Schema.Literals<readonly ["blocked", "ready", "deploying", "building", "shipped", "held"]>;
+            readonly stages: Schema.Struct<{
+                readonly build: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["not-started", "queued", "running", "succeeded", "failed", "held"]>;
+                    readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"count">;
+                        readonly completed: Schema.Int;
+                        readonly total: Schema.Int;
+                    }>, Schema.TaggedStruct<"percent", {
+                        readonly value: Schema.Number;
+                    }>]>>;
+                }>;
+                readonly verify: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["not-started", "pending", "passed", "failed", "held"]>;
+                    readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"count">;
+                        readonly completed: Schema.Int;
+                        readonly total: Schema.Int;
+                    }>, Schema.TaggedStruct<"percent", {
+                        readonly value: Schema.Number;
+                    }>]>>;
+                }>;
+                readonly production: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["not-started", "waiting", "deploying", "succeeded", "failed", "rolled-back", "held"]>;
+                    readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"count">;
+                        readonly completed: Schema.Int;
+                        readonly total: Schema.Int;
+                    }>, Schema.TaggedStruct<"percent", {
+                        readonly value: Schema.Number;
+                    }>]>>;
+                }>;
+            }>;
+            readonly blockers: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                readonly subject: Schema.TaggedUnion<{
+                    readonly source: Schema.TaggedStruct<"source", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly fact: Schema.TaggedStruct<"fact", {
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    }>;
+                    readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                }>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly warnings: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                readonly subject: Schema.TaggedUnion<{
+                    readonly source: Schema.TaggedStruct<"source", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly fact: Schema.TaggedStruct<"fact", {
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    }>;
+                    readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                }>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly gaps: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                readonly subject: Schema.TaggedUnion<{
+                    readonly source: Schema.TaggedStruct<"source", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly fact: Schema.TaggedStruct<"fact", {
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    }>;
+                    readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                }>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly sourceFreshness: Schema.$Array<Schema.Struct<{
+                readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+        }>;
+    }, "Type">) => Effect.Effect<{
+        assessment: Schema.Struct.ReadonlySide<{
+            readonly _tag: Schema.Literal<"environment">;
+            readonly candidate: Schema.Struct<{
+                readonly scope: Schema.TaggedStruct<"environment", {
+                    readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                    readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+                }>;
+                readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                readonly releaseRevision: Schema.Int;
+                readonly artifactRevision: Schema.String;
+                readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+            }>;
+            readonly inputComplete: Schema.Boolean;
+            readonly facts: Schema.$Array<Schema.Struct<{
+                readonly definition: Schema.Struct<{
+                    readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    readonly kind: Schema.Literals<readonly ["relationship", "approval", "check", "execution", "documentation", "deployment"]>;
+                    readonly requirement: Schema.Literals<readonly ["required", "advisory"]>;
+                }>;
+                readonly observation: Schema.NullOr<Schema.Struct<{
+                    readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    readonly state: Schema.TaggedUnion<{
+                        readonly relationship: Schema.TaggedStruct<"relationship", {
+                            readonly status: Schema.Literals<readonly ["missing", "inferred", "proposed", "verified", "governed", "rejected", "superseded"]>;
+                        }>;
+                        readonly approval: Schema.TaggedStruct<"approval", {
+                            readonly status: Schema.Literals<readonly ["missing", "pending", "approved", "rejected", "expired"]>;
+                        }>;
+                        readonly check: Schema.TaggedStruct<"check", {
+                            readonly status: Schema.Literals<readonly ["missing", "queued", "running", "passed", "failed", "cancelled"]>;
+                        }>;
+                        readonly execution: Schema.TaggedStruct<"execution", {
+                            readonly status: Schema.Literals<readonly ["missing", "queued", "running", "succeeded", "failed", "stopped"]>;
+                            readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                                readonly _tag: Schema.tag<"count">;
+                                readonly completed: Schema.Int;
+                                readonly total: Schema.Int;
+                            }>, Schema.TaggedStruct<"percent", {
+                                readonly value: Schema.Number;
+                            }>]>>;
+                        }>;
+                        readonly documentation: Schema.TaggedStruct<"documentation", {
+                            readonly status: Schema.Literals<readonly ["missing", "draft", "current", "stale", "superseded"]>;
+                        }>;
+                        readonly deployment: Schema.TaggedStruct<"deployment", {
+                            readonly status: Schema.Literals<readonly ["not-started", "pending", "deploying", "succeeded", "failed", "rolled-back"]>;
+                            readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                                readonly _tag: Schema.tag<"count">;
+                                readonly completed: Schema.Int;
+                                readonly total: Schema.Int;
+                            }>, Schema.TaggedStruct<"percent", {
+                                readonly value: Schema.Number;
+                            }>]>>;
+                        }>;
+                    }>;
+                    readonly evidence: Schema.$Array<Schema.Struct<{
+                        readonly evidenceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">;
+                        readonly source: Schema.TaggedUnion<{
+                            readonly plugin: Schema.TaggedStruct<"plugin", {
+                                readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                                readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                            }>;
+                            readonly local: Schema.TaggedStruct<"local", {
+                                readonly origin: Schema.Literals<readonly ["human", "agent", "system"]>;
+                            }>;
+                        }>;
+                        readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                        readonly validity: Schema.Literals<readonly ["valid", "expired"]>;
+                        readonly reevaluateAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                    }>>;
+                }>>;
+                readonly result: Schema.Literals<readonly ["verified", "pending", "failed", "gap", "advisory"]>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly requiredFactIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+            readonly verifiedFactIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+            readonly assessmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">;
+            readonly previousAssessmentId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">>;
+            readonly rule: Schema.Struct<{
+                readonly ruleId: Schema.String;
+                readonly version: Schema.brand<Schema.Int, "ReadinessRuleVersion">;
+                readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+            }>;
+            readonly derivationVersion: Schema.brand<Schema.Int, "ReadinessDerivationVersion">;
+            readonly evaluatedAt: Schema.DateTimeUtcFromString;
+            readonly nextEvaluationAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+            readonly verdict: Schema.Literals<readonly ["blocked", "ready", "deploying", "building", "shipped", "held"]>;
+            readonly stages: Schema.Struct<{
+                readonly build: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["not-started", "queued", "running", "succeeded", "failed", "held"]>;
+                    readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"count">;
+                        readonly completed: Schema.Int;
+                        readonly total: Schema.Int;
+                    }>, Schema.TaggedStruct<"percent", {
+                        readonly value: Schema.Number;
+                    }>]>>;
+                }>;
+                readonly verify: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["not-started", "pending", "passed", "failed", "held"]>;
+                    readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"count">;
+                        readonly completed: Schema.Int;
+                        readonly total: Schema.Int;
+                    }>, Schema.TaggedStruct<"percent", {
+                        readonly value: Schema.Number;
+                    }>]>>;
+                }>;
+                readonly production: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["not-started", "waiting", "deploying", "succeeded", "failed", "rolled-back", "held"]>;
+                    readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"count">;
+                        readonly completed: Schema.Int;
+                        readonly total: Schema.Int;
+                    }>, Schema.TaggedStruct<"percent", {
+                        readonly value: Schema.Number;
+                    }>]>>;
+                }>;
+            }>;
+            readonly blockers: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                readonly subject: Schema.TaggedUnion<{
+                    readonly source: Schema.TaggedStruct<"source", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly fact: Schema.TaggedStruct<"fact", {
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    }>;
+                    readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                }>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly warnings: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                readonly subject: Schema.TaggedUnion<{
+                    readonly source: Schema.TaggedStruct<"source", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly fact: Schema.TaggedStruct<"fact", {
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    }>;
+                    readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                }>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly gaps: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                readonly subject: Schema.TaggedUnion<{
+                    readonly source: Schema.TaggedStruct<"source", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly fact: Schema.TaggedStruct<"fact", {
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    }>;
+                    readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                }>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly sourceFreshness: Schema.$Array<Schema.Struct<{
+                readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+        }, "Type">;
+        headRevision: number & import("effect/Brand").Brand<"ReadinessHeadRevision">;
+        committedAt: DateTime.Utc;
+    }, unknown, import("effect/Crypto").Crypto>;
+    commitRelease: (request: Schema.Struct.ReadonlySide<{
+        readonly expectedHeadRevision: Schema.NullOr<Schema.brand<Schema.Int, "ReadinessHeadRevision">>;
+        readonly invalidation: Schema.NullOr<Schema.Struct<{
+            readonly invalidationRevision: Schema.brand<Schema.Int, "ReadinessInvalidationRevision">;
+            readonly leaseOwner: Schema.brand<Schema.String, "ReadinessLeaseOwner">;
+            readonly leaseToken: Schema.brand<Schema.String, "ReadinessLeaseToken">;
+        }>>;
+        readonly assessment: Schema.Struct<{
+            readonly _tag: Schema.Literal<"release">;
+            readonly candidate: Schema.Struct<{
+                readonly scope: Schema.TaggedStruct<"release", {
+                    readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                }>;
+                readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                readonly releaseRevision: Schema.Int;
+                readonly artifactRevision: Schema.String;
+                readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+            }>;
+            readonly environments: Schema.NonEmptyArray<Schema.Struct<{
+                readonly assessmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">;
+                readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+                readonly candidateDigest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+                readonly inputComplete: Schema.Boolean;
+                readonly facts: Schema.$Array<Schema.Struct<{
+                    readonly definition: Schema.Struct<{
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        readonly kind: Schema.Literals<readonly ["relationship", "approval", "check", "execution", "documentation", "deployment"]>;
+                        readonly requirement: Schema.Literals<readonly ["required", "advisory"]>;
+                    }>;
+                    readonly observation: Schema.NullOr<Schema.Struct<{
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        readonly state: Schema.TaggedUnion<{
+                            readonly relationship: Schema.TaggedStruct<"relationship", {
+                                readonly status: Schema.Literals<readonly ["missing", "inferred", "proposed", "verified", "governed", "rejected", "superseded"]>;
+                            }>;
+                            readonly approval: Schema.TaggedStruct<"approval", {
+                                readonly status: Schema.Literals<readonly ["missing", "pending", "approved", "rejected", "expired"]>;
+                            }>;
+                            readonly check: Schema.TaggedStruct<"check", {
+                                readonly status: Schema.Literals<readonly ["missing", "queued", "running", "passed", "failed", "cancelled"]>;
+                            }>;
+                            readonly execution: Schema.TaggedStruct<"execution", {
+                                readonly status: Schema.Literals<readonly ["missing", "queued", "running", "succeeded", "failed", "stopped"]>;
+                                readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                                    readonly _tag: Schema.tag<"count">;
+                                    readonly completed: Schema.Int;
+                                    readonly total: Schema.Int;
+                                }>, Schema.TaggedStruct<"percent", {
+                                    readonly value: Schema.Number;
+                                }>]>>;
+                            }>;
+                            readonly documentation: Schema.TaggedStruct<"documentation", {
+                                readonly status: Schema.Literals<readonly ["missing", "draft", "current", "stale", "superseded"]>;
+                            }>;
+                            readonly deployment: Schema.TaggedStruct<"deployment", {
+                                readonly status: Schema.Literals<readonly ["not-started", "pending", "deploying", "succeeded", "failed", "rolled-back"]>;
+                                readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                                    readonly _tag: Schema.tag<"count">;
+                                    readonly completed: Schema.Int;
+                                    readonly total: Schema.Int;
+                                }>, Schema.TaggedStruct<"percent", {
+                                    readonly value: Schema.Number;
+                                }>]>>;
+                            }>;
+                        }>;
+                        readonly evidence: Schema.$Array<Schema.Struct<{
+                            readonly evidenceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">;
+                            readonly source: Schema.TaggedUnion<{
+                                readonly plugin: Schema.TaggedStruct<"plugin", {
+                                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                                    readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                                }>;
+                                readonly local: Schema.TaggedStruct<"local", {
+                                    readonly origin: Schema.Literals<readonly ["human", "agent", "system"]>;
+                                }>;
+                            }>;
+                            readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                            readonly validity: Schema.Literals<readonly ["valid", "expired"]>;
+                            readonly reevaluateAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                        }>>;
+                    }>>;
+                    readonly result: Schema.Literals<readonly ["verified", "pending", "failed", "gap", "advisory"]>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly nextEvaluationAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                readonly verdict: Schema.Literals<readonly ["blocked", "ready", "deploying", "building", "shipped", "held"]>;
+                readonly stages: Schema.Struct<{
+                    readonly build: Schema.Struct<{
+                        readonly state: Schema.Literals<readonly ["not-started", "queued", "running", "succeeded", "failed", "held"]>;
+                        readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                    readonly verify: Schema.Struct<{
+                        readonly state: Schema.Literals<readonly ["not-started", "pending", "passed", "failed", "held"]>;
+                        readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                    readonly production: Schema.Struct<{
+                        readonly state: Schema.Literals<readonly ["not-started", "waiting", "deploying", "succeeded", "failed", "rolled-back", "held"]>;
+                        readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                }>;
+                readonly blockers: Schema.$Array<Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                    readonly subject: Schema.TaggedUnion<{
+                        readonly source: Schema.TaggedStruct<"source", {
+                            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        }>;
+                        readonly fact: Schema.TaggedStruct<"fact", {
+                            readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        }>;
+                        readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                    }>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly warnings: Schema.$Array<Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                    readonly subject: Schema.TaggedUnion<{
+                        readonly source: Schema.TaggedStruct<"source", {
+                            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        }>;
+                        readonly fact: Schema.TaggedStruct<"fact", {
+                            readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        }>;
+                        readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                    }>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly gaps: Schema.$Array<Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                    readonly subject: Schema.TaggedUnion<{
+                        readonly source: Schema.TaggedStruct<"source", {
+                            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        }>;
+                        readonly fact: Schema.TaggedStruct<"fact", {
+                            readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        }>;
+                        readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                    }>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly sourceFreshness: Schema.$Array<Schema.Struct<{
+                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                    readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly assessmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">;
+            readonly previousAssessmentId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">>;
+            readonly rule: Schema.Struct<{
+                readonly ruleId: Schema.String;
+                readonly version: Schema.brand<Schema.Int, "ReadinessRuleVersion">;
+                readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+            }>;
+            readonly derivationVersion: Schema.brand<Schema.Int, "ReadinessDerivationVersion">;
+            readonly evaluatedAt: Schema.DateTimeUtcFromString;
+            readonly nextEvaluationAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+            readonly verdict: Schema.Literals<readonly ["blocked", "ready", "deploying", "building", "shipped", "held"]>;
+            readonly stages: Schema.Struct<{
+                readonly build: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["not-started", "queued", "running", "succeeded", "failed", "held"]>;
+                    readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"count">;
+                        readonly completed: Schema.Int;
+                        readonly total: Schema.Int;
+                    }>, Schema.TaggedStruct<"percent", {
+                        readonly value: Schema.Number;
+                    }>]>>;
+                }>;
+                readonly verify: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["not-started", "pending", "passed", "failed", "held"]>;
+                    readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"count">;
+                        readonly completed: Schema.Int;
+                        readonly total: Schema.Int;
+                    }>, Schema.TaggedStruct<"percent", {
+                        readonly value: Schema.Number;
+                    }>]>>;
+                }>;
+                readonly production: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["not-started", "waiting", "deploying", "succeeded", "failed", "rolled-back", "held"]>;
+                    readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"count">;
+                        readonly completed: Schema.Int;
+                        readonly total: Schema.Int;
+                    }>, Schema.TaggedStruct<"percent", {
+                        readonly value: Schema.Number;
+                    }>]>>;
+                }>;
+            }>;
+            readonly blockers: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                readonly subject: Schema.TaggedUnion<{
+                    readonly source: Schema.TaggedStruct<"source", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly fact: Schema.TaggedStruct<"fact", {
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    }>;
+                    readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                }>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly warnings: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                readonly subject: Schema.TaggedUnion<{
+                    readonly source: Schema.TaggedStruct<"source", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly fact: Schema.TaggedStruct<"fact", {
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    }>;
+                    readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                }>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly gaps: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                readonly subject: Schema.TaggedUnion<{
+                    readonly source: Schema.TaggedStruct<"source", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly fact: Schema.TaggedStruct<"fact", {
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    }>;
+                    readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                }>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly sourceFreshness: Schema.$Array<Schema.Struct<{
+                readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+        }>;
+    }, "Type">) => Effect.Effect<{
+        assessment: Schema.Struct.ReadonlySide<{
+            readonly _tag: Schema.Literal<"release">;
+            readonly candidate: Schema.Struct<{
+                readonly scope: Schema.TaggedStruct<"release", {
+                    readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                }>;
+                readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                readonly releaseRevision: Schema.Int;
+                readonly artifactRevision: Schema.String;
+                readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+            }>;
+            readonly environments: Schema.NonEmptyArray<Schema.Struct<{
+                readonly assessmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">;
+                readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+                readonly candidateDigest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+                readonly inputComplete: Schema.Boolean;
+                readonly facts: Schema.$Array<Schema.Struct<{
+                    readonly definition: Schema.Struct<{
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        readonly kind: Schema.Literals<readonly ["relationship", "approval", "check", "execution", "documentation", "deployment"]>;
+                        readonly requirement: Schema.Literals<readonly ["required", "advisory"]>;
+                    }>;
+                    readonly observation: Schema.NullOr<Schema.Struct<{
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        readonly state: Schema.TaggedUnion<{
+                            readonly relationship: Schema.TaggedStruct<"relationship", {
+                                readonly status: Schema.Literals<readonly ["missing", "inferred", "proposed", "verified", "governed", "rejected", "superseded"]>;
+                            }>;
+                            readonly approval: Schema.TaggedStruct<"approval", {
+                                readonly status: Schema.Literals<readonly ["missing", "pending", "approved", "rejected", "expired"]>;
+                            }>;
+                            readonly check: Schema.TaggedStruct<"check", {
+                                readonly status: Schema.Literals<readonly ["missing", "queued", "running", "passed", "failed", "cancelled"]>;
+                            }>;
+                            readonly execution: Schema.TaggedStruct<"execution", {
+                                readonly status: Schema.Literals<readonly ["missing", "queued", "running", "succeeded", "failed", "stopped"]>;
+                                readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                                    readonly _tag: Schema.tag<"count">;
+                                    readonly completed: Schema.Int;
+                                    readonly total: Schema.Int;
+                                }>, Schema.TaggedStruct<"percent", {
+                                    readonly value: Schema.Number;
+                                }>]>>;
+                            }>;
+                            readonly documentation: Schema.TaggedStruct<"documentation", {
+                                readonly status: Schema.Literals<readonly ["missing", "draft", "current", "stale", "superseded"]>;
+                            }>;
+                            readonly deployment: Schema.TaggedStruct<"deployment", {
+                                readonly status: Schema.Literals<readonly ["not-started", "pending", "deploying", "succeeded", "failed", "rolled-back"]>;
+                                readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                                    readonly _tag: Schema.tag<"count">;
+                                    readonly completed: Schema.Int;
+                                    readonly total: Schema.Int;
+                                }>, Schema.TaggedStruct<"percent", {
+                                    readonly value: Schema.Number;
+                                }>]>>;
+                            }>;
+                        }>;
+                        readonly evidence: Schema.$Array<Schema.Struct<{
+                            readonly evidenceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">;
+                            readonly source: Schema.TaggedUnion<{
+                                readonly plugin: Schema.TaggedStruct<"plugin", {
+                                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                                    readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                                }>;
+                                readonly local: Schema.TaggedStruct<"local", {
+                                    readonly origin: Schema.Literals<readonly ["human", "agent", "system"]>;
+                                }>;
+                            }>;
+                            readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                            readonly validity: Schema.Literals<readonly ["valid", "expired"]>;
+                            readonly reevaluateAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                        }>>;
+                    }>>;
+                    readonly result: Schema.Literals<readonly ["verified", "pending", "failed", "gap", "advisory"]>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly nextEvaluationAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                readonly verdict: Schema.Literals<readonly ["blocked", "ready", "deploying", "building", "shipped", "held"]>;
+                readonly stages: Schema.Struct<{
+                    readonly build: Schema.Struct<{
+                        readonly state: Schema.Literals<readonly ["not-started", "queued", "running", "succeeded", "failed", "held"]>;
+                        readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                    readonly verify: Schema.Struct<{
+                        readonly state: Schema.Literals<readonly ["not-started", "pending", "passed", "failed", "held"]>;
+                        readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                    readonly production: Schema.Struct<{
+                        readonly state: Schema.Literals<readonly ["not-started", "waiting", "deploying", "succeeded", "failed", "rolled-back", "held"]>;
+                        readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                }>;
+                readonly blockers: Schema.$Array<Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                    readonly subject: Schema.TaggedUnion<{
+                        readonly source: Schema.TaggedStruct<"source", {
+                            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        }>;
+                        readonly fact: Schema.TaggedStruct<"fact", {
+                            readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        }>;
+                        readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                    }>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly warnings: Schema.$Array<Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                    readonly subject: Schema.TaggedUnion<{
+                        readonly source: Schema.TaggedStruct<"source", {
+                            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        }>;
+                        readonly fact: Schema.TaggedStruct<"fact", {
+                            readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        }>;
+                        readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                    }>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly gaps: Schema.$Array<Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                    readonly subject: Schema.TaggedUnion<{
+                        readonly source: Schema.TaggedStruct<"source", {
+                            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        }>;
+                        readonly fact: Schema.TaggedStruct<"fact", {
+                            readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        }>;
+                        readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                    }>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly sourceFreshness: Schema.$Array<Schema.Struct<{
+                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                    readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly assessmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">;
+            readonly previousAssessmentId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">>;
+            readonly rule: Schema.Struct<{
+                readonly ruleId: Schema.String;
+                readonly version: Schema.brand<Schema.Int, "ReadinessRuleVersion">;
+                readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+            }>;
+            readonly derivationVersion: Schema.brand<Schema.Int, "ReadinessDerivationVersion">;
+            readonly evaluatedAt: Schema.DateTimeUtcFromString;
+            readonly nextEvaluationAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+            readonly verdict: Schema.Literals<readonly ["blocked", "ready", "deploying", "building", "shipped", "held"]>;
+            readonly stages: Schema.Struct<{
+                readonly build: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["not-started", "queued", "running", "succeeded", "failed", "held"]>;
+                    readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"count">;
+                        readonly completed: Schema.Int;
+                        readonly total: Schema.Int;
+                    }>, Schema.TaggedStruct<"percent", {
+                        readonly value: Schema.Number;
+                    }>]>>;
+                }>;
+                readonly verify: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["not-started", "pending", "passed", "failed", "held"]>;
+                    readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"count">;
+                        readonly completed: Schema.Int;
+                        readonly total: Schema.Int;
+                    }>, Schema.TaggedStruct<"percent", {
+                        readonly value: Schema.Number;
+                    }>]>>;
+                }>;
+                readonly production: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["not-started", "waiting", "deploying", "succeeded", "failed", "rolled-back", "held"]>;
+                    readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"count">;
+                        readonly completed: Schema.Int;
+                        readonly total: Schema.Int;
+                    }>, Schema.TaggedStruct<"percent", {
+                        readonly value: Schema.Number;
+                    }>]>>;
+                }>;
+            }>;
+            readonly blockers: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                readonly subject: Schema.TaggedUnion<{
+                    readonly source: Schema.TaggedStruct<"source", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly fact: Schema.TaggedStruct<"fact", {
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    }>;
+                    readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                }>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly warnings: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                readonly subject: Schema.TaggedUnion<{
+                    readonly source: Schema.TaggedStruct<"source", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly fact: Schema.TaggedStruct<"fact", {
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    }>;
+                    readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                }>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly gaps: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                readonly subject: Schema.TaggedUnion<{
+                    readonly source: Schema.TaggedStruct<"source", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly fact: Schema.TaggedStruct<"fact", {
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    }>;
+                    readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                }>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly sourceFreshness: Schema.$Array<Schema.Struct<{
+                readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+        }, "Type">;
+        headRevision: number & import("effect/Brand").Brand<"ReadinessHeadRevision">;
+        committedAt: DateTime.Utc;
+    }, unknown, import("effect/Crypto").Crypto>;
+    currentReleaseRows: (request: Schema.Struct.ReadonlySide<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly releaseIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">>;
+    }, "Type">) => Effect.Effect<{
+        headEnvironmentId: null;
+        joinComplete: number;
+        pendingCount: number;
+    }[], import("effect/unstable/sql/SqlError").SqlError, never>;
+    currentRows: (request: ReadCurrentReadinessAssessmentRequest) => Effect.Effect<{
+        readonly [x: string]: unknown;
+    }[], Schema.SchemaError | import("effect/unstable/sql/SqlError").SqlError, never>;
+    decodeCurrentReleaseRow: (row: {
+        readonly [x: string]: unknown;
+    }, workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">) => Effect.Effect<{
+        assessment: Schema.Struct.ReadonlySide<{
+            readonly _tag: Schema.Literal<"environment">;
+            readonly candidate: Schema.Struct<{
+                readonly scope: Schema.TaggedStruct<"environment", {
+                    readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                    readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+                }>;
+                readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                readonly releaseRevision: Schema.Int;
+                readonly artifactRevision: Schema.String;
+                readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+            }>;
+            readonly inputComplete: Schema.Boolean;
+            readonly facts: Schema.$Array<Schema.Struct<{
+                readonly definition: Schema.Struct<{
+                    readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    readonly kind: Schema.Literals<readonly ["relationship", "approval", "check", "execution", "documentation", "deployment"]>;
+                    readonly requirement: Schema.Literals<readonly ["required", "advisory"]>;
+                }>;
+                readonly observation: Schema.NullOr<Schema.Struct<{
+                    readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    readonly state: Schema.TaggedUnion<{
+                        readonly relationship: Schema.TaggedStruct<"relationship", {
+                            readonly status: Schema.Literals<readonly ["missing", "inferred", "proposed", "verified", "governed", "rejected", "superseded"]>;
+                        }>;
+                        readonly approval: Schema.TaggedStruct<"approval", {
+                            readonly status: Schema.Literals<readonly ["missing", "pending", "approved", "rejected", "expired"]>;
+                        }>;
+                        readonly check: Schema.TaggedStruct<"check", {
+                            readonly status: Schema.Literals<readonly ["missing", "queued", "running", "passed", "failed", "cancelled"]>;
+                        }>;
+                        readonly execution: Schema.TaggedStruct<"execution", {
+                            readonly status: Schema.Literals<readonly ["missing", "queued", "running", "succeeded", "failed", "stopped"]>;
+                            readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                                readonly _tag: Schema.tag<"count">;
+                                readonly completed: Schema.Int;
+                                readonly total: Schema.Int;
+                            }>, Schema.TaggedStruct<"percent", {
+                                readonly value: Schema.Number;
+                            }>]>>;
+                        }>;
+                        readonly documentation: Schema.TaggedStruct<"documentation", {
+                            readonly status: Schema.Literals<readonly ["missing", "draft", "current", "stale", "superseded"]>;
+                        }>;
+                        readonly deployment: Schema.TaggedStruct<"deployment", {
+                            readonly status: Schema.Literals<readonly ["not-started", "pending", "deploying", "succeeded", "failed", "rolled-back"]>;
+                            readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                                readonly _tag: Schema.tag<"count">;
+                                readonly completed: Schema.Int;
+                                readonly total: Schema.Int;
+                            }>, Schema.TaggedStruct<"percent", {
+                                readonly value: Schema.Number;
+                            }>]>>;
+                        }>;
+                    }>;
+                    readonly evidence: Schema.$Array<Schema.Struct<{
+                        readonly evidenceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">;
+                        readonly source: Schema.TaggedUnion<{
+                            readonly plugin: Schema.TaggedStruct<"plugin", {
+                                readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                                readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                            }>;
+                            readonly local: Schema.TaggedStruct<"local", {
+                                readonly origin: Schema.Literals<readonly ["human", "agent", "system"]>;
+                            }>;
+                        }>;
+                        readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                        readonly validity: Schema.Literals<readonly ["valid", "expired"]>;
+                        readonly reevaluateAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                    }>>;
+                }>>;
+                readonly result: Schema.Literals<readonly ["verified", "pending", "failed", "gap", "advisory"]>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly requiredFactIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+            readonly verifiedFactIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+            readonly assessmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">;
+            readonly previousAssessmentId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">>;
+            readonly rule: Schema.Struct<{
+                readonly ruleId: Schema.String;
+                readonly version: Schema.brand<Schema.Int, "ReadinessRuleVersion">;
+                readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+            }>;
+            readonly derivationVersion: Schema.brand<Schema.Int, "ReadinessDerivationVersion">;
+            readonly evaluatedAt: Schema.DateTimeUtcFromString;
+            readonly nextEvaluationAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+            readonly verdict: Schema.Literals<readonly ["blocked", "ready", "deploying", "building", "shipped", "held"]>;
+            readonly stages: Schema.Struct<{
+                readonly build: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["not-started", "queued", "running", "succeeded", "failed", "held"]>;
+                    readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"count">;
+                        readonly completed: Schema.Int;
+                        readonly total: Schema.Int;
+                    }>, Schema.TaggedStruct<"percent", {
+                        readonly value: Schema.Number;
+                    }>]>>;
+                }>;
+                readonly verify: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["not-started", "pending", "passed", "failed", "held"]>;
+                    readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"count">;
+                        readonly completed: Schema.Int;
+                        readonly total: Schema.Int;
+                    }>, Schema.TaggedStruct<"percent", {
+                        readonly value: Schema.Number;
+                    }>]>>;
+                }>;
+                readonly production: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["not-started", "waiting", "deploying", "succeeded", "failed", "rolled-back", "held"]>;
+                    readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"count">;
+                        readonly completed: Schema.Int;
+                        readonly total: Schema.Int;
+                    }>, Schema.TaggedStruct<"percent", {
+                        readonly value: Schema.Number;
+                    }>]>>;
+                }>;
+            }>;
+            readonly blockers: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                readonly subject: Schema.TaggedUnion<{
+                    readonly source: Schema.TaggedStruct<"source", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly fact: Schema.TaggedStruct<"fact", {
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    }>;
+                    readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                }>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly warnings: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                readonly subject: Schema.TaggedUnion<{
+                    readonly source: Schema.TaggedStruct<"source", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly fact: Schema.TaggedStruct<"fact", {
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    }>;
+                    readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                }>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly gaps: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                readonly subject: Schema.TaggedUnion<{
+                    readonly source: Schema.TaggedStruct<"source", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly fact: Schema.TaggedStruct<"fact", {
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    }>;
+                    readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                }>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly sourceFreshness: Schema.$Array<Schema.Struct<{
+                readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+        }, "Type"> | Schema.Struct.ReadonlySide<{
+            readonly _tag: Schema.Literal<"release">;
+            readonly candidate: Schema.Struct<{
+                readonly scope: Schema.TaggedStruct<"release", {
+                    readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                }>;
+                readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                readonly releaseRevision: Schema.Int;
+                readonly artifactRevision: Schema.String;
+                readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+            }>;
+            readonly environments: Schema.NonEmptyArray<Schema.Struct<{
+                readonly assessmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">;
+                readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+                readonly candidateDigest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+                readonly inputComplete: Schema.Boolean;
+                readonly facts: Schema.$Array<Schema.Struct<{
+                    readonly definition: Schema.Struct<{
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        readonly kind: Schema.Literals<readonly ["relationship", "approval", "check", "execution", "documentation", "deployment"]>;
+                        readonly requirement: Schema.Literals<readonly ["required", "advisory"]>;
+                    }>;
+                    readonly observation: Schema.NullOr<Schema.Struct<{
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        readonly state: Schema.TaggedUnion<{
+                            readonly relationship: Schema.TaggedStruct<"relationship", {
+                                readonly status: Schema.Literals<readonly ["missing", "inferred", "proposed", "verified", "governed", "rejected", "superseded"]>;
+                            }>;
+                            readonly approval: Schema.TaggedStruct<"approval", {
+                                readonly status: Schema.Literals<readonly ["missing", "pending", "approved", "rejected", "expired"]>;
+                            }>;
+                            readonly check: Schema.TaggedStruct<"check", {
+                                readonly status: Schema.Literals<readonly ["missing", "queued", "running", "passed", "failed", "cancelled"]>;
+                            }>;
+                            readonly execution: Schema.TaggedStruct<"execution", {
+                                readonly status: Schema.Literals<readonly ["missing", "queued", "running", "succeeded", "failed", "stopped"]>;
+                                readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                                    readonly _tag: Schema.tag<"count">;
+                                    readonly completed: Schema.Int;
+                                    readonly total: Schema.Int;
+                                }>, Schema.TaggedStruct<"percent", {
+                                    readonly value: Schema.Number;
+                                }>]>>;
+                            }>;
+                            readonly documentation: Schema.TaggedStruct<"documentation", {
+                                readonly status: Schema.Literals<readonly ["missing", "draft", "current", "stale", "superseded"]>;
+                            }>;
+                            readonly deployment: Schema.TaggedStruct<"deployment", {
+                                readonly status: Schema.Literals<readonly ["not-started", "pending", "deploying", "succeeded", "failed", "rolled-back"]>;
+                                readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                                    readonly _tag: Schema.tag<"count">;
+                                    readonly completed: Schema.Int;
+                                    readonly total: Schema.Int;
+                                }>, Schema.TaggedStruct<"percent", {
+                                    readonly value: Schema.Number;
+                                }>]>>;
+                            }>;
+                        }>;
+                        readonly evidence: Schema.$Array<Schema.Struct<{
+                            readonly evidenceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">;
+                            readonly source: Schema.TaggedUnion<{
+                                readonly plugin: Schema.TaggedStruct<"plugin", {
+                                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                                    readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                                }>;
+                                readonly local: Schema.TaggedStruct<"local", {
+                                    readonly origin: Schema.Literals<readonly ["human", "agent", "system"]>;
+                                }>;
+                            }>;
+                            readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                            readonly validity: Schema.Literals<readonly ["valid", "expired"]>;
+                            readonly reevaluateAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                        }>>;
+                    }>>;
+                    readonly result: Schema.Literals<readonly ["verified", "pending", "failed", "gap", "advisory"]>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly nextEvaluationAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                readonly verdict: Schema.Literals<readonly ["blocked", "ready", "deploying", "building", "shipped", "held"]>;
+                readonly stages: Schema.Struct<{
+                    readonly build: Schema.Struct<{
+                        readonly state: Schema.Literals<readonly ["not-started", "queued", "running", "succeeded", "failed", "held"]>;
+                        readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                    readonly verify: Schema.Struct<{
+                        readonly state: Schema.Literals<readonly ["not-started", "pending", "passed", "failed", "held"]>;
+                        readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                    readonly production: Schema.Struct<{
+                        readonly state: Schema.Literals<readonly ["not-started", "waiting", "deploying", "succeeded", "failed", "rolled-back", "held"]>;
+                        readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                }>;
+                readonly blockers: Schema.$Array<Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                    readonly subject: Schema.TaggedUnion<{
+                        readonly source: Schema.TaggedStruct<"source", {
+                            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        }>;
+                        readonly fact: Schema.TaggedStruct<"fact", {
+                            readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        }>;
+                        readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                    }>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly warnings: Schema.$Array<Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                    readonly subject: Schema.TaggedUnion<{
+                        readonly source: Schema.TaggedStruct<"source", {
+                            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        }>;
+                        readonly fact: Schema.TaggedStruct<"fact", {
+                            readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        }>;
+                        readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                    }>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly gaps: Schema.$Array<Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                    readonly subject: Schema.TaggedUnion<{
+                        readonly source: Schema.TaggedStruct<"source", {
+                            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        }>;
+                        readonly fact: Schema.TaggedStruct<"fact", {
+                            readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        }>;
+                        readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                    }>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly sourceFreshness: Schema.$Array<Schema.Struct<{
+                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                    readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly assessmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">;
+            readonly previousAssessmentId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">>;
+            readonly rule: Schema.Struct<{
+                readonly ruleId: Schema.String;
+                readonly version: Schema.brand<Schema.Int, "ReadinessRuleVersion">;
+                readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+            }>;
+            readonly derivationVersion: Schema.brand<Schema.Int, "ReadinessDerivationVersion">;
+            readonly evaluatedAt: Schema.DateTimeUtcFromString;
+            readonly nextEvaluationAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+            readonly verdict: Schema.Literals<readonly ["blocked", "ready", "deploying", "building", "shipped", "held"]>;
+            readonly stages: Schema.Struct<{
+                readonly build: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["not-started", "queued", "running", "succeeded", "failed", "held"]>;
+                    readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"count">;
+                        readonly completed: Schema.Int;
+                        readonly total: Schema.Int;
+                    }>, Schema.TaggedStruct<"percent", {
+                        readonly value: Schema.Number;
+                    }>]>>;
+                }>;
+                readonly verify: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["not-started", "pending", "passed", "failed", "held"]>;
+                    readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"count">;
+                        readonly completed: Schema.Int;
+                        readonly total: Schema.Int;
+                    }>, Schema.TaggedStruct<"percent", {
+                        readonly value: Schema.Number;
+                    }>]>>;
+                }>;
+                readonly production: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["not-started", "waiting", "deploying", "succeeded", "failed", "rolled-back", "held"]>;
+                    readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"count">;
+                        readonly completed: Schema.Int;
+                        readonly total: Schema.Int;
+                    }>, Schema.TaggedStruct<"percent", {
+                        readonly value: Schema.Number;
+                    }>]>>;
+                }>;
+            }>;
+            readonly blockers: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                readonly subject: Schema.TaggedUnion<{
+                    readonly source: Schema.TaggedStruct<"source", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly fact: Schema.TaggedStruct<"fact", {
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    }>;
+                    readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                }>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly warnings: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                readonly subject: Schema.TaggedUnion<{
+                    readonly source: Schema.TaggedStruct<"source", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly fact: Schema.TaggedStruct<"fact", {
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    }>;
+                    readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                }>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly gaps: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                readonly subject: Schema.TaggedUnion<{
+                    readonly source: Schema.TaggedStruct<"source", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly fact: Schema.TaggedStruct<"fact", {
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    }>;
+                    readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                }>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly sourceFreshness: Schema.$Array<Schema.Struct<{
+                readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+        }, "Type">;
+        headRevision: number & import("effect/Brand").Brand<"ReadinessHeadRevision">;
+        committedAt: DateTime.Utc;
+        authority: "pending" | "authoritative";
+    }, import("../../errors.js").PersistenceOperationError | import("./quarantine.js").MalformedReadinessRecord, import("effect/Crypto").Crypto>;
+    decodeCurrentRow: (row: {
+        readonly [x: string]: unknown;
+    }, request: Schema.Struct.ReadonlySide<{
+        readonly _tag: Schema.tag<"release">;
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+    }, "Type"> | Schema.Struct.ReadonlySide<{
+        readonly _tag: Schema.tag<"environment">;
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+        readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+    }, "Type">) => Effect.Effect<{
+        assessment: Schema.Struct.ReadonlySide<{
+            readonly _tag: Schema.Literal<"environment">;
+            readonly candidate: Schema.Struct<{
+                readonly scope: Schema.TaggedStruct<"environment", {
+                    readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                    readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+                }>;
+                readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                readonly releaseRevision: Schema.Int;
+                readonly artifactRevision: Schema.String;
+                readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+            }>;
+            readonly inputComplete: Schema.Boolean;
+            readonly facts: Schema.$Array<Schema.Struct<{
+                readonly definition: Schema.Struct<{
+                    readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    readonly kind: Schema.Literals<readonly ["relationship", "approval", "check", "execution", "documentation", "deployment"]>;
+                    readonly requirement: Schema.Literals<readonly ["required", "advisory"]>;
+                }>;
+                readonly observation: Schema.NullOr<Schema.Struct<{
+                    readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    readonly state: Schema.TaggedUnion<{
+                        readonly relationship: Schema.TaggedStruct<"relationship", {
+                            readonly status: Schema.Literals<readonly ["missing", "inferred", "proposed", "verified", "governed", "rejected", "superseded"]>;
+                        }>;
+                        readonly approval: Schema.TaggedStruct<"approval", {
+                            readonly status: Schema.Literals<readonly ["missing", "pending", "approved", "rejected", "expired"]>;
+                        }>;
+                        readonly check: Schema.TaggedStruct<"check", {
+                            readonly status: Schema.Literals<readonly ["missing", "queued", "running", "passed", "failed", "cancelled"]>;
+                        }>;
+                        readonly execution: Schema.TaggedStruct<"execution", {
+                            readonly status: Schema.Literals<readonly ["missing", "queued", "running", "succeeded", "failed", "stopped"]>;
+                            readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                                readonly _tag: Schema.tag<"count">;
+                                readonly completed: Schema.Int;
+                                readonly total: Schema.Int;
+                            }>, Schema.TaggedStruct<"percent", {
+                                readonly value: Schema.Number;
+                            }>]>>;
+                        }>;
+                        readonly documentation: Schema.TaggedStruct<"documentation", {
+                            readonly status: Schema.Literals<readonly ["missing", "draft", "current", "stale", "superseded"]>;
+                        }>;
+                        readonly deployment: Schema.TaggedStruct<"deployment", {
+                            readonly status: Schema.Literals<readonly ["not-started", "pending", "deploying", "succeeded", "failed", "rolled-back"]>;
+                            readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                                readonly _tag: Schema.tag<"count">;
+                                readonly completed: Schema.Int;
+                                readonly total: Schema.Int;
+                            }>, Schema.TaggedStruct<"percent", {
+                                readonly value: Schema.Number;
+                            }>]>>;
+                        }>;
+                    }>;
+                    readonly evidence: Schema.$Array<Schema.Struct<{
+                        readonly evidenceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">;
+                        readonly source: Schema.TaggedUnion<{
+                            readonly plugin: Schema.TaggedStruct<"plugin", {
+                                readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                                readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                            }>;
+                            readonly local: Schema.TaggedStruct<"local", {
+                                readonly origin: Schema.Literals<readonly ["human", "agent", "system"]>;
+                            }>;
+                        }>;
+                        readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                        readonly validity: Schema.Literals<readonly ["valid", "expired"]>;
+                        readonly reevaluateAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                    }>>;
+                }>>;
+                readonly result: Schema.Literals<readonly ["verified", "pending", "failed", "gap", "advisory"]>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly requiredFactIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+            readonly verifiedFactIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+            readonly assessmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">;
+            readonly previousAssessmentId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">>;
+            readonly rule: Schema.Struct<{
+                readonly ruleId: Schema.String;
+                readonly version: Schema.brand<Schema.Int, "ReadinessRuleVersion">;
+                readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+            }>;
+            readonly derivationVersion: Schema.brand<Schema.Int, "ReadinessDerivationVersion">;
+            readonly evaluatedAt: Schema.DateTimeUtcFromString;
+            readonly nextEvaluationAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+            readonly verdict: Schema.Literals<readonly ["blocked", "ready", "deploying", "building", "shipped", "held"]>;
+            readonly stages: Schema.Struct<{
+                readonly build: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["not-started", "queued", "running", "succeeded", "failed", "held"]>;
+                    readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"count">;
+                        readonly completed: Schema.Int;
+                        readonly total: Schema.Int;
+                    }>, Schema.TaggedStruct<"percent", {
+                        readonly value: Schema.Number;
+                    }>]>>;
+                }>;
+                readonly verify: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["not-started", "pending", "passed", "failed", "held"]>;
+                    readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"count">;
+                        readonly completed: Schema.Int;
+                        readonly total: Schema.Int;
+                    }>, Schema.TaggedStruct<"percent", {
+                        readonly value: Schema.Number;
+                    }>]>>;
+                }>;
+                readonly production: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["not-started", "waiting", "deploying", "succeeded", "failed", "rolled-back", "held"]>;
+                    readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"count">;
+                        readonly completed: Schema.Int;
+                        readonly total: Schema.Int;
+                    }>, Schema.TaggedStruct<"percent", {
+                        readonly value: Schema.Number;
+                    }>]>>;
+                }>;
+            }>;
+            readonly blockers: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                readonly subject: Schema.TaggedUnion<{
+                    readonly source: Schema.TaggedStruct<"source", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly fact: Schema.TaggedStruct<"fact", {
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    }>;
+                    readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                }>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly warnings: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                readonly subject: Schema.TaggedUnion<{
+                    readonly source: Schema.TaggedStruct<"source", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly fact: Schema.TaggedStruct<"fact", {
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    }>;
+                    readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                }>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly gaps: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                readonly subject: Schema.TaggedUnion<{
+                    readonly source: Schema.TaggedStruct<"source", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly fact: Schema.TaggedStruct<"fact", {
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    }>;
+                    readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                }>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly sourceFreshness: Schema.$Array<Schema.Struct<{
+                readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+        }, "Type"> | Schema.Struct.ReadonlySide<{
+            readonly _tag: Schema.Literal<"release">;
+            readonly candidate: Schema.Struct<{
+                readonly scope: Schema.TaggedStruct<"release", {
+                    readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                }>;
+                readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                readonly releaseRevision: Schema.Int;
+                readonly artifactRevision: Schema.String;
+                readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+            }>;
+            readonly environments: Schema.NonEmptyArray<Schema.Struct<{
+                readonly assessmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">;
+                readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+                readonly candidateDigest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+                readonly inputComplete: Schema.Boolean;
+                readonly facts: Schema.$Array<Schema.Struct<{
+                    readonly definition: Schema.Struct<{
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        readonly kind: Schema.Literals<readonly ["relationship", "approval", "check", "execution", "documentation", "deployment"]>;
+                        readonly requirement: Schema.Literals<readonly ["required", "advisory"]>;
+                    }>;
+                    readonly observation: Schema.NullOr<Schema.Struct<{
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        readonly state: Schema.TaggedUnion<{
+                            readonly relationship: Schema.TaggedStruct<"relationship", {
+                                readonly status: Schema.Literals<readonly ["missing", "inferred", "proposed", "verified", "governed", "rejected", "superseded"]>;
+                            }>;
+                            readonly approval: Schema.TaggedStruct<"approval", {
+                                readonly status: Schema.Literals<readonly ["missing", "pending", "approved", "rejected", "expired"]>;
+                            }>;
+                            readonly check: Schema.TaggedStruct<"check", {
+                                readonly status: Schema.Literals<readonly ["missing", "queued", "running", "passed", "failed", "cancelled"]>;
+                            }>;
+                            readonly execution: Schema.TaggedStruct<"execution", {
+                                readonly status: Schema.Literals<readonly ["missing", "queued", "running", "succeeded", "failed", "stopped"]>;
+                                readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                                    readonly _tag: Schema.tag<"count">;
+                                    readonly completed: Schema.Int;
+                                    readonly total: Schema.Int;
+                                }>, Schema.TaggedStruct<"percent", {
+                                    readonly value: Schema.Number;
+                                }>]>>;
+                            }>;
+                            readonly documentation: Schema.TaggedStruct<"documentation", {
+                                readonly status: Schema.Literals<readonly ["missing", "draft", "current", "stale", "superseded"]>;
+                            }>;
+                            readonly deployment: Schema.TaggedStruct<"deployment", {
+                                readonly status: Schema.Literals<readonly ["not-started", "pending", "deploying", "succeeded", "failed", "rolled-back"]>;
+                                readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                                    readonly _tag: Schema.tag<"count">;
+                                    readonly completed: Schema.Int;
+                                    readonly total: Schema.Int;
+                                }>, Schema.TaggedStruct<"percent", {
+                                    readonly value: Schema.Number;
+                                }>]>>;
+                            }>;
+                        }>;
+                        readonly evidence: Schema.$Array<Schema.Struct<{
+                            readonly evidenceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">;
+                            readonly source: Schema.TaggedUnion<{
+                                readonly plugin: Schema.TaggedStruct<"plugin", {
+                                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                                    readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                                }>;
+                                readonly local: Schema.TaggedStruct<"local", {
+                                    readonly origin: Schema.Literals<readonly ["human", "agent", "system"]>;
+                                }>;
+                            }>;
+                            readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                            readonly validity: Schema.Literals<readonly ["valid", "expired"]>;
+                            readonly reevaluateAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                        }>>;
+                    }>>;
+                    readonly result: Schema.Literals<readonly ["verified", "pending", "failed", "gap", "advisory"]>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly nextEvaluationAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                readonly verdict: Schema.Literals<readonly ["blocked", "ready", "deploying", "building", "shipped", "held"]>;
+                readonly stages: Schema.Struct<{
+                    readonly build: Schema.Struct<{
+                        readonly state: Schema.Literals<readonly ["not-started", "queued", "running", "succeeded", "failed", "held"]>;
+                        readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                    readonly verify: Schema.Struct<{
+                        readonly state: Schema.Literals<readonly ["not-started", "pending", "passed", "failed", "held"]>;
+                        readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                    readonly production: Schema.Struct<{
+                        readonly state: Schema.Literals<readonly ["not-started", "waiting", "deploying", "succeeded", "failed", "rolled-back", "held"]>;
+                        readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                }>;
+                readonly blockers: Schema.$Array<Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                    readonly subject: Schema.TaggedUnion<{
+                        readonly source: Schema.TaggedStruct<"source", {
+                            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        }>;
+                        readonly fact: Schema.TaggedStruct<"fact", {
+                            readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        }>;
+                        readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                    }>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly warnings: Schema.$Array<Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                    readonly subject: Schema.TaggedUnion<{
+                        readonly source: Schema.TaggedStruct<"source", {
+                            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        }>;
+                        readonly fact: Schema.TaggedStruct<"fact", {
+                            readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        }>;
+                        readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                    }>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly gaps: Schema.$Array<Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                    readonly subject: Schema.TaggedUnion<{
+                        readonly source: Schema.TaggedStruct<"source", {
+                            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        }>;
+                        readonly fact: Schema.TaggedStruct<"fact", {
+                            readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        }>;
+                        readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                    }>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly sourceFreshness: Schema.$Array<Schema.Struct<{
+                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                    readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly assessmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">;
+            readonly previousAssessmentId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">>;
+            readonly rule: Schema.Struct<{
+                readonly ruleId: Schema.String;
+                readonly version: Schema.brand<Schema.Int, "ReadinessRuleVersion">;
+                readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+            }>;
+            readonly derivationVersion: Schema.brand<Schema.Int, "ReadinessDerivationVersion">;
+            readonly evaluatedAt: Schema.DateTimeUtcFromString;
+            readonly nextEvaluationAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+            readonly verdict: Schema.Literals<readonly ["blocked", "ready", "deploying", "building", "shipped", "held"]>;
+            readonly stages: Schema.Struct<{
+                readonly build: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["not-started", "queued", "running", "succeeded", "failed", "held"]>;
+                    readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"count">;
+                        readonly completed: Schema.Int;
+                        readonly total: Schema.Int;
+                    }>, Schema.TaggedStruct<"percent", {
+                        readonly value: Schema.Number;
+                    }>]>>;
+                }>;
+                readonly verify: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["not-started", "pending", "passed", "failed", "held"]>;
+                    readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"count">;
+                        readonly completed: Schema.Int;
+                        readonly total: Schema.Int;
+                    }>, Schema.TaggedStruct<"percent", {
+                        readonly value: Schema.Number;
+                    }>]>>;
+                }>;
+                readonly production: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["not-started", "waiting", "deploying", "succeeded", "failed", "rolled-back", "held"]>;
+                    readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"count">;
+                        readonly completed: Schema.Int;
+                        readonly total: Schema.Int;
+                    }>, Schema.TaggedStruct<"percent", {
+                        readonly value: Schema.Number;
+                    }>]>>;
+                }>;
+            }>;
+            readonly blockers: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                readonly subject: Schema.TaggedUnion<{
+                    readonly source: Schema.TaggedStruct<"source", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly fact: Schema.TaggedStruct<"fact", {
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    }>;
+                    readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                }>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly warnings: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                readonly subject: Schema.TaggedUnion<{
+                    readonly source: Schema.TaggedStruct<"source", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly fact: Schema.TaggedStruct<"fact", {
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    }>;
+                    readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                }>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly gaps: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                readonly subject: Schema.TaggedUnion<{
+                    readonly source: Schema.TaggedStruct<"source", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly fact: Schema.TaggedStruct<"fact", {
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    }>;
+                    readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                }>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly sourceFreshness: Schema.$Array<Schema.Struct<{
+                readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+        }, "Type">;
+        headRevision: number & import("effect/Brand").Brand<"ReadinessHeadRevision">;
+        committedAt: DateTime.Utc;
+        authority: "pending" | "authoritative";
+    }, import("../../errors.js").PersistenceOperationError | import("./quarantine.js").MalformedReadinessRecord, import("effect/Crypto").Crypto>;
+    decodeHistoryRow: (row: {
+        readonly [x: string]: unknown;
+    }, request: Schema.Struct.ReadonlySide<{
+        readonly _tag: Schema.tag<"release">;
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+        readonly beforeHeadRevision: Schema.NullOr<Schema.brand<Schema.Int, "ReadinessHeadRevision">>;
+        readonly limit: Schema.brand<Schema.Int, "ReadinessHistoryLimit">;
+    }, "Type"> | Schema.Struct.ReadonlySide<{
+        readonly _tag: Schema.tag<"environment">;
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+        readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+        readonly beforeHeadRevision: Schema.NullOr<Schema.brand<Schema.Int, "ReadinessHeadRevision">>;
+        readonly limit: Schema.brand<Schema.Int, "ReadinessHistoryLimit">;
+    }, "Type">) => Effect.Effect<{
+        assessment: Schema.Struct.ReadonlySide<{
+            readonly _tag: Schema.Literal<"environment">;
+            readonly candidate: Schema.Struct<{
+                readonly scope: Schema.TaggedStruct<"environment", {
+                    readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                    readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+                }>;
+                readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                readonly releaseRevision: Schema.Int;
+                readonly artifactRevision: Schema.String;
+                readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+            }>;
+            readonly inputComplete: Schema.Boolean;
+            readonly facts: Schema.$Array<Schema.Struct<{
+                readonly definition: Schema.Struct<{
+                    readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    readonly kind: Schema.Literals<readonly ["relationship", "approval", "check", "execution", "documentation", "deployment"]>;
+                    readonly requirement: Schema.Literals<readonly ["required", "advisory"]>;
+                }>;
+                readonly observation: Schema.NullOr<Schema.Struct<{
+                    readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    readonly state: Schema.TaggedUnion<{
+                        readonly relationship: Schema.TaggedStruct<"relationship", {
+                            readonly status: Schema.Literals<readonly ["missing", "inferred", "proposed", "verified", "governed", "rejected", "superseded"]>;
+                        }>;
+                        readonly approval: Schema.TaggedStruct<"approval", {
+                            readonly status: Schema.Literals<readonly ["missing", "pending", "approved", "rejected", "expired"]>;
+                        }>;
+                        readonly check: Schema.TaggedStruct<"check", {
+                            readonly status: Schema.Literals<readonly ["missing", "queued", "running", "passed", "failed", "cancelled"]>;
+                        }>;
+                        readonly execution: Schema.TaggedStruct<"execution", {
+                            readonly status: Schema.Literals<readonly ["missing", "queued", "running", "succeeded", "failed", "stopped"]>;
+                            readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                                readonly _tag: Schema.tag<"count">;
+                                readonly completed: Schema.Int;
+                                readonly total: Schema.Int;
+                            }>, Schema.TaggedStruct<"percent", {
+                                readonly value: Schema.Number;
+                            }>]>>;
+                        }>;
+                        readonly documentation: Schema.TaggedStruct<"documentation", {
+                            readonly status: Schema.Literals<readonly ["missing", "draft", "current", "stale", "superseded"]>;
+                        }>;
+                        readonly deployment: Schema.TaggedStruct<"deployment", {
+                            readonly status: Schema.Literals<readonly ["not-started", "pending", "deploying", "succeeded", "failed", "rolled-back"]>;
+                            readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                                readonly _tag: Schema.tag<"count">;
+                                readonly completed: Schema.Int;
+                                readonly total: Schema.Int;
+                            }>, Schema.TaggedStruct<"percent", {
+                                readonly value: Schema.Number;
+                            }>]>>;
+                        }>;
+                    }>;
+                    readonly evidence: Schema.$Array<Schema.Struct<{
+                        readonly evidenceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">;
+                        readonly source: Schema.TaggedUnion<{
+                            readonly plugin: Schema.TaggedStruct<"plugin", {
+                                readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                                readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                            }>;
+                            readonly local: Schema.TaggedStruct<"local", {
+                                readonly origin: Schema.Literals<readonly ["human", "agent", "system"]>;
+                            }>;
+                        }>;
+                        readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                        readonly validity: Schema.Literals<readonly ["valid", "expired"]>;
+                        readonly reevaluateAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                    }>>;
+                }>>;
+                readonly result: Schema.Literals<readonly ["verified", "pending", "failed", "gap", "advisory"]>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly requiredFactIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+            readonly verifiedFactIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+            readonly assessmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">;
+            readonly previousAssessmentId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">>;
+            readonly rule: Schema.Struct<{
+                readonly ruleId: Schema.String;
+                readonly version: Schema.brand<Schema.Int, "ReadinessRuleVersion">;
+                readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+            }>;
+            readonly derivationVersion: Schema.brand<Schema.Int, "ReadinessDerivationVersion">;
+            readonly evaluatedAt: Schema.DateTimeUtcFromString;
+            readonly nextEvaluationAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+            readonly verdict: Schema.Literals<readonly ["blocked", "ready", "deploying", "building", "shipped", "held"]>;
+            readonly stages: Schema.Struct<{
+                readonly build: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["not-started", "queued", "running", "succeeded", "failed", "held"]>;
+                    readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"count">;
+                        readonly completed: Schema.Int;
+                        readonly total: Schema.Int;
+                    }>, Schema.TaggedStruct<"percent", {
+                        readonly value: Schema.Number;
+                    }>]>>;
+                }>;
+                readonly verify: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["not-started", "pending", "passed", "failed", "held"]>;
+                    readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"count">;
+                        readonly completed: Schema.Int;
+                        readonly total: Schema.Int;
+                    }>, Schema.TaggedStruct<"percent", {
+                        readonly value: Schema.Number;
+                    }>]>>;
+                }>;
+                readonly production: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["not-started", "waiting", "deploying", "succeeded", "failed", "rolled-back", "held"]>;
+                    readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"count">;
+                        readonly completed: Schema.Int;
+                        readonly total: Schema.Int;
+                    }>, Schema.TaggedStruct<"percent", {
+                        readonly value: Schema.Number;
+                    }>]>>;
+                }>;
+            }>;
+            readonly blockers: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                readonly subject: Schema.TaggedUnion<{
+                    readonly source: Schema.TaggedStruct<"source", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly fact: Schema.TaggedStruct<"fact", {
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    }>;
+                    readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                }>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly warnings: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                readonly subject: Schema.TaggedUnion<{
+                    readonly source: Schema.TaggedStruct<"source", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly fact: Schema.TaggedStruct<"fact", {
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    }>;
+                    readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                }>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly gaps: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                readonly subject: Schema.TaggedUnion<{
+                    readonly source: Schema.TaggedStruct<"source", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly fact: Schema.TaggedStruct<"fact", {
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    }>;
+                    readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                }>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly sourceFreshness: Schema.$Array<Schema.Struct<{
+                readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+        }, "Type"> | Schema.Struct.ReadonlySide<{
+            readonly _tag: Schema.Literal<"release">;
+            readonly candidate: Schema.Struct<{
+                readonly scope: Schema.TaggedStruct<"release", {
+                    readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                }>;
+                readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                readonly releaseRevision: Schema.Int;
+                readonly artifactRevision: Schema.String;
+                readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+            }>;
+            readonly environments: Schema.NonEmptyArray<Schema.Struct<{
+                readonly assessmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">;
+                readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+                readonly candidateDigest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+                readonly inputComplete: Schema.Boolean;
+                readonly facts: Schema.$Array<Schema.Struct<{
+                    readonly definition: Schema.Struct<{
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        readonly kind: Schema.Literals<readonly ["relationship", "approval", "check", "execution", "documentation", "deployment"]>;
+                        readonly requirement: Schema.Literals<readonly ["required", "advisory"]>;
+                    }>;
+                    readonly observation: Schema.NullOr<Schema.Struct<{
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        readonly state: Schema.TaggedUnion<{
+                            readonly relationship: Schema.TaggedStruct<"relationship", {
+                                readonly status: Schema.Literals<readonly ["missing", "inferred", "proposed", "verified", "governed", "rejected", "superseded"]>;
+                            }>;
+                            readonly approval: Schema.TaggedStruct<"approval", {
+                                readonly status: Schema.Literals<readonly ["missing", "pending", "approved", "rejected", "expired"]>;
+                            }>;
+                            readonly check: Schema.TaggedStruct<"check", {
+                                readonly status: Schema.Literals<readonly ["missing", "queued", "running", "passed", "failed", "cancelled"]>;
+                            }>;
+                            readonly execution: Schema.TaggedStruct<"execution", {
+                                readonly status: Schema.Literals<readonly ["missing", "queued", "running", "succeeded", "failed", "stopped"]>;
+                                readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                                    readonly _tag: Schema.tag<"count">;
+                                    readonly completed: Schema.Int;
+                                    readonly total: Schema.Int;
+                                }>, Schema.TaggedStruct<"percent", {
+                                    readonly value: Schema.Number;
+                                }>]>>;
+                            }>;
+                            readonly documentation: Schema.TaggedStruct<"documentation", {
+                                readonly status: Schema.Literals<readonly ["missing", "draft", "current", "stale", "superseded"]>;
+                            }>;
+                            readonly deployment: Schema.TaggedStruct<"deployment", {
+                                readonly status: Schema.Literals<readonly ["not-started", "pending", "deploying", "succeeded", "failed", "rolled-back"]>;
+                                readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                                    readonly _tag: Schema.tag<"count">;
+                                    readonly completed: Schema.Int;
+                                    readonly total: Schema.Int;
+                                }>, Schema.TaggedStruct<"percent", {
+                                    readonly value: Schema.Number;
+                                }>]>>;
+                            }>;
+                        }>;
+                        readonly evidence: Schema.$Array<Schema.Struct<{
+                            readonly evidenceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">;
+                            readonly source: Schema.TaggedUnion<{
+                                readonly plugin: Schema.TaggedStruct<"plugin", {
+                                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                                    readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                                }>;
+                                readonly local: Schema.TaggedStruct<"local", {
+                                    readonly origin: Schema.Literals<readonly ["human", "agent", "system"]>;
+                                }>;
+                            }>;
+                            readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                            readonly validity: Schema.Literals<readonly ["valid", "expired"]>;
+                            readonly reevaluateAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                        }>>;
+                    }>>;
+                    readonly result: Schema.Literals<readonly ["verified", "pending", "failed", "gap", "advisory"]>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly nextEvaluationAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                readonly verdict: Schema.Literals<readonly ["blocked", "ready", "deploying", "building", "shipped", "held"]>;
+                readonly stages: Schema.Struct<{
+                    readonly build: Schema.Struct<{
+                        readonly state: Schema.Literals<readonly ["not-started", "queued", "running", "succeeded", "failed", "held"]>;
+                        readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                    readonly verify: Schema.Struct<{
+                        readonly state: Schema.Literals<readonly ["not-started", "pending", "passed", "failed", "held"]>;
+                        readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                    readonly production: Schema.Struct<{
+                        readonly state: Schema.Literals<readonly ["not-started", "waiting", "deploying", "succeeded", "failed", "rolled-back", "held"]>;
+                        readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                }>;
+                readonly blockers: Schema.$Array<Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                    readonly subject: Schema.TaggedUnion<{
+                        readonly source: Schema.TaggedStruct<"source", {
+                            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        }>;
+                        readonly fact: Schema.TaggedStruct<"fact", {
+                            readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        }>;
+                        readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                    }>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly warnings: Schema.$Array<Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                    readonly subject: Schema.TaggedUnion<{
+                        readonly source: Schema.TaggedStruct<"source", {
+                            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        }>;
+                        readonly fact: Schema.TaggedStruct<"fact", {
+                            readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        }>;
+                        readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                    }>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly gaps: Schema.$Array<Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                    readonly subject: Schema.TaggedUnion<{
+                        readonly source: Schema.TaggedStruct<"source", {
+                            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        }>;
+                        readonly fact: Schema.TaggedStruct<"fact", {
+                            readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        }>;
+                        readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                    }>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly sourceFreshness: Schema.$Array<Schema.Struct<{
+                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                    readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly assessmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">;
+            readonly previousAssessmentId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">>;
+            readonly rule: Schema.Struct<{
+                readonly ruleId: Schema.String;
+                readonly version: Schema.brand<Schema.Int, "ReadinessRuleVersion">;
+                readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+            }>;
+            readonly derivationVersion: Schema.brand<Schema.Int, "ReadinessDerivationVersion">;
+            readonly evaluatedAt: Schema.DateTimeUtcFromString;
+            readonly nextEvaluationAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+            readonly verdict: Schema.Literals<readonly ["blocked", "ready", "deploying", "building", "shipped", "held"]>;
+            readonly stages: Schema.Struct<{
+                readonly build: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["not-started", "queued", "running", "succeeded", "failed", "held"]>;
+                    readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"count">;
+                        readonly completed: Schema.Int;
+                        readonly total: Schema.Int;
+                    }>, Schema.TaggedStruct<"percent", {
+                        readonly value: Schema.Number;
+                    }>]>>;
+                }>;
+                readonly verify: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["not-started", "pending", "passed", "failed", "held"]>;
+                    readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"count">;
+                        readonly completed: Schema.Int;
+                        readonly total: Schema.Int;
+                    }>, Schema.TaggedStruct<"percent", {
+                        readonly value: Schema.Number;
+                    }>]>>;
+                }>;
+                readonly production: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["not-started", "waiting", "deploying", "succeeded", "failed", "rolled-back", "held"]>;
+                    readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"count">;
+                        readonly completed: Schema.Int;
+                        readonly total: Schema.Int;
+                    }>, Schema.TaggedStruct<"percent", {
+                        readonly value: Schema.Number;
+                    }>]>>;
+                }>;
+            }>;
+            readonly blockers: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                readonly subject: Schema.TaggedUnion<{
+                    readonly source: Schema.TaggedStruct<"source", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly fact: Schema.TaggedStruct<"fact", {
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    }>;
+                    readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                }>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly warnings: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                readonly subject: Schema.TaggedUnion<{
+                    readonly source: Schema.TaggedStruct<"source", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly fact: Schema.TaggedStruct<"fact", {
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    }>;
+                    readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                }>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly gaps: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                readonly subject: Schema.TaggedUnion<{
+                    readonly source: Schema.TaggedStruct<"source", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly fact: Schema.TaggedStruct<"fact", {
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    }>;
+                    readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                }>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly sourceFreshness: Schema.$Array<Schema.Struct<{
+                readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+        }, "Type">;
+        headRevision: number & import("effect/Brand").Brand<"ReadinessHeadRevision">;
+        committedAt: DateTime.Utc;
+    }, import("../../errors.js").PersistenceOperationError | import("./quarantine.js").MalformedReadinessRecord, import("effect/Crypto").Crypto>;
+    historyRows: (request: ReadReadinessHistoryRequest) => Effect.Effect<{
+        readonly [x: string]: unknown;
+    }[], Schema.SchemaError | import("effect/unstable/sql/SqlError").SqlError, never>;
+    loadAssessmentMaterialization: (input: {
+        readonly workspaceId: WorkspaceId;
+        readonly assessmentIds: ReadonlyArray<import("../../../../domain/identifiers.js").ReadinessAssessmentId>;
+    }) => Effect.Effect<import("./materialization.js").GroupedMaterialization, Schema.SchemaError | import("effect/unstable/sql/SqlError").SqlError | import("./quarantine.js").MalformedReadinessRecord, never>;
+    verifyAssessmentMaterialization: (assessment: Schema.Struct.ReadonlySide<{
+        readonly _tag: Schema.Literal<"environment">;
+        readonly candidate: Schema.Struct<{
+            readonly scope: Schema.TaggedStruct<"environment", {
+                readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+            }>;
+            readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            readonly releaseRevision: Schema.Int;
+            readonly artifactRevision: Schema.String;
+            readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+        }>;
+        readonly inputComplete: Schema.Boolean;
+        readonly facts: Schema.$Array<Schema.Struct<{
+            readonly definition: Schema.Struct<{
+                readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                readonly kind: Schema.Literals<readonly ["relationship", "approval", "check", "execution", "documentation", "deployment"]>;
+                readonly requirement: Schema.Literals<readonly ["required", "advisory"]>;
+            }>;
+            readonly observation: Schema.NullOr<Schema.Struct<{
+                readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                readonly state: Schema.TaggedUnion<{
+                    readonly relationship: Schema.TaggedStruct<"relationship", {
+                        readonly status: Schema.Literals<readonly ["missing", "inferred", "proposed", "verified", "governed", "rejected", "superseded"]>;
+                    }>;
+                    readonly approval: Schema.TaggedStruct<"approval", {
+                        readonly status: Schema.Literals<readonly ["missing", "pending", "approved", "rejected", "expired"]>;
+                    }>;
+                    readonly check: Schema.TaggedStruct<"check", {
+                        readonly status: Schema.Literals<readonly ["missing", "queued", "running", "passed", "failed", "cancelled"]>;
+                    }>;
+                    readonly execution: Schema.TaggedStruct<"execution", {
+                        readonly status: Schema.Literals<readonly ["missing", "queued", "running", "succeeded", "failed", "stopped"]>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                    readonly documentation: Schema.TaggedStruct<"documentation", {
+                        readonly status: Schema.Literals<readonly ["missing", "draft", "current", "stale", "superseded"]>;
+                    }>;
+                    readonly deployment: Schema.TaggedStruct<"deployment", {
+                        readonly status: Schema.Literals<readonly ["not-started", "pending", "deploying", "succeeded", "failed", "rolled-back"]>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                }>;
+                readonly evidence: Schema.$Array<Schema.Struct<{
+                    readonly evidenceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">;
+                    readonly source: Schema.TaggedUnion<{
+                        readonly plugin: Schema.TaggedStruct<"plugin", {
+                            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                            readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                        }>;
+                        readonly local: Schema.TaggedStruct<"local", {
+                            readonly origin: Schema.Literals<readonly ["human", "agent", "system"]>;
+                        }>;
+                    }>;
+                    readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                    readonly validity: Schema.Literals<readonly ["valid", "expired"]>;
+                    readonly reevaluateAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                }>>;
+            }>>;
+            readonly result: Schema.Literals<readonly ["verified", "pending", "failed", "gap", "advisory"]>;
+            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+        }>>;
+        readonly requiredFactIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+        readonly verifiedFactIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+        readonly assessmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">;
+        readonly previousAssessmentId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">>;
+        readonly rule: Schema.Struct<{
+            readonly ruleId: Schema.String;
+            readonly version: Schema.brand<Schema.Int, "ReadinessRuleVersion">;
+            readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+        }>;
+        readonly derivationVersion: Schema.brand<Schema.Int, "ReadinessDerivationVersion">;
+        readonly evaluatedAt: Schema.DateTimeUtcFromString;
+        readonly nextEvaluationAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+        readonly verdict: Schema.Literals<readonly ["blocked", "ready", "deploying", "building", "shipped", "held"]>;
+        readonly stages: Schema.Struct<{
+            readonly build: Schema.Struct<{
+                readonly state: Schema.Literals<readonly ["not-started", "queued", "running", "succeeded", "failed", "held"]>;
+                readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                    readonly _tag: Schema.tag<"count">;
+                    readonly completed: Schema.Int;
+                    readonly total: Schema.Int;
+                }>, Schema.TaggedStruct<"percent", {
+                    readonly value: Schema.Number;
+                }>]>>;
+            }>;
+            readonly verify: Schema.Struct<{
+                readonly state: Schema.Literals<readonly ["not-started", "pending", "passed", "failed", "held"]>;
+                readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                    readonly _tag: Schema.tag<"count">;
+                    readonly completed: Schema.Int;
+                    readonly total: Schema.Int;
+                }>, Schema.TaggedStruct<"percent", {
+                    readonly value: Schema.Number;
+                }>]>>;
+            }>;
+            readonly production: Schema.Struct<{
+                readonly state: Schema.Literals<readonly ["not-started", "waiting", "deploying", "succeeded", "failed", "rolled-back", "held"]>;
+                readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                    readonly _tag: Schema.tag<"count">;
+                    readonly completed: Schema.Int;
+                    readonly total: Schema.Int;
+                }>, Schema.TaggedStruct<"percent", {
+                    readonly value: Schema.Number;
+                }>]>>;
+            }>;
+        }>;
+        readonly blockers: Schema.$Array<Schema.Struct<{
+            readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+            readonly subject: Schema.TaggedUnion<{
+                readonly source: Schema.TaggedStruct<"source", {
+                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                }>;
+                readonly fact: Schema.TaggedStruct<"fact", {
+                    readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                }>;
+                readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+            }>;
+            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+        }>>;
+        readonly warnings: Schema.$Array<Schema.Struct<{
+            readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+            readonly subject: Schema.TaggedUnion<{
+                readonly source: Schema.TaggedStruct<"source", {
+                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                }>;
+                readonly fact: Schema.TaggedStruct<"fact", {
+                    readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                }>;
+                readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+            }>;
+            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+        }>>;
+        readonly gaps: Schema.$Array<Schema.Struct<{
+            readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+            readonly subject: Schema.TaggedUnion<{
+                readonly source: Schema.TaggedStruct<"source", {
+                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                }>;
+                readonly fact: Schema.TaggedStruct<"fact", {
+                    readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                }>;
+                readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+            }>;
+            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+        }>>;
+        readonly sourceFreshness: Schema.$Array<Schema.Struct<{
+            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+            readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+            readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+        }>>;
+        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+    }, "Type"> | Schema.Struct.ReadonlySide<{
+        readonly _tag: Schema.Literal<"release">;
+        readonly candidate: Schema.Struct<{
+            readonly scope: Schema.TaggedStruct<"release", {
+                readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+            }>;
+            readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            readonly releaseRevision: Schema.Int;
+            readonly artifactRevision: Schema.String;
+            readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+        }>;
+        readonly environments: Schema.NonEmptyArray<Schema.Struct<{
+            readonly assessmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">;
+            readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+            readonly candidateDigest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+            readonly inputComplete: Schema.Boolean;
+            readonly facts: Schema.$Array<Schema.Struct<{
+                readonly definition: Schema.Struct<{
+                    readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    readonly kind: Schema.Literals<readonly ["relationship", "approval", "check", "execution", "documentation", "deployment"]>;
+                    readonly requirement: Schema.Literals<readonly ["required", "advisory"]>;
+                }>;
+                readonly observation: Schema.NullOr<Schema.Struct<{
+                    readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    readonly state: Schema.TaggedUnion<{
+                        readonly relationship: Schema.TaggedStruct<"relationship", {
+                            readonly status: Schema.Literals<readonly ["missing", "inferred", "proposed", "verified", "governed", "rejected", "superseded"]>;
+                        }>;
+                        readonly approval: Schema.TaggedStruct<"approval", {
+                            readonly status: Schema.Literals<readonly ["missing", "pending", "approved", "rejected", "expired"]>;
+                        }>;
+                        readonly check: Schema.TaggedStruct<"check", {
+                            readonly status: Schema.Literals<readonly ["missing", "queued", "running", "passed", "failed", "cancelled"]>;
+                        }>;
+                        readonly execution: Schema.TaggedStruct<"execution", {
+                            readonly status: Schema.Literals<readonly ["missing", "queued", "running", "succeeded", "failed", "stopped"]>;
+                            readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                                readonly _tag: Schema.tag<"count">;
+                                readonly completed: Schema.Int;
+                                readonly total: Schema.Int;
+                            }>, Schema.TaggedStruct<"percent", {
+                                readonly value: Schema.Number;
+                            }>]>>;
+                        }>;
+                        readonly documentation: Schema.TaggedStruct<"documentation", {
+                            readonly status: Schema.Literals<readonly ["missing", "draft", "current", "stale", "superseded"]>;
+                        }>;
+                        readonly deployment: Schema.TaggedStruct<"deployment", {
+                            readonly status: Schema.Literals<readonly ["not-started", "pending", "deploying", "succeeded", "failed", "rolled-back"]>;
+                            readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                                readonly _tag: Schema.tag<"count">;
+                                readonly completed: Schema.Int;
+                                readonly total: Schema.Int;
+                            }>, Schema.TaggedStruct<"percent", {
+                                readonly value: Schema.Number;
+                            }>]>>;
+                        }>;
+                    }>;
+                    readonly evidence: Schema.$Array<Schema.Struct<{
+                        readonly evidenceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">;
+                        readonly source: Schema.TaggedUnion<{
+                            readonly plugin: Schema.TaggedStruct<"plugin", {
+                                readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                                readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                            }>;
+                            readonly local: Schema.TaggedStruct<"local", {
+                                readonly origin: Schema.Literals<readonly ["human", "agent", "system"]>;
+                            }>;
+                        }>;
+                        readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                        readonly validity: Schema.Literals<readonly ["valid", "expired"]>;
+                        readonly reevaluateAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                    }>>;
+                }>>;
+                readonly result: Schema.Literals<readonly ["verified", "pending", "failed", "gap", "advisory"]>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly nextEvaluationAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+            readonly verdict: Schema.Literals<readonly ["blocked", "ready", "deploying", "building", "shipped", "held"]>;
+            readonly stages: Schema.Struct<{
+                readonly build: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["not-started", "queued", "running", "succeeded", "failed", "held"]>;
+                    readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"count">;
+                        readonly completed: Schema.Int;
+                        readonly total: Schema.Int;
+                    }>, Schema.TaggedStruct<"percent", {
+                        readonly value: Schema.Number;
+                    }>]>>;
+                }>;
+                readonly verify: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["not-started", "pending", "passed", "failed", "held"]>;
+                    readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"count">;
+                        readonly completed: Schema.Int;
+                        readonly total: Schema.Int;
+                    }>, Schema.TaggedStruct<"percent", {
+                        readonly value: Schema.Number;
+                    }>]>>;
+                }>;
+                readonly production: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["not-started", "waiting", "deploying", "succeeded", "failed", "rolled-back", "held"]>;
+                    readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"count">;
+                        readonly completed: Schema.Int;
+                        readonly total: Schema.Int;
+                    }>, Schema.TaggedStruct<"percent", {
+                        readonly value: Schema.Number;
+                    }>]>>;
+                }>;
+            }>;
+            readonly blockers: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                readonly subject: Schema.TaggedUnion<{
+                    readonly source: Schema.TaggedStruct<"source", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly fact: Schema.TaggedStruct<"fact", {
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    }>;
+                    readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                }>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly warnings: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                readonly subject: Schema.TaggedUnion<{
+                    readonly source: Schema.TaggedStruct<"source", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly fact: Schema.TaggedStruct<"fact", {
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    }>;
+                    readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                }>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly gaps: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                readonly subject: Schema.TaggedUnion<{
+                    readonly source: Schema.TaggedStruct<"source", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly fact: Schema.TaggedStruct<"fact", {
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    }>;
+                    readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                }>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly sourceFreshness: Schema.$Array<Schema.Struct<{
+                readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+        }>>;
+        readonly assessmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">;
+        readonly previousAssessmentId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">>;
+        readonly rule: Schema.Struct<{
+            readonly ruleId: Schema.String;
+            readonly version: Schema.brand<Schema.Int, "ReadinessRuleVersion">;
+            readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+        }>;
+        readonly derivationVersion: Schema.brand<Schema.Int, "ReadinessDerivationVersion">;
+        readonly evaluatedAt: Schema.DateTimeUtcFromString;
+        readonly nextEvaluationAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+        readonly verdict: Schema.Literals<readonly ["blocked", "ready", "deploying", "building", "shipped", "held"]>;
+        readonly stages: Schema.Struct<{
+            readonly build: Schema.Struct<{
+                readonly state: Schema.Literals<readonly ["not-started", "queued", "running", "succeeded", "failed", "held"]>;
+                readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                    readonly _tag: Schema.tag<"count">;
+                    readonly completed: Schema.Int;
+                    readonly total: Schema.Int;
+                }>, Schema.TaggedStruct<"percent", {
+                    readonly value: Schema.Number;
+                }>]>>;
+            }>;
+            readonly verify: Schema.Struct<{
+                readonly state: Schema.Literals<readonly ["not-started", "pending", "passed", "failed", "held"]>;
+                readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                    readonly _tag: Schema.tag<"count">;
+                    readonly completed: Schema.Int;
+                    readonly total: Schema.Int;
+                }>, Schema.TaggedStruct<"percent", {
+                    readonly value: Schema.Number;
+                }>]>>;
+            }>;
+            readonly production: Schema.Struct<{
+                readonly state: Schema.Literals<readonly ["not-started", "waiting", "deploying", "succeeded", "failed", "rolled-back", "held"]>;
+                readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                    readonly _tag: Schema.tag<"count">;
+                    readonly completed: Schema.Int;
+                    readonly total: Schema.Int;
+                }>, Schema.TaggedStruct<"percent", {
+                    readonly value: Schema.Number;
+                }>]>>;
+            }>;
+        }>;
+        readonly blockers: Schema.$Array<Schema.Struct<{
+            readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+            readonly subject: Schema.TaggedUnion<{
+                readonly source: Schema.TaggedStruct<"source", {
+                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                }>;
+                readonly fact: Schema.TaggedStruct<"fact", {
+                    readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                }>;
+                readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+            }>;
+            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+        }>>;
+        readonly warnings: Schema.$Array<Schema.Struct<{
+            readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+            readonly subject: Schema.TaggedUnion<{
+                readonly source: Schema.TaggedStruct<"source", {
+                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                }>;
+                readonly fact: Schema.TaggedStruct<"fact", {
+                    readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                }>;
+                readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+            }>;
+            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+        }>>;
+        readonly gaps: Schema.$Array<Schema.Struct<{
+            readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+            readonly subject: Schema.TaggedUnion<{
+                readonly source: Schema.TaggedStruct<"source", {
+                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                }>;
+                readonly fact: Schema.TaggedStruct<"fact", {
+                    readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                }>;
+                readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+            }>;
+            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+        }>>;
+        readonly sourceFreshness: Schema.$Array<Schema.Struct<{
+            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+            readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+            readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+        }>>;
+        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+    }, "Type">, row: unknown, grouped: import("./materialization.js").GroupedMaterialization) => Effect.Effect<undefined, import("./quarantine.js").MalformedReadinessRecord, never>;
+}, never, import("effect/Crypto").Crypto | Database>;
+//# sourceMappingURL=assessments.d.ts.map