@knpkv/control-center 0.1.0

package/dist/server/domain/readiness/model.d.ts

@@ -0,0 +1,1736 @@
+import * as Schema from "effect/Schema";
+/** Maximum exact evidence dependencies in one environment or release assessment. */
+export declare const MAX_READINESS_EVIDENCE_REFERENCES = 512;
+/** Maximum blockers, warnings, or gaps retained in one assessment. */
+export declare const MAX_READINESS_FINDINGS = 1025;
+/** Stable identity of one V1 readiness fact, independent of display copy. */
+export declare const ReadinessFactId: Schema.brand<Schema.String, "ReadinessFactId">;
+/** Decoded readiness-fact identity. */
+export type ReadinessFactId = typeof ReadinessFactId.Type;
+/** Hash of the complete canonical candidate input assembled by the application layer. */
+export declare const ReadinessCandidateDigest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+/** Decoded candidate digest. */
+export type ReadinessCandidateDigest = typeof ReadinessCandidateDigest.Type;
+/** Positive version of the rule policy used for one assessment. */
+export declare const ReadinessRuleVersion: Schema.brand<Schema.Int, "ReadinessRuleVersion">;
+/** Decoded readiness-rule version. */
+export type ReadinessRuleVersion = typeof ReadinessRuleVersion.Type;
+/** Positive version of the evaluator implementation used for one assessment. */
+export declare const ReadinessDerivationVersion: Schema.brand<Schema.Int, "ReadinessDerivationVersion">;
+/** Decoded readiness-derivation version. */
+export type ReadinessDerivationVersion = typeof ReadinessDerivationVersion.Type;
+/** V1 readiness policy version. */
+export declare const READINESS_RULE_VERSION_V1: number & import("effect/Brand").Brand<"ReadinessRuleVersion">;
+/** V1 evaluator implementation version. */
+export declare const READINESS_DERIVATION_VERSION_V1: number & import("effect/Brand").Brand<"ReadinessDerivationVersion">;
+/** Positive source revision of the release candidate. */
+export declare const ReadinessReleaseRevision: Schema.Int;
+/** Decoded release-candidate revision. */
+export type ReadinessReleaseRevision = typeof ReadinessReleaseRevision.Type;
+/** Bounded immutable artifact revision, such as a commit or image digest. */
+export declare const ReadinessArtifactRevision: Schema.String;
+/** Decoded artifact revision. */
+export type ReadinessArtifactRevision = typeof ReadinessArtifactRevision.Type;
+/** Stable identity of a readiness rule set. */
+export declare const ReadinessRuleId: Schema.String;
+/** Decoded readiness-rule identity. */
+export type ReadinessRuleId = typeof ReadinessRuleId.Type;
+/** Explicit release or target-environment scope of an assessment. */
+export declare const ReadinessScope: Schema.TaggedUnion<{
+    readonly release: Schema.TaggedStruct<"release", {
+        readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+    }>;
+    readonly environment: 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">;
+    }>;
+}>;
+/** Decoded readiness scope. */
+export type ReadinessScope = typeof ReadinessScope.Type;
+/** Immutable target-environment candidate whose complete material is digest-bound. */
+export declare const EnvironmentReadinessCandidateIdentity: 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">;
+}>;
+/** Immutable release-scope candidate whose child assessments are digest-bound. */
+export declare const ReleaseReadinessCandidateIdentity: 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">;
+}>;
+/** Immutable deployable candidate whose complete material is bound by a digest. */
+export declare const ReadinessCandidateIdentity: Schema.Union<readonly [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">;
+}>, 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">;
+}>]>;
+/** Decoded deployable candidate identity. */
+export type ReadinessCandidateIdentity = typeof ReadinessCandidateIdentity.Type;
+/** Stable rule-set identity and content digest retained with every assessment. */
+export declare const ReadinessRuleReference: Schema.Struct<{
+    readonly ruleId: Schema.String;
+    readonly version: Schema.brand<Schema.Int, "ReadinessRuleVersion">;
+    readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+}>;
+/** Decoded readiness rule reference. */
+export type ReadinessRuleReference = typeof ReadinessRuleReference.Type;
+/** Canonical six-state readiness verdict. */
+export declare const ReadinessVerdict: Schema.Literals<readonly ["blocked", "ready", "deploying", "building", "shipped", "held"]>;
+/** Decoded readiness verdict. */
+export type ReadinessVerdict = typeof ReadinessVerdict.Type;
+/** Closed provider-neutral fact categories understood by the V1 evaluator. */
+export declare const ReadinessFactKind: Schema.Literals<readonly ["relationship", "approval", "check", "execution", "documentation", "deployment"]>;
+/** Decoded readiness-fact category. */
+export type ReadinessFactKind = typeof ReadinessFactKind.Type;
+/** Whether a fact gates readiness or only contributes context. */
+export declare const ReadinessFactRequirement: Schema.Literals<readonly ["required", "advisory"]>;
+/** Decoded fact requirement. */
+export type ReadinessFactRequirement = typeof ReadinessFactRequirement.Type;
+/** Policy definition that makes missing observations explicit rather than successful by absence. */
+export declare const ReadinessFactDefinition: 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 readiness-fact definition. */
+export type ReadinessFactDefinition = typeof ReadinessFactDefinition.Type;
+/** Typed progress for builds and deployments without copied display text. */
+export declare const ReadinessProgress: Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+    readonly _tag: Schema.tag<"count">;
+    readonly completed: Schema.Int;
+    readonly total: Schema.Int;
+}>, Schema.TaggedStruct<"percent", {
+    readonly value: Schema.Number;
+}>]>;
+/** Decoded readiness progress. */
+export type ReadinessProgress = typeof ReadinessProgress.Type;
+/** Closed normalized observation states; vendor strings never enter rule evaluation. */
+export declare const ReadinessFactState: 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;
+        }>]>>;
+    }>;
+}>;
+/** Decoded normalized readiness observation state. */
+export type ReadinessFactState = typeof ReadinessFactState.Type;
+/** Exact origin of evidence used for dependency tracking and plugin-health invalidation. */
+export declare const ReadinessEvidenceSource: 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"]>;
+    }>;
+}>;
+/** Decoded readiness-evidence source. */
+export type ReadinessEvidenceSource = typeof ReadinessEvidenceSource.Type;
+/** Exact evidence dependency and its freshness at the injected evaluation boundary. */
+export declare const ReadinessEvidenceReference: 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>;
+}>;
+/** Decoded readiness-evidence dependency. */
+export type ReadinessEvidenceReference = typeof ReadinessEvidenceReference.Type;
+/** One normalized observation for a policy-defined fact. */
+export declare const ReadinessFactObservation: 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>;
+    }>>;
+}>;
+/** Decoded readiness-fact observation. */
+export type ReadinessFactObservation = typeof ReadinessFactObservation.Type;
+/** Stable machine-readable reason emitted by the V1 rule policy. */
+export declare const ReadinessFindingCode: 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"]>;
+/** Decoded readiness finding code. */
+export type ReadinessFindingCode = typeof ReadinessFindingCode.Type;
+/** Stable subject of a readiness finding. */
+export declare const ReadinessFindingSubject: 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", {}>;
+}>;
+/** One blocker, warning, or evidence gap without presentation prose. */
+export declare const ReadinessFinding: 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">>;
+}>;
+/** Decoded readiness finding. */
+export type ReadinessFinding = typeof ReadinessFinding.Type;
+/** Outcome retained for every evaluated fact. */
+export declare const ReadinessFactResult: Schema.Literals<readonly ["verified", "pending", "failed", "gap", "advisory"]>;
+/** Decoded readiness-fact outcome. */
+export type ReadinessFactResult = typeof ReadinessFactResult.Type;
+/** Auditable fact evaluation retained in an environment assessment. */
+export declare const ReadinessFactEvaluation: 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">>;
+}>;
+/** Decoded readiness-fact evaluation. */
+export type ReadinessFactEvaluation = typeof ReadinessFactEvaluation.Type;
+/** Worst current source state for one contributing plugin connection. */
+export declare const ReadinessSourceSummary: 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">>;
+}>;
+/** Decoded source summary. */
+export type ReadinessSourceSummary = typeof ReadinessSourceSummary.Type;
+/** Server-derived Build stage. */
+export declare const BuildReadinessStage: 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;
+    }>]>>;
+}>;
+/** Server-derived Verify stage. */
+export declare const VerifyReadinessStage: 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;
+    }>]>>;
+}>;
+/** Server-derived Production stage. */
+export declare const ProductionReadinessStage: 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;
+    }>]>>;
+}>;
+/** Exactly three authoritative delivery stages. */
+export declare const ReadinessStages: 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;
+        }>]>>;
+    }>;
+}>;
+/** Decoded readiness stages. */
+export type ReadinessStages = typeof ReadinessStages.Type;
+/** Complete, decoded input for one environment evaluation. */
+export declare const EnvironmentReadinessEvaluationInput: Schema.Struct<{
+    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 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 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 complete: Schema.Boolean;
+    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 observations: Schema.$Array<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>;
+        }>>;
+    }>>;
+}>;
+/** Decoded environment-readiness input. */
+export type EnvironmentReadinessEvaluationInput = typeof EnvironmentReadinessEvaluationInput.Type;
+/** Immutable environment assessment retaining exact facts and evidence. */
+export declare const EnvironmentReadinessAssessment: 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 immutable environment assessment. */
+export type EnvironmentReadinessAssessment = typeof EnvironmentReadinessAssessment.Type;
+/** Compact immutable child retained by a release-scope roll-up. */
+export declare const EnvironmentReadinessSummary: 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">>;
+}>;
+/** Immutable release assessment rolled up from current target environments. */
+export declare const ReleaseReadinessAssessment: 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 immutable release readiness assessment. */
+export type ReleaseReadinessAssessment = typeof ReleaseReadinessAssessment.Type;
+/** Any immutable server-authoritative readiness assessment. */
+export declare const ReadinessAssessment: Schema.toTaggedUnion<"_tag", readonly [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">>;
+}>, 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 readiness assessment. */
+export type ReadinessAssessment = typeof ReadinessAssessment.Type;
+/** Complete, decoded input for one release-scope roll-up. */
+export declare const ReleaseReadinessRollupInput: Schema.Struct<{
+    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 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 evaluatedAt: Schema.DateTimeUtcFromString;
+    readonly environments: Schema.NonEmptyArray<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 release-readiness roll-up input. */
+export type ReleaseReadinessRollupInput = typeof ReleaseReadinessRollupInput.Type;
+//# sourceMappingURL=model.d.ts.map