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

@@ -0,0 +1,1722 @@
+import * as Context from "effect/Context";
+import * as Crypto from "effect/Crypto";
+import * as DateTime from "effect/DateTime";
+import * as Effect from "effect/Effect";
+import type { Success } from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import { Database } from "../Database.js";
+import { PersistedRecordError, type PersistenceOperationError, type QuarantineWriteError } from "../errors.js";
+import { QuarantineRepository } from "./quarantineRepository.js";
+import { ReadinessInputError } from "./readiness/contract.js";
+import type { MalformedReadinessRecord } from "./readiness/quarantine.js";
+export * from "./readiness/contract.js";
+declare const makeReadinessRepository: Effect.Effect<{
+    claimInvalidation: (input: unknown) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly _tag: Schema.tag<"release">;
+        readonly invalidationRevision: Schema.brand<Schema.Int, "ReadinessInvalidationRevision">;
+        readonly reason: Schema.Literals<readonly ["evidence-changed", "plugin-health-changed", "rule-changed", "candidate-changed", "scheduled", "environment-assessment-changed"]>;
+        readonly enqueuedAt: Schema.DateTimeUtcFromString;
+        readonly lease: Schema.NullOr<Schema.Struct<{
+            readonly owner: Schema.brand<Schema.String, "ReadinessLeaseOwner">;
+            readonly token: Schema.brand<Schema.String, "ReadinessLeaseToken">;
+            readonly claimedAt: Schema.DateTimeUtcFromString;
+            readonly expiresAt: Schema.DateTimeUtcFromString;
+        }>>;
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+    }, "Type"> | Schema.Struct.ReadonlySide<{
+        readonly _tag: Schema.tag<"environment">;
+        readonly invalidationRevision: Schema.brand<Schema.Int, "ReadinessInvalidationRevision">;
+        readonly reason: Schema.Literals<readonly ["evidence-changed", "plugin-health-changed", "rule-changed", "candidate-changed", "scheduled", "environment-assessment-changed"]>;
+        readonly enqueuedAt: Schema.DateTimeUtcFromString;
+        readonly lease: Schema.NullOr<Schema.Struct<{
+            readonly owner: Schema.brand<Schema.String, "ReadinessLeaseOwner">;
+            readonly token: Schema.brand<Schema.String, "ReadinessLeaseToken">;
+            readonly claimedAt: Schema.DateTimeUtcFromString;
+            readonly expiresAt: Schema.DateTimeUtcFromString;
+        }>>;
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+        readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+    }, "Type"> | null, unknown, never>;
+    commitEnvironment: (input: unknown) => Effect.Effect<{
+        assessment: Schema.Struct.ReadonlySide<{
+            readonly _tag: Schema.Literal<"environment">;
+            readonly candidate: Schema.Struct<{
+                readonly scope: Schema.TaggedStruct<"environment", {
+                    readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                    readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+                }>;
+                readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                readonly releaseRevision: Schema.Int;
+                readonly artifactRevision: Schema.String;
+                readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+            }>;
+            readonly inputComplete: Schema.Boolean;
+            readonly facts: Schema.$Array<Schema.Struct<{
+                readonly definition: Schema.Struct<{
+                    readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    readonly kind: Schema.Literals<readonly ["relationship", "approval", "check", "execution", "documentation", "deployment"]>;
+                    readonly requirement: Schema.Literals<readonly ["required", "advisory"]>;
+                }>;
+                readonly observation: Schema.NullOr<Schema.Struct<{
+                    readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    readonly state: Schema.TaggedUnion<{
+                        readonly relationship: Schema.TaggedStruct<"relationship", {
+                            readonly status: Schema.Literals<readonly ["missing", "inferred", "proposed", "verified", "governed", "rejected", "superseded"]>;
+                        }>;
+                        readonly approval: Schema.TaggedStruct<"approval", {
+                            readonly status: Schema.Literals<readonly ["missing", "pending", "approved", "rejected", "expired"]>;
+                        }>;
+                        readonly check: Schema.TaggedStruct<"check", {
+                            readonly status: Schema.Literals<readonly ["missing", "queued", "running", "passed", "failed", "cancelled"]>;
+                        }>;
+                        readonly execution: Schema.TaggedStruct<"execution", {
+                            readonly status: Schema.Literals<readonly ["missing", "queued", "running", "succeeded", "failed", "stopped"]>;
+                            readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                                readonly _tag: Schema.tag<"count">;
+                                readonly completed: Schema.Int;
+                                readonly total: Schema.Int;
+                            }>, Schema.TaggedStruct<"percent", {
+                                readonly value: Schema.Number;
+                            }>]>>;
+                        }>;
+                        readonly documentation: Schema.TaggedStruct<"documentation", {
+                            readonly status: Schema.Literals<readonly ["missing", "draft", "current", "stale", "superseded"]>;
+                        }>;
+                        readonly deployment: Schema.TaggedStruct<"deployment", {
+                            readonly status: Schema.Literals<readonly ["not-started", "pending", "deploying", "succeeded", "failed", "rolled-back"]>;
+                            readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                                readonly _tag: Schema.tag<"count">;
+                                readonly completed: Schema.Int;
+                                readonly total: Schema.Int;
+                            }>, Schema.TaggedStruct<"percent", {
+                                readonly value: Schema.Number;
+                            }>]>>;
+                        }>;
+                    }>;
+                    readonly evidence: Schema.$Array<Schema.Struct<{
+                        readonly evidenceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">;
+                        readonly source: Schema.TaggedUnion<{
+                            readonly plugin: Schema.TaggedStruct<"plugin", {
+                                readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                                readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                            }>;
+                            readonly local: Schema.TaggedStruct<"local", {
+                                readonly origin: Schema.Literals<readonly ["human", "agent", "system"]>;
+                            }>;
+                        }>;
+                        readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                        readonly validity: Schema.Literals<readonly ["valid", "expired"]>;
+                        readonly reevaluateAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                    }>>;
+                }>>;
+                readonly result: Schema.Literals<readonly ["verified", "pending", "failed", "gap", "advisory"]>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly requiredFactIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+            readonly verifiedFactIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+            readonly assessmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">;
+            readonly previousAssessmentId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">>;
+            readonly rule: Schema.Struct<{
+                readonly ruleId: Schema.String;
+                readonly version: Schema.brand<Schema.Int, "ReadinessRuleVersion">;
+                readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+            }>;
+            readonly derivationVersion: Schema.brand<Schema.Int, "ReadinessDerivationVersion">;
+            readonly evaluatedAt: Schema.DateTimeUtcFromString;
+            readonly nextEvaluationAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+            readonly verdict: Schema.Literals<readonly ["blocked", "ready", "deploying", "building", "shipped", "held"]>;
+            readonly stages: Schema.Struct<{
+                readonly build: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["not-started", "queued", "running", "succeeded", "failed", "held"]>;
+                    readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"count">;
+                        readonly completed: Schema.Int;
+                        readonly total: Schema.Int;
+                    }>, Schema.TaggedStruct<"percent", {
+                        readonly value: Schema.Number;
+                    }>]>>;
+                }>;
+                readonly verify: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["not-started", "pending", "passed", "failed", "held"]>;
+                    readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"count">;
+                        readonly completed: Schema.Int;
+                        readonly total: Schema.Int;
+                    }>, Schema.TaggedStruct<"percent", {
+                        readonly value: Schema.Number;
+                    }>]>>;
+                }>;
+                readonly production: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["not-started", "waiting", "deploying", "succeeded", "failed", "rolled-back", "held"]>;
+                    readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"count">;
+                        readonly completed: Schema.Int;
+                        readonly total: Schema.Int;
+                    }>, Schema.TaggedStruct<"percent", {
+                        readonly value: Schema.Number;
+                    }>]>>;
+                }>;
+            }>;
+            readonly blockers: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                readonly subject: Schema.TaggedUnion<{
+                    readonly source: Schema.TaggedStruct<"source", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly fact: Schema.TaggedStruct<"fact", {
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    }>;
+                    readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                }>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly warnings: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                readonly subject: Schema.TaggedUnion<{
+                    readonly source: Schema.TaggedStruct<"source", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly fact: Schema.TaggedStruct<"fact", {
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    }>;
+                    readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                }>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly gaps: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                readonly subject: Schema.TaggedUnion<{
+                    readonly source: Schema.TaggedStruct<"source", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly fact: Schema.TaggedStruct<"fact", {
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    }>;
+                    readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                }>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly sourceFreshness: Schema.$Array<Schema.Struct<{
+                readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+        }, "Type">;
+        headRevision: number & import("effect/Brand").Brand<"ReadinessHeadRevision">;
+        committedAt: DateTime.Utc;
+    }, unknown, Crypto.Crypto>;
+    commitRelease: (input: unknown) => Effect.Effect<{
+        assessment: Schema.Struct.ReadonlySide<{
+            readonly _tag: Schema.Literal<"release">;
+            readonly candidate: Schema.Struct<{
+                readonly scope: Schema.TaggedStruct<"release", {
+                    readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                }>;
+                readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                readonly releaseRevision: Schema.Int;
+                readonly artifactRevision: Schema.String;
+                readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+            }>;
+            readonly environments: Schema.NonEmptyArray<Schema.Struct<{
+                readonly assessmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">;
+                readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+                readonly candidateDigest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+                readonly inputComplete: Schema.Boolean;
+                readonly facts: Schema.$Array<Schema.Struct<{
+                    readonly definition: Schema.Struct<{
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        readonly kind: Schema.Literals<readonly ["relationship", "approval", "check", "execution", "documentation", "deployment"]>;
+                        readonly requirement: Schema.Literals<readonly ["required", "advisory"]>;
+                    }>;
+                    readonly observation: Schema.NullOr<Schema.Struct<{
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        readonly state: Schema.TaggedUnion<{
+                            readonly relationship: Schema.TaggedStruct<"relationship", {
+                                readonly status: Schema.Literals<readonly ["missing", "inferred", "proposed", "verified", "governed", "rejected", "superseded"]>;
+                            }>;
+                            readonly approval: Schema.TaggedStruct<"approval", {
+                                readonly status: Schema.Literals<readonly ["missing", "pending", "approved", "rejected", "expired"]>;
+                            }>;
+                            readonly check: Schema.TaggedStruct<"check", {
+                                readonly status: Schema.Literals<readonly ["missing", "queued", "running", "passed", "failed", "cancelled"]>;
+                            }>;
+                            readonly execution: Schema.TaggedStruct<"execution", {
+                                readonly status: Schema.Literals<readonly ["missing", "queued", "running", "succeeded", "failed", "stopped"]>;
+                                readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                                    readonly _tag: Schema.tag<"count">;
+                                    readonly completed: Schema.Int;
+                                    readonly total: Schema.Int;
+                                }>, Schema.TaggedStruct<"percent", {
+                                    readonly value: Schema.Number;
+                                }>]>>;
+                            }>;
+                            readonly documentation: Schema.TaggedStruct<"documentation", {
+                                readonly status: Schema.Literals<readonly ["missing", "draft", "current", "stale", "superseded"]>;
+                            }>;
+                            readonly deployment: Schema.TaggedStruct<"deployment", {
+                                readonly status: Schema.Literals<readonly ["not-started", "pending", "deploying", "succeeded", "failed", "rolled-back"]>;
+                                readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                                    readonly _tag: Schema.tag<"count">;
+                                    readonly completed: Schema.Int;
+                                    readonly total: Schema.Int;
+                                }>, Schema.TaggedStruct<"percent", {
+                                    readonly value: Schema.Number;
+                                }>]>>;
+                            }>;
+                        }>;
+                        readonly evidence: Schema.$Array<Schema.Struct<{
+                            readonly evidenceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">;
+                            readonly source: Schema.TaggedUnion<{
+                                readonly plugin: Schema.TaggedStruct<"plugin", {
+                                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                                    readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                                }>;
+                                readonly local: Schema.TaggedStruct<"local", {
+                                    readonly origin: Schema.Literals<readonly ["human", "agent", "system"]>;
+                                }>;
+                            }>;
+                            readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                            readonly validity: Schema.Literals<readonly ["valid", "expired"]>;
+                            readonly reevaluateAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                        }>>;
+                    }>>;
+                    readonly result: Schema.Literals<readonly ["verified", "pending", "failed", "gap", "advisory"]>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly nextEvaluationAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                readonly verdict: Schema.Literals<readonly ["blocked", "ready", "deploying", "building", "shipped", "held"]>;
+                readonly stages: Schema.Struct<{
+                    readonly build: Schema.Struct<{
+                        readonly state: Schema.Literals<readonly ["not-started", "queued", "running", "succeeded", "failed", "held"]>;
+                        readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                    readonly verify: Schema.Struct<{
+                        readonly state: Schema.Literals<readonly ["not-started", "pending", "passed", "failed", "held"]>;
+                        readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                    readonly production: Schema.Struct<{
+                        readonly state: Schema.Literals<readonly ["not-started", "waiting", "deploying", "succeeded", "failed", "rolled-back", "held"]>;
+                        readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                }>;
+                readonly blockers: Schema.$Array<Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                    readonly subject: Schema.TaggedUnion<{
+                        readonly source: Schema.TaggedStruct<"source", {
+                            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        }>;
+                        readonly fact: Schema.TaggedStruct<"fact", {
+                            readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        }>;
+                        readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                    }>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly warnings: Schema.$Array<Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                    readonly subject: Schema.TaggedUnion<{
+                        readonly source: Schema.TaggedStruct<"source", {
+                            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        }>;
+                        readonly fact: Schema.TaggedStruct<"fact", {
+                            readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        }>;
+                        readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                    }>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly gaps: Schema.$Array<Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                    readonly subject: Schema.TaggedUnion<{
+                        readonly source: Schema.TaggedStruct<"source", {
+                            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        }>;
+                        readonly fact: Schema.TaggedStruct<"fact", {
+                            readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        }>;
+                        readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                    }>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly sourceFreshness: Schema.$Array<Schema.Struct<{
+                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                    readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly assessmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">;
+            readonly previousAssessmentId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">>;
+            readonly rule: Schema.Struct<{
+                readonly ruleId: Schema.String;
+                readonly version: Schema.brand<Schema.Int, "ReadinessRuleVersion">;
+                readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+            }>;
+            readonly derivationVersion: Schema.brand<Schema.Int, "ReadinessDerivationVersion">;
+            readonly evaluatedAt: Schema.DateTimeUtcFromString;
+            readonly nextEvaluationAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+            readonly verdict: Schema.Literals<readonly ["blocked", "ready", "deploying", "building", "shipped", "held"]>;
+            readonly stages: Schema.Struct<{
+                readonly build: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["not-started", "queued", "running", "succeeded", "failed", "held"]>;
+                    readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"count">;
+                        readonly completed: Schema.Int;
+                        readonly total: Schema.Int;
+                    }>, Schema.TaggedStruct<"percent", {
+                        readonly value: Schema.Number;
+                    }>]>>;
+                }>;
+                readonly verify: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["not-started", "pending", "passed", "failed", "held"]>;
+                    readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"count">;
+                        readonly completed: Schema.Int;
+                        readonly total: Schema.Int;
+                    }>, Schema.TaggedStruct<"percent", {
+                        readonly value: Schema.Number;
+                    }>]>>;
+                }>;
+                readonly production: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["not-started", "waiting", "deploying", "succeeded", "failed", "rolled-back", "held"]>;
+                    readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"count">;
+                        readonly completed: Schema.Int;
+                        readonly total: Schema.Int;
+                    }>, Schema.TaggedStruct<"percent", {
+                        readonly value: Schema.Number;
+                    }>]>>;
+                }>;
+            }>;
+            readonly blockers: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                readonly subject: Schema.TaggedUnion<{
+                    readonly source: Schema.TaggedStruct<"source", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly fact: Schema.TaggedStruct<"fact", {
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    }>;
+                    readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                }>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly warnings: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                readonly subject: Schema.TaggedUnion<{
+                    readonly source: Schema.TaggedStruct<"source", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly fact: Schema.TaggedStruct<"fact", {
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    }>;
+                    readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                }>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly gaps: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                readonly subject: Schema.TaggedUnion<{
+                    readonly source: Schema.TaggedStruct<"source", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly fact: Schema.TaggedStruct<"fact", {
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    }>;
+                    readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                }>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly sourceFreshness: Schema.$Array<Schema.Struct<{
+                readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+        }, "Type">;
+        headRevision: number & import("effect/Brand").Brand<"ReadinessHeadRevision">;
+        committedAt: DateTime.Utc;
+    }, unknown, Crypto.Crypto>;
+    enqueueAffected: (input: unknown) => Effect.Effect<{
+        environments: number;
+        releases: number;
+    }, PersistenceOperationError | ReadinessInputError, never>;
+    enqueueDue: (input: unknown) => Effect.Effect<{
+        enqueued: number;
+    }, PersistenceOperationError | import("effect/Cause").NoSuchElementError | ReadinessInputError, never>;
+    enqueueInvalidation: (input: unknown) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly _tag: Schema.tag<"release">;
+        readonly invalidationRevision: Schema.brand<Schema.Int, "ReadinessInvalidationRevision">;
+        readonly reason: Schema.Literals<readonly ["evidence-changed", "plugin-health-changed", "rule-changed", "candidate-changed", "scheduled", "environment-assessment-changed"]>;
+        readonly enqueuedAt: Schema.DateTimeUtcFromString;
+        readonly lease: Schema.NullOr<Schema.Struct<{
+            readonly owner: Schema.brand<Schema.String, "ReadinessLeaseOwner">;
+            readonly token: Schema.brand<Schema.String, "ReadinessLeaseToken">;
+            readonly claimedAt: Schema.DateTimeUtcFromString;
+            readonly expiresAt: Schema.DateTimeUtcFromString;
+        }>>;
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+    }, "Type"> | Schema.Struct.ReadonlySide<{
+        readonly _tag: Schema.tag<"environment">;
+        readonly invalidationRevision: Schema.brand<Schema.Int, "ReadinessInvalidationRevision">;
+        readonly reason: Schema.Literals<readonly ["evidence-changed", "plugin-health-changed", "rule-changed", "candidate-changed", "scheduled", "environment-assessment-changed"]>;
+        readonly enqueuedAt: Schema.DateTimeUtcFromString;
+        readonly lease: Schema.NullOr<Schema.Struct<{
+            readonly owner: Schema.brand<Schema.String, "ReadinessLeaseOwner">;
+            readonly token: Schema.brand<Schema.String, "ReadinessLeaseToken">;
+            readonly claimedAt: Schema.DateTimeUtcFromString;
+            readonly expiresAt: Schema.DateTimeUtcFromString;
+        }>>;
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+        readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+    }, "Type">, PersistenceOperationError | import("effect/Cause").NoSuchElementError | ReadinessInputError, never>;
+    readCurrent: (input: unknown) => Effect.Effect<{
+        _tag: "release" | "environment";
+        record: null;
+    } | {
+        _tag: "environment";
+        record: Schema.Struct.ReadonlySide<{
+            readonly authority: Schema.Literals<readonly ["authoritative", "pending"]>;
+            readonly headRevision: Schema.brand<Schema.Int, "ReadinessHeadRevision">;
+            readonly assessment: Schema.Struct<{
+                readonly _tag: Schema.Literal<"environment">;
+                readonly candidate: Schema.Struct<{
+                    readonly scope: Schema.TaggedStruct<"environment", {
+                        readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                        readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+                    }>;
+                    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                    readonly releaseRevision: Schema.Int;
+                    readonly artifactRevision: Schema.String;
+                    readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+                }>;
+                readonly inputComplete: Schema.Boolean;
+                readonly facts: Schema.$Array<Schema.Struct<{
+                    readonly definition: Schema.Struct<{
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        readonly kind: Schema.Literals<readonly ["relationship", "approval", "check", "execution", "documentation", "deployment"]>;
+                        readonly requirement: Schema.Literals<readonly ["required", "advisory"]>;
+                    }>;
+                    readonly observation: Schema.NullOr<Schema.Struct<{
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        readonly state: Schema.TaggedUnion<{
+                            readonly relationship: Schema.TaggedStruct<"relationship", {
+                                readonly status: Schema.Literals<readonly ["missing", "inferred", "proposed", "verified", "governed", "rejected", "superseded"]>;
+                            }>;
+                            readonly approval: Schema.TaggedStruct<"approval", {
+                                readonly status: Schema.Literals<readonly ["missing", "pending", "approved", "rejected", "expired"]>;
+                            }>;
+                            readonly check: Schema.TaggedStruct<"check", {
+                                readonly status: Schema.Literals<readonly ["missing", "queued", "running", "passed", "failed", "cancelled"]>;
+                            }>;
+                            readonly execution: Schema.TaggedStruct<"execution", {
+                                readonly status: Schema.Literals<readonly ["missing", "queued", "running", "succeeded", "failed", "stopped"]>;
+                                readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                                    readonly _tag: Schema.tag<"count">;
+                                    readonly completed: Schema.Int;
+                                    readonly total: Schema.Int;
+                                }>, Schema.TaggedStruct<"percent", {
+                                    readonly value: Schema.Number;
+                                }>]>>;
+                            }>;
+                            readonly documentation: Schema.TaggedStruct<"documentation", {
+                                readonly status: Schema.Literals<readonly ["missing", "draft", "current", "stale", "superseded"]>;
+                            }>;
+                            readonly deployment: Schema.TaggedStruct<"deployment", {
+                                readonly status: Schema.Literals<readonly ["not-started", "pending", "deploying", "succeeded", "failed", "rolled-back"]>;
+                                readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                                    readonly _tag: Schema.tag<"count">;
+                                    readonly completed: Schema.Int;
+                                    readonly total: Schema.Int;
+                                }>, Schema.TaggedStruct<"percent", {
+                                    readonly value: Schema.Number;
+                                }>]>>;
+                            }>;
+                        }>;
+                        readonly evidence: Schema.$Array<Schema.Struct<{
+                            readonly evidenceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">;
+                            readonly source: Schema.TaggedUnion<{
+                                readonly plugin: Schema.TaggedStruct<"plugin", {
+                                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                                    readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                                }>;
+                                readonly local: Schema.TaggedStruct<"local", {
+                                    readonly origin: Schema.Literals<readonly ["human", "agent", "system"]>;
+                                }>;
+                            }>;
+                            readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                            readonly validity: Schema.Literals<readonly ["valid", "expired"]>;
+                            readonly reevaluateAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                        }>>;
+                    }>>;
+                    readonly result: Schema.Literals<readonly ["verified", "pending", "failed", "gap", "advisory"]>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly requiredFactIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                readonly verifiedFactIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                readonly assessmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">;
+                readonly previousAssessmentId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">>;
+                readonly rule: Schema.Struct<{
+                    readonly ruleId: Schema.String;
+                    readonly version: Schema.brand<Schema.Int, "ReadinessRuleVersion">;
+                    readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+                }>;
+                readonly derivationVersion: Schema.brand<Schema.Int, "ReadinessDerivationVersion">;
+                readonly evaluatedAt: Schema.DateTimeUtcFromString;
+                readonly nextEvaluationAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                readonly verdict: Schema.Literals<readonly ["blocked", "ready", "deploying", "building", "shipped", "held"]>;
+                readonly stages: Schema.Struct<{
+                    readonly build: Schema.Struct<{
+                        readonly state: Schema.Literals<readonly ["not-started", "queued", "running", "succeeded", "failed", "held"]>;
+                        readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                    readonly verify: Schema.Struct<{
+                        readonly state: Schema.Literals<readonly ["not-started", "pending", "passed", "failed", "held"]>;
+                        readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                    readonly production: Schema.Struct<{
+                        readonly state: Schema.Literals<readonly ["not-started", "waiting", "deploying", "succeeded", "failed", "rolled-back", "held"]>;
+                        readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                }>;
+                readonly blockers: Schema.$Array<Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                    readonly subject: Schema.TaggedUnion<{
+                        readonly source: Schema.TaggedStruct<"source", {
+                            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        }>;
+                        readonly fact: Schema.TaggedStruct<"fact", {
+                            readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        }>;
+                        readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                    }>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly warnings: Schema.$Array<Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                    readonly subject: Schema.TaggedUnion<{
+                        readonly source: Schema.TaggedStruct<"source", {
+                            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        }>;
+                        readonly fact: Schema.TaggedStruct<"fact", {
+                            readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        }>;
+                        readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                    }>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly gaps: Schema.$Array<Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                    readonly subject: Schema.TaggedUnion<{
+                        readonly source: Schema.TaggedStruct<"source", {
+                            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        }>;
+                        readonly fact: Schema.TaggedStruct<"fact", {
+                            readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        }>;
+                        readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                    }>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly sourceFreshness: Schema.$Array<Schema.Struct<{
+                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                    readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>;
+            readonly committedAt: Schema.DateTimeUtcFromString;
+        }, "Type">;
+    } | {
+        _tag: "release";
+        record: Schema.Struct.ReadonlySide<{
+            readonly authority: Schema.Literals<readonly ["authoritative", "pending"]>;
+            readonly headRevision: Schema.brand<Schema.Int, "ReadinessHeadRevision">;
+            readonly assessment: Schema.Struct<{
+                readonly _tag: Schema.Literal<"release">;
+                readonly candidate: Schema.Struct<{
+                    readonly scope: Schema.TaggedStruct<"release", {
+                        readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                    }>;
+                    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                    readonly releaseRevision: Schema.Int;
+                    readonly artifactRevision: Schema.String;
+                    readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+                }>;
+                readonly environments: Schema.NonEmptyArray<Schema.Struct<{
+                    readonly assessmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">;
+                    readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+                    readonly candidateDigest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+                    readonly inputComplete: Schema.Boolean;
+                    readonly facts: Schema.$Array<Schema.Struct<{
+                        readonly definition: Schema.Struct<{
+                            readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                            readonly kind: Schema.Literals<readonly ["relationship", "approval", "check", "execution", "documentation", "deployment"]>;
+                            readonly requirement: Schema.Literals<readonly ["required", "advisory"]>;
+                        }>;
+                        readonly observation: Schema.NullOr<Schema.Struct<{
+                            readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                            readonly state: Schema.TaggedUnion<{
+                                readonly relationship: Schema.TaggedStruct<"relationship", {
+                                    readonly status: Schema.Literals<readonly ["missing", "inferred", "proposed", "verified", "governed", "rejected", "superseded"]>;
+                                }>;
+                                readonly approval: Schema.TaggedStruct<"approval", {
+                                    readonly status: Schema.Literals<readonly ["missing", "pending", "approved", "rejected", "expired"]>;
+                                }>;
+                                readonly check: Schema.TaggedStruct<"check", {
+                                    readonly status: Schema.Literals<readonly ["missing", "queued", "running", "passed", "failed", "cancelled"]>;
+                                }>;
+                                readonly execution: Schema.TaggedStruct<"execution", {
+                                    readonly status: Schema.Literals<readonly ["missing", "queued", "running", "succeeded", "failed", "stopped"]>;
+                                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                                        readonly _tag: Schema.tag<"count">;
+                                        readonly completed: Schema.Int;
+                                        readonly total: Schema.Int;
+                                    }>, Schema.TaggedStruct<"percent", {
+                                        readonly value: Schema.Number;
+                                    }>]>>;
+                                }>;
+                                readonly documentation: Schema.TaggedStruct<"documentation", {
+                                    readonly status: Schema.Literals<readonly ["missing", "draft", "current", "stale", "superseded"]>;
+                                }>;
+                                readonly deployment: Schema.TaggedStruct<"deployment", {
+                                    readonly status: Schema.Literals<readonly ["not-started", "pending", "deploying", "succeeded", "failed", "rolled-back"]>;
+                                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                                        readonly _tag: Schema.tag<"count">;
+                                        readonly completed: Schema.Int;
+                                        readonly total: Schema.Int;
+                                    }>, Schema.TaggedStruct<"percent", {
+                                        readonly value: Schema.Number;
+                                    }>]>>;
+                                }>;
+                            }>;
+                            readonly evidence: Schema.$Array<Schema.Struct<{
+                                readonly evidenceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">;
+                                readonly source: Schema.TaggedUnion<{
+                                    readonly plugin: Schema.TaggedStruct<"plugin", {
+                                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                                        readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                                    }>;
+                                    readonly local: Schema.TaggedStruct<"local", {
+                                        readonly origin: Schema.Literals<readonly ["human", "agent", "system"]>;
+                                    }>;
+                                }>;
+                                readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                                readonly validity: Schema.Literals<readonly ["valid", "expired"]>;
+                                readonly reevaluateAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                            }>>;
+                        }>>;
+                        readonly result: Schema.Literals<readonly ["verified", "pending", "failed", "gap", "advisory"]>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    }>>;
+                    readonly nextEvaluationAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                    readonly verdict: Schema.Literals<readonly ["blocked", "ready", "deploying", "building", "shipped", "held"]>;
+                    readonly stages: Schema.Struct<{
+                        readonly build: Schema.Struct<{
+                            readonly state: Schema.Literals<readonly ["not-started", "queued", "running", "succeeded", "failed", "held"]>;
+                            readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                            readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                                readonly _tag: Schema.tag<"count">;
+                                readonly completed: Schema.Int;
+                                readonly total: Schema.Int;
+                            }>, Schema.TaggedStruct<"percent", {
+                                readonly value: Schema.Number;
+                            }>]>>;
+                        }>;
+                        readonly verify: Schema.Struct<{
+                            readonly state: Schema.Literals<readonly ["not-started", "pending", "passed", "failed", "held"]>;
+                            readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                            readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                                readonly _tag: Schema.tag<"count">;
+                                readonly completed: Schema.Int;
+                                readonly total: Schema.Int;
+                            }>, Schema.TaggedStruct<"percent", {
+                                readonly value: Schema.Number;
+                            }>]>>;
+                        }>;
+                        readonly production: Schema.Struct<{
+                            readonly state: Schema.Literals<readonly ["not-started", "waiting", "deploying", "succeeded", "failed", "rolled-back", "held"]>;
+                            readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                            readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                                readonly _tag: Schema.tag<"count">;
+                                readonly completed: Schema.Int;
+                                readonly total: Schema.Int;
+                            }>, Schema.TaggedStruct<"percent", {
+                                readonly value: Schema.Number;
+                            }>]>>;
+                        }>;
+                    }>;
+                    readonly blockers: Schema.$Array<Schema.Struct<{
+                        readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                        readonly subject: Schema.TaggedUnion<{
+                            readonly source: Schema.TaggedStruct<"source", {
+                                readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                            }>;
+                            readonly fact: Schema.TaggedStruct<"fact", {
+                                readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                            }>;
+                            readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                        }>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    }>>;
+                    readonly warnings: Schema.$Array<Schema.Struct<{
+                        readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                        readonly subject: Schema.TaggedUnion<{
+                            readonly source: Schema.TaggedStruct<"source", {
+                                readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                            }>;
+                            readonly fact: Schema.TaggedStruct<"fact", {
+                                readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                            }>;
+                            readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                        }>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    }>>;
+                    readonly gaps: Schema.$Array<Schema.Struct<{
+                        readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                        readonly subject: Schema.TaggedUnion<{
+                            readonly source: Schema.TaggedStruct<"source", {
+                                readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                            }>;
+                            readonly fact: Schema.TaggedStruct<"fact", {
+                                readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                            }>;
+                            readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                        }>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    }>>;
+                    readonly sourceFreshness: Schema.$Array<Schema.Struct<{
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                        readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    }>>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly assessmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">;
+                readonly previousAssessmentId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">>;
+                readonly rule: Schema.Struct<{
+                    readonly ruleId: Schema.String;
+                    readonly version: Schema.brand<Schema.Int, "ReadinessRuleVersion">;
+                    readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+                }>;
+                readonly derivationVersion: Schema.brand<Schema.Int, "ReadinessDerivationVersion">;
+                readonly evaluatedAt: Schema.DateTimeUtcFromString;
+                readonly nextEvaluationAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                readonly verdict: Schema.Literals<readonly ["blocked", "ready", "deploying", "building", "shipped", "held"]>;
+                readonly stages: Schema.Struct<{
+                    readonly build: Schema.Struct<{
+                        readonly state: Schema.Literals<readonly ["not-started", "queued", "running", "succeeded", "failed", "held"]>;
+                        readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                    readonly verify: Schema.Struct<{
+                        readonly state: Schema.Literals<readonly ["not-started", "pending", "passed", "failed", "held"]>;
+                        readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                    readonly production: Schema.Struct<{
+                        readonly state: Schema.Literals<readonly ["not-started", "waiting", "deploying", "succeeded", "failed", "rolled-back", "held"]>;
+                        readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                }>;
+                readonly blockers: Schema.$Array<Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                    readonly subject: Schema.TaggedUnion<{
+                        readonly source: Schema.TaggedStruct<"source", {
+                            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        }>;
+                        readonly fact: Schema.TaggedStruct<"fact", {
+                            readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        }>;
+                        readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                    }>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly warnings: Schema.$Array<Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                    readonly subject: Schema.TaggedUnion<{
+                        readonly source: Schema.TaggedStruct<"source", {
+                            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        }>;
+                        readonly fact: Schema.TaggedStruct<"fact", {
+                            readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        }>;
+                        readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                    }>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly gaps: Schema.$Array<Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                    readonly subject: Schema.TaggedUnion<{
+                        readonly source: Schema.TaggedStruct<"source", {
+                            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        }>;
+                        readonly fact: Schema.TaggedStruct<"fact", {
+                            readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        }>;
+                        readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                    }>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly sourceFreshness: Schema.$Array<Schema.Struct<{
+                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                    readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>;
+            readonly committedAt: Schema.DateTimeUtcFromString;
+        }, "Type">;
+    }, Schema.SchemaError | PersistenceOperationError | PersistedRecordError | QuarantineWriteError | import("effect/unstable/sql/SqlError").SqlError | ReadinessInputError | MalformedReadinessRecord, Crypto.Crypto>;
+    readCurrentReleases: (input: unknown) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly authority: Schema.Literals<readonly ["authoritative", "pending"]>;
+        readonly headRevision: Schema.brand<Schema.Int, "ReadinessHeadRevision">;
+        readonly assessment: Schema.Struct<{
+            readonly _tag: Schema.Literal<"release">;
+            readonly candidate: Schema.Struct<{
+                readonly scope: Schema.TaggedStruct<"release", {
+                    readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                }>;
+                readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                readonly releaseRevision: Schema.Int;
+                readonly artifactRevision: Schema.String;
+                readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+            }>;
+            readonly environments: Schema.NonEmptyArray<Schema.Struct<{
+                readonly assessmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">;
+                readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+                readonly candidateDigest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+                readonly inputComplete: Schema.Boolean;
+                readonly facts: Schema.$Array<Schema.Struct<{
+                    readonly definition: Schema.Struct<{
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        readonly kind: Schema.Literals<readonly ["relationship", "approval", "check", "execution", "documentation", "deployment"]>;
+                        readonly requirement: Schema.Literals<readonly ["required", "advisory"]>;
+                    }>;
+                    readonly observation: Schema.NullOr<Schema.Struct<{
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        readonly state: Schema.TaggedUnion<{
+                            readonly relationship: Schema.TaggedStruct<"relationship", {
+                                readonly status: Schema.Literals<readonly ["missing", "inferred", "proposed", "verified", "governed", "rejected", "superseded"]>;
+                            }>;
+                            readonly approval: Schema.TaggedStruct<"approval", {
+                                readonly status: Schema.Literals<readonly ["missing", "pending", "approved", "rejected", "expired"]>;
+                            }>;
+                            readonly check: Schema.TaggedStruct<"check", {
+                                readonly status: Schema.Literals<readonly ["missing", "queued", "running", "passed", "failed", "cancelled"]>;
+                            }>;
+                            readonly execution: Schema.TaggedStruct<"execution", {
+                                readonly status: Schema.Literals<readonly ["missing", "queued", "running", "succeeded", "failed", "stopped"]>;
+                                readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                                    readonly _tag: Schema.tag<"count">;
+                                    readonly completed: Schema.Int;
+                                    readonly total: Schema.Int;
+                                }>, Schema.TaggedStruct<"percent", {
+                                    readonly value: Schema.Number;
+                                }>]>>;
+                            }>;
+                            readonly documentation: Schema.TaggedStruct<"documentation", {
+                                readonly status: Schema.Literals<readonly ["missing", "draft", "current", "stale", "superseded"]>;
+                            }>;
+                            readonly deployment: Schema.TaggedStruct<"deployment", {
+                                readonly status: Schema.Literals<readonly ["not-started", "pending", "deploying", "succeeded", "failed", "rolled-back"]>;
+                                readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                                    readonly _tag: Schema.tag<"count">;
+                                    readonly completed: Schema.Int;
+                                    readonly total: Schema.Int;
+                                }>, Schema.TaggedStruct<"percent", {
+                                    readonly value: Schema.Number;
+                                }>]>>;
+                            }>;
+                        }>;
+                        readonly evidence: Schema.$Array<Schema.Struct<{
+                            readonly evidenceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">;
+                            readonly source: Schema.TaggedUnion<{
+                                readonly plugin: Schema.TaggedStruct<"plugin", {
+                                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                                    readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                                }>;
+                                readonly local: Schema.TaggedStruct<"local", {
+                                    readonly origin: Schema.Literals<readonly ["human", "agent", "system"]>;
+                                }>;
+                            }>;
+                            readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                            readonly validity: Schema.Literals<readonly ["valid", "expired"]>;
+                            readonly reevaluateAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                        }>>;
+                    }>>;
+                    readonly result: Schema.Literals<readonly ["verified", "pending", "failed", "gap", "advisory"]>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly nextEvaluationAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                readonly verdict: Schema.Literals<readonly ["blocked", "ready", "deploying", "building", "shipped", "held"]>;
+                readonly stages: Schema.Struct<{
+                    readonly build: Schema.Struct<{
+                        readonly state: Schema.Literals<readonly ["not-started", "queued", "running", "succeeded", "failed", "held"]>;
+                        readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                    readonly verify: Schema.Struct<{
+                        readonly state: Schema.Literals<readonly ["not-started", "pending", "passed", "failed", "held"]>;
+                        readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                    readonly production: Schema.Struct<{
+                        readonly state: Schema.Literals<readonly ["not-started", "waiting", "deploying", "succeeded", "failed", "rolled-back", "held"]>;
+                        readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                }>;
+                readonly blockers: Schema.$Array<Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                    readonly subject: Schema.TaggedUnion<{
+                        readonly source: Schema.TaggedStruct<"source", {
+                            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        }>;
+                        readonly fact: Schema.TaggedStruct<"fact", {
+                            readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        }>;
+                        readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                    }>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly warnings: Schema.$Array<Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                    readonly subject: Schema.TaggedUnion<{
+                        readonly source: Schema.TaggedStruct<"source", {
+                            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        }>;
+                        readonly fact: Schema.TaggedStruct<"fact", {
+                            readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        }>;
+                        readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                    }>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly gaps: Schema.$Array<Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                    readonly subject: Schema.TaggedUnion<{
+                        readonly source: Schema.TaggedStruct<"source", {
+                            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        }>;
+                        readonly fact: Schema.TaggedStruct<"fact", {
+                            readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        }>;
+                        readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                    }>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly sourceFreshness: Schema.$Array<Schema.Struct<{
+                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                    readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly assessmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">;
+            readonly previousAssessmentId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">>;
+            readonly rule: Schema.Struct<{
+                readonly ruleId: Schema.String;
+                readonly version: Schema.brand<Schema.Int, "ReadinessRuleVersion">;
+                readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+            }>;
+            readonly derivationVersion: Schema.brand<Schema.Int, "ReadinessDerivationVersion">;
+            readonly evaluatedAt: Schema.DateTimeUtcFromString;
+            readonly nextEvaluationAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+            readonly verdict: Schema.Literals<readonly ["blocked", "ready", "deploying", "building", "shipped", "held"]>;
+            readonly stages: Schema.Struct<{
+                readonly build: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["not-started", "queued", "running", "succeeded", "failed", "held"]>;
+                    readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"count">;
+                        readonly completed: Schema.Int;
+                        readonly total: Schema.Int;
+                    }>, Schema.TaggedStruct<"percent", {
+                        readonly value: Schema.Number;
+                    }>]>>;
+                }>;
+                readonly verify: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["not-started", "pending", "passed", "failed", "held"]>;
+                    readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"count">;
+                        readonly completed: Schema.Int;
+                        readonly total: Schema.Int;
+                    }>, Schema.TaggedStruct<"percent", {
+                        readonly value: Schema.Number;
+                    }>]>>;
+                }>;
+                readonly production: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["not-started", "waiting", "deploying", "succeeded", "failed", "rolled-back", "held"]>;
+                    readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"count">;
+                        readonly completed: Schema.Int;
+                        readonly total: Schema.Int;
+                    }>, Schema.TaggedStruct<"percent", {
+                        readonly value: Schema.Number;
+                    }>]>>;
+                }>;
+            }>;
+            readonly blockers: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                readonly subject: Schema.TaggedUnion<{
+                    readonly source: Schema.TaggedStruct<"source", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly fact: Schema.TaggedStruct<"fact", {
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    }>;
+                    readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                }>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly warnings: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                readonly subject: Schema.TaggedUnion<{
+                    readonly source: Schema.TaggedStruct<"source", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly fact: Schema.TaggedStruct<"fact", {
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    }>;
+                    readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                }>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly gaps: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                readonly subject: Schema.TaggedUnion<{
+                    readonly source: Schema.TaggedStruct<"source", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly fact: Schema.TaggedStruct<"fact", {
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    }>;
+                    readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                }>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly sourceFreshness: Schema.$Array<Schema.Struct<{
+                readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+        }>;
+        readonly committedAt: Schema.DateTimeUtcFromString;
+    }, "Type">[], Schema.SchemaError | PersistenceOperationError | PersistedRecordError | QuarantineWriteError | import("effect/unstable/sql/SqlError").SqlError | ReadinessInputError | MalformedReadinessRecord, Crypto.Crypto>;
+    readHistory: (input: unknown) => Effect.Effect<{
+        _tag: "environment";
+        records: Schema.Struct.ReadonlySide<{
+            readonly headRevision: Schema.brand<Schema.Int, "ReadinessHeadRevision">;
+            readonly assessment: Schema.Struct<{
+                readonly _tag: Schema.Literal<"environment">;
+                readonly candidate: Schema.Struct<{
+                    readonly scope: Schema.TaggedStruct<"environment", {
+                        readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                        readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+                    }>;
+                    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                    readonly releaseRevision: Schema.Int;
+                    readonly artifactRevision: Schema.String;
+                    readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+                }>;
+                readonly inputComplete: Schema.Boolean;
+                readonly facts: Schema.$Array<Schema.Struct<{
+                    readonly definition: Schema.Struct<{
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        readonly kind: Schema.Literals<readonly ["relationship", "approval", "check", "execution", "documentation", "deployment"]>;
+                        readonly requirement: Schema.Literals<readonly ["required", "advisory"]>;
+                    }>;
+                    readonly observation: Schema.NullOr<Schema.Struct<{
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        readonly state: Schema.TaggedUnion<{
+                            readonly relationship: Schema.TaggedStruct<"relationship", {
+                                readonly status: Schema.Literals<readonly ["missing", "inferred", "proposed", "verified", "governed", "rejected", "superseded"]>;
+                            }>;
+                            readonly approval: Schema.TaggedStruct<"approval", {
+                                readonly status: Schema.Literals<readonly ["missing", "pending", "approved", "rejected", "expired"]>;
+                            }>;
+                            readonly check: Schema.TaggedStruct<"check", {
+                                readonly status: Schema.Literals<readonly ["missing", "queued", "running", "passed", "failed", "cancelled"]>;
+                            }>;
+                            readonly execution: Schema.TaggedStruct<"execution", {
+                                readonly status: Schema.Literals<readonly ["missing", "queued", "running", "succeeded", "failed", "stopped"]>;
+                                readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                                    readonly _tag: Schema.tag<"count">;
+                                    readonly completed: Schema.Int;
+                                    readonly total: Schema.Int;
+                                }>, Schema.TaggedStruct<"percent", {
+                                    readonly value: Schema.Number;
+                                }>]>>;
+                            }>;
+                            readonly documentation: Schema.TaggedStruct<"documentation", {
+                                readonly status: Schema.Literals<readonly ["missing", "draft", "current", "stale", "superseded"]>;
+                            }>;
+                            readonly deployment: Schema.TaggedStruct<"deployment", {
+                                readonly status: Schema.Literals<readonly ["not-started", "pending", "deploying", "succeeded", "failed", "rolled-back"]>;
+                                readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                                    readonly _tag: Schema.tag<"count">;
+                                    readonly completed: Schema.Int;
+                                    readonly total: Schema.Int;
+                                }>, Schema.TaggedStruct<"percent", {
+                                    readonly value: Schema.Number;
+                                }>]>>;
+                            }>;
+                        }>;
+                        readonly evidence: Schema.$Array<Schema.Struct<{
+                            readonly evidenceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">;
+                            readonly source: Schema.TaggedUnion<{
+                                readonly plugin: Schema.TaggedStruct<"plugin", {
+                                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                                    readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                                }>;
+                                readonly local: Schema.TaggedStruct<"local", {
+                                    readonly origin: Schema.Literals<readonly ["human", "agent", "system"]>;
+                                }>;
+                            }>;
+                            readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                            readonly validity: Schema.Literals<readonly ["valid", "expired"]>;
+                            readonly reevaluateAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                        }>>;
+                    }>>;
+                    readonly result: Schema.Literals<readonly ["verified", "pending", "failed", "gap", "advisory"]>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly requiredFactIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                readonly verifiedFactIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                readonly assessmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">;
+                readonly previousAssessmentId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">>;
+                readonly rule: Schema.Struct<{
+                    readonly ruleId: Schema.String;
+                    readonly version: Schema.brand<Schema.Int, "ReadinessRuleVersion">;
+                    readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+                }>;
+                readonly derivationVersion: Schema.brand<Schema.Int, "ReadinessDerivationVersion">;
+                readonly evaluatedAt: Schema.DateTimeUtcFromString;
+                readonly nextEvaluationAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                readonly verdict: Schema.Literals<readonly ["blocked", "ready", "deploying", "building", "shipped", "held"]>;
+                readonly stages: Schema.Struct<{
+                    readonly build: Schema.Struct<{
+                        readonly state: Schema.Literals<readonly ["not-started", "queued", "running", "succeeded", "failed", "held"]>;
+                        readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                    readonly verify: Schema.Struct<{
+                        readonly state: Schema.Literals<readonly ["not-started", "pending", "passed", "failed", "held"]>;
+                        readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                    readonly production: Schema.Struct<{
+                        readonly state: Schema.Literals<readonly ["not-started", "waiting", "deploying", "succeeded", "failed", "rolled-back", "held"]>;
+                        readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                }>;
+                readonly blockers: Schema.$Array<Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                    readonly subject: Schema.TaggedUnion<{
+                        readonly source: Schema.TaggedStruct<"source", {
+                            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        }>;
+                        readonly fact: Schema.TaggedStruct<"fact", {
+                            readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        }>;
+                        readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                    }>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly warnings: Schema.$Array<Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                    readonly subject: Schema.TaggedUnion<{
+                        readonly source: Schema.TaggedStruct<"source", {
+                            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        }>;
+                        readonly fact: Schema.TaggedStruct<"fact", {
+                            readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        }>;
+                        readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                    }>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly gaps: Schema.$Array<Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                    readonly subject: Schema.TaggedUnion<{
+                        readonly source: Schema.TaggedStruct<"source", {
+                            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        }>;
+                        readonly fact: Schema.TaggedStruct<"fact", {
+                            readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        }>;
+                        readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                    }>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly sourceFreshness: Schema.$Array<Schema.Struct<{
+                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                    readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>;
+            readonly committedAt: Schema.DateTimeUtcFromString;
+        }, "Type">[];
+        nextBeforeHeadRevision: (number & import("effect/Brand").Brand<"ReadinessHeadRevision">) | null;
+    } | {
+        _tag: "release";
+        records: Schema.Struct.ReadonlySide<{
+            readonly headRevision: Schema.brand<Schema.Int, "ReadinessHeadRevision">;
+            readonly assessment: Schema.Struct<{
+                readonly _tag: Schema.Literal<"release">;
+                readonly candidate: Schema.Struct<{
+                    readonly scope: Schema.TaggedStruct<"release", {
+                        readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                    }>;
+                    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                    readonly releaseRevision: Schema.Int;
+                    readonly artifactRevision: Schema.String;
+                    readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+                }>;
+                readonly environments: Schema.NonEmptyArray<Schema.Struct<{
+                    readonly assessmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">;
+                    readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+                    readonly candidateDigest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+                    readonly inputComplete: Schema.Boolean;
+                    readonly facts: Schema.$Array<Schema.Struct<{
+                        readonly definition: Schema.Struct<{
+                            readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                            readonly kind: Schema.Literals<readonly ["relationship", "approval", "check", "execution", "documentation", "deployment"]>;
+                            readonly requirement: Schema.Literals<readonly ["required", "advisory"]>;
+                        }>;
+                        readonly observation: Schema.NullOr<Schema.Struct<{
+                            readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                            readonly state: Schema.TaggedUnion<{
+                                readonly relationship: Schema.TaggedStruct<"relationship", {
+                                    readonly status: Schema.Literals<readonly ["missing", "inferred", "proposed", "verified", "governed", "rejected", "superseded"]>;
+                                }>;
+                                readonly approval: Schema.TaggedStruct<"approval", {
+                                    readonly status: Schema.Literals<readonly ["missing", "pending", "approved", "rejected", "expired"]>;
+                                }>;
+                                readonly check: Schema.TaggedStruct<"check", {
+                                    readonly status: Schema.Literals<readonly ["missing", "queued", "running", "passed", "failed", "cancelled"]>;
+                                }>;
+                                readonly execution: Schema.TaggedStruct<"execution", {
+                                    readonly status: Schema.Literals<readonly ["missing", "queued", "running", "succeeded", "failed", "stopped"]>;
+                                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                                        readonly _tag: Schema.tag<"count">;
+                                        readonly completed: Schema.Int;
+                                        readonly total: Schema.Int;
+                                    }>, Schema.TaggedStruct<"percent", {
+                                        readonly value: Schema.Number;
+                                    }>]>>;
+                                }>;
+                                readonly documentation: Schema.TaggedStruct<"documentation", {
+                                    readonly status: Schema.Literals<readonly ["missing", "draft", "current", "stale", "superseded"]>;
+                                }>;
+                                readonly deployment: Schema.TaggedStruct<"deployment", {
+                                    readonly status: Schema.Literals<readonly ["not-started", "pending", "deploying", "succeeded", "failed", "rolled-back"]>;
+                                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                                        readonly _tag: Schema.tag<"count">;
+                                        readonly completed: Schema.Int;
+                                        readonly total: Schema.Int;
+                                    }>, Schema.TaggedStruct<"percent", {
+                                        readonly value: Schema.Number;
+                                    }>]>>;
+                                }>;
+                            }>;
+                            readonly evidence: Schema.$Array<Schema.Struct<{
+                                readonly evidenceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">;
+                                readonly source: Schema.TaggedUnion<{
+                                    readonly plugin: Schema.TaggedStruct<"plugin", {
+                                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                                        readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                                    }>;
+                                    readonly local: Schema.TaggedStruct<"local", {
+                                        readonly origin: Schema.Literals<readonly ["human", "agent", "system"]>;
+                                    }>;
+                                }>;
+                                readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                                readonly validity: Schema.Literals<readonly ["valid", "expired"]>;
+                                readonly reevaluateAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                            }>>;
+                        }>>;
+                        readonly result: Schema.Literals<readonly ["verified", "pending", "failed", "gap", "advisory"]>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    }>>;
+                    readonly nextEvaluationAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                    readonly verdict: Schema.Literals<readonly ["blocked", "ready", "deploying", "building", "shipped", "held"]>;
+                    readonly stages: Schema.Struct<{
+                        readonly build: Schema.Struct<{
+                            readonly state: Schema.Literals<readonly ["not-started", "queued", "running", "succeeded", "failed", "held"]>;
+                            readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                            readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                                readonly _tag: Schema.tag<"count">;
+                                readonly completed: Schema.Int;
+                                readonly total: Schema.Int;
+                            }>, Schema.TaggedStruct<"percent", {
+                                readonly value: Schema.Number;
+                            }>]>>;
+                        }>;
+                        readonly verify: Schema.Struct<{
+                            readonly state: Schema.Literals<readonly ["not-started", "pending", "passed", "failed", "held"]>;
+                            readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                            readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                                readonly _tag: Schema.tag<"count">;
+                                readonly completed: Schema.Int;
+                                readonly total: Schema.Int;
+                            }>, Schema.TaggedStruct<"percent", {
+                                readonly value: Schema.Number;
+                            }>]>>;
+                        }>;
+                        readonly production: Schema.Struct<{
+                            readonly state: Schema.Literals<readonly ["not-started", "waiting", "deploying", "succeeded", "failed", "rolled-back", "held"]>;
+                            readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                            readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                                readonly _tag: Schema.tag<"count">;
+                                readonly completed: Schema.Int;
+                                readonly total: Schema.Int;
+                            }>, Schema.TaggedStruct<"percent", {
+                                readonly value: Schema.Number;
+                            }>]>>;
+                        }>;
+                    }>;
+                    readonly blockers: Schema.$Array<Schema.Struct<{
+                        readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                        readonly subject: Schema.TaggedUnion<{
+                            readonly source: Schema.TaggedStruct<"source", {
+                                readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                            }>;
+                            readonly fact: Schema.TaggedStruct<"fact", {
+                                readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                            }>;
+                            readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                        }>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    }>>;
+                    readonly warnings: Schema.$Array<Schema.Struct<{
+                        readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                        readonly subject: Schema.TaggedUnion<{
+                            readonly source: Schema.TaggedStruct<"source", {
+                                readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                            }>;
+                            readonly fact: Schema.TaggedStruct<"fact", {
+                                readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                            }>;
+                            readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                        }>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    }>>;
+                    readonly gaps: Schema.$Array<Schema.Struct<{
+                        readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                        readonly subject: Schema.TaggedUnion<{
+                            readonly source: Schema.TaggedStruct<"source", {
+                                readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                            }>;
+                            readonly fact: Schema.TaggedStruct<"fact", {
+                                readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                            }>;
+                            readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                        }>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    }>>;
+                    readonly sourceFreshness: Schema.$Array<Schema.Struct<{
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                        readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    }>>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly assessmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">;
+                readonly previousAssessmentId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">>;
+                readonly rule: Schema.Struct<{
+                    readonly ruleId: Schema.String;
+                    readonly version: Schema.brand<Schema.Int, "ReadinessRuleVersion">;
+                    readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+                }>;
+                readonly derivationVersion: Schema.brand<Schema.Int, "ReadinessDerivationVersion">;
+                readonly evaluatedAt: Schema.DateTimeUtcFromString;
+                readonly nextEvaluationAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                readonly verdict: Schema.Literals<readonly ["blocked", "ready", "deploying", "building", "shipped", "held"]>;
+                readonly stages: Schema.Struct<{
+                    readonly build: Schema.Struct<{
+                        readonly state: Schema.Literals<readonly ["not-started", "queued", "running", "succeeded", "failed", "held"]>;
+                        readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                    readonly verify: Schema.Struct<{
+                        readonly state: Schema.Literals<readonly ["not-started", "pending", "passed", "failed", "held"]>;
+                        readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                    readonly production: Schema.Struct<{
+                        readonly state: Schema.Literals<readonly ["not-started", "waiting", "deploying", "succeeded", "failed", "rolled-back", "held"]>;
+                        readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                }>;
+                readonly blockers: Schema.$Array<Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                    readonly subject: Schema.TaggedUnion<{
+                        readonly source: Schema.TaggedStruct<"source", {
+                            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        }>;
+                        readonly fact: Schema.TaggedStruct<"fact", {
+                            readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        }>;
+                        readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                    }>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly warnings: Schema.$Array<Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                    readonly subject: Schema.TaggedUnion<{
+                        readonly source: Schema.TaggedStruct<"source", {
+                            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        }>;
+                        readonly fact: Schema.TaggedStruct<"fact", {
+                            readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        }>;
+                        readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                    }>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly gaps: Schema.$Array<Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                    readonly subject: Schema.TaggedUnion<{
+                        readonly source: Schema.TaggedStruct<"source", {
+                            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        }>;
+                        readonly fact: Schema.TaggedStruct<"fact", {
+                            readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        }>;
+                        readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                    }>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly sourceFreshness: Schema.$Array<Schema.Struct<{
+                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                    readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>;
+            readonly committedAt: Schema.DateTimeUtcFromString;
+        }, "Type">[];
+        nextBeforeHeadRevision: (number & import("effect/Brand").Brand<"ReadinessHeadRevision">) | null;
+    }, Schema.SchemaError | PersistenceOperationError | PersistedRecordError | QuarantineWriteError | import("effect/unstable/sql/SqlError").SqlError | ReadinessInputError | MalformedReadinessRecord, Crypto.Crypto>;
+    registerRule: (input: unknown) => Effect.Effect<{
+        _tag: "created";
+        record: {
+            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">;
+            workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">;
+            digest: string & import("effect/Brand").Brand<"ReadinessCandidateDigest">;
+            registeredAt: DateTime.Utc;
+        };
+    } | {
+        _tag: "existing";
+        record: {
+            workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">;
+            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">;
+            digest: string & import("effect/Brand").Brand<"ReadinessCandidateDigest">;
+            registeredAt: DateTime.Utc;
+        };
+    }, unknown, Crypto.Crypto>;
+}, never, Crypto.Crypto | Database | QuarantineRepository>;
+/** Deep persistence interface for digest-bound readiness assessments and reevaluation work. */
+export interface ReadinessRepositoryService extends Success<typeof makeReadinessRepository> {
+}
+declare const ReadinessRepository_base: Context.ServiceClass<ReadinessRepository, "@knpkv/control-center/ReadinessRepository", ReadinessRepositoryService>;
+/** Effect service binding readiness audit records, current heads, schedules, and queues. */
+export declare class ReadinessRepository extends ReadinessRepository_base {
+    static readonly layer: Layer.Layer<ReadinessRepository, never, Crypto.Crypto | Database | QuarantineRepository>;
+}
+//# sourceMappingURL=readinessRepository.d.ts.map