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

@knpkv/control-center 0.1.0

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

Files changed (664) hide show

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

@@ -0,0 +1,3315 @@
+import * as Schema from "effect/Schema";
+/** Positive optimistic-concurrency revision of one readiness-assessment head. */
+export declare const ReadinessHeadRevision: Schema.brand<Schema.Int, "ReadinessHeadRevision">;
+/** Decoded readiness-assessment head revision. */
+export type ReadinessHeadRevision = typeof ReadinessHeadRevision.Type;
+/** Positive monotonic revision of one coalesced readiness invalidation. */
+export declare const ReadinessInvalidationRevision: Schema.brand<Schema.Int, "ReadinessInvalidationRevision">;
+/** Decoded readiness-invalidation revision. */
+export type ReadinessInvalidationRevision = typeof ReadinessInvalidationRevision.Type;
+/** Stable identity of one readiness-invalidation worker lease. */
+export declare const ReadinessLeaseOwner: Schema.brand<Schema.String, "ReadinessLeaseOwner">;
+/** Decoded readiness lease-owner identity. */
+export type ReadinessLeaseOwner = typeof ReadinessLeaseOwner.Type;
+/** Storage-generated fencing token for one exact readiness lease generation. */
+export declare const ReadinessLeaseToken: Schema.brand<Schema.String, "ReadinessLeaseToken">;
+/** Decoded readiness lease fencing token. */
+export type ReadinessLeaseToken = typeof ReadinessLeaseToken.Type;
+/** Closed machine-readable reason for reevaluating readiness. */
+export declare const ReadinessInvalidationReason: Schema.Literals<readonly ["evidence-changed", "plugin-health-changed", "rule-changed", "candidate-changed", "scheduled", "environment-assessment-changed"]>;
+/** Decoded readiness-invalidation reason. */
+export type ReadinessInvalidationReason = typeof ReadinessInvalidationReason.Type;
+/** Bounded number of immutable assessments returned by one history read. */
+export declare const ReadinessHistoryLimit: Schema.brand<Schema.Int, "ReadinessHistoryLimit">;
+/** Decoded readiness-history page size. */
+export type ReadinessHistoryLimit = typeof ReadinessHistoryLimit.Type;
+declare const ReadinessInputError_base: Schema.Class<ReadinessInputError, Schema.TaggedStruct<"ReadinessInputError", {
+    readonly operation: Schema.Literals<readonly ["register-rule", "commit-environment", "commit-release", "read-current", "read-current-releases", "read-history", "enqueue-invalidation", "claim-invalidation", "enqueue-affected", "enqueue-due"]>;
+    readonly reason: Schema.Literals<readonly ["invalid-request", "candidate-digest-mismatch", "rule-digest-mismatch", "rule-definition-mismatch", "stale-invalidation"]>;
+}>, import("effect/Cause").YieldableError>;
+/** Bounded caller or integrity failure at the readiness repository boundary. */
+export declare class ReadinessInputError extends ReadinessInputError_base {
+}
+/** Immutable, digest-bound readiness rule stored within one workspace. */
+export declare const ReadinessRuleRecord: Schema.Struct<{
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+    readonly material: Schema.Struct<{
+        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"]>;
+        }>>;
+    }>;
+    readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+    readonly registeredAt: Schema.DateTimeUtcFromString;
+}>;
+/** Decoded persisted readiness-rule record. */
+export type ReadinessRuleRecord = typeof ReadinessRuleRecord.Type;
+/** Request to idempotently register one immutable readiness-rule snapshot. */
+export declare const RegisterReadinessRuleRequest: Schema.Struct<{
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+    readonly material: Schema.Struct<{
+        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"]>;
+        }>>;
+    }>;
+    readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+    readonly registeredAt: Schema.DateTimeUtcFromString;
+}>;
+/** Decoded immutable readiness-rule registration request. */
+export type RegisterReadinessRuleRequest = typeof RegisterReadinessRuleRequest.Type;
+/** Outcome of registering an immutable rule or finding its exact existing record. */
+export declare const RegisterReadinessRuleResult: Schema.TaggedUnion<{
+    readonly created: Schema.TaggedStruct<"created", {
+        readonly record: Schema.Struct<{
+            readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            readonly material: Schema.Struct<{
+                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"]>;
+                }>>;
+            }>;
+            readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+            readonly registeredAt: Schema.DateTimeUtcFromString;
+        }>;
+    }>;
+    readonly existing: Schema.TaggedStruct<"existing", {
+        readonly record: Schema.Struct<{
+            readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            readonly material: Schema.Struct<{
+                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"]>;
+                }>>;
+            }>;
+            readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+            readonly registeredAt: Schema.DateTimeUtcFromString;
+        }>;
+    }>;
+}>;
+/** Decoded immutable readiness-rule registration outcome. */
+export type RegisterReadinessRuleResult = typeof RegisterReadinessRuleResult.Type;
+/** Persisted immutable environment assessment at one subject-head revision. */
+export declare const EnvironmentReadinessAssessmentRecord: Schema.Struct<{
+    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;
+}>;
+/** Decoded persisted environment-readiness assessment. */
+export type EnvironmentReadinessAssessmentRecord = typeof EnvironmentReadinessAssessmentRecord.Type;
+/** Persisted immutable release assessment at one subject-head revision. */
+export declare const ReleaseReadinessAssessmentRecord: Schema.Struct<{
+    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;
+}>;
+/** Decoded persisted release-readiness assessment. */
+export type ReleaseReadinessAssessmentRecord = typeof ReleaseReadinessAssessmentRecord.Type;
+/** Exact leased invalidation a worker must consume with its assessment commit. */
+export declare const ReadinessCommitLease: Schema.Struct<{
+    readonly invalidationRevision: Schema.brand<Schema.Int, "ReadinessInvalidationRevision">;
+    readonly leaseOwner: Schema.brand<Schema.String, "ReadinessLeaseOwner">;
+    readonly leaseToken: Schema.brand<Schema.String, "ReadinessLeaseToken">;
+}>;
+/** Decoded exact leased invalidation used by a readiness commit. */
+export type ReadinessCommitLease = typeof ReadinessCommitLease.Type;
+/** Compare-and-swap request for an immutable environment assessment. */
+export declare const CommitEnvironmentReadinessAssessmentRequest: Schema.Struct<{
+    readonly expectedHeadRevision: Schema.NullOr<Schema.brand<Schema.Int, "ReadinessHeadRevision">>;
+    readonly invalidation: Schema.NullOr<Schema.Struct<{
+        readonly invalidationRevision: Schema.brand<Schema.Int, "ReadinessInvalidationRevision">;
+        readonly leaseOwner: Schema.brand<Schema.String, "ReadinessLeaseOwner">;
+        readonly leaseToken: Schema.brand<Schema.String, "ReadinessLeaseToken">;
+    }>>;
+    readonly assessment: Schema.Struct<{
+        readonly _tag: Schema.Literal<"environment">;
+        readonly candidate: Schema.Struct<{
+            readonly scope: Schema.TaggedStruct<"environment", {
+                readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+            }>;
+            readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            readonly releaseRevision: Schema.Int;
+            readonly artifactRevision: Schema.String;
+            readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+        }>;
+        readonly inputComplete: Schema.Boolean;
+        readonly facts: Schema.$Array<Schema.Struct<{
+            readonly definition: Schema.Struct<{
+                readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                readonly kind: Schema.Literals<readonly ["relationship", "approval", "check", "execution", "documentation", "deployment"]>;
+                readonly requirement: Schema.Literals<readonly ["required", "advisory"]>;
+            }>;
+            readonly observation: Schema.NullOr<Schema.Struct<{
+                readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                readonly state: Schema.TaggedUnion<{
+                    readonly relationship: Schema.TaggedStruct<"relationship", {
+                        readonly status: Schema.Literals<readonly ["missing", "inferred", "proposed", "verified", "governed", "rejected", "superseded"]>;
+                    }>;
+                    readonly approval: Schema.TaggedStruct<"approval", {
+                        readonly status: Schema.Literals<readonly ["missing", "pending", "approved", "rejected", "expired"]>;
+                    }>;
+                    readonly check: Schema.TaggedStruct<"check", {
+                        readonly status: Schema.Literals<readonly ["missing", "queued", "running", "passed", "failed", "cancelled"]>;
+                    }>;
+                    readonly execution: Schema.TaggedStruct<"execution", {
+                        readonly status: Schema.Literals<readonly ["missing", "queued", "running", "succeeded", "failed", "stopped"]>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                    readonly documentation: Schema.TaggedStruct<"documentation", {
+                        readonly status: Schema.Literals<readonly ["missing", "draft", "current", "stale", "superseded"]>;
+                    }>;
+                    readonly deployment: Schema.TaggedStruct<"deployment", {
+                        readonly status: Schema.Literals<readonly ["not-started", "pending", "deploying", "succeeded", "failed", "rolled-back"]>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                }>;
+                readonly evidence: Schema.$Array<Schema.Struct<{
+                    readonly evidenceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">;
+                    readonly source: Schema.TaggedUnion<{
+                        readonly plugin: Schema.TaggedStruct<"plugin", {
+                            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                            readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                        }>;
+                        readonly local: Schema.TaggedStruct<"local", {
+                            readonly origin: Schema.Literals<readonly ["human", "agent", "system"]>;
+                        }>;
+                    }>;
+                    readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                    readonly validity: Schema.Literals<readonly ["valid", "expired"]>;
+                    readonly reevaluateAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                }>>;
+            }>>;
+            readonly result: Schema.Literals<readonly ["verified", "pending", "failed", "gap", "advisory"]>;
+            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+        }>>;
+        readonly requiredFactIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+        readonly verifiedFactIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+        readonly assessmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">;
+        readonly previousAssessmentId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">>;
+        readonly rule: Schema.Struct<{
+            readonly ruleId: Schema.String;
+            readonly version: Schema.brand<Schema.Int, "ReadinessRuleVersion">;
+            readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+        }>;
+        readonly derivationVersion: Schema.brand<Schema.Int, "ReadinessDerivationVersion">;
+        readonly evaluatedAt: Schema.DateTimeUtcFromString;
+        readonly nextEvaluationAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+        readonly verdict: Schema.Literals<readonly ["blocked", "ready", "deploying", "building", "shipped", "held"]>;
+        readonly stages: Schema.Struct<{
+            readonly build: Schema.Struct<{
+                readonly state: Schema.Literals<readonly ["not-started", "queued", "running", "succeeded", "failed", "held"]>;
+                readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                    readonly _tag: Schema.tag<"count">;
+                    readonly completed: Schema.Int;
+                    readonly total: Schema.Int;
+                }>, Schema.TaggedStruct<"percent", {
+                    readonly value: Schema.Number;
+                }>]>>;
+            }>;
+            readonly verify: Schema.Struct<{
+                readonly state: Schema.Literals<readonly ["not-started", "pending", "passed", "failed", "held"]>;
+                readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                    readonly _tag: Schema.tag<"count">;
+                    readonly completed: Schema.Int;
+                    readonly total: Schema.Int;
+                }>, Schema.TaggedStruct<"percent", {
+                    readonly value: Schema.Number;
+                }>]>>;
+            }>;
+            readonly production: Schema.Struct<{
+                readonly state: Schema.Literals<readonly ["not-started", "waiting", "deploying", "succeeded", "failed", "rolled-back", "held"]>;
+                readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                    readonly _tag: Schema.tag<"count">;
+                    readonly completed: Schema.Int;
+                    readonly total: Schema.Int;
+                }>, Schema.TaggedStruct<"percent", {
+                    readonly value: Schema.Number;
+                }>]>>;
+            }>;
+        }>;
+        readonly blockers: Schema.$Array<Schema.Struct<{
+            readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+            readonly subject: Schema.TaggedUnion<{
+                readonly source: Schema.TaggedStruct<"source", {
+                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                }>;
+                readonly fact: Schema.TaggedStruct<"fact", {
+                    readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                }>;
+                readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+            }>;
+            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+        }>>;
+        readonly warnings: Schema.$Array<Schema.Struct<{
+            readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+            readonly subject: Schema.TaggedUnion<{
+                readonly source: Schema.TaggedStruct<"source", {
+                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                }>;
+                readonly fact: Schema.TaggedStruct<"fact", {
+                    readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                }>;
+                readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+            }>;
+            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+        }>>;
+        readonly gaps: Schema.$Array<Schema.Struct<{
+            readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+            readonly subject: Schema.TaggedUnion<{
+                readonly source: Schema.TaggedStruct<"source", {
+                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                }>;
+                readonly fact: Schema.TaggedStruct<"fact", {
+                    readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                }>;
+                readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+            }>;
+            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+        }>>;
+        readonly sourceFreshness: Schema.$Array<Schema.Struct<{
+            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+            readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+            readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+        }>>;
+        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+    }>;
+}>;
+/** Decoded environment-readiness commit request. */
+export type CommitEnvironmentReadinessAssessmentRequest = typeof CommitEnvironmentReadinessAssessmentRequest.Type;
+/** Environment-readiness record committed at the new head revision. */
+export declare const CommitEnvironmentReadinessAssessmentResult: Schema.Struct<{
+    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;
+}>;
+/** Decoded environment-readiness commit result. */
+export type CommitEnvironmentReadinessAssessmentResult = typeof CommitEnvironmentReadinessAssessmentResult.Type;
+/** Compare-and-swap request for an immutable release assessment. */
+export declare const CommitReleaseReadinessAssessmentRequest: Schema.Struct<{
+    readonly expectedHeadRevision: Schema.NullOr<Schema.brand<Schema.Int, "ReadinessHeadRevision">>;
+    readonly invalidation: Schema.NullOr<Schema.Struct<{
+        readonly invalidationRevision: Schema.brand<Schema.Int, "ReadinessInvalidationRevision">;
+        readonly leaseOwner: Schema.brand<Schema.String, "ReadinessLeaseOwner">;
+        readonly leaseToken: Schema.brand<Schema.String, "ReadinessLeaseToken">;
+    }>>;
+    readonly assessment: Schema.Struct<{
+        readonly _tag: Schema.Literal<"release">;
+        readonly candidate: Schema.Struct<{
+            readonly scope: Schema.TaggedStruct<"release", {
+                readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+            }>;
+            readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            readonly releaseRevision: Schema.Int;
+            readonly artifactRevision: Schema.String;
+            readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+        }>;
+        readonly environments: Schema.NonEmptyArray<Schema.Struct<{
+            readonly assessmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">;
+            readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+            readonly candidateDigest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+            readonly inputComplete: Schema.Boolean;
+            readonly facts: Schema.$Array<Schema.Struct<{
+                readonly definition: Schema.Struct<{
+                    readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    readonly kind: Schema.Literals<readonly ["relationship", "approval", "check", "execution", "documentation", "deployment"]>;
+                    readonly requirement: Schema.Literals<readonly ["required", "advisory"]>;
+                }>;
+                readonly observation: Schema.NullOr<Schema.Struct<{
+                    readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    readonly state: Schema.TaggedUnion<{
+                        readonly relationship: Schema.TaggedStruct<"relationship", {
+                            readonly status: Schema.Literals<readonly ["missing", "inferred", "proposed", "verified", "governed", "rejected", "superseded"]>;
+                        }>;
+                        readonly approval: Schema.TaggedStruct<"approval", {
+                            readonly status: Schema.Literals<readonly ["missing", "pending", "approved", "rejected", "expired"]>;
+                        }>;
+                        readonly check: Schema.TaggedStruct<"check", {
+                            readonly status: Schema.Literals<readonly ["missing", "queued", "running", "passed", "failed", "cancelled"]>;
+                        }>;
+                        readonly execution: Schema.TaggedStruct<"execution", {
+                            readonly status: Schema.Literals<readonly ["missing", "queued", "running", "succeeded", "failed", "stopped"]>;
+                            readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                                readonly _tag: Schema.tag<"count">;
+                                readonly completed: Schema.Int;
+                                readonly total: Schema.Int;
+                            }>, Schema.TaggedStruct<"percent", {
+                                readonly value: Schema.Number;
+                            }>]>>;
+                        }>;
+                        readonly documentation: Schema.TaggedStruct<"documentation", {
+                            readonly status: Schema.Literals<readonly ["missing", "draft", "current", "stale", "superseded"]>;
+                        }>;
+                        readonly deployment: Schema.TaggedStruct<"deployment", {
+                            readonly status: Schema.Literals<readonly ["not-started", "pending", "deploying", "succeeded", "failed", "rolled-back"]>;
+                            readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                                readonly _tag: Schema.tag<"count">;
+                                readonly completed: Schema.Int;
+                                readonly total: Schema.Int;
+                            }>, Schema.TaggedStruct<"percent", {
+                                readonly value: Schema.Number;
+                            }>]>>;
+                        }>;
+                    }>;
+                    readonly evidence: Schema.$Array<Schema.Struct<{
+                        readonly evidenceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">;
+                        readonly source: Schema.TaggedUnion<{
+                            readonly plugin: Schema.TaggedStruct<"plugin", {
+                                readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                                readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                            }>;
+                            readonly local: Schema.TaggedStruct<"local", {
+                                readonly origin: Schema.Literals<readonly ["human", "agent", "system"]>;
+                            }>;
+                        }>;
+                        readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                        readonly validity: Schema.Literals<readonly ["valid", "expired"]>;
+                        readonly reevaluateAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                    }>>;
+                }>>;
+                readonly result: Schema.Literals<readonly ["verified", "pending", "failed", "gap", "advisory"]>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly nextEvaluationAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+            readonly verdict: Schema.Literals<readonly ["blocked", "ready", "deploying", "building", "shipped", "held"]>;
+            readonly stages: Schema.Struct<{
+                readonly build: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["not-started", "queued", "running", "succeeded", "failed", "held"]>;
+                    readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"count">;
+                        readonly completed: Schema.Int;
+                        readonly total: Schema.Int;
+                    }>, Schema.TaggedStruct<"percent", {
+                        readonly value: Schema.Number;
+                    }>]>>;
+                }>;
+                readonly verify: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["not-started", "pending", "passed", "failed", "held"]>;
+                    readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"count">;
+                        readonly completed: Schema.Int;
+                        readonly total: Schema.Int;
+                    }>, Schema.TaggedStruct<"percent", {
+                        readonly value: Schema.Number;
+                    }>]>>;
+                }>;
+                readonly production: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["not-started", "waiting", "deploying", "succeeded", "failed", "rolled-back", "held"]>;
+                    readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"count">;
+                        readonly completed: Schema.Int;
+                        readonly total: Schema.Int;
+                    }>, Schema.TaggedStruct<"percent", {
+                        readonly value: Schema.Number;
+                    }>]>>;
+                }>;
+            }>;
+            readonly blockers: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                readonly subject: Schema.TaggedUnion<{
+                    readonly source: Schema.TaggedStruct<"source", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly fact: Schema.TaggedStruct<"fact", {
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    }>;
+                    readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                }>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly warnings: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                readonly subject: Schema.TaggedUnion<{
+                    readonly source: Schema.TaggedStruct<"source", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly fact: Schema.TaggedStruct<"fact", {
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    }>;
+                    readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                }>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly gaps: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                readonly subject: Schema.TaggedUnion<{
+                    readonly source: Schema.TaggedStruct<"source", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly fact: Schema.TaggedStruct<"fact", {
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    }>;
+                    readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                }>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly sourceFreshness: Schema.$Array<Schema.Struct<{
+                readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+        }>>;
+        readonly assessmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">;
+        readonly previousAssessmentId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">>;
+        readonly rule: Schema.Struct<{
+            readonly ruleId: Schema.String;
+            readonly version: Schema.brand<Schema.Int, "ReadinessRuleVersion">;
+            readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+        }>;
+        readonly derivationVersion: Schema.brand<Schema.Int, "ReadinessDerivationVersion">;
+        readonly evaluatedAt: Schema.DateTimeUtcFromString;
+        readonly nextEvaluationAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+        readonly verdict: Schema.Literals<readonly ["blocked", "ready", "deploying", "building", "shipped", "held"]>;
+        readonly stages: Schema.Struct<{
+            readonly build: Schema.Struct<{
+                readonly state: Schema.Literals<readonly ["not-started", "queued", "running", "succeeded", "failed", "held"]>;
+                readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                    readonly _tag: Schema.tag<"count">;
+                    readonly completed: Schema.Int;
+                    readonly total: Schema.Int;
+                }>, Schema.TaggedStruct<"percent", {
+                    readonly value: Schema.Number;
+                }>]>>;
+            }>;
+            readonly verify: Schema.Struct<{
+                readonly state: Schema.Literals<readonly ["not-started", "pending", "passed", "failed", "held"]>;
+                readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                    readonly _tag: Schema.tag<"count">;
+                    readonly completed: Schema.Int;
+                    readonly total: Schema.Int;
+                }>, Schema.TaggedStruct<"percent", {
+                    readonly value: Schema.Number;
+                }>]>>;
+            }>;
+            readonly production: Schema.Struct<{
+                readonly state: Schema.Literals<readonly ["not-started", "waiting", "deploying", "succeeded", "failed", "rolled-back", "held"]>;
+                readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                    readonly _tag: Schema.tag<"count">;
+                    readonly completed: Schema.Int;
+                    readonly total: Schema.Int;
+                }>, Schema.TaggedStruct<"percent", {
+                    readonly value: Schema.Number;
+                }>]>>;
+            }>;
+        }>;
+        readonly blockers: Schema.$Array<Schema.Struct<{
+            readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+            readonly subject: Schema.TaggedUnion<{
+                readonly source: Schema.TaggedStruct<"source", {
+                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                }>;
+                readonly fact: Schema.TaggedStruct<"fact", {
+                    readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                }>;
+                readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+            }>;
+            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+        }>>;
+        readonly warnings: Schema.$Array<Schema.Struct<{
+            readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+            readonly subject: Schema.TaggedUnion<{
+                readonly source: Schema.TaggedStruct<"source", {
+                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                }>;
+                readonly fact: Schema.TaggedStruct<"fact", {
+                    readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                }>;
+                readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+            }>;
+            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+        }>>;
+        readonly gaps: Schema.$Array<Schema.Struct<{
+            readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+            readonly subject: Schema.TaggedUnion<{
+                readonly source: Schema.TaggedStruct<"source", {
+                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                }>;
+                readonly fact: Schema.TaggedStruct<"fact", {
+                    readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                }>;
+                readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+            }>;
+            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+        }>>;
+        readonly sourceFreshness: Schema.$Array<Schema.Struct<{
+            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+            readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+            readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+        }>>;
+        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+    }>;
+}>;
+/** Decoded release-readiness commit request. */
+export type CommitReleaseReadinessAssessmentRequest = typeof CommitReleaseReadinessAssessmentRequest.Type;
+/** Release-readiness record committed at the new head revision. */
+export declare const CommitReleaseReadinessAssessmentResult: Schema.Struct<{
+    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;
+}>;
+/** Decoded release-readiness commit result. */
+export type CommitReleaseReadinessAssessmentResult = typeof CommitReleaseReadinessAssessmentResult.Type;
+/** Exhaustive environment or release subject addressed by readiness persistence. */
+export declare const ReadinessAssessmentTarget: Schema.TaggedUnion<{
+    readonly release: Schema.TaggedStruct<"release", {
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+    }>;
+    readonly environment: Schema.TaggedStruct<"environment", {
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+        readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+    }>;
+}>;
+/** Decoded readiness-assessment target. */
+export type ReadinessAssessmentTarget = typeof ReadinessAssessmentTarget.Type;
+/** Whether a current readiness verdict may be used for governed decisions. */
+export declare const ReadinessAssessmentAuthority: Schema.Literals<readonly ["authoritative", "pending"]>;
+/** Decoded authority state for a current readiness verdict. */
+export type ReadinessAssessmentAuthority = typeof ReadinessAssessmentAuthority.Type;
+/** Current environment assessment plus its atomic invalidation authority state. */
+export declare const CurrentEnvironmentReadinessAssessmentRecord: Schema.Struct<{
+    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;
+}>;
+/** Decoded current environment readiness record. */
+export type CurrentEnvironmentReadinessAssessmentRecord = typeof CurrentEnvironmentReadinessAssessmentRecord.Type;
+/** Current release assessment plus its atomic invalidation authority state. */
+export declare const CurrentReleaseReadinessAssessmentRecord: Schema.Struct<{
+    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;
+}>;
+/** Decoded current release readiness record. */
+export type CurrentReleaseReadinessAssessmentRecord = typeof CurrentReleaseReadinessAssessmentRecord.Type;
+/** Request for the current environment or release readiness head. */
+export declare const ReadCurrentReadinessAssessmentRequest: Schema.TaggedUnion<{
+    readonly release: Schema.TaggedStruct<"release", {
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+    }>;
+    readonly environment: Schema.TaggedStruct<"environment", {
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+        readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+    }>;
+}>;
+/** Decoded current-readiness request. */
+export type ReadCurrentReadinessAssessmentRequest = typeof ReadCurrentReadinessAssessmentRequest.Type;
+/** Scope-preserving result of reading a current readiness head. */
+export declare const ReadCurrentReadinessAssessmentResult: Schema.TaggedUnion<{
+    readonly release: Schema.TaggedStruct<"release", {
+        readonly record: Schema.NullOr<Schema.Struct<{
+            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;
+        }>>;
+    }>;
+    readonly environment: Schema.TaggedStruct<"environment", {
+        readonly record: Schema.NullOr<Schema.Struct<{
+            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;
+        }>>;
+    }>;
+}>;
+/** Decoded current-readiness result. */
+export type ReadCurrentReadinessAssessmentResult = typeof ReadCurrentReadinessAssessmentResult.Type;
+/** Maximum release heads accepted by one bounded current-readiness batch read. */
+export declare const MAXIMUM_CURRENT_RELEASE_READINESS_BATCH = 200;
+/** Request for current release readiness heads within one workspace. */
+export declare const ReadCurrentReleaseReadinessAssessmentsRequest: Schema.Struct<{
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+    readonly releaseIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">>;
+}>;
+/** Decoded bounded current release-readiness batch request. */
+export type ReadCurrentReleaseReadinessAssessmentsRequest = typeof ReadCurrentReleaseReadinessAssessmentsRequest.Type;
+/** Existing current release heads returned in release-identifier order. */
+export declare const ReadCurrentReleaseReadinessAssessmentsResult: Schema.$Array<Schema.Struct<{
+    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;
+}>>;
+/** Decoded current release-readiness batch result. */
+export type ReadCurrentReleaseReadinessAssessmentsResult = typeof ReadCurrentReleaseReadinessAssessmentsResult.Type;
+/** Exclusive-cursor request for newest-first immutable readiness history. */
+export declare const ReadReadinessHistoryRequest: Schema.TaggedUnion<{
+    readonly release: Schema.TaggedStruct<"release", {
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+        readonly beforeHeadRevision: Schema.NullOr<Schema.brand<Schema.Int, "ReadinessHeadRevision">>;
+        readonly limit: Schema.brand<Schema.Int, "ReadinessHistoryLimit">;
+    }>;
+    readonly environment: Schema.TaggedStruct<"environment", {
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+        readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+        readonly beforeHeadRevision: Schema.NullOr<Schema.brand<Schema.Int, "ReadinessHeadRevision">>;
+        readonly limit: Schema.brand<Schema.Int, "ReadinessHistoryLimit">;
+    }>;
+}>;
+/** Decoded readiness-history request. */
+export type ReadReadinessHistoryRequest = typeof ReadReadinessHistoryRequest.Type;
+/** Scope-preserving page of newest-first immutable readiness history. */
+export declare const ReadReadinessHistoryResult: Schema.TaggedUnion<{
+    readonly release: Schema.TaggedStruct<"release", {
+        readonly records: Schema.$Array<Schema.Struct<{
+            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;
+        }>>;
+        readonly nextBeforeHeadRevision: Schema.NullOr<Schema.brand<Schema.Int, "ReadinessHeadRevision">>;
+    }>;
+    readonly environment: Schema.TaggedStruct<"environment", {
+        readonly records: Schema.$Array<Schema.Struct<{
+            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;
+        }>>;
+        readonly nextBeforeHeadRevision: Schema.NullOr<Schema.brand<Schema.Int, "ReadinessHeadRevision">>;
+    }>;
+}>;
+/** Decoded readiness-history page. */
+export type ReadReadinessHistoryResult = typeof ReadReadinessHistoryResult.Type;
+/** Active worker ownership of one exact readiness-invalidation revision. */
+export declare const ReadinessInvalidationLease: Schema.Struct<{
+    readonly owner: Schema.brand<Schema.String, "ReadinessLeaseOwner">;
+    readonly token: Schema.brand<Schema.String, "ReadinessLeaseToken">;
+    readonly claimedAt: Schema.DateTimeUtcFromString;
+    readonly expiresAt: Schema.DateTimeUtcFromString;
+}>;
+/** Decoded readiness-invalidation lease. */
+export type ReadinessInvalidationLease = typeof ReadinessInvalidationLease.Type;
+/** Coalesced environment or release invalidation with its exact monotonic revision. */
+export declare const ReadinessInvalidationRecord: Schema.TaggedUnion<{
+    readonly release: Schema.TaggedStruct<"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">;
+    }>;
+    readonly environment: Schema.TaggedStruct<"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">;
+    }>;
+}>;
+/** Decoded readiness-invalidation record. */
+export type ReadinessInvalidationRecord = typeof ReadinessInvalidationRecord.Type;
+/** Request to enqueue or advance a coalesced environment or release invalidation. */
+export declare const EnqueueReadinessInvalidationRequest: Schema.TaggedUnion<{
+    readonly release: Schema.TaggedStruct<"release", {
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+        readonly reason: Schema.Literals<readonly ["environment-assessment-changed", "rule-changed", "candidate-changed"]>;
+        readonly enqueuedAt: Schema.DateTimeUtcFromString;
+    }>;
+    readonly environment: Schema.TaggedStruct<"environment", {
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+        readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+        readonly reason: Schema.Literals<readonly ["evidence-changed", "plugin-health-changed", "rule-changed", "candidate-changed", "scheduled"]>;
+        readonly enqueuedAt: Schema.DateTimeUtcFromString;
+    }>;
+}>;
+/** Decoded readiness-invalidation enqueue request. */
+export type EnqueueReadinessInvalidationRequest = typeof EnqueueReadinessInvalidationRequest.Type;
+/** Invalidation record created or revision-advanced by an enqueue. */
+export declare const EnqueueReadinessInvalidationResult: Schema.TaggedUnion<{
+    readonly release: Schema.TaggedStruct<"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">;
+    }>;
+    readonly environment: Schema.TaggedStruct<"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">;
+    }>;
+}>;
+/** Decoded readiness-invalidation enqueue result. */
+export type EnqueueReadinessInvalidationResult = typeof EnqueueReadinessInvalidationResult.Type;
+/** Exact evidence or plugin-health change used to invalidate only dependent current heads. */
+export declare const EnqueueAffectedReadinessRequest: Schema.TaggedUnion<{
+    readonly plugin: Schema.TaggedStruct<"plugin", {
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+        readonly enqueuedAt: Schema.DateTimeUtcFromString;
+    }>;
+    readonly evidence: Schema.TaggedStruct<"evidence", {
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly evidenceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">;
+        readonly enqueuedAt: Schema.DateTimeUtcFromString;
+    }>;
+}>;
+/** Decoded dependency-scoped readiness invalidation request. */
+export type EnqueueAffectedReadinessRequest = typeof EnqueueAffectedReadinessRequest.Type;
+/** Counts of current environment and release subjects invalidated by one dependency change. */
+export declare const EnqueueAffectedReadinessResult: Schema.Struct<{
+    readonly environments: Schema.Int;
+    readonly releases: Schema.Int;
+}>;
+/** Decoded dependency-scoped readiness invalidation result. */
+export type EnqueueAffectedReadinessResult = typeof EnqueueAffectedReadinessResult.Type;
+/** Compare-and-swap request to lease one exact readiness-invalidation revision. */
+export declare const ClaimReadinessInvalidationRequest: Schema.TaggedUnion<{
+    readonly release: Schema.TaggedStruct<"release", {
+        readonly expectedInvalidationRevision: Schema.brand<Schema.Int, "ReadinessInvalidationRevision">;
+        readonly leaseOwner: Schema.brand<Schema.String, "ReadinessLeaseOwner">;
+        readonly leaseExpiresAt: 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 environment: Schema.TaggedStruct<"environment", {
+        readonly expectedInvalidationRevision: Schema.brand<Schema.Int, "ReadinessInvalidationRevision">;
+        readonly leaseOwner: Schema.brand<Schema.String, "ReadinessLeaseOwner">;
+        readonly leaseExpiresAt: 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">;
+    }>;
+}>;
+/** Decoded readiness-invalidation claim request. */
+export type ClaimReadinessInvalidationRequest = typeof ClaimReadinessInvalidationRequest.Type;
+/** Exact leased invalidation, or null when the compare-and-swap claim lost. */
+export declare const ClaimReadinessInvalidationResult: Schema.NullOr<Schema.TaggedUnion<{
+    readonly release: Schema.TaggedStruct<"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">;
+    }>;
+    readonly environment: Schema.TaggedStruct<"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">;
+    }>;
+}>>;
+/** Decoded readiness-invalidation claim result. */
+export type ClaimReadinessInvalidationResult = typeof ClaimReadinessInvalidationResult.Type;
+/** Bounded due-schedule sweep for one workspace. */
+export declare const EnqueueDueReadinessEvaluationsRequest: Schema.Struct<{
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+    readonly dueAt: Schema.DateTimeUtcFromString;
+    readonly limit: Schema.Int;
+}>;
+/** Decoded due-schedule sweep request. */
+export type EnqueueDueReadinessEvaluationsRequest = typeof EnqueueDueReadinessEvaluationsRequest.Type;
+/** Number of exact due schedules promoted to coalesced environment invalidations. */
+export declare const EnqueueDueReadinessEvaluationsResult: Schema.Struct<{
+    readonly enqueued: Schema.Int;
+}>;
+/** Decoded due-schedule sweep result. */
+export type EnqueueDueReadinessEvaluationsResult = typeof EnqueueDueReadinessEvaluationsResult.Type;
+export {};
+//# sourceMappingURL=contract.d.ts.map