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

@knpkv/control-center 0.3.0 → 0.4.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 (298) hide show

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

@@ -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,30 @@ 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;
+            };
+        };
         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 +110,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 +209,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 +245,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 +345,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 +381,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 +466,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 +493,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 +531,30 @@ 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;
+            };
+        };
         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 +567,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 +666,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 +702,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 +802,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 +838,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 +920,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 +992,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 +1005,16 @@ 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 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 +1028,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 +1127,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 +1163,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 +1263,337 @@ 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;
+            };
+        };
+        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 +1620,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 +1775,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 +1800,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 +1816,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 +1834,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