@knpkv/control-center 0.1.0

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

@@ -0,0 +1,1478 @@
+import * as DateTime from "effect/DateTime";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { GovernedActionLifecycleHeadV1, type GovernedActionProviderLineage as GovernedActionLineage } from "../../../../domain/governedAction/lifecycle.js";
+import { type GovernedActionEnvelopeV1 as GovernedActionEnvelope } from "../../../../domain/governedAction/model.js";
+import { GovernedActionTransitionCause, GovernedActionTransitionCommand, type GovernedActionTransitionV1 as GovernedActionTransition } from "../../../../domain/governedAction/stateMachine.js";
+import type { AgentId, GovernedActionAttemptId, GovernedActionAuthorizationId, GovernedActionTransitionId, JobId, PersonId, SessionId } from "../../../../domain/identifiers.js";
+import type { PluginActionReconciliationKey, PluginProviderOperationId } from "../../../../domain/plugins/actions.js";
+import { UtcTimestamp } from "../../../../domain/utcTimestamp.js";
+import { PersistedRecordError, PersistenceOperationError } from "../../errors.js";
+import { type PersistedGovernedActionReconciliationLocator } from "../../governedActionReconciliationLocator.js";
+import type { QuarantineReasonCode, QuarantineRecordKind } from "../models.js";
+import type { GovernedActionRow, GovernedActionTransitionRow } from "./rows.js";
+declare const envelopeJson: Schema.fromJsonString<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<{
+        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;
+    }>;
+    readonly evidence: Schema.$Array<Schema.Struct<{
+        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"]>;
+    }>>;
+    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 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 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">>;
+}>>;
+declare const policyEvaluationJson: Schema.fromJsonString<Schema.Struct<{
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+    readonly policy: Schema.Struct<{
+        readonly policyId: Schema.brand<Schema.String, string>;
+        readonly policyVersion: Schema.Int;
+        readonly policyDigest: Schema.brand<Schema.String, string>;
+        readonly requiredPermission: Schema.Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
+    }>;
+    readonly payloadDigest: Schema.brand<Schema.String, "PluginActionPayloadDigest">;
+    readonly evidenceSetDigest: Schema.brand<Schema.String, string>;
+    readonly expectedRevision: Schema.brand<Schema.String, "Revision">;
+    readonly decision: Schema.Literals<readonly ["allowed", "denied"]>;
+    readonly evaluatedAt: Schema.DateTimeUtcFromString;
+}>>;
+declare const authorizationJson: Schema.fromJsonString<Schema.Struct<{
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly authorizationId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionAuthorizationId">;
+    readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+    readonly pluginConnectionRevision: Schema.brand<Schema.Int, "GovernedActionPluginConnectionRevision">;
+    readonly pluginConnectionAuthorityDigest: Schema.brand<Schema.String, string>;
+    readonly actionEnvelopeDigest: Schema.brand<Schema.String, string>;
+    readonly idempotencyKey: Schema.brand<Schema.String, "GovernedActionIdempotencyKey">;
+    readonly payloadDigest: Schema.brand<Schema.String, "PluginActionPayloadDigest">;
+    readonly evidenceSetDigest: Schema.brand<Schema.String, string>;
+    readonly policyDigest: Schema.brand<Schema.String, string>;
+    readonly expectedRevision: Schema.brand<Schema.String, "Revision">;
+    readonly capabilityVersion: Schema.Int;
+    readonly actor: Schema.TaggedStruct<"human", {
+        readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+    }>;
+    readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+    readonly sessionPermission: Schema.Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
+    readonly sessionExpiresAt: Schema.DateTimeUtcFromString;
+    readonly requiredPermission: Schema.Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
+    readonly authorizedAt: Schema.DateTimeUtcFromString;
+    readonly expiresAt: Schema.DateTimeUtcFromString;
+}>>;
+declare const attemptJson: Schema.fromJsonString<Schema.Struct<{
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly attemptId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionAttemptId">;
+    readonly authorizationId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionAuthorizationId">;
+    readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+    readonly idempotencyKey: Schema.brand<Schema.String, "GovernedActionIdempotencyKey">;
+    readonly attemptNumber: Schema.Literal<1>;
+    readonly actionEnvelopeDigest: Schema.brand<Schema.String, string>;
+    readonly expectedRevision: Schema.brand<Schema.String, "Revision">;
+    readonly policyEvaluationDigest: Schema.brand<Schema.String, string>;
+    readonly preflight: Schema.TaggedStruct<"ready", {
+        readonly checkedRevision: Schema.brand<Schema.String, "Revision">;
+        readonly checkedAt: Schema.DateTimeUtcFromString;
+    }>;
+    readonly startedAt: Schema.DateTimeUtcFromString;
+}>>;
+declare const transitionJson: Schema.fromJsonString<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">;
+    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 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 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 status: Schema.Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                readonly providerOperationId: Schema.brand<Schema.String, string>;
+                readonly safeSummary: Schema.String;
+                readonly observedAt: Schema.DateTimeUtcFromString;
+            }>;
+            readonly source: Schema.TaggedUnion<{
+                readonly direct: Schema.TaggedStruct<"direct", {}>;
+                readonly providerOperation: Schema.TaggedStruct<"providerOperation", {
+                    readonly providerOperationId: Schema.brand<Schema.String, string>;
+                }>;
+                readonly reconciliation: Schema.TaggedStruct<"reconciliation", {
+                    readonly reconciliationKey: Schema.NullOr<Schema.brand<Schema.String, string>>;
+                }>;
+            }>;
+        }>;
+        readonly reconciliationPending: Schema.TaggedStruct<"reconciliationPending", {
+            readonly checkedAt: Schema.DateTimeUtcFromString;
+            readonly reconciliationKey: Schema.NullOr<Schema.brand<Schema.String, string>>;
+        }>;
+    }>;
+    readonly cause: Schema.TaggedUnion<{
+        readonly human: Schema.TaggedStruct<"human", {
+            readonly actor: Schema.TaggedStruct<"human", {
+                readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+            }>;
+            readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+        }>;
+        readonly agent: Schema.TaggedStruct<"agent", {
+            readonly actor: Schema.TaggedStruct<"agent", {
+                readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+            }>;
+            readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+        }>;
+        readonly system: Schema.TaggedStruct<"system", {
+            readonly component: Schema.brand<Schema.String, string>;
+        }>;
+    }>;
+    readonly occurredAt: Schema.DateTimeUtcFromString;
+    readonly causationId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "DomainEventId">>;
+    readonly correlationId: Schema.NullOr<Schema.brand<Schema.String, "DomainEventCorrelationId">>;
+}>>;
+declare const lineageJson: Schema.fromJsonString<Schema.TaggedUnion<{
+    readonly none: Schema.TaggedStruct<"none", {}>;
+    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 terminal: Schema.TaggedStruct<"terminal", {
+        readonly receipt: Schema.Struct<{
+            readonly status: Schema.Literals<readonly ["succeeded", "failed", "cancelled"]>;
+            readonly providerOperationId: Schema.brand<Schema.String, string>;
+            readonly safeSummary: Schema.String;
+            readonly observedAt: Schema.DateTimeUtcFromString;
+        }>;
+    }>;
+}>>;
+declare const commandJson: Schema.fromJsonString<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 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 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 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>>;
+    }>;
+}>>;
+declare const causeJson: Schema.fromJsonString<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>;
+    }>;
+}>>;
+/** Canonical JSON codecs shared by governed-action reads and writes. */
+export { attemptJson as GovernedActionAttemptJson, authorizationJson as GovernedActionAuthorizationJson, causeJson as GovernedActionCauseJson, commandJson as GovernedActionCommandJson, envelopeJson as GovernedActionEnvelopeJson, lineageJson as GovernedActionLineageJson, policyEvaluationJson as GovernedActionPolicyEvaluationJson, transitionJson as GovernedActionTransitionJson };
+/** Closed quarantine kinds emitted by the governed-action integrity codec. */
+export type GovernedActionQuarantineRecordKind = Extract<QuarantineRecordKind, "governed-action" | "governed-action-policy-evaluation" | "governed-action-authorization" | "governed-action-attempt" | "governed-action-transition" | "governed-action-audit">;
+/** Closed diagnostics emitted by the governed-action integrity codec. */
+export type GovernedActionQuarantineReasonCode = Extract<QuarantineReasonCode, "governed-action-schema-invalid" | "governed-action-digest-mismatch" | "governed-action-identity-mismatch" | "governed-action-chain-invalid" | "governed-action-head-mismatch" | "governed-action-companion-invalid" | "governed-action-transition-schema-invalid" | "governed-action-transition-digest-mismatch" | "governed-action-audit-mismatch">;
+interface GovernedActionRecordErrorOptions {
+    readonly workspaceId: typeof GovernedActionRow.Type["workspaceId"];
+    readonly recordKind: GovernedActionQuarantineRecordKind;
+    readonly recordKey: string;
+    readonly diagnosticCode: GovernedActionQuarantineReasonCode;
+}
+/** Construct a bounded corruption diagnostic without retaining raw governed-action material. */
+export declare const governedActionRecordError: (options: GovernedActionRecordErrorOptions) => PersistedRecordError;
+/** Denormalized provider-lineage columns shared by action heads and transitions. */
+export interface GovernedActionLineageProjection {
+    readonly lineageKind: GovernedActionLineage["_tag"];
+    readonly providerOperationId: PluginProviderOperationId | null;
+    readonly reconciliationKey: PluginActionReconciliationKey | null;
+    readonly terminalStatus: "succeeded" | "failed" | "cancelled" | null;
+}
+/** Denormalized replay and provider-identity columns for one transition command. */
+export interface GovernedActionCommandProjection {
+    readonly commandTag: GovernedActionTransitionCommand["_tag"];
+    readonly authorizationId: GovernedActionAuthorizationId | null;
+    readonly attemptId: GovernedActionAttemptId | null;
+    readonly outcomeSourceKind: "direct" | "providerOperation" | "reconciliation" | null;
+    readonly commandProviderOperationId: PluginProviderOperationId | null;
+    readonly commandReconciliationKey: PersistedGovernedActionReconciliationLocator | null;
+    readonly commandTerminalStatus: "succeeded" | "failed" | "cancelled" | null;
+    readonly commandUnknownKind: "reconcilable" | "manual" | null;
+}
+/** Denormalized human, agent, or system attribution columns for one transition. */
+export interface GovernedActionCauseProjection {
+    readonly causeKind: GovernedActionTransitionCause["_tag"];
+    readonly causeActorId: PersonId | AgentId | null;
+    readonly causeSessionId: SessionId | null;
+    readonly causeJobId: JobId | null;
+    readonly causeSystemComponent: string | null;
+}
+/** Verified materialized action-head metadata reconstructed from the persisted lineage. */
+export interface GovernedActionHeadRecord {
+    readonly transitionId: GovernedActionTransitionId;
+    readonly sequence: number;
+    readonly lifecycle: typeof GovernedActionLifecycleHeadV1.Type;
+    readonly updatedAt: typeof UtcTimestamp.Type;
+}
+/** Verified action envelope and its nullable transaction-local materialized head. */
+export interface DecodedGovernedActionRow {
+    readonly envelope: GovernedActionEnvelope;
+    readonly head: GovernedActionHeadRecord | null;
+    readonly createdAt: typeof UtcTimestamp.Type;
+}
+/** Verified transition and the independently persisted lifecycle projection it produced. */
+export interface DecodedGovernedActionTransitionRow {
+    readonly transition: GovernedActionTransition;
+    readonly transitionDigest: typeof GovernedActionTransitionRow.Type["transitionDigest"];
+    readonly resultHead: typeof GovernedActionLifecycleHeadV1.Type;
+}
+/** Project provider lineage into the independently constrained SQL columns. */
+export declare const projectGovernedActionLineage: (lineage: GovernedActionLineage) => GovernedActionLineageProjection;
+/** Project command-specific identities without retaining descriptions or provider payloads. */
+export declare const projectGovernedActionCommand: (command: GovernedActionTransitionCommand) => GovernedActionCommandProjection;
+/** Project closed transition attribution into mutually exclusive SQL columns. */
+export declare const projectGovernedActionCause: (cause: GovernedActionTransitionCause) => GovernedActionCauseProjection;
+/** Encode a validated immutable governed-action envelope as bounded JSON text. */
+export declare const encodeGovernedActionEnvelopeJson: (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<{
+        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;
+    }>;
+    readonly evidence: Schema.$Array<Schema.Struct<{
+        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"]>;
+    }>>;
+    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 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 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">) => Effect.Effect<string, PersistenceOperationError, never>;
+/** Encode a validated fresh policy evaluation as bounded JSON text. */
+export declare const encodeGovernedActionPolicyEvaluationJson: (evaluation: 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">) => Effect.Effect<string, PersistenceOperationError, never>;
+/** Encode a validated immutable human authorization as bounded JSON text. */
+export declare const encodeGovernedActionAuthorizationJson: (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">) => Effect.Effect<string, PersistenceOperationError, never>;
+/** Encode a validated durable dispatch attempt as bounded JSON text. */
+export declare const encodeGovernedActionAttemptJson: (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">) => Effect.Effect<string, PersistenceOperationError, never>;
+/** Encode a validated immutable lifecycle transition as bounded JSON text. */
+export declare const encodeGovernedActionTransitionJson: (transition: 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 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 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 status: Schema.Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                readonly providerOperationId: Schema.brand<Schema.String, string>;
+                readonly safeSummary: Schema.String;
+                readonly observedAt: Schema.DateTimeUtcFromString;
+            }>;
+            readonly source: Schema.TaggedUnion<{
+                readonly direct: Schema.TaggedStruct<"direct", {}>;
+                readonly providerOperation: Schema.TaggedStruct<"providerOperation", {
+                    readonly providerOperationId: Schema.brand<Schema.String, string>;
+                }>;
+                readonly reconciliation: Schema.TaggedStruct<"reconciliation", {
+                    readonly reconciliationKey: Schema.NullOr<Schema.brand<Schema.String, string>>;
+                }>;
+            }>;
+        }>;
+        readonly reconciliationPending: Schema.TaggedStruct<"reconciliationPending", {
+            readonly checkedAt: Schema.DateTimeUtcFromString;
+            readonly reconciliationKey: Schema.NullOr<Schema.brand<Schema.String, string>>;
+        }>;
+    }>;
+    readonly cause: Schema.TaggedUnion<{
+        readonly human: Schema.TaggedStruct<"human", {
+            readonly actor: Schema.TaggedStruct<"human", {
+                readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+            }>;
+            readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+        }>;
+        readonly agent: Schema.TaggedStruct<"agent", {
+            readonly actor: Schema.TaggedStruct<"agent", {
+                readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+            }>;
+            readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+        }>;
+        readonly system: Schema.TaggedStruct<"system", {
+            readonly component: Schema.brand<Schema.String, string>;
+        }>;
+    }>;
+    readonly occurredAt: Schema.DateTimeUtcFromString;
+    readonly causationId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "DomainEventId">>;
+    readonly correlationId: Schema.NullOr<Schema.brand<Schema.String, "DomainEventCorrelationId">>;
+}, "Type">) => Effect.Effect<string, PersistenceOperationError, never>;
+/** Encode a validated provider lineage projection as bounded JSON text. */
+export declare const encodeGovernedActionLineageJson: (lineage: Schema.Struct.ReadonlySide<{
+    readonly _tag: Schema.tag<"none">;
+}, "Type"> | Schema.Struct.ReadonlySide<{
+    readonly _tag: Schema.tag<"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;
+    }>;
+}, "Type"> | Schema.Struct.ReadonlySide<{
+    readonly _tag: Schema.tag<"reconcilable">;
+    readonly providerOperationId: Schema.NullOr<Schema.brand<Schema.String, string>>;
+    readonly reconciliationKey: Schema.brand<Schema.String, string>;
+}, "Type"> | Schema.Struct.ReadonlySide<{
+    readonly _tag: Schema.tag<"manual">;
+    readonly providerOperationId: Schema.NullOr<Schema.brand<Schema.String, string>>;
+}, "Type"> | Schema.Struct.ReadonlySide<{
+    readonly _tag: Schema.tag<"terminal">;
+    readonly receipt: Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["succeeded", "failed", "cancelled"]>;
+        readonly providerOperationId: Schema.brand<Schema.String, string>;
+        readonly safeSummary: Schema.String;
+        readonly observedAt: Schema.DateTimeUtcFromString;
+    }>;
+}, "Type">) => Effect.Effect<string, PersistenceOperationError, never>;
+/** Decode and verify the immutable envelope and nullable action-head projection. */
+export declare const decodeGovernedActionRow: (row: Schema.Struct.ReadonlySide<{
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+    readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
+    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+    readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+    readonly targetEntityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+    readonly idempotencyKey: Schema.brand<Schema.String, "GovernedActionIdempotencyKey">;
+    readonly envelopeDigest: Schema.brand<Schema.String, string>;
+    readonly envelopeJson: Schema.String;
+    readonly state: Schema.NullOr<Schema.Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>>;
+    readonly lineageJson: Schema.NullOr<Schema.String>;
+    readonly lineageKind: Schema.NullOr<Schema.Literals<readonly ["none", "accepted", "reconcilable", "manual", "terminal"]>>;
+    readonly providerOperationId: Schema.NullOr<Schema.brand<Schema.String, string>>;
+    readonly reconciliationKey: Schema.NullOr<Schema.brand<Schema.String, string>>;
+    readonly terminalStatus: Schema.NullOr<Schema.Literals<readonly ["succeeded", "failed", "cancelled"]>>;
+    readonly headTransitionId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionTransitionId">>;
+    readonly headSequence: Schema.NullOr<Schema.Int>;
+    readonly createdAt: Schema.String;
+    readonly updatedAt: Schema.String;
+}, "Type">) => Effect.Effect<{
+    envelope: Schema.Struct.ReadonlySide<{
+        readonly envelopeDigest: Schema.brand<Schema.String, string>;
+        readonly schemaVersion: Schema.Literal<1>;
+        readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
+        readonly idempotencyKey: Schema.brand<Schema.String, "GovernedActionIdempotencyKey">;
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+        readonly pluginConnectionRevision: Schema.brand<Schema.Int, "GovernedActionPluginConnectionRevision">;
+        readonly pluginConnectionAuthorityDigest: Schema.brand<Schema.String, string>;
+        readonly pluginId: Schema.brand<Schema.String, string>;
+        readonly pluginContractVersion: Schema.Struct<{
+            readonly major: Schema.Int;
+            readonly minor: Schema.Int;
+            readonly patch: Schema.Int;
+        }>;
+        readonly pluginAdapterVersion: Schema.Struct<{
+            readonly major: Schema.Int;
+            readonly minor: Schema.Int;
+            readonly patch: Schema.Int;
+        }>;
+        readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+        readonly capability: Schema.Struct<{
+            readonly capabilityId: Schema.Literal<"action.execute">;
+            readonly version: Schema.Int;
+        }>;
+        readonly targetEntityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+        readonly proposal: Schema.Struct<{
+            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;
+        }>;
+        readonly evidence: Schema.$Array<Schema.Struct<{
+            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"]>;
+        }>>;
+        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 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 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: null;
+    createdAt: DateTime.Utc;
+} | {
+    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<{
+            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;
+        }>;
+        readonly evidence: Schema.$Array<Schema.Struct<{
+            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"]>;
+        }>>;
+        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 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 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: {
+        transitionId: string & import("effect/Brand").Brand<"GovernedActionTransitionId">;
+        sequence: number;
+        lifecycle: 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 none: Schema.TaggedStruct<"none", {}>;
+                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 terminal: Schema.TaggedStruct<"terminal", {
+                    readonly receipt: Schema.Struct<{
+                        readonly status: Schema.Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        readonly safeSummary: Schema.String;
+                        readonly observedAt: Schema.DateTimeUtcFromString;
+                    }>;
+                }>;
+            }>;
+        }, "Type">;
+        updatedAt: DateTime.Utc;
+    };
+    createdAt: DateTime.Utc;
+}, PersistedRecordError, import("effect/Crypto").Crypto>;
+/** Decode a policy evaluation, then verify its digest and denormalized identity. */
+export declare const decodeGovernedActionPolicyEvaluationRow: (row: Schema.Struct.ReadonlySide<{
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+    readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
+    readonly evaluationDigest: Schema.brand<Schema.String, string>;
+    readonly evaluationJson: Schema.String;
+    readonly decision: Schema.Literals<readonly ["allowed", "denied"]>;
+    readonly evaluatedAt: Schema.String;
+}, "Type">) => Effect.Effect<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">, PersistedRecordError, import("effect/Crypto").Crypto>;
+/** Decode an authorization, then verify its full digest and denormalized authority columns. */
+export declare const decodeGovernedActionAuthorizationRow: (row: Schema.Struct.ReadonlySide<{
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+    readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
+    readonly authorizationId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionAuthorizationId">;
+    readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+    readonly envelopeDigest: Schema.brand<Schema.String, string>;
+    readonly authorizationDigest: Schema.brand<Schema.String, string>;
+    readonly authorizationJson: Schema.String;
+    readonly authorizedAt: Schema.String;
+    readonly expiresAt: Schema.String;
+}, "Type">) => Effect.Effect<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">, PersistedRecordError, import("effect/Crypto").Crypto>;
+/** Decode a durable attempt, then verify its full digest and authority linkage columns. */
+export declare const decodeGovernedActionAttemptRow: (row: Schema.Struct.ReadonlySide<{
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+    readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
+    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 policyEvaluationDigest: Schema.brand<Schema.String, string>;
+    readonly attemptDigest: Schema.brand<Schema.String, string>;
+    readonly attemptNumber: Schema.Literal<1>;
+    readonly attemptJson: Schema.String;
+    readonly startedAt: Schema.String;
+}, "Type">) => Effect.Effect<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">, PersistedRecordError, import("effect/Crypto").Crypto>;
+/** Decode a transition and verify both canonical digests plus every replay projection. */
+export declare const decodeGovernedActionTransitionRow: (row: Schema.Struct.ReadonlySide<{
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+    readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
+    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 sequence: Schema.Int;
+    readonly commandId: Schema.brand<Schema.String, string>;
+    readonly commandTag: Schema.Literals<readonly ["propose", "authorize", "deny", "expire", "cancel", "start", "requestCancellation", "recordAccepted", "recordSucceeded", "recordFailed", "recordUnknown", "recordCancelled", "reconciliationPending"]>;
+    readonly authorizationId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionAuthorizationId">>;
+    readonly attemptId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionAttemptId">>;
+    readonly policyEvaluationDigest: Schema.NullOr<Schema.brand<Schema.String, string>>;
+    readonly outcomeSourceKind: Schema.NullOr<Schema.Literals<readonly ["direct", "providerOperation", "reconciliation"]>>;
+    readonly commandProviderOperationId: Schema.NullOr<Schema.brand<Schema.String, string>>;
+    readonly commandReconciliationKey: Schema.NullOr<Schema.Union<readonly [Schema.brand<Schema.String, string>, Schema.Literal<" @knpkv/idempotency-reconciliation/v1">]>>;
+    readonly commandTerminalStatus: Schema.NullOr<Schema.Literals<readonly ["succeeded", "failed", "cancelled"]>>;
+    readonly commandUnknownKind: Schema.NullOr<Schema.Literals<readonly ["reconcilable", "manual"]>>;
+    readonly commandDigest: Schema.brand<Schema.String, "GovernedActionCommandDigest">;
+    readonly transitionDigest: Schema.brand<Schema.String, "GovernedActionTransitionDigest">;
+    readonly envelopeDigest: Schema.brand<Schema.String, string>;
+    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 resultLineageJson: Schema.String;
+    readonly resultLineageKind: Schema.Literals<readonly ["none", "accepted", "reconcilable", "manual", "terminal"]>;
+    readonly resultProviderOperationId: Schema.NullOr<Schema.brand<Schema.String, string>>;
+    readonly resultReconciliationKey: Schema.NullOr<Schema.brand<Schema.String, string>>;
+    readonly resultTerminalStatus: Schema.NullOr<Schema.Literals<readonly ["succeeded", "failed", "cancelled"]>>;
+    readonly causeKind: Schema.Literals<readonly ["human", "agent", "system"]>;
+    readonly causeActorId: Schema.NullOr<Schema.Union<readonly [Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">, Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">]>>;
+    readonly causeSessionId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">>;
+    readonly causeJobId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">>;
+    readonly causeSystemComponent: Schema.NullOr<Schema.String>;
+    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 transitionJson: Schema.String;
+    readonly occurredAt: Schema.String;
+}, "Type">) => Effect.Effect<{
+    transition: 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 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 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 status: Schema.Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                    readonly providerOperationId: Schema.brand<Schema.String, string>;
+                    readonly safeSummary: Schema.String;
+                    readonly observedAt: Schema.DateTimeUtcFromString;
+                }>;
+                readonly source: Schema.TaggedUnion<{
+                    readonly direct: Schema.TaggedStruct<"direct", {}>;
+                    readonly providerOperation: Schema.TaggedStruct<"providerOperation", {
+                        readonly providerOperationId: Schema.brand<Schema.String, string>;
+                    }>;
+                    readonly reconciliation: Schema.TaggedStruct<"reconciliation", {
+                        readonly reconciliationKey: Schema.NullOr<Schema.brand<Schema.String, string>>;
+                    }>;
+                }>;
+            }>;
+            readonly reconciliationPending: Schema.TaggedStruct<"reconciliationPending", {
+                readonly checkedAt: Schema.DateTimeUtcFromString;
+                readonly reconciliationKey: Schema.NullOr<Schema.brand<Schema.String, string>>;
+            }>;
+        }>;
+        readonly cause: Schema.TaggedUnion<{
+            readonly human: Schema.TaggedStruct<"human", {
+                readonly actor: Schema.TaggedStruct<"human", {
+                    readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                }>;
+                readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+            }>;
+            readonly agent: Schema.TaggedStruct<"agent", {
+                readonly actor: Schema.TaggedStruct<"agent", {
+                    readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                }>;
+                readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+            }>;
+            readonly system: Schema.TaggedStruct<"system", {
+                readonly component: Schema.brand<Schema.String, string>;
+            }>;
+        }>;
+        readonly occurredAt: Schema.DateTimeUtcFromString;
+        readonly causationId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "DomainEventId">>;
+        readonly correlationId: Schema.NullOr<Schema.brand<Schema.String, "DomainEventCorrelationId">>;
+    }, "Type">;
+    transitionDigest: string & import("effect/Brand").Brand<"GovernedActionTransitionDigest">;
+    resultHead: 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 none: Schema.TaggedStruct<"none", {}>;
+            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 terminal: Schema.TaggedStruct<"terminal", {
+                readonly receipt: Schema.Struct<{
+                    readonly status: Schema.Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                    readonly providerOperationId: Schema.brand<Schema.String, string>;
+                    readonly safeSummary: Schema.String;
+                    readonly observedAt: Schema.DateTimeUtcFromString;
+                }>;
+            }>;
+        }>;
+    }, "Type">;
+}, PersistedRecordError, import("effect/Crypto").Crypto>;
+/** Decode an audit payload and prove that all audit columns attribute its exact transition. */
+export declare const decodeGovernedActionAuditEventRow: (row: Schema.Struct.ReadonlySide<{
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+    readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
+    readonly transitionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionTransitionId">;
+    readonly auditEventId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "DomainEventId">;
+    readonly eventKind: Schema.Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>;
+    readonly causeKind: Schema.Literals<readonly ["human", "agent", "system"]>;
+    readonly actorId: Schema.NullOr<Schema.Union<readonly [Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">, Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">]>>;
+    readonly sessionId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">>;
+    readonly jobId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">>;
+    readonly systemComponent: Schema.NullOr<Schema.String>;
+    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 payloadDigest: Schema.brand<Schema.String, "GovernedActionTransitionDigest">;
+    readonly payloadJson: Schema.String;
+    readonly occurredAt: Schema.String;
+}, "Type">) => Effect.Effect<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 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 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 status: Schema.Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                readonly providerOperationId: Schema.brand<Schema.String, string>;
+                readonly safeSummary: Schema.String;
+                readonly observedAt: Schema.DateTimeUtcFromString;
+            }>;
+            readonly source: Schema.TaggedUnion<{
+                readonly direct: Schema.TaggedStruct<"direct", {}>;
+                readonly providerOperation: Schema.TaggedStruct<"providerOperation", {
+                    readonly providerOperationId: Schema.brand<Schema.String, string>;
+                }>;
+                readonly reconciliation: Schema.TaggedStruct<"reconciliation", {
+                    readonly reconciliationKey: Schema.NullOr<Schema.brand<Schema.String, string>>;
+                }>;
+            }>;
+        }>;
+        readonly reconciliationPending: Schema.TaggedStruct<"reconciliationPending", {
+            readonly checkedAt: Schema.DateTimeUtcFromString;
+            readonly reconciliationKey: Schema.NullOr<Schema.brand<Schema.String, string>>;
+        }>;
+    }>;
+    readonly cause: Schema.TaggedUnion<{
+        readonly human: Schema.TaggedStruct<"human", {
+            readonly actor: Schema.TaggedStruct<"human", {
+                readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+            }>;
+            readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+        }>;
+        readonly agent: Schema.TaggedStruct<"agent", {
+            readonly actor: Schema.TaggedStruct<"agent", {
+                readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+            }>;
+            readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+        }>;
+        readonly system: Schema.TaggedStruct<"system", {
+            readonly component: Schema.brand<Schema.String, string>;
+        }>;
+    }>;
+    readonly occurredAt: Schema.DateTimeUtcFromString;
+    readonly causationId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "DomainEventId">>;
+    readonly correlationId: Schema.NullOr<Schema.brand<Schema.String, "DomainEventCorrelationId">>;
+}, "Type">, PersistedRecordError, import("effect/Crypto").Crypto>;
+//# sourceMappingURL=codec.d.ts.map