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/transaction.d.ts CHANGED Viewed

@@ -1,9 +1,10 @@
 import * as Crypto from "effect/Crypto";
+import * as DateTime from "effect/DateTime";
 import * as Effect from "effect/Effect";
 import { Database } from "../../Database.js";
 import type { PersistedRecordError, PersistenceOperationError, QuarantineWriteError } from "../../errors.js";
 import { QuarantineRepository } from "../quarantineRepository.js";
-import type { GovernedActionIdempotencyReadInput, GovernedActionReadInput, GovernedActionTargetReadInput } from "./contract.js";
+import type { GovernedActionIdempotencyReadInput, GovernedActionReadInput, GovernedActionReleasePublicationReadInput, GovernedActionTargetReadInput } from "./contract.js";
 import type { MalformedGovernedActionRecord } from "./quarantine.js";
 /**
  * Build the rollback-then-quarantine boundary shared by verified governed-action transactions.
@@ -12,33 +13,14 @@ import type { MalformedGovernedActionRecord } from "./quarantine.js";
 export declare const makeGovernedActionTransaction: Effect.Effect<{
     capture: <Value, Failure, Requirements>(effect: Effect.Effect<Value, Failure, Requirements>) => Effect.Effect<Value, Failure | PersistedRecordError | PersistenceOperationError | QuarantineWriteError, Requirements>;
     read: (request: GovernedActionReadInput) => Effect.Effect<{
-        envelope: import("effect/Schema").Struct.ReadonlySide<{
-            readonly envelopeDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
-            readonly schemaVersion: import("effect/Schema").Literal<1>;
-            readonly actionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionId">;
-            readonly idempotencyKey: import("effect/Schema").brand<import("effect/Schema").String, "GovernedActionIdempotencyKey">;
-            readonly workspaceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "WorkspaceId">;
-            readonly pluginConnectionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PluginConnectionId">;
-            readonly pluginConnectionRevision: import("effect/Schema").brand<import("effect/Schema").Int, "GovernedActionPluginConnectionRevision">;
-            readonly pluginConnectionAuthorityDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
-            readonly pluginId: import("effect/Schema").brand<import("effect/Schema").String, string>;
-            readonly pluginContractVersion: import("effect/Schema").Struct<{
-                readonly major: import("effect/Schema").Int;
-                readonly minor: import("effect/Schema").Int;
-                readonly patch: import("effect/Schema").Int;
-            }>;
-            readonly pluginAdapterVersion: import("effect/Schema").Struct<{
-                readonly major: import("effect/Schema").Int;
-                readonly minor: import("effect/Schema").Int;
-                readonly patch: import("effect/Schema").Int;
-            }>;
-            readonly providerId: import("effect/Schema").Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
-            readonly capability: import("effect/Schema").Struct<{
-                readonly capabilityId: import("effect/Schema").Literal<"action.execute">;
-                readonly version: import("effect/Schema").Int;
-            }>;
-            readonly targetEntityId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "EntityId">;
-            readonly proposal: import("effect/Schema").Struct<{
+        envelope: {
+            readonly providerId: "codecommit" | "codepipeline" | "jira" | "confluence" | "clockify";
+            readonly pluginConnectionId: string & import("effect/Brand").Brand<"PluginConnectionId">;
+            readonly workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">;
+            readonly schemaVersion: 1;
+            readonly causationId: (string & import("effect/Brand").Brand<"DomainEventId">) | null;
+            readonly correlationId: (string & import("effect/Brand").Brand<"DomainEventCorrelationId">) | null;
+            readonly proposal: import("effect/Schema").Struct.ReadonlySide<{
                 readonly proposalKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
                 readonly capabilityVersion: import("effect/Schema").Int;
                 readonly request: import("effect/Schema").Struct<{
@@ -58,8 +40,35 @@ export declare const makeGovernedActionTransaction: Effect.Effect<{
                     readonly summary: import("effect/Schema").String;
                 }>;
                 readonly proposedAt: import("effect/Schema").DateTimeUtcFromString;
-            }>;
-            readonly evidence: import("effect/Schema").$Array<import("effect/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: import("effect/Schema").Struct.ReadonlySide<{
+                readonly policyId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly policyVersion: import("effect/Schema").Int;
+                readonly policyDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly requiredPermission: import("effect/Schema").Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
+            }, "Type">;
+            readonly evidenceSetDigest: string & import("effect/Brand").Brand<string>;
+            readonly pluginConnectionRevision: number & import("effect/Brand").Brand<"GovernedActionPluginConnectionRevision">;
+            readonly pluginConnectionAuthorityDigest: string & import("effect/Brand").Brand<string>;
+            readonly pluginContractVersion: import("effect/Schema").Struct.ReadonlySide<{
+                readonly major: import("effect/Schema").Int;
+                readonly minor: import("effect/Schema").Int;
+                readonly patch: import("effect/Schema").Int;
+            }, "Type">;
+            readonly pluginAdapterVersion: import("effect/Schema").Struct.ReadonlySide<{
+                readonly major: import("effect/Schema").Int;
+                readonly minor: import("effect/Schema").Int;
+                readonly patch: import("effect/Schema").Int;
+            }, "Type">;
+            readonly capability: import("effect/Schema").Struct.ReadonlySide<{
+                readonly capabilityId: import("effect/Schema").Literal<"action.execute">;
+                readonly version: import("effect/Schema").Int;
+            }, "Type">;
+            readonly targetEntityId: string & import("effect/Brand").Brand<"EntityId">;
+            readonly evidence: readonly import("effect/Schema").Struct.ReadonlySide<{
                 readonly workspaceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "WorkspaceId">;
                 readonly evidenceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "EvidenceId">;
                 readonly evidenceClaimIds: import("effect/Schema").$Array<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "EvidenceClaimId">>;
@@ -69,33 +78,483 @@ export declare const makeGovernedActionTransaction: Effect.Effect<{
                 readonly evaluatedAt: import("effect/Schema").DateTimeUtcFromString;
                 readonly source: import("effect/Schema").Literals<readonly ["current", "stale", "missing", "unavailable"]>;
                 readonly validity: import("effect/Schema").Literals<readonly ["valid", "expired"]>;
-            }>>;
-            readonly evidenceSetDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
-            readonly policy: import("effect/Schema").Struct<{
-                readonly policyId: import("effect/Schema").brand<import("effect/Schema").String, string>;
-                readonly policyVersion: import("effect/Schema").Int;
-                readonly policyDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
-                readonly requiredPermission: import("effect/Schema").Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
+            }, "Type">[];
+            readonly origin: import("effect/Schema").Struct.ReadonlySide<{
+                readonly _tag: import("effect/Schema").tag<"human">;
+                readonly actor: import("effect/Schema").TaggedStruct<"human", {
+                    readonly personId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PersonId">;
+                }>;
+                readonly sessionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "SessionId">;
+            }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+                readonly _tag: import("effect/Schema").tag<"agent">;
+                readonly actor: import("effect/Schema").TaggedStruct<"agent", {
+                    readonly agentId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "AgentId">;
+                }>;
+                readonly jobId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "JobId">;
+                readonly initiatingSessionId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "SessionId">>;
+            }, "Type">;
+            readonly proposalExpiresAt: DateTime.Utc;
+            readonly envelopeDigest: string & import("effect/Brand").Brand<string>;
+            readonly releasePublication?: {
+                readonly releaseId: string & import("effect/Brand").Brand<"ReleaseId">;
+                readonly sourceRevisionDigest: string & import("effect/Brand").Brand<string>;
+                readonly sourceRevisionCount: number;
+                readonly predecessorPublicationActionId?: (string & import("effect/Brand").Brand<"GovernedActionId">) | null;
+            };
+        };
+        head: import("effect/Schema").Struct.ReadonlySide<{
+            readonly state: import("effect/Schema").Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>;
+            readonly lineage: import("effect/Schema").TaggedUnion<{
+                readonly accepted: import("effect/Schema").TaggedStruct<"accepted", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly status: import("effect/Schema").Literal<"accepted">;
+                        readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                }>;
+                readonly reconcilable: import("effect/Schema").TaggedStruct<"reconcilable", {
+                    readonly providerOperationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                    readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                }>;
+                readonly manual: import("effect/Schema").TaggedStruct<"manual", {
+                    readonly providerOperationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                }>;
+                readonly none: import("effect/Schema").TaggedStruct<"none", {}>;
+                readonly terminal: import("effect/Schema").TaggedStruct<"terminal", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly observationBasis: import("effect/Schema").optionalKey<import("effect/Schema").Literal<"authorization">>;
+                        readonly status: import("effect/Schema").Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                }>;
             }>;
-            readonly origin: import("effect/Schema").TaggedUnion<{
+        }, "Type">;
+        headTransition: import("effect/Schema").Struct.ReadonlySide<{
+            readonly commandDigest: import("effect/Schema").brand<import("effect/Schema").String, "GovernedActionCommandDigest">;
+            readonly schemaVersion: import("effect/Schema").Literal<1>;
+            readonly transitionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionTransitionId">;
+            readonly previousTransitionId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionTransitionId">>;
+            readonly commandId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly actionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionId">;
+            readonly workspaceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "WorkspaceId">;
+            readonly sequence: import("effect/Schema").Int;
+            readonly fromState: import("effect/Schema").NullOr<import("effect/Schema").Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>>;
+            readonly toState: import("effect/Schema").Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>;
+            readonly actionEnvelopeDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly command: import("effect/Schema").TaggedUnion<{
+                readonly propose: import("effect/Schema").TaggedStruct<"propose", {}>;
+                readonly authorize: import("effect/Schema").TaggedStruct<"authorize", {
+                    readonly authorizationId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionAuthorizationId">;
+                }>;
+                readonly deny: import("effect/Schema").TaggedStruct<"deny", {
+                    readonly reason: import("effect/Schema").Literals<readonly ["revision-changed", "evidence-stale", "evidence-invalid", "policy-denied", "session-invalid", "capability-changed", "plugin-unavailable", "preflight-blocked"]>;
+                    readonly safeSummary: import("effect/Schema").String;
+                }>;
+                readonly expire: import("effect/Schema").TaggedStruct<"expire", {
+                    readonly reason: import("effect/Schema").Literals<readonly ["proposal-expired", "authorization-expired"]>;
+                }>;
+                readonly cancel: import("effect/Schema").TaggedStruct<"cancel", {
+                    readonly safeSummary: import("effect/Schema").String;
+                }>;
+                readonly start: import("effect/Schema").TaggedStruct<"start", {
+                    readonly attemptId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionAttemptId">;
+                }>;
+                readonly requestCancellation: import("effect/Schema").TaggedStruct<"requestCancellation", {
+                    readonly safeSummary: import("effect/Schema").String;
+                }>;
+                readonly recordAccepted: import("effect/Schema").TaggedStruct<"recordAccepted", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly status: import("effect/Schema").Literal<"accepted">;
+                        readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                }>;
+                readonly recordSucceeded: import("effect/Schema").TaggedStruct<"recordSucceeded", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly observationBasis: import("effect/Schema").optionalKey<import("effect/Schema").Literal<"authorization">>;
+                        readonly status: import("effect/Schema").Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                    readonly source: import("effect/Schema").TaggedUnion<{
+                        readonly direct: import("effect/Schema").TaggedStruct<"direct", {}>;
+                        readonly providerOperation: import("effect/Schema").TaggedStruct<"providerOperation", {
+                            readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        }>;
+                        readonly reconciliation: import("effect/Schema").TaggedStruct<"reconciliation", {
+                            readonly reconciliationKey: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                        }>;
+                    }>;
+                }>;
+                readonly recordFailed: import("effect/Schema").TaggedStruct<"recordFailed", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly observationBasis: import("effect/Schema").optionalKey<import("effect/Schema").Literal<"authorization">>;
+                        readonly status: import("effect/Schema").Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                    readonly source: import("effect/Schema").TaggedUnion<{
+                        readonly direct: import("effect/Schema").TaggedStruct<"direct", {}>;
+                        readonly providerOperation: import("effect/Schema").TaggedStruct<"providerOperation", {
+                            readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        }>;
+                        readonly reconciliation: import("effect/Schema").TaggedStruct<"reconciliation", {
+                            readonly reconciliationKey: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                        }>;
+                    }>;
+                }>;
+                readonly recordUnknown: import("effect/Schema").TaggedStruct<"recordUnknown", {
+                    readonly outcome: import("effect/Schema").TaggedUnion<{
+                        readonly reconcilable: import("effect/Schema").TaggedStruct<"reconcilable", {
+                            readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                            readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                            readonly safeSummary: import("effect/Schema").String;
+                        }>;
+                        readonly manual: import("effect/Schema").TaggedStruct<"manual", {
+                            readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                            readonly safeSummary: import("effect/Schema").String;
+                            readonly reason: import("effect/Schema").Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
+                        }>;
+                    }>;
+                }>;
+                readonly recordCancelled: import("effect/Schema").TaggedStruct<"recordCancelled", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly observationBasis: import("effect/Schema").optionalKey<import("effect/Schema").Literal<"authorization">>;
+                        readonly status: import("effect/Schema").Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                    readonly source: import("effect/Schema").TaggedUnion<{
+                        readonly direct: import("effect/Schema").TaggedStruct<"direct", {}>;
+                        readonly providerOperation: import("effect/Schema").TaggedStruct<"providerOperation", {
+                            readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        }>;
+                        readonly reconciliation: import("effect/Schema").TaggedStruct<"reconciliation", {
+                            readonly reconciliationKey: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                        }>;
+                    }>;
+                }>;
+                readonly reconciliationPending: import("effect/Schema").TaggedStruct<"reconciliationPending", {
+                    readonly checkedAt: import("effect/Schema").DateTimeUtcFromString;
+                    readonly reconciliationKey: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                }>;
+            }>;
+            readonly cause: import("effect/Schema").TaggedUnion<{
+                readonly human: import("effect/Schema").TaggedStruct<"human", {
+                    readonly actor: import("effect/Schema").TaggedStruct<"human", {
+                        readonly personId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PersonId">;
+                    }>;
+                    readonly sessionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "SessionId">;
+                }>;
                 readonly agent: import("effect/Schema").TaggedStruct<"agent", {
                     readonly actor: import("effect/Schema").TaggedStruct<"agent", {
                         readonly agentId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "AgentId">;
                     }>;
                     readonly jobId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "JobId">;
-                    readonly initiatingSessionId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "SessionId">>;
                 }>;
+                readonly system: import("effect/Schema").TaggedStruct<"system", {
+                    readonly component: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                }>;
+            }>;
+            readonly occurredAt: import("effect/Schema").DateTimeUtcFromString;
+            readonly causationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "DomainEventId">>;
+            readonly correlationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, "DomainEventCorrelationId">>;
+        }, "Type">;
+        history: import("effect/Schema").Struct.ReadonlySide<{
+            readonly commandDigest: import("effect/Schema").brand<import("effect/Schema").String, "GovernedActionCommandDigest">;
+            readonly schemaVersion: import("effect/Schema").Literal<1>;
+            readonly transitionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionTransitionId">;
+            readonly previousTransitionId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionTransitionId">>;
+            readonly commandId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly actionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionId">;
+            readonly workspaceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "WorkspaceId">;
+            readonly sequence: import("effect/Schema").Int;
+            readonly fromState: import("effect/Schema").NullOr<import("effect/Schema").Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>>;
+            readonly toState: import("effect/Schema").Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>;
+            readonly actionEnvelopeDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly command: import("effect/Schema").TaggedUnion<{
+                readonly propose: import("effect/Schema").TaggedStruct<"propose", {}>;
+                readonly authorize: import("effect/Schema").TaggedStruct<"authorize", {
+                    readonly authorizationId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionAuthorizationId">;
+                }>;
+                readonly deny: import("effect/Schema").TaggedStruct<"deny", {
+                    readonly reason: import("effect/Schema").Literals<readonly ["revision-changed", "evidence-stale", "evidence-invalid", "policy-denied", "session-invalid", "capability-changed", "plugin-unavailable", "preflight-blocked"]>;
+                    readonly safeSummary: import("effect/Schema").String;
+                }>;
+                readonly expire: import("effect/Schema").TaggedStruct<"expire", {
+                    readonly reason: import("effect/Schema").Literals<readonly ["proposal-expired", "authorization-expired"]>;
+                }>;
+                readonly cancel: import("effect/Schema").TaggedStruct<"cancel", {
+                    readonly safeSummary: import("effect/Schema").String;
+                }>;
+                readonly start: import("effect/Schema").TaggedStruct<"start", {
+                    readonly attemptId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionAttemptId">;
+                }>;
+                readonly requestCancellation: import("effect/Schema").TaggedStruct<"requestCancellation", {
+                    readonly safeSummary: import("effect/Schema").String;
+                }>;
+                readonly recordAccepted: import("effect/Schema").TaggedStruct<"recordAccepted", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly status: import("effect/Schema").Literal<"accepted">;
+                        readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                }>;
+                readonly recordSucceeded: import("effect/Schema").TaggedStruct<"recordSucceeded", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly observationBasis: import("effect/Schema").optionalKey<import("effect/Schema").Literal<"authorization">>;
+                        readonly status: import("effect/Schema").Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                    readonly source: import("effect/Schema").TaggedUnion<{
+                        readonly direct: import("effect/Schema").TaggedStruct<"direct", {}>;
+                        readonly providerOperation: import("effect/Schema").TaggedStruct<"providerOperation", {
+                            readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        }>;
+                        readonly reconciliation: import("effect/Schema").TaggedStruct<"reconciliation", {
+                            readonly reconciliationKey: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                        }>;
+                    }>;
+                }>;
+                readonly recordFailed: import("effect/Schema").TaggedStruct<"recordFailed", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly observationBasis: import("effect/Schema").optionalKey<import("effect/Schema").Literal<"authorization">>;
+                        readonly status: import("effect/Schema").Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                    readonly source: import("effect/Schema").TaggedUnion<{
+                        readonly direct: import("effect/Schema").TaggedStruct<"direct", {}>;
+                        readonly providerOperation: import("effect/Schema").TaggedStruct<"providerOperation", {
+                            readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        }>;
+                        readonly reconciliation: import("effect/Schema").TaggedStruct<"reconciliation", {
+                            readonly reconciliationKey: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                        }>;
+                    }>;
+                }>;
+                readonly recordUnknown: import("effect/Schema").TaggedStruct<"recordUnknown", {
+                    readonly outcome: import("effect/Schema").TaggedUnion<{
+                        readonly reconcilable: import("effect/Schema").TaggedStruct<"reconcilable", {
+                            readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                            readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                            readonly safeSummary: import("effect/Schema").String;
+                        }>;
+                        readonly manual: import("effect/Schema").TaggedStruct<"manual", {
+                            readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                            readonly safeSummary: import("effect/Schema").String;
+                            readonly reason: import("effect/Schema").Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
+                        }>;
+                    }>;
+                }>;
+                readonly recordCancelled: import("effect/Schema").TaggedStruct<"recordCancelled", {
+                    readonly receipt: import("effect/Schema").Struct<{
+                        readonly observationBasis: import("effect/Schema").optionalKey<import("effect/Schema").Literal<"authorization">>;
+                        readonly status: import("effect/Schema").Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly safeSummary: import("effect/Schema").String;
+                        readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                    }>;
+                    readonly source: import("effect/Schema").TaggedUnion<{
+                        readonly direct: import("effect/Schema").TaggedStruct<"direct", {}>;
+                        readonly providerOperation: import("effect/Schema").TaggedStruct<"providerOperation", {
+                            readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        }>;
+                        readonly reconciliation: import("effect/Schema").TaggedStruct<"reconciliation", {
+                            readonly reconciliationKey: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                        }>;
+                    }>;
+                }>;
+                readonly reconciliationPending: import("effect/Schema").TaggedStruct<"reconciliationPending", {
+                    readonly checkedAt: import("effect/Schema").DateTimeUtcFromString;
+                    readonly reconciliationKey: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                }>;
+            }>;
+            readonly cause: import("effect/Schema").TaggedUnion<{
                 readonly human: import("effect/Schema").TaggedStruct<"human", {
                     readonly actor: import("effect/Schema").TaggedStruct<"human", {
                         readonly personId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PersonId">;
                     }>;
                     readonly sessionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "SessionId">;
                 }>;
+                readonly agent: import("effect/Schema").TaggedStruct<"agent", {
+                    readonly actor: import("effect/Schema").TaggedStruct<"agent", {
+                        readonly agentId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "AgentId">;
+                    }>;
+                    readonly jobId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "JobId">;
+                }>;
+                readonly system: import("effect/Schema").TaggedStruct<"system", {
+                    readonly component: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                }>;
             }>;
-            readonly proposalExpiresAt: import("effect/Schema").DateTimeUtcFromString;
+            readonly occurredAt: import("effect/Schema").DateTimeUtcFromString;
             readonly causationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "DomainEventId">>;
             readonly correlationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, "DomainEventCorrelationId">>;
-        }, "Type">;
+        }, "Type">[];
+        authorization: import("effect/Schema").Struct.ReadonlySide<{
+            readonly schemaVersion: import("effect/Schema").Literal<1>;
+            readonly authorizationId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionAuthorizationId">;
+            readonly actionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionId">;
+            readonly workspaceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "WorkspaceId">;
+            readonly pluginConnectionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PluginConnectionId">;
+            readonly pluginConnectionRevision: import("effect/Schema").brand<import("effect/Schema").Int, "GovernedActionPluginConnectionRevision">;
+            readonly pluginConnectionAuthorityDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly actionEnvelopeDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly idempotencyKey: import("effect/Schema").brand<import("effect/Schema").String, "GovernedActionIdempotencyKey">;
+            readonly payloadDigest: import("effect/Schema").brand<import("effect/Schema").String, "PluginActionPayloadDigest">;
+            readonly evidenceSetDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly policyDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly expectedRevision: import("effect/Schema").brand<import("effect/Schema").String, "Revision">;
+            readonly capabilityVersion: import("effect/Schema").Int;
+            readonly actor: import("effect/Schema").TaggedStruct<"human", {
+                readonly personId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PersonId">;
+            }>;
+            readonly sessionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "SessionId">;
+            readonly sessionPermission: import("effect/Schema").Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
+            readonly sessionExpiresAt: import("effect/Schema").DateTimeUtcFromString;
+            readonly requiredPermission: import("effect/Schema").Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
+            readonly authorizedAt: import("effect/Schema").DateTimeUtcFromString;
+            readonly expiresAt: import("effect/Schema").DateTimeUtcFromString;
+        }, "Type"> | null;
+        policyEvaluation: import("effect/Schema").Struct.ReadonlySide<{
+            readonly schemaVersion: import("effect/Schema").Literal<1>;
+            readonly actionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionId">;
+            readonly workspaceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "WorkspaceId">;
+            readonly policy: import("effect/Schema").Struct<{
+                readonly policyId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly policyVersion: import("effect/Schema").Int;
+                readonly policyDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly requiredPermission: import("effect/Schema").Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
+            }>;
+            readonly payloadDigest: import("effect/Schema").brand<import("effect/Schema").String, "PluginActionPayloadDigest">;
+            readonly evidenceSetDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly expectedRevision: import("effect/Schema").brand<import("effect/Schema").String, "Revision">;
+            readonly decision: import("effect/Schema").Literals<readonly ["allowed", "denied"]>;
+            readonly evaluatedAt: import("effect/Schema").DateTimeUtcFromString;
+        }, "Type"> | null;
+        attempt: import("effect/Schema").Struct.ReadonlySide<{
+            readonly schemaVersion: import("effect/Schema").Literal<1>;
+            readonly attemptId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionAttemptId">;
+            readonly authorizationId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionAuthorizationId">;
+            readonly actionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionId">;
+            readonly workspaceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "WorkspaceId">;
+            readonly pluginConnectionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PluginConnectionId">;
+            readonly idempotencyKey: import("effect/Schema").brand<import("effect/Schema").String, "GovernedActionIdempotencyKey">;
+            readonly attemptNumber: import("effect/Schema").Literal<1>;
+            readonly actionEnvelopeDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly expectedRevision: import("effect/Schema").brand<import("effect/Schema").String, "Revision">;
+            readonly policyEvaluationDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly preflight: import("effect/Schema").TaggedStruct<"ready", {
+                readonly checkedRevision: import("effect/Schema").brand<import("effect/Schema").String, "Revision">;
+                readonly checkedAt: import("effect/Schema").DateTimeUtcFromString;
+            }>;
+            readonly startedAt: import("effect/Schema").DateTimeUtcFromString;
+        }, "Type"> | null;
+    }, import("../../errors.js").RecordNotFoundError | PersistenceOperationError | PersistedRecordError | import("effect/unstable/sql/SqlError").SqlError | MalformedGovernedActionRecord, never>;
+    readByIdempotencyKey: (request: GovernedActionIdempotencyReadInput) => Effect.Effect<{
+        envelope: {
+            readonly providerId: "codecommit" | "codepipeline" | "jira" | "confluence" | "clockify";
+            readonly pluginConnectionId: string & import("effect/Brand").Brand<"PluginConnectionId">;
+            readonly workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">;
+            readonly schemaVersion: 1;
+            readonly causationId: (string & import("effect/Brand").Brand<"DomainEventId">) | null;
+            readonly correlationId: (string & import("effect/Brand").Brand<"DomainEventCorrelationId">) | null;
+            readonly proposal: import("effect/Schema").Struct.ReadonlySide<{
+                readonly proposalKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly capabilityVersion: import("effect/Schema").Int;
+                readonly request: import("effect/Schema").Struct<{
+                    readonly actionKind: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                    readonly target: import("effect/Schema").Struct<{
+                        entityType: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        vendorImmutableId: import("effect/Schema").brand<import("effect/Schema").String, "VendorImmutableId">;
+                    }>;
+                    readonly expectedRevision: import("effect/Schema").brand<import("effect/Schema").String, "Revision">;
+                    readonly payload: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
+                    readonly evidenceIds: import("effect/Schema").$Array<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                }>;
+                readonly payloadDigest: import("effect/Schema").brand<import("effect/Schema").String, "PluginActionPayloadDigest">;
+                readonly summary: import("effect/Schema").String;
+                readonly impact: import("effect/Schema").Struct<{
+                    readonly level: import("effect/Schema").Literals<readonly ["low", "medium", "high", "critical"]>;
+                    readonly summary: import("effect/Schema").String;
+                }>;
+                readonly proposedAt: import("effect/Schema").DateTimeUtcFromString;
+            }, "Type">;
+            readonly idempotencyKey: string & import("effect/Brand").Brand<"GovernedActionIdempotencyKey">;
+            readonly pluginId: string & import("effect/Brand").Brand<string>;
+            readonly actionId: string & import("effect/Brand").Brand<"GovernedActionId">;
+            readonly policy: import("effect/Schema").Struct.ReadonlySide<{
+                readonly policyId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly policyVersion: import("effect/Schema").Int;
+                readonly policyDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly requiredPermission: import("effect/Schema").Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
+            }, "Type">;
+            readonly evidenceSetDigest: string & import("effect/Brand").Brand<string>;
+            readonly pluginConnectionRevision: number & import("effect/Brand").Brand<"GovernedActionPluginConnectionRevision">;
+            readonly pluginConnectionAuthorityDigest: string & import("effect/Brand").Brand<string>;
+            readonly pluginContractVersion: import("effect/Schema").Struct.ReadonlySide<{
+                readonly major: import("effect/Schema").Int;
+                readonly minor: import("effect/Schema").Int;
+                readonly patch: import("effect/Schema").Int;
+            }, "Type">;
+            readonly pluginAdapterVersion: import("effect/Schema").Struct.ReadonlySide<{
+                readonly major: import("effect/Schema").Int;
+                readonly minor: import("effect/Schema").Int;
+                readonly patch: import("effect/Schema").Int;
+            }, "Type">;
+            readonly capability: import("effect/Schema").Struct.ReadonlySide<{
+                readonly capabilityId: import("effect/Schema").Literal<"action.execute">;
+                readonly version: import("effect/Schema").Int;
+            }, "Type">;
+            readonly targetEntityId: string & import("effect/Brand").Brand<"EntityId">;
+            readonly evidence: readonly import("effect/Schema").Struct.ReadonlySide<{
+                readonly workspaceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "WorkspaceId">;
+                readonly evidenceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "EvidenceId">;
+                readonly evidenceClaimIds: import("effect/Schema").$Array<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "EvidenceClaimId">>;
+                readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                readonly validUntil: import("effect/Schema").NullOr<import("effect/Schema").DateTimeUtcFromString>;
+                readonly currentUntil: import("effect/Schema").NullOr<import("effect/Schema").DateTimeUtcFromString>;
+                readonly evaluatedAt: import("effect/Schema").DateTimeUtcFromString;
+                readonly source: import("effect/Schema").Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                readonly validity: import("effect/Schema").Literals<readonly ["valid", "expired"]>;
+            }, "Type">[];
+            readonly origin: import("effect/Schema").Struct.ReadonlySide<{
+                readonly _tag: import("effect/Schema").tag<"human">;
+                readonly actor: import("effect/Schema").TaggedStruct<"human", {
+                    readonly personId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PersonId">;
+                }>;
+                readonly sessionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "SessionId">;
+            }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+                readonly _tag: import("effect/Schema").tag<"agent">;
+                readonly actor: import("effect/Schema").TaggedStruct<"agent", {
+                    readonly agentId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "AgentId">;
+                }>;
+                readonly jobId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "JobId">;
+                readonly initiatingSessionId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "SessionId">>;
+            }, "Type">;
+            readonly proposalExpiresAt: DateTime.Utc;
+            readonly envelopeDigest: string & import("effect/Brand").Brand<string>;
+            readonly releasePublication?: {
+                readonly releaseId: string & import("effect/Brand").Brand<"ReleaseId">;
+                readonly sourceRevisionDigest: string & import("effect/Brand").Brand<string>;
+                readonly sourceRevisionCount: number;
+                readonly predecessorPublicationActionId?: (string & import("effect/Brand").Brand<"GovernedActionId">) | null;
+            };
+        };
         head: import("effect/Schema").Struct.ReadonlySide<{
             readonly state: import("effect/Schema").Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>;
             readonly lineage: import("effect/Schema").TaggedUnion<{
@@ -108,14 +567,14 @@ export declare const makeGovernedActionTransaction: Effect.Effect<{
                         readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
                     }>;
                 }>;
-                readonly none: import("effect/Schema").TaggedStruct<"none", {}>;
-                readonly manual: import("effect/Schema").TaggedStruct<"manual", {
-                    readonly providerOperationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
-                }>;
                 readonly reconcilable: import("effect/Schema").TaggedStruct<"reconcilable", {
                     readonly providerOperationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
                     readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
                 }>;
+                readonly manual: import("effect/Schema").TaggedStruct<"manual", {
+                    readonly providerOperationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                }>;
+                readonly none: import("effect/Schema").TaggedStruct<"none", {}>;
                 readonly terminal: import("effect/Schema").TaggedStruct<"terminal", {
                     readonly receipt: import("effect/Schema").Struct<{
                         readonly observationBasis: import("effect/Schema").optionalKey<import("effect/Schema").Literal<"authorization">>;
@@ -207,15 +666,15 @@ export declare const makeGovernedActionTransaction: Effect.Effect<{
                 }>;
                 readonly recordUnknown: import("effect/Schema").TaggedStruct<"recordUnknown", {
                     readonly outcome: import("effect/Schema").TaggedUnion<{
-                        readonly manual: import("effect/Schema").TaggedStruct<"manual", {
+                        readonly reconcilable: import("effect/Schema").TaggedStruct<"reconcilable", {
+                            readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
                             readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
                             readonly safeSummary: import("effect/Schema").String;
-                            readonly reason: import("effect/Schema").Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
                         }>;
-                        readonly reconcilable: import("effect/Schema").TaggedStruct<"reconcilable", {
-                            readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly manual: import("effect/Schema").TaggedStruct<"manual", {
                             readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
                             readonly safeSummary: import("effect/Schema").String;
+                            readonly reason: import("effect/Schema").Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
                         }>;
                     }>;
                 }>;
@@ -243,17 +702,17 @@ export declare const makeGovernedActionTransaction: Effect.Effect<{
                 }>;
             }>;
             readonly cause: import("effect/Schema").TaggedUnion<{
-                readonly agent: import("effect/Schema").TaggedStruct<"agent", {
-                    readonly actor: import("effect/Schema").TaggedStruct<"agent", {
-                        readonly agentId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "AgentId">;
-                    }>;
-                    readonly jobId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "JobId">;
-                }>;
                 readonly human: import("effect/Schema").TaggedStruct<"human", {
                     readonly actor: import("effect/Schema").TaggedStruct<"human", {
                         readonly personId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PersonId">;
                     }>;
-                    readonly sessionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "SessionId">;
+                    readonly sessionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "SessionId">;
+                }>;
+                readonly agent: import("effect/Schema").TaggedStruct<"agent", {
+                    readonly actor: import("effect/Schema").TaggedStruct<"agent", {
+                        readonly agentId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "AgentId">;
+                    }>;
+                    readonly jobId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "JobId">;
                 }>;
                 readonly system: import("effect/Schema").TaggedStruct<"system", {
                     readonly component: import("effect/Schema").brand<import("effect/Schema").String, string>;
@@ -343,15 +802,15 @@ export declare const makeGovernedActionTransaction: Effect.Effect<{
                 }>;
                 readonly recordUnknown: import("effect/Schema").TaggedStruct<"recordUnknown", {
                     readonly outcome: import("effect/Schema").TaggedUnion<{
-                        readonly manual: import("effect/Schema").TaggedStruct<"manual", {
+                        readonly reconcilable: import("effect/Schema").TaggedStruct<"reconcilable", {
+                            readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
                             readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
                             readonly safeSummary: import("effect/Schema").String;
-                            readonly reason: import("effect/Schema").Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
                         }>;
-                        readonly reconcilable: import("effect/Schema").TaggedStruct<"reconcilable", {
-                            readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly manual: import("effect/Schema").TaggedStruct<"manual", {
                             readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
                             readonly safeSummary: import("effect/Schema").String;
+                            readonly reason: import("effect/Schema").Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
                         }>;
                     }>;
                 }>;
@@ -379,18 +838,18 @@ export declare const makeGovernedActionTransaction: Effect.Effect<{
                 }>;
             }>;
             readonly cause: import("effect/Schema").TaggedUnion<{
-                readonly agent: import("effect/Schema").TaggedStruct<"agent", {
-                    readonly actor: import("effect/Schema").TaggedStruct<"agent", {
-                        readonly agentId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "AgentId">;
-                    }>;
-                    readonly jobId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "JobId">;
-                }>;
                 readonly human: import("effect/Schema").TaggedStruct<"human", {
                     readonly actor: import("effect/Schema").TaggedStruct<"human", {
                         readonly personId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PersonId">;
                     }>;
                     readonly sessionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "SessionId">;
                 }>;
+                readonly agent: import("effect/Schema").TaggedStruct<"agent", {
+                    readonly actor: import("effect/Schema").TaggedStruct<"agent", {
+                        readonly agentId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "AgentId">;
+                    }>;
+                    readonly jobId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "JobId">;
+                }>;
                 readonly system: import("effect/Schema").TaggedStruct<"system", {
                     readonly component: import("effect/Schema").brand<import("effect/Schema").String, string>;
                 }>;
@@ -459,8 +918,8 @@ export declare const makeGovernedActionTransaction: Effect.Effect<{
             readonly startedAt: import("effect/Schema").DateTimeUtcFromString;
         }, "Type"> | null;
     }, import("../../errors.js").RecordNotFoundError | PersistenceOperationError | PersistedRecordError | import("effect/unstable/sql/SqlError").SqlError | MalformedGovernedActionRecord, never>;
-    readByIdempotencyKey: (request: GovernedActionIdempotencyReadInput) => Effect.Effect<{
-        envelope: import("effect/Schema").Struct.ReadonlySide<{
+    readLatestTerminalByTarget: (request: GovernedActionTargetReadInput) => Effect.Effect<readonly import("effect/Schema").Struct.ReadonlySide<{
+        readonly envelope: import("effect/Schema").Struct<{
             readonly envelopeDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
             readonly schemaVersion: import("effect/Schema").Literal<1>;
             readonly actionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionId">;
@@ -526,6 +985,12 @@ export declare const makeGovernedActionTransaction: Effect.Effect<{
                 readonly requiredPermission: import("effect/Schema").Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
             }>;
             readonly origin: import("effect/Schema").TaggedUnion<{
+                readonly human: import("effect/Schema").TaggedStruct<"human", {
+                    readonly actor: import("effect/Schema").TaggedStruct<"human", {
+                        readonly personId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PersonId">;
+                    }>;
+                    readonly sessionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "SessionId">;
+                }>;
                 readonly agent: import("effect/Schema").TaggedStruct<"agent", {
                     readonly actor: import("effect/Schema").TaggedStruct<"agent", {
                         readonly agentId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "AgentId">;
@@ -533,18 +998,18 @@ export declare const makeGovernedActionTransaction: Effect.Effect<{
                     readonly jobId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "JobId">;
                     readonly initiatingSessionId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "SessionId">>;
                 }>;
-                readonly human: import("effect/Schema").TaggedStruct<"human", {
-                    readonly actor: import("effect/Schema").TaggedStruct<"human", {
-                        readonly personId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PersonId">;
-                    }>;
-                    readonly sessionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "SessionId">;
-                }>;
             }>;
             readonly proposalExpiresAt: import("effect/Schema").DateTimeUtcFromString;
             readonly causationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "DomainEventId">>;
             readonly correlationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, "DomainEventCorrelationId">>;
-        }, "Type">;
-        head: import("effect/Schema").Struct.ReadonlySide<{
+            readonly releasePublication: import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+                readonly releaseId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "ReleaseId">;
+                readonly predecessorPublicationActionId: import("effect/Schema").optionalKey<import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionId">>>;
+                readonly sourceRevisionDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly sourceRevisionCount: import("effect/Schema").Int;
+            }>>;
+        }>;
+        readonly head: import("effect/Schema").Struct<{
             readonly state: import("effect/Schema").Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>;
             readonly lineage: import("effect/Schema").TaggedUnion<{
                 readonly accepted: import("effect/Schema").TaggedStruct<"accepted", {
@@ -556,14 +1021,14 @@ export declare const makeGovernedActionTransaction: Effect.Effect<{
                         readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
                     }>;
                 }>;
-                readonly none: import("effect/Schema").TaggedStruct<"none", {}>;
-                readonly manual: import("effect/Schema").TaggedStruct<"manual", {
-                    readonly providerOperationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
-                }>;
                 readonly reconcilable: import("effect/Schema").TaggedStruct<"reconcilable", {
                     readonly providerOperationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
                     readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
                 }>;
+                readonly manual: import("effect/Schema").TaggedStruct<"manual", {
+                    readonly providerOperationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                }>;
+                readonly none: import("effect/Schema").TaggedStruct<"none", {}>;
                 readonly terminal: import("effect/Schema").TaggedStruct<"terminal", {
                     readonly receipt: import("effect/Schema").Struct<{
                         readonly observationBasis: import("effect/Schema").optionalKey<import("effect/Schema").Literal<"authorization">>;
@@ -574,8 +1039,8 @@ export declare const makeGovernedActionTransaction: Effect.Effect<{
                     }>;
                 }>;
             }>;
-        }, "Type">;
-        headTransition: import("effect/Schema").Struct.ReadonlySide<{
+        }>;
+        readonly headTransition: import("effect/Schema").Struct<{
             readonly commandDigest: import("effect/Schema").brand<import("effect/Schema").String, "GovernedActionCommandDigest">;
             readonly schemaVersion: import("effect/Schema").Literal<1>;
             readonly transitionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionTransitionId">;
@@ -655,15 +1120,15 @@ export declare const makeGovernedActionTransaction: Effect.Effect<{
                 }>;
                 readonly recordUnknown: import("effect/Schema").TaggedStruct<"recordUnknown", {
                     readonly outcome: import("effect/Schema").TaggedUnion<{
-                        readonly manual: import("effect/Schema").TaggedStruct<"manual", {
+                        readonly reconcilable: import("effect/Schema").TaggedStruct<"reconcilable", {
+                            readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
                             readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
                             readonly safeSummary: import("effect/Schema").String;
-                            readonly reason: import("effect/Schema").Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
                         }>;
-                        readonly reconcilable: import("effect/Schema").TaggedStruct<"reconcilable", {
-                            readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly manual: import("effect/Schema").TaggedStruct<"manual", {
                             readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
                             readonly safeSummary: import("effect/Schema").String;
+                            readonly reason: import("effect/Schema").Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
                         }>;
                     }>;
                 }>;
@@ -691,18 +1156,18 @@ export declare const makeGovernedActionTransaction: Effect.Effect<{
                 }>;
             }>;
             readonly cause: import("effect/Schema").TaggedUnion<{
-                readonly agent: import("effect/Schema").TaggedStruct<"agent", {
-                    readonly actor: import("effect/Schema").TaggedStruct<"agent", {
-                        readonly agentId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "AgentId">;
-                    }>;
-                    readonly jobId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "JobId">;
-                }>;
                 readonly human: import("effect/Schema").TaggedStruct<"human", {
                     readonly actor: import("effect/Schema").TaggedStruct<"human", {
                         readonly personId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PersonId">;
                     }>;
                     readonly sessionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "SessionId">;
                 }>;
+                readonly agent: import("effect/Schema").TaggedStruct<"agent", {
+                    readonly actor: import("effect/Schema").TaggedStruct<"agent", {
+                        readonly agentId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "AgentId">;
+                    }>;
+                    readonly jobId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "JobId">;
+                }>;
                 readonly system: import("effect/Schema").TaggedStruct<"system", {
                     readonly component: import("effect/Schema").brand<import("effect/Schema").String, string>;
                 }>;
@@ -710,8 +1175,8 @@ export declare const makeGovernedActionTransaction: Effect.Effect<{
             readonly occurredAt: import("effect/Schema").DateTimeUtcFromString;
             readonly causationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "DomainEventId">>;
             readonly correlationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, "DomainEventCorrelationId">>;
-        }, "Type">;
-        history: import("effect/Schema").Struct.ReadonlySide<{
+        }>;
+        readonly history: import("effect/Schema").$Array<import("effect/Schema").Struct<{
             readonly commandDigest: import("effect/Schema").brand<import("effect/Schema").String, "GovernedActionCommandDigest">;
             readonly schemaVersion: import("effect/Schema").Literal<1>;
             readonly transitionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionTransitionId">;
@@ -791,15 +1256,15 @@ export declare const makeGovernedActionTransaction: Effect.Effect<{
                 }>;
                 readonly recordUnknown: import("effect/Schema").TaggedStruct<"recordUnknown", {
                     readonly outcome: import("effect/Schema").TaggedUnion<{
-                        readonly manual: import("effect/Schema").TaggedStruct<"manual", {
+                        readonly reconcilable: import("effect/Schema").TaggedStruct<"reconcilable", {
+                            readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
                             readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
                             readonly safeSummary: import("effect/Schema").String;
-                            readonly reason: import("effect/Schema").Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
                         }>;
-                        readonly reconcilable: import("effect/Schema").TaggedStruct<"reconcilable", {
-                            readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly manual: import("effect/Schema").TaggedStruct<"manual", {
                             readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
                             readonly safeSummary: import("effect/Schema").String;
+                            readonly reason: import("effect/Schema").Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
                         }>;
                     }>;
                 }>;
@@ -827,18 +1292,18 @@ export declare const makeGovernedActionTransaction: Effect.Effect<{
                 }>;
             }>;
             readonly cause: import("effect/Schema").TaggedUnion<{
-                readonly agent: import("effect/Schema").TaggedStruct<"agent", {
-                    readonly actor: import("effect/Schema").TaggedStruct<"agent", {
-                        readonly agentId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "AgentId">;
-                    }>;
-                    readonly jobId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "JobId">;
-                }>;
                 readonly human: import("effect/Schema").TaggedStruct<"human", {
                     readonly actor: import("effect/Schema").TaggedStruct<"human", {
                         readonly personId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PersonId">;
                     }>;
                     readonly sessionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "SessionId">;
                 }>;
+                readonly agent: import("effect/Schema").TaggedStruct<"agent", {
+                    readonly actor: import("effect/Schema").TaggedStruct<"agent", {
+                        readonly agentId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "AgentId">;
+                    }>;
+                    readonly jobId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "JobId">;
+                }>;
                 readonly system: import("effect/Schema").TaggedStruct<"system", {
                     readonly component: import("effect/Schema").brand<import("effect/Schema").String, string>;
                 }>;
@@ -846,8 +1311,8 @@ export declare const makeGovernedActionTransaction: Effect.Effect<{
             readonly occurredAt: import("effect/Schema").DateTimeUtcFromString;
             readonly causationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "DomainEventId">>;
             readonly correlationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, "DomainEventCorrelationId">>;
-        }, "Type">[];
-        authorization: import("effect/Schema").Struct.ReadonlySide<{
+        }>>;
+        readonly authorization: import("effect/Schema").NullOr<import("effect/Schema").Struct<{
             readonly schemaVersion: import("effect/Schema").Literal<1>;
             readonly authorizationId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionAuthorizationId">;
             readonly actionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionId">;
@@ -871,8 +1336,8 @@ export declare const makeGovernedActionTransaction: Effect.Effect<{
             readonly requiredPermission: import("effect/Schema").Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
             readonly authorizedAt: import("effect/Schema").DateTimeUtcFromString;
             readonly expiresAt: import("effect/Schema").DateTimeUtcFromString;
-        }, "Type"> | null;
-        policyEvaluation: import("effect/Schema").Struct.ReadonlySide<{
+        }>>;
+        readonly policyEvaluation: import("effect/Schema").NullOr<import("effect/Schema").Struct<{
             readonly schemaVersion: import("effect/Schema").Literal<1>;
             readonly actionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionId">;
             readonly workspaceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "WorkspaceId">;
@@ -887,8 +1352,8 @@ export declare const makeGovernedActionTransaction: Effect.Effect<{
             readonly expectedRevision: import("effect/Schema").brand<import("effect/Schema").String, "Revision">;
             readonly decision: import("effect/Schema").Literals<readonly ["allowed", "denied"]>;
             readonly evaluatedAt: import("effect/Schema").DateTimeUtcFromString;
-        }, "Type"> | null;
-        attempt: import("effect/Schema").Struct.ReadonlySide<{
+        }>>;
+        readonly attempt: import("effect/Schema").NullOr<import("effect/Schema").Struct<{
             readonly schemaVersion: import("effect/Schema").Literal<1>;
             readonly attemptId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionAttemptId">;
             readonly authorizationId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionAuthorizationId">;
@@ -905,36 +1370,17 @@ export declare const makeGovernedActionTransaction: Effect.Effect<{
                 readonly checkedAt: import("effect/Schema").DateTimeUtcFromString;
             }>;
             readonly startedAt: import("effect/Schema").DateTimeUtcFromString;
-        }, "Type"> | null;
-    }, import("../../errors.js").RecordNotFoundError | PersistenceOperationError | PersistedRecordError | import("effect/unstable/sql/SqlError").SqlError | MalformedGovernedActionRecord, never>;
-    readLatestTerminalByTarget: (request: GovernedActionTargetReadInput) => Effect.Effect<readonly import("effect/Schema").Struct.ReadonlySide<{
-        readonly envelope: import("effect/Schema").Struct<{
-            readonly envelopeDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
-            readonly schemaVersion: import("effect/Schema").Literal<1>;
-            readonly actionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionId">;
-            readonly idempotencyKey: import("effect/Schema").brand<import("effect/Schema").String, "GovernedActionIdempotencyKey">;
-            readonly workspaceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "WorkspaceId">;
-            readonly pluginConnectionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PluginConnectionId">;
-            readonly pluginConnectionRevision: import("effect/Schema").brand<import("effect/Schema").Int, "GovernedActionPluginConnectionRevision">;
-            readonly pluginConnectionAuthorityDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
-            readonly pluginId: import("effect/Schema").brand<import("effect/Schema").String, string>;
-            readonly pluginContractVersion: import("effect/Schema").Struct<{
-                readonly major: import("effect/Schema").Int;
-                readonly minor: import("effect/Schema").Int;
-                readonly patch: import("effect/Schema").Int;
-            }>;
-            readonly pluginAdapterVersion: import("effect/Schema").Struct<{
-                readonly major: import("effect/Schema").Int;
-                readonly minor: import("effect/Schema").Int;
-                readonly patch: import("effect/Schema").Int;
-            }>;
-            readonly providerId: import("effect/Schema").Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
-            readonly capability: import("effect/Schema").Struct<{
-                readonly capabilityId: import("effect/Schema").Literal<"action.execute">;
-                readonly version: import("effect/Schema").Int;
-            }>;
-            readonly targetEntityId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "EntityId">;
-            readonly proposal: import("effect/Schema").Struct<{
+        }>>;
+    }, "Type">[], import("../../errors.js").RecordNotFoundError | PersistenceOperationError | PersistedRecordError | import("effect/unstable/sql/SqlError").SqlError | MalformedGovernedActionRecord, never>;
+    readLatestTerminalReleasePublications: (request: GovernedActionReleasePublicationReadInput) => Effect.Effect<{
+        envelope: {
+            readonly providerId: "codecommit" | "codepipeline" | "jira" | "confluence" | "clockify";
+            readonly pluginConnectionId: string & import("effect/Brand").Brand<"PluginConnectionId">;
+            readonly workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">;
+            readonly schemaVersion: 1;
+            readonly causationId: (string & import("effect/Brand").Brand<"DomainEventId">) | null;
+            readonly correlationId: (string & import("effect/Brand").Brand<"DomainEventCorrelationId">) | null;
+            readonly proposal: import("effect/Schema").Struct.ReadonlySide<{
                 readonly proposalKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
                 readonly capabilityVersion: import("effect/Schema").Int;
                 readonly request: import("effect/Schema").Struct<{
@@ -954,8 +1400,35 @@ export declare const makeGovernedActionTransaction: Effect.Effect<{
                     readonly summary: import("effect/Schema").String;
                 }>;
                 readonly proposedAt: import("effect/Schema").DateTimeUtcFromString;
-            }>;
-            readonly evidence: import("effect/Schema").$Array<import("effect/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: import("effect/Schema").Struct.ReadonlySide<{
+                readonly policyId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly policyVersion: import("effect/Schema").Int;
+                readonly policyDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly requiredPermission: import("effect/Schema").Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
+            }, "Type">;
+            readonly evidenceSetDigest: string & import("effect/Brand").Brand<string>;
+            readonly pluginConnectionRevision: number & import("effect/Brand").Brand<"GovernedActionPluginConnectionRevision">;
+            readonly pluginConnectionAuthorityDigest: string & import("effect/Brand").Brand<string>;
+            readonly pluginContractVersion: import("effect/Schema").Struct.ReadonlySide<{
+                readonly major: import("effect/Schema").Int;
+                readonly minor: import("effect/Schema").Int;
+                readonly patch: import("effect/Schema").Int;
+            }, "Type">;
+            readonly pluginAdapterVersion: import("effect/Schema").Struct.ReadonlySide<{
+                readonly major: import("effect/Schema").Int;
+                readonly minor: import("effect/Schema").Int;
+                readonly patch: import("effect/Schema").Int;
+            }, "Type">;
+            readonly capability: import("effect/Schema").Struct.ReadonlySide<{
+                readonly capabilityId: import("effect/Schema").Literal<"action.execute">;
+                readonly version: import("effect/Schema").Int;
+            }, "Type">;
+            readonly targetEntityId: string & import("effect/Brand").Brand<"EntityId">;
+            readonly evidence: readonly import("effect/Schema").Struct.ReadonlySide<{
                 readonly workspaceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "WorkspaceId">;
                 readonly evidenceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "EvidenceId">;
                 readonly evidenceClaimIds: import("effect/Schema").$Array<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "EvidenceClaimId">>;
@@ -965,34 +1438,31 @@ export declare const makeGovernedActionTransaction: Effect.Effect<{
                 readonly evaluatedAt: import("effect/Schema").DateTimeUtcFromString;
                 readonly source: import("effect/Schema").Literals<readonly ["current", "stale", "missing", "unavailable"]>;
                 readonly validity: import("effect/Schema").Literals<readonly ["valid", "expired"]>;
-            }>>;
-            readonly evidenceSetDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
-            readonly policy: import("effect/Schema").Struct<{
-                readonly policyId: import("effect/Schema").brand<import("effect/Schema").String, string>;
-                readonly policyVersion: import("effect/Schema").Int;
-                readonly policyDigest: import("effect/Schema").brand<import("effect/Schema").String, string>;
-                readonly requiredPermission: import("effect/Schema").Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
-            }>;
-            readonly origin: import("effect/Schema").TaggedUnion<{
-                readonly agent: import("effect/Schema").TaggedStruct<"agent", {
-                    readonly actor: import("effect/Schema").TaggedStruct<"agent", {
-                        readonly agentId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "AgentId">;
-                    }>;
-                    readonly jobId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "JobId">;
-                    readonly initiatingSessionId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "SessionId">>;
-                }>;
-                readonly human: import("effect/Schema").TaggedStruct<"human", {
-                    readonly actor: import("effect/Schema").TaggedStruct<"human", {
-                        readonly personId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PersonId">;
-                    }>;
-                    readonly sessionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "SessionId">;
-                }>;
-            }>;
-            readonly proposalExpiresAt: import("effect/Schema").DateTimeUtcFromString;
-            readonly causationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "DomainEventId">>;
-            readonly correlationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, "DomainEventCorrelationId">>;
-        }>;
-        readonly head: import("effect/Schema").Struct<{
+            }, "Type">[];
+            readonly origin: import("effect/Schema").Struct.ReadonlySide<{
+                readonly _tag: import("effect/Schema").tag<"human">;
+                readonly actor: import("effect/Schema").TaggedStruct<"human", {
+                    readonly personId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PersonId">;
+                }>;
+                readonly sessionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "SessionId">;
+            }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+                readonly _tag: import("effect/Schema").tag<"agent">;
+                readonly actor: import("effect/Schema").TaggedStruct<"agent", {
+                    readonly agentId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "AgentId">;
+                }>;
+                readonly jobId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "JobId">;
+                readonly initiatingSessionId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "SessionId">>;
+            }, "Type">;
+            readonly proposalExpiresAt: DateTime.Utc;
+            readonly envelopeDigest: string & import("effect/Brand").Brand<string>;
+            readonly releasePublication?: {
+                readonly releaseId: string & import("effect/Brand").Brand<"ReleaseId">;
+                readonly sourceRevisionDigest: string & import("effect/Brand").Brand<string>;
+                readonly sourceRevisionCount: number;
+                readonly predecessorPublicationActionId?: (string & import("effect/Brand").Brand<"GovernedActionId">) | null;
+            };
+        };
+        head: import("effect/Schema").Struct.ReadonlySide<{
             readonly state: import("effect/Schema").Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>;
             readonly lineage: import("effect/Schema").TaggedUnion<{
                 readonly accepted: import("effect/Schema").TaggedStruct<"accepted", {
@@ -1004,14 +1474,14 @@ export declare const makeGovernedActionTransaction: Effect.Effect<{
                         readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
                     }>;
                 }>;
-                readonly none: import("effect/Schema").TaggedStruct<"none", {}>;
-                readonly manual: import("effect/Schema").TaggedStruct<"manual", {
-                    readonly providerOperationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
-                }>;
                 readonly reconcilable: import("effect/Schema").TaggedStruct<"reconcilable", {
                     readonly providerOperationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
                     readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
                 }>;
+                readonly manual: import("effect/Schema").TaggedStruct<"manual", {
+                    readonly providerOperationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                }>;
+                readonly none: import("effect/Schema").TaggedStruct<"none", {}>;
                 readonly terminal: import("effect/Schema").TaggedStruct<"terminal", {
                     readonly receipt: import("effect/Schema").Struct<{
                         readonly observationBasis: import("effect/Schema").optionalKey<import("effect/Schema").Literal<"authorization">>;
@@ -1022,8 +1492,8 @@ export declare const makeGovernedActionTransaction: Effect.Effect<{
                     }>;
                 }>;
             }>;
-        }>;
-        readonly headTransition: import("effect/Schema").Struct<{
+        }, "Type">;
+        headTransition: import("effect/Schema").Struct.ReadonlySide<{
             readonly commandDigest: import("effect/Schema").brand<import("effect/Schema").String, "GovernedActionCommandDigest">;
             readonly schemaVersion: import("effect/Schema").Literal<1>;
             readonly transitionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionTransitionId">;
@@ -1103,15 +1573,15 @@ export declare const makeGovernedActionTransaction: Effect.Effect<{
                 }>;
                 readonly recordUnknown: import("effect/Schema").TaggedStruct<"recordUnknown", {
                     readonly outcome: import("effect/Schema").TaggedUnion<{
-                        readonly manual: import("effect/Schema").TaggedStruct<"manual", {
+                        readonly reconcilable: import("effect/Schema").TaggedStruct<"reconcilable", {
+                            readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
                             readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
                             readonly safeSummary: import("effect/Schema").String;
-                            readonly reason: import("effect/Schema").Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
                         }>;
-                        readonly reconcilable: import("effect/Schema").TaggedStruct<"reconcilable", {
-                            readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly manual: import("effect/Schema").TaggedStruct<"manual", {
                             readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
                             readonly safeSummary: import("effect/Schema").String;
+                            readonly reason: import("effect/Schema").Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
                         }>;
                     }>;
                 }>;
@@ -1139,18 +1609,18 @@ export declare const makeGovernedActionTransaction: Effect.Effect<{
                 }>;
             }>;
             readonly cause: import("effect/Schema").TaggedUnion<{
-                readonly agent: import("effect/Schema").TaggedStruct<"agent", {
-                    readonly actor: import("effect/Schema").TaggedStruct<"agent", {
-                        readonly agentId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "AgentId">;
-                    }>;
-                    readonly jobId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "JobId">;
-                }>;
                 readonly human: import("effect/Schema").TaggedStruct<"human", {
                     readonly actor: import("effect/Schema").TaggedStruct<"human", {
                         readonly personId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PersonId">;
                     }>;
                     readonly sessionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "SessionId">;
                 }>;
+                readonly agent: import("effect/Schema").TaggedStruct<"agent", {
+                    readonly actor: import("effect/Schema").TaggedStruct<"agent", {
+                        readonly agentId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "AgentId">;
+                    }>;
+                    readonly jobId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "JobId">;
+                }>;
                 readonly system: import("effect/Schema").TaggedStruct<"system", {
                     readonly component: import("effect/Schema").brand<import("effect/Schema").String, string>;
                 }>;
@@ -1158,8 +1628,8 @@ export declare const makeGovernedActionTransaction: Effect.Effect<{
             readonly occurredAt: import("effect/Schema").DateTimeUtcFromString;
             readonly causationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "DomainEventId">>;
             readonly correlationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, "DomainEventCorrelationId">>;
-        }>;
-        readonly history: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+        }, "Type">;
+        history: import("effect/Schema").Struct.ReadonlySide<{
             readonly commandDigest: import("effect/Schema").brand<import("effect/Schema").String, "GovernedActionCommandDigest">;
             readonly schemaVersion: import("effect/Schema").Literal<1>;
             readonly transitionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionTransitionId">;
@@ -1239,15 +1709,15 @@ export declare const makeGovernedActionTransaction: Effect.Effect<{
                 }>;
                 readonly recordUnknown: import("effect/Schema").TaggedStruct<"recordUnknown", {
                     readonly outcome: import("effect/Schema").TaggedUnion<{
-                        readonly manual: import("effect/Schema").TaggedStruct<"manual", {
+                        readonly reconcilable: import("effect/Schema").TaggedStruct<"reconcilable", {
+                            readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
                             readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
                             readonly safeSummary: import("effect/Schema").String;
-                            readonly reason: import("effect/Schema").Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
                         }>;
-                        readonly reconcilable: import("effect/Schema").TaggedStruct<"reconcilable", {
-                            readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        readonly manual: import("effect/Schema").TaggedStruct<"manual", {
                             readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
                             readonly safeSummary: import("effect/Schema").String;
+                            readonly reason: import("effect/Schema").Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
                         }>;
                     }>;
                 }>;
@@ -1275,18 +1745,18 @@ export declare const makeGovernedActionTransaction: Effect.Effect<{
                 }>;
             }>;
             readonly cause: import("effect/Schema").TaggedUnion<{
-                readonly agent: import("effect/Schema").TaggedStruct<"agent", {
-                    readonly actor: import("effect/Schema").TaggedStruct<"agent", {
-                        readonly agentId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "AgentId">;
-                    }>;
-                    readonly jobId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "JobId">;
-                }>;
                 readonly human: import("effect/Schema").TaggedStruct<"human", {
                     readonly actor: import("effect/Schema").TaggedStruct<"human", {
                         readonly personId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PersonId">;
                     }>;
                     readonly sessionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "SessionId">;
                 }>;
+                readonly agent: import("effect/Schema").TaggedStruct<"agent", {
+                    readonly actor: import("effect/Schema").TaggedStruct<"agent", {
+                        readonly agentId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "AgentId">;
+                    }>;
+                    readonly jobId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "JobId">;
+                }>;
                 readonly system: import("effect/Schema").TaggedStruct<"system", {
                     readonly component: import("effect/Schema").brand<import("effect/Schema").String, string>;
                 }>;
@@ -1294,8 +1764,8 @@ export declare const makeGovernedActionTransaction: Effect.Effect<{
             readonly occurredAt: import("effect/Schema").DateTimeUtcFromString;
             readonly causationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "DomainEventId">>;
             readonly correlationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, "DomainEventCorrelationId">>;
-        }>>;
-        readonly authorization: import("effect/Schema").NullOr<import("effect/Schema").Struct<{
+        }, "Type">[];
+        authorization: import("effect/Schema").Struct.ReadonlySide<{
             readonly schemaVersion: import("effect/Schema").Literal<1>;
             readonly authorizationId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionAuthorizationId">;
             readonly actionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionId">;
@@ -1319,8 +1789,8 @@ export declare const makeGovernedActionTransaction: Effect.Effect<{
             readonly requiredPermission: import("effect/Schema").Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
             readonly authorizedAt: import("effect/Schema").DateTimeUtcFromString;
             readonly expiresAt: import("effect/Schema").DateTimeUtcFromString;
-        }>>;
-        readonly policyEvaluation: import("effect/Schema").NullOr<import("effect/Schema").Struct<{
+        }, "Type"> | null;
+        policyEvaluation: import("effect/Schema").Struct.ReadonlySide<{
             readonly schemaVersion: import("effect/Schema").Literal<1>;
             readonly actionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionId">;
             readonly workspaceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "WorkspaceId">;
@@ -1335,8 +1805,8 @@ export declare const makeGovernedActionTransaction: Effect.Effect<{
             readonly expectedRevision: import("effect/Schema").brand<import("effect/Schema").String, "Revision">;
             readonly decision: import("effect/Schema").Literals<readonly ["allowed", "denied"]>;
             readonly evaluatedAt: import("effect/Schema").DateTimeUtcFromString;
-        }>>;
-        readonly attempt: import("effect/Schema").NullOr<import("effect/Schema").Struct<{
+        }, "Type"> | null;
+        attempt: import("effect/Schema").Struct.ReadonlySide<{
             readonly schemaVersion: import("effect/Schema").Literal<1>;
             readonly attemptId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionAttemptId">;
             readonly authorizationId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "GovernedActionAuthorizationId">;
@@ -1353,8 +1823,8 @@ export declare const makeGovernedActionTransaction: Effect.Effect<{
                 readonly checkedAt: import("effect/Schema").DateTimeUtcFromString;
             }>;
             readonly startedAt: import("effect/Schema").DateTimeUtcFromString;
-        }>>;
-    }, "Type">[], import("../../errors.js").RecordNotFoundError | PersistenceOperationError | PersistedRecordError | import("effect/unstable/sql/SqlError").SqlError | MalformedGovernedActionRecord, never>;
+        }, "Type"> | null;
+    }[], import("../../errors.js").RecordNotFoundError | PersistenceOperationError | PersistedRecordError | import("effect/unstable/sql/SqlError").SqlError | MalformedGovernedActionRecord, never>;
     transact: <Value, Failure, Requirements>(operation: string, effect: Effect.Effect<Value, Failure, Requirements>) => Effect.Effect<Value, Failure | PersistedRecordError | PersistenceOperationError | QuarantineWriteError, Requirements>;
 }, never, Crypto.Crypto | Database | QuarantineRepository>;
 //# sourceMappingURL=transaction.d.ts.map