@knpkv/control-center 0.1.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../../../../../../src/server/persistence/repositories/governed-action/contract.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,EAUL,0BAA0B,EAC3B,MAAM,4CAA4C,CAAA;AASnD,gFAAgF;AAChF,eAAO,MAAM,0BAA0B,4FAAgB,CAAA;AAEvD,8CAA8C;AAC9C,MAAM,MAAM,0BAA0B,GAAG,OAAO,0BAA0B,CAAC,IAAI,CAAA;AAE/E,sFAAsF;AACtF,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQxC,CAAA;AAEF,mCAAmC;AACnC,MAAM,MAAM,6BAA6B,GAAG,OAAO,6BAA6B,CAAC,IAAI,CAAA;AA+BrF,0GAA0G;AAC1G,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmHrC,CAAA;AAED,oDAAoD;AACpD,MAAM,MAAM,yBAAyB,GAAG,OAAO,yBAAyB,CAAC,IAAI,CAAA;AAE7E,yCAAyC;AACzC,eAAO,MAAM,uBAAuB;;;EAGlC,CAAA;AAEF,sCAAsC;AACtC,MAAM,MAAM,uBAAuB,GAAG,OAAO,uBAAuB,CAAC,IAAI,CAAA;AAEzE,gFAAgF;AAChF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQ/B,CAAA;AAEF,yCAAyC;AACzC,MAAM,MAAM,oBAAoB,GAAG,OAAO,oBAAoB,CAAC,IAAI,CAAA;AAEnE,sFAAsF;AACtF,MAAM,MAAM,0BAA0B,GAClC;IAAE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAAC,QAAQ,CAAC,UAAU,EAAE,0BAA0B,CAAA;CAAE,GAC/E;IAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,UAAU,EAAE,0BAA0B,CAAA;CAAE,CAAA;;;;;AAElF,uFAAuF;AACvF,qBAAa,wBAAyB,SAAQ,6BAY7C;CAAG"}

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

@@ -0,0 +1,22 @@
+import * as Effect from "effect/Effect";
+import type { PersistedRecordError } from "../../errors.js";
+import type { QuarantineDiagnosticSummary, QuarantineReasonCode, QuarantineRecordKind } from "../models.js";
+type GovernedActionRecordKind = Extract<QuarantineRecordKind, "governed-action" | "governed-action-policy-evaluation" | "governed-action-authorization" | "governed-action-attempt" | "governed-action-transition" | "governed-action-audit">;
+interface GovernedActionQuarantineDiagnostic {
+    readonly diagnosticCode: QuarantineReasonCode;
+    readonly diagnosticSummary: QuarantineDiagnosticSummary;
+    readonly recordKind: GovernedActionRecordKind;
+}
+/** Internal carrier retaining an untrusted row only until quarantine runs after rollback. */
+export declare class MalformedGovernedActionRecord {
+    readonly _tag = "MalformedGovernedActionRecord";
+    readonly error: PersistedRecordError;
+    readonly row: unknown;
+    constructor(error: PersistedRecordError, row: unknown);
+}
+/** Attach an ephemeral raw row to a bounded persisted-record failure. */
+export declare const captureMalformedGovernedActionRow: (row: unknown) => <Success, Failure, Requirements>(effect: Effect.Effect<Success, Failure, Requirements>) => Effect.Effect<Success, MalformedGovernedActionRecord | Exclude<Failure, Failure & PersistedRecordError>, Requirements>;
+/** Fixed, non-secret quarantine metadata for governed-action corruption. */
+export declare const governedActionQuarantineDiagnostic: (error: PersistedRecordError) => GovernedActionQuarantineDiagnostic | null;
+export {};
+//# sourceMappingURL=quarantine.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"quarantine.d.ts","sourceRoot":"","sources":["../../../../../../src/server/persistence/repositories/governed-action/quarantine.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAA;AAC3D,OAAO,KAAK,EAAE,2BAA2B,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAA;AAE3G,KAAK,wBAAwB,GAAG,OAAO,CACrC,oBAAoB,EAClB,iBAAiB,GACjB,mCAAmC,GACnC,+BAA+B,GAC/B,yBAAyB,GACzB,4BAA4B,GAC5B,uBAAuB,CAC1B,CAAA;AAED,UAAU,kCAAkC;IAC1C,QAAQ,CAAC,cAAc,EAAE,oBAAoB,CAAA;IAC7C,QAAQ,CAAC,iBAAiB,EAAE,2BAA2B,CAAA;IACvD,QAAQ,CAAC,UAAU,EAAE,wBAAwB,CAAA;CAC9C;AAED,6FAA6F;AAC7F,qBAAa,6BAA6B;IACxC,QAAQ,CAAC,IAAI,mCAAkC;IAC/C,QAAQ,CAAC,KAAK,EAAE,oBAAoB,CAAA;IACpC,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAA;gBAET,KAAK,EAAE,oBAAoB,EAAE,GAAG,EAAE,OAAO;CAItD;AAED,yEAAyE;AACzE,eAAO,MAAM,iCAAiC,GAC3C,KAAK,OAAO,MAAM,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,QAAQ,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,YAAY,CAAC,2HAKrG,CAAA;AAEL,4EAA4E;AAC5E,eAAO,MAAM,kCAAkC,GAC7C,OAAO,oBAAoB,KAC1B,kCAAkC,GAAG,IAqEvC,CAAA"}

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

@@ -0,0 +1,452 @@
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { Database } from "../../Database.js";
+import { PersistedRecordError, RecordNotFoundError } from "../../errors.js";
+/** Build verified governed-action aggregate reads over one transaction-local SQL client. */
+export declare const makeGovernedActionRead: Effect.Effect<{
+    read: (request: 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">;
+    }, "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: 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;
+    }, RecordNotFoundError | import("../../errors.js").PersistenceOperationError | PersistedRecordError | import("effect/unstable/sql/SqlError").SqlError | import("./quarantine.js").MalformedGovernedActionRecord, import("effect/Crypto").Crypto>;
+}, never, Database>;
+//# sourceMappingURL=read.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"read.d.ts","sourceRoot":"","sources":["../../../../../../src/server/persistence/repositories/governed-action/read.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AASvC,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AAC5C,OAAO,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AAmE3E,4FAA4F;AAC5F,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAqXjC,CAAA"}

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

@@ -0,0 +1,115 @@
+import * as Schema from "effect/Schema";
+/** Driver row retained without trust until repository-controlled decoding and verification. */
+export declare const RawGovernedActionRow: Schema.$Record<Schema.String, Schema.Unknown>;
+/** Persisted immutable action envelope plus its materialized lifecycle head. */
+export declare const GovernedActionRow: Schema.Struct<{
+    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;
+}>;
+/** Persisted canonical policy decision bound to one governed action. */
+export declare const GovernedActionPolicyEvaluationRow: Schema.Struct<{
+    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;
+}>;
+/** Persisted immutable human authorization bound to an exact envelope. */
+export declare const GovernedActionAuthorizationRow: Schema.Struct<{
+    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;
+}>;
+/** Persisted durable dispatch intent bound to authorization and fresh policy. */
+export declare const GovernedActionAttemptRow: Schema.Struct<{
+    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;
+}>;
+/** Persisted transition with exact command, cause, result-lineage, and replay projections. */
+export declare const GovernedActionTransitionRow: Schema.Struct<{
+    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;
+}>;
+/** Persisted audit event whose payload is the exact canonical transition JSON. */
+export declare const GovernedActionAuditEventRow: Schema.Struct<{
+    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;
+}>;
+/** Decode an untrusted driver result without allowing malformed rows into repository logic. */
+export declare const decodeGovernedActionRows: <SchemaType extends Schema.Top>(schema: SchemaType, rows: unknown) => import("effect/Effect").Effect<readonly SchemaType["Type"][], Schema.SchemaError, SchemaType["DecodingServices"]>;
+//# sourceMappingURL=rows.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rows.d.ts","sourceRoot":"","sources":["../../../../../../src/server/persistence/repositories/governed-action/rows.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAmEvC,+FAA+F;AAC/F,eAAO,MAAM,oBAAoB,+CAA+C,CAAA;AAEhF,gFAAgF;AAChF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;EAmB5B,CAAA;AAEF,wEAAwE;AACxE,eAAO,MAAM,iCAAiC;;;;;;;EAO5C,CAAA;AAEF,0EAA0E;AAC1E,eAAO,MAAM,8BAA8B;;;;;;;;;;EAUzC,CAAA;AAEF,iFAAiF;AACjF,eAAO,MAAM,wBAAwB;;;;;;;;;;EAUnC,CAAA;AAEF,8FAA8F;AAC9F,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmCtC,CAAA;AAEF,kFAAkF;AAClF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;EAgBtC,CAAA;AAEF,+FAA+F;AAC/F,eAAO,MAAM,wBAAwB,GAAI,UAAU,SAAS,MAAM,CAAC,GAAG,EAAE,QAAQ,UAAU,EAAE,MAAM,OAAO,sHACjD,CAAA"}