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/codec.d.ts ADDED Viewed

@@ -0,0 +1,1368 @@
+import * as Crypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { PersistedRecordError, PersistenceOperationError } from "../../errors.js";
+export declare const makeReadinessCodec: Effect.Effect<{
+    candidateDigest: (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">) => Effect.Effect<string & import("effect/Brand").Brand<"ReadinessCandidateDigest">, import("../../../readinessDigests.js").ReadinessDigestError, Crypto.Crypto>;
+    decodeAssessmentRow: (row: Schema.Struct.ReadonlySide<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly assessmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">;
+        readonly scopeKind: Schema.Literals<readonly ["environment", "release"]>;
+        readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+        readonly environmentId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">>;
+        readonly releaseRevision: Schema.Int;
+        readonly artifactRevision: Schema.String;
+        readonly candidateDigest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+        readonly ruleId: Schema.String;
+        readonly ruleVersion: Schema.brand<Schema.Int, "ReadinessRuleVersion">;
+        readonly ruleDigest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+        readonly derivationVersion: Schema.brand<Schema.Int, "ReadinessDerivationVersion">;
+        readonly previousAssessmentId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">>;
+        readonly verdict: Schema.Literals<readonly ["blocked", "ready", "deploying", "building", "shipped", "held"]>;
+        readonly evaluatedAt: Schema.String;
+        readonly nextEvaluationAt: Schema.NullOr<Schema.String>;
+        readonly assessmentJson: Schema.String;
+        readonly assessmentDigest: Schema.brand<Schema.String, "BlobDigest">;
+    }, "Type">) => Effect.Effect<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">, PersistenceOperationError | PersistedRecordError, Crypto.Crypto>;
+    decodeRuleRow: (row: Schema.Struct.ReadonlySide<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly ruleId: Schema.String;
+        readonly ruleVersion: Schema.brand<Schema.Int, "ReadinessRuleVersion">;
+        readonly ruleDigest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+        readonly materialJson: Schema.String;
+        readonly createdAt: Schema.String;
+    }, "Type">) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly ruleId: Schema.String;
+        readonly version: Schema.brand<Schema.Int, "ReadinessRuleVersion">;
+        readonly definitions: Schema.$Array<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"]>;
+        }>>;
+    }, "Type">, PersistedRecordError, Crypto.Crypto>;
+    digestJson: (value: string) => Effect.Effect<string & import("effect/Brand").Brand<"BlobDigest">, PersistenceOperationError, never>;
+    prepareAssessment: (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">) => Effect.Effect<{
+        assessmentJson: string;
+        assessmentDigest: string & import("effect/Brand").Brand<"BlobDigest">;
+        computedCandidateDigest: string & import("effect/Brand").Brand<"ReadinessCandidateDigest">;
+        evidenceIds: readonly (string & import("effect/Brand").Brand<"EvidenceId">)[];
+        sourcePluginConnectionIds: (string & import("effect/Brand").Brand<"PluginConnectionId">)[];
+        releaseChildren: {
+            environmentId: string & import("effect/Brand").Brand<"EnvironmentId">;
+            environmentAssessmentId: string & import("effect/Brand").Brand<"ReadinessAssessmentId">;
+            environmentCandidateDigest: string & import("effect/Brand").Brand<"ReadinessCandidateDigest">;
+        }[];
+    }, PersistenceOperationError | import("../../../readinessDigests.js").ReadinessDigestError, Crypto.Crypto>;
+    prepareRule: (material: Schema.Struct.ReadonlySide<{
+        readonly ruleId: Schema.String;
+        readonly version: Schema.brand<Schema.Int, "ReadinessRuleVersion">;
+        readonly definitions: Schema.$Array<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"]>;
+        }>>;
+    }, "Type">) => Effect.Effect<{
+        material: Schema.Struct.ReadonlySide<{
+            readonly ruleId: Schema.String;
+            readonly version: Schema.brand<Schema.Int, "ReadinessRuleVersion">;
+            readonly definitions: Schema.$Array<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"]>;
+            }>>;
+        }, "Type">;
+        materialJson: string;
+        ruleDigest: string & import("effect/Brand").Brand<"ReadinessCandidateDigest">;
+    }, PersistenceOperationError | import("../../../readinessDigests.js").ReadinessDigestError, Crypto.Crypto>;
+}, never, Crypto.Crypto>;
+//# sourceMappingURL=codec.d.ts.map