@knpkv/control-center 0.3.0 → 0.5.0

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

@@ -1457,14 +1457,14 @@ export declare const CommitReleaseReadinessAssessmentResult: Schema.Struct<{
 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 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 environment: Schema.TaggedStruct<"environment", {
+    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 environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
     }>;
 }>;
 /** Decoded readiness-assessment target. */
@@ -1923,20 +1923,199 @@ export declare const CurrentReleaseReadinessAssessmentRecord: Schema.Struct<{
 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 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 environment: Schema.TaggedStruct<"environment", {
+    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 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 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;
+        }>>;
+    }>;
     readonly release: Schema.TaggedStruct<"release", {
         readonly record: Schema.NullOr<Schema.Struct<{
             readonly authority: Schema.Literals<readonly ["authoritative", "pending"]>;
@@ -2204,222 +2383,43 @@ export declare const ReadCurrentReadinessAssessmentResult: Schema.TaggedUnion<{
             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"]>;
+}>;
+/** 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">;
@@ -2649,40 +2649,219 @@ export declare const ReadCurrentReleaseReadinessAssessmentsResult: Schema.$Array
                 }>;
                 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 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 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">;
+    }>;
+    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">;
+    }>;
+}>;
+/** 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 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 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">;
+        readonly nextBeforeHeadRevision: Schema.NullOr<Schema.brand<Schema.Int, "ReadinessHeadRevision">>;
     }>;
-}>;
-/** 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">;
@@ -2950,185 +3129,6 @@ export declare const ReadReadinessHistoryResult: Schema.TaggedUnion<{
         }>>;
         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;
@@ -3143,7 +3143,7 @@ export declare const ReadinessInvalidationLease: Schema.Struct<{
 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 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;
@@ -3155,8 +3155,9 @@ export declare const ReadinessInvalidationRecord: Schema.TaggedUnion<{
         }>>;
         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 environment: Schema.TaggedStruct<"environment", {
+    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;
@@ -3168,24 +3169,23 @@ export declare const ReadinessInvalidationRecord: Schema.TaggedUnion<{
         }>>;
         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 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 reason: Schema.Literals<readonly ["environment-assessment-changed", "rule-changed", "candidate-changed"]>;
+        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;
     }>;
-    readonly environment: Schema.TaggedStruct<"environment", {
+    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 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 reason: Schema.Literals<readonly ["environment-assessment-changed", "rule-changed", "candidate-changed"]>;
         readonly enqueuedAt: Schema.DateTimeUtcFromString;
     }>;
 }>;
@@ -3193,7 +3193,7 @@ export declare const EnqueueReadinessInvalidationRequest: Schema.TaggedUnion<{
 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 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;
@@ -3205,8 +3205,9 @@ export declare const EnqueueReadinessInvalidationResult: Schema.TaggedUnion<{
         }>>;
         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 environment: Schema.TaggedStruct<"environment", {
+    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;
@@ -3218,7 +3219,6 @@ export declare const EnqueueReadinessInvalidationResult: Schema.TaggedUnion<{
         }>>;
         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. */
@@ -3247,27 +3247,27 @@ export declare const EnqueueAffectedReadinessResult: Schema.Struct<{
 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 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">;
     }>;
-    readonly environment: Schema.TaggedStruct<"environment", {
+    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 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 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;
@@ -3279,8 +3279,9 @@ export declare const ClaimReadinessInvalidationResult: Schema.NullOr<Schema.Tagg
         }>>;
         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 environment: Schema.TaggedStruct<"environment", {
+    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;
@@ -3292,7 +3293,6 @@ export declare const ClaimReadinessInvalidationResult: Schema.NullOr<Schema.Tagg
         }>>;
         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. */