@knpkv/control-center 0.1.0

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

@@ -0,0 +1,467 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import type { Success } from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import { GovernedActionInputError } from "./governed-action/contract.js";
+export * from "./governed-action/contract.js";
+declare const makeGovernedActionRepository: Effect.Effect<{
+    commit: (input: unknown) => Effect.Effect<{
+        readonly _tag: "committed";
+        readonly transition: import("../../../index.ts").GovernedActionTransitionV1;
+    } | {
+        readonly _tag: "replayed";
+        readonly transition: import("../../../index.ts").GovernedActionTransitionV1;
+    }, import("../errors.ts").PersistenceOperationError | import("../errors.ts").PersistedRecordError | import("../errors.ts").QuarantineWriteError | GovernedActionInputError | import("./governed-action/quarantine.ts").MalformedGovernedActionRecord, never>;
+    read: (input: unknown) => Effect.Effect<{
+        envelope: Schema.Struct.ReadonlySide<{
+            readonly envelopeDigest: Schema.brand<Schema.String, string>;
+            readonly schemaVersion: Schema.Literal<1>;
+            readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
+            readonly idempotencyKey: Schema.brand<Schema.String, "GovernedActionIdempotencyKey">;
+            readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+            readonly pluginConnectionRevision: Schema.brand<Schema.Int, "GovernedActionPluginConnectionRevision">;
+            readonly pluginConnectionAuthorityDigest: Schema.brand<Schema.String, string>;
+            readonly pluginId: Schema.brand<Schema.String, string>;
+            readonly pluginContractVersion: Schema.Struct<{
+                readonly major: Schema.Int;
+                readonly minor: Schema.Int;
+                readonly patch: Schema.Int;
+            }>;
+            readonly pluginAdapterVersion: Schema.Struct<{
+                readonly major: Schema.Int;
+                readonly minor: Schema.Int;
+                readonly patch: Schema.Int;
+            }>;
+            readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+            readonly capability: Schema.Struct<{
+                readonly capabilityId: Schema.Literal<"action.execute">;
+                readonly version: Schema.Int;
+            }>;
+            readonly targetEntityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+            readonly proposal: Schema.Struct<{
+                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: 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">;
+        headTransition: Schema.Struct.ReadonlySide<{
+            readonly commandDigest: Schema.brand<Schema.String, "GovernedActionCommandDigest">;
+            readonly schemaVersion: Schema.Literal<1>;
+            readonly transitionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionTransitionId">;
+            readonly previousTransitionId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionTransitionId">>;
+            readonly commandId: Schema.brand<Schema.String, string>;
+            readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
+            readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            readonly sequence: Schema.Int;
+            readonly fromState: Schema.NullOr<Schema.Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>>;
+            readonly toState: Schema.Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>;
+            readonly actionEnvelopeDigest: Schema.brand<Schema.String, string>;
+            readonly command: Schema.TaggedUnion<{
+                readonly propose: Schema.TaggedStruct<"propose", {}>;
+                readonly authorize: Schema.TaggedStruct<"authorize", {
+                    readonly authorizationId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionAuthorizationId">;
+                }>;
+                readonly deny: Schema.TaggedStruct<"deny", {
+                    readonly reason: Schema.Literals<readonly ["revision-changed", "evidence-stale", "evidence-invalid", "policy-denied", "session-invalid", "capability-changed", "plugin-unavailable", "preflight-blocked"]>;
+                    readonly safeSummary: Schema.String;
+                }>;
+                readonly expire: Schema.TaggedStruct<"expire", {
+                    readonly reason: Schema.Literals<readonly ["proposal-expired", "authorization-expired"]>;
+                }>;
+                readonly cancel: Schema.TaggedStruct<"cancel", {
+                    readonly safeSummary: Schema.String;
+                }>;
+                readonly start: Schema.TaggedStruct<"start", {
+                    readonly attemptId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionAttemptId">;
+                }>;
+                readonly requestCancellation: Schema.TaggedStruct<"requestCancellation", {
+                    readonly safeSummary: Schema.String;
+                }>;
+                readonly recordAccepted: Schema.TaggedStruct<"recordAccepted", {
+                    readonly receipt: Schema.Struct<{
+                        readonly status: Schema.Literal<"accepted">;
+                        readonly reconciliationKey: Schema.brand<Schema.String, string>;
+                        readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        readonly safeSummary: Schema.String;
+                        readonly observedAt: Schema.DateTimeUtcFromString;
+                    }>;
+                }>;
+                readonly recordSucceeded: Schema.TaggedStruct<"recordSucceeded", {
+                    readonly receipt: Schema.Struct<{
+                        readonly 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">;
+        history: Schema.Struct.ReadonlySide<{
+            readonly commandDigest: Schema.brand<Schema.String, "GovernedActionCommandDigest">;
+            readonly schemaVersion: Schema.Literal<1>;
+            readonly transitionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionTransitionId">;
+            readonly previousTransitionId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionTransitionId">>;
+            readonly commandId: Schema.brand<Schema.String, string>;
+            readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
+            readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            readonly sequence: Schema.Int;
+            readonly fromState: Schema.NullOr<Schema.Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>>;
+            readonly toState: Schema.Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>;
+            readonly actionEnvelopeDigest: Schema.brand<Schema.String, string>;
+            readonly command: Schema.TaggedUnion<{
+                readonly propose: Schema.TaggedStruct<"propose", {}>;
+                readonly authorize: Schema.TaggedStruct<"authorize", {
+                    readonly authorizationId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionAuthorizationId">;
+                }>;
+                readonly deny: Schema.TaggedStruct<"deny", {
+                    readonly reason: Schema.Literals<readonly ["revision-changed", "evidence-stale", "evidence-invalid", "policy-denied", "session-invalid", "capability-changed", "plugin-unavailable", "preflight-blocked"]>;
+                    readonly safeSummary: Schema.String;
+                }>;
+                readonly expire: Schema.TaggedStruct<"expire", {
+                    readonly reason: Schema.Literals<readonly ["proposal-expired", "authorization-expired"]>;
+                }>;
+                readonly cancel: Schema.TaggedStruct<"cancel", {
+                    readonly safeSummary: Schema.String;
+                }>;
+                readonly start: Schema.TaggedStruct<"start", {
+                    readonly attemptId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionAttemptId">;
+                }>;
+                readonly requestCancellation: Schema.TaggedStruct<"requestCancellation", {
+                    readonly safeSummary: Schema.String;
+                }>;
+                readonly recordAccepted: Schema.TaggedStruct<"recordAccepted", {
+                    readonly receipt: Schema.Struct<{
+                        readonly status: Schema.Literal<"accepted">;
+                        readonly reconciliationKey: Schema.brand<Schema.String, string>;
+                        readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        readonly safeSummary: Schema.String;
+                        readonly observedAt: Schema.DateTimeUtcFromString;
+                    }>;
+                }>;
+                readonly recordSucceeded: Schema.TaggedStruct<"recordSucceeded", {
+                    readonly receipt: Schema.Struct<{
+                        readonly 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">[];
+        authorization: Schema.Struct.ReadonlySide<{
+            readonly schemaVersion: Schema.Literal<1>;
+            readonly authorizationId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionAuthorizationId">;
+            readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
+            readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+            readonly pluginConnectionRevision: Schema.brand<Schema.Int, "GovernedActionPluginConnectionRevision">;
+            readonly pluginConnectionAuthorityDigest: Schema.brand<Schema.String, string>;
+            readonly actionEnvelopeDigest: Schema.brand<Schema.String, string>;
+            readonly idempotencyKey: Schema.brand<Schema.String, "GovernedActionIdempotencyKey">;
+            readonly payloadDigest: Schema.brand<Schema.String, "PluginActionPayloadDigest">;
+            readonly evidenceSetDigest: Schema.brand<Schema.String, string>;
+            readonly policyDigest: Schema.brand<Schema.String, string>;
+            readonly expectedRevision: Schema.brand<Schema.String, "Revision">;
+            readonly capabilityVersion: Schema.Int;
+            readonly actor: Schema.TaggedStruct<"human", {
+                readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+            }>;
+            readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+            readonly sessionPermission: Schema.Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
+            readonly sessionExpiresAt: Schema.DateTimeUtcFromString;
+            readonly requiredPermission: Schema.Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
+            readonly authorizedAt: Schema.DateTimeUtcFromString;
+            readonly expiresAt: Schema.DateTimeUtcFromString;
+        }, "Type"> | null;
+        policyEvaluation: Schema.Struct.ReadonlySide<{
+            readonly schemaVersion: Schema.Literal<1>;
+            readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
+            readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            readonly policy: Schema.Struct<{
+                readonly policyId: Schema.brand<Schema.String, string>;
+                readonly policyVersion: Schema.Int;
+                readonly policyDigest: Schema.brand<Schema.String, string>;
+                readonly requiredPermission: Schema.Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
+            }>;
+            readonly payloadDigest: Schema.brand<Schema.String, "PluginActionPayloadDigest">;
+            readonly evidenceSetDigest: Schema.brand<Schema.String, string>;
+            readonly expectedRevision: Schema.brand<Schema.String, "Revision">;
+            readonly decision: Schema.Literals<readonly ["allowed", "denied"]>;
+            readonly evaluatedAt: Schema.DateTimeUtcFromString;
+        }, "Type"> | null;
+        attempt: Schema.Struct.ReadonlySide<{
+            readonly schemaVersion: Schema.Literal<1>;
+            readonly attemptId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionAttemptId">;
+            readonly authorizationId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionAuthorizationId">;
+            readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
+            readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+            readonly idempotencyKey: Schema.brand<Schema.String, "GovernedActionIdempotencyKey">;
+            readonly attemptNumber: Schema.Literal<1>;
+            readonly actionEnvelopeDigest: Schema.brand<Schema.String, string>;
+            readonly expectedRevision: Schema.brand<Schema.String, "Revision">;
+            readonly policyEvaluationDigest: Schema.brand<Schema.String, string>;
+            readonly preflight: Schema.TaggedStruct<"ready", {
+                readonly checkedRevision: Schema.brand<Schema.String, "Revision">;
+                readonly checkedAt: Schema.DateTimeUtcFromString;
+            }>;
+            readonly startedAt: Schema.DateTimeUtcFromString;
+        }, "Type"> | null;
+    }, import("../errors.ts").RecordNotFoundError | import("../errors.ts").PersistenceOperationError | import("../errors.ts").PersistedRecordError | import("../errors.ts").QuarantineWriteError | import("effect/unstable/sql/SqlError").SqlError | GovernedActionInputError | import("./governed-action/quarantine.ts").MalformedGovernedActionRecord, never>;
+}, never, import("effect/Crypto").Crypto | import("../Database.ts").Database | import("./quarantineRepository.ts").QuarantineRepository>;
+/** Deep server-only repository for governed action authority, lifecycle, and audit. */
+export interface GovernedActionRepositoryService extends Success<typeof makeGovernedActionRepository> {
+}
+declare const GovernedActionRepository_base: Context.ServiceClass<GovernedActionRepository, "@knpkv/control-center/GovernedActionRepository", GovernedActionRepositoryService>;
+/** Atomic governed-action persistence service. It never exposes provider execution capability. */
+export declare class GovernedActionRepository extends GovernedActionRepository_base {
+    /** Layer binding governed-action persistence to database, cryptography, and quarantine. */
+    static readonly layer: Layer.Layer<GovernedActionRepository, never, import("effect/Crypto").Crypto | import("../Database.ts").Database | import("./quarantineRepository.ts").QuarantineRepository>;
+}
+//# sourceMappingURL=governedActionRepository.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"governedActionRepository.d.ts","sourceRoot":"","sources":["../../../../../src/server/persistence/repositories/governedActionRepository.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAA;AACzC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAC5C,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,EAEL,wBAAwB,EAEzB,MAAM,+BAA+B,CAAA;AAItC,cAAc,+BAA+B,CAAA;AAE7C,QAAA,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wIAmBhC,CAAA;AAEF,uFAAuF;AACvF,MAAM,WAAW,+BAAgC,SAAQ,OAAO,CAAC,OAAO,4BAA4B,CAAC;CAAG;;AAExG,kGAAkG;AAClG,qBAAa,wBAAyB,SAAQ,6BAGO;IACnD,2FAA2F;IAC3F,MAAM,CAAC,QAAQ,CAAC,KAAK,8KAAuE;CAC7F"}

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

@@ -0,0 +1,26 @@
+/** Workspace, plugin, entity, release, people, blob-metadata, and quarantine repositories. */
+export * from "./agentJobModels.js";
+export * from "./agentJobRepository.js";
+export * from "./authorizedShareRepository.js";
+export * from "./contentBlobMetadataRepository.js";
+export * from "./deliveryGraphRepository.js";
+export * from "./domainEventModels.js";
+export * from "./domainEventRepository.js";
+export * from "./entityRepository.js";
+export * from "./governedActionRepository.js";
+export * from "./models.js";
+export * from "./peopleRepository.js";
+export * from "./pluginConfigurationModels.js";
+export * from "./pluginConfigurationRepository.js";
+export * from "./pluginConnectionRepository.js";
+export * from "./pluginRuntimeModels.js";
+export * from "./pluginRuntimeRepository.js";
+export * from "./providerAccountRepository.js";
+export * from "./quarantineRepository.js";
+export * from "./readinessRepository.js";
+export * from "./relationshipRepairProposalRepository.js";
+export * from "./releaseRepository.js";
+export * from "./timelineExportAuditRepository.js";
+export * from "./timelineRepository.js";
+export * from "./workspaceRepository.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/server/server/persistence/repositories/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/server/persistence/repositories/index.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,cAAc,qBAAqB,CAAA;AACnC,cAAc,yBAAyB,CAAA;AACvC,cAAc,gCAAgC,CAAA;AAC9C,cAAc,oCAAoC,CAAA;AAClD,cAAc,8BAA8B,CAAA;AAC5C,cAAc,wBAAwB,CAAA;AACtC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,uBAAuB,CAAA;AACrC,cAAc,+BAA+B,CAAA;AAC7C,cAAc,aAAa,CAAA;AAC3B,cAAc,uBAAuB,CAAA;AACrC,cAAc,gCAAgC,CAAA;AAC9C,cAAc,oCAAoC,CAAA;AAClD,cAAc,iCAAiC,CAAA;AAC/C,cAAc,0BAA0B,CAAA;AACxC,cAAc,8BAA8B,CAAA;AAC5C,cAAc,gCAAgC,CAAA;AAC9C,cAAc,2BAA2B,CAAA;AACzC,cAAc,0BAA0B,CAAA;AACxC,cAAc,2CAA2C,CAAA;AACzD,cAAc,wBAAwB,CAAA;AACtC,cAAc,oCAAoC,CAAA;AAClD,cAAc,yBAAyB,CAAA;AACvC,cAAc,0BAA0B,CAAA"}

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

@@ -0,0 +1,38 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import type * as SqlClient from "effect/unstable/sql/SqlClient";
+import * as SqlError from "effect/unstable/sql/SqlError";
+import type { WorkspaceId } from "../../../domain/identifiers.js";
+import { PersistenceOperationError, RecordAlreadyExistsError } from "../errors.js";
+/** Parameters shared by optimistic-concurrency failure resolution. */
+export interface ResolveCasFailureOptions {
+    readonly workspaceId: WorkspaceId;
+    readonly recordKind: string;
+    readonly recordKey: string;
+    readonly expectedRevision: number;
+    readonly findActualRevision: Effect.Effect<Option.Option<{
+        readonly revision: number;
+    }>, unknown>;
+}
+/** Identity used to translate a unique-constraint violation into a domain error. */
+export interface AlreadyExistsOptions {
+    readonly workspaceId: WorkspaceId;
+    readonly recordKind: string;
+    readonly recordKey: string;
+}
+type PersistenceInfrastructureError = SqlError.SqlError | Schema.SchemaError;
+/** Preserve operational SQL failures while classifying duplicate identities. */
+export declare const mapAlreadyExists: (options: AlreadyExistsOptions) => <Success, Failure, Requirements>(effect: Effect.Effect<Success, Failure, Requirements>) => Effect.Effect<Success, RecordAlreadyExistsError | Failure, Requirements>;
+/** Hide driver details at repository boundaries while retaining an internal diagnostic. */
+export declare function mapPersistenceOperation(operation: string): <Success, Failure, Requirements>(effect: Effect.Effect<Success, Failure, Requirements>) => Effect.Effect<Success, Exclude<Failure, PersistenceInfrastructureError> | PersistenceOperationError, Requirements>;
+/** Read the affected-row count of the immediately preceding SQLite statement. */
+export declare const readChanges: (sql: SqlClient.SqlClient) => Effect.Effect<number, unknown>;
+/** Build a workspace-scoped current-revision lookup for a mutable record. */
+export declare const revisionLookup: (execute: () => Effect.Effect<ReadonlyArray<unknown>, unknown>) => Effect.Effect<Option.Option<{
+    readonly revision: number;
+}>, unknown>;
+/** Distinguish a missing record from an optimistic-concurrency conflict. */
+export declare const resolveCasFailure: (options: ResolveCasFailureOptions) => Effect.Effect<never, unknown, never>;
+export {};
+//# sourceMappingURL=internal.d.ts.map

package/dist/server/server/persistence/repositories/internal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../../../../../src/server/persistence/repositories/internal.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,SAAS,MAAM,+BAA+B,CAAA;AAC/D,OAAO,KAAK,QAAQ,MAAM,8BAA8B,CAAA;AAGxD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAA;AACjE,OAAO,EACL,yBAAyB,EACzB,wBAAwB,EAGzB,MAAM,cAAc,CAAA;AAKrB,sEAAsE;AACtE,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAA;IACjC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAA;IACjC,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC;QAAE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,EAAE,OAAO,CAAC,CAAA;CAClG;AAED,oFAAoF;AACpF,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAA;IACjC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAC3B;AAKD,KAAK,8BAA8B,GAAG,QAAQ,CAAC,QAAQ,GAAG,MAAM,CAAC,WAAW,CAAA;AAK5E,gFAAgF;AAChF,eAAO,MAAM,gBAAgB,GAC1B,SAAS,oBAAoB,MAC7B,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,QAAQ,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,YAAY,CAAC,6EAQnF,CAAA;AAEL,2FAA2F;AAC3F,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,MAAM,GAChB,CAAC,OAAO,EAAE,OAAO,EAAE,YAAY,EAChC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,YAAY,CAAC,KAClD,MAAM,CAAC,MAAM,CAChB,OAAO,EACP,OAAO,CAAC,OAAO,EAAE,8BAA8B,CAAC,GAAG,yBAAyB,EAC5E,YAAY,CACb,CAAA;AAkBD,iFAAiF;AACjF,eAAO,MAAM,WAAW,GAAI,KAAK,SAAS,CAAC,SAAS,KAAG,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAOnF,CAAA;AAED,6EAA6E;AAC7E,eAAO,MAAM,cAAc,GACzB,SAAS,MAAM,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,KAC5D,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC;IAAE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,EAAE,OAAO,CACsB,CAAA;AAE5F,4EAA4E;AAC5E,eAAO,MAAM,iBAAiB,6EAkB5B,CAAA"}