npm - @knpkv/control-center - Versions diffs - 0.3.0 → 0.5.0 - Mend

@knpkv/control-center 0.3.0 → 0.5.0

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

Files changed (346) hide show

package/dist/server/server/application/portfolioSnapshots.d.ts CHANGED Viewed

@@ -1,12 +1,2026 @@
+import * as Crypto from "effect/Crypto";
+import * as DateTime from "effect/DateTime";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
-import type { PortfolioSnapshot } from "../../api/portfolio.js";
+import type { PortfolioReleasePageAwareness, PortfolioSnapshot } from "../../api/portfolio.js";
+import type { Release } from "../../domain/release.js";
 import { ApplicationServiceUnavailable, PortfolioSnapshots } from "../api/ApplicationServices.js";
 import { Persistence } from "../persistence/Persistence.js";
+import { type ReleasePublicationReceiptCandidate } from "./releasePublicationMetadata.js";
+/** Compare the synchronized release projection with the latest successful page publication. */
+export declare const classifyReleasePageAwareness: (releaseUpdatedAt: Release["updatedAt"], lastPublishedAt: Release["updatedAt"] | null) => PortfolioReleasePageAwareness["state"];
+/** Fail closed when successful publication history has no supported durable receipt locator. */
+export declare const classifyReleasePublicationAwareness: (release: Release, publications: ReadonlyArray<ReleasePublicationReceiptCandidate>, currentSourceRevisionDigest: ReleasePublicationReceiptCandidate["sourceRevisionDigest"]) => PortfolioReleasePageAwareness;
+/**
+ * Load release publication awareness with one indexed history projection.
+ *
+ * Any projection failure makes every requested release unknown so callers
+ * cannot mistake unavailable or malformed history for permission to republish.
+ */
+export declare const loadReleasePageAwareness: (history: Pick<{
+    commit: (input: unknown) => Effect.Effect<{
+        readonly _tag: "committed";
+        readonly transition: import("../../index.ts").GovernedActionTransitionV1;
+    } | {
+        readonly _tag: "replayed";
+        readonly transition: import("../../index.ts").GovernedActionTransitionV1;
+    }, import("../persistence/Persistence.js").PersistenceOperationFailure, never>;
+    read: (input: unknown) => Effect.Effect<{
+        envelope: {
+            readonly providerId: "codecommit" | "codepipeline" | "jira" | "confluence" | "clockify";
+            readonly pluginConnectionId: string & import("effect/Brand").Brand<"PluginConnectionId">;
+            readonly workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">;
+            readonly schemaVersion: 1;
+            readonly causationId: (string & import("effect/Brand").Brand<"DomainEventId">) | null;
+            readonly correlationId: (string & import("effect/Brand").Brand<"DomainEventCorrelationId">) | null;
+            readonly proposal: import("effect/Schema").Struct.ReadonlySide<{
+                readonly proposalKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly capabilityVersion: import("effect/Schema").Int;
+                readonly request: import("effect/Schema").Struct<{
+                    readonly actionKind: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                    readonly target: import("effect/Schema").Struct<{
+                        entityType: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        vendorImmutableId: import("effect/Schema").brand<import("effect/Schema").String, "VendorImmutableId">;
+                    }>;
+                    readonly expectedRevision: import("effect/Schema").brand<import("effect/Schema").String, "Revision">;
+                    readonly payload: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
+                    readonly evidenceIds: import("effect/Schema").$Array<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                }>;
+                readonly payloadDigest: import("effect/Schema").brand<import("effect/Schema").String, "PluginActionPayloadDigest">;
+                readonly summary: import("effect/Schema").String;
+                readonly impact: import("effect/Schema").Struct<{
+                    readonly level: import("effect/Schema").Literals<readonly ["low", "medium", "high", "critical"]>;
+                    readonly summary: import("effect/Schema").String;
+                }>;
+                readonly proposedAt: import("effect/Schema").DateTimeUtcFromString;
+            }, "Type">;
+            readonly idempotencyKey: string & import("effect/Brand").Brand<"GovernedActionIdempotencyKey">;
+            readonly pluginId: string & import("effect/Brand").Brand<string>;
+            readonly actionId: string & import("effect/Brand").Brand<"GovernedActionId">;
+            readonly policy: import("effect/Schema").Struct.ReadonlySide<{
+                readonly policyId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly policyVersion: import("effect/Schema").Int;
+                readonly policyDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly requiredPermission: import("effect/Schema").Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
+            }, "Type">;
+            readonly evidenceSetDigest: string & import("effect/Brand").Brand<string>;
+            readonly pluginConnectionRevision: number & import("effect/Brand").Brand<"GovernedActionPluginConnectionRevision">;
+            readonly pluginConnectionAuthorityDigest: string & import("effect/Brand").Brand<string>;
+            readonly pluginContractVersion: import("effect/Schema").Struct.ReadonlySide<{
+                readonly major: import("effect/Schema").Int;
+                readonly minor: import("effect/Schema").Int;
+                readonly patch: import("effect/Schema").Int;
+            }, "Type">;
+            readonly pluginAdapterVersion: import("effect/Schema").Struct.ReadonlySide<{
+                readonly major: import("effect/Schema").Int;
+                readonly minor: import("effect/Schema").Int;
+                readonly patch: import("effect/Schema").Int;
+            }, "Type">;
+            readonly capability: import("effect/Schema").Struct.ReadonlySide<{
+                readonly capabilityId: import("effect/Schema").Literal<"action.execute">;
+                readonly version: import("effect/Schema").Int;
+            }, "Type">;
+            readonly targetEntityId: string & import("effect/Brand").Brand<"EntityId">;
+            readonly evidence: readonly import("effect/Schema").Struct.ReadonlySide<{
+                readonly workspaceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "WorkspaceId">;
+                readonly evidenceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "EvidenceId">;
+                readonly evidenceClaimIds: import("effect/Schema").$Array<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "EvidenceClaimId">>;
+                readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                readonly validUntil: import("effect/Schema").NullOr<import("effect/Schema").DateTimeUtcFromString>;
+                readonly currentUntil: import("effect/Schema").NullOr<import("effect/Schema").DateTimeUtcFromString>;
+                readonly evaluatedAt: import("effect/Schema").DateTimeUtcFromString;
+                readonly source: import("effect/Schema").Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                readonly validity: import("effect/Schema").Literals<readonly ["valid", "expired"]>;
+            }, "Type">[];
+            readonly origin: import("effect/Schema").Struct.ReadonlySide<{
+                readonly _tag: import("effect/Schema").tag<"human">;
+                readonly actor: import("effect/Schema").TaggedStruct<"human", {
+                    readonly personId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PersonId">;
+                }>;
+                readonly sessionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "SessionId">;
+            }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+                readonly _tag: import("effect/Schema").tag<"agent">;
+                readonly actor: import("effect/Schema").TaggedStruct<"agent", {
+                    readonly agentId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "AgentId">;
+                }>;
+                readonly jobId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "JobId">;
+                readonly initiatingSessionId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "SessionId">>;
+            }, "Type">;
+            readonly proposalExpiresAt: DateTime.Utc;
+            readonly envelopeDigest: string & import("effect/Brand").Brand<string>;
+            readonly releasePublication?: {
+                readonly releaseId: string & import("effect/Brand").Brand<"ReleaseId">;
+                readonly sourceRevisionDigest: string & import("effect/Brand").Brand<string>;
+                readonly sourceRevisionCount: number;
+                readonly predecessorPublicationActionId?: (string & import("effect/Brand").Brand<"GovernedActionId">) | null;
+                readonly templateSourceEntityId?: string & import("effect/Brand").Brand<"EntityId">;
+            };
+        };
+        head: import("effect/Schema").Struct.ReadonlySide<{
+            readonly state: import("effect/Schema").Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>;
+            readonly lineage: import("effect/Schema").TaggedUnion<{
+                readonly accepted: import("effect/Schema").TaggedStruct<"accepted", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly status: import("effect/Schema").Literal<"accepted">;
+                        readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                }>;
+                readonly reconcilable: import("effect/Schema").TaggedStruct<"reconcilable", {
+                    readonly providerOperationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                    readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                }>;
+                readonly manual: import("effect/Schema").TaggedStruct<"manual", {
+                    readonly providerOperationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                }>;
+                readonly none: import("effect/Schema").TaggedStruct<"none", {}>;
+                readonly terminal: import("effect/Schema").TaggedStruct<"terminal", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly observationBasis: import("effect/Schema").optionalKey<import("effect/Schema").Literal<"authorization">>;
+                        readonly status: import("effect/Schema").Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                }>;
+            }>;
+        }, "Type">;
+        headTransition: import("effect/Schema").Struct.ReadonlySide<{
+            readonly commandDigest: import("effect/Schema").brand<import("effect/Schema").String, "GovernedActionCommandDigest">;
+            readonly schemaVersion: import("effect/Schema").Literal<1>;
+            readonly transitionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionTransitionId">;
+            readonly previousTransitionId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionTransitionId">>;
+            readonly commandId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly actionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionId">;
+            readonly workspaceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "WorkspaceId">;
+            readonly sequence: import("effect/Schema").Int;
+            readonly fromState: import("effect/Schema").NullOr<import("effect/Schema").Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>>;
+            readonly toState: import("effect/Schema").Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>;
+            readonly actionEnvelopeDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly command: import("effect/Schema").TaggedUnion<{
+                readonly propose: import("effect/Schema").TaggedStruct<"propose", {}>;
+                readonly authorize: import("effect/Schema").TaggedStruct<"authorize", {
+                    readonly authorizationId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionAuthorizationId">;
+                }>;
+                readonly deny: import("effect/Schema").TaggedStruct<"deny", {
+                    readonly reason: import("effect/Schema").Literals<readonly ["revision-changed", "evidence-stale", "evidence-invalid", "policy-denied", "session-invalid", "capability-changed", "plugin-unavailable", "preflight-blocked"]>;
+                    readonly safeSummary: import("effect/Schema").String;
+                }>;
+                readonly expire: import("effect/Schema").TaggedStruct<"expire", {
+                    readonly reason: import("effect/Schema").Literals<readonly ["proposal-expired", "authorization-expired"]>;
+                }>;
+                readonly cancel: import("effect/Schema").TaggedStruct<"cancel", {
+                    readonly safeSummary: import("effect/Schema").String;
+                }>;
+                readonly start: import("effect/Schema").TaggedStruct<"start", {
+                    readonly attemptId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionAttemptId">;
+                }>;
+                readonly requestCancellation: import("effect/Schema").TaggedStruct<"requestCancellation", {
+                    readonly safeSummary: import("effect/Schema").String;
+                }>;
+                readonly recordAccepted: import("effect/Schema").TaggedStruct<"recordAccepted", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly status: import("effect/Schema").Literal<"accepted">;
+                        readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                }>;
+                readonly recordSucceeded: import("effect/Schema").TaggedStruct<"recordSucceeded", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly observationBasis: import("effect/Schema").optionalKey<import("effect/Schema").Literal<"authorization">>;
+                        readonly status: import("effect/Schema").Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                    readonly source: import("effect/Schema").TaggedUnion<{
+                        readonly direct: import("effect/Schema").TaggedStruct<"direct", {}>;
+                        readonly providerOperation: import("effect/Schema").TaggedStruct<"providerOperation", {
+                            readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        }>;
+                        readonly reconciliation: import("effect/Schema").TaggedStruct<"reconciliation", {
+                            readonly reconciliationKey: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                        }>;
+                    }>;
+                }>;
+                readonly recordFailed: import("effect/Schema").TaggedStruct<"recordFailed", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly observationBasis: import("effect/Schema").optionalKey<import("effect/Schema").Literal<"authorization">>;
+                        readonly status: import("effect/Schema").Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                    readonly source: import("effect/Schema").TaggedUnion<{
+                        readonly direct: import("effect/Schema").TaggedStruct<"direct", {}>;
+                        readonly providerOperation: import("effect/Schema").TaggedStruct<"providerOperation", {
+                            readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        }>;
+                        readonly reconciliation: import("effect/Schema").TaggedStruct<"reconciliation", {
+                            readonly reconciliationKey: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                        }>;
+                    }>;
+                }>;
+                readonly recordUnknown: import("effect/Schema").TaggedStruct<"recordUnknown", {
+                    readonly outcome: import("effect/Schema").TaggedUnion<{
+                        readonly reconcilable: import("effect/Schema").TaggedStruct<"reconcilable", {
+                            readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                            readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                            readonly safeSummary: import("effect/Schema").String;
+                        }>;
+                        readonly manual: import("effect/Schema").TaggedStruct<"manual", {
+                            readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                            readonly safeSummary: import("effect/Schema").String;
+                            readonly reason: import("effect/Schema").Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
+                        }>;
+                    }>;
+                }>;
+                readonly recordCancelled: import("effect/Schema").TaggedStruct<"recordCancelled", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly observationBasis: import("effect/Schema").optionalKey<import("effect/Schema").Literal<"authorization">>;
+                        readonly status: import("effect/Schema").Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                    readonly source: import("effect/Schema").TaggedUnion<{
+                        readonly direct: import("effect/Schema").TaggedStruct<"direct", {}>;
+                        readonly providerOperation: import("effect/Schema").TaggedStruct<"providerOperation", {
+                            readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        }>;
+                        readonly reconciliation: import("effect/Schema").TaggedStruct<"reconciliation", {
+                            readonly reconciliationKey: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                        }>;
+                    }>;
+                }>;
+                readonly reconciliationPending: import("effect/Schema").TaggedStruct<"reconciliationPending", {
+                    readonly checkedAt: import("effect/Schema").DateTimeUtcFromString;
+                    readonly reconciliationKey: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                }>;
+            }>;
+            readonly cause: import("effect/Schema").TaggedUnion<{
+                readonly human: import("effect/Schema").TaggedStruct<"human", {
+                    readonly actor: import("effect/Schema").TaggedStruct<"human", {
+                        readonly personId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PersonId">;
+                    }>;
+                    readonly sessionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "SessionId">;
+                }>;
+                readonly agent: import("effect/Schema").TaggedStruct<"agent", {
+                    readonly actor: import("effect/Schema").TaggedStruct<"agent", {
+                        readonly agentId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "AgentId">;
+                    }>;
+                    readonly jobId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "JobId">;
+                }>;
+                readonly system: import("effect/Schema").TaggedStruct<"system", {
+                    readonly component: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                }>;
+            }>;
+            readonly occurredAt: import("effect/Schema").DateTimeUtcFromString;
+            readonly causationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "DomainEventId">>;
+            readonly correlationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, "DomainEventCorrelationId">>;
+        }, "Type">;
+        history: import("effect/Schema").Struct.ReadonlySide<{
+            readonly commandDigest: import("effect/Schema").brand<import("effect/Schema").String, "GovernedActionCommandDigest">;
+            readonly schemaVersion: import("effect/Schema").Literal<1>;
+            readonly transitionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionTransitionId">;
+            readonly previousTransitionId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionTransitionId">>;
+            readonly commandId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly actionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionId">;
+            readonly workspaceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "WorkspaceId">;
+            readonly sequence: import("effect/Schema").Int;
+            readonly fromState: import("effect/Schema").NullOr<import("effect/Schema").Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>>;
+            readonly toState: import("effect/Schema").Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>;
+            readonly actionEnvelopeDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly command: import("effect/Schema").TaggedUnion<{
+                readonly propose: import("effect/Schema").TaggedStruct<"propose", {}>;
+                readonly authorize: import("effect/Schema").TaggedStruct<"authorize", {
+                    readonly authorizationId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionAuthorizationId">;
+                }>;
+                readonly deny: import("effect/Schema").TaggedStruct<"deny", {
+                    readonly reason: import("effect/Schema").Literals<readonly ["revision-changed", "evidence-stale", "evidence-invalid", "policy-denied", "session-invalid", "capability-changed", "plugin-unavailable", "preflight-blocked"]>;
+                    readonly safeSummary: import("effect/Schema").String;
+                }>;
+                readonly expire: import("effect/Schema").TaggedStruct<"expire", {
+                    readonly reason: import("effect/Schema").Literals<readonly ["proposal-expired", "authorization-expired"]>;
+                }>;
+                readonly cancel: import("effect/Schema").TaggedStruct<"cancel", {
+                    readonly safeSummary: import("effect/Schema").String;
+                }>;
+                readonly start: import("effect/Schema").TaggedStruct<"start", {
+                    readonly attemptId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionAttemptId">;
+                }>;
+                readonly requestCancellation: import("effect/Schema").TaggedStruct<"requestCancellation", {
+                    readonly safeSummary: import("effect/Schema").String;
+                }>;
+                readonly recordAccepted: import("effect/Schema").TaggedStruct<"recordAccepted", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly status: import("effect/Schema").Literal<"accepted">;
+                        readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                }>;
+                readonly recordSucceeded: import("effect/Schema").TaggedStruct<"recordSucceeded", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly observationBasis: import("effect/Schema").optionalKey<import("effect/Schema").Literal<"authorization">>;
+                        readonly status: import("effect/Schema").Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                    readonly source: import("effect/Schema").TaggedUnion<{
+                        readonly direct: import("effect/Schema").TaggedStruct<"direct", {}>;
+                        readonly providerOperation: import("effect/Schema").TaggedStruct<"providerOperation", {
+                            readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        }>;
+                        readonly reconciliation: import("effect/Schema").TaggedStruct<"reconciliation", {
+                            readonly reconciliationKey: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                        }>;
+                    }>;
+                }>;
+                readonly recordFailed: import("effect/Schema").TaggedStruct<"recordFailed", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly observationBasis: import("effect/Schema").optionalKey<import("effect/Schema").Literal<"authorization">>;
+                        readonly status: import("effect/Schema").Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                    readonly source: import("effect/Schema").TaggedUnion<{
+                        readonly direct: import("effect/Schema").TaggedStruct<"direct", {}>;
+                        readonly providerOperation: import("effect/Schema").TaggedStruct<"providerOperation", {
+                            readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        }>;
+                        readonly reconciliation: import("effect/Schema").TaggedStruct<"reconciliation", {
+                            readonly reconciliationKey: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                        }>;
+                    }>;
+                }>;
+                readonly recordUnknown: import("effect/Schema").TaggedStruct<"recordUnknown", {
+                    readonly outcome: import("effect/Schema").TaggedUnion<{
+                        readonly reconcilable: import("effect/Schema").TaggedStruct<"reconcilable", {
+                            readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                            readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                            readonly safeSummary: import("effect/Schema").String;
+                        }>;
+                        readonly manual: import("effect/Schema").TaggedStruct<"manual", {
+                            readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                            readonly safeSummary: import("effect/Schema").String;
+                            readonly reason: import("effect/Schema").Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
+                        }>;
+                    }>;
+                }>;
+                readonly recordCancelled: import("effect/Schema").TaggedStruct<"recordCancelled", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly observationBasis: import("effect/Schema").optionalKey<import("effect/Schema").Literal<"authorization">>;
+                        readonly status: import("effect/Schema").Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                    readonly source: import("effect/Schema").TaggedUnion<{
+                        readonly direct: import("effect/Schema").TaggedStruct<"direct", {}>;
+                        readonly providerOperation: import("effect/Schema").TaggedStruct<"providerOperation", {
+                            readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        }>;
+                        readonly reconciliation: import("effect/Schema").TaggedStruct<"reconciliation", {
+                            readonly reconciliationKey: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                        }>;
+                    }>;
+                }>;
+                readonly reconciliationPending: import("effect/Schema").TaggedStruct<"reconciliationPending", {
+                    readonly checkedAt: import("effect/Schema").DateTimeUtcFromString;
+                    readonly reconciliationKey: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                }>;
+            }>;
+            readonly cause: import("effect/Schema").TaggedUnion<{
+                readonly human: import("effect/Schema").TaggedStruct<"human", {
+                    readonly actor: import("effect/Schema").TaggedStruct<"human", {
+                        readonly personId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PersonId">;
+                    }>;
+                    readonly sessionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "SessionId">;
+                }>;
+                readonly agent: import("effect/Schema").TaggedStruct<"agent", {
+                    readonly actor: import("effect/Schema").TaggedStruct<"agent", {
+                        readonly agentId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "AgentId">;
+                    }>;
+                    readonly jobId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "JobId">;
+                }>;
+                readonly system: import("effect/Schema").TaggedStruct<"system", {
+                    readonly component: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                }>;
+            }>;
+            readonly occurredAt: import("effect/Schema").DateTimeUtcFromString;
+            readonly causationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "DomainEventId">>;
+            readonly correlationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, "DomainEventCorrelationId">>;
+        }, "Type">[];
+        authorization: import("effect/Schema").Struct.ReadonlySide<{
+            readonly schemaVersion: import("effect/Schema").Literal<1>;
+            readonly authorizationId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionAuthorizationId">;
+            readonly actionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionId">;
+            readonly workspaceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "WorkspaceId">;
+            readonly pluginConnectionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PluginConnectionId">;
+            readonly pluginConnectionRevision: import("effect/Schema").brand<import("effect/Schema").Int, "GovernedActionPluginConnectionRevision">;
+            readonly pluginConnectionAuthorityDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly actionEnvelopeDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly idempotencyKey: import("effect/Schema").brand<import("effect/Schema").String, "GovernedActionIdempotencyKey">;
+            readonly payloadDigest: import("effect/Schema").brand<import("effect/Schema").String, "PluginActionPayloadDigest">;
+            readonly evidenceSetDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly policyDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly expectedRevision: import("effect/Schema").brand<import("effect/Schema").String, "Revision">;
+            readonly capabilityVersion: import("effect/Schema").Int;
+            readonly actor: import("effect/Schema").TaggedStruct<"human", {
+                readonly personId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PersonId">;
+            }>;
+            readonly sessionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "SessionId">;
+            readonly sessionPermission: import("effect/Schema").Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
+            readonly sessionExpiresAt: import("effect/Schema").DateTimeUtcFromString;
+            readonly requiredPermission: import("effect/Schema").Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
+            readonly authorizedAt: import("effect/Schema").DateTimeUtcFromString;
+            readonly expiresAt: import("effect/Schema").DateTimeUtcFromString;
+        }, "Type"> | null;
+        policyEvaluation: import("effect/Schema").Struct.ReadonlySide<{
+            readonly schemaVersion: import("effect/Schema").Literal<1>;
+            readonly actionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionId">;
+            readonly workspaceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "WorkspaceId">;
+            readonly policy: import("effect/Schema").Struct<{
+                readonly policyId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly policyVersion: import("effect/Schema").Int;
+                readonly policyDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly requiredPermission: import("effect/Schema").Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
+            }>;
+            readonly payloadDigest: import("effect/Schema").brand<import("effect/Schema").String, "PluginActionPayloadDigest">;
+            readonly evidenceSetDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly expectedRevision: import("effect/Schema").brand<import("effect/Schema").String, "Revision">;
+            readonly decision: import("effect/Schema").Literals<readonly ["allowed", "denied"]>;
+            readonly evaluatedAt: import("effect/Schema").DateTimeUtcFromString;
+        }, "Type"> | null;
+        attempt: import("effect/Schema").Struct.ReadonlySide<{
+            readonly schemaVersion: import("effect/Schema").Literal<1>;
+            readonly attemptId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionAttemptId">;
+            readonly authorizationId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionAuthorizationId">;
+            readonly actionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionId">;
+            readonly workspaceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "WorkspaceId">;
+            readonly pluginConnectionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PluginConnectionId">;
+            readonly idempotencyKey: import("effect/Schema").brand<import("effect/Schema").String, "GovernedActionIdempotencyKey">;
+            readonly attemptNumber: import("effect/Schema").Literal<1>;
+            readonly actionEnvelopeDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly expectedRevision: import("effect/Schema").brand<import("effect/Schema").String, "Revision">;
+            readonly policyEvaluationDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly preflight: import("effect/Schema").TaggedStruct<"ready", {
+                readonly checkedRevision: import("effect/Schema").brand<import("effect/Schema").String, "Revision">;
+                readonly checkedAt: import("effect/Schema").DateTimeUtcFromString;
+            }>;
+            readonly startedAt: import("effect/Schema").DateTimeUtcFromString;
+        }, "Type"> | null;
+    }, import("../persistence/Persistence.js").PersistenceOperationFailure, never>;
+    readByIdempotencyKey: (input: unknown) => Effect.Effect<{
+        envelope: {
+            readonly providerId: "codecommit" | "codepipeline" | "jira" | "confluence" | "clockify";
+            readonly pluginConnectionId: string & import("effect/Brand").Brand<"PluginConnectionId">;
+            readonly workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">;
+            readonly schemaVersion: 1;
+            readonly causationId: (string & import("effect/Brand").Brand<"DomainEventId">) | null;
+            readonly correlationId: (string & import("effect/Brand").Brand<"DomainEventCorrelationId">) | null;
+            readonly proposal: import("effect/Schema").Struct.ReadonlySide<{
+                readonly proposalKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly capabilityVersion: import("effect/Schema").Int;
+                readonly request: import("effect/Schema").Struct<{
+                    readonly actionKind: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                    readonly target: import("effect/Schema").Struct<{
+                        entityType: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        vendorImmutableId: import("effect/Schema").brand<import("effect/Schema").String, "VendorImmutableId">;
+                    }>;
+                    readonly expectedRevision: import("effect/Schema").brand<import("effect/Schema").String, "Revision">;
+                    readonly payload: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
+                    readonly evidenceIds: import("effect/Schema").$Array<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                }>;
+                readonly payloadDigest: import("effect/Schema").brand<import("effect/Schema").String, "PluginActionPayloadDigest">;
+                readonly summary: import("effect/Schema").String;
+                readonly impact: import("effect/Schema").Struct<{
+                    readonly level: import("effect/Schema").Literals<readonly ["low", "medium", "high", "critical"]>;
+                    readonly summary: import("effect/Schema").String;
+                }>;
+                readonly proposedAt: import("effect/Schema").DateTimeUtcFromString;
+            }, "Type">;
+            readonly idempotencyKey: string & import("effect/Brand").Brand<"GovernedActionIdempotencyKey">;
+            readonly pluginId: string & import("effect/Brand").Brand<string>;
+            readonly actionId: string & import("effect/Brand").Brand<"GovernedActionId">;
+            readonly policy: import("effect/Schema").Struct.ReadonlySide<{
+                readonly policyId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly policyVersion: import("effect/Schema").Int;
+                readonly policyDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly requiredPermission: import("effect/Schema").Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
+            }, "Type">;
+            readonly evidenceSetDigest: string & import("effect/Brand").Brand<string>;
+            readonly pluginConnectionRevision: number & import("effect/Brand").Brand<"GovernedActionPluginConnectionRevision">;
+            readonly pluginConnectionAuthorityDigest: string & import("effect/Brand").Brand<string>;
+            readonly pluginContractVersion: import("effect/Schema").Struct.ReadonlySide<{
+                readonly major: import("effect/Schema").Int;
+                readonly minor: import("effect/Schema").Int;
+                readonly patch: import("effect/Schema").Int;
+            }, "Type">;
+            readonly pluginAdapterVersion: import("effect/Schema").Struct.ReadonlySide<{
+                readonly major: import("effect/Schema").Int;
+                readonly minor: import("effect/Schema").Int;
+                readonly patch: import("effect/Schema").Int;
+            }, "Type">;
+            readonly capability: import("effect/Schema").Struct.ReadonlySide<{
+                readonly capabilityId: import("effect/Schema").Literal<"action.execute">;
+                readonly version: import("effect/Schema").Int;
+            }, "Type">;
+            readonly targetEntityId: string & import("effect/Brand").Brand<"EntityId">;
+            readonly evidence: readonly import("effect/Schema").Struct.ReadonlySide<{
+                readonly workspaceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "WorkspaceId">;
+                readonly evidenceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "EvidenceId">;
+                readonly evidenceClaimIds: import("effect/Schema").$Array<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "EvidenceClaimId">>;
+                readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                readonly validUntil: import("effect/Schema").NullOr<import("effect/Schema").DateTimeUtcFromString>;
+                readonly currentUntil: import("effect/Schema").NullOr<import("effect/Schema").DateTimeUtcFromString>;
+                readonly evaluatedAt: import("effect/Schema").DateTimeUtcFromString;
+                readonly source: import("effect/Schema").Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                readonly validity: import("effect/Schema").Literals<readonly ["valid", "expired"]>;
+            }, "Type">[];
+            readonly origin: import("effect/Schema").Struct.ReadonlySide<{
+                readonly _tag: import("effect/Schema").tag<"human">;
+                readonly actor: import("effect/Schema").TaggedStruct<"human", {
+                    readonly personId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PersonId">;
+                }>;
+                readonly sessionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "SessionId">;
+            }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+                readonly _tag: import("effect/Schema").tag<"agent">;
+                readonly actor: import("effect/Schema").TaggedStruct<"agent", {
+                    readonly agentId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "AgentId">;
+                }>;
+                readonly jobId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "JobId">;
+                readonly initiatingSessionId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "SessionId">>;
+            }, "Type">;
+            readonly proposalExpiresAt: DateTime.Utc;
+            readonly envelopeDigest: string & import("effect/Brand").Brand<string>;
+            readonly releasePublication?: {
+                readonly releaseId: string & import("effect/Brand").Brand<"ReleaseId">;
+                readonly sourceRevisionDigest: string & import("effect/Brand").Brand<string>;
+                readonly sourceRevisionCount: number;
+                readonly predecessorPublicationActionId?: (string & import("effect/Brand").Brand<"GovernedActionId">) | null;
+                readonly templateSourceEntityId?: string & import("effect/Brand").Brand<"EntityId">;
+            };
+        };
+        head: import("effect/Schema").Struct.ReadonlySide<{
+            readonly state: import("effect/Schema").Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>;
+            readonly lineage: import("effect/Schema").TaggedUnion<{
+                readonly accepted: import("effect/Schema").TaggedStruct<"accepted", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly status: import("effect/Schema").Literal<"accepted">;
+                        readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                }>;
+                readonly reconcilable: import("effect/Schema").TaggedStruct<"reconcilable", {
+                    readonly providerOperationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                    readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                }>;
+                readonly manual: import("effect/Schema").TaggedStruct<"manual", {
+                    readonly providerOperationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                }>;
+                readonly none: import("effect/Schema").TaggedStruct<"none", {}>;
+                readonly terminal: import("effect/Schema").TaggedStruct<"terminal", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly observationBasis: import("effect/Schema").optionalKey<import("effect/Schema").Literal<"authorization">>;
+                        readonly status: import("effect/Schema").Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                }>;
+            }>;
+        }, "Type">;
+        headTransition: import("effect/Schema").Struct.ReadonlySide<{
+            readonly commandDigest: import("effect/Schema").brand<import("effect/Schema").String, "GovernedActionCommandDigest">;
+            readonly schemaVersion: import("effect/Schema").Literal<1>;
+            readonly transitionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionTransitionId">;
+            readonly previousTransitionId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionTransitionId">>;
+            readonly commandId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly actionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionId">;
+            readonly workspaceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "WorkspaceId">;
+            readonly sequence: import("effect/Schema").Int;
+            readonly fromState: import("effect/Schema").NullOr<import("effect/Schema").Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>>;
+            readonly toState: import("effect/Schema").Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>;
+            readonly actionEnvelopeDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly command: import("effect/Schema").TaggedUnion<{
+                readonly propose: import("effect/Schema").TaggedStruct<"propose", {}>;
+                readonly authorize: import("effect/Schema").TaggedStruct<"authorize", {
+                    readonly authorizationId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionAuthorizationId">;
+                }>;
+                readonly deny: import("effect/Schema").TaggedStruct<"deny", {
+                    readonly reason: import("effect/Schema").Literals<readonly ["revision-changed", "evidence-stale", "evidence-invalid", "policy-denied", "session-invalid", "capability-changed", "plugin-unavailable", "preflight-blocked"]>;
+                    readonly safeSummary: import("effect/Schema").String;
+                }>;
+                readonly expire: import("effect/Schema").TaggedStruct<"expire", {
+                    readonly reason: import("effect/Schema").Literals<readonly ["proposal-expired", "authorization-expired"]>;
+                }>;
+                readonly cancel: import("effect/Schema").TaggedStruct<"cancel", {
+                    readonly safeSummary: import("effect/Schema").String;
+                }>;
+                readonly start: import("effect/Schema").TaggedStruct<"start", {
+                    readonly attemptId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionAttemptId">;
+                }>;
+                readonly requestCancellation: import("effect/Schema").TaggedStruct<"requestCancellation", {
+                    readonly safeSummary: import("effect/Schema").String;
+                }>;
+                readonly recordAccepted: import("effect/Schema").TaggedStruct<"recordAccepted", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly status: import("effect/Schema").Literal<"accepted">;
+                        readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                }>;
+                readonly recordSucceeded: import("effect/Schema").TaggedStruct<"recordSucceeded", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly observationBasis: import("effect/Schema").optionalKey<import("effect/Schema").Literal<"authorization">>;
+                        readonly status: import("effect/Schema").Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                    readonly source: import("effect/Schema").TaggedUnion<{
+                        readonly direct: import("effect/Schema").TaggedStruct<"direct", {}>;
+                        readonly providerOperation: import("effect/Schema").TaggedStruct<"providerOperation", {
+                            readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        }>;
+                        readonly reconciliation: import("effect/Schema").TaggedStruct<"reconciliation", {
+                            readonly reconciliationKey: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                        }>;
+                    }>;
+                }>;
+                readonly recordFailed: import("effect/Schema").TaggedStruct<"recordFailed", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly observationBasis: import("effect/Schema").optionalKey<import("effect/Schema").Literal<"authorization">>;
+                        readonly status: import("effect/Schema").Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                    readonly source: import("effect/Schema").TaggedUnion<{
+                        readonly direct: import("effect/Schema").TaggedStruct<"direct", {}>;
+                        readonly providerOperation: import("effect/Schema").TaggedStruct<"providerOperation", {
+                            readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        }>;
+                        readonly reconciliation: import("effect/Schema").TaggedStruct<"reconciliation", {
+                            readonly reconciliationKey: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                        }>;
+                    }>;
+                }>;
+                readonly recordUnknown: import("effect/Schema").TaggedStruct<"recordUnknown", {
+                    readonly outcome: import("effect/Schema").TaggedUnion<{
+                        readonly reconcilable: import("effect/Schema").TaggedStruct<"reconcilable", {
+                            readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                            readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                            readonly safeSummary: import("effect/Schema").String;
+                        }>;
+                        readonly manual: import("effect/Schema").TaggedStruct<"manual", {
+                            readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                            readonly safeSummary: import("effect/Schema").String;
+                            readonly reason: import("effect/Schema").Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
+                        }>;
+                    }>;
+                }>;
+                readonly recordCancelled: import("effect/Schema").TaggedStruct<"recordCancelled", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly observationBasis: import("effect/Schema").optionalKey<import("effect/Schema").Literal<"authorization">>;
+                        readonly status: import("effect/Schema").Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                    readonly source: import("effect/Schema").TaggedUnion<{
+                        readonly direct: import("effect/Schema").TaggedStruct<"direct", {}>;
+                        readonly providerOperation: import("effect/Schema").TaggedStruct<"providerOperation", {
+                            readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        }>;
+                        readonly reconciliation: import("effect/Schema").TaggedStruct<"reconciliation", {
+                            readonly reconciliationKey: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                        }>;
+                    }>;
+                }>;
+                readonly reconciliationPending: import("effect/Schema").TaggedStruct<"reconciliationPending", {
+                    readonly checkedAt: import("effect/Schema").DateTimeUtcFromString;
+                    readonly reconciliationKey: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                }>;
+            }>;
+            readonly cause: import("effect/Schema").TaggedUnion<{
+                readonly human: import("effect/Schema").TaggedStruct<"human", {
+                    readonly actor: import("effect/Schema").TaggedStruct<"human", {
+                        readonly personId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PersonId">;
+                    }>;
+                    readonly sessionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "SessionId">;
+                }>;
+                readonly agent: import("effect/Schema").TaggedStruct<"agent", {
+                    readonly actor: import("effect/Schema").TaggedStruct<"agent", {
+                        readonly agentId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "AgentId">;
+                    }>;
+                    readonly jobId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "JobId">;
+                }>;
+                readonly system: import("effect/Schema").TaggedStruct<"system", {
+                    readonly component: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                }>;
+            }>;
+            readonly occurredAt: import("effect/Schema").DateTimeUtcFromString;
+            readonly causationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "DomainEventId">>;
+            readonly correlationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, "DomainEventCorrelationId">>;
+        }, "Type">;
+        history: import("effect/Schema").Struct.ReadonlySide<{
+            readonly commandDigest: import("effect/Schema").brand<import("effect/Schema").String, "GovernedActionCommandDigest">;
+            readonly schemaVersion: import("effect/Schema").Literal<1>;
+            readonly transitionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionTransitionId">;
+            readonly previousTransitionId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionTransitionId">>;
+            readonly commandId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly actionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionId">;
+            readonly workspaceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "WorkspaceId">;
+            readonly sequence: import("effect/Schema").Int;
+            readonly fromState: import("effect/Schema").NullOr<import("effect/Schema").Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>>;
+            readonly toState: import("effect/Schema").Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>;
+            readonly actionEnvelopeDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly command: import("effect/Schema").TaggedUnion<{
+                readonly propose: import("effect/Schema").TaggedStruct<"propose", {}>;
+                readonly authorize: import("effect/Schema").TaggedStruct<"authorize", {
+                    readonly authorizationId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionAuthorizationId">;
+                }>;
+                readonly deny: import("effect/Schema").TaggedStruct<"deny", {
+                    readonly reason: import("effect/Schema").Literals<readonly ["revision-changed", "evidence-stale", "evidence-invalid", "policy-denied", "session-invalid", "capability-changed", "plugin-unavailable", "preflight-blocked"]>;
+                    readonly safeSummary: import("effect/Schema").String;
+                }>;
+                readonly expire: import("effect/Schema").TaggedStruct<"expire", {
+                    readonly reason: import("effect/Schema").Literals<readonly ["proposal-expired", "authorization-expired"]>;
+                }>;
+                readonly cancel: import("effect/Schema").TaggedStruct<"cancel", {
+                    readonly safeSummary: import("effect/Schema").String;
+                }>;
+                readonly start: import("effect/Schema").TaggedStruct<"start", {
+                    readonly attemptId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionAttemptId">;
+                }>;
+                readonly requestCancellation: import("effect/Schema").TaggedStruct<"requestCancellation", {
+                    readonly safeSummary: import("effect/Schema").String;
+                }>;
+                readonly recordAccepted: import("effect/Schema").TaggedStruct<"recordAccepted", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly status: import("effect/Schema").Literal<"accepted">;
+                        readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                }>;
+                readonly recordSucceeded: import("effect/Schema").TaggedStruct<"recordSucceeded", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly observationBasis: import("effect/Schema").optionalKey<import("effect/Schema").Literal<"authorization">>;
+                        readonly status: import("effect/Schema").Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                    readonly source: import("effect/Schema").TaggedUnion<{
+                        readonly direct: import("effect/Schema").TaggedStruct<"direct", {}>;
+                        readonly providerOperation: import("effect/Schema").TaggedStruct<"providerOperation", {
+                            readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        }>;
+                        readonly reconciliation: import("effect/Schema").TaggedStruct<"reconciliation", {
+                            readonly reconciliationKey: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                        }>;
+                    }>;
+                }>;
+                readonly recordFailed: import("effect/Schema").TaggedStruct<"recordFailed", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly observationBasis: import("effect/Schema").optionalKey<import("effect/Schema").Literal<"authorization">>;
+                        readonly status: import("effect/Schema").Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                    readonly source: import("effect/Schema").TaggedUnion<{
+                        readonly direct: import("effect/Schema").TaggedStruct<"direct", {}>;
+                        readonly providerOperation: import("effect/Schema").TaggedStruct<"providerOperation", {
+                            readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        }>;
+                        readonly reconciliation: import("effect/Schema").TaggedStruct<"reconciliation", {
+                            readonly reconciliationKey: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                        }>;
+                    }>;
+                }>;
+                readonly recordUnknown: import("effect/Schema").TaggedStruct<"recordUnknown", {
+                    readonly outcome: import("effect/Schema").TaggedUnion<{
+                        readonly reconcilable: import("effect/Schema").TaggedStruct<"reconcilable", {
+                            readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                            readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                            readonly safeSummary: import("effect/Schema").String;
+                        }>;
+                        readonly manual: import("effect/Schema").TaggedStruct<"manual", {
+                            readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                            readonly safeSummary: import("effect/Schema").String;
+                            readonly reason: import("effect/Schema").Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
+                        }>;
+                    }>;
+                }>;
+                readonly recordCancelled: import("effect/Schema").TaggedStruct<"recordCancelled", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly observationBasis: import("effect/Schema").optionalKey<import("effect/Schema").Literal<"authorization">>;
+                        readonly status: import("effect/Schema").Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                    readonly source: import("effect/Schema").TaggedUnion<{
+                        readonly direct: import("effect/Schema").TaggedStruct<"direct", {}>;
+                        readonly providerOperation: import("effect/Schema").TaggedStruct<"providerOperation", {
+                            readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        }>;
+                        readonly reconciliation: import("effect/Schema").TaggedStruct<"reconciliation", {
+                            readonly reconciliationKey: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                        }>;
+                    }>;
+                }>;
+                readonly reconciliationPending: import("effect/Schema").TaggedStruct<"reconciliationPending", {
+                    readonly checkedAt: import("effect/Schema").DateTimeUtcFromString;
+                    readonly reconciliationKey: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                }>;
+            }>;
+            readonly cause: import("effect/Schema").TaggedUnion<{
+                readonly human: import("effect/Schema").TaggedStruct<"human", {
+                    readonly actor: import("effect/Schema").TaggedStruct<"human", {
+                        readonly personId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PersonId">;
+                    }>;
+                    readonly sessionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "SessionId">;
+                }>;
+                readonly agent: import("effect/Schema").TaggedStruct<"agent", {
+                    readonly actor: import("effect/Schema").TaggedStruct<"agent", {
+                        readonly agentId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "AgentId">;
+                    }>;
+                    readonly jobId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "JobId">;
+                }>;
+                readonly system: import("effect/Schema").TaggedStruct<"system", {
+                    readonly component: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                }>;
+            }>;
+            readonly occurredAt: import("effect/Schema").DateTimeUtcFromString;
+            readonly causationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "DomainEventId">>;
+            readonly correlationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, "DomainEventCorrelationId">>;
+        }, "Type">[];
+        authorization: import("effect/Schema").Struct.ReadonlySide<{
+            readonly schemaVersion: import("effect/Schema").Literal<1>;
+            readonly authorizationId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionAuthorizationId">;
+            readonly actionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionId">;
+            readonly workspaceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "WorkspaceId">;
+            readonly pluginConnectionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PluginConnectionId">;
+            readonly pluginConnectionRevision: import("effect/Schema").brand<import("effect/Schema").Int, "GovernedActionPluginConnectionRevision">;
+            readonly pluginConnectionAuthorityDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly actionEnvelopeDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly idempotencyKey: import("effect/Schema").brand<import("effect/Schema").String, "GovernedActionIdempotencyKey">;
+            readonly payloadDigest: import("effect/Schema").brand<import("effect/Schema").String, "PluginActionPayloadDigest">;
+            readonly evidenceSetDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly policyDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly expectedRevision: import("effect/Schema").brand<import("effect/Schema").String, "Revision">;
+            readonly capabilityVersion: import("effect/Schema").Int;
+            readonly actor: import("effect/Schema").TaggedStruct<"human", {
+                readonly personId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PersonId">;
+            }>;
+            readonly sessionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "SessionId">;
+            readonly sessionPermission: import("effect/Schema").Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
+            readonly sessionExpiresAt: import("effect/Schema").DateTimeUtcFromString;
+            readonly requiredPermission: import("effect/Schema").Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
+            readonly authorizedAt: import("effect/Schema").DateTimeUtcFromString;
+            readonly expiresAt: import("effect/Schema").DateTimeUtcFromString;
+        }, "Type"> | null;
+        policyEvaluation: import("effect/Schema").Struct.ReadonlySide<{
+            readonly schemaVersion: import("effect/Schema").Literal<1>;
+            readonly actionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionId">;
+            readonly workspaceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "WorkspaceId">;
+            readonly policy: import("effect/Schema").Struct<{
+                readonly policyId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly policyVersion: import("effect/Schema").Int;
+                readonly policyDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly requiredPermission: import("effect/Schema").Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
+            }>;
+            readonly payloadDigest: import("effect/Schema").brand<import("effect/Schema").String, "PluginActionPayloadDigest">;
+            readonly evidenceSetDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly expectedRevision: import("effect/Schema").brand<import("effect/Schema").String, "Revision">;
+            readonly decision: import("effect/Schema").Literals<readonly ["allowed", "denied"]>;
+            readonly evaluatedAt: import("effect/Schema").DateTimeUtcFromString;
+        }, "Type"> | null;
+        attempt: import("effect/Schema").Struct.ReadonlySide<{
+            readonly schemaVersion: import("effect/Schema").Literal<1>;
+            readonly attemptId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionAttemptId">;
+            readonly authorizationId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionAuthorizationId">;
+            readonly actionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionId">;
+            readonly workspaceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "WorkspaceId">;
+            readonly pluginConnectionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PluginConnectionId">;
+            readonly idempotencyKey: import("effect/Schema").brand<import("effect/Schema").String, "GovernedActionIdempotencyKey">;
+            readonly attemptNumber: import("effect/Schema").Literal<1>;
+            readonly actionEnvelopeDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly expectedRevision: import("effect/Schema").brand<import("effect/Schema").String, "Revision">;
+            readonly policyEvaluationDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly preflight: import("effect/Schema").TaggedStruct<"ready", {
+                readonly checkedRevision: import("effect/Schema").brand<import("effect/Schema").String, "Revision">;
+                readonly checkedAt: import("effect/Schema").DateTimeUtcFromString;
+            }>;
+            readonly startedAt: import("effect/Schema").DateTimeUtcFromString;
+        }, "Type"> | null;
+    }, import("../persistence/Persistence.js").PersistenceOperationFailure, never>;
+    readLatestTerminalByTarget: (input: unknown) => Effect.Effect<readonly import("effect/Schema").Struct.ReadonlySide<{
+        readonly envelope: import("effect/Schema").Struct<{
+            readonly envelopeDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly schemaVersion: import("effect/Schema").Literal<1>;
+            readonly actionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionId">;
+            readonly idempotencyKey: import("effect/Schema").brand<import("effect/Schema").String, "GovernedActionIdempotencyKey">;
+            readonly workspaceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "WorkspaceId">;
+            readonly pluginConnectionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PluginConnectionId">;
+            readonly pluginConnectionRevision: import("effect/Schema").brand<import("effect/Schema").Int, "GovernedActionPluginConnectionRevision">;
+            readonly pluginConnectionAuthorityDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly pluginId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly pluginContractVersion: import("effect/Schema").Struct<{
+                readonly major: import("effect/Schema").Int;
+                readonly minor: import("effect/Schema").Int;
+                readonly patch: import("effect/Schema").Int;
+            }>;
+            readonly pluginAdapterVersion: import("effect/Schema").Struct<{
+                readonly major: import("effect/Schema").Int;
+                readonly minor: import("effect/Schema").Int;
+                readonly patch: import("effect/Schema").Int;
+            }>;
+            readonly providerId: import("effect/Schema").Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+            readonly capability: import("effect/Schema").Struct<{
+                readonly capabilityId: import("effect/Schema").Literal<"action.execute">;
+                readonly version: import("effect/Schema").Int;
+            }>;
+            readonly targetEntityId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "EntityId">;
+            readonly proposal: import("effect/Schema").Struct<{
+                readonly proposalKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly capabilityVersion: import("effect/Schema").Int;
+                readonly request: import("effect/Schema").Struct<{
+                    readonly actionKind: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                    readonly target: import("effect/Schema").Struct<{
+                        entityType: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        vendorImmutableId: import("effect/Schema").brand<import("effect/Schema").String, "VendorImmutableId">;
+                    }>;
+                    readonly expectedRevision: import("effect/Schema").brand<import("effect/Schema").String, "Revision">;
+                    readonly payload: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
+                    readonly evidenceIds: import("effect/Schema").$Array<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                }>;
+                readonly payloadDigest: import("effect/Schema").brand<import("effect/Schema").String, "PluginActionPayloadDigest">;
+                readonly summary: import("effect/Schema").String;
+                readonly impact: import("effect/Schema").Struct<{
+                    readonly level: import("effect/Schema").Literals<readonly ["low", "medium", "high", "critical"]>;
+                    readonly summary: import("effect/Schema").String;
+                }>;
+                readonly proposedAt: import("effect/Schema").DateTimeUtcFromString;
+            }>;
+            readonly evidence: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+                readonly workspaceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "WorkspaceId">;
+                readonly evidenceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "EvidenceId">;
+                readonly evidenceClaimIds: import("effect/Schema").$Array<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "EvidenceClaimId">>;
+                readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                readonly validUntil: import("effect/Schema").NullOr<import("effect/Schema").DateTimeUtcFromString>;
+                readonly currentUntil: import("effect/Schema").NullOr<import("effect/Schema").DateTimeUtcFromString>;
+                readonly evaluatedAt: import("effect/Schema").DateTimeUtcFromString;
+                readonly source: import("effect/Schema").Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                readonly validity: import("effect/Schema").Literals<readonly ["valid", "expired"]>;
+            }>>;
+            readonly evidenceSetDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly policy: import("effect/Schema").Struct<{
+                readonly policyId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly policyVersion: import("effect/Schema").Int;
+                readonly policyDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly requiredPermission: import("effect/Schema").Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
+            }>;
+            readonly origin: import("effect/Schema").TaggedUnion<{
+                readonly human: import("effect/Schema").TaggedStruct<"human", {
+                    readonly actor: import("effect/Schema").TaggedStruct<"human", {
+                        readonly personId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PersonId">;
+                    }>;
+                    readonly sessionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "SessionId">;
+                }>;
+                readonly agent: import("effect/Schema").TaggedStruct<"agent", {
+                    readonly actor: import("effect/Schema").TaggedStruct<"agent", {
+                        readonly agentId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "AgentId">;
+                    }>;
+                    readonly jobId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "JobId">;
+                    readonly initiatingSessionId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "SessionId">>;
+                }>;
+            }>;
+            readonly proposalExpiresAt: import("effect/Schema").DateTimeUtcFromString;
+            readonly causationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "DomainEventId">>;
+            readonly correlationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, "DomainEventCorrelationId">>;
+            readonly releasePublication: import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+                readonly releaseId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "ReleaseId">;
+                readonly predecessorPublicationActionId: import("effect/Schema").optionalKey<import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionId">>>;
+                readonly templateSourceEntityId: import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "EntityId">>;
+                readonly sourceRevisionDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly sourceRevisionCount: import("effect/Schema").Int;
+            }>>;
+        }>;
+        readonly head: import("effect/Schema").Struct<{
+            readonly state: import("effect/Schema").Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>;
+            readonly lineage: import("effect/Schema").TaggedUnion<{
+                readonly accepted: import("effect/Schema").TaggedStruct<"accepted", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly status: import("effect/Schema").Literal<"accepted">;
+                        readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                }>;
+                readonly reconcilable: import("effect/Schema").TaggedStruct<"reconcilable", {
+                    readonly providerOperationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                    readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                }>;
+                readonly manual: import("effect/Schema").TaggedStruct<"manual", {
+                    readonly providerOperationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                }>;
+                readonly none: import("effect/Schema").TaggedStruct<"none", {}>;
+                readonly terminal: import("effect/Schema").TaggedStruct<"terminal", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly observationBasis: import("effect/Schema").optionalKey<import("effect/Schema").Literal<"authorization">>;
+                        readonly status: import("effect/Schema").Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                }>;
+            }>;
+        }>;
+        readonly headTransition: import("effect/Schema").Struct<{
+            readonly commandDigest: import("effect/Schema").brand<import("effect/Schema").String, "GovernedActionCommandDigest">;
+            readonly schemaVersion: import("effect/Schema").Literal<1>;
+            readonly transitionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionTransitionId">;
+            readonly previousTransitionId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionTransitionId">>;
+            readonly commandId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly actionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionId">;
+            readonly workspaceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "WorkspaceId">;
+            readonly sequence: import("effect/Schema").Int;
+            readonly fromState: import("effect/Schema").NullOr<import("effect/Schema").Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>>;
+            readonly toState: import("effect/Schema").Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>;
+            readonly actionEnvelopeDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly command: import("effect/Schema").TaggedUnion<{
+                readonly propose: import("effect/Schema").TaggedStruct<"propose", {}>;
+                readonly authorize: import("effect/Schema").TaggedStruct<"authorize", {
+                    readonly authorizationId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionAuthorizationId">;
+                }>;
+                readonly deny: import("effect/Schema").TaggedStruct<"deny", {
+                    readonly reason: import("effect/Schema").Literals<readonly ["revision-changed", "evidence-stale", "evidence-invalid", "policy-denied", "session-invalid", "capability-changed", "plugin-unavailable", "preflight-blocked"]>;
+                    readonly safeSummary: import("effect/Schema").String;
+                }>;
+                readonly expire: import("effect/Schema").TaggedStruct<"expire", {
+                    readonly reason: import("effect/Schema").Literals<readonly ["proposal-expired", "authorization-expired"]>;
+                }>;
+                readonly cancel: import("effect/Schema").TaggedStruct<"cancel", {
+                    readonly safeSummary: import("effect/Schema").String;
+                }>;
+                readonly start: import("effect/Schema").TaggedStruct<"start", {
+                    readonly attemptId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionAttemptId">;
+                }>;
+                readonly requestCancellation: import("effect/Schema").TaggedStruct<"requestCancellation", {
+                    readonly safeSummary: import("effect/Schema").String;
+                }>;
+                readonly recordAccepted: import("effect/Schema").TaggedStruct<"recordAccepted", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly status: import("effect/Schema").Literal<"accepted">;
+                        readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                }>;
+                readonly recordSucceeded: import("effect/Schema").TaggedStruct<"recordSucceeded", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly observationBasis: import("effect/Schema").optionalKey<import("effect/Schema").Literal<"authorization">>;
+                        readonly status: import("effect/Schema").Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                    readonly source: import("effect/Schema").TaggedUnion<{
+                        readonly direct: import("effect/Schema").TaggedStruct<"direct", {}>;
+                        readonly providerOperation: import("effect/Schema").TaggedStruct<"providerOperation", {
+                            readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        }>;
+                        readonly reconciliation: import("effect/Schema").TaggedStruct<"reconciliation", {
+                            readonly reconciliationKey: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                        }>;
+                    }>;
+                }>;
+                readonly recordFailed: import("effect/Schema").TaggedStruct<"recordFailed", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly observationBasis: import("effect/Schema").optionalKey<import("effect/Schema").Literal<"authorization">>;
+                        readonly status: import("effect/Schema").Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                    readonly source: import("effect/Schema").TaggedUnion<{
+                        readonly direct: import("effect/Schema").TaggedStruct<"direct", {}>;
+                        readonly providerOperation: import("effect/Schema").TaggedStruct<"providerOperation", {
+                            readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        }>;
+                        readonly reconciliation: import("effect/Schema").TaggedStruct<"reconciliation", {
+                            readonly reconciliationKey: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                        }>;
+                    }>;
+                }>;
+                readonly recordUnknown: import("effect/Schema").TaggedStruct<"recordUnknown", {
+                    readonly outcome: import("effect/Schema").TaggedUnion<{
+                        readonly reconcilable: import("effect/Schema").TaggedStruct<"reconcilable", {
+                            readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                            readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                            readonly safeSummary: import("effect/Schema").String;
+                        }>;
+                        readonly manual: import("effect/Schema").TaggedStruct<"manual", {
+                            readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                            readonly safeSummary: import("effect/Schema").String;
+                            readonly reason: import("effect/Schema").Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
+                        }>;
+                    }>;
+                }>;
+                readonly recordCancelled: import("effect/Schema").TaggedStruct<"recordCancelled", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly observationBasis: import("effect/Schema").optionalKey<import("effect/Schema").Literal<"authorization">>;
+                        readonly status: import("effect/Schema").Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                    readonly source: import("effect/Schema").TaggedUnion<{
+                        readonly direct: import("effect/Schema").TaggedStruct<"direct", {}>;
+                        readonly providerOperation: import("effect/Schema").TaggedStruct<"providerOperation", {
+                            readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        }>;
+                        readonly reconciliation: import("effect/Schema").TaggedStruct<"reconciliation", {
+                            readonly reconciliationKey: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                        }>;
+                    }>;
+                }>;
+                readonly reconciliationPending: import("effect/Schema").TaggedStruct<"reconciliationPending", {
+                    readonly checkedAt: import("effect/Schema").DateTimeUtcFromString;
+                    readonly reconciliationKey: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                }>;
+            }>;
+            readonly cause: import("effect/Schema").TaggedUnion<{
+                readonly human: import("effect/Schema").TaggedStruct<"human", {
+                    readonly actor: import("effect/Schema").TaggedStruct<"human", {
+                        readonly personId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PersonId">;
+                    }>;
+                    readonly sessionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "SessionId">;
+                }>;
+                readonly agent: import("effect/Schema").TaggedStruct<"agent", {
+                    readonly actor: import("effect/Schema").TaggedStruct<"agent", {
+                        readonly agentId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "AgentId">;
+                    }>;
+                    readonly jobId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "JobId">;
+                }>;
+                readonly system: import("effect/Schema").TaggedStruct<"system", {
+                    readonly component: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                }>;
+            }>;
+            readonly occurredAt: import("effect/Schema").DateTimeUtcFromString;
+            readonly causationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "DomainEventId">>;
+            readonly correlationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, "DomainEventCorrelationId">>;
+        }>;
+        readonly history: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+            readonly commandDigest: import("effect/Schema").brand<import("effect/Schema").String, "GovernedActionCommandDigest">;
+            readonly schemaVersion: import("effect/Schema").Literal<1>;
+            readonly transitionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionTransitionId">;
+            readonly previousTransitionId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionTransitionId">>;
+            readonly commandId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly actionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionId">;
+            readonly workspaceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "WorkspaceId">;
+            readonly sequence: import("effect/Schema").Int;
+            readonly fromState: import("effect/Schema").NullOr<import("effect/Schema").Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>>;
+            readonly toState: import("effect/Schema").Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>;
+            readonly actionEnvelopeDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly command: import("effect/Schema").TaggedUnion<{
+                readonly propose: import("effect/Schema").TaggedStruct<"propose", {}>;
+                readonly authorize: import("effect/Schema").TaggedStruct<"authorize", {
+                    readonly authorizationId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionAuthorizationId">;
+                }>;
+                readonly deny: import("effect/Schema").TaggedStruct<"deny", {
+                    readonly reason: import("effect/Schema").Literals<readonly ["revision-changed", "evidence-stale", "evidence-invalid", "policy-denied", "session-invalid", "capability-changed", "plugin-unavailable", "preflight-blocked"]>;
+                    readonly safeSummary: import("effect/Schema").String;
+                }>;
+                readonly expire: import("effect/Schema").TaggedStruct<"expire", {
+                    readonly reason: import("effect/Schema").Literals<readonly ["proposal-expired", "authorization-expired"]>;
+                }>;
+                readonly cancel: import("effect/Schema").TaggedStruct<"cancel", {
+                    readonly safeSummary: import("effect/Schema").String;
+                }>;
+                readonly start: import("effect/Schema").TaggedStruct<"start", {
+                    readonly attemptId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionAttemptId">;
+                }>;
+                readonly requestCancellation: import("effect/Schema").TaggedStruct<"requestCancellation", {
+                    readonly safeSummary: import("effect/Schema").String;
+                }>;
+                readonly recordAccepted: import("effect/Schema").TaggedStruct<"recordAccepted", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly status: import("effect/Schema").Literal<"accepted">;
+                        readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                }>;
+                readonly recordSucceeded: import("effect/Schema").TaggedStruct<"recordSucceeded", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly observationBasis: import("effect/Schema").optionalKey<import("effect/Schema").Literal<"authorization">>;
+                        readonly status: import("effect/Schema").Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                    readonly source: import("effect/Schema").TaggedUnion<{
+                        readonly direct: import("effect/Schema").TaggedStruct<"direct", {}>;
+                        readonly providerOperation: import("effect/Schema").TaggedStruct<"providerOperation", {
+                            readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        }>;
+                        readonly reconciliation: import("effect/Schema").TaggedStruct<"reconciliation", {
+                            readonly reconciliationKey: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                        }>;
+                    }>;
+                }>;
+                readonly recordFailed: import("effect/Schema").TaggedStruct<"recordFailed", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly observationBasis: import("effect/Schema").optionalKey<import("effect/Schema").Literal<"authorization">>;
+                        readonly status: import("effect/Schema").Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                    readonly source: import("effect/Schema").TaggedUnion<{
+                        readonly direct: import("effect/Schema").TaggedStruct<"direct", {}>;
+                        readonly providerOperation: import("effect/Schema").TaggedStruct<"providerOperation", {
+                            readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        }>;
+                        readonly reconciliation: import("effect/Schema").TaggedStruct<"reconciliation", {
+                            readonly reconciliationKey: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                        }>;
+                    }>;
+                }>;
+                readonly recordUnknown: import("effect/Schema").TaggedStruct<"recordUnknown", {
+                    readonly outcome: import("effect/Schema").TaggedUnion<{
+                        readonly reconcilable: import("effect/Schema").TaggedStruct<"reconcilable", {
+                            readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                            readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                            readonly safeSummary: import("effect/Schema").String;
+                        }>;
+                        readonly manual: import("effect/Schema").TaggedStruct<"manual", {
+                            readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                            readonly safeSummary: import("effect/Schema").String;
+                            readonly reason: import("effect/Schema").Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
+                        }>;
+                    }>;
+                }>;
+                readonly recordCancelled: import("effect/Schema").TaggedStruct<"recordCancelled", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly observationBasis: import("effect/Schema").optionalKey<import("effect/Schema").Literal<"authorization">>;
+                        readonly status: import("effect/Schema").Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                    readonly source: import("effect/Schema").TaggedUnion<{
+                        readonly direct: import("effect/Schema").TaggedStruct<"direct", {}>;
+                        readonly providerOperation: import("effect/Schema").TaggedStruct<"providerOperation", {
+                            readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        }>;
+                        readonly reconciliation: import("effect/Schema").TaggedStruct<"reconciliation", {
+                            readonly reconciliationKey: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                        }>;
+                    }>;
+                }>;
+                readonly reconciliationPending: import("effect/Schema").TaggedStruct<"reconciliationPending", {
+                    readonly checkedAt: import("effect/Schema").DateTimeUtcFromString;
+                    readonly reconciliationKey: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                }>;
+            }>;
+            readonly cause: import("effect/Schema").TaggedUnion<{
+                readonly human: import("effect/Schema").TaggedStruct<"human", {
+                    readonly actor: import("effect/Schema").TaggedStruct<"human", {
+                        readonly personId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PersonId">;
+                    }>;
+                    readonly sessionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "SessionId">;
+                }>;
+                readonly agent: import("effect/Schema").TaggedStruct<"agent", {
+                    readonly actor: import("effect/Schema").TaggedStruct<"agent", {
+                        readonly agentId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "AgentId">;
+                    }>;
+                    readonly jobId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "JobId">;
+                }>;
+                readonly system: import("effect/Schema").TaggedStruct<"system", {
+                    readonly component: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                }>;
+            }>;
+            readonly occurredAt: import("effect/Schema").DateTimeUtcFromString;
+            readonly causationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "DomainEventId">>;
+            readonly correlationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, "DomainEventCorrelationId">>;
+        }>>;
+        readonly authorization: import("effect/Schema").NullOr<import("effect/Schema").Struct<{
+            readonly schemaVersion: import("effect/Schema").Literal<1>;
+            readonly authorizationId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionAuthorizationId">;
+            readonly actionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionId">;
+            readonly workspaceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "WorkspaceId">;
+            readonly pluginConnectionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PluginConnectionId">;
+            readonly pluginConnectionRevision: import("effect/Schema").brand<import("effect/Schema").Int, "GovernedActionPluginConnectionRevision">;
+            readonly pluginConnectionAuthorityDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly actionEnvelopeDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly idempotencyKey: import("effect/Schema").brand<import("effect/Schema").String, "GovernedActionIdempotencyKey">;
+            readonly payloadDigest: import("effect/Schema").brand<import("effect/Schema").String, "PluginActionPayloadDigest">;
+            readonly evidenceSetDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly policyDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly expectedRevision: import("effect/Schema").brand<import("effect/Schema").String, "Revision">;
+            readonly capabilityVersion: import("effect/Schema").Int;
+            readonly actor: import("effect/Schema").TaggedStruct<"human", {
+                readonly personId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PersonId">;
+            }>;
+            readonly sessionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "SessionId">;
+            readonly sessionPermission: import("effect/Schema").Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
+            readonly sessionExpiresAt: import("effect/Schema").DateTimeUtcFromString;
+            readonly requiredPermission: import("effect/Schema").Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
+            readonly authorizedAt: import("effect/Schema").DateTimeUtcFromString;
+            readonly expiresAt: import("effect/Schema").DateTimeUtcFromString;
+        }>>;
+        readonly policyEvaluation: import("effect/Schema").NullOr<import("effect/Schema").Struct<{
+            readonly schemaVersion: import("effect/Schema").Literal<1>;
+            readonly actionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionId">;
+            readonly workspaceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "WorkspaceId">;
+            readonly policy: import("effect/Schema").Struct<{
+                readonly policyId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly policyVersion: import("effect/Schema").Int;
+                readonly policyDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly requiredPermission: import("effect/Schema").Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
+            }>;
+            readonly payloadDigest: import("effect/Schema").brand<import("effect/Schema").String, "PluginActionPayloadDigest">;
+            readonly evidenceSetDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly expectedRevision: import("effect/Schema").brand<import("effect/Schema").String, "Revision">;
+            readonly decision: import("effect/Schema").Literals<readonly ["allowed", "denied"]>;
+            readonly evaluatedAt: import("effect/Schema").DateTimeUtcFromString;
+        }>>;
+        readonly attempt: import("effect/Schema").NullOr<import("effect/Schema").Struct<{
+            readonly schemaVersion: import("effect/Schema").Literal<1>;
+            readonly attemptId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionAttemptId">;
+            readonly authorizationId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionAuthorizationId">;
+            readonly actionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionId">;
+            readonly workspaceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "WorkspaceId">;
+            readonly pluginConnectionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PluginConnectionId">;
+            readonly idempotencyKey: import("effect/Schema").brand<import("effect/Schema").String, "GovernedActionIdempotencyKey">;
+            readonly attemptNumber: import("effect/Schema").Literal<1>;
+            readonly actionEnvelopeDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly expectedRevision: import("effect/Schema").brand<import("effect/Schema").String, "Revision">;
+            readonly policyEvaluationDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly preflight: import("effect/Schema").TaggedStruct<"ready", {
+                readonly checkedRevision: import("effect/Schema").brand<import("effect/Schema").String, "Revision">;
+                readonly checkedAt: import("effect/Schema").DateTimeUtcFromString;
+            }>;
+            readonly startedAt: import("effect/Schema").DateTimeUtcFromString;
+        }>>;
+    }, "Type">[], import("../persistence/Persistence.js").PersistenceOperationFailure, never>;
+    readLatestTerminalReleasePublications: (input: unknown) => Effect.Effect<{
+        envelope: {
+            readonly providerId: "codecommit" | "codepipeline" | "jira" | "confluence" | "clockify";
+            readonly pluginConnectionId: string & import("effect/Brand").Brand<"PluginConnectionId">;
+            readonly workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">;
+            readonly schemaVersion: 1;
+            readonly causationId: (string & import("effect/Brand").Brand<"DomainEventId">) | null;
+            readonly correlationId: (string & import("effect/Brand").Brand<"DomainEventCorrelationId">) | null;
+            readonly proposal: import("effect/Schema").Struct.ReadonlySide<{
+                readonly proposalKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly capabilityVersion: import("effect/Schema").Int;
+                readonly request: import("effect/Schema").Struct<{
+                    readonly actionKind: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                    readonly target: import("effect/Schema").Struct<{
+                        entityType: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        vendorImmutableId: import("effect/Schema").brand<import("effect/Schema").String, "VendorImmutableId">;
+                    }>;
+                    readonly expectedRevision: import("effect/Schema").brand<import("effect/Schema").String, "Revision">;
+                    readonly payload: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
+                    readonly evidenceIds: import("effect/Schema").$Array<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                }>;
+                readonly payloadDigest: import("effect/Schema").brand<import("effect/Schema").String, "PluginActionPayloadDigest">;
+                readonly summary: import("effect/Schema").String;
+                readonly impact: import("effect/Schema").Struct<{
+                    readonly level: import("effect/Schema").Literals<readonly ["low", "medium", "high", "critical"]>;
+                    readonly summary: import("effect/Schema").String;
+                }>;
+                readonly proposedAt: import("effect/Schema").DateTimeUtcFromString;
+            }, "Type">;
+            readonly idempotencyKey: string & import("effect/Brand").Brand<"GovernedActionIdempotencyKey">;
+            readonly pluginId: string & import("effect/Brand").Brand<string>;
+            readonly actionId: string & import("effect/Brand").Brand<"GovernedActionId">;
+            readonly policy: import("effect/Schema").Struct.ReadonlySide<{
+                readonly policyId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly policyVersion: import("effect/Schema").Int;
+                readonly policyDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly requiredPermission: import("effect/Schema").Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
+            }, "Type">;
+            readonly evidenceSetDigest: string & import("effect/Brand").Brand<string>;
+            readonly pluginConnectionRevision: number & import("effect/Brand").Brand<"GovernedActionPluginConnectionRevision">;
+            readonly pluginConnectionAuthorityDigest: string & import("effect/Brand").Brand<string>;
+            readonly pluginContractVersion: import("effect/Schema").Struct.ReadonlySide<{
+                readonly major: import("effect/Schema").Int;
+                readonly minor: import("effect/Schema").Int;
+                readonly patch: import("effect/Schema").Int;
+            }, "Type">;
+            readonly pluginAdapterVersion: import("effect/Schema").Struct.ReadonlySide<{
+                readonly major: import("effect/Schema").Int;
+                readonly minor: import("effect/Schema").Int;
+                readonly patch: import("effect/Schema").Int;
+            }, "Type">;
+            readonly capability: import("effect/Schema").Struct.ReadonlySide<{
+                readonly capabilityId: import("effect/Schema").Literal<"action.execute">;
+                readonly version: import("effect/Schema").Int;
+            }, "Type">;
+            readonly targetEntityId: string & import("effect/Brand").Brand<"EntityId">;
+            readonly evidence: readonly import("effect/Schema").Struct.ReadonlySide<{
+                readonly workspaceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "WorkspaceId">;
+                readonly evidenceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "EvidenceId">;
+                readonly evidenceClaimIds: import("effect/Schema").$Array<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "EvidenceClaimId">>;
+                readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                readonly validUntil: import("effect/Schema").NullOr<import("effect/Schema").DateTimeUtcFromString>;
+                readonly currentUntil: import("effect/Schema").NullOr<import("effect/Schema").DateTimeUtcFromString>;
+                readonly evaluatedAt: import("effect/Schema").DateTimeUtcFromString;
+                readonly source: import("effect/Schema").Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                readonly validity: import("effect/Schema").Literals<readonly ["valid", "expired"]>;
+            }, "Type">[];
+            readonly origin: import("effect/Schema").Struct.ReadonlySide<{
+                readonly _tag: import("effect/Schema").tag<"human">;
+                readonly actor: import("effect/Schema").TaggedStruct<"human", {
+                    readonly personId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PersonId">;
+                }>;
+                readonly sessionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "SessionId">;
+            }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+                readonly _tag: import("effect/Schema").tag<"agent">;
+                readonly actor: import("effect/Schema").TaggedStruct<"agent", {
+                    readonly agentId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "AgentId">;
+                }>;
+                readonly jobId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "JobId">;
+                readonly initiatingSessionId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "SessionId">>;
+            }, "Type">;
+            readonly proposalExpiresAt: DateTime.Utc;
+            readonly envelopeDigest: string & import("effect/Brand").Brand<string>;
+            readonly releasePublication?: {
+                readonly releaseId: string & import("effect/Brand").Brand<"ReleaseId">;
+                readonly sourceRevisionDigest: string & import("effect/Brand").Brand<string>;
+                readonly sourceRevisionCount: number;
+                readonly predecessorPublicationActionId?: (string & import("effect/Brand").Brand<"GovernedActionId">) | null;
+                readonly templateSourceEntityId?: string & import("effect/Brand").Brand<"EntityId">;
+            };
+        };
+        head: import("effect/Schema").Struct.ReadonlySide<{
+            readonly state: import("effect/Schema").Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>;
+            readonly lineage: import("effect/Schema").TaggedUnion<{
+                readonly accepted: import("effect/Schema").TaggedStruct<"accepted", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly status: import("effect/Schema").Literal<"accepted">;
+                        readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                }>;
+                readonly reconcilable: import("effect/Schema").TaggedStruct<"reconcilable", {
+                    readonly providerOperationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                    readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                }>;
+                readonly manual: import("effect/Schema").TaggedStruct<"manual", {
+                    readonly providerOperationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                }>;
+                readonly none: import("effect/Schema").TaggedStruct<"none", {}>;
+                readonly terminal: import("effect/Schema").TaggedStruct<"terminal", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly observationBasis: import("effect/Schema").optionalKey<import("effect/Schema").Literal<"authorization">>;
+                        readonly status: import("effect/Schema").Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                }>;
+            }>;
+        }, "Type">;
+        headTransition: import("effect/Schema").Struct.ReadonlySide<{
+            readonly commandDigest: import("effect/Schema").brand<import("effect/Schema").String, "GovernedActionCommandDigest">;
+            readonly schemaVersion: import("effect/Schema").Literal<1>;
+            readonly transitionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionTransitionId">;
+            readonly previousTransitionId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionTransitionId">>;
+            readonly commandId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly actionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionId">;
+            readonly workspaceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "WorkspaceId">;
+            readonly sequence: import("effect/Schema").Int;
+            readonly fromState: import("effect/Schema").NullOr<import("effect/Schema").Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>>;
+            readonly toState: import("effect/Schema").Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>;
+            readonly actionEnvelopeDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly command: import("effect/Schema").TaggedUnion<{
+                readonly propose: import("effect/Schema").TaggedStruct<"propose", {}>;
+                readonly authorize: import("effect/Schema").TaggedStruct<"authorize", {
+                    readonly authorizationId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionAuthorizationId">;
+                }>;
+                readonly deny: import("effect/Schema").TaggedStruct<"deny", {
+                    readonly reason: import("effect/Schema").Literals<readonly ["revision-changed", "evidence-stale", "evidence-invalid", "policy-denied", "session-invalid", "capability-changed", "plugin-unavailable", "preflight-blocked"]>;
+                    readonly safeSummary: import("effect/Schema").String;
+                }>;
+                readonly expire: import("effect/Schema").TaggedStruct<"expire", {
+                    readonly reason: import("effect/Schema").Literals<readonly ["proposal-expired", "authorization-expired"]>;
+                }>;
+                readonly cancel: import("effect/Schema").TaggedStruct<"cancel", {
+                    readonly safeSummary: import("effect/Schema").String;
+                }>;
+                readonly start: import("effect/Schema").TaggedStruct<"start", {
+                    readonly attemptId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionAttemptId">;
+                }>;
+                readonly requestCancellation: import("effect/Schema").TaggedStruct<"requestCancellation", {
+                    readonly safeSummary: import("effect/Schema").String;
+                }>;
+                readonly recordAccepted: import("effect/Schema").TaggedStruct<"recordAccepted", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly status: import("effect/Schema").Literal<"accepted">;
+                        readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                }>;
+                readonly recordSucceeded: import("effect/Schema").TaggedStruct<"recordSucceeded", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly observationBasis: import("effect/Schema").optionalKey<import("effect/Schema").Literal<"authorization">>;
+                        readonly status: import("effect/Schema").Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                    readonly source: import("effect/Schema").TaggedUnion<{
+                        readonly direct: import("effect/Schema").TaggedStruct<"direct", {}>;
+                        readonly providerOperation: import("effect/Schema").TaggedStruct<"providerOperation", {
+                            readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        }>;
+                        readonly reconciliation: import("effect/Schema").TaggedStruct<"reconciliation", {
+                            readonly reconciliationKey: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                        }>;
+                    }>;
+                }>;
+                readonly recordFailed: import("effect/Schema").TaggedStruct<"recordFailed", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly observationBasis: import("effect/Schema").optionalKey<import("effect/Schema").Literal<"authorization">>;
+                        readonly status: import("effect/Schema").Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                    readonly source: import("effect/Schema").TaggedUnion<{
+                        readonly direct: import("effect/Schema").TaggedStruct<"direct", {}>;
+                        readonly providerOperation: import("effect/Schema").TaggedStruct<"providerOperation", {
+                            readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        }>;
+                        readonly reconciliation: import("effect/Schema").TaggedStruct<"reconciliation", {
+                            readonly reconciliationKey: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                        }>;
+                    }>;
+                }>;
+                readonly recordUnknown: import("effect/Schema").TaggedStruct<"recordUnknown", {
+                    readonly outcome: import("effect/Schema").TaggedUnion<{
+                        readonly reconcilable: import("effect/Schema").TaggedStruct<"reconcilable", {
+                            readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                            readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                            readonly safeSummary: import("effect/Schema").String;
+                        }>;
+                        readonly manual: import("effect/Schema").TaggedStruct<"manual", {
+                            readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                            readonly safeSummary: import("effect/Schema").String;
+                            readonly reason: import("effect/Schema").Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
+                        }>;
+                    }>;
+                }>;
+                readonly recordCancelled: import("effect/Schema").TaggedStruct<"recordCancelled", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly observationBasis: import("effect/Schema").optionalKey<import("effect/Schema").Literal<"authorization">>;
+                        readonly status: import("effect/Schema").Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                    readonly source: import("effect/Schema").TaggedUnion<{
+                        readonly direct: import("effect/Schema").TaggedStruct<"direct", {}>;
+                        readonly providerOperation: import("effect/Schema").TaggedStruct<"providerOperation", {
+                            readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        }>;
+                        readonly reconciliation: import("effect/Schema").TaggedStruct<"reconciliation", {
+                            readonly reconciliationKey: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                        }>;
+                    }>;
+                }>;
+                readonly reconciliationPending: import("effect/Schema").TaggedStruct<"reconciliationPending", {
+                    readonly checkedAt: import("effect/Schema").DateTimeUtcFromString;
+                    readonly reconciliationKey: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                }>;
+            }>;
+            readonly cause: import("effect/Schema").TaggedUnion<{
+                readonly human: import("effect/Schema").TaggedStruct<"human", {
+                    readonly actor: import("effect/Schema").TaggedStruct<"human", {
+                        readonly personId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PersonId">;
+                    }>;
+                    readonly sessionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "SessionId">;
+                }>;
+                readonly agent: import("effect/Schema").TaggedStruct<"agent", {
+                    readonly actor: import("effect/Schema").TaggedStruct<"agent", {
+                        readonly agentId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "AgentId">;
+                    }>;
+                    readonly jobId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "JobId">;
+                }>;
+                readonly system: import("effect/Schema").TaggedStruct<"system", {
+                    readonly component: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                }>;
+            }>;
+            readonly occurredAt: import("effect/Schema").DateTimeUtcFromString;
+            readonly causationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "DomainEventId">>;
+            readonly correlationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, "DomainEventCorrelationId">>;
+        }, "Type">;
+        history: import("effect/Schema").Struct.ReadonlySide<{
+            readonly commandDigest: import("effect/Schema").brand<import("effect/Schema").String, "GovernedActionCommandDigest">;
+            readonly schemaVersion: import("effect/Schema").Literal<1>;
+            readonly transitionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionTransitionId">;
+            readonly previousTransitionId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionTransitionId">>;
+            readonly commandId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly actionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionId">;
+            readonly workspaceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "WorkspaceId">;
+            readonly sequence: import("effect/Schema").Int;
+            readonly fromState: import("effect/Schema").NullOr<import("effect/Schema").Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>>;
+            readonly toState: import("effect/Schema").Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>;
+            readonly actionEnvelopeDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly command: import("effect/Schema").TaggedUnion<{
+                readonly propose: import("effect/Schema").TaggedStruct<"propose", {}>;
+                readonly authorize: import("effect/Schema").TaggedStruct<"authorize", {
+                    readonly authorizationId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionAuthorizationId">;
+                }>;
+                readonly deny: import("effect/Schema").TaggedStruct<"deny", {
+                    readonly reason: import("effect/Schema").Literals<readonly ["revision-changed", "evidence-stale", "evidence-invalid", "policy-denied", "session-invalid", "capability-changed", "plugin-unavailable", "preflight-blocked"]>;
+                    readonly safeSummary: import("effect/Schema").String;
+                }>;
+                readonly expire: import("effect/Schema").TaggedStruct<"expire", {
+                    readonly reason: import("effect/Schema").Literals<readonly ["proposal-expired", "authorization-expired"]>;
+                }>;
+                readonly cancel: import("effect/Schema").TaggedStruct<"cancel", {
+                    readonly safeSummary: import("effect/Schema").String;
+                }>;
+                readonly start: import("effect/Schema").TaggedStruct<"start", {
+                    readonly attemptId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionAttemptId">;
+                }>;
+                readonly requestCancellation: import("effect/Schema").TaggedStruct<"requestCancellation", {
+                    readonly safeSummary: import("effect/Schema").String;
+                }>;
+                readonly recordAccepted: import("effect/Schema").TaggedStruct<"recordAccepted", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly status: import("effect/Schema").Literal<"accepted">;
+                        readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                }>;
+                readonly recordSucceeded: import("effect/Schema").TaggedStruct<"recordSucceeded", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly observationBasis: import("effect/Schema").optionalKey<import("effect/Schema").Literal<"authorization">>;
+                        readonly status: import("effect/Schema").Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                    readonly source: import("effect/Schema").TaggedUnion<{
+                        readonly direct: import("effect/Schema").TaggedStruct<"direct", {}>;
+                        readonly providerOperation: import("effect/Schema").TaggedStruct<"providerOperation", {
+                            readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        }>;
+                        readonly reconciliation: import("effect/Schema").TaggedStruct<"reconciliation", {
+                            readonly reconciliationKey: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                        }>;
+                    }>;
+                }>;
+                readonly recordFailed: import("effect/Schema").TaggedStruct<"recordFailed", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly observationBasis: import("effect/Schema").optionalKey<import("effect/Schema").Literal<"authorization">>;
+                        readonly status: import("effect/Schema").Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                    readonly source: import("effect/Schema").TaggedUnion<{
+                        readonly direct: import("effect/Schema").TaggedStruct<"direct", {}>;
+                        readonly providerOperation: import("effect/Schema").TaggedStruct<"providerOperation", {
+                            readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        }>;
+                        readonly reconciliation: import("effect/Schema").TaggedStruct<"reconciliation", {
+                            readonly reconciliationKey: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                        }>;
+                    }>;
+                }>;
+                readonly recordUnknown: import("effect/Schema").TaggedStruct<"recordUnknown", {
+                    readonly outcome: import("effect/Schema").TaggedUnion<{
+                        readonly reconcilable: import("effect/Schema").TaggedStruct<"reconcilable", {
+                            readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                            readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                            readonly safeSummary: import("effect/Schema").String;
+                        }>;
+                        readonly manual: import("effect/Schema").TaggedStruct<"manual", {
+                            readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                            readonly safeSummary: import("effect/Schema").String;
+                            readonly reason: import("effect/Schema").Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
+                        }>;
+                    }>;
+                }>;
+                readonly recordCancelled: import("effect/Schema").TaggedStruct<"recordCancelled", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly observationBasis: import("effect/Schema").optionalKey<import("effect/Schema").Literal<"authorization">>;
+                        readonly status: import("effect/Schema").Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                    readonly source: import("effect/Schema").TaggedUnion<{
+                        readonly direct: import("effect/Schema").TaggedStruct<"direct", {}>;
+                        readonly providerOperation: import("effect/Schema").TaggedStruct<"providerOperation", {
+                            readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        }>;
+                        readonly reconciliation: import("effect/Schema").TaggedStruct<"reconciliation", {
+                            readonly reconciliationKey: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                        }>;
+                    }>;
+                }>;
+                readonly reconciliationPending: import("effect/Schema").TaggedStruct<"reconciliationPending", {
+                    readonly checkedAt: import("effect/Schema").DateTimeUtcFromString;
+                    readonly reconciliationKey: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                }>;
+            }>;
+            readonly cause: import("effect/Schema").TaggedUnion<{
+                readonly human: import("effect/Schema").TaggedStruct<"human", {
+                    readonly actor: import("effect/Schema").TaggedStruct<"human", {
+                        readonly personId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PersonId">;
+                    }>;
+                    readonly sessionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "SessionId">;
+                }>;
+                readonly agent: import("effect/Schema").TaggedStruct<"agent", {
+                    readonly actor: import("effect/Schema").TaggedStruct<"agent", {
+                        readonly agentId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "AgentId">;
+                    }>;
+                    readonly jobId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "JobId">;
+                }>;
+                readonly system: import("effect/Schema").TaggedStruct<"system", {
+                    readonly component: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                }>;
+            }>;
+            readonly occurredAt: import("effect/Schema").DateTimeUtcFromString;
+            readonly causationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "DomainEventId">>;
+            readonly correlationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, "DomainEventCorrelationId">>;
+        }, "Type">[];
+        authorization: import("effect/Schema").Struct.ReadonlySide<{
+            readonly schemaVersion: import("effect/Schema").Literal<1>;
+            readonly authorizationId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionAuthorizationId">;
+            readonly actionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionId">;
+            readonly workspaceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "WorkspaceId">;
+            readonly pluginConnectionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PluginConnectionId">;
+            readonly pluginConnectionRevision: import("effect/Schema").brand<import("effect/Schema").Int, "GovernedActionPluginConnectionRevision">;
+            readonly pluginConnectionAuthorityDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly actionEnvelopeDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly idempotencyKey: import("effect/Schema").brand<import("effect/Schema").String, "GovernedActionIdempotencyKey">;
+            readonly payloadDigest: import("effect/Schema").brand<import("effect/Schema").String, "PluginActionPayloadDigest">;
+            readonly evidenceSetDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly policyDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly expectedRevision: import("effect/Schema").brand<import("effect/Schema").String, "Revision">;
+            readonly capabilityVersion: import("effect/Schema").Int;
+            readonly actor: import("effect/Schema").TaggedStruct<"human", {
+                readonly personId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PersonId">;
+            }>;
+            readonly sessionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "SessionId">;
+            readonly sessionPermission: import("effect/Schema").Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
+            readonly sessionExpiresAt: import("effect/Schema").DateTimeUtcFromString;
+            readonly requiredPermission: import("effect/Schema").Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
+            readonly authorizedAt: import("effect/Schema").DateTimeUtcFromString;
+            readonly expiresAt: import("effect/Schema").DateTimeUtcFromString;
+        }, "Type"> | null;
+        policyEvaluation: import("effect/Schema").Struct.ReadonlySide<{
+            readonly schemaVersion: import("effect/Schema").Literal<1>;
+            readonly actionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionId">;
+            readonly workspaceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "WorkspaceId">;
+            readonly policy: import("effect/Schema").Struct<{
+                readonly policyId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly policyVersion: import("effect/Schema").Int;
+                readonly policyDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly requiredPermission: import("effect/Schema").Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
+            }>;
+            readonly payloadDigest: import("effect/Schema").brand<import("effect/Schema").String, "PluginActionPayloadDigest">;
+            readonly evidenceSetDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly expectedRevision: import("effect/Schema").brand<import("effect/Schema").String, "Revision">;
+            readonly decision: import("effect/Schema").Literals<readonly ["allowed", "denied"]>;
+            readonly evaluatedAt: import("effect/Schema").DateTimeUtcFromString;
+        }, "Type"> | null;
+        attempt: import("effect/Schema").Struct.ReadonlySide<{
+            readonly schemaVersion: import("effect/Schema").Literal<1>;
+            readonly attemptId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionAttemptId">;
+            readonly authorizationId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionAuthorizationId">;
+            readonly actionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionId">;
+            readonly workspaceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "WorkspaceId">;
+            readonly pluginConnectionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PluginConnectionId">;
+            readonly idempotencyKey: import("effect/Schema").brand<import("effect/Schema").String, "GovernedActionIdempotencyKey">;
+            readonly attemptNumber: import("effect/Schema").Literal<1>;
+            readonly actionEnvelopeDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly expectedRevision: import("effect/Schema").brand<import("effect/Schema").String, "Revision">;
+            readonly policyEvaluationDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly preflight: import("effect/Schema").TaggedStruct<"ready", {
+                readonly checkedRevision: import("effect/Schema").brand<import("effect/Schema").String, "Revision">;
+                readonly checkedAt: import("effect/Schema").DateTimeUtcFromString;
+            }>;
+            readonly startedAt: import("effect/Schema").DateTimeUtcFromString;
+        }, "Type"> | null;
+    }[], import("../persistence/Persistence.js").PersistenceOperationFailure, never>;
+}, "readLatestTerminalReleasePublications">, releases: readonly import("effect/Schema").Struct.ReadonlySide<{
+    readonly createdAt: import("effect/Schema").DateTimeUtcFromString;
+    readonly freshness: import("effect/Schema").toTaggedUnion<"_tag", readonly [import("effect/Schema").Struct<{
+        readonly _tag: import("effect/Schema").tag<"current">;
+        readonly pluginHealth: import("effect/Schema").Union<readonly [import("effect/Schema").TaggedStruct<"healthy", {
+            readonly checkedAt: import("effect/Schema").DateTimeUtcFromString;
+        }>, import("effect/Schema").Struct<{
+            readonly _tag: import("effect/Schema").tag<"degraded">;
+            readonly checkedAt: import("effect/Schema").DateTimeUtcFromString;
+            readonly failureClass: import("effect/Schema").Literals<readonly ["authentication", "authorization", "rate-limit", "timeout", "malformed-response", "outage", "unknown"]>;
+            readonly retryAt: import("effect/Schema").NullOr<import("effect/Schema").DateTimeUtcFromString>;
+            readonly safeMessage: import("effect/Schema").String;
+        }>]>;
+        readonly provenance: import("effect/Schema").Union<readonly [import("effect/Schema").TaggedStruct<"provider", {
+            readonly sourceRevision: import("effect/Schema").Struct<{
+                readonly providerId: import("effect/Schema").Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+                readonly pluginConnectionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PluginConnectionId">;
+                readonly vendorImmutableId: import("effect/Schema").brand<import("effect/Schema").String, "VendorImmutableId">;
+                readonly revision: import("effect/Schema").brand<import("effect/Schema").String, "Revision">;
+                readonly sourceUrl: import("effect/Schema").Union<readonly [import("effect/Schema").decodeTo<import("effect/Schema").URL, import("effect/Schema").String, never, never>, import("effect/Schema").Null]>;
+                readonly firstObservedAt: import("effect/Schema").DateTimeUtcFromString;
+                readonly lastObservedAt: import("effect/Schema").DateTimeUtcFromString;
+                readonly synchronizedAt: import("effect/Schema").DateTimeUtcFromString;
+                readonly normalizationSchemaVersion: import("effect/Schema").brand<import("effect/Schema").Number, "NormalizationSchemaVersion">;
+            }>;
+        }>, import("effect/Schema").Struct<{
+            readonly _tag: import("effect/Schema").tag<"cache">;
+            readonly cachedAt: import("effect/Schema").DateTimeUtcFromString;
+            readonly sourceRevision: import("effect/Schema").Struct<{
+                readonly providerId: import("effect/Schema").Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+                readonly pluginConnectionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PluginConnectionId">;
+                readonly vendorImmutableId: import("effect/Schema").brand<import("effect/Schema").String, "VendorImmutableId">;
+                readonly revision: import("effect/Schema").brand<import("effect/Schema").String, "Revision">;
+                readonly sourceUrl: import("effect/Schema").Union<readonly [import("effect/Schema").decodeTo<import("effect/Schema").URL, import("effect/Schema").String, never, never>, import("effect/Schema").Null]>;
+                readonly firstObservedAt: import("effect/Schema").DateTimeUtcFromString;
+                readonly lastObservedAt: import("effect/Schema").DateTimeUtcFromString;
+                readonly synchronizedAt: import("effect/Schema").DateTimeUtcFromString;
+                readonly normalizationSchemaVersion: import("effect/Schema").brand<import("effect/Schema").Number, "NormalizationSchemaVersion">;
+            }>;
+        }>]>;
+        readonly sourceObservedAt: import("effect/Schema").DateTimeUtcFromString;
+        readonly staleAfterSeconds: import("effect/Schema").Int;
+        readonly synchronizedAt: import("effect/Schema").DateTimeUtcFromString;
+        readonly evaluatedAt: import("effect/Schema").optional<import("effect/Schema").DateTimeUtcFromString>;
+    }>, import("effect/Schema").Struct<{
+        readonly _tag: import("effect/Schema").tag<"stale">;
+        readonly pluginHealth: import("effect/Schema").toTaggedUnion<"_tag", readonly [import("effect/Schema").TaggedStruct<"healthy", {
+            readonly checkedAt: import("effect/Schema").DateTimeUtcFromString;
+        }>, import("effect/Schema").Struct<{
+            readonly _tag: import("effect/Schema").tag<"degraded">;
+            readonly checkedAt: import("effect/Schema").DateTimeUtcFromString;
+            readonly failureClass: import("effect/Schema").Literals<readonly ["authentication", "authorization", "rate-limit", "timeout", "malformed-response", "outage", "unknown"]>;
+            readonly retryAt: import("effect/Schema").NullOr<import("effect/Schema").DateTimeUtcFromString>;
+            readonly safeMessage: import("effect/Schema").String;
+        }>, import("effect/Schema").Struct<{
+            readonly _tag: import("effect/Schema").tag<"unavailable">;
+            readonly checkedAt: import("effect/Schema").DateTimeUtcFromString;
+            readonly failureClass: import("effect/Schema").Literals<readonly ["authentication", "authorization", "rate-limit", "timeout", "malformed-response", "outage", "unknown"]>;
+            readonly retryAt: import("effect/Schema").NullOr<import("effect/Schema").DateTimeUtcFromString>;
+            readonly safeMessage: import("effect/Schema").String;
+        }>, import("effect/Schema").TaggedStruct<"disabled", {
+            readonly checkedAt: import("effect/Schema").DateTimeUtcFromString;
+        }>]>;
+        readonly provenance: import("effect/Schema").Struct<{
+            readonly _tag: import("effect/Schema").tag<"cache">;
+            readonly cachedAt: import("effect/Schema").DateTimeUtcFromString;
+            readonly sourceRevision: import("effect/Schema").Struct<{
+                readonly providerId: import("effect/Schema").Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+                readonly pluginConnectionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PluginConnectionId">;
+                readonly vendorImmutableId: import("effect/Schema").brand<import("effect/Schema").String, "VendorImmutableId">;
+                readonly revision: import("effect/Schema").brand<import("effect/Schema").String, "Revision">;
+                readonly sourceUrl: import("effect/Schema").Union<readonly [import("effect/Schema").decodeTo<import("effect/Schema").URL, import("effect/Schema").String, never, never>, import("effect/Schema").Null]>;
+                readonly firstObservedAt: import("effect/Schema").DateTimeUtcFromString;
+                readonly lastObservedAt: import("effect/Schema").DateTimeUtcFromString;
+                readonly synchronizedAt: import("effect/Schema").DateTimeUtcFromString;
+                readonly normalizationSchemaVersion: import("effect/Schema").brand<import("effect/Schema").Number, "NormalizationSchemaVersion">;
+            }>;
+        }>;
+        readonly sourceObservedAt: import("effect/Schema").DateTimeUtcFromString;
+        readonly staleAfterSeconds: import("effect/Schema").Int;
+        readonly synchronizedAt: import("effect/Schema").DateTimeUtcFromString;
+        readonly evaluatedAt: import("effect/Schema").optional<import("effect/Schema").DateTimeUtcFromString>;
+    }>, import("effect/Schema").TaggedStruct<"missing", {
+        readonly pluginHealth: import("effect/Schema").TaggedStruct<"healthy", {
+            readonly checkedAt: import("effect/Schema").DateTimeUtcFromString;
+        }>;
+        readonly provenance: import("effect/Schema").TaggedStruct<"none", {
+            readonly pluginConnectionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PluginConnectionId">;
+        }>;
+        readonly sourceObservedAt: import("effect/Schema").Null;
+        readonly staleAfterSeconds: import("effect/Schema").Int;
+        readonly synchronizedAt: import("effect/Schema").DateTimeUtcFromString;
+    }>, import("effect/Schema").TaggedStruct<"unavailable", {
+        readonly pluginHealth: import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+            readonly _tag: import("effect/Schema").tag<"unavailable">;
+            readonly checkedAt: import("effect/Schema").DateTimeUtcFromString;
+            readonly failureClass: import("effect/Schema").Literals<readonly ["authentication", "authorization", "rate-limit", "timeout", "malformed-response", "outage", "unknown"]>;
+            readonly retryAt: import("effect/Schema").NullOr<import("effect/Schema").DateTimeUtcFromString>;
+            readonly safeMessage: import("effect/Schema").String;
+        }>, import("effect/Schema").TaggedStruct<"disabled", {
+            readonly checkedAt: import("effect/Schema").DateTimeUtcFromString;
+        }>]>;
+        readonly provenance: import("effect/Schema").TaggedStruct<"none", {
+            readonly pluginConnectionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PluginConnectionId">;
+        }>;
+        readonly sourceObservedAt: import("effect/Schema").Null;
+        readonly staleAfterSeconds: import("effect/Schema").Int;
+        readonly synchronizedAt: import("effect/Schema").Null;
+    }>]>;
+    readonly id: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "ReleaseId">;
+    readonly lifecycle: import("effect/Schema").Literals<readonly ["assembling", "candidate", "deploying", "released", "cancelled"]>;
+    readonly relay: import("effect/Schema").Struct<{
+        readonly algorithm: import("effect/Schema").Literal<"relay/v1">;
+        readonly codename: import("effect/Schema").TemplateLiteral<readonly [import("effect/Schema").Literals<readonly ["Amber", "Azure", "Copper", "Ember", "Golden", "Lunar", "Moss", "Nova", "Quiet", "Silver", "Solar", "Tidal", "Velvet", "Verdant", "Wild", "Winter"]>, " ", import("effect/Schema").Literals<readonly ["Anchor", "Beacon", "Bridge", "Comet", "Finch", "Fork", "Gate", "Grove", "Harbor", "Orbit", "Pulse", "Reef", "Relay", "Spark", "Wave", "Willow"]>]>;
+        readonly symbolIndices: import("effect/Schema").Tuple<readonly [import("effect/Schema").Literals<readonly [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]>, import("effect/Schema").Literals<readonly [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]>, import("effect/Schema").Literals<readonly [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]>]>;
+    }>;
+    readonly roleAssignments: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+        readonly actor: import("effect/Schema").toTaggedUnion<"_tag", readonly [import("effect/Schema").TaggedStruct<"human", {
+            readonly personId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PersonId">;
+        }>, import("effect/Schema").TaggedStruct<"agent", {
+            readonly agentId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "AgentId">;
+        }>]>;
+        readonly assignmentId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "RoleAssignmentId">;
+        readonly lifecycle: import("effect/Schema").toTaggedUnion<"_tag", readonly [import("effect/Schema").TaggedStruct<"active", {
+            readonly assignedAt: import("effect/Schema").DateTimeUtcFromString;
+        }>, import("effect/Schema").Struct<{
+            readonly _tag: import("effect/Schema").tag<"ended">;
+            readonly assignedAt: import("effect/Schema").DateTimeUtcFromString;
+            readonly endedAt: import("effect/Schema").DateTimeUtcFromString;
+        }>, import("effect/Schema").Struct<{
+            readonly _tag: import("effect/Schema").tag<"revoked">;
+            readonly assignedAt: import("effect/Schema").DateTimeUtcFromString;
+            readonly revokedAt: import("effect/Schema").DateTimeUtcFromString;
+        }>]>;
+        readonly role: import("effect/Schema").Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
+        readonly scope: import("effect/Schema").TaggedUnion<{
+            readonly entity: import("effect/Schema").TaggedStruct<"entity", {
+                readonly entityId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "EntityId">;
+                readonly workspaceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "WorkspaceId">;
+            }>;
+            readonly environment: import("effect/Schema").TaggedStruct<"environment", {
+                readonly environmentId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "EnvironmentId">;
+                readonly releaseId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "ReleaseId">;
+                readonly workspaceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "WorkspaceId">;
+            }>;
+            readonly release: import("effect/Schema").TaggedStruct<"release", {
+                readonly releaseId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "ReleaseId">;
+                readonly workspaceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "WorkspaceId">;
+            }>;
+            readonly workspace: import("effect/Schema").TaggedStruct<"workspace", {
+                readonly workspaceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "WorkspaceId">;
+            }>;
+        }>;
+    }>>;
+    readonly serviceName: import("effect/Schema").brand<import("effect/Schema").String, "ReleaseServiceName">;
+    readonly sourceRevisions: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+        readonly providerId: import("effect/Schema").Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+        readonly pluginConnectionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PluginConnectionId">;
+        readonly vendorImmutableId: import("effect/Schema").brand<import("effect/Schema").String, "VendorImmutableId">;
+        readonly revision: import("effect/Schema").brand<import("effect/Schema").String, "Revision">;
+        readonly sourceUrl: import("effect/Schema").Union<readonly [import("effect/Schema").decodeTo<import("effect/Schema").URL, import("effect/Schema").String, never, never>, import("effect/Schema").Null]>;
+        readonly firstObservedAt: import("effect/Schema").DateTimeUtcFromString;
+        readonly lastObservedAt: import("effect/Schema").DateTimeUtcFromString;
+        readonly synchronizedAt: import("effect/Schema").DateTimeUtcFromString;
+        readonly normalizationSchemaVersion: import("effect/Schema").brand<import("effect/Schema").Number, "NormalizationSchemaVersion">;
+    }>>;
+    readonly targetEnvironmentIds: import("effect/Schema").$Array<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "EnvironmentId">>;
+    readonly updatedAt: import("effect/Schema").DateTimeUtcFromString;
+    readonly version: import("effect/Schema").brand<import("effect/Schema").String, "ReleaseVersion">;
+    readonly workspaceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "WorkspaceId">;
+}, "Type">[]) => Effect.Effect<Map<string & import("effect/Brand").Brand<"ReleaseId">, {
+    readonly state: "unknown" | "current" | "stale" | "not-published";
+    readonly lastPublishedAt: DateTime.Utc | null;
+    readonly publicationActionId?: string & import("effect/Brand").Brand<"GovernedActionId">;
+}>, never, Crypto.Crypto>;
 /** Construct the bird's-eye projection from persisted facts only. */
 export declare const makePortfolioSnapshots: Effect.Effect<{
-    readonly snapshot: (workspaceId: import("../../index.ts").WorkspaceId) => Effect.Effect<PortfolioSnapshot, ApplicationServiceUnavailable>;
-}, never, Persistence>;
+    readonly snapshot: (workspaceId: import("../../domain/identifiers.js").WorkspaceId) => Effect.Effect<PortfolioSnapshot, ApplicationServiceUnavailable>;
+}, never, Crypto.Crypto | Persistence>;
 /** Live portfolio projection layer. */
-export declare const portfolioSnapshotsLayer: Layer.Layer<PortfolioSnapshots, never, Persistence>;
+export declare const portfolioSnapshotsLayer: Layer.Layer<PortfolioSnapshots, never, Crypto.Crypto | Persistence>;
 //# sourceMappingURL=portfolioSnapshots.d.ts.map