@knpkv/control-center 0.3.0 → 0.5.0

package/dist/server/server/persistence/repositories/governed-action/read.d.ts

@@ -1,3 +1,4 @@
+import * as DateTime from "effect/DateTime";
 import * as Effect from "effect/Effect";
 import * as Schema from "effect/Schema";
 import { Database } from "../../Database.js";
@@ -8,33 +9,14 @@ export declare const makeGovernedActionRead: Effect.Effect<{
         readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
         readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
     }, "Type">) => Effect.Effect<{
-        envelope: Schema.Struct.ReadonlySide<{
-            readonly envelopeDigest: Schema.brand<Schema.String, string>;
-            readonly schemaVersion: Schema.Literal<1>;
-            readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
-            readonly idempotencyKey: Schema.brand<Schema.String, "GovernedActionIdempotencyKey">;
-            readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
-            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
-            readonly pluginConnectionRevision: Schema.brand<Schema.Int, "GovernedActionPluginConnectionRevision">;
-            readonly pluginConnectionAuthorityDigest: Schema.brand<Schema.String, string>;
-            readonly pluginId: Schema.brand<Schema.String, string>;
-            readonly pluginContractVersion: Schema.Struct<{
-                readonly major: Schema.Int;
-                readonly minor: Schema.Int;
-                readonly patch: Schema.Int;
-            }>;
-            readonly pluginAdapterVersion: Schema.Struct<{
-                readonly major: Schema.Int;
-                readonly minor: Schema.Int;
-                readonly patch: Schema.Int;
-            }>;
-            readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
-            readonly capability: Schema.Struct<{
-                readonly capabilityId: Schema.Literal<"action.execute">;
-                readonly version: Schema.Int;
-            }>;
-            readonly targetEntityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
-            readonly proposal: Schema.Struct<{
+        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: Schema.Struct.ReadonlySide<{
                 readonly proposalKey: Schema.brand<Schema.String, string>;
                 readonly capabilityVersion: Schema.Int;
                 readonly request: Schema.Struct<{
@@ -54,8 +36,35 @@ export declare const makeGovernedActionRead: Effect.Effect<{
                     readonly summary: Schema.String;
                 }>;
                 readonly proposedAt: Schema.DateTimeUtcFromString;
-            }>;
-            readonly evidence: Schema.$Array<Schema.Struct<{
+            }, "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: Schema.Struct.ReadonlySide<{
+                readonly policyId: Schema.brand<Schema.String, string>;
+                readonly policyVersion: Schema.Int;
+                readonly policyDigest: Schema.brand<Schema.String, string>;
+                readonly requiredPermission: 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: Schema.Struct.ReadonlySide<{
+                readonly major: Schema.Int;
+                readonly minor: Schema.Int;
+                readonly patch: Schema.Int;
+            }, "Type">;
+            readonly pluginAdapterVersion: Schema.Struct.ReadonlySide<{
+                readonly major: Schema.Int;
+                readonly minor: Schema.Int;
+                readonly patch: Schema.Int;
+            }, "Type">;
+            readonly capability: Schema.Struct.ReadonlySide<{
+                readonly capabilityId: Schema.Literal<"action.execute">;
+                readonly version: Schema.Int;
+            }, "Type">;
+            readonly targetEntityId: string & import("effect/Brand").Brand<"EntityId">;
+            readonly evidence: readonly Schema.Struct.ReadonlySide<{
                 readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
                 readonly evidenceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">;
                 readonly evidenceClaimIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceClaimId">>;
@@ -65,33 +74,31 @@ export declare const makeGovernedActionRead: Effect.Effect<{
                 readonly evaluatedAt: Schema.DateTimeUtcFromString;
                 readonly source: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
                 readonly validity: Schema.Literals<readonly ["valid", "expired"]>;
-            }>>;
-            readonly evidenceSetDigest: Schema.brand<Schema.String, string>;
-            readonly policy: Schema.Struct<{
-                readonly policyId: Schema.brand<Schema.String, string>;
-                readonly policyVersion: Schema.Int;
-                readonly policyDigest: Schema.brand<Schema.String, string>;
-                readonly requiredPermission: 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: Schema.TaggedUnion<{
-                readonly agent: Schema.TaggedStruct<"agent", {
-                    readonly actor: Schema.TaggedStruct<"agent", {
-                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
-                    }>;
-                    readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
-                    readonly initiatingSessionId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">>;
-                }>;
-                readonly human: Schema.TaggedStruct<"human", {
-                    readonly actor: Schema.TaggedStruct<"human", {
-                        readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
-                    }>;
-                    readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
-                }>;
-            }>;
-            readonly proposalExpiresAt: Schema.DateTimeUtcFromString;
-            readonly causationId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "DomainEventId">>;
-            readonly correlationId: Schema.NullOr<Schema.brand<Schema.String, "DomainEventCorrelationId">>;
-        }, "Type">;
+            }, "Type">[];
+            readonly origin: Schema.Struct.ReadonlySide<{
+                readonly _tag: Schema.tag<"human">;
+                readonly actor: Schema.TaggedStruct<"human", {
+                    readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                }>;
+                readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+            }, "Type"> | Schema.Struct.ReadonlySide<{
+                readonly _tag: Schema.tag<"agent">;
+                readonly actor: Schema.TaggedStruct<"agent", {
+                    readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                }>;
+                readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+                readonly initiatingSessionId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, 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: Schema.Struct.ReadonlySide<{
             readonly state: Schema.Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>;
             readonly lineage: Schema.TaggedUnion<{
@@ -104,14 +111,14 @@ export declare const makeGovernedActionRead: Effect.Effect<{
                         readonly observedAt: Schema.DateTimeUtcFromString;
                     }>;
                 }>;
-                readonly none: Schema.TaggedStruct<"none", {}>;
-                readonly manual: Schema.TaggedStruct<"manual", {
-                    readonly providerOperationId: Schema.NullOr<Schema.brand<Schema.String, string>>;
-                }>;
                 readonly reconcilable: Schema.TaggedStruct<"reconcilable", {
                     readonly providerOperationId: Schema.NullOr<Schema.brand<Schema.String, string>>;
                     readonly reconciliationKey: Schema.brand<Schema.String, string>;
                 }>;
+                readonly manual: Schema.TaggedStruct<"manual", {
+                    readonly providerOperationId: Schema.NullOr<Schema.brand<Schema.String, string>>;
+                }>;
+                readonly none: Schema.TaggedStruct<"none", {}>;
                 readonly terminal: Schema.TaggedStruct<"terminal", {
                     readonly receipt: Schema.Struct<{
                         readonly observationBasis: Schema.optionalKey<Schema.Literal<"authorization">>;
@@ -203,15 +210,15 @@ export declare const makeGovernedActionRead: Effect.Effect<{
                 }>;
                 readonly recordUnknown: Schema.TaggedStruct<"recordUnknown", {
                     readonly outcome: Schema.TaggedUnion<{
-                        readonly manual: Schema.TaggedStruct<"manual", {
+                        readonly reconcilable: Schema.TaggedStruct<"reconcilable", {
+                            readonly reconciliationKey: Schema.brand<Schema.String, string>;
                             readonly observedAt: Schema.DateTimeUtcFromString;
                             readonly safeSummary: Schema.String;
-                            readonly reason: Schema.Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
                         }>;
-                        readonly reconcilable: Schema.TaggedStruct<"reconcilable", {
-                            readonly reconciliationKey: Schema.brand<Schema.String, string>;
+                        readonly manual: Schema.TaggedStruct<"manual", {
                             readonly observedAt: Schema.DateTimeUtcFromString;
                             readonly safeSummary: Schema.String;
+                            readonly reason: Schema.Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
                         }>;
                     }>;
                 }>;
@@ -239,18 +246,18 @@ export declare const makeGovernedActionRead: Effect.Effect<{
                 }>;
             }>;
             readonly cause: Schema.TaggedUnion<{
-                readonly agent: Schema.TaggedStruct<"agent", {
-                    readonly actor: Schema.TaggedStruct<"agent", {
-                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
-                    }>;
-                    readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
-                }>;
                 readonly human: Schema.TaggedStruct<"human", {
                     readonly actor: Schema.TaggedStruct<"human", {
                         readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
                     }>;
                     readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
                 }>;
+                readonly agent: Schema.TaggedStruct<"agent", {
+                    readonly actor: Schema.TaggedStruct<"agent", {
+                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                    }>;
+                    readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+                }>;
                 readonly system: Schema.TaggedStruct<"system", {
                     readonly component: Schema.brand<Schema.String, string>;
                 }>;
@@ -339,15 +346,15 @@ export declare const makeGovernedActionRead: Effect.Effect<{
                 }>;
                 readonly recordUnknown: Schema.TaggedStruct<"recordUnknown", {
                     readonly outcome: Schema.TaggedUnion<{
-                        readonly manual: Schema.TaggedStruct<"manual", {
+                        readonly reconcilable: Schema.TaggedStruct<"reconcilable", {
+                            readonly reconciliationKey: Schema.brand<Schema.String, string>;
                             readonly observedAt: Schema.DateTimeUtcFromString;
                             readonly safeSummary: Schema.String;
-                            readonly reason: Schema.Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
                         }>;
-                        readonly reconcilable: Schema.TaggedStruct<"reconcilable", {
-                            readonly reconciliationKey: Schema.brand<Schema.String, string>;
+                        readonly manual: Schema.TaggedStruct<"manual", {
                             readonly observedAt: Schema.DateTimeUtcFromString;
                             readonly safeSummary: Schema.String;
+                            readonly reason: Schema.Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
                         }>;
                     }>;
                 }>;
@@ -375,18 +382,18 @@ export declare const makeGovernedActionRead: Effect.Effect<{
                 }>;
             }>;
             readonly cause: Schema.TaggedUnion<{
-                readonly agent: Schema.TaggedStruct<"agent", {
-                    readonly actor: Schema.TaggedStruct<"agent", {
-                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
-                    }>;
-                    readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
-                }>;
                 readonly human: Schema.TaggedStruct<"human", {
                     readonly actor: Schema.TaggedStruct<"human", {
                         readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
                     }>;
                     readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
                 }>;
+                readonly agent: Schema.TaggedStruct<"agent", {
+                    readonly actor: Schema.TaggedStruct<"agent", {
+                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                    }>;
+                    readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+                }>;
                 readonly system: Schema.TaggedStruct<"system", {
                     readonly component: Schema.brand<Schema.String, string>;
                 }>;
@@ -460,33 +467,14 @@ export declare const makeGovernedActionRead: Effect.Effect<{
         readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
         readonly idempotencyKey: Schema.brand<Schema.String, "GovernedActionIdempotencyKey">;
     }, "Type">) => Effect.Effect<{
-        envelope: Schema.Struct.ReadonlySide<{
-            readonly envelopeDigest: Schema.brand<Schema.String, string>;
-            readonly schemaVersion: Schema.Literal<1>;
-            readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
-            readonly idempotencyKey: Schema.brand<Schema.String, "GovernedActionIdempotencyKey">;
-            readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
-            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
-            readonly pluginConnectionRevision: Schema.brand<Schema.Int, "GovernedActionPluginConnectionRevision">;
-            readonly pluginConnectionAuthorityDigest: Schema.brand<Schema.String, string>;
-            readonly pluginId: Schema.brand<Schema.String, string>;
-            readonly pluginContractVersion: Schema.Struct<{
-                readonly major: Schema.Int;
-                readonly minor: Schema.Int;
-                readonly patch: Schema.Int;
-            }>;
-            readonly pluginAdapterVersion: Schema.Struct<{
-                readonly major: Schema.Int;
-                readonly minor: Schema.Int;
-                readonly patch: Schema.Int;
-            }>;
-            readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
-            readonly capability: Schema.Struct<{
-                readonly capabilityId: Schema.Literal<"action.execute">;
-                readonly version: Schema.Int;
-            }>;
-            readonly targetEntityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
-            readonly proposal: Schema.Struct<{
+        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: Schema.Struct.ReadonlySide<{
                 readonly proposalKey: Schema.brand<Schema.String, string>;
                 readonly capabilityVersion: Schema.Int;
                 readonly request: Schema.Struct<{
@@ -506,8 +494,35 @@ export declare const makeGovernedActionRead: Effect.Effect<{
                     readonly summary: Schema.String;
                 }>;
                 readonly proposedAt: Schema.DateTimeUtcFromString;
-            }>;
-            readonly evidence: Schema.$Array<Schema.Struct<{
+            }, "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: Schema.Struct.ReadonlySide<{
+                readonly policyId: Schema.brand<Schema.String, string>;
+                readonly policyVersion: Schema.Int;
+                readonly policyDigest: Schema.brand<Schema.String, string>;
+                readonly requiredPermission: 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: Schema.Struct.ReadonlySide<{
+                readonly major: Schema.Int;
+                readonly minor: Schema.Int;
+                readonly patch: Schema.Int;
+            }, "Type">;
+            readonly pluginAdapterVersion: Schema.Struct.ReadonlySide<{
+                readonly major: Schema.Int;
+                readonly minor: Schema.Int;
+                readonly patch: Schema.Int;
+            }, "Type">;
+            readonly capability: Schema.Struct.ReadonlySide<{
+                readonly capabilityId: Schema.Literal<"action.execute">;
+                readonly version: Schema.Int;
+            }, "Type">;
+            readonly targetEntityId: string & import("effect/Brand").Brand<"EntityId">;
+            readonly evidence: readonly Schema.Struct.ReadonlySide<{
                 readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
                 readonly evidenceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">;
                 readonly evidenceClaimIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceClaimId">>;
@@ -517,33 +532,31 @@ export declare const makeGovernedActionRead: Effect.Effect<{
                 readonly evaluatedAt: Schema.DateTimeUtcFromString;
                 readonly source: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
                 readonly validity: Schema.Literals<readonly ["valid", "expired"]>;
-            }>>;
-            readonly evidenceSetDigest: Schema.brand<Schema.String, string>;
-            readonly policy: Schema.Struct<{
-                readonly policyId: Schema.brand<Schema.String, string>;
-                readonly policyVersion: Schema.Int;
-                readonly policyDigest: Schema.brand<Schema.String, string>;
-                readonly requiredPermission: 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: Schema.TaggedUnion<{
-                readonly agent: Schema.TaggedStruct<"agent", {
-                    readonly actor: Schema.TaggedStruct<"agent", {
-                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
-                    }>;
-                    readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
-                    readonly initiatingSessionId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">>;
-                }>;
-                readonly human: Schema.TaggedStruct<"human", {
-                    readonly actor: Schema.TaggedStruct<"human", {
-                        readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
-                    }>;
-                    readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
-                }>;
-            }>;
-            readonly proposalExpiresAt: Schema.DateTimeUtcFromString;
-            readonly causationId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "DomainEventId">>;
-            readonly correlationId: Schema.NullOr<Schema.brand<Schema.String, "DomainEventCorrelationId">>;
-        }, "Type">;
+            }, "Type">[];
+            readonly origin: Schema.Struct.ReadonlySide<{
+                readonly _tag: Schema.tag<"human">;
+                readonly actor: Schema.TaggedStruct<"human", {
+                    readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                }>;
+                readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+            }, "Type"> | Schema.Struct.ReadonlySide<{
+                readonly _tag: Schema.tag<"agent">;
+                readonly actor: Schema.TaggedStruct<"agent", {
+                    readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                }>;
+                readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+                readonly initiatingSessionId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, 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: Schema.Struct.ReadonlySide<{
             readonly state: Schema.Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>;
             readonly lineage: Schema.TaggedUnion<{
@@ -556,14 +569,14 @@ export declare const makeGovernedActionRead: Effect.Effect<{
                         readonly observedAt: Schema.DateTimeUtcFromString;
                     }>;
                 }>;
-                readonly none: Schema.TaggedStruct<"none", {}>;
-                readonly manual: Schema.TaggedStruct<"manual", {
-                    readonly providerOperationId: Schema.NullOr<Schema.brand<Schema.String, string>>;
-                }>;
                 readonly reconcilable: Schema.TaggedStruct<"reconcilable", {
                     readonly providerOperationId: Schema.NullOr<Schema.brand<Schema.String, string>>;
                     readonly reconciliationKey: Schema.brand<Schema.String, string>;
                 }>;
+                readonly manual: Schema.TaggedStruct<"manual", {
+                    readonly providerOperationId: Schema.NullOr<Schema.brand<Schema.String, string>>;
+                }>;
+                readonly none: Schema.TaggedStruct<"none", {}>;
                 readonly terminal: Schema.TaggedStruct<"terminal", {
                     readonly receipt: Schema.Struct<{
                         readonly observationBasis: Schema.optionalKey<Schema.Literal<"authorization">>;
@@ -655,15 +668,15 @@ export declare const makeGovernedActionRead: Effect.Effect<{
                 }>;
                 readonly recordUnknown: Schema.TaggedStruct<"recordUnknown", {
                     readonly outcome: Schema.TaggedUnion<{
-                        readonly manual: Schema.TaggedStruct<"manual", {
+                        readonly reconcilable: Schema.TaggedStruct<"reconcilable", {
+                            readonly reconciliationKey: Schema.brand<Schema.String, string>;
                             readonly observedAt: Schema.DateTimeUtcFromString;
                             readonly safeSummary: Schema.String;
-                            readonly reason: Schema.Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
                         }>;
-                        readonly reconcilable: Schema.TaggedStruct<"reconcilable", {
-                            readonly reconciliationKey: Schema.brand<Schema.String, string>;
+                        readonly manual: Schema.TaggedStruct<"manual", {
                             readonly observedAt: Schema.DateTimeUtcFromString;
                             readonly safeSummary: Schema.String;
+                            readonly reason: Schema.Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
                         }>;
                     }>;
                 }>;
@@ -691,18 +704,18 @@ export declare const makeGovernedActionRead: Effect.Effect<{
                 }>;
             }>;
             readonly cause: Schema.TaggedUnion<{
-                readonly agent: Schema.TaggedStruct<"agent", {
-                    readonly actor: Schema.TaggedStruct<"agent", {
-                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
-                    }>;
-                    readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
-                }>;
                 readonly human: Schema.TaggedStruct<"human", {
                     readonly actor: Schema.TaggedStruct<"human", {
                         readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
                     }>;
                     readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
                 }>;
+                readonly agent: Schema.TaggedStruct<"agent", {
+                    readonly actor: Schema.TaggedStruct<"agent", {
+                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                    }>;
+                    readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+                }>;
                 readonly system: Schema.TaggedStruct<"system", {
                     readonly component: Schema.brand<Schema.String, string>;
                 }>;
@@ -791,15 +804,15 @@ export declare const makeGovernedActionRead: Effect.Effect<{
                 }>;
                 readonly recordUnknown: Schema.TaggedStruct<"recordUnknown", {
                     readonly outcome: Schema.TaggedUnion<{
-                        readonly manual: Schema.TaggedStruct<"manual", {
+                        readonly reconcilable: Schema.TaggedStruct<"reconcilable", {
+                            readonly reconciliationKey: Schema.brand<Schema.String, string>;
                             readonly observedAt: Schema.DateTimeUtcFromString;
                             readonly safeSummary: Schema.String;
-                            readonly reason: Schema.Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
                         }>;
-                        readonly reconcilable: Schema.TaggedStruct<"reconcilable", {
-                            readonly reconciliationKey: Schema.brand<Schema.String, string>;
+                        readonly manual: Schema.TaggedStruct<"manual", {
                             readonly observedAt: Schema.DateTimeUtcFromString;
                             readonly safeSummary: Schema.String;
+                            readonly reason: Schema.Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
                         }>;
                     }>;
                 }>;
@@ -827,18 +840,18 @@ export declare const makeGovernedActionRead: Effect.Effect<{
                 }>;
             }>;
             readonly cause: Schema.TaggedUnion<{
-                readonly agent: Schema.TaggedStruct<"agent", {
-                    readonly actor: Schema.TaggedStruct<"agent", {
-                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
-                    }>;
-                    readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
-                }>;
                 readonly human: Schema.TaggedStruct<"human", {
                     readonly actor: Schema.TaggedStruct<"human", {
                         readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
                     }>;
                     readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
                 }>;
+                readonly agent: Schema.TaggedStruct<"agent", {
+                    readonly actor: Schema.TaggedStruct<"agent", {
+                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                    }>;
+                    readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+                }>;
                 readonly system: Schema.TaggedStruct<"system", {
                     readonly component: Schema.brand<Schema.String, string>;
                 }>;
@@ -909,10 +922,10 @@ export declare const makeGovernedActionRead: Effect.Effect<{
     }, RecordNotFoundError | import("../../errors.js").PersistenceOperationError | PersistedRecordError | import("effect/unstable/sql/SqlError").SqlError | import("./quarantine.js").MalformedGovernedActionRecord, import("effect/Crypto").Crypto>;
     readLatestTerminalByTarget: (request: {
         readonly providerId: "codecommit" | "codepipeline" | "jira" | "confluence" | "clockify";
-        readonly actionKind: string & import("effect/Brand").Brand<string>;
         readonly workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">;
-        readonly limit: number;
+        readonly actionKind: string & import("effect/Brand").Brand<string>;
         readonly targetEntityId: string & import("effect/Brand").Brand<"EntityId">;
+        readonly limit: number;
         readonly expectedRevision?: string & import("effect/Brand").Brand<"Revision">;
     }) => Effect.Effect<readonly Schema.Struct.ReadonlySide<{
         readonly envelope: Schema.Struct<{
@@ -981,6 +994,12 @@ export declare const makeGovernedActionRead: Effect.Effect<{
                 readonly requiredPermission: 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: Schema.TaggedUnion<{
+                readonly human: Schema.TaggedStruct<"human", {
+                    readonly actor: Schema.TaggedStruct<"human", {
+                        readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                    }>;
+                    readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+                }>;
                 readonly agent: Schema.TaggedStruct<"agent", {
                     readonly actor: Schema.TaggedStruct<"agent", {
                         readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
@@ -988,16 +1007,17 @@ export declare const makeGovernedActionRead: Effect.Effect<{
                     readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
                     readonly initiatingSessionId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">>;
                 }>;
-                readonly human: Schema.TaggedStruct<"human", {
-                    readonly actor: Schema.TaggedStruct<"human", {
-                        readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
-                    }>;
-                    readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
-                }>;
             }>;
             readonly proposalExpiresAt: Schema.DateTimeUtcFromString;
             readonly causationId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "DomainEventId">>;
             readonly correlationId: Schema.NullOr<Schema.brand<Schema.String, "DomainEventCorrelationId">>;
+            readonly releasePublication: Schema.optionalKey<Schema.Struct<{
+                readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                readonly predecessorPublicationActionId: Schema.optionalKey<Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">>>;
+                readonly templateSourceEntityId: Schema.optionalKey<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">>;
+                readonly sourceRevisionDigest: Schema.brand<Schema.String, string>;
+                readonly sourceRevisionCount: Schema.Int;
+            }>>;
         }>;
         readonly head: Schema.Struct<{
             readonly state: Schema.Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>;
@@ -1011,14 +1031,14 @@ export declare const makeGovernedActionRead: Effect.Effect<{
                         readonly observedAt: Schema.DateTimeUtcFromString;
                     }>;
                 }>;
-                readonly none: Schema.TaggedStruct<"none", {}>;
-                readonly manual: Schema.TaggedStruct<"manual", {
-                    readonly providerOperationId: Schema.NullOr<Schema.brand<Schema.String, string>>;
-                }>;
                 readonly reconcilable: Schema.TaggedStruct<"reconcilable", {
                     readonly providerOperationId: Schema.NullOr<Schema.brand<Schema.String, string>>;
                     readonly reconciliationKey: Schema.brand<Schema.String, string>;
                 }>;
+                readonly manual: Schema.TaggedStruct<"manual", {
+                    readonly providerOperationId: Schema.NullOr<Schema.brand<Schema.String, string>>;
+                }>;
+                readonly none: Schema.TaggedStruct<"none", {}>;
                 readonly terminal: Schema.TaggedStruct<"terminal", {
                     readonly receipt: Schema.Struct<{
                         readonly observationBasis: Schema.optionalKey<Schema.Literal<"authorization">>;
@@ -1110,15 +1130,15 @@ export declare const makeGovernedActionRead: Effect.Effect<{
                 }>;
                 readonly recordUnknown: Schema.TaggedStruct<"recordUnknown", {
                     readonly outcome: Schema.TaggedUnion<{
-                        readonly manual: Schema.TaggedStruct<"manual", {
+                        readonly reconcilable: Schema.TaggedStruct<"reconcilable", {
+                            readonly reconciliationKey: Schema.brand<Schema.String, string>;
                             readonly observedAt: Schema.DateTimeUtcFromString;
                             readonly safeSummary: Schema.String;
-                            readonly reason: Schema.Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
                         }>;
-                        readonly reconcilable: Schema.TaggedStruct<"reconcilable", {
-                            readonly reconciliationKey: Schema.brand<Schema.String, string>;
+                        readonly manual: Schema.TaggedStruct<"manual", {
                             readonly observedAt: Schema.DateTimeUtcFromString;
                             readonly safeSummary: Schema.String;
+                            readonly reason: Schema.Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
                         }>;
                     }>;
                 }>;
@@ -1146,18 +1166,18 @@ export declare const makeGovernedActionRead: Effect.Effect<{
                 }>;
             }>;
             readonly cause: Schema.TaggedUnion<{
-                readonly agent: Schema.TaggedStruct<"agent", {
-                    readonly actor: Schema.TaggedStruct<"agent", {
-                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
-                    }>;
-                    readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
-                }>;
                 readonly human: Schema.TaggedStruct<"human", {
                     readonly actor: Schema.TaggedStruct<"human", {
                         readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
                     }>;
                     readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
                 }>;
+                readonly agent: Schema.TaggedStruct<"agent", {
+                    readonly actor: Schema.TaggedStruct<"agent", {
+                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                    }>;
+                    readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+                }>;
                 readonly system: Schema.TaggedStruct<"system", {
                     readonly component: Schema.brand<Schema.String, string>;
                 }>;
@@ -1246,16 +1266,338 @@ export declare const makeGovernedActionRead: Effect.Effect<{
                 }>;
                 readonly recordUnknown: Schema.TaggedStruct<"recordUnknown", {
                     readonly outcome: Schema.TaggedUnion<{
+                        readonly reconcilable: Schema.TaggedStruct<"reconcilable", {
+                            readonly reconciliationKey: Schema.brand<Schema.String, string>;
+                            readonly observedAt: Schema.DateTimeUtcFromString;
+                            readonly safeSummary: Schema.String;
+                        }>;
                         readonly manual: Schema.TaggedStruct<"manual", {
                             readonly observedAt: Schema.DateTimeUtcFromString;
                             readonly safeSummary: Schema.String;
                             readonly reason: Schema.Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
                         }>;
+                    }>;
+                }>;
+                readonly recordCancelled: Schema.TaggedStruct<"recordCancelled", {
+                    readonly receipt: Schema.Struct<{
+                        readonly observationBasis: Schema.optionalKey<Schema.Literal<"authorization">>;
+                        readonly status: Schema.Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        readonly safeSummary: Schema.String;
+                        readonly observedAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly source: Schema.TaggedUnion<{
+                        readonly direct: Schema.TaggedStruct<"direct", {}>;
+                        readonly providerOperation: Schema.TaggedStruct<"providerOperation", {
+                            readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        }>;
+                        readonly reconciliation: Schema.TaggedStruct<"reconciliation", {
+                            readonly reconciliationKey: Schema.NullOr<Schema.brand<Schema.String, string>>;
+                        }>;
+                    }>;
+                }>;
+                readonly reconciliationPending: Schema.TaggedStruct<"reconciliationPending", {
+                    readonly checkedAt: Schema.DateTimeUtcFromString;
+                    readonly reconciliationKey: Schema.NullOr<Schema.brand<Schema.String, string>>;
+                }>;
+            }>;
+            readonly cause: Schema.TaggedUnion<{
+                readonly human: Schema.TaggedStruct<"human", {
+                    readonly actor: Schema.TaggedStruct<"human", {
+                        readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                    }>;
+                    readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+                }>;
+                readonly agent: Schema.TaggedStruct<"agent", {
+                    readonly actor: Schema.TaggedStruct<"agent", {
+                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                    }>;
+                    readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+                }>;
+                readonly system: Schema.TaggedStruct<"system", {
+                    readonly component: Schema.brand<Schema.String, string>;
+                }>;
+            }>;
+            readonly occurredAt: Schema.DateTimeUtcFromString;
+            readonly causationId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "DomainEventId">>;
+            readonly correlationId: Schema.NullOr<Schema.brand<Schema.String, "DomainEventCorrelationId">>;
+        }>>;
+        readonly authorization: Schema.NullOr<Schema.Struct<{
+            readonly schemaVersion: Schema.Literal<1>;
+            readonly authorizationId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionAuthorizationId">;
+            readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
+            readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+            readonly pluginConnectionRevision: Schema.brand<Schema.Int, "GovernedActionPluginConnectionRevision">;
+            readonly pluginConnectionAuthorityDigest: Schema.brand<Schema.String, string>;
+            readonly actionEnvelopeDigest: Schema.brand<Schema.String, string>;
+            readonly idempotencyKey: Schema.brand<Schema.String, "GovernedActionIdempotencyKey">;
+            readonly payloadDigest: Schema.brand<Schema.String, "PluginActionPayloadDigest">;
+            readonly evidenceSetDigest: Schema.brand<Schema.String, string>;
+            readonly policyDigest: Schema.brand<Schema.String, string>;
+            readonly expectedRevision: Schema.brand<Schema.String, "Revision">;
+            readonly capabilityVersion: Schema.Int;
+            readonly actor: Schema.TaggedStruct<"human", {
+                readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+            }>;
+            readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+            readonly sessionPermission: 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: Schema.DateTimeUtcFromString;
+            readonly requiredPermission: 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: Schema.DateTimeUtcFromString;
+            readonly expiresAt: Schema.DateTimeUtcFromString;
+        }>>;
+        readonly policyEvaluation: Schema.NullOr<Schema.Struct<{
+            readonly schemaVersion: Schema.Literal<1>;
+            readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
+            readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            readonly policy: Schema.Struct<{
+                readonly policyId: Schema.brand<Schema.String, string>;
+                readonly policyVersion: Schema.Int;
+                readonly policyDigest: Schema.brand<Schema.String, string>;
+                readonly requiredPermission: 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: Schema.brand<Schema.String, "PluginActionPayloadDigest">;
+            readonly evidenceSetDigest: Schema.brand<Schema.String, string>;
+            readonly expectedRevision: Schema.brand<Schema.String, "Revision">;
+            readonly decision: Schema.Literals<readonly ["allowed", "denied"]>;
+            readonly evaluatedAt: Schema.DateTimeUtcFromString;
+        }>>;
+        readonly attempt: Schema.NullOr<Schema.Struct<{
+            readonly schemaVersion: Schema.Literal<1>;
+            readonly attemptId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionAttemptId">;
+            readonly authorizationId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionAuthorizationId">;
+            readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
+            readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+            readonly idempotencyKey: Schema.brand<Schema.String, "GovernedActionIdempotencyKey">;
+            readonly attemptNumber: Schema.Literal<1>;
+            readonly actionEnvelopeDigest: Schema.brand<Schema.String, string>;
+            readonly expectedRevision: Schema.brand<Schema.String, "Revision">;
+            readonly policyEvaluationDigest: Schema.brand<Schema.String, string>;
+            readonly preflight: Schema.TaggedStruct<"ready", {
+                readonly checkedRevision: Schema.brand<Schema.String, "Revision">;
+                readonly checkedAt: Schema.DateTimeUtcFromString;
+            }>;
+            readonly startedAt: Schema.DateTimeUtcFromString;
+        }>>;
+    }, "Type">[], RecordNotFoundError | import("../../errors.js").PersistenceOperationError | PersistedRecordError | import("effect/unstable/sql/SqlError").SqlError | import("./quarantine.js").MalformedGovernedActionRecord, import("effect/Crypto").Crypto>;
+    readLatestTerminalReleasePublications: (request: Schema.Struct.ReadonlySide<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly providerId: Schema.Literal<"confluence">;
+        readonly releaseIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">>;
+    }, "Type">) => 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: Schema.Struct.ReadonlySide<{
+                readonly proposalKey: Schema.brand<Schema.String, string>;
+                readonly capabilityVersion: Schema.Int;
+                readonly request: Schema.Struct<{
+                    readonly actionKind: Schema.brand<Schema.String, string>;
+                    readonly target: Schema.Struct<{
+                        entityType: Schema.brand<Schema.String, string>;
+                        vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+                    }>;
+                    readonly expectedRevision: Schema.brand<Schema.String, "Revision">;
+                    readonly payload: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.String, string>>;
+                }>;
+                readonly payloadDigest: Schema.brand<Schema.String, "PluginActionPayloadDigest">;
+                readonly summary: Schema.String;
+                readonly impact: Schema.Struct<{
+                    readonly level: Schema.Literals<readonly ["low", "medium", "high", "critical"]>;
+                    readonly summary: Schema.String;
+                }>;
+                readonly proposedAt: 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: Schema.Struct.ReadonlySide<{
+                readonly policyId: Schema.brand<Schema.String, string>;
+                readonly policyVersion: Schema.Int;
+                readonly policyDigest: Schema.brand<Schema.String, string>;
+                readonly requiredPermission: 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: Schema.Struct.ReadonlySide<{
+                readonly major: Schema.Int;
+                readonly minor: Schema.Int;
+                readonly patch: Schema.Int;
+            }, "Type">;
+            readonly pluginAdapterVersion: Schema.Struct.ReadonlySide<{
+                readonly major: Schema.Int;
+                readonly minor: Schema.Int;
+                readonly patch: Schema.Int;
+            }, "Type">;
+            readonly capability: Schema.Struct.ReadonlySide<{
+                readonly capabilityId: Schema.Literal<"action.execute">;
+                readonly version: Schema.Int;
+            }, "Type">;
+            readonly targetEntityId: string & import("effect/Brand").Brand<"EntityId">;
+            readonly evidence: readonly Schema.Struct.ReadonlySide<{
+                readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                readonly evidenceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">;
+                readonly evidenceClaimIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceClaimId">>;
+                readonly observedAt: Schema.DateTimeUtcFromString;
+                readonly validUntil: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                readonly currentUntil: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                readonly evaluatedAt: Schema.DateTimeUtcFromString;
+                readonly source: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                readonly validity: Schema.Literals<readonly ["valid", "expired"]>;
+            }, "Type">[];
+            readonly origin: Schema.Struct.ReadonlySide<{
+                readonly _tag: Schema.tag<"human">;
+                readonly actor: Schema.TaggedStruct<"human", {
+                    readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                }>;
+                readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+            }, "Type"> | Schema.Struct.ReadonlySide<{
+                readonly _tag: Schema.tag<"agent">;
+                readonly actor: Schema.TaggedStruct<"agent", {
+                    readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                }>;
+                readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+                readonly initiatingSessionId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, 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: Schema.Struct.ReadonlySide<{
+            readonly state: Schema.Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>;
+            readonly lineage: Schema.TaggedUnion<{
+                readonly accepted: Schema.TaggedStruct<"accepted", {
+                    readonly receipt: Schema.Struct<{
+                        readonly status: Schema.Literal<"accepted">;
+                        readonly reconciliationKey: Schema.brand<Schema.String, string>;
+                        readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        readonly safeSummary: Schema.String;
+                        readonly observedAt: Schema.DateTimeUtcFromString;
+                    }>;
+                }>;
+                readonly reconcilable: Schema.TaggedStruct<"reconcilable", {
+                    readonly providerOperationId: Schema.NullOr<Schema.brand<Schema.String, string>>;
+                    readonly reconciliationKey: Schema.brand<Schema.String, string>;
+                }>;
+                readonly manual: Schema.TaggedStruct<"manual", {
+                    readonly providerOperationId: Schema.NullOr<Schema.brand<Schema.String, string>>;
+                }>;
+                readonly none: Schema.TaggedStruct<"none", {}>;
+                readonly terminal: Schema.TaggedStruct<"terminal", {
+                    readonly receipt: Schema.Struct<{
+                        readonly observationBasis: Schema.optionalKey<Schema.Literal<"authorization">>;
+                        readonly status: Schema.Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        readonly safeSummary: Schema.String;
+                        readonly observedAt: Schema.DateTimeUtcFromString;
+                    }>;
+                }>;
+            }>;
+        }, "Type">;
+        headTransition: Schema.Struct.ReadonlySide<{
+            readonly commandDigest: Schema.brand<Schema.String, "GovernedActionCommandDigest">;
+            readonly schemaVersion: Schema.Literal<1>;
+            readonly transitionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionTransitionId">;
+            readonly previousTransitionId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionTransitionId">>;
+            readonly commandId: Schema.brand<Schema.String, string>;
+            readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
+            readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            readonly sequence: Schema.Int;
+            readonly fromState: Schema.NullOr<Schema.Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>>;
+            readonly toState: Schema.Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>;
+            readonly actionEnvelopeDigest: Schema.brand<Schema.String, string>;
+            readonly command: Schema.TaggedUnion<{
+                readonly propose: Schema.TaggedStruct<"propose", {}>;
+                readonly authorize: Schema.TaggedStruct<"authorize", {
+                    readonly authorizationId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionAuthorizationId">;
+                }>;
+                readonly deny: Schema.TaggedStruct<"deny", {
+                    readonly reason: Schema.Literals<readonly ["revision-changed", "evidence-stale", "evidence-invalid", "policy-denied", "session-invalid", "capability-changed", "plugin-unavailable", "preflight-blocked"]>;
+                    readonly safeSummary: Schema.String;
+                }>;
+                readonly expire: Schema.TaggedStruct<"expire", {
+                    readonly reason: Schema.Literals<readonly ["proposal-expired", "authorization-expired"]>;
+                }>;
+                readonly cancel: Schema.TaggedStruct<"cancel", {
+                    readonly safeSummary: Schema.String;
+                }>;
+                readonly start: Schema.TaggedStruct<"start", {
+                    readonly attemptId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionAttemptId">;
+                }>;
+                readonly requestCancellation: Schema.TaggedStruct<"requestCancellation", {
+                    readonly safeSummary: Schema.String;
+                }>;
+                readonly recordAccepted: Schema.TaggedStruct<"recordAccepted", {
+                    readonly receipt: Schema.Struct<{
+                        readonly status: Schema.Literal<"accepted">;
+                        readonly reconciliationKey: Schema.brand<Schema.String, string>;
+                        readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        readonly safeSummary: Schema.String;
+                        readonly observedAt: Schema.DateTimeUtcFromString;
+                    }>;
+                }>;
+                readonly recordSucceeded: Schema.TaggedStruct<"recordSucceeded", {
+                    readonly receipt: Schema.Struct<{
+                        readonly observationBasis: Schema.optionalKey<Schema.Literal<"authorization">>;
+                        readonly status: Schema.Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        readonly safeSummary: Schema.String;
+                        readonly observedAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly source: Schema.TaggedUnion<{
+                        readonly direct: Schema.TaggedStruct<"direct", {}>;
+                        readonly providerOperation: Schema.TaggedStruct<"providerOperation", {
+                            readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        }>;
+                        readonly reconciliation: Schema.TaggedStruct<"reconciliation", {
+                            readonly reconciliationKey: Schema.NullOr<Schema.brand<Schema.String, string>>;
+                        }>;
+                    }>;
+                }>;
+                readonly recordFailed: Schema.TaggedStruct<"recordFailed", {
+                    readonly receipt: Schema.Struct<{
+                        readonly observationBasis: Schema.optionalKey<Schema.Literal<"authorization">>;
+                        readonly status: Schema.Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        readonly safeSummary: Schema.String;
+                        readonly observedAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly source: Schema.TaggedUnion<{
+                        readonly direct: Schema.TaggedStruct<"direct", {}>;
+                        readonly providerOperation: Schema.TaggedStruct<"providerOperation", {
+                            readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        }>;
+                        readonly reconciliation: Schema.TaggedStruct<"reconciliation", {
+                            readonly reconciliationKey: Schema.NullOr<Schema.brand<Schema.String, string>>;
+                        }>;
+                    }>;
+                }>;
+                readonly recordUnknown: Schema.TaggedStruct<"recordUnknown", {
+                    readonly outcome: Schema.TaggedUnion<{
                         readonly reconcilable: Schema.TaggedStruct<"reconcilable", {
                             readonly reconciliationKey: Schema.brand<Schema.String, string>;
                             readonly observedAt: Schema.DateTimeUtcFromString;
                             readonly safeSummary: Schema.String;
                         }>;
+                        readonly manual: Schema.TaggedStruct<"manual", {
+                            readonly observedAt: Schema.DateTimeUtcFromString;
+                            readonly safeSummary: Schema.String;
+                            readonly reason: Schema.Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
+                        }>;
                     }>;
                 }>;
                 readonly recordCancelled: Schema.TaggedStruct<"recordCancelled", {
@@ -1282,18 +1624,154 @@ export declare const makeGovernedActionRead: Effect.Effect<{
                 }>;
             }>;
             readonly cause: Schema.TaggedUnion<{
+                readonly human: Schema.TaggedStruct<"human", {
+                    readonly actor: Schema.TaggedStruct<"human", {
+                        readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                    }>;
+                    readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+                }>;
                 readonly agent: Schema.TaggedStruct<"agent", {
                     readonly actor: Schema.TaggedStruct<"agent", {
                         readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
                     }>;
                     readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
                 }>;
+                readonly system: Schema.TaggedStruct<"system", {
+                    readonly component: Schema.brand<Schema.String, string>;
+                }>;
+            }>;
+            readonly occurredAt: Schema.DateTimeUtcFromString;
+            readonly causationId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "DomainEventId">>;
+            readonly correlationId: Schema.NullOr<Schema.brand<Schema.String, "DomainEventCorrelationId">>;
+        }, "Type">;
+        history: Schema.Struct.ReadonlySide<{
+            readonly commandDigest: Schema.brand<Schema.String, "GovernedActionCommandDigest">;
+            readonly schemaVersion: Schema.Literal<1>;
+            readonly transitionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionTransitionId">;
+            readonly previousTransitionId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionTransitionId">>;
+            readonly commandId: Schema.brand<Schema.String, string>;
+            readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
+            readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            readonly sequence: Schema.Int;
+            readonly fromState: Schema.NullOr<Schema.Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>>;
+            readonly toState: Schema.Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>;
+            readonly actionEnvelopeDigest: Schema.brand<Schema.String, string>;
+            readonly command: Schema.TaggedUnion<{
+                readonly propose: Schema.TaggedStruct<"propose", {}>;
+                readonly authorize: Schema.TaggedStruct<"authorize", {
+                    readonly authorizationId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionAuthorizationId">;
+                }>;
+                readonly deny: Schema.TaggedStruct<"deny", {
+                    readonly reason: Schema.Literals<readonly ["revision-changed", "evidence-stale", "evidence-invalid", "policy-denied", "session-invalid", "capability-changed", "plugin-unavailable", "preflight-blocked"]>;
+                    readonly safeSummary: Schema.String;
+                }>;
+                readonly expire: Schema.TaggedStruct<"expire", {
+                    readonly reason: Schema.Literals<readonly ["proposal-expired", "authorization-expired"]>;
+                }>;
+                readonly cancel: Schema.TaggedStruct<"cancel", {
+                    readonly safeSummary: Schema.String;
+                }>;
+                readonly start: Schema.TaggedStruct<"start", {
+                    readonly attemptId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionAttemptId">;
+                }>;
+                readonly requestCancellation: Schema.TaggedStruct<"requestCancellation", {
+                    readonly safeSummary: Schema.String;
+                }>;
+                readonly recordAccepted: Schema.TaggedStruct<"recordAccepted", {
+                    readonly receipt: Schema.Struct<{
+                        readonly status: Schema.Literal<"accepted">;
+                        readonly reconciliationKey: Schema.brand<Schema.String, string>;
+                        readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        readonly safeSummary: Schema.String;
+                        readonly observedAt: Schema.DateTimeUtcFromString;
+                    }>;
+                }>;
+                readonly recordSucceeded: Schema.TaggedStruct<"recordSucceeded", {
+                    readonly receipt: Schema.Struct<{
+                        readonly observationBasis: Schema.optionalKey<Schema.Literal<"authorization">>;
+                        readonly status: Schema.Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        readonly safeSummary: Schema.String;
+                        readonly observedAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly source: Schema.TaggedUnion<{
+                        readonly direct: Schema.TaggedStruct<"direct", {}>;
+                        readonly providerOperation: Schema.TaggedStruct<"providerOperation", {
+                            readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        }>;
+                        readonly reconciliation: Schema.TaggedStruct<"reconciliation", {
+                            readonly reconciliationKey: Schema.NullOr<Schema.brand<Schema.String, string>>;
+                        }>;
+                    }>;
+                }>;
+                readonly recordFailed: Schema.TaggedStruct<"recordFailed", {
+                    readonly receipt: Schema.Struct<{
+                        readonly observationBasis: Schema.optionalKey<Schema.Literal<"authorization">>;
+                        readonly status: Schema.Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        readonly safeSummary: Schema.String;
+                        readonly observedAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly source: Schema.TaggedUnion<{
+                        readonly direct: Schema.TaggedStruct<"direct", {}>;
+                        readonly providerOperation: Schema.TaggedStruct<"providerOperation", {
+                            readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        }>;
+                        readonly reconciliation: Schema.TaggedStruct<"reconciliation", {
+                            readonly reconciliationKey: Schema.NullOr<Schema.brand<Schema.String, string>>;
+                        }>;
+                    }>;
+                }>;
+                readonly recordUnknown: Schema.TaggedStruct<"recordUnknown", {
+                    readonly outcome: Schema.TaggedUnion<{
+                        readonly reconcilable: Schema.TaggedStruct<"reconcilable", {
+                            readonly reconciliationKey: Schema.brand<Schema.String, string>;
+                            readonly observedAt: Schema.DateTimeUtcFromString;
+                            readonly safeSummary: Schema.String;
+                        }>;
+                        readonly manual: Schema.TaggedStruct<"manual", {
+                            readonly observedAt: Schema.DateTimeUtcFromString;
+                            readonly safeSummary: Schema.String;
+                            readonly reason: Schema.Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
+                        }>;
+                    }>;
+                }>;
+                readonly recordCancelled: Schema.TaggedStruct<"recordCancelled", {
+                    readonly receipt: Schema.Struct<{
+                        readonly observationBasis: Schema.optionalKey<Schema.Literal<"authorization">>;
+                        readonly status: Schema.Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        readonly safeSummary: Schema.String;
+                        readonly observedAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly source: Schema.TaggedUnion<{
+                        readonly direct: Schema.TaggedStruct<"direct", {}>;
+                        readonly providerOperation: Schema.TaggedStruct<"providerOperation", {
+                            readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        }>;
+                        readonly reconciliation: Schema.TaggedStruct<"reconciliation", {
+                            readonly reconciliationKey: Schema.NullOr<Schema.brand<Schema.String, string>>;
+                        }>;
+                    }>;
+                }>;
+                readonly reconciliationPending: Schema.TaggedStruct<"reconciliationPending", {
+                    readonly checkedAt: Schema.DateTimeUtcFromString;
+                    readonly reconciliationKey: Schema.NullOr<Schema.brand<Schema.String, string>>;
+                }>;
+            }>;
+            readonly cause: Schema.TaggedUnion<{
                 readonly human: Schema.TaggedStruct<"human", {
                     readonly actor: Schema.TaggedStruct<"human", {
                         readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
                     }>;
                     readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
                 }>;
+                readonly agent: Schema.TaggedStruct<"agent", {
+                    readonly actor: Schema.TaggedStruct<"agent", {
+                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                    }>;
+                    readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+                }>;
                 readonly system: Schema.TaggedStruct<"system", {
                     readonly component: Schema.brand<Schema.String, string>;
                 }>;
@@ -1301,8 +1779,8 @@ export declare const makeGovernedActionRead: Effect.Effect<{
             readonly occurredAt: Schema.DateTimeUtcFromString;
             readonly causationId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "DomainEventId">>;
             readonly correlationId: Schema.NullOr<Schema.brand<Schema.String, "DomainEventCorrelationId">>;
-        }>>;
-        readonly authorization: Schema.NullOr<Schema.Struct<{
+        }, "Type">[];
+        authorization: Schema.Struct.ReadonlySide<{
             readonly schemaVersion: Schema.Literal<1>;
             readonly authorizationId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionAuthorizationId">;
             readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
@@ -1326,8 +1804,8 @@ export declare const makeGovernedActionRead: Effect.Effect<{
             readonly requiredPermission: 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: Schema.DateTimeUtcFromString;
             readonly expiresAt: Schema.DateTimeUtcFromString;
-        }>>;
-        readonly policyEvaluation: Schema.NullOr<Schema.Struct<{
+        }, "Type"> | null;
+        policyEvaluation: Schema.Struct.ReadonlySide<{
             readonly schemaVersion: Schema.Literal<1>;
             readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
             readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
@@ -1342,8 +1820,8 @@ export declare const makeGovernedActionRead: Effect.Effect<{
             readonly expectedRevision: Schema.brand<Schema.String, "Revision">;
             readonly decision: Schema.Literals<readonly ["allowed", "denied"]>;
             readonly evaluatedAt: Schema.DateTimeUtcFromString;
-        }>>;
-        readonly attempt: Schema.NullOr<Schema.Struct<{
+        }, "Type"> | null;
+        attempt: Schema.Struct.ReadonlySide<{
             readonly schemaVersion: Schema.Literal<1>;
             readonly attemptId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionAttemptId">;
             readonly authorizationId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionAuthorizationId">;
@@ -1360,7 +1838,7 @@ export declare const makeGovernedActionRead: Effect.Effect<{
                 readonly checkedAt: Schema.DateTimeUtcFromString;
             }>;
             readonly startedAt: Schema.DateTimeUtcFromString;
-        }>>;
-    }, "Type">[], RecordNotFoundError | import("../../errors.js").PersistenceOperationError | PersistedRecordError | import("effect/unstable/sql/SqlError").SqlError | import("./quarantine.js").MalformedGovernedActionRecord, import("effect/Crypto").Crypto>;
+        }, "Type"> | null;
+    }[], RecordNotFoundError | import("../../errors.js").PersistenceOperationError | PersistedRecordError | import("effect/unstable/sql/SqlError").SqlError | import("./quarantine.js").MalformedGovernedActionRecord, import("effect/Crypto").Crypto>;
 }, never, Database>;
 //# sourceMappingURL=read.d.ts.map