@knpkv/control-center 0.1.0

package/dist/server/server/governance/governedActionDigests.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"governedActionDigests.d.ts","sourceRoot":"","sources":["../../../../src/server/governance/governedActionDigests.ts"],"names":[],"mappings":"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"}

package/dist/server/server/governance/internal/GovernedActionExecutionEngine.d.ts

@@ -0,0 +1,55 @@
+import * as Cause from "effect/Cause";
+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 type { GovernedActionState } from "../../../domain/governedAction/index.js";
+import type { PluginFailure } from "../../plugins/failures.js";
+import { AuthorizedPluginExecutorMap } from "../../plugins/internal/AuthorizedPluginExecutorMap.js";
+import { GovernedActionExecutionStore } from "./GovernedActionExecutionStore.js";
+declare const GovernedActionExecutionInputError_base: Schema.Class<GovernedActionExecutionInputError, Schema.TaggedStruct<"GovernedActionExecutionInputError", {}>, Cause.YieldableError>;
+/** Invalid untrusted action identity at the private worker boundary. */
+export declare class GovernedActionExecutionInputError extends GovernedActionExecutionInputError_base {
+}
+declare const GovernedActionReconciliationDeadlineExceeded_base: Schema.Class<GovernedActionReconciliationDeadlineExceeded, Schema.TaggedStruct<"GovernedActionReconciliationDeadlineExceeded", {}>, Cause.YieldableError>;
+/** The recovery claim expired before the provider reconciliation completed. */
+declare class GovernedActionReconciliationDeadlineExceeded extends GovernedActionReconciliationDeadlineExceeded_base {
+}
+/** Stable result of advancing one action without exposing an execution capability. */
+export type GovernedActionExecutionResult = {
+    readonly _tag: "inactive";
+    readonly state: GovernedActionState;
+} | {
+    readonly _tag: "advanced";
+    readonly state: GovernedActionState;
+};
+/** Bounded process-start reconciliation outcome without action payloads or provider data. */
+export interface GovernedActionRecoverySweepResult {
+    readonly advanced: number;
+    readonly attempted: number;
+    readonly failed: number;
+    readonly inactive: number;
+}
+declare const makeGovernedActionExecutionEngine: Effect.Effect<{
+    recoverEligible: () => Effect.Effect<{
+        attempted: number;
+        advanced: number;
+        inactive: number;
+        failed: number;
+    }, import("./GovernedActionExecutionStore.js").GovernedActionExecutionStoreError, never>;
+    run: (input: unknown) => Effect.Effect<import("./GovernedActionExecutionStore.js").GovernedActionInactiveExecution | {
+        _tag: "advanced";
+        state: "unknown" | "proposed" | "expired" | "failed" | "cancelled" | "succeeded" | "cancel-requested" | "denied" | "authorized" | "started" | "cancel-requested-unknown";
+    }, PluginFailure | import("./GovernedActionExecutionStore.js").GovernedActionExecutionStoreError | GovernedActionExecutionInputError | GovernedActionReconciliationDeadlineExceeded, never>;
+}, never, GovernedActionExecutionStore | AuthorizedPluginExecutorMap>;
+/** Internal execution engine service; only private worker composition may consume this tag. */
+export interface GovernedActionExecutionEngineService extends Success<typeof makeGovernedActionExecutionEngine> {
+}
+declare const GovernedActionExecutionEngine_base: Context.ServiceClass<GovernedActionExecutionEngine, "@knpkv/control-center/internal/GovernedActionExecutionEngine", GovernedActionExecutionEngineService>;
+/** State-driven owner of scoped preflight, one-use dispatch, and non-replaying recovery. */
+export declare class GovernedActionExecutionEngine extends GovernedActionExecutionEngine_base {
+    static readonly layer: Layer.Layer<GovernedActionExecutionEngine, never, GovernedActionExecutionStore | AuthorizedPluginExecutorMap>;
+}
+export {};
+//# sourceMappingURL=GovernedActionExecutionEngine.d.ts.map

package/dist/server/server/governance/internal/GovernedActionExecutionEngine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GovernedActionExecutionEngine.d.ts","sourceRoot":"","sources":["../../../../../src/server/governance/internal/GovernedActionExecutionEngine.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAA;AAEzC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAC5C,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAErC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,EAAE,mBAAmB,EAAgC,MAAM,yCAAyC,CAAA;AAEhH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAA;AAE9D,OAAO,EAAE,2BAA2B,EAAE,MAAM,uDAAuD,CAAA;AAGnG,OAAO,EAKL,4BAA4B,EAE7B,MAAM,mCAAmC,CAAA;;AAE1C,wEAAwE;AACxE,qBAAa,iCAAkC,SAAQ,sCAGtD;CAAG;;AAQJ,+EAA+E;AAC/E,cAAM,4CACJ,SAAQ,iDAGP;CACD;AAEF,sFAAsF;AACtF,MAAM,MAAM,6BAA6B,GACrC;IAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,mBAAmB,CAAA;CAAE,GAClE;IAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,mBAAmB,CAAA;CAAE,CAAA;AAEtE,6FAA6F;AAC7F,MAAM,WAAW,iCAAiC;IAChD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAC1B;AAmCD,QAAA,MAAM,iCAAiC;;;;;;;;;;;qEAoMrC,CAAA;AAEF,+FAA+F;AAC/F,MAAM,WAAW,oCAAqC,SAAQ,OAAO,CAAC,OAAO,iCAAiC,CAAC;CAAG;;AAElH,4FAA4F;AAC5F,qBAAa,6BAA8B,SAAQ,kCAGgB;IACjE,MAAM,CAAC,QAAQ,CAAC,KAAK,gHAAiF;CACvG"}

package/dist/server/server/governance/internal/GovernedActionExecutionStore.d.ts

@@ -0,0 +1,116 @@
+import * as Context from "effect/Context";
+import type * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { type GovernedActionState, type GovernedActionUnknownOutcome } from "../../../domain/governedAction/index.js";
+import type { AuthorizedPluginActionV1, BlockedPluginActionPreflightV1, PluginActionDispatchResultV1, PluginActionReconciliationRequestV1, PluginActionReconciliationResultV1, ReadyPluginActionPreflightV1 } from "../../../domain/plugins/actions.js";
+import type { UtcTimestamp } from "../../../domain/utcTimestamp.js";
+import type { PluginRuntimeAuthorityToken } from "../../plugins/internal/PluginRuntimeAuthority.js";
+import type { PluginRuntimeScope } from "../../plugins/PluginConnectionMap.js";
+import type { GovernedActionPermitToken, GovernedActionPreparationToken, GovernedActionRecoveryToken } from "./execution-store/tokens.js";
+/** Workspace-scoped action identity accepted by the sealed execution worker. */
+export declare const GovernedActionExecutionReference: 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">;
+}>;
+/** Decoded execution identity. */
+export type GovernedActionExecutionReference = typeof GovernedActionExecutionReference.Type;
+declare const GovernedActionExecutionStoreError_base: Schema.Class<GovernedActionExecutionStoreError, Schema.TaggedStruct<"GovernedActionExecutionStoreError", {
+    readonly operation: Schema.Literals<readonly ["inspect", "list-recovery", "expire-recovery-claims", "begin", "block", "record-dispatch", "record-recovery-unavailable", "record-unknown", "record-reconciliation"]>;
+    readonly reason: Schema.Literals<readonly ["authority-changed", "conflict", "invalid-record", "not-found", "persistence-unavailable"]>;
+}>, import("effect/Cause").YieldableError>;
+/** Closed failure from the atomic authority/start and durable outcome boundary. */
+export declare class GovernedActionExecutionStoreError extends GovernedActionExecutionStoreError_base {
+}
+export interface GovernedActionInactiveExecution {
+    readonly _tag: "inactive";
+    readonly state: GovernedActionState;
+}
+/** Immutable preparation data only; it grants no provider execution authority. */
+export interface GovernedActionDispatchPreparation {
+    readonly _tag: "dispatch";
+    readonly preparationToken: GovernedActionPreparationToken;
+    readonly scope: PluginRuntimeScope;
+    readonly request: AuthorizedPluginActionV1;
+}
+/** Recovery plan for durable started/unknown work; reconciliation never replays the mutation. */
+export interface GovernedActionRecoveryPreparation {
+    readonly _tag: "reconcile";
+    readonly recoveryToken: GovernedActionRecoveryToken;
+    readonly runtimeAuthorityToken: PluginRuntimeAuthorityToken;
+    readonly reconciliationDeadline: UtcTimestamp;
+    readonly scope: PluginRuntimeScope;
+    readonly request: PluginActionReconciliationRequestV1;
+}
+export type GovernedActionExecutionPlan = GovernedActionInactiveExecution | GovernedActionDispatchPreparation | GovernedActionRecoveryPreparation;
+/** One-use permit returned only by an atomic live-authority verification plus start commit. */
+export interface GovernedActionDispatchPermit {
+    readonly _tag: "permitted";
+    readonly permitToken: GovernedActionPermitToken;
+    readonly runtimeAuthorityToken: PluginRuntimeAuthorityToken;
+    readonly dispatchDeadline: UtcTimestamp;
+    readonly leaseExpiresAt: UtcTimestamp;
+    readonly recovery: {
+        readonly strategy: "idempotency";
+        readonly capabilityVersion: 1;
+    };
+    readonly scope: PluginRuntimeScope;
+    readonly request: AuthorizedPluginActionV1;
+}
+export type GovernedActionBeginResult = GovernedActionInactiveExecution | GovernedActionDispatchPermit;
+/**
+ * Persistence-side half of governed execution.
+ *
+ * `begin` must reload session, evidence, target, policy, and plugin authority in one database
+ * snapshot, sample its trusted clock, match the leased runtime authority token, require negotiated
+ * idempotency reconciliation, and atomically commit `started` plus a recovery lease; replay never
+ * returns `permitted`. The returned provider-call deadline must be strictly before lease expiry.
+ * While that lease is live `inspect` returns inactive. Recovery becomes eligible only after lease
+ * expiry plus a safety interval that exceeds the maximum provider-call deadline; an immediate
+ * not-found after timeout is never terminal. Recovery plans retain the exact runtime-authority
+ * token that owned dispatch. Outcome methods
+ * must append the provider result to a durable inbox before folding the current lifecycle head,
+ * so concurrent cancellation cannot discard a receipt. `inspect` must return `reconcile` for
+ * stranded `started` work, using a null reconciliation key to recover by idempotency identity.
+ */
+export interface GovernedActionExecutionStoreV1 {
+    /** Stable bounded identities whose recovery safety interval has elapsed. */
+    readonly recoveryCandidates: Effect.Effect<ReadonlyArray<GovernedActionExecutionReference>, GovernedActionExecutionStoreError>;
+    readonly inspect: (reference: GovernedActionExecutionReference) => Effect.Effect<GovernedActionExecutionPlan, GovernedActionExecutionStoreError>;
+    readonly begin: (input: {
+        readonly preparationToken: GovernedActionPreparationToken;
+        readonly preflight: ReadyPluginActionPreflightV1;
+        readonly runtimeAuthorityToken: PluginRuntimeAuthorityToken;
+        readonly scope: PluginRuntimeScope;
+    }) => Effect.Effect<GovernedActionBeginResult, GovernedActionExecutionStoreError>;
+    readonly recordBlocked: (input: {
+        readonly preparationToken: GovernedActionPreparationToken;
+        readonly preflight: BlockedPluginActionPreflightV1;
+        readonly observedAt: UtcTimestamp;
+        readonly scope: PluginRuntimeScope;
+    }) => Effect.Effect<GovernedActionState, GovernedActionExecutionStoreError>;
+    readonly recordDispatch: (input: {
+        readonly permitToken: GovernedActionPermitToken;
+        readonly result: PluginActionDispatchResultV1;
+        readonly observedAt: UtcTimestamp;
+    }) => Effect.Effect<GovernedActionState, GovernedActionExecutionStoreError>;
+    readonly recordUnknown: (input: {
+        readonly permitToken: GovernedActionPermitToken;
+        readonly outcome: GovernedActionUnknownOutcome;
+    }) => Effect.Effect<GovernedActionState, GovernedActionExecutionStoreError>;
+    readonly recordRecoveryUnavailable: (input: {
+        readonly recoveryToken: GovernedActionRecoveryToken;
+        readonly observedAt: UtcTimestamp;
+        readonly reason: "runtime-generation-unavailable";
+    }) => Effect.Effect<GovernedActionState, GovernedActionExecutionStoreError>;
+    readonly recordReconciliation: (input: {
+        readonly recoveryToken: GovernedActionRecoveryToken;
+        readonly result: PluginActionReconciliationResultV1;
+        readonly observedAt: UtcTimestamp;
+    }) => Effect.Effect<GovernedActionState, GovernedActionExecutionStoreError>;
+}
+declare const GovernedActionExecutionStore_base: Context.ServiceClass<GovernedActionExecutionStore, "@knpkv/control-center/internal/GovernedActionExecutionStore", GovernedActionExecutionStoreV1>;
+/** Internal atomic authority and outcome port; no route or agent layer may provide it. */
+export declare class GovernedActionExecutionStore extends GovernedActionExecutionStore_base {
+}
+export {};
+//# sourceMappingURL=GovernedActionExecutionStore.d.ts.map

package/dist/server/server/governance/internal/GovernedActionExecutionStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GovernedActionExecutionStore.d.ts","sourceRoot":"","sources":["../../../../../src/server/governance/internal/GovernedActionExecutionStore.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAA;AACzC,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAA;AAC5C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,EAAE,KAAK,mBAAmB,EAAE,KAAK,4BAA4B,EAAE,MAAM,yCAAyC,CAAA;AAErH,OAAO,KAAK,EACV,wBAAwB,EACxB,8BAA8B,EAC9B,4BAA4B,EAC5B,mCAAmC,EACnC,kCAAkC,EAClC,4BAA4B,EAC7B,MAAM,oCAAoC,CAAA;AAC3C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAA;AACnE,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,kDAAkD,CAAA;AACnG,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sCAAsC,CAAA;AAC9E,OAAO,KAAK,EACV,yBAAyB,EACzB,8BAA8B,EAC9B,2BAA2B,EAC5B,MAAM,6BAA6B,CAAA;AAEpC,gFAAgF;AAChF,eAAO,MAAM,gCAAgC;;;EAG3C,CAAA;AAEF,kCAAkC;AAClC,MAAM,MAAM,gCAAgC,GAAG,OAAO,gCAAgC,CAAC,IAAI,CAAA;;;;;AAE3F,mFAAmF;AACnF,qBAAa,iCAAkC,SAAQ,sCAsBtD;CAAG;AAEJ,MAAM,WAAW,+BAA+B;IAC9C,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;IACzB,QAAQ,CAAC,KAAK,EAAE,mBAAmB,CAAA;CACpC;AAED,kFAAkF;AAClF,MAAM,WAAW,iCAAiC;IAChD,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;IACzB,QAAQ,CAAC,gBAAgB,EAAE,8BAA8B,CAAA;IACzD,QAAQ,CAAC,KAAK,EAAE,kBAAkB,CAAA;IAClC,QAAQ,CAAC,OAAO,EAAE,wBAAwB,CAAA;CAC3C;AAED,iGAAiG;AACjG,MAAM,WAAW,iCAAiC;IAChD,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAA;IAC1B,QAAQ,CAAC,aAAa,EAAE,2BAA2B,CAAA;IACnD,QAAQ,CAAC,qBAAqB,EAAE,2BAA2B,CAAA;IAC3D,QAAQ,CAAC,sBAAsB,EAAE,YAAY,CAAA;IAC7C,QAAQ,CAAC,KAAK,EAAE,kBAAkB,CAAA;IAClC,QAAQ,CAAC,OAAO,EAAE,mCAAmC,CAAA;CACtD;AAED,MAAM,MAAM,2BAA2B,GACnC,+BAA+B,GAC/B,iCAAiC,GACjC,iCAAiC,CAAA;AAErC,+FAA+F;AAC/F,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAA;IAC1B,QAAQ,CAAC,WAAW,EAAE,yBAAyB,CAAA;IAC/C,QAAQ,CAAC,qBAAqB,EAAE,2BAA2B,CAAA;IAC3D,QAAQ,CAAC,gBAAgB,EAAE,YAAY,CAAA;IACvC,QAAQ,CAAC,cAAc,EAAE,YAAY,CAAA;IACrC,QAAQ,CAAC,QAAQ,EAAE;QACjB,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAA;QAChC,QAAQ,CAAC,iBAAiB,EAAE,CAAC,CAAA;KAC9B,CAAA;IACD,QAAQ,CAAC,KAAK,EAAE,kBAAkB,CAAA;IAClC,QAAQ,CAAC,OAAO,EAAE,wBAAwB,CAAA;CAC3C;AAED,MAAM,MAAM,yBAAyB,GAAG,+BAA+B,GAAG,4BAA4B,CAAA;AAEtG;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,8BAA8B;IAC7C,4EAA4E;IAC5E,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC,MAAM,CACxC,aAAa,CAAC,gCAAgC,CAAC,EAC/C,iCAAiC,CAClC,CAAA;IACD,QAAQ,CAAC,OAAO,EAAE,CAChB,SAAS,EAAE,gCAAgC,KACxC,MAAM,CAAC,MAAM,CAAC,2BAA2B,EAAE,iCAAiC,CAAC,CAAA;IAClF,QAAQ,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE;QACtB,QAAQ,CAAC,gBAAgB,EAAE,8BAA8B,CAAA;QACzD,QAAQ,CAAC,SAAS,EAAE,4BAA4B,CAAA;QAChD,QAAQ,CAAC,qBAAqB,EAAE,2BAA2B,CAAA;QAC3D,QAAQ,CAAC,KAAK,EAAE,kBAAkB,CAAA;KACnC,KAAK,MAAM,CAAC,MAAM,CAAC,yBAAyB,EAAE,iCAAiC,CAAC,CAAA;IACjF,QAAQ,CAAC,aAAa,EAAE,CAAC,KAAK,EAAE;QAC9B,QAAQ,CAAC,gBAAgB,EAAE,8BAA8B,CAAA;QACzD,QAAQ,CAAC,SAAS,EAAE,8BAA8B,CAAA;QAClD,QAAQ,CAAC,UAAU,EAAE,YAAY,CAAA;QACjC,QAAQ,CAAC,KAAK,EAAE,kBAAkB,CAAA;KACnC,KAAK,MAAM,CAAC,MAAM,CAAC,mBAAmB,EAAE,iCAAiC,CAAC,CAAA;IAC3E,QAAQ,CAAC,cAAc,EAAE,CAAC,KAAK,EAAE;QAC/B,QAAQ,CAAC,WAAW,EAAE,yBAAyB,CAAA;QAC/C,QAAQ,CAAC,MAAM,EAAE,4BAA4B,CAAA;QAC7C,QAAQ,CAAC,UAAU,EAAE,YAAY,CAAA;KAClC,KAAK,MAAM,CAAC,MAAM,CAAC,mBAAmB,EAAE,iCAAiC,CAAC,CAAA;IAC3E,QAAQ,CAAC,aAAa,EAAE,CAAC,KAAK,EAAE;QAC9B,QAAQ,CAAC,WAAW,EAAE,yBAAyB,CAAA;QAC/C,QAAQ,CAAC,OAAO,EAAE,4BAA4B,CAAA;KAC/C,KAAK,MAAM,CAAC,MAAM,CAAC,mBAAmB,EAAE,iCAAiC,CAAC,CAAA;IAC3E,QAAQ,CAAC,yBAAyB,EAAE,CAAC,KAAK,EAAE;QAC1C,QAAQ,CAAC,aAAa,EAAE,2BAA2B,CAAA;QACnD,QAAQ,CAAC,UAAU,EAAE,YAAY,CAAA;QACjC,QAAQ,CAAC,MAAM,EAAE,gCAAgC,CAAA;KAClD,KAAK,MAAM,CAAC,MAAM,CAAC,mBAAmB,EAAE,iCAAiC,CAAC,CAAA;IAC3E,QAAQ,CAAC,oBAAoB,EAAE,CAAC,KAAK,EAAE;QACrC,QAAQ,CAAC,aAAa,EAAE,2BAA2B,CAAA;QACnD,QAAQ,CAAC,MAAM,EAAE,kCAAkC,CAAA;QACnD,QAAQ,CAAC,UAAU,EAAE,YAAY,CAAA;KAClC,KAAK,MAAM,CAAC,MAAM,CAAC,mBAAmB,EAAE,iCAAiC,CAAC,CAAA;CAC5E;;AAED,0FAA0F;AAC1F,qBAAa,4BAA6B,SAAQ,iCAGgB;CAAG"}

package/dist/server/server/governance/internal/GovernedActionPolicyEvaluator.d.ts

@@ -0,0 +1,120 @@
+import * as Context from "effect/Context";
+import * as Crypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import { type GovernedActionPolicyBinding as GovernedActionPolicyBindingType, GovernedActionPolicyEvaluationV1 } from "../../../domain/governedAction/index.js";
+import type { VerifyGovernedActionDispatchAuthorityInput } from "../governedActionAuthority.js";
+import { type GovernedActionDigestError } from "../governedActionDigests.js";
+/** Canonical declarative policy material; executable source text is never hashed. */
+export declare const GovernedActionPolicyMaterialV1: Schema.Struct<{
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly policyId: Schema.brand<Schema.String, string>;
+    readonly policyVersion: Schema.Int;
+    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 evaluator: Schema.Literal<"human-session-policy">;
+    readonly evaluatorVersion: Schema.Literal<1>;
+    readonly rules: Schema.$Array<Schema.Literals<readonly ["permission-grants", "workspace-match"]>>;
+}>;
+/** Decoded version-one policy definition material. */
+export type GovernedActionPolicyMaterialV1 = typeof GovernedActionPolicyMaterialV1.Type;
+/** Version-one rule implemented by the built-in governed-action policy catalog. */
+export declare const BUILT_IN_GOVERNED_ACTION_POLICY_MATERIAL: Schema.Struct.ReadonlySide<{
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly policyId: Schema.brand<Schema.String, string>;
+    readonly policyVersion: Schema.Int;
+    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 evaluator: Schema.Literal<"human-session-policy">;
+    readonly evaluatorVersion: Schema.Literal<1>;
+    readonly rules: Schema.$Array<Schema.Literals<readonly ["permission-grants", "workspace-match"]>>;
+}, "Type">;
+export interface GovernedActionPolicyDefinition {
+    readonly binding: GovernedActionPolicyBindingType;
+    readonly enabled: boolean;
+    readonly material: GovernedActionPolicyMaterialV1;
+}
+declare const GovernedActionPolicyBindingUnavailable_base: Schema.Class<GovernedActionPolicyBindingUnavailable, Schema.TaggedStruct<"GovernedActionPolicyBindingUnavailable", {}>, import("effect/Cause").YieldableError>;
+/** The proposal's policy identity is absent from or differs from the current server catalog. */
+export declare class GovernedActionPolicyBindingUnavailable extends GovernedActionPolicyBindingUnavailable_base {
+}
+declare const GovernedActionPolicyCatalogInvalid_base: Schema.Class<GovernedActionPolicyCatalogInvalid, Schema.TaggedStruct<"GovernedActionPolicyCatalogInvalid", {}>, import("effect/Cause").YieldableError>;
+/** The server-owned policy catalog contains ambiguous current policy families. */
+export declare class GovernedActionPolicyCatalogInvalid extends GovernedActionPolicyCatalogInvalid_base {
+}
+type GovernedActionPolicyEvaluationInput = Pick<VerifyGovernedActionDispatchAuthorityInput, "currentEvidence" | "envelope" | "evaluatedAt" | "session">;
+/** Internal policy boundary evaluated from current policy and session inputs only. */
+export interface GovernedActionPolicyEvaluatorV1 {
+    readonly evaluate: (input: GovernedActionPolicyEvaluationInput) => Effect.Effect<GovernedActionPolicyEvaluationV1, GovernedActionDigestError | GovernedActionPolicyBindingUnavailable>;
+}
+/** Construct a catalog entry whose binding digest is derived from its complete declarative semantics. */
+export declare const makeGovernedActionPolicyDefinition: (material: Schema.Struct.ReadonlySide<{
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly policyId: Schema.brand<Schema.String, string>;
+    readonly policyVersion: Schema.Int;
+    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 evaluator: Schema.Literal<"human-session-policy">;
+    readonly evaluatorVersion: Schema.Literal<1>;
+    readonly rules: Schema.$Array<Schema.Literals<readonly ["permission-grants", "workspace-match"]>>;
+}, "Type">, enabled: boolean) => Effect.Effect<{
+    material: Schema.Struct.ReadonlySide<{
+        readonly schemaVersion: Schema.Literal<1>;
+        readonly policyId: Schema.brand<Schema.String, string>;
+        readonly policyVersion: Schema.Int;
+        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 evaluator: Schema.Literal<"human-session-policy">;
+        readonly evaluatorVersion: Schema.Literal<1>;
+        readonly rules: Schema.$Array<Schema.Literals<readonly ["permission-grants", "workspace-match"]>>;
+    }, "Type">;
+    enabled: boolean;
+    binding: Schema.Struct.ReadonlySide<{
+        readonly policyId: Schema.brand<Schema.String, string>;
+        readonly policyVersion: Schema.Int;
+        readonly policyDigest: Schema.brand<Schema.String, string>;
+        readonly requiredPermission: Schema.Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
+    }, "Type">;
+}, GovernedActionPolicyCatalogInvalid, Crypto.Crypto>;
+/** Construct the built-in policy entry from its canonical declarative material. */
+export declare const makeBuiltInGovernedActionPolicyDefinition: () => Effect.Effect<{
+    material: Schema.Struct.ReadonlySide<{
+        readonly schemaVersion: Schema.Literal<1>;
+        readonly policyId: Schema.brand<Schema.String, string>;
+        readonly policyVersion: Schema.Int;
+        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 evaluator: Schema.Literal<"human-session-policy">;
+        readonly evaluatorVersion: Schema.Literal<1>;
+        readonly rules: Schema.$Array<Schema.Literals<readonly ["permission-grants", "workspace-match"]>>;
+    }, "Type">;
+    enabled: boolean;
+    binding: Schema.Struct.ReadonlySide<{
+        readonly policyId: Schema.brand<Schema.String, string>;
+        readonly policyVersion: Schema.Int;
+        readonly policyDigest: Schema.brand<Schema.String, string>;
+        readonly requiredPermission: Schema.Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
+    }, "Type">;
+}, GovernedActionPolicyCatalogInvalid, Crypto.Crypto>;
+/** Build the policy evaluator from a versioned server-owned catalog. */
+export declare const makeGovernedActionPolicyEvaluator: (definitions: readonly GovernedActionPolicyDefinition[]) => Effect.Effect<{
+    evaluate: (input: GovernedActionPolicyEvaluationInput) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly schemaVersion: Schema.Literal<1>;
+        readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly policy: Schema.Struct<{
+            readonly policyId: Schema.brand<Schema.String, string>;
+            readonly policyVersion: Schema.Int;
+            readonly policyDigest: Schema.brand<Schema.String, string>;
+            readonly requiredPermission: Schema.Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
+        }>;
+        readonly payloadDigest: Schema.brand<Schema.String, "PluginActionPayloadDigest">;
+        readonly evidenceSetDigest: Schema.brand<Schema.String, string>;
+        readonly expectedRevision: Schema.brand<Schema.String, "Revision">;
+        readonly decision: Schema.Literals<readonly ["allowed", "denied"]>;
+        readonly evaluatedAt: Schema.DateTimeUtcFromString;
+    }, "Type">, GovernedActionDigestError | GovernedActionPolicyBindingUnavailable, never>;
+}, GovernedActionPolicyCatalogInvalid, Crypto.Crypto>;
+declare const GovernedActionPolicyEvaluator_base: Context.ServiceClass<GovernedActionPolicyEvaluator, "@knpkv/control-center/internal/GovernedActionPolicyEvaluator", GovernedActionPolicyEvaluatorV1>;
+/** Server-only fresh policy evaluator; persisted workspace-policy adapters replace this at I12. */
+export declare class GovernedActionPolicyEvaluator extends GovernedActionPolicyEvaluator_base {
+    static readonly layer: Layer.Layer<GovernedActionPolicyEvaluator, GovernedActionPolicyCatalogInvalid, Crypto.Crypto>;
+}
+export {};
+//# sourceMappingURL=GovernedActionPolicyEvaluator.d.ts.map

package/dist/server/server/governance/internal/GovernedActionPolicyEvaluator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GovernedActionPolicyEvaluator.d.ts","sourceRoot":"","sources":["../../../../../src/server/governance/internal/GovernedActionPolicyEvaluator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAA;AACzC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,EAGL,KAAK,2BAA2B,IAAI,+BAA+B,EACnE,gCAAgC,EACjC,MAAM,yCAAyC,CAAA;AAChD,OAAO,KAAK,EAAE,0CAA0C,EAAE,MAAM,+BAA+B,CAAA;AAC/F,OAAO,EAGL,KAAK,yBAAyB,EAC/B,MAAM,6BAA6B,CAAA;AAQpC,qFAAqF;AACrF,eAAO,MAAM,8BAA8B;;;;;;;;EAQzC,CAAA;AAEF,sDAAsD;AACtD,MAAM,MAAM,8BAA8B,GAAG,OAAO,8BAA8B,CAAC,IAAI,CAAA;AAEvF,mFAAmF;AACnF,eAAO,MAAM,wCAAwC;;;;;;;;UAUnD,CAAA;AAEF,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,CAAC,OAAO,EAAE,+BAA+B,CAAA;IACjD,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,QAAQ,EAAE,8BAA8B,CAAA;CAClD;;AAED,gGAAgG;AAChG,qBAAa,sCAAuC,SAAQ,2CAEX;CAAG;;AAEpD,kFAAkF;AAClF,qBAAa,kCAAmC,SAAQ,uCAEX;CAAG;AAEhD,KAAK,mCAAmC,GAAG,IAAI,CAC7C,0CAA0C,EAC1C,iBAAiB,GAAG,UAAU,GAAG,aAAa,GAAG,SAAS,CAC3D,CAAA;AAED,sFAAsF;AACtF,MAAM,WAAW,+BAA+B;IAC9C,QAAQ,CAAC,QAAQ,EAAE,CACjB,KAAK,EAAE,mCAAmC,KACvC,MAAM,CAAC,MAAM,CAChB,gCAAgC,EAChC,yBAAyB,GAAG,sCAAsC,CACnE,CAAA;CACF;AAwCD,yGAAyG;AACzG,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;qDAsB7C,CAAA;AAEF,mFAAmF;AACnF,eAAO,MAAM,yCAAyC;;;;;;;;;;;;;;;;;qDAIpD,CAAA;AAEF,wEAAwE;AACxE,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;qDA8C5C,CAAA;;AAOF,mGAAmG;AACnG,qBAAa,6BAA8B,SAAQ,kCAGgB;IACjE,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAChC,6BAA6B,EAC7B,kCAAkC,EAClC,MAAM,CAAC,MAAM,CACd,CAGA;CACF"}

package/dist/server/server/governance/internal/execution-store/begin.d.ts

@@ -0,0 +1,17 @@
+import * as Crypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import { Database } from "../../../persistence/Database.js";
+import { PluginRuntimeAuthoritySource } from "../../../plugins/internal/PluginRuntimeAuthoritySource.js";
+import type { GovernedActionBeginResult } from "../GovernedActionExecutionStore.js";
+import { GovernedActionExecutionStoreError } from "../GovernedActionExecutionStore.js";
+import { GovernedActionPolicyEvaluator } from "../GovernedActionPolicyEvaluator.js";
+/** Convert a preparation capability into durable dispatch intent and a one-use permit. */
+export declare const makeGovernedActionExecutionBegin: Effect.Effect<{
+    begin: (input: {
+        readonly preparationToken: import("./tokens.js").GovernedActionPreparationToken;
+        readonly preflight: import("../../../../domain/plugins/actions.js").ReadyPluginActionPreflightV1;
+        readonly runtimeAuthorityToken: import("../../../plugins/internal/PluginRuntimeAuthority.ts").PluginRuntimeAuthorityToken;
+        readonly scope: import("../../../index.ts").PluginRuntimeScope;
+    }) => Effect.Effect<GovernedActionBeginResult, GovernedActionExecutionStoreError>;
+}, never, Crypto.Crypto | Database | import("../../../persistence/repositories/quarantineRepository.ts").QuarantineRepository | PluginRuntimeAuthoritySource | GovernedActionPolicyEvaluator>;
+//# sourceMappingURL=begin.d.ts.map

package/dist/server/server/governance/internal/execution-store/begin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"begin.d.ts","sourceRoot":"","sources":["../../../../../../src/server/governance/internal/execution-store/begin.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAcvC,OAAO,EAAE,QAAQ,EAAE,MAAM,kCAAkC,CAAA;AAI3D,OAAO,EAAE,4BAA4B,EAAE,MAAM,2DAA2D,CAAA;AAGxG,OAAO,KAAK,EAAE,yBAAyB,EAAkC,MAAM,oCAAoC,CAAA;AACnH,OAAO,EAAE,iCAAiC,EAAE,MAAM,oCAAoC,CAAA;AACtF,OAAO,EAAE,6BAA6B,EAAE,MAAM,qCAAqC,CAAA;AA+DnF,0FAA0F;AAC1F,eAAO,MAAM,gCAAgC;;;;;;;6LA+P3C,CAAA"}

package/dist/server/server/governance/internal/execution-store/current-evidence.d.ts

@@ -0,0 +1,33 @@
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import type { GovernedActionEvidenceSet } from "../../../../domain/governedAction/index.js";
+import type { WorkspaceId } from "../../../../domain/identifiers.js";
+import type { UtcTimestamp } from "../../../../domain/utcTimestamp.js";
+import { Database } from "../../../persistence/Database.js";
+import { PersistedRecordError } from "../../../persistence/errors.js";
+declare const GovernedActionCurrentEvidenceRejected_base: Schema.Class<GovernedActionCurrentEvidenceRejected, Schema.TaggedStruct<"GovernedActionCurrentEvidenceRejected", {
+    readonly reason: Schema.Literals<readonly ["claim-changed", "claim-missing", "evidence-changed", "evidence-missing", "evidence-not-current"]>;
+}>, import("effect/Cause").YieldableError>;
+/** A persisted evidence set no longer grants the same current dispatch authority. */
+export declare class GovernedActionCurrentEvidenceRejected extends GovernedActionCurrentEvidenceRejected_base {
+}
+/** Strict current evidence reader used only inside the atomic dispatch-authority transaction. */
+export declare const makeGovernedActionCurrentEvidenceReader: Effect.Effect<{
+    read: (input: {
+        readonly workspaceId: WorkspaceId;
+        readonly evidence: GovernedActionEvidenceSet;
+        readonly now: UtcTimestamp;
+    }) => Effect.Effect<readonly Schema.Struct.ReadonlySide<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly evidenceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">;
+        readonly evidenceClaimIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceClaimId">>;
+        readonly observedAt: Schema.DateTimeUtcFromString;
+        readonly validUntil: Schema.NullOr<Schema.DateTimeUtcFromString>;
+        readonly currentUntil: Schema.NullOr<Schema.DateTimeUtcFromString>;
+        readonly evaluatedAt: Schema.DateTimeUtcFromString;
+        readonly source: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+        readonly validity: Schema.Literals<readonly ["valid", "expired"]>;
+    }, "Type">[], import("../../../persistence/errors.js").PersistenceOperationError | PersistedRecordError | import("effect/unstable/sql/SqlError").SqlError | GovernedActionCurrentEvidenceRejected, never>;
+}, never, import("effect/Crypto").Crypto | Database>;
+export {};
+//# sourceMappingURL=current-evidence.d.ts.map

package/dist/server/server/governance/internal/execution-store/current-evidence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"current-evidence.d.ts","sourceRoot":"","sources":["../../../../../../src/server/governance/internal/execution-store/current-evidence.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC,OAAO,KAAK,EAEV,yBAAyB,EAC1B,MAAM,4CAA4C,CAAA;AACnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAA;AAEpE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAA;AACtE,OAAO,EAAE,QAAQ,EAAE,MAAM,kCAAkC,CAAA;AAC3D,OAAO,EAAE,oBAAoB,EAAE,MAAM,gCAAgC,CAAA;;;;AAcrE,qFAAqF;AACrF,qBAAa,qCAAsC,SAAQ,0CAUzD;CAAG;AAwDL,iGAAiG;AACjG,eAAO,MAAM,uCAAuC;;8BAK1B,WAAW;2BACd,yBAAyB;sBAC9B,YAAY;;;;;;;;;;;;oDA0G5B,CAAA"}

package/dist/server/server/governance/internal/execution-store/current-session.d.ts

@@ -0,0 +1,29 @@
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { SessionId, WorkspaceId } from "../../../../domain/identifiers.js";
+import { Database } from "../../../persistence/Database.js";
+import { PersistedRecordError, RecordNotFoundError } from "../../../persistence/errors.js";
+/** Workspace-scoped identity of the session whose current authority is required. */
+export interface CurrentSessionAuthorityReference {
+    readonly workspaceId: WorkspaceId;
+    readonly sessionId: SessionId;
+}
+/** Build a bounded, secret-free reader for the authority of an existing session. */
+export declare const makeGovernedActionCurrentSessionReader: Effect.Effect<{
+    read: (reference: CurrentSessionAuthorityReference) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly actor: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"human", {
+            readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+        }>, Schema.TaggedStruct<"agent", {
+            readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+        }>]>;
+        readonly permission: 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 createdAt: Schema.DateTimeUtcFromString;
+        readonly lastSeenAt: Schema.DateTimeUtcFromString;
+        readonly idleExpiresAt: Schema.DateTimeUtcFromString;
+        readonly absoluteExpiresAt: Schema.DateTimeUtcFromString;
+        readonly revokedAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+    }, "Type">, RecordNotFoundError | PersistedRecordError | import("effect/unstable/sql/SqlError").SqlError, never>;
+}, never, Database>;
+//# sourceMappingURL=current-session.d.ts.map

package/dist/server/server/governance/internal/execution-store/current-session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"current-session.d.ts","sourceRoot":"","sources":["../../../../../../src/server/governance/internal/execution-store/current-session.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC,OAAO,EAAqB,SAAS,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAA;AAG7F,OAAO,EAAE,QAAQ,EAAE,MAAM,kCAAkC,CAAA;AAC3D,OAAO,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAA;AAkC1F,oFAAoF;AACpF,MAAM,WAAW,gCAAgC;IAC/C,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAA;IACjC,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAA;CAC9B;AAaD,oFAAoF;AACpF,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;;mBA6DjD,CAAA"}

package/dist/server/server/governance/internal/execution-store/current-target.d.ts

@@ -0,0 +1,28 @@
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { EntityId, WorkspaceId } from "../../../../domain/identifiers.js";
+import { Database } from "../../../persistence/Database.js";
+import { PersistedRecordError, RecordNotFoundError } from "../../../persistence/errors.js";
+/** Strict target reader for the authority-owned execution transaction; it never falls back revisions. */
+export declare const makeGovernedActionCurrentTargetReader: Effect.Effect<{
+    read: (input: {
+        readonly workspaceId: WorkspaceId;
+        readonly entityId: EntityId;
+    }) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly entityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+        readonly entityType: Schema.brand<Schema.String, string>;
+        readonly sourceRevision: Schema.Struct<{
+            readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+            readonly vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+            readonly revision: Schema.brand<Schema.String, "Revision">;
+            readonly sourceUrl: Schema.Union<readonly [Schema.decodeTo<Schema.URL, Schema.String, never, never>, Schema.Null]>;
+            readonly firstObservedAt: Schema.DateTimeUtcFromString;
+            readonly lastObservedAt: Schema.DateTimeUtcFromString;
+            readonly synchronizedAt: Schema.DateTimeUtcFromString;
+            readonly normalizationSchemaVersion: Schema.brand<Schema.Number, "NormalizationSchemaVersion">;
+        }>;
+    }, "Type">, RecordNotFoundError | import("../../../persistence/errors.js").PersistenceOperationError | PersistedRecordError | import("effect/unstable/sql/SqlError").SqlError, never>;
+}, never, import("effect/Crypto").Crypto | Database>;
+//# sourceMappingURL=current-target.d.ts.map

package/dist/server/server/governance/internal/execution-store/current-target.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"current-target.d.ts","sourceRoot":"","sources":["../../../../../../src/server/governance/internal/execution-store/current-target.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAA;AAGzE,OAAO,EAAE,QAAQ,EAAE,MAAM,kCAAkC,CAAA;AAC3D,OAAO,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAA;AAoE1F,yGAAyG;AACzG,eAAO,MAAM,qCAAqC;;8BAKxB,WAAW;2BACd,QAAQ;;;;;;;;;;;;;;;;;oDAoG7B,CAAA"}

package/dist/server/server/governance/internal/execution-store/dispatch-inbox.d.ts

@@ -0,0 +1,20 @@
+import * as Crypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import { UtcTimestamp } from "../../../../domain/utcTimestamp.js";
+import { Database } from "../../../persistence/Database.js";
+import { GovernedActionExecutionStoreError } from "../GovernedActionExecutionStore.js";
+import { type DispatchInboxOutcome } from "./dispatch-outcome.js";
+import { type GovernedActionPermitToken } from "./tokens.js";
+type DispatchInboxOperation = "record-dispatch" | "record-unknown";
+interface DispatchInboxInput {
+    readonly operation: DispatchInboxOperation;
+    readonly outcome: DispatchInboxOutcome;
+    readonly permitToken: GovernedActionPermitToken;
+    readonly receivedAt: UtcTimestamp;
+}
+/** Build the single durable append-then-fold boundary shared by dispatch-side outcomes. */
+export declare const makeGovernedActionExecutionDispatchInbox: Effect.Effect<{
+    recordOutcome: (input: DispatchInboxInput) => Effect.Effect<"unknown" | "proposed" | "expired" | "failed" | "cancelled" | "succeeded" | "cancel-requested" | "denied" | "authorized" | "started" | "cancel-requested-unknown", GovernedActionExecutionStoreError, never>;
+}, never, Crypto.Crypto | Database | import("../../../persistence/repositories/quarantineRepository.ts").QuarantineRepository>;
+export {};
+//# sourceMappingURL=dispatch-inbox.d.ts.map

package/dist/server/server/governance/internal/execution-store/dispatch-inbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatch-inbox.d.ts","sourceRoot":"","sources":["../../../../../../src/server/governance/internal/execution-store/dispatch-inbox.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAMvC,OAAO,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAA;AACjE,OAAO,EAAE,QAAQ,EAAE,MAAM,kCAAkC,CAAA;AAG3D,OAAO,EAAE,iCAAiC,EAAE,MAAM,oCAAoC,CAAA;AACtF,OAAO,EACL,KAAK,oBAAoB,EAM1B,MAAM,uBAAuB,CAAA;AAE9B,OAAO,EAEL,KAAK,yBAAyB,EAE/B,MAAM,aAAa,CAAA;AAEpB,KAAK,sBAAsB,GAAG,iBAAiB,GAAG,gBAAgB,CAAA;AAElE,UAAU,kBAAkB;IAC1B,QAAQ,CAAC,SAAS,EAAE,sBAAsB,CAAA;IAC1C,QAAQ,CAAC,OAAO,EAAE,oBAAoB,CAAA;IACtC,QAAQ,CAAC,WAAW,EAAE,yBAAyB,CAAA;IAC/C,QAAQ,CAAC,UAAU,EAAE,YAAY,CAAA;CAClC;AA6DD,2FAA2F;AAC3F,eAAO,MAAM,wCAAwC;;8HAkJnD,CAAA"}

package/dist/server/server/governance/internal/execution-store/dispatch-outcome.d.ts

@@ -0,0 +1,78 @@
+import type * as Crypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { type GovernedActionTransitionCommand } from "../../../../domain/governedAction/index.js";
+import type { UtcTimestamp } from "../../../../domain/utcTimestamp.js";
+import type { EncodedGovernedActionDispatchOutcome, GovernedActionDigestError } from "../../governedActionDigests.js";
+/** Closed dispatch-side artifacts that can enter the durable provider-outcome inbox. */
+export declare const DispatchInboxOutcome: Schema.Union<readonly [Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"confirmed", {
+    readonly receipt: Schema.Union<readonly [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;
+    }>, 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;
+    }>]>;
+}>, Schema.TaggedStruct<"unknown", {
+    readonly reconciliationKey: Schema.brand<Schema.String, string>;
+    readonly safeSummary: Schema.String;
+    readonly observedAt: Schema.DateTimeUtcFromString;
+}>]>, 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"]>;
+    }>;
+}>]>;
+/** Decoded dispatch-side inbox artifact. */
+export type DispatchInboxOutcome = typeof DispatchInboxOutcome.Type;
+/** Closed persisted kinds for immediate dispatch results. */
+export declare const DispatchResultKind: Schema.Literals<readonly ["accepted", "succeeded", "failed", "cancelled", "unknown", "manual-unknown"]>;
+/** Project one provider or locally synthesized dispatch-side outcome to its immutable inbox kind. */
+export declare const dispatchInboxOutcomeKind: (outcome: DispatchInboxOutcome) => typeof DispatchResultKind.Type;
+/** Source observation time retained separately from the trusted host receipt time. */
+export declare const dispatchInboxOutcomeObservedAt: (outcome: DispatchInboxOutcome) => typeof UtcTimestamp.Type;
+/** Reconstruct the exact lifecycle command represented by one dispatch-side inbox outcome. */
+export declare const dispatchInboxOutcomeCommand: (result: DispatchInboxOutcome) => GovernedActionTransitionCommand;
+/** Canonically encode either provider output or a local unknown marker. */
+export declare const encodeDispatchInboxOutcome: (outcome: Schema.Struct.ReadonlySide<{
+    readonly _tag: Schema.tag<"confirmed">;
+    readonly receipt: Schema.Union<readonly [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;
+    }>, 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"> | Schema.Struct.ReadonlySide<{
+    readonly _tag: Schema.tag<"unknown">;
+    readonly reconciliationKey: Schema.brand<Schema.String, string>;
+    readonly safeSummary: Schema.String;
+    readonly observedAt: Schema.DateTimeUtcFromString;
+}, "Type"> | Schema.Struct.ReadonlySide<{
+    readonly _tag: Schema.tag<"reconcilable">;
+    readonly reconciliationKey: Schema.brand<Schema.String, string>;
+    readonly observedAt: Schema.DateTimeUtcFromString;
+    readonly safeSummary: Schema.String;
+}, "Type"> | Schema.Struct.ReadonlySide<{
+    readonly _tag: Schema.tag<"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"]>;
+}, "Type">) => Effect.Effect<EncodedGovernedActionDispatchOutcome, GovernedActionDigestError, Crypto.Crypto>;
+//# sourceMappingURL=dispatch-outcome.d.ts.map

package/dist/server/server/governance/internal/execution-store/dispatch-outcome.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatch-outcome.d.ts","sourceRoot":"","sources":["../../../../../../src/server/governance/internal/execution-store/dispatch-outcome.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAA;AAC5C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,EACL,KAAK,+BAA+B,EAErC,MAAM,4CAA4C,CAAA;AAEnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAA;AAEtE,OAAO,KAAK,EAAE,oCAAoC,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAA;AAErH,wFAAwF;AACxF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAG/B,CAAA;AAEF,4CAA4C;AAC5C,MAAM,MAAM,oBAAoB,GAAG,OAAO,oBAAoB,CAAC,IAAI,CAAA;AAEnE,6DAA6D;AAC7D,eAAO,MAAM,kBAAkB,yGAO7B,CAAA;AAMF,qGAAqG;AACrG,eAAO,MAAM,wBAAwB,GACnC,SAAS,oBAAoB,KAC5B,OAAO,kBAAkB,CAAC,IAKD,CAAA;AAE5B,sFAAsF;AACtF,eAAO,MAAM,8BAA8B,GACzC,SAAS,oBAAoB,KAC5B,OAAO,YAAY,CAAC,IAKS,CAAA;AAEhC,8FAA8F;AAC9F,eAAO,MAAM,2BAA2B,GACtC,QAAQ,oBAAoB,KAC3B,+BAuBF,CAAA;AAED,2EAA2E;AAC3E,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4GAUrC,CAAA"}

package/dist/server/server/governance/internal/execution-store/inspect.d.ts

@@ -0,0 +1,17 @@
+import * as Crypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { Database } from "../../../persistence/Database.js";
+import type { GovernedActionExecutionPlan } from "../GovernedActionExecutionStore.js";
+import { GovernedActionExecutionStoreError } from "../GovernedActionExecutionStore.js";
+/**
+ * Build authorized action preparation over one verified aggregate transaction.
+ * The returned capability is short-lived and cannot authorize provider dispatch by itself.
+ */
+export declare const makeGovernedActionExecutionInspect: Effect.Effect<{
+    inspect: (reference: 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<GovernedActionExecutionPlan, GovernedActionExecutionStoreError, never>;
+}, never, Crypto.Crypto | Database | import("../../../persistence/repositories/quarantineRepository.ts").QuarantineRepository>;
+//# sourceMappingURL=inspect.d.ts.map

package/dist/server/server/governance/internal/execution-store/inspect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspect.d.ts","sourceRoot":"","sources":["../../../../../../src/server/governance/internal/execution-store/inspect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAIvC,OAAO,EAAE,QAAQ,EAAE,MAAM,kCAAkC,CAAA;AAG3D,OAAO,KAAK,EAEV,2BAA2B,EAE5B,MAAM,oCAAoC,CAAA;AAC3C,OAAO,EAAE,iCAAiC,EAAE,MAAM,oCAAoC,CAAA;AA8BtF;;;GAGG;AACH,eAAO,MAAM,kCAAkC;;;;;8HA8E7C,CAAA"}

package/dist/server/server/governance/internal/execution-store/live.d.ts

@@ -0,0 +1,6 @@
+import * as Layer from "effect/Layer";
+import type { WorkspaceId } from "../../../../domain/identifiers.js";
+import { GovernedActionExecutionStore } from "../GovernedActionExecutionStore.js";
+/** Private live store; only governed worker startup may install this authority-bearing service. */
+export declare const governedActionExecutionStoreLayer: (workspaceId: WorkspaceId) => Layer.Layer<GovernedActionExecutionStore, never, import("effect/Crypto").Crypto | import("../../../persistence/Database.ts").Database | import("../../../persistence/repositories/quarantineRepository.ts").QuarantineRepository | import("../../../plugins/internal/PluginRuntimeAuthoritySource.ts").PluginRuntimeAuthoritySource | import("../GovernedActionPolicyEvaluator.ts").GovernedActionPolicyEvaluator>;
+//# sourceMappingURL=live.d.ts.map