@knpkv/control-center 0.3.0 → 0.5.0

package/dist/server/server/persistence/repositories/governedActionRepository.d.ts

@@ -14,33 +14,14 @@ declare const makeGovernedActionRepository: Effect.Effect<{
         readonly transition: import("../../../index.ts").GovernedActionTransitionV1;
     }, import("../errors.ts").PersistenceOperationError | import("../errors.ts").PersistedRecordError | import("../errors.ts").QuarantineWriteError | GovernedActionInputError | import("./governed-action/quarantine.ts").MalformedGovernedActionRecord, never>;
     read: (input: unknown) => Effect.Effect<{
-        envelope: Schema.Struct.ReadonlySide<{
-            readonly envelopeDigest: Schema.brand<Schema.String, string>;
-            readonly schemaVersion: Schema.Literal<1>;
-            readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
-            readonly idempotencyKey: Schema.brand<Schema.String, "GovernedActionIdempotencyKey">;
-            readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
-            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
-            readonly pluginConnectionRevision: Schema.brand<Schema.Int, "GovernedActionPluginConnectionRevision">;
-            readonly pluginConnectionAuthorityDigest: Schema.brand<Schema.String, string>;
-            readonly pluginId: Schema.brand<Schema.String, string>;
-            readonly pluginContractVersion: Schema.Struct<{
-                readonly major: Schema.Int;
-                readonly minor: Schema.Int;
-                readonly patch: Schema.Int;
-            }>;
-            readonly pluginAdapterVersion: Schema.Struct<{
-                readonly major: Schema.Int;
-                readonly minor: Schema.Int;
-                readonly patch: Schema.Int;
-            }>;
-            readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
-            readonly capability: Schema.Struct<{
-                readonly capabilityId: Schema.Literal<"action.execute">;
-                readonly version: Schema.Int;
-            }>;
-            readonly targetEntityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
-            readonly proposal: Schema.Struct<{
+        envelope: {
+            readonly providerId: "codecommit" | "codepipeline" | "jira" | "confluence" | "clockify";
+            readonly pluginConnectionId: string & import("effect/Brand").Brand<"PluginConnectionId">;
+            readonly workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">;
+            readonly schemaVersion: 1;
+            readonly causationId: (string & import("effect/Brand").Brand<"DomainEventId">) | null;
+            readonly correlationId: (string & import("effect/Brand").Brand<"DomainEventCorrelationId">) | null;
+            readonly proposal: Schema.Struct.ReadonlySide<{
                 readonly proposalKey: Schema.brand<Schema.String, string>;
                 readonly capabilityVersion: Schema.Int;
                 readonly request: Schema.Struct<{
@@ -60,8 +41,35 @@ declare const makeGovernedActionRepository: Effect.Effect<{
                     readonly summary: Schema.String;
                 }>;
                 readonly proposedAt: Schema.DateTimeUtcFromString;
-            }>;
-            readonly evidence: Schema.$Array<Schema.Struct<{
+            }, "Type">;
+            readonly idempotencyKey: string & import("effect/Brand").Brand<"GovernedActionIdempotencyKey">;
+            readonly pluginId: string & import("effect/Brand").Brand<string>;
+            readonly actionId: string & import("effect/Brand").Brand<"GovernedActionId">;
+            readonly policy: Schema.Struct.ReadonlySide<{
+                readonly policyId: Schema.brand<Schema.String, string>;
+                readonly policyVersion: Schema.Int;
+                readonly policyDigest: Schema.brand<Schema.String, string>;
+                readonly requiredPermission: Schema.Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
+            }, "Type">;
+            readonly evidenceSetDigest: string & import("effect/Brand").Brand<string>;
+            readonly pluginConnectionRevision: number & import("effect/Brand").Brand<"GovernedActionPluginConnectionRevision">;
+            readonly pluginConnectionAuthorityDigest: string & import("effect/Brand").Brand<string>;
+            readonly pluginContractVersion: Schema.Struct.ReadonlySide<{
+                readonly major: Schema.Int;
+                readonly minor: Schema.Int;
+                readonly patch: Schema.Int;
+            }, "Type">;
+            readonly pluginAdapterVersion: Schema.Struct.ReadonlySide<{
+                readonly major: Schema.Int;
+                readonly minor: Schema.Int;
+                readonly patch: Schema.Int;
+            }, "Type">;
+            readonly capability: Schema.Struct.ReadonlySide<{
+                readonly capabilityId: Schema.Literal<"action.execute">;
+                readonly version: Schema.Int;
+            }, "Type">;
+            readonly targetEntityId: string & import("effect/Brand").Brand<"EntityId">;
+            readonly evidence: readonly Schema.Struct.ReadonlySide<{
                 readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
                 readonly evidenceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">;
                 readonly evidenceClaimIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceClaimId">>;
@@ -71,33 +79,485 @@ declare const makeGovernedActionRepository: Effect.Effect<{
                 readonly evaluatedAt: Schema.DateTimeUtcFromString;
                 readonly source: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
                 readonly validity: Schema.Literals<readonly ["valid", "expired"]>;
-            }>>;
-            readonly evidenceSetDigest: Schema.brand<Schema.String, string>;
-            readonly policy: Schema.Struct<{
-                readonly policyId: Schema.brand<Schema.String, string>;
-                readonly policyVersion: Schema.Int;
-                readonly policyDigest: Schema.brand<Schema.String, string>;
-                readonly requiredPermission: Schema.Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
+            }, "Type">[];
+            readonly origin: Schema.Struct.ReadonlySide<{
+                readonly _tag: Schema.tag<"human">;
+                readonly actor: Schema.TaggedStruct<"human", {
+                    readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                }>;
+                readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+            }, "Type"> | Schema.Struct.ReadonlySide<{
+                readonly _tag: Schema.tag<"agent">;
+                readonly actor: Schema.TaggedStruct<"agent", {
+                    readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                }>;
+                readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+                readonly initiatingSessionId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">>;
+            }, "Type">;
+            readonly proposalExpiresAt: import("effect/DateTime").Utc;
+            readonly envelopeDigest: string & import("effect/Brand").Brand<string>;
+            readonly releasePublication?: {
+                readonly releaseId: string & import("effect/Brand").Brand<"ReleaseId">;
+                readonly sourceRevisionDigest: string & import("effect/Brand").Brand<string>;
+                readonly sourceRevisionCount: number;
+                readonly predecessorPublicationActionId?: (string & import("effect/Brand").Brand<"GovernedActionId">) | null;
+                readonly templateSourceEntityId?: string & import("effect/Brand").Brand<"EntityId">;
+            };
+        };
+        head: Schema.Struct.ReadonlySide<{
+            readonly state: Schema.Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>;
+            readonly lineage: Schema.TaggedUnion<{
+                readonly accepted: Schema.TaggedStruct<"accepted", {
+                    readonly receipt: Schema.Struct<{
+                        readonly status: Schema.Literal<"accepted">;
+                        readonly reconciliationKey: Schema.brand<Schema.String, string>;
+                        readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        readonly safeSummary: Schema.String;
+                        readonly observedAt: Schema.DateTimeUtcFromString;
+                    }>;
+                }>;
+                readonly reconcilable: Schema.TaggedStruct<"reconcilable", {
+                    readonly providerOperationId: Schema.NullOr<Schema.brand<Schema.String, string>>;
+                    readonly reconciliationKey: Schema.brand<Schema.String, string>;
+                }>;
+                readonly manual: Schema.TaggedStruct<"manual", {
+                    readonly providerOperationId: Schema.NullOr<Schema.brand<Schema.String, string>>;
+                }>;
+                readonly none: Schema.TaggedStruct<"none", {}>;
+                readonly terminal: Schema.TaggedStruct<"terminal", {
+                    readonly receipt: Schema.Struct<{
+                        readonly observationBasis: Schema.optionalKey<Schema.Literal<"authorization">>;
+                        readonly status: Schema.Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        readonly safeSummary: Schema.String;
+                        readonly observedAt: Schema.DateTimeUtcFromString;
+                    }>;
+                }>;
             }>;
-            readonly origin: Schema.TaggedUnion<{
+        }, "Type">;
+        headTransition: Schema.Struct.ReadonlySide<{
+            readonly commandDigest: Schema.brand<Schema.String, "GovernedActionCommandDigest">;
+            readonly schemaVersion: Schema.Literal<1>;
+            readonly transitionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionTransitionId">;
+            readonly previousTransitionId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionTransitionId">>;
+            readonly commandId: Schema.brand<Schema.String, string>;
+            readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
+            readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            readonly sequence: Schema.Int;
+            readonly fromState: Schema.NullOr<Schema.Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>>;
+            readonly toState: Schema.Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>;
+            readonly actionEnvelopeDigest: Schema.brand<Schema.String, string>;
+            readonly command: Schema.TaggedUnion<{
+                readonly propose: Schema.TaggedStruct<"propose", {}>;
+                readonly authorize: Schema.TaggedStruct<"authorize", {
+                    readonly authorizationId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionAuthorizationId">;
+                }>;
+                readonly deny: Schema.TaggedStruct<"deny", {
+                    readonly reason: Schema.Literals<readonly ["revision-changed", "evidence-stale", "evidence-invalid", "policy-denied", "session-invalid", "capability-changed", "plugin-unavailable", "preflight-blocked"]>;
+                    readonly safeSummary: Schema.String;
+                }>;
+                readonly expire: Schema.TaggedStruct<"expire", {
+                    readonly reason: Schema.Literals<readonly ["proposal-expired", "authorization-expired"]>;
+                }>;
+                readonly cancel: Schema.TaggedStruct<"cancel", {
+                    readonly safeSummary: Schema.String;
+                }>;
+                readonly start: Schema.TaggedStruct<"start", {
+                    readonly attemptId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionAttemptId">;
+                }>;
+                readonly requestCancellation: Schema.TaggedStruct<"requestCancellation", {
+                    readonly safeSummary: Schema.String;
+                }>;
+                readonly recordAccepted: Schema.TaggedStruct<"recordAccepted", {
+                    readonly receipt: Schema.Struct<{
+                        readonly status: Schema.Literal<"accepted">;
+                        readonly reconciliationKey: Schema.brand<Schema.String, string>;
+                        readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        readonly safeSummary: Schema.String;
+                        readonly observedAt: Schema.DateTimeUtcFromString;
+                    }>;
+                }>;
+                readonly recordSucceeded: Schema.TaggedStruct<"recordSucceeded", {
+                    readonly receipt: Schema.Struct<{
+                        readonly observationBasis: Schema.optionalKey<Schema.Literal<"authorization">>;
+                        readonly status: Schema.Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        readonly safeSummary: Schema.String;
+                        readonly observedAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly source: Schema.TaggedUnion<{
+                        readonly direct: Schema.TaggedStruct<"direct", {}>;
+                        readonly providerOperation: Schema.TaggedStruct<"providerOperation", {
+                            readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        }>;
+                        readonly reconciliation: Schema.TaggedStruct<"reconciliation", {
+                            readonly reconciliationKey: Schema.NullOr<Schema.brand<Schema.String, string>>;
+                        }>;
+                    }>;
+                }>;
+                readonly recordFailed: Schema.TaggedStruct<"recordFailed", {
+                    readonly receipt: Schema.Struct<{
+                        readonly observationBasis: Schema.optionalKey<Schema.Literal<"authorization">>;
+                        readonly status: Schema.Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        readonly safeSummary: Schema.String;
+                        readonly observedAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly source: Schema.TaggedUnion<{
+                        readonly direct: Schema.TaggedStruct<"direct", {}>;
+                        readonly providerOperation: Schema.TaggedStruct<"providerOperation", {
+                            readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        }>;
+                        readonly reconciliation: Schema.TaggedStruct<"reconciliation", {
+                            readonly reconciliationKey: Schema.NullOr<Schema.brand<Schema.String, string>>;
+                        }>;
+                    }>;
+                }>;
+                readonly recordUnknown: Schema.TaggedStruct<"recordUnknown", {
+                    readonly outcome: Schema.TaggedUnion<{
+                        readonly reconcilable: Schema.TaggedStruct<"reconcilable", {
+                            readonly reconciliationKey: Schema.brand<Schema.String, string>;
+                            readonly observedAt: Schema.DateTimeUtcFromString;
+                            readonly safeSummary: Schema.String;
+                        }>;
+                        readonly manual: Schema.TaggedStruct<"manual", {
+                            readonly observedAt: Schema.DateTimeUtcFromString;
+                            readonly safeSummary: Schema.String;
+                            readonly reason: Schema.Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
+                        }>;
+                    }>;
+                }>;
+                readonly recordCancelled: Schema.TaggedStruct<"recordCancelled", {
+                    readonly receipt: Schema.Struct<{
+                        readonly observationBasis: Schema.optionalKey<Schema.Literal<"authorization">>;
+                        readonly status: Schema.Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        readonly safeSummary: Schema.String;
+                        readonly observedAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly source: Schema.TaggedUnion<{
+                        readonly direct: Schema.TaggedStruct<"direct", {}>;
+                        readonly providerOperation: Schema.TaggedStruct<"providerOperation", {
+                            readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        }>;
+                        readonly reconciliation: Schema.TaggedStruct<"reconciliation", {
+                            readonly reconciliationKey: Schema.NullOr<Schema.brand<Schema.String, string>>;
+                        }>;
+                    }>;
+                }>;
+                readonly reconciliationPending: Schema.TaggedStruct<"reconciliationPending", {
+                    readonly checkedAt: Schema.DateTimeUtcFromString;
+                    readonly reconciliationKey: Schema.NullOr<Schema.brand<Schema.String, string>>;
+                }>;
+            }>;
+            readonly cause: Schema.TaggedUnion<{
+                readonly human: Schema.TaggedStruct<"human", {
+                    readonly actor: Schema.TaggedStruct<"human", {
+                        readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                    }>;
+                    readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+                }>;
                 readonly agent: Schema.TaggedStruct<"agent", {
                     readonly actor: Schema.TaggedStruct<"agent", {
                         readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
                     }>;
                     readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
-                    readonly initiatingSessionId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">>;
                 }>;
+                readonly system: Schema.TaggedStruct<"system", {
+                    readonly component: Schema.brand<Schema.String, string>;
+                }>;
+            }>;
+            readonly occurredAt: Schema.DateTimeUtcFromString;
+            readonly causationId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "DomainEventId">>;
+            readonly correlationId: Schema.NullOr<Schema.brand<Schema.String, "DomainEventCorrelationId">>;
+        }, "Type">;
+        history: Schema.Struct.ReadonlySide<{
+            readonly commandDigest: Schema.brand<Schema.String, "GovernedActionCommandDigest">;
+            readonly schemaVersion: Schema.Literal<1>;
+            readonly transitionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionTransitionId">;
+            readonly previousTransitionId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionTransitionId">>;
+            readonly commandId: Schema.brand<Schema.String, string>;
+            readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
+            readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            readonly sequence: Schema.Int;
+            readonly fromState: Schema.NullOr<Schema.Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>>;
+            readonly toState: Schema.Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>;
+            readonly actionEnvelopeDigest: Schema.brand<Schema.String, string>;
+            readonly command: Schema.TaggedUnion<{
+                readonly propose: Schema.TaggedStruct<"propose", {}>;
+                readonly authorize: Schema.TaggedStruct<"authorize", {
+                    readonly authorizationId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionAuthorizationId">;
+                }>;
+                readonly deny: Schema.TaggedStruct<"deny", {
+                    readonly reason: Schema.Literals<readonly ["revision-changed", "evidence-stale", "evidence-invalid", "policy-denied", "session-invalid", "capability-changed", "plugin-unavailable", "preflight-blocked"]>;
+                    readonly safeSummary: Schema.String;
+                }>;
+                readonly expire: Schema.TaggedStruct<"expire", {
+                    readonly reason: Schema.Literals<readonly ["proposal-expired", "authorization-expired"]>;
+                }>;
+                readonly cancel: Schema.TaggedStruct<"cancel", {
+                    readonly safeSummary: Schema.String;
+                }>;
+                readonly start: Schema.TaggedStruct<"start", {
+                    readonly attemptId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionAttemptId">;
+                }>;
+                readonly requestCancellation: Schema.TaggedStruct<"requestCancellation", {
+                    readonly safeSummary: Schema.String;
+                }>;
+                readonly recordAccepted: Schema.TaggedStruct<"recordAccepted", {
+                    readonly receipt: Schema.Struct<{
+                        readonly status: Schema.Literal<"accepted">;
+                        readonly reconciliationKey: Schema.brand<Schema.String, string>;
+                        readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        readonly safeSummary: Schema.String;
+                        readonly observedAt: Schema.DateTimeUtcFromString;
+                    }>;
+                }>;
+                readonly recordSucceeded: Schema.TaggedStruct<"recordSucceeded", {
+                    readonly receipt: Schema.Struct<{
+                        readonly observationBasis: Schema.optionalKey<Schema.Literal<"authorization">>;
+                        readonly status: Schema.Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        readonly safeSummary: Schema.String;
+                        readonly observedAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly source: Schema.TaggedUnion<{
+                        readonly direct: Schema.TaggedStruct<"direct", {}>;
+                        readonly providerOperation: Schema.TaggedStruct<"providerOperation", {
+                            readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        }>;
+                        readonly reconciliation: Schema.TaggedStruct<"reconciliation", {
+                            readonly reconciliationKey: Schema.NullOr<Schema.brand<Schema.String, string>>;
+                        }>;
+                    }>;
+                }>;
+                readonly recordFailed: Schema.TaggedStruct<"recordFailed", {
+                    readonly receipt: Schema.Struct<{
+                        readonly observationBasis: Schema.optionalKey<Schema.Literal<"authorization">>;
+                        readonly status: Schema.Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        readonly safeSummary: Schema.String;
+                        readonly observedAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly source: Schema.TaggedUnion<{
+                        readonly direct: Schema.TaggedStruct<"direct", {}>;
+                        readonly providerOperation: Schema.TaggedStruct<"providerOperation", {
+                            readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        }>;
+                        readonly reconciliation: Schema.TaggedStruct<"reconciliation", {
+                            readonly reconciliationKey: Schema.NullOr<Schema.brand<Schema.String, string>>;
+                        }>;
+                    }>;
+                }>;
+                readonly recordUnknown: Schema.TaggedStruct<"recordUnknown", {
+                    readonly outcome: Schema.TaggedUnion<{
+                        readonly reconcilable: Schema.TaggedStruct<"reconcilable", {
+                            readonly reconciliationKey: Schema.brand<Schema.String, string>;
+                            readonly observedAt: Schema.DateTimeUtcFromString;
+                            readonly safeSummary: Schema.String;
+                        }>;
+                        readonly manual: Schema.TaggedStruct<"manual", {
+                            readonly observedAt: Schema.DateTimeUtcFromString;
+                            readonly safeSummary: Schema.String;
+                            readonly reason: Schema.Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
+                        }>;
+                    }>;
+                }>;
+                readonly recordCancelled: Schema.TaggedStruct<"recordCancelled", {
+                    readonly receipt: Schema.Struct<{
+                        readonly observationBasis: Schema.optionalKey<Schema.Literal<"authorization">>;
+                        readonly status: Schema.Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        readonly safeSummary: Schema.String;
+                        readonly observedAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly source: Schema.TaggedUnion<{
+                        readonly direct: Schema.TaggedStruct<"direct", {}>;
+                        readonly providerOperation: Schema.TaggedStruct<"providerOperation", {
+                            readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        }>;
+                        readonly reconciliation: Schema.TaggedStruct<"reconciliation", {
+                            readonly reconciliationKey: Schema.NullOr<Schema.brand<Schema.String, string>>;
+                        }>;
+                    }>;
+                }>;
+                readonly reconciliationPending: Schema.TaggedStruct<"reconciliationPending", {
+                    readonly checkedAt: Schema.DateTimeUtcFromString;
+                    readonly reconciliationKey: Schema.NullOr<Schema.brand<Schema.String, string>>;
+                }>;
+            }>;
+            readonly cause: Schema.TaggedUnion<{
                 readonly human: Schema.TaggedStruct<"human", {
                     readonly actor: Schema.TaggedStruct<"human", {
                         readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
                     }>;
                     readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
                 }>;
+                readonly agent: Schema.TaggedStruct<"agent", {
+                    readonly actor: Schema.TaggedStruct<"agent", {
+                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                    }>;
+                    readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+                }>;
+                readonly system: Schema.TaggedStruct<"system", {
+                    readonly component: Schema.brand<Schema.String, string>;
+                }>;
             }>;
-            readonly proposalExpiresAt: Schema.DateTimeUtcFromString;
+            readonly occurredAt: Schema.DateTimeUtcFromString;
             readonly causationId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "DomainEventId">>;
             readonly correlationId: Schema.NullOr<Schema.brand<Schema.String, "DomainEventCorrelationId">>;
-        }, "Type">;
+        }, "Type">[];
+        authorization: Schema.Struct.ReadonlySide<{
+            readonly schemaVersion: Schema.Literal<1>;
+            readonly authorizationId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionAuthorizationId">;
+            readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
+            readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+            readonly pluginConnectionRevision: Schema.brand<Schema.Int, "GovernedActionPluginConnectionRevision">;
+            readonly pluginConnectionAuthorityDigest: Schema.brand<Schema.String, string>;
+            readonly actionEnvelopeDigest: Schema.brand<Schema.String, string>;
+            readonly idempotencyKey: Schema.brand<Schema.String, "GovernedActionIdempotencyKey">;
+            readonly payloadDigest: Schema.brand<Schema.String, "PluginActionPayloadDigest">;
+            readonly evidenceSetDigest: Schema.brand<Schema.String, string>;
+            readonly policyDigest: Schema.brand<Schema.String, string>;
+            readonly expectedRevision: Schema.brand<Schema.String, "Revision">;
+            readonly capabilityVersion: Schema.Int;
+            readonly actor: Schema.TaggedStruct<"human", {
+                readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+            }>;
+            readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+            readonly sessionPermission: Schema.Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
+            readonly sessionExpiresAt: Schema.DateTimeUtcFromString;
+            readonly requiredPermission: Schema.Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
+            readonly authorizedAt: Schema.DateTimeUtcFromString;
+            readonly expiresAt: Schema.DateTimeUtcFromString;
+        }, "Type"> | null;
+        policyEvaluation: Schema.Struct.ReadonlySide<{
+            readonly schemaVersion: Schema.Literal<1>;
+            readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
+            readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            readonly policy: Schema.Struct<{
+                readonly policyId: Schema.brand<Schema.String, string>;
+                readonly policyVersion: Schema.Int;
+                readonly policyDigest: Schema.brand<Schema.String, string>;
+                readonly requiredPermission: Schema.Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
+            }>;
+            readonly payloadDigest: Schema.brand<Schema.String, "PluginActionPayloadDigest">;
+            readonly evidenceSetDigest: Schema.brand<Schema.String, string>;
+            readonly expectedRevision: Schema.brand<Schema.String, "Revision">;
+            readonly decision: Schema.Literals<readonly ["allowed", "denied"]>;
+            readonly evaluatedAt: Schema.DateTimeUtcFromString;
+        }, "Type"> | null;
+        attempt: Schema.Struct.ReadonlySide<{
+            readonly schemaVersion: Schema.Literal<1>;
+            readonly attemptId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionAttemptId">;
+            readonly authorizationId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionAuthorizationId">;
+            readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
+            readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+            readonly idempotencyKey: Schema.brand<Schema.String, "GovernedActionIdempotencyKey">;
+            readonly attemptNumber: Schema.Literal<1>;
+            readonly actionEnvelopeDigest: Schema.brand<Schema.String, string>;
+            readonly expectedRevision: Schema.brand<Schema.String, "Revision">;
+            readonly policyEvaluationDigest: Schema.brand<Schema.String, string>;
+            readonly preflight: Schema.TaggedStruct<"ready", {
+                readonly checkedRevision: Schema.brand<Schema.String, "Revision">;
+                readonly checkedAt: Schema.DateTimeUtcFromString;
+            }>;
+            readonly startedAt: Schema.DateTimeUtcFromString;
+        }, "Type"> | null;
+    }, import("../errors.ts").RecordNotFoundError | import("../errors.ts").PersistenceOperationError | import("../errors.ts").PersistedRecordError | import("../errors.ts").QuarantineWriteError | import("effect/unstable/sql/SqlError").SqlError | GovernedActionInputError | import("./governed-action/quarantine.ts").MalformedGovernedActionRecord, never>;
+    readByIdempotencyKey: (input: unknown) => Effect.Effect<{
+        envelope: {
+            readonly providerId: "codecommit" | "codepipeline" | "jira" | "confluence" | "clockify";
+            readonly pluginConnectionId: string & import("effect/Brand").Brand<"PluginConnectionId">;
+            readonly workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">;
+            readonly schemaVersion: 1;
+            readonly causationId: (string & import("effect/Brand").Brand<"DomainEventId">) | null;
+            readonly correlationId: (string & import("effect/Brand").Brand<"DomainEventCorrelationId">) | null;
+            readonly proposal: Schema.Struct.ReadonlySide<{
+                readonly proposalKey: Schema.brand<Schema.String, string>;
+                readonly capabilityVersion: Schema.Int;
+                readonly request: Schema.Struct<{
+                    readonly actionKind: Schema.brand<Schema.String, string>;
+                    readonly target: Schema.Struct<{
+                        entityType: Schema.brand<Schema.String, string>;
+                        vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+                    }>;
+                    readonly expectedRevision: Schema.brand<Schema.String, "Revision">;
+                    readonly payload: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.String, string>>;
+                }>;
+                readonly payloadDigest: Schema.brand<Schema.String, "PluginActionPayloadDigest">;
+                readonly summary: Schema.String;
+                readonly impact: Schema.Struct<{
+                    readonly level: Schema.Literals<readonly ["low", "medium", "high", "critical"]>;
+                    readonly summary: Schema.String;
+                }>;
+                readonly proposedAt: Schema.DateTimeUtcFromString;
+            }, "Type">;
+            readonly idempotencyKey: string & import("effect/Brand").Brand<"GovernedActionIdempotencyKey">;
+            readonly pluginId: string & import("effect/Brand").Brand<string>;
+            readonly actionId: string & import("effect/Brand").Brand<"GovernedActionId">;
+            readonly policy: Schema.Struct.ReadonlySide<{
+                readonly policyId: Schema.brand<Schema.String, string>;
+                readonly policyVersion: Schema.Int;
+                readonly policyDigest: Schema.brand<Schema.String, string>;
+                readonly requiredPermission: Schema.Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
+            }, "Type">;
+            readonly evidenceSetDigest: string & import("effect/Brand").Brand<string>;
+            readonly pluginConnectionRevision: number & import("effect/Brand").Brand<"GovernedActionPluginConnectionRevision">;
+            readonly pluginConnectionAuthorityDigest: string & import("effect/Brand").Brand<string>;
+            readonly pluginContractVersion: Schema.Struct.ReadonlySide<{
+                readonly major: Schema.Int;
+                readonly minor: Schema.Int;
+                readonly patch: Schema.Int;
+            }, "Type">;
+            readonly pluginAdapterVersion: Schema.Struct.ReadonlySide<{
+                readonly major: Schema.Int;
+                readonly minor: Schema.Int;
+                readonly patch: Schema.Int;
+            }, "Type">;
+            readonly capability: Schema.Struct.ReadonlySide<{
+                readonly capabilityId: Schema.Literal<"action.execute">;
+                readonly version: Schema.Int;
+            }, "Type">;
+            readonly targetEntityId: string & import("effect/Brand").Brand<"EntityId">;
+            readonly evidence: readonly Schema.Struct.ReadonlySide<{
+                readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                readonly evidenceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">;
+                readonly evidenceClaimIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceClaimId">>;
+                readonly observedAt: Schema.DateTimeUtcFromString;
+                readonly validUntil: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                readonly currentUntil: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                readonly evaluatedAt: Schema.DateTimeUtcFromString;
+                readonly source: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                readonly validity: Schema.Literals<readonly ["valid", "expired"]>;
+            }, "Type">[];
+            readonly origin: Schema.Struct.ReadonlySide<{
+                readonly _tag: Schema.tag<"human">;
+                readonly actor: Schema.TaggedStruct<"human", {
+                    readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                }>;
+                readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+            }, "Type"> | Schema.Struct.ReadonlySide<{
+                readonly _tag: Schema.tag<"agent">;
+                readonly actor: Schema.TaggedStruct<"agent", {
+                    readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                }>;
+                readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+                readonly initiatingSessionId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">>;
+            }, "Type">;
+            readonly proposalExpiresAt: import("effect/DateTime").Utc;
+            readonly envelopeDigest: string & import("effect/Brand").Brand<string>;
+            readonly releasePublication?: {
+                readonly releaseId: string & import("effect/Brand").Brand<"ReleaseId">;
+                readonly sourceRevisionDigest: string & import("effect/Brand").Brand<string>;
+                readonly sourceRevisionCount: number;
+                readonly predecessorPublicationActionId?: (string & import("effect/Brand").Brand<"GovernedActionId">) | null;
+                readonly templateSourceEntityId?: string & import("effect/Brand").Brand<"EntityId">;
+            };
+        };
         head: Schema.Struct.ReadonlySide<{
             readonly state: Schema.Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>;
             readonly lineage: Schema.TaggedUnion<{
@@ -110,14 +570,14 @@ declare const makeGovernedActionRepository: Effect.Effect<{
                         readonly observedAt: Schema.DateTimeUtcFromString;
                     }>;
                 }>;
-                readonly none: Schema.TaggedStruct<"none", {}>;
-                readonly manual: Schema.TaggedStruct<"manual", {
-                    readonly providerOperationId: Schema.NullOr<Schema.brand<Schema.String, string>>;
-                }>;
                 readonly reconcilable: Schema.TaggedStruct<"reconcilable", {
                     readonly providerOperationId: Schema.NullOr<Schema.brand<Schema.String, string>>;
                     readonly reconciliationKey: Schema.brand<Schema.String, string>;
                 }>;
+                readonly manual: Schema.TaggedStruct<"manual", {
+                    readonly providerOperationId: Schema.NullOr<Schema.brand<Schema.String, string>>;
+                }>;
+                readonly none: Schema.TaggedStruct<"none", {}>;
                 readonly terminal: Schema.TaggedStruct<"terminal", {
                     readonly receipt: Schema.Struct<{
                         readonly observationBasis: Schema.optionalKey<Schema.Literal<"authorization">>;
@@ -209,15 +669,15 @@ declare const makeGovernedActionRepository: Effect.Effect<{
                 }>;
                 readonly recordUnknown: Schema.TaggedStruct<"recordUnknown", {
                     readonly outcome: Schema.TaggedUnion<{
-                        readonly manual: Schema.TaggedStruct<"manual", {
+                        readonly reconcilable: Schema.TaggedStruct<"reconcilable", {
+                            readonly reconciliationKey: Schema.brand<Schema.String, string>;
                             readonly observedAt: Schema.DateTimeUtcFromString;
                             readonly safeSummary: Schema.String;
-                            readonly reason: Schema.Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
                         }>;
-                        readonly reconcilable: Schema.TaggedStruct<"reconcilable", {
-                            readonly reconciliationKey: Schema.brand<Schema.String, string>;
+                        readonly manual: Schema.TaggedStruct<"manual", {
                             readonly observedAt: Schema.DateTimeUtcFromString;
                             readonly safeSummary: Schema.String;
+                            readonly reason: Schema.Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
                         }>;
                     }>;
                 }>;
@@ -245,17 +705,17 @@ declare const makeGovernedActionRepository: Effect.Effect<{
                 }>;
             }>;
             readonly cause: Schema.TaggedUnion<{
-                readonly agent: Schema.TaggedStruct<"agent", {
-                    readonly actor: Schema.TaggedStruct<"agent", {
-                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
-                    }>;
-                    readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
-                }>;
                 readonly human: Schema.TaggedStruct<"human", {
                     readonly actor: Schema.TaggedStruct<"human", {
                         readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
                     }>;
-                    readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+                    readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+                }>;
+                readonly agent: Schema.TaggedStruct<"agent", {
+                    readonly actor: Schema.TaggedStruct<"agent", {
+                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                    }>;
+                    readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
                 }>;
                 readonly system: Schema.TaggedStruct<"system", {
                     readonly component: Schema.brand<Schema.String, string>;
@@ -345,15 +805,15 @@ declare const makeGovernedActionRepository: Effect.Effect<{
                 }>;
                 readonly recordUnknown: Schema.TaggedStruct<"recordUnknown", {
                     readonly outcome: Schema.TaggedUnion<{
-                        readonly manual: Schema.TaggedStruct<"manual", {
+                        readonly reconcilable: Schema.TaggedStruct<"reconcilable", {
+                            readonly reconciliationKey: Schema.brand<Schema.String, string>;
                             readonly observedAt: Schema.DateTimeUtcFromString;
                             readonly safeSummary: Schema.String;
-                            readonly reason: Schema.Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
                         }>;
-                        readonly reconcilable: Schema.TaggedStruct<"reconcilable", {
-                            readonly reconciliationKey: Schema.brand<Schema.String, string>;
+                        readonly manual: Schema.TaggedStruct<"manual", {
                             readonly observedAt: Schema.DateTimeUtcFromString;
                             readonly safeSummary: Schema.String;
+                            readonly reason: Schema.Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
                         }>;
                     }>;
                 }>;
@@ -381,18 +841,18 @@ declare const makeGovernedActionRepository: Effect.Effect<{
                 }>;
             }>;
             readonly cause: Schema.TaggedUnion<{
-                readonly agent: Schema.TaggedStruct<"agent", {
-                    readonly actor: Schema.TaggedStruct<"agent", {
-                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
-                    }>;
-                    readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
-                }>;
                 readonly human: Schema.TaggedStruct<"human", {
                     readonly actor: Schema.TaggedStruct<"human", {
                         readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
                     }>;
                     readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
                 }>;
+                readonly agent: Schema.TaggedStruct<"agent", {
+                    readonly actor: Schema.TaggedStruct<"agent", {
+                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                    }>;
+                    readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+                }>;
                 readonly system: Schema.TaggedStruct<"system", {
                     readonly component: Schema.brand<Schema.String, string>;
                 }>;
@@ -461,8 +921,8 @@ declare const makeGovernedActionRepository: Effect.Effect<{
             readonly startedAt: Schema.DateTimeUtcFromString;
         }, "Type"> | null;
     }, import("../errors.ts").RecordNotFoundError | import("../errors.ts").PersistenceOperationError | import("../errors.ts").PersistedRecordError | import("../errors.ts").QuarantineWriteError | import("effect/unstable/sql/SqlError").SqlError | GovernedActionInputError | import("./governed-action/quarantine.ts").MalformedGovernedActionRecord, never>;
-    readByIdempotencyKey: (input: unknown) => Effect.Effect<{
-        envelope: Schema.Struct.ReadonlySide<{
+    readLatestTerminalByTarget: (input: unknown) => Effect.Effect<readonly Schema.Struct.ReadonlySide<{
+        readonly envelope: Schema.Struct<{
             readonly envelopeDigest: Schema.brand<Schema.String, string>;
             readonly schemaVersion: Schema.Literal<1>;
             readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
@@ -528,6 +988,12 @@ declare const makeGovernedActionRepository: Effect.Effect<{
                 readonly requiredPermission: Schema.Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
             }>;
             readonly origin: Schema.TaggedUnion<{
+                readonly human: Schema.TaggedStruct<"human", {
+                    readonly actor: Schema.TaggedStruct<"human", {
+                        readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                    }>;
+                    readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+                }>;
                 readonly agent: Schema.TaggedStruct<"agent", {
                     readonly actor: Schema.TaggedStruct<"agent", {
                         readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
@@ -535,18 +1001,19 @@ declare const makeGovernedActionRepository: Effect.Effect<{
                     readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
                     readonly initiatingSessionId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">>;
                 }>;
-                readonly human: Schema.TaggedStruct<"human", {
-                    readonly actor: Schema.TaggedStruct<"human", {
-                        readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
-                    }>;
-                    readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
-                }>;
             }>;
             readonly proposalExpiresAt: Schema.DateTimeUtcFromString;
             readonly causationId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "DomainEventId">>;
             readonly correlationId: Schema.NullOr<Schema.brand<Schema.String, "DomainEventCorrelationId">>;
-        }, "Type">;
-        head: Schema.Struct.ReadonlySide<{
+            readonly releasePublication: Schema.optionalKey<Schema.Struct<{
+                readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                readonly predecessorPublicationActionId: Schema.optionalKey<Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">>>;
+                readonly templateSourceEntityId: Schema.optionalKey<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">>;
+                readonly sourceRevisionDigest: Schema.brand<Schema.String, string>;
+                readonly sourceRevisionCount: Schema.Int;
+            }>>;
+        }>;
+        readonly head: Schema.Struct<{
             readonly state: Schema.Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>;
             readonly lineage: Schema.TaggedUnion<{
                 readonly accepted: Schema.TaggedStruct<"accepted", {
@@ -558,14 +1025,14 @@ declare const makeGovernedActionRepository: Effect.Effect<{
                         readonly observedAt: Schema.DateTimeUtcFromString;
                     }>;
                 }>;
-                readonly none: Schema.TaggedStruct<"none", {}>;
-                readonly manual: Schema.TaggedStruct<"manual", {
-                    readonly providerOperationId: Schema.NullOr<Schema.brand<Schema.String, string>>;
-                }>;
                 readonly reconcilable: Schema.TaggedStruct<"reconcilable", {
                     readonly providerOperationId: Schema.NullOr<Schema.brand<Schema.String, string>>;
                     readonly reconciliationKey: Schema.brand<Schema.String, string>;
                 }>;
+                readonly manual: Schema.TaggedStruct<"manual", {
+                    readonly providerOperationId: Schema.NullOr<Schema.brand<Schema.String, string>>;
+                }>;
+                readonly none: Schema.TaggedStruct<"none", {}>;
                 readonly terminal: Schema.TaggedStruct<"terminal", {
                     readonly receipt: Schema.Struct<{
                         readonly observationBasis: Schema.optionalKey<Schema.Literal<"authorization">>;
@@ -576,8 +1043,8 @@ declare const makeGovernedActionRepository: Effect.Effect<{
                     }>;
                 }>;
             }>;
-        }, "Type">;
-        headTransition: Schema.Struct.ReadonlySide<{
+        }>;
+        readonly headTransition: Schema.Struct<{
             readonly commandDigest: Schema.brand<Schema.String, "GovernedActionCommandDigest">;
             readonly schemaVersion: Schema.Literal<1>;
             readonly transitionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionTransitionId">;
@@ -657,15 +1124,15 @@ declare const makeGovernedActionRepository: Effect.Effect<{
                 }>;
                 readonly recordUnknown: Schema.TaggedStruct<"recordUnknown", {
                     readonly outcome: Schema.TaggedUnion<{
-                        readonly manual: Schema.TaggedStruct<"manual", {
+                        readonly reconcilable: Schema.TaggedStruct<"reconcilable", {
+                            readonly reconciliationKey: Schema.brand<Schema.String, string>;
                             readonly observedAt: Schema.DateTimeUtcFromString;
                             readonly safeSummary: Schema.String;
-                            readonly reason: Schema.Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
                         }>;
-                        readonly reconcilable: Schema.TaggedStruct<"reconcilable", {
-                            readonly reconciliationKey: Schema.brand<Schema.String, string>;
+                        readonly manual: Schema.TaggedStruct<"manual", {
                             readonly observedAt: Schema.DateTimeUtcFromString;
                             readonly safeSummary: Schema.String;
+                            readonly reason: Schema.Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
                         }>;
                     }>;
                 }>;
@@ -693,18 +1160,18 @@ declare const makeGovernedActionRepository: Effect.Effect<{
                 }>;
             }>;
             readonly cause: Schema.TaggedUnion<{
-                readonly agent: Schema.TaggedStruct<"agent", {
-                    readonly actor: Schema.TaggedStruct<"agent", {
-                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
-                    }>;
-                    readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
-                }>;
                 readonly human: Schema.TaggedStruct<"human", {
                     readonly actor: Schema.TaggedStruct<"human", {
                         readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
                     }>;
                     readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
                 }>;
+                readonly agent: Schema.TaggedStruct<"agent", {
+                    readonly actor: Schema.TaggedStruct<"agent", {
+                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                    }>;
+                    readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+                }>;
                 readonly system: Schema.TaggedStruct<"system", {
                     readonly component: Schema.brand<Schema.String, string>;
                 }>;
@@ -712,8 +1179,8 @@ declare const makeGovernedActionRepository: Effect.Effect<{
             readonly occurredAt: Schema.DateTimeUtcFromString;
             readonly causationId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "DomainEventId">>;
             readonly correlationId: Schema.NullOr<Schema.brand<Schema.String, "DomainEventCorrelationId">>;
-        }, "Type">;
-        history: Schema.Struct.ReadonlySide<{
+        }>;
+        readonly history: Schema.$Array<Schema.Struct<{
             readonly commandDigest: Schema.brand<Schema.String, "GovernedActionCommandDigest">;
             readonly schemaVersion: Schema.Literal<1>;
             readonly transitionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionTransitionId">;
@@ -793,15 +1260,15 @@ declare const makeGovernedActionRepository: Effect.Effect<{
                 }>;
                 readonly recordUnknown: Schema.TaggedStruct<"recordUnknown", {
                     readonly outcome: Schema.TaggedUnion<{
-                        readonly manual: Schema.TaggedStruct<"manual", {
+                        readonly reconcilable: Schema.TaggedStruct<"reconcilable", {
+                            readonly reconciliationKey: Schema.brand<Schema.String, string>;
                             readonly observedAt: Schema.DateTimeUtcFromString;
                             readonly safeSummary: Schema.String;
-                            readonly reason: Schema.Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
                         }>;
-                        readonly reconcilable: Schema.TaggedStruct<"reconcilable", {
-                            readonly reconciliationKey: Schema.brand<Schema.String, string>;
+                        readonly manual: Schema.TaggedStruct<"manual", {
                             readonly observedAt: Schema.DateTimeUtcFromString;
                             readonly safeSummary: Schema.String;
+                            readonly reason: Schema.Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
                         }>;
                     }>;
                 }>;
@@ -829,18 +1296,18 @@ declare const makeGovernedActionRepository: Effect.Effect<{
                 }>;
             }>;
             readonly cause: Schema.TaggedUnion<{
-                readonly agent: Schema.TaggedStruct<"agent", {
-                    readonly actor: Schema.TaggedStruct<"agent", {
-                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
-                    }>;
-                    readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
-                }>;
                 readonly human: Schema.TaggedStruct<"human", {
                     readonly actor: Schema.TaggedStruct<"human", {
                         readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
                     }>;
                     readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
                 }>;
+                readonly agent: Schema.TaggedStruct<"agent", {
+                    readonly actor: Schema.TaggedStruct<"agent", {
+                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                    }>;
+                    readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+                }>;
                 readonly system: Schema.TaggedStruct<"system", {
                     readonly component: Schema.brand<Schema.String, string>;
                 }>;
@@ -848,8 +1315,8 @@ declare const makeGovernedActionRepository: Effect.Effect<{
             readonly occurredAt: Schema.DateTimeUtcFromString;
             readonly causationId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "DomainEventId">>;
             readonly correlationId: Schema.NullOr<Schema.brand<Schema.String, "DomainEventCorrelationId">>;
-        }, "Type">[];
-        authorization: Schema.Struct.ReadonlySide<{
+        }>>;
+        readonly authorization: Schema.NullOr<Schema.Struct<{
             readonly schemaVersion: Schema.Literal<1>;
             readonly authorizationId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionAuthorizationId">;
             readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
@@ -873,8 +1340,8 @@ declare const makeGovernedActionRepository: Effect.Effect<{
             readonly requiredPermission: Schema.Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
             readonly authorizedAt: Schema.DateTimeUtcFromString;
             readonly expiresAt: Schema.DateTimeUtcFromString;
-        }, "Type"> | null;
-        policyEvaluation: Schema.Struct.ReadonlySide<{
+        }>>;
+        readonly policyEvaluation: Schema.NullOr<Schema.Struct<{
             readonly schemaVersion: Schema.Literal<1>;
             readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
             readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
@@ -889,8 +1356,8 @@ declare const makeGovernedActionRepository: Effect.Effect<{
             readonly expectedRevision: Schema.brand<Schema.String, "Revision">;
             readonly decision: Schema.Literals<readonly ["allowed", "denied"]>;
             readonly evaluatedAt: Schema.DateTimeUtcFromString;
-        }, "Type"> | null;
-        attempt: Schema.Struct.ReadonlySide<{
+        }>>;
+        readonly attempt: Schema.NullOr<Schema.Struct<{
             readonly schemaVersion: Schema.Literal<1>;
             readonly attemptId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionAttemptId">;
             readonly authorizationId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionAuthorizationId">;
@@ -907,36 +1374,17 @@ declare const makeGovernedActionRepository: Effect.Effect<{
                 readonly checkedAt: Schema.DateTimeUtcFromString;
             }>;
             readonly startedAt: Schema.DateTimeUtcFromString;
-        }, "Type"> | null;
-    }, import("../errors.ts").RecordNotFoundError | import("../errors.ts").PersistenceOperationError | import("../errors.ts").PersistedRecordError | import("../errors.ts").QuarantineWriteError | import("effect/unstable/sql/SqlError").SqlError | GovernedActionInputError | import("./governed-action/quarantine.ts").MalformedGovernedActionRecord, never>;
-    readLatestTerminalByTarget: (input: unknown) => Effect.Effect<readonly Schema.Struct.ReadonlySide<{
-        readonly envelope: Schema.Struct<{
-            readonly envelopeDigest: Schema.brand<Schema.String, string>;
-            readonly schemaVersion: Schema.Literal<1>;
-            readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
-            readonly idempotencyKey: Schema.brand<Schema.String, "GovernedActionIdempotencyKey">;
-            readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
-            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
-            readonly pluginConnectionRevision: Schema.brand<Schema.Int, "GovernedActionPluginConnectionRevision">;
-            readonly pluginConnectionAuthorityDigest: Schema.brand<Schema.String, string>;
-            readonly pluginId: Schema.brand<Schema.String, string>;
-            readonly pluginContractVersion: Schema.Struct<{
-                readonly major: Schema.Int;
-                readonly minor: Schema.Int;
-                readonly patch: Schema.Int;
-            }>;
-            readonly pluginAdapterVersion: Schema.Struct<{
-                readonly major: Schema.Int;
-                readonly minor: Schema.Int;
-                readonly patch: Schema.Int;
-            }>;
-            readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
-            readonly capability: Schema.Struct<{
-                readonly capabilityId: Schema.Literal<"action.execute">;
-                readonly version: Schema.Int;
-            }>;
-            readonly targetEntityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
-            readonly proposal: Schema.Struct<{
+        }>>;
+    }, "Type">[], import("../errors.ts").RecordNotFoundError | import("../errors.ts").PersistenceOperationError | import("../errors.ts").PersistedRecordError | import("../errors.ts").QuarantineWriteError | import("effect/unstable/sql/SqlError").SqlError | GovernedActionInputError | import("./governed-action/quarantine.ts").MalformedGovernedActionRecord, never>;
+    readLatestTerminalReleasePublications: (input: unknown) => Effect.Effect<{
+        envelope: {
+            readonly providerId: "codecommit" | "codepipeline" | "jira" | "confluence" | "clockify";
+            readonly pluginConnectionId: string & import("effect/Brand").Brand<"PluginConnectionId">;
+            readonly workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">;
+            readonly schemaVersion: 1;
+            readonly causationId: (string & import("effect/Brand").Brand<"DomainEventId">) | null;
+            readonly correlationId: (string & import("effect/Brand").Brand<"DomainEventCorrelationId">) | null;
+            readonly proposal: Schema.Struct.ReadonlySide<{
                 readonly proposalKey: Schema.brand<Schema.String, string>;
                 readonly capabilityVersion: Schema.Int;
                 readonly request: Schema.Struct<{
@@ -956,8 +1404,35 @@ declare const makeGovernedActionRepository: Effect.Effect<{
                     readonly summary: Schema.String;
                 }>;
                 readonly proposedAt: Schema.DateTimeUtcFromString;
-            }>;
-            readonly evidence: Schema.$Array<Schema.Struct<{
+            }, "Type">;
+            readonly idempotencyKey: string & import("effect/Brand").Brand<"GovernedActionIdempotencyKey">;
+            readonly pluginId: string & import("effect/Brand").Brand<string>;
+            readonly actionId: string & import("effect/Brand").Brand<"GovernedActionId">;
+            readonly policy: Schema.Struct.ReadonlySide<{
+                readonly policyId: Schema.brand<Schema.String, string>;
+                readonly policyVersion: Schema.Int;
+                readonly policyDigest: Schema.brand<Schema.String, string>;
+                readonly requiredPermission: Schema.Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
+            }, "Type">;
+            readonly evidenceSetDigest: string & import("effect/Brand").Brand<string>;
+            readonly pluginConnectionRevision: number & import("effect/Brand").Brand<"GovernedActionPluginConnectionRevision">;
+            readonly pluginConnectionAuthorityDigest: string & import("effect/Brand").Brand<string>;
+            readonly pluginContractVersion: Schema.Struct.ReadonlySide<{
+                readonly major: Schema.Int;
+                readonly minor: Schema.Int;
+                readonly patch: Schema.Int;
+            }, "Type">;
+            readonly pluginAdapterVersion: Schema.Struct.ReadonlySide<{
+                readonly major: Schema.Int;
+                readonly minor: Schema.Int;
+                readonly patch: Schema.Int;
+            }, "Type">;
+            readonly capability: Schema.Struct.ReadonlySide<{
+                readonly capabilityId: Schema.Literal<"action.execute">;
+                readonly version: Schema.Int;
+            }, "Type">;
+            readonly targetEntityId: string & import("effect/Brand").Brand<"EntityId">;
+            readonly evidence: readonly Schema.Struct.ReadonlySide<{
                 readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
                 readonly evidenceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">;
                 readonly evidenceClaimIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceClaimId">>;
@@ -967,34 +1442,32 @@ declare const makeGovernedActionRepository: Effect.Effect<{
                 readonly evaluatedAt: Schema.DateTimeUtcFromString;
                 readonly source: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
                 readonly validity: Schema.Literals<readonly ["valid", "expired"]>;
-            }>>;
-            readonly evidenceSetDigest: Schema.brand<Schema.String, string>;
-            readonly policy: Schema.Struct<{
-                readonly policyId: Schema.brand<Schema.String, string>;
-                readonly policyVersion: Schema.Int;
-                readonly policyDigest: Schema.brand<Schema.String, string>;
-                readonly requiredPermission: Schema.Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
-            }>;
-            readonly origin: Schema.TaggedUnion<{
-                readonly agent: Schema.TaggedStruct<"agent", {
-                    readonly actor: Schema.TaggedStruct<"agent", {
-                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
-                    }>;
-                    readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
-                    readonly initiatingSessionId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">>;
-                }>;
-                readonly human: Schema.TaggedStruct<"human", {
-                    readonly actor: Schema.TaggedStruct<"human", {
-                        readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
-                    }>;
-                    readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
-                }>;
-            }>;
-            readonly proposalExpiresAt: Schema.DateTimeUtcFromString;
-            readonly causationId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "DomainEventId">>;
-            readonly correlationId: Schema.NullOr<Schema.brand<Schema.String, "DomainEventCorrelationId">>;
-        }>;
-        readonly head: Schema.Struct<{
+            }, "Type">[];
+            readonly origin: Schema.Struct.ReadonlySide<{
+                readonly _tag: Schema.tag<"human">;
+                readonly actor: Schema.TaggedStruct<"human", {
+                    readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                }>;
+                readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+            }, "Type"> | Schema.Struct.ReadonlySide<{
+                readonly _tag: Schema.tag<"agent">;
+                readonly actor: Schema.TaggedStruct<"agent", {
+                    readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                }>;
+                readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+                readonly initiatingSessionId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">>;
+            }, "Type">;
+            readonly proposalExpiresAt: import("effect/DateTime").Utc;
+            readonly envelopeDigest: string & import("effect/Brand").Brand<string>;
+            readonly releasePublication?: {
+                readonly releaseId: string & import("effect/Brand").Brand<"ReleaseId">;
+                readonly sourceRevisionDigest: string & import("effect/Brand").Brand<string>;
+                readonly sourceRevisionCount: number;
+                readonly predecessorPublicationActionId?: (string & import("effect/Brand").Brand<"GovernedActionId">) | null;
+                readonly templateSourceEntityId?: string & import("effect/Brand").Brand<"EntityId">;
+            };
+        };
+        head: Schema.Struct.ReadonlySide<{
             readonly state: Schema.Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>;
             readonly lineage: Schema.TaggedUnion<{
                 readonly accepted: Schema.TaggedStruct<"accepted", {
@@ -1006,14 +1479,14 @@ declare const makeGovernedActionRepository: Effect.Effect<{
                         readonly observedAt: Schema.DateTimeUtcFromString;
                     }>;
                 }>;
-                readonly none: Schema.TaggedStruct<"none", {}>;
-                readonly manual: Schema.TaggedStruct<"manual", {
-                    readonly providerOperationId: Schema.NullOr<Schema.brand<Schema.String, string>>;
-                }>;
                 readonly reconcilable: Schema.TaggedStruct<"reconcilable", {
                     readonly providerOperationId: Schema.NullOr<Schema.brand<Schema.String, string>>;
                     readonly reconciliationKey: Schema.brand<Schema.String, string>;
                 }>;
+                readonly manual: Schema.TaggedStruct<"manual", {
+                    readonly providerOperationId: Schema.NullOr<Schema.brand<Schema.String, string>>;
+                }>;
+                readonly none: Schema.TaggedStruct<"none", {}>;
                 readonly terminal: Schema.TaggedStruct<"terminal", {
                     readonly receipt: Schema.Struct<{
                         readonly observationBasis: Schema.optionalKey<Schema.Literal<"authorization">>;
@@ -1024,8 +1497,8 @@ declare const makeGovernedActionRepository: Effect.Effect<{
                     }>;
                 }>;
             }>;
-        }>;
-        readonly headTransition: Schema.Struct<{
+        }, "Type">;
+        headTransition: Schema.Struct.ReadonlySide<{
             readonly commandDigest: Schema.brand<Schema.String, "GovernedActionCommandDigest">;
             readonly schemaVersion: Schema.Literal<1>;
             readonly transitionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionTransitionId">;
@@ -1105,15 +1578,15 @@ declare const makeGovernedActionRepository: Effect.Effect<{
                 }>;
                 readonly recordUnknown: Schema.TaggedStruct<"recordUnknown", {
                     readonly outcome: Schema.TaggedUnion<{
-                        readonly manual: Schema.TaggedStruct<"manual", {
+                        readonly reconcilable: Schema.TaggedStruct<"reconcilable", {
+                            readonly reconciliationKey: Schema.brand<Schema.String, string>;
                             readonly observedAt: Schema.DateTimeUtcFromString;
                             readonly safeSummary: Schema.String;
-                            readonly reason: Schema.Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
                         }>;
-                        readonly reconcilable: Schema.TaggedStruct<"reconcilable", {
-                            readonly reconciliationKey: Schema.brand<Schema.String, string>;
+                        readonly manual: Schema.TaggedStruct<"manual", {
                             readonly observedAt: Schema.DateTimeUtcFromString;
                             readonly safeSummary: Schema.String;
+                            readonly reason: Schema.Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
                         }>;
                     }>;
                 }>;
@@ -1141,18 +1614,18 @@ declare const makeGovernedActionRepository: Effect.Effect<{
                 }>;
             }>;
             readonly cause: Schema.TaggedUnion<{
-                readonly agent: Schema.TaggedStruct<"agent", {
-                    readonly actor: Schema.TaggedStruct<"agent", {
-                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
-                    }>;
-                    readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
-                }>;
                 readonly human: Schema.TaggedStruct<"human", {
                     readonly actor: Schema.TaggedStruct<"human", {
                         readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
                     }>;
                     readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
                 }>;
+                readonly agent: Schema.TaggedStruct<"agent", {
+                    readonly actor: Schema.TaggedStruct<"agent", {
+                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                    }>;
+                    readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+                }>;
                 readonly system: Schema.TaggedStruct<"system", {
                     readonly component: Schema.brand<Schema.String, string>;
                 }>;
@@ -1160,8 +1633,8 @@ declare const makeGovernedActionRepository: Effect.Effect<{
             readonly occurredAt: Schema.DateTimeUtcFromString;
             readonly causationId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "DomainEventId">>;
             readonly correlationId: Schema.NullOr<Schema.brand<Schema.String, "DomainEventCorrelationId">>;
-        }>;
-        readonly history: Schema.$Array<Schema.Struct<{
+        }, "Type">;
+        history: Schema.Struct.ReadonlySide<{
             readonly commandDigest: Schema.brand<Schema.String, "GovernedActionCommandDigest">;
             readonly schemaVersion: Schema.Literal<1>;
             readonly transitionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionTransitionId">;
@@ -1241,15 +1714,15 @@ declare const makeGovernedActionRepository: Effect.Effect<{
                 }>;
                 readonly recordUnknown: Schema.TaggedStruct<"recordUnknown", {
                     readonly outcome: Schema.TaggedUnion<{
-                        readonly manual: Schema.TaggedStruct<"manual", {
+                        readonly reconcilable: Schema.TaggedStruct<"reconcilable", {
+                            readonly reconciliationKey: Schema.brand<Schema.String, string>;
                             readonly observedAt: Schema.DateTimeUtcFromString;
                             readonly safeSummary: Schema.String;
-                            readonly reason: Schema.Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
                         }>;
-                        readonly reconcilable: Schema.TaggedStruct<"reconcilable", {
-                            readonly reconciliationKey: Schema.brand<Schema.String, string>;
+                        readonly manual: Schema.TaggedStruct<"manual", {
                             readonly observedAt: Schema.DateTimeUtcFromString;
                             readonly safeSummary: Schema.String;
+                            readonly reason: Schema.Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
                         }>;
                     }>;
                 }>;
@@ -1277,18 +1750,18 @@ declare const makeGovernedActionRepository: Effect.Effect<{
                 }>;
             }>;
             readonly cause: Schema.TaggedUnion<{
-                readonly agent: Schema.TaggedStruct<"agent", {
-                    readonly actor: Schema.TaggedStruct<"agent", {
-                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
-                    }>;
-                    readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
-                }>;
                 readonly human: Schema.TaggedStruct<"human", {
                     readonly actor: Schema.TaggedStruct<"human", {
                         readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
                     }>;
                     readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
                 }>;
+                readonly agent: Schema.TaggedStruct<"agent", {
+                    readonly actor: Schema.TaggedStruct<"agent", {
+                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                    }>;
+                    readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+                }>;
                 readonly system: Schema.TaggedStruct<"system", {
                     readonly component: Schema.brand<Schema.String, string>;
                 }>;
@@ -1296,8 +1769,8 @@ declare const makeGovernedActionRepository: Effect.Effect<{
             readonly occurredAt: Schema.DateTimeUtcFromString;
             readonly causationId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "DomainEventId">>;
             readonly correlationId: Schema.NullOr<Schema.brand<Schema.String, "DomainEventCorrelationId">>;
-        }>>;
-        readonly authorization: Schema.NullOr<Schema.Struct<{
+        }, "Type">[];
+        authorization: Schema.Struct.ReadonlySide<{
             readonly schemaVersion: Schema.Literal<1>;
             readonly authorizationId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionAuthorizationId">;
             readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
@@ -1321,8 +1794,8 @@ declare const makeGovernedActionRepository: Effect.Effect<{
             readonly requiredPermission: Schema.Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
             readonly authorizedAt: Schema.DateTimeUtcFromString;
             readonly expiresAt: Schema.DateTimeUtcFromString;
-        }>>;
-        readonly policyEvaluation: Schema.NullOr<Schema.Struct<{
+        }, "Type"> | null;
+        policyEvaluation: Schema.Struct.ReadonlySide<{
             readonly schemaVersion: Schema.Literal<1>;
             readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
             readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
@@ -1337,8 +1810,8 @@ declare const makeGovernedActionRepository: Effect.Effect<{
             readonly expectedRevision: Schema.brand<Schema.String, "Revision">;
             readonly decision: Schema.Literals<readonly ["allowed", "denied"]>;
             readonly evaluatedAt: Schema.DateTimeUtcFromString;
-        }>>;
-        readonly attempt: Schema.NullOr<Schema.Struct<{
+        }, "Type"> | null;
+        attempt: Schema.Struct.ReadonlySide<{
             readonly schemaVersion: Schema.Literal<1>;
             readonly attemptId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionAttemptId">;
             readonly authorizationId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionAuthorizationId">;
@@ -1355,8 +1828,8 @@ declare const makeGovernedActionRepository: Effect.Effect<{
                 readonly checkedAt: Schema.DateTimeUtcFromString;
             }>;
             readonly startedAt: Schema.DateTimeUtcFromString;
-        }>>;
-    }, "Type">[], import("../errors.ts").RecordNotFoundError | import("../errors.ts").PersistenceOperationError | import("../errors.ts").PersistedRecordError | import("../errors.ts").QuarantineWriteError | import("effect/unstable/sql/SqlError").SqlError | GovernedActionInputError | import("./governed-action/quarantine.ts").MalformedGovernedActionRecord, never>;
+        }, "Type"> | null;
+    }[], import("../errors.ts").RecordNotFoundError | import("../errors.ts").PersistenceOperationError | import("../errors.ts").PersistedRecordError | import("../errors.ts").QuarantineWriteError | import("effect/unstable/sql/SqlError").SqlError | GovernedActionInputError | import("./governed-action/quarantine.ts").MalformedGovernedActionRecord, never>;
 }, never, import("effect/Crypto").Crypto | import("../Database.ts").Database | import("./quarantineRepository.ts").QuarantineRepository>;
 /** Deep server-only repository for governed action authority, lifecycle, and audit. */
 export interface GovernedActionRepositoryService extends Success<typeof makeGovernedActionRepository> {