@makaio/framework 1.0.0-dev-1788511348215 → 1.0.0-dev-1788811230746

package/dist/workflow-engine/index.d.mts

@@ -1,12 +1,13 @@
-import { a as ProviderOperationClaim, c as ProviderOperationObligation, i as ProcessBoundProvisionerLossProof, l as ProviderOperationOwnershipRecord, n as InitialProviderOperationClaimContextSource, o as ProviderOperationClaimDecision, r as PROVIDER_OPERATION_OBLIGATIONS, s as ProviderOperationMutationDecision, t as InitialProviderOperationClaimContext } from "../provider-operation-DbdyFwNm.mjs";
-import { A as RecordProviderOperationUncertaintyInput, C as PendingAttemptAbandonmentDecision, D as RecordAllocationInput, E as ProvisioningClaimDecision, F as TakeOverProviderOperationInput, I as decodeDurableOutcome, L as durableOutcome, M as RecordProvisioningAbsentInput, N as RecoverableAttemptRecord, O as RecordAllocationTerminatedInput, P as RenewProviderOperationClaimInput, R as sameAllocationRef, S as OutcomeCodec, T as ProvisioningAbsenceDecision, _ as ExecutionAttemptSettlementKind, a as BeginProvisioningInput, b as HandoffProviderOperationInput, c as DurableOutcome, d as ExecutionAttemptCreate, f as ExecutionAttemptOutcomeCommit, g as ExecutionAttemptRepository, h as ExecutionAttemptRecoveryOperations, i as AllocationTerminationDecision, j as RecordProvisionerIncarnationLostInput, k as RecordInfrastructureFailureInput, l as EXECUTION_ATTEMPT_SETTLEMENT_KINDS, m as ExecutionAttemptRecord, n as AllocationRefEvolution, o as DiscoveredAllocationDecision, p as ExecutionAttemptOutcomeDecision, r as AllocationRefEvolutionDecision, s as DuplicateExecutionAttemptError, t as AllocationRecordingDecision, u as EXECUTION_ATTEMPT_STATUSES, v as ExecutionAttemptStatus, w as ProvisionerIncarnationLossDecision, x as InfrastructureFailureDecision, y as ExecutionOwnerId, z as sameDurableOutcome } from "../execution-attempt-repository-DY4KTptE.mjs";
-import { a as WorkflowEngineServiceOptions, c as ExecutionAttemptAuthority, d as WorkflowWorkspaceRootResolver, f as registerDrizzleWorkflowStorage, i as WorkflowEngineService, l as WorkflowMaterializationSpecResolution, n as createWorkflowEnginePackage, o as WorkflowTriggerReconciler, r as workflowEnginePackage, s as WorkflowExecutor, t as WorkflowEngineToken, u as WorkflowMaterializationSpecResolver } from "../package-efR90JGe.mjs";
+import { a as ProviderOperationClaim, c as ProviderOperationObligation, i as ProcessBoundProvisionerLossProof, l as ProviderOperationOwnershipRecord, n as InitialProviderOperationClaimContextSource, o as ProviderOperationClaimDecision, r as PROVIDER_OPERATION_OBLIGATIONS, s as ProviderOperationMutationDecision, t as InitialProviderOperationClaimContext } from "../provider-operation-B2wQST6N.mjs";
+import { $ as RuntimeReadinessDecision, A as MarkRuntimeReadyInput, B as ReadBootstrapStartStateInput, C as ExecutionAttemptRepository, E as ExecutionOwnerId, F as PendingAttemptAbandonmentDecision, G as RecordProvisionerIncarnationLostInput, H as RecordAllocationTerminatedInput, J as RegisterRuntimeInput, K as RecordProvisioningAbsentInput, L as ProvisionerIncarnationLossDecision, M as OperationCompletionDecision, O as HandoffProviderOperationInput, P as OutcomeCodec, Q as RuntimeOutcomeFenceMismatchError, R as ProvisioningAbsenceDecision, S as ExecutionAttemptRecoveryOperations, T as ExecutionAttemptStatus, U as RecordInfrastructureFailureInput, V as RecordAllocationInput, W as RecordProviderOperationUncertaintyInput, Y as RenewProviderOperationClaimInput, Z as RuntimeOutcomeFence, _ as EXECUTION_ATTEMPT_STATUSES, a as AllocationRefEvolutionDecision, at as sameAllocationRef, b as ExecutionAttemptOutcomeDecision, ct as AttemptReachabilityDecision, d as BootstrapStartState, dt as evaluateOperationCompletion, et as RuntimeRegistrationDecision, f as CompleteOperationInput, g as EXECUTION_ATTEMPT_SETTLEMENT_KINDS, h as DurableOutcome, i as AllocationRefEvolution, it as durableOutcome, j as OperationAdmissionDecision, k as InfrastructureFailureDecision, l as AttemptOperationStartGate, lt as evaluateAttemptReachability, m as DuplicateExecutionAttemptError, mt as evaluateRuntimeRegistration, n as AdmitOperationInput, nt as assertRuntimeOutcomeFence, o as AllocationTerminationDecision, ot as sameDurableOutcome, p as DiscoveredAllocationDecision, pt as evaluateRuntimeReadiness, q as RecoverableAttemptRecord, r as AllocationRecordingDecision, rt as decodeDurableOutcome, s as AttemptControlState, st as AttemptReachability, t as ATTEMPT_OPERATION_START_GATES, tt as TakeOverProviderOperationInput, u as BeginProvisioningInput, ut as evaluateOperationAdmission, v as ExecutionAttemptCreate, w as ExecutionAttemptSettlementKind, x as ExecutionAttemptRecord, y as ExecutionAttemptOutcomeCommit, z as ProvisioningClaimDecision } from "../execution-attempt-repository-OryBjQQI.mjs";
+import { A as WorkflowWorkspaceRootResolver, C as OutcomePreCommitValidation, D as BootstrapStartOptions, E as BootstrapStartAuthority, O as WorkflowMaterializationSpecResolution, S as OutcomeConvergenceInput, T as ExecutionAttemptAuthority, _ as ExecutionAttemptHandlersDeps, a as WorkflowEngineServiceOptions, b as AttemptOutcomeSubmissionDeps, c as CommittedWorkflowOutcomeIdentity, d as WorkflowAttemptOutcomeSchema, f as WorkflowAttemptTechnicalFailure, g as AttemptOutcomeDecodingInput, h as workflowAttemptOutcomeCodec, i as WorkflowEngineService, j as registerDrizzleWorkflowStorage, k as WorkflowMaterializationSpecResolver, l as WorkflowAttemptCancellation, m as toCommittedWorkflowRunnerResult, n as createWorkflowEnginePackage, o as WorkflowTriggerReconciler, p as decodeWorkflowAttemptOutcome, r as workflowEnginePackage, s as WorkflowExecutor, t as WorkflowEngineToken, u as WorkflowAttemptOutcome, v as registerExecutionAttemptHandlers, w as submitAttemptOutcome, x as OutcomeConvergence, y as AttemptOutcomeSubmission } from "../package-eOEt1w6u.mjs";
 import { WorkflowTriggerPayloadPredicate, assertWorkflowTriggerPayload, compileWorkflowTriggerBindingFilter } from "./workflow-trigger-binding-consumer.mjs";
 import { z } from "zod";
 import * as _$_makaio_core0 from "@makaio/framework/core";
+import { BaseMessageContext } from "@makaio/framework/core";
 import { IMakaioBus } from "@makaio/framework/bus";
 import * as _$_makaio_contracts0 from "@makaio/framework/contracts";
-import { JsonPatchOperation, JsonValue, WorkflowAutomationTriggerBinding, WorkflowExecution, WorkflowExecutionSchema, WorkflowListQuerySchema, WorkflowRunResult, createWorkflowFinalizerNamespace } from "@makaio/framework/contracts";
+import { ExecutionAttemptInstruction, ExecutionPreservationRequirements, JsonPatchOperation, JsonValue, WorkflowAutomationTriggerBinding, WorkflowExecution, WorkflowExecutionSchema, WorkflowListQuerySchema, WorkflowRunContext, WorkflowRunResult, WorkflowWorkerConfig, WorkspaceRequirement, createWorkflowFinalizerNamespace } from "@makaio/framework/contracts";
 import * as _$drizzle_orm_sqlite_core0 from "drizzle-orm/sqlite-core";
 import * as _$drizzle_orm_pg_core0 from "drizzle-orm/pg-core";
 import * as _$_makaio_storage_drizzle0 from "@makaio/framework/storage/drizzle";
@@ -24,183 +25,401 @@ interface WorkflowSuccessFinalizer {
   readonly finalizeSubject: ReturnType<typeof createWorkflowFinalizerNamespace>['subjects']['finalize'];
 }
 //#endregion
-//#region subsystems/workflow-engine/src/authority-dispatch-runner.d.ts
+//#region subsystems/workflow-engine/src/execution-bound-access.d.ts
 /**
- * Inputs for dispatching an Authority-owned attempt.
- * @typeParam TOutcome - Owner-specific outcome type committed per attempt.
+ * Authenticated dispatch identity carried by a remote workflow worker.
+ *
+ * Both fields are derived from the transport peer the receiving transport
+ * authenticated — never from the request payload — so a worker cannot claim
+ * another attempt or another execution.
  */
-interface AuthorityDispatchRunnerOptions<TOutcome> {
-  /** Authority that persists and owns the execution attempt. */
-  readonly authority: ExecutionAttemptAuthority<TOutcome>;
-  /** Owner identifier of the aggregate that owns the attempt. */
-  readonly executionId: ExecutionOwnerId;
-  /** Dispatch operation whose successful return acknowledges acceptance. */
-  readonly dispatch: (executionAttemptId: string) => Promise<unknown>;
+interface ExecutionAttemptPeerIdentity {
+  /** Authority-created attempt identifier (`peer.id`). */
+  readonly executionAttemptId: string;
+  /** Workflow execution identifier from the Authority-issued `executionId` claim. */
+  readonly executionId: string;
 }
 /**
- * Dispatch an Authority-owned attempt and await its canonical outcome.
+ * Resolve the authenticated attempt identity of a remote caller.
  *
- * A rejected dispatch operation is not proof that no provider received the
- * request. The pending-abandonment CAS distinguishes a confirmed pre-allocation
- * failure from a lost acknowledgement after provisioning, allocation, or settlement.
- * @param options - Authority, owner identity, and dispatch operation.
- * @returns The Authority-committed outcome.
+ * This is the single derivation of "who is this worker" shared by every
+ * execution-bound seam in the subsystem. A caller qualifies only when the
+ * receiving transport authenticated it as a `workflow-execution-attempt` peer
+ * carrying both a non-empty attempt id and a non-empty Authority-issued
+ * `executionId` claim.
+ *
+ * Local origin is deliberately not considered here: each seam decides what a
+ * trusted local caller may do with the identity it already owns.
+ * @param ctx - Incoming message context.
+ * @returns Resolved attempt identity, or `null` when the caller is not an authenticated attempt peer.
  */
-declare function runAuthorityDispatchedAttempt<TOutcome>(options: AuthorityDispatchRunnerOptions<TOutcome>): Promise<TOutcome>;
+declare function resolveExecutionAttemptPeer(ctx: BaseMessageContext): ExecutionAttemptPeerIdentity | null;
 //#endregion
-//#region subsystems/workflow-engine/src/outcome-convergence.d.ts
+//#region subsystems/workflow-engine/src/workflow-attempt-instruction.d.ts
+/** Installed adapter that interprets portable workflow invocation input. */
+declare const WORKFLOW_WORKLOAD_KIND = "workflow";
+/** Version of the workflow adapter's frozen input contract. */
+declare const WORKFLOW_WORKLOAD_VERSION = "1";
 /**
- * Input handed to {@link OutcomeConvergence.converge}.
+ * Immutable workflow semantics, independent of the selected Worker Runtime.
  *
- * Named rather than inlined so an owner-side realization can state the shape
- * it implements against, and so a consumer can pin it from the public surface.
- * @typeParam TOutcome - Owner-specific outcome type committed per attempt.
+ * Environment values, contribution packages, and provider suspension behavior
+ * are runtime inputs. Executable acquisition remains in this adapter payload;
+ * it does not implicitly request a project Workspace.
  */
-interface OutcomeConvergenceInput<TOutcome> {
-  /** Owner identifier the attempt belongs to. */
-  readonly executionId: ExecutionOwnerId;
-  /** Authority-created attempt identifier. */
-  readonly executionAttemptId: string;
-  /** The canonical committed outcome, never the submitter's copy of it. */
-  readonly outcome: TOutcome;
-  /** The durable decision that produced the committed outcome. */
-  readonly decision: 'accepted' | 'duplicate';
+declare const WorkflowInvocationInputSchema: z.ZodObject<{
+  executionId: z.ZodString;
+  workflowId: z.ZodString;
+  source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"path">;
+    path: z.ZodString;
+  }, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"source">;
+    filename: z.ZodString;
+    source: z.ZodString;
+  }, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"definition">;
+    workflowId: z.ZodString;
+  }, z.core.$strict>], "kind">;
+  definitionSnapshot: z.ZodOptional<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    inputSchema: z.ZodOptional<z.ZodType<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>, z.core.$ZodTypeInternals<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>>>>;
+    configSchema: z.ZodOptional<z.ZodType<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>, z.core.$ZodTypeInternals<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>>>>;
+    outputSchema: z.ZodOptional<z.ZodType<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>, z.core.$ZodTypeInternals<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>>>>;
+    state: z.ZodOptional<z.ZodObject<{
+      schema: z.ZodType<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>, z.core.$ZodTypeInternals<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>>>;
+      initial: z.ZodOptional<z.ZodType<_$_makaio_contracts0.JsonValue, _$_makaio_contracts0.JsonValue, z.core.$ZodTypeInternals<_$_makaio_contracts0.JsonValue, _$_makaio_contracts0.JsonValue>>>;
+    }, z.core.$strip>>;
+    artifact: z.ZodOptional<z.ZodObject<{
+      kind: z.ZodString;
+      schemaVersion: z.ZodString;
+      scope: z.ZodObject<{
+        level: z.ZodString;
+        ids: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+      }, z.core.$strip>;
+      resolve: z.ZodOptional<z.ZodString>;
+      create: z.ZodOptional<z.ZodString>;
+      statusPath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    root: z.ZodObject<{
+      id: z.ZodString;
+      when: z.ZodOptional<z.ZodString>;
+      skip: z.ZodOptional<z.ZodString>;
+      writes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        kind: z.ZodString;
+        schemaVersion: z.ZodString;
+        scope: z.ZodObject<{
+          level: z.ZodString;
+          ids: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strip>;
+        dataExpression: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>>>;
+      type: z.ZodLiteral<"sequence">;
+      nodes: z.ZodLazy<z.ZodType<_$_makaio_contracts0.WorkflowNode[], unknown, z.core.$ZodTypeInternals<_$_makaio_contracts0.WorkflowNode[], unknown>>>;
+    }, z.core.$strip>;
+    triggers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      kind: z.ZodString;
+      params: z.ZodType<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>, z.core.$ZodTypeInternals<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>>>;
+      filter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, z.ZodObject<{
+        $in: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>;
+      }, z.core.$strict>, z.ZodObject<{
+        $ne: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+      }, z.core.$strict>, z.ZodObject<{
+        $exists: z.ZodBoolean;
+      }, z.core.$strict>, z.ZodObject<{
+        $startsWith: z.ZodString;
+      }, z.core.$strict>, z.ZodObject<{
+        $endsWith: z.ZodString;
+      }, z.core.$strict>]>>>;
+      filterExpression: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    scope: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+      type: z.ZodLiteral<"global">;
+    }, z.core.$strict>, z.ZodObject<{
+      type: z.ZodLiteral<"workspace">;
+      id: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+      type: z.ZodLiteral<"session">;
+      id: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+      type: z.ZodLiteral<"external">;
+      kind: z.ZodString;
+      id: z.ZodString;
+    }, z.core.$strict>], "type">>;
+    canvasLayout: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<_$_makaio_contracts0.JsonValue, _$_makaio_contracts0.JsonValue, z.core.$ZodTypeInternals<_$_makaio_contracts0.JsonValue, _$_makaio_contracts0.JsonValue>>>>;
+    source: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+      kind: z.ZodLiteral<"editor">;
+    }, z.core.$strict>, z.ZodObject<{
+      kind: z.ZodLiteral<"extension">;
+      extension: z.ZodString;
+      externalId: z.ZodOptional<z.ZodString>;
+      syncedAt: z.ZodOptional<z.ZodString>;
+      metadata: z.ZodDefault<z.ZodType<Record<string, unknown>, Record<string, unknown>, z.core.$ZodTypeInternals<Record<string, unknown>, Record<string, unknown>>>>;
+    }, z.core.$strict>], "kind">>;
+    executableSource: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+      kind: z.ZodLiteral<"path">;
+      path: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+      kind: z.ZodLiteral<"source">;
+      filename: z.ZodString;
+      source: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+      kind: z.ZodLiteral<"definition">;
+      workflowId: z.ZodString;
+    }, z.core.$strict>], "kind">>;
+    requirements: z.ZodOptional<z.ZodObject<{
+      maxRuntimeMs: z.ZodOptional<z.ZodNumber>;
+      persistentStorage: z.ZodOptional<z.ZodBoolean>;
+      customCapabilities: z.ZodDefault<z.ZodArray<z.ZodString>>;
+      recoverableAllocation: z.ZodOptional<z.ZodBoolean>;
+      materializationModes: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        "local-directory": "local-directory";
+        "workspace-snapshot": "workspace-snapshot";
+      }>>>;
+    }, z.core.$strip>>;
+    successFinalizerId: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  inputs: z.ZodDefault<z.ZodType<_$_makaio_contracts0.JsonValue, _$_makaio_contracts0.JsonValue, z.core.$ZodTypeInternals<_$_makaio_contracts0.JsonValue, _$_makaio_contracts0.JsonValue>>>;
+  config: z.ZodOptional<z.ZodType<Record<string, unknown>, Record<string, unknown>, z.core.$ZodTypeInternals<Record<string, unknown>, Record<string, unknown>>>>;
+  scope: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"global">;
+  }, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"workspace">;
+    id: z.ZodString;
+  }, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"session">;
+    id: z.ZodString;
+  }, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"external">;
+    kind: z.ZodString;
+    id: z.ZodString;
+  }, z.core.$strict>], "type">>;
+  triggerPayload: z.ZodDefault<z.ZodType<Record<string, unknown>, Record<string, unknown>, z.core.$ZodTypeInternals<Record<string, unknown>, Record<string, unknown>>>>;
+  triggerMode: z.ZodOptional<z.ZodEnum<{
+    immediate: "immediate";
+    "await-trigger": "await-trigger";
+  }>>;
+  artifactRef: z.ZodOptional<z.ZodObject<{
+    kind: z.ZodString;
+    id: z.ZodString;
+  }, z.core.$strip>>;
+  coordinatorSessionId: z.ZodString;
+  cancelSubject: z.ZodString;
+  materializationSpec: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"local-directory">;
+    workspaceId: z.ZodString;
+    rootDigest: z.ZodString;
+    sourcePath: z.ZodString;
+  }, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"workspace-snapshot">;
+    snapshotId: z.ZodString;
+    digest: z.ZodString;
+    sourcePath: z.ZodString;
+  }, z.core.$strict>], "kind">>;
+  terminalAuthority: z.ZodLiteral<"authority">;
+}, z.core.$strict>;
+/** Portable input understood exclusively by the workflow workload adapter. */
+type WorkflowInvocationInput = z.infer<typeof WorkflowInvocationInputSchema>;
+/** Owner inputs for freezing one workflow assignment before Attempt dispatch. */
+interface BuildWorkflowAttemptInstructionOptions {
+  /** Identity assigned by the execution owner to this instruction. */
+  readonly id: string;
+  /** Revision assigned by the execution owner before Attempt creation. */
+  readonly revision: string;
+  /** Runner configuration; transport credentials and environment are never copied. */
+  readonly config: WorkflowWorkerConfig;
+  /** Portable owner snapshot, required when runner config names a local executable path. */
+  readonly runContext?: WorkflowRunContext;
+  /** Optional project working area, independent of workflow executable acquisition. */
+  readonly workspace?: WorkspaceRequirement;
+  /** Explicit preservation obligations; an empty list declares scratch work. */
+  readonly preservation: ExecutionPreservationRequirements;
 }
 /**
- * Owner-side convergence of a committed attempt outcome.
+ * Freeze workflow semantics without persisting a worker config or local paths.
+ * @param options - Instruction identity, portable workflow input, and explicit resource requirements.
+ * @returns A detached instruction suitable for Authority-owned Attempt creation.
+ */
+declare function buildWorkflowAttemptInstruction(options: BuildWorkflowAttemptInstructionOptions): ExecutionAttemptInstruction;
+/**
+ * Parse an assignment at the workflow adapter boundary.
+ * @param instruction - Frozen generic Attempt instruction.
+ * @returns The workflow adapter's portable input.
+ * @throws When the instruction requires another adapter or input version.
+ */
+declare function parseWorkflowAttemptInstruction(instruction: ExecutionAttemptInstruction): WorkflowInvocationInput;
+//#endregion
+//#region subsystems/workflow-engine/src/runtime-registration.d.ts
+/**
+ * Time the authority waits for the runtime's receipt of the bounded probe.
  *
- * Runs after the durable commit and before waiter settlement and ACK. It is
- * idempotent by contract: it is re-entered for every duplicate retry, because
- * a worker whose first submission committed but did not converge resubmits
- * the same outcome, receives `duplicate`, and must converge again.
- * @typeParam TOutcome - Owner-specific outcome type committed per attempt.
+ * Strictly below the bus-wide `DEFAULT_REQUEST_TIMEOUT_MS` of 60 000 ms the
+ * outer `execution-attempt.runtime.register` request runs on, so a dead
+ * endpoint fails its own registration with `probe-failed` instead of timing
+ * out the runtime that is waiting for the decision.
+ */
+declare const RUNTIME_PROBE_DELIVERY_TIMEOUT_MS = 10000;
+/**
+ * Dependencies for the runtime registration handler.
  */
-interface OutcomeConvergence<TOutcome> {
+interface RuntimeRegistrationDeps<TOutcome> {
   /**
-   * Converge owner state with the committed outcome.
-   * @param input - Attempt identity, the canonical committed outcome, and the
-   *   durable decision that produced it.
+   * Bus the authority speaks on.
+   *
+   * Carries the probe delivery request and the readiness event. The bus the
+   * handler is registered on is the registrar's own first argument; in every
+   * production wiring the two are the same instance.
    */
-  converge(input: OutcomeConvergenceInput<TOutcome>): Promise<void>;
+  readonly bus: IMakaioBus;
+  /** Execution attempt Authority service. */
+  readonly authority: ExecutionAttemptAuthority<TOutcome>;
+  /**
+   * Probe delivery budget override, in milliseconds.
+   *
+   * Defaults to {@link RUNTIME_PROBE_DELIVERY_TIMEOUT_MS}. Exists so a test can
+   * pin the timeout branch without waiting ten seconds for it; production
+   * wiring omits it.
+   */
+  readonly probeDeliveryTimeoutMs?: number;
 }
 /**
- * Owner-side validation that runs before the durable commit.
- *
- * Performs reads only: an outcome it rejects never becomes an immutable
- * attempt outcome, so a corrected retry is not answered as a conflict. What
- * it inspects is the canonical outcome the attempt will hold, obtained from
- * `ExecutionAttemptAuthority.canonicalizeOutcome` before the commit.
+ * Register the `execution-attempt.runtime.register` bus handler.
  *
- * **A realization must be retry-stable.** {@link submitAttemptOutcome} runs it
- * ahead of every commit, including the retry of a submission that already
- * committed, so its verdict may depend only on the submission itself and on
- * owner facts no convergence step rewrites — never on owner state convergence
- * moves forward. A validator that read, say, a mutable lifecycle status would
- * reject the identical retry of an outcome its own convergence already
- * committed, and the waiter for that outcome would never settle.
+ * The single authority gate for runtime registration. It runs the whole
+ * handshake inside the one request the runtime made, so the reply is the
+ * runtime's complete answer and there is no `not-ready` retry loop:
  *
- * Retry-stable is measured on the outcome, not on its text. A retry need not
- * render the same text as the first commit: `sameDurableOutcome` judges
- * two texts the same outcome whatever member order they carry and answers
- * `duplicate` for such a retry, while the validator sees the retry's own
- * canonical rendering, never the stored one. Its verdict may therefore turn
- * only on what `sameDurableOutcome` compares — the members and their values
- * — and never on member order or any other detail of one particular
- * rendering. A validator that keyed on which member comes first would reject
- * the retry the repository is about to report as `duplicate`, and the
- * committed-but-unconverged waiter could never recover. Validating the stored
- * representation instead is not an option, for the reason the next paragraph
- * gives: validation runs ahead of the commit, where the retry's rendering is
- * the only one there is.
+ * 1. Resolve the authenticated attempt peer and refuse unless its attempt id
+ *    equals the payload's. Local origin is not a bypass — this handler is the
+ *    identity fence, and the peer is where `executionId` comes from, because no
+ *    payload in the namespace carries one.
+ * 2. `registerRuntime`. A `duplicate` that already proved readiness announces
+ *    that readiness again (step 7) and is answered `duplicate`; a `duplicate` without
+ *    readiness is a replay of this incarnation's own report and continues at
+ *    step 3 exactly as `registered` does. Every other refusal is reported
+ *    one-to-one.
+ * 3. Admit the bounded runtime probe under `probe:<runtimeIncarnationId>`. **No
+ *    `operation.admitted` event is published for `runtime-probe`** — the probe
+ *    never reaches the pool.
+ * 4. Deliver the probe to the runtime's own filtered subscription within
+ *    {@link RUNTIME_PROBE_DELIVERY_TIMEOUT_MS}. The delivery names the
+ *    incarnation, so only the endpoint that registered can answer it. A
+ *    `refused` receipt, a timeout, an absent responder, or any throw fails the
+ *    registration with `probe-failed`, releases the probe's slot, and leaves
+ *    readiness unproven.
+ * 5. `completeOperation`, which frees the attempt for real work.
+ * 6. `markRuntimeReady`, which makes readiness durable for this generation and
+ *    is the last fence: an attempt superseded since step 2 is refused here.
+ * 7. Publish `execution-attempt.runtime.ready` for the durable readiness, on
+ *    the `ready` transition and on every `duplicate` that finds it already
+ *    persisted. Announcements are at-least-once projections of durable state:
+ *    the authority re-reads the control state right before it announces and
+ *    publishes only the readiness that still holds — the same generation, still
+ *    ready — so a newer incarnation that registered in between is never
+ *    misrepresented by a stale announcement; a retried registration announces
+ *    again, so an announcement whose first pass failed after persistence is
+ *    delivered by the next pass; and every consumer is idempotent and
+ *    generation-aware — the worker pool projects each generation once and
+ *    ignores older ones, the Fly tracker resolves once, and observability
+ *    upserts. What this does not cover is a process that exits between
+ *    persisting readiness and announcing it: until a durable publication marker
+ *    exists, that readiness is announced by the next registration of the same
+ *    incarnation, or never.
+ * 8. Reply `ready` with the generation the runtime must fence everything else
+ *    with.
  *
- * The rule is stated here rather than worked around downstream because the
- * order it constrains is the one that keeps a spoofed outcome out of durable
- * storage: validation cannot move behind the commit without committing what
- * it exists to reject. The workflow adapter's `validateOutcomeExecutionIdentity`
- * satisfies it by correlating the submitted result against immutable durable
- * identity — the execution's own id and workflow id, and the run context's
- * terminal-authority binding, none of which outcome convergence touches.
- * @typeParam TOutcome - Owner-specific outcome type committed per attempt.
+ * Step 7 is unreachable unless step 5 persisted the completion: readiness is
+ * announced only after the probe receipt became a durable fact.
+ * @param bus - Bus the handler subscribes on.
+ * @param deps - Runtime registration dependencies.
+ * @returns Cleanup function for handler deregistration.
  */
-interface OutcomePreCommitValidation<TOutcome> {
+declare function registerRuntimeRegistrationHandler<TOutcome>(bus: IMakaioBus, deps: RuntimeRegistrationDeps<TOutcome>): () => void;
+//#endregion
+//#region subsystems/workflow-engine/src/operation-admission.d.ts
+/**
+ * Dependencies for the operation admission handler.
+ */
+interface OperationAdmissionDeps<TOutcome> {
   /**
-   * Validate an outcome against owner state.
-   *
-   * Called again for every retry of the same submission, so the same outcome
-   * owes the same verdict — the same as `sameDurableOutcome` reads it,
-   * which ignores member order and every other rendering detail, not the
-   * same text.
+   * Bus the authority speaks on.
    *
-   * The outcome handed over is the canonical one — what the attempt will
-   * hold and what {@link OutcomeConvergence.converge} will receive — not the
-   * submitter's copy of it. A codec may normalize while serializing, so
-   * validating the copy would let an outcome the validator would have
-   * rejected become the immutable committed one.
-   * @param executionId - Owner identifier the attempt belongs to.
-   * @param outcome - Canonical outcome about to be committed.
-   * @throws When the outcome must not be committed.
+   * Carries the `operation.admitted` announcement. The bus the handler is
+   * registered on is the registrar's own first argument; in every production
+   * wiring the two are the same instance.
    */
-  validate(executionId: ExecutionOwnerId, outcome: TOutcome): Promise<void>;
+  readonly bus: IMakaioBus;
+  /** Execution attempt Authority service. */
+  readonly authority: ExecutionAttemptAuthority<TOutcome>;
 }
 /**
- * Dependencies of {@link submitAttemptOutcome}.
- * @typeParam TOutcome - Owner-specific outcome type committed per attempt.
+ * Register the `execution-attempt.operation.admit` bus handler.
+ *
+ * The single authority gate for the attempt's start gate. It fences the caller
+ * exactly as runtime registration does — the authenticated attempt peer must be
+ * the attempt named in the payload, and `executionId` is taken from the peer
+ * because no payload in the namespace carries one — and then makes one
+ * `admitOperation` call whose eight refusal kinds are the eight wire refusal
+ * reasons, one to one.
+ *
+ * `runtime-probe` is not admissible here at all. The bounded probe is the
+ * authority's own proof of the endpoint, admitted and completed inside the
+ * registration handshake; a caller admitting one on this gate would occupy the
+ * attempt's single slot with an operation no subject can complete. It is
+ * refused as a protocol violation, exactly like a peer mismatch.
+ *
+ * `execution-attempt.operation.admitted` is published for the durable
+ * admission, on the `admitted` transition and on every `duplicate` that finds
+ * it already persisted. Publication is at-least-once: a retried admission
+ * announces again, so an announcement whose first pass failed after
+ * persistence is delivered by the next pass. Every consumer is idempotent —
+ * the worker pool collapses repeats into one `busy` projection and
+ * observability upserts. What this does not cover is a process that exits
+ * between persisting the admission and announcing it: until a durable
+ * publication marker exists, that admission is announced by the next retry of
+ * the same key, or never.
+ * @param bus - Bus the handler subscribes on.
+ * @param deps - Operation admission dependencies.
+ * @returns Cleanup function for handler deregistration.
  */
-interface AttemptOutcomeSubmissionDeps<TOutcome> {
-  /** Authority that commits the outcome and holds the in-process waiter. */
-  readonly authority: ExecutionAttemptAuthority<TOutcome>;
-  /** Owner convergence that runs for `accepted` and `duplicate` decisions. */
-  readonly convergence: OutcomeConvergence<TOutcome>;
-  /** Optional owner validation that runs before the durable commit. */
-  readonly validation?: OutcomePreCommitValidation<TOutcome>;
-}
+declare function registerOperationAdmissionHandler<TOutcome>(bus: IMakaioBus, deps: OperationAdmissionDeps<TOutcome>): () => void;
+//#endregion
+//#region subsystems/workflow-engine/src/bootstrap-start-handler.d.ts
 /**
- * Input of {@link submitAttemptOutcome}.
+ * Register attempt-authenticated start authorization and own its pending waits.
+ * @param bus - Bus receiving the authenticated requests.
+ * @param authority - Durable start authorization, shared with credential ingress.
+ * @returns Idempotent cleanup that cancels waits before removing the handler.
+ */
+declare function registerBootstrapStartHandler(bus: IMakaioBus, authority: BootstrapStartAuthority): () => void;
+//#endregion
+//#region subsystems/workflow-engine/src/authority-dispatch-runner.d.ts
+/**
+ * Inputs for dispatching an Authority-owned attempt.
  * @typeParam TOutcome - Owner-specific outcome type committed per attempt.
  */
-interface AttemptOutcomeSubmission<TOutcome> {
-  /** Owner identifier the attempt belongs to. */
+interface AuthorityDispatchRunnerOptions<TOutcome> {
+  /** Authority that persists and owns the execution attempt. */
+  readonly authority: ExecutionAttemptAuthority<TOutcome>;
+  /** Owner identifier of the aggregate that owns the attempt. */
   readonly executionId: ExecutionOwnerId;
-  /** Authority-created attempt identifier. */
-  readonly executionAttemptId: string;
-  /** Outcome the worker submitted. */
-  readonly outcome: TOutcome;
+  /** Complete non-secret assignment frozen before this Attempt can be dispatched. */
+  readonly instruction: ExecutionAttemptInstruction;
+  /** Dispatch operation whose successful return acknowledges acceptance. */
+  readonly dispatch: (executionAttemptId: string) => Promise<unknown>;
 }
 /**
- * Submit an attempt outcome through the generic owner boundary.
- *
- * Order: one canonicalization of the submitted outcome, optional pre-commit
- * validation of that canonical value, durable commit of that same rendering
- * through the authority, owner convergence for `accepted` and `duplicate`,
- * then waiter settlement on a fresh decode of the text the decision reports
- * as committed. The decision kind is returned for the caller's
- * acknowledgement.
+ * Dispatch an Authority-owned attempt and await its canonical outcome.
  *
- * Invariants this function keeps:
- * - the submission is rendered exactly once, and the submitter's object is
- *   never read again after that: an outcome the caller mutates while an await
- *   is pending can reach neither the validation nor the durable write;
- * - validation and convergence see one and the same value: the canonical
- *   outcome the attempt holds, never the submitter's copy of it;
- * - convergence only ever sees `decision.outcome`, the repository's own
- *   committed object;
- * - the waiter settles on a value decoded afresh from the text the attempt
- *   stores — the decision's own text, which for a `duplicate` is the first
- *   commit's rather than the retry's — so what a runner receives is the
- *   committed outcome even when convergence mutated the object it was handed;
- * - a throwing convergence leaves the outcome durably committed and the
- *   waiter pending, so the worker's retry yields `duplicate` and converges
- *   again; nothing is rejected or deleted here. That recovery path runs the
- *   validation again first, which is why {@link OutcomePreCommitValidation}
- *   owes a retry-stable verdict;
- * - `conflict` and `fenced` skip convergence and settlement; their waiter
- *   rejection already happened inside `ExecutionAttemptAuthority.commitOutcome`.
- * @param deps - Authority, convergence, and optional validation.
- * @param input - Attempt identity and submitted outcome.
- * @returns The durable decision kind.
- * @typeParam TOutcome - Owner-specific outcome type committed per attempt.
+ * A rejected dispatch operation is not proof that no provider received the
+ * request. The pending-abandonment CAS distinguishes a confirmed pre-allocation
+ * failure from a lost acknowledgement after provisioning, allocation, or settlement.
+ * @param options - Authority, owner identity, immutable instruction, and dispatch operation.
+ * @returns The Authority-committed outcome.
  */
-declare function submitAttemptOutcome<TOutcome>(deps: AttemptOutcomeSubmissionDeps<TOutcome>, input: AttemptOutcomeSubmission<TOutcome>): Promise<'accepted' | 'duplicate' | 'conflict' | 'fenced'>;
+declare function runAuthorityDispatchedAttempt<TOutcome>(options: AuthorityDispatchRunnerOptions<TOutcome>): Promise<TOutcome>;
 //#endregion
 //#region subsystems/workflow-engine/src/storage/namespace.d.ts
 /**
@@ -1345,8 +1564,8 @@ declare const WorkflowStorageNamespace: _$_makaio_storage_core0.StorageNamespace
           cancelled: "cancelled";
           failed: "failed";
           running: "running";
-          waiting: "waiting";
           skipped: "skipped";
+          waiting: "waiting";
         }>;
         attempt: z.ZodDefault<z.ZodNumber>;
         iteration: z.ZodOptional<z.ZodNumber>;
@@ -1391,8 +1610,8 @@ declare const WorkflowStorageNamespace: _$_makaio_storage_core0.StorageNamespace
           cancelled: "cancelled";
           failed: "failed";
           running: "running";
-          waiting: "waiting";
           skipped: "skipped";
+          waiting: "waiting";
         }>;
         attempt: z.ZodDefault<z.ZodNumber>;
         iteration: z.ZodOptional<z.ZodNumber>;
@@ -1434,8 +1653,8 @@ declare const WorkflowStorageNamespace: _$_makaio_storage_core0.StorageNamespace
           cancelled: "cancelled";
           failed: "failed";
           running: "running";
-          waiting: "waiting";
           skipped: "skipped";
+          waiting: "waiting";
         }>;
         attempt: z.ZodDefault<z.ZodNumber>;
         iteration: z.ZodOptional<z.ZodNumber>;
@@ -1462,8 +1681,8 @@ declare const WorkflowStorageNamespace: _$_makaio_storage_core0.StorageNamespace
         status: z.ZodEnum<{
           cancelled: "cancelled";
           rejected: "rejected";
-          waiting: "waiting";
           resumed: "resumed";
+          waiting: "waiting";
           "timed-out": "timed-out";
         }>;
         autoAction: z.ZodEnum<{
@@ -1594,8 +1813,8 @@ declare const WorkflowStorageNamespace: _$_makaio_storage_core0.StorageNamespace
         status: z.ZodEnum<{
           cancelled: "cancelled";
           rejected: "rejected";
-          waiting: "waiting";
           resumed: "resumed";
+          waiting: "waiting";
           "timed-out": "timed-out";
         }>;
         autoAction: z.ZodEnum<{
@@ -1619,8 +1838,8 @@ declare const WorkflowStorageNamespace: _$_makaio_storage_core0.StorageNamespace
       status: z.ZodOptional<z.ZodEnum<{
         cancelled: "cancelled";
         rejected: "rejected";
-        waiting: "waiting";
         resumed: "resumed";
+        waiting: "waiting";
         "timed-out": "timed-out";
       }>>;
       limit: z.ZodDefault<z.ZodNumber>;
@@ -1635,8 +1854,8 @@ declare const WorkflowStorageNamespace: _$_makaio_storage_core0.StorageNamespace
         status: z.ZodEnum<{
           cancelled: "cancelled";
           rejected: "rejected";
-          waiting: "waiting";
           resumed: "resumed";
+          waiting: "waiting";
           "timed-out": "timed-out";
         }>;
         autoAction: z.ZodEnum<{
@@ -1670,8 +1889,8 @@ declare const WorkflowStorageNamespace: _$_makaio_storage_core0.StorageNamespace
         status: z.ZodEnum<{
           cancelled: "cancelled";
           rejected: "rejected";
-          waiting: "waiting";
           resumed: "resumed";
+          waiting: "waiting";
           "timed-out": "timed-out";
         }>;
         autoAction: z.ZodEnum<{
@@ -2374,7 +2593,7 @@ declare const WorkflowStorageNamespace: _$_makaio_storage_core0.StorageNamespace
           tableName: "workflow_definitions";
           dataType: "string";
           columnType: "SQLiteText";
-          data: "external" | "session" | "global" | "workspace";
+          data: "external" | "session" | "workspace" | "global";
           driverParam: string;
           notNull: true;
           hasDefault: false;
@@ -2387,7 +2606,7 @@ declare const WorkflowStorageNamespace: _$_makaio_storage_core0.StorageNamespace
           generated: undefined;
         }, {}, {
           length: number | undefined;
-          $type: "external" | "session" | "global" | "workspace";
+          $type: "external" | "session" | "workspace" | "global";
         }>;
         scopeKind: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
           name: "scope_kind";
@@ -2685,7 +2904,7 @@ declare const WorkflowStorageNamespace: _$_makaio_storage_core0.StorageNamespace
           tableName: "workflow_executions";
           dataType: "string";
           columnType: "SQLiteText";
-          data: "external" | "session" | "global" | "workspace";
+          data: "external" | "session" | "workspace" | "global";
           driverParam: string;
           notNull: true;
           hasDefault: false;
@@ -2698,7 +2917,7 @@ declare const WorkflowStorageNamespace: _$_makaio_storage_core0.StorageNamespace
           generated: undefined;
         }, {}, {
           length: number | undefined;
-          $type: "external" | "session" | "global" | "workspace";
+          $type: "external" | "session" | "workspace" | "global";
         }>;
         scopeKind: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
           name: "scope_kind";
@@ -3127,7 +3346,7 @@ declare const WorkflowStorageNamespace: _$_makaio_storage_core0.StorageNamespace
           tableName: "workflow_execution_frames";
           dataType: "string";
           columnType: "SQLiteText";
-          data: "pending" | "completed" | "cancelled" | "failed" | "running" | "waiting" | "skipped";
+          data: "pending" | "completed" | "cancelled" | "failed" | "running" | "skipped" | "waiting";
           driverParam: string;
           notNull: true;
           hasDefault: true;
@@ -3140,7 +3359,7 @@ declare const WorkflowStorageNamespace: _$_makaio_storage_core0.StorageNamespace
           generated: undefined;
         }, {}, {
           length: number | undefined;
-          $type: "pending" | "completed" | "cancelled" | "failed" | "running" | "waiting" | "skipped";
+          $type: "pending" | "completed" | "cancelled" | "failed" | "running" | "skipped" | "waiting";
         }>;
         attempt: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
           name: string;
@@ -3410,7 +3629,7 @@ declare const WorkflowStorageNamespace: _$_makaio_storage_core0.StorageNamespace
           tableName: "workflow_gate_instances";
           dataType: "string";
           columnType: "SQLiteText";
-          data: "cancelled" | "rejected" | "waiting" | "resumed" | "timed-out";
+          data: "cancelled" | "rejected" | "resumed" | "waiting" | "timed-out";
           driverParam: string;
           notNull: true;
           hasDefault: true;
@@ -3423,7 +3642,7 @@ declare const WorkflowStorageNamespace: _$_makaio_storage_core0.StorageNamespace
           generated: undefined;
         }, {}, {
           length: number | undefined;
-          $type: "cancelled" | "rejected" | "waiting" | "resumed" | "timed-out";
+          $type: "cancelled" | "rejected" | "resumed" | "waiting" | "timed-out";
         }>;
         autoAction: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
           name: "auto_action";
@@ -4404,7 +4623,7 @@ declare const WorkflowStorageNamespace: _$_makaio_storage_core0.StorageNamespace
           tableName: "workflow_run_contexts";
           dataType: "string";
           columnType: "SQLiteText";
-          data: "external" | "session" | "global" | "workspace";
+          data: "external" | "session" | "workspace" | "global";
           driverParam: string;
           notNull: true;
           hasDefault: true;
@@ -4417,7 +4636,7 @@ declare const WorkflowStorageNamespace: _$_makaio_storage_core0.StorageNamespace
           generated: undefined;
         }, {}, {
           length: number | undefined;
-          $type: "external" | "session" | "global" | "workspace";
+          $type: "external" | "session" | "workspace" | "global";
         }>;
         scopeKind: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
           name: "scope_kind";
@@ -4922,7 +5141,7 @@ declare const WorkflowStorageNamespace: _$_makaio_storage_core0.StorageNamespace
           tableName: "worklog_frame_entries";
           dataType: "string";
           columnType: "SQLiteText";
-          data: "pending" | "completed" | "cancelled" | "failed" | "running" | "waiting" | "skipped";
+          data: "pending" | "completed" | "cancelled" | "failed" | "running" | "skipped" | "waiting";
           driverParam: string;
           notNull: true;
           hasDefault: false;
@@ -5356,7 +5575,7 @@ declare const WorkflowStorageNamespace: _$_makaio_storage_core0.StorageNamespace
           tableName: "worklog_gate_events";
           dataType: "string";
           columnType: "SQLiteText";
-          data: "cancelled" | "rejected" | "waiting" | "resumed" | "timed-out";
+          data: "cancelled" | "rejected" | "resumed" | "waiting" | "timed-out";
           driverParam: string;
           notNull: true;
           hasDefault: false;
@@ -5369,7 +5588,7 @@ declare const WorkflowStorageNamespace: _$_makaio_storage_core0.StorageNamespace
           generated: undefined;
         }, {}, {
           length: number | undefined;
-          $type: "cancelled" | "rejected" | "waiting" | "resumed" | "timed-out";
+          $type: "cancelled" | "rejected" | "resumed" | "waiting" | "timed-out";
         }>;
         prompt: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
           name: "prompt";
@@ -6968,8 +7187,8 @@ declare const WorkflowStorageSubjects: _$_makaio_core0.BusSubjects<_$_makaio_cor
           cancelled: "cancelled";
           failed: "failed";
           running: "running";
-          waiting: "waiting";
           skipped: "skipped";
+          waiting: "waiting";
         }>;
         attempt: z.ZodDefault<z.ZodNumber>;
         iteration: z.ZodOptional<z.ZodNumber>;
@@ -7014,8 +7233,8 @@ declare const WorkflowStorageSubjects: _$_makaio_core0.BusSubjects<_$_makaio_cor
           cancelled: "cancelled";
           failed: "failed";
           running: "running";
-          waiting: "waiting";
           skipped: "skipped";
+          waiting: "waiting";
         }>;
         attempt: z.ZodDefault<z.ZodNumber>;
         iteration: z.ZodOptional<z.ZodNumber>;
@@ -7057,8 +7276,8 @@ declare const WorkflowStorageSubjects: _$_makaio_core0.BusSubjects<_$_makaio_cor
           cancelled: "cancelled";
           failed: "failed";
           running: "running";
-          waiting: "waiting";
           skipped: "skipped";
+          waiting: "waiting";
         }>;
         attempt: z.ZodDefault<z.ZodNumber>;
         iteration: z.ZodOptional<z.ZodNumber>;
@@ -7085,8 +7304,8 @@ declare const WorkflowStorageSubjects: _$_makaio_core0.BusSubjects<_$_makaio_cor
         status: z.ZodEnum<{
           cancelled: "cancelled";
           rejected: "rejected";
-          waiting: "waiting";
           resumed: "resumed";
+          waiting: "waiting";
           "timed-out": "timed-out";
         }>;
         autoAction: z.ZodEnum<{
@@ -7217,8 +7436,8 @@ declare const WorkflowStorageSubjects: _$_makaio_core0.BusSubjects<_$_makaio_cor
         status: z.ZodEnum<{
           cancelled: "cancelled";
           rejected: "rejected";
-          waiting: "waiting";
           resumed: "resumed";
+          waiting: "waiting";
           "timed-out": "timed-out";
         }>;
         autoAction: z.ZodEnum<{
@@ -7242,8 +7461,8 @@ declare const WorkflowStorageSubjects: _$_makaio_core0.BusSubjects<_$_makaio_cor
       status: z.ZodOptional<z.ZodEnum<{
         cancelled: "cancelled";
         rejected: "rejected";
-        waiting: "waiting";
         resumed: "resumed";
+        waiting: "waiting";
         "timed-out": "timed-out";
       }>>;
       limit: z.ZodDefault<z.ZodNumber>;
@@ -7258,8 +7477,8 @@ declare const WorkflowStorageSubjects: _$_makaio_core0.BusSubjects<_$_makaio_cor
         status: z.ZodEnum<{
           cancelled: "cancelled";
           rejected: "rejected";
-          waiting: "waiting";
           resumed: "resumed";
+          waiting: "waiting";
           "timed-out": "timed-out";
         }>;
         autoAction: z.ZodEnum<{
@@ -7293,8 +7512,8 @@ declare const WorkflowStorageSubjects: _$_makaio_core0.BusSubjects<_$_makaio_cor
         status: z.ZodEnum<{
           cancelled: "cancelled";
           rejected: "rejected";
-          waiting: "waiting";
           resumed: "resumed";
+          waiting: "waiting";
           "timed-out": "timed-out";
         }>;
         autoAction: z.ZodEnum<{
@@ -7963,7 +8182,7 @@ declare const workflowDefinitionsDual: _$_makaio_storage_drizzle0.DualTable<"wor
     materializationModes?: ("local-directory" | "workspace-snapshot")[] | undefined;
   }>>; /** Definition-owned finalizer selected after successful execution. */
   successFinalizerId: _$_makaio_storage_drizzle0.DualBuilder<_$drizzle_orm_sqlite_core0.SQLiteTextBuilderInitial<"success_finalizer_id", [string, ...string[]], number | undefined>, _$drizzle_orm_pg_core0.PgTextBuilderInitial<"success_finalizer_id", [string, ...string[]]>>;
-  scopeType: _$_makaio_storage_drizzle0.DualBuilder<_$drizzle_orm0.$Type<_$drizzle_orm0.NotNull<_$drizzle_orm_sqlite_core0.SQLiteTextBuilderInitial<"scope_type", ["global", "workspace", "session", "external"], number | undefined>>, "external" | "session" | "global" | "workspace">, _$drizzle_orm0.$Type<_$drizzle_orm0.NotNull<_$drizzle_orm_pg_core0.PgTextBuilderInitial<"scope_type", ["global", "workspace", "session", "external"]>>, "external" | "session" | "global" | "workspace">>;
+  scopeType: _$_makaio_storage_drizzle0.DualBuilder<_$drizzle_orm0.$Type<_$drizzle_orm0.NotNull<_$drizzle_orm_sqlite_core0.SQLiteTextBuilderInitial<"scope_type", ["global", "workspace", "session", "external"], number | undefined>>, "external" | "session" | "workspace" | "global">, _$drizzle_orm0.$Type<_$drizzle_orm0.NotNull<_$drizzle_orm_pg_core0.PgTextBuilderInitial<"scope_type", ["global", "workspace", "session", "external"]>>, "external" | "session" | "workspace" | "global">>;
   scopeKind: _$_makaio_storage_drizzle0.DualBuilder<_$drizzle_orm0.HasDefault<_$drizzle_orm0.NotNull<_$drizzle_orm_sqlite_core0.SQLiteTextBuilderInitial<"scope_kind", [string, ...string[]], number | undefined>>>, _$drizzle_orm0.HasDefault<_$drizzle_orm0.NotNull<_$drizzle_orm_pg_core0.PgTextBuilderInitial<"scope_kind", [string, ...string[]]>>>>;
   scopeId: _$_makaio_storage_drizzle0.DualBuilder<_$drizzle_orm0.HasDefault<_$drizzle_orm0.NotNull<_$drizzle_orm_sqlite_core0.SQLiteTextBuilderInitial<"scope_id", [string, ...string[]], number | undefined>>>, _$drizzle_orm0.HasDefault<_$drizzle_orm0.NotNull<_$drizzle_orm_pg_core0.PgTextBuilderInitial<"scope_id", [string, ...string[]]>>>>; /** Unique workflow identifier. */
   id: _$_makaio_storage_drizzle0.DualBuilder<_$drizzle_orm0.IsPrimaryKey<_$drizzle_orm0.NotNull<_$drizzle_orm_sqlite_core0.SQLiteTextBuilderInitial<"id", [string, ...string[]], number | undefined>>>, _$drizzle_orm0.IsPrimaryKey<_$drizzle_orm0.NotNull<_$drizzle_orm_pg_core0.PgTextBuilderInitial<"id", [string, ...string[]]>>>>; /** Workflow name. */
@@ -8046,7 +8265,7 @@ declare const workflowDefinitionsDual: _$_makaio_storage_drizzle0.DualTable<"wor
  * Stores runtime state of workflow executions.
  */
 declare const workflowExecutionsDual: _$_makaio_storage_drizzle0.DualTable<"workflow_executions", {
-  scopeType: _$_makaio_storage_drizzle0.DualBuilder<_$drizzle_orm0.$Type<_$drizzle_orm0.NotNull<_$drizzle_orm_sqlite_core0.SQLiteTextBuilderInitial<"scope_type", ["global", "workspace", "session", "external"], number | undefined>>, "external" | "session" | "global" | "workspace">, _$drizzle_orm0.$Type<_$drizzle_orm0.NotNull<_$drizzle_orm_pg_core0.PgTextBuilderInitial<"scope_type", ["global", "workspace", "session", "external"]>>, "external" | "session" | "global" | "workspace">>;
+  scopeType: _$_makaio_storage_drizzle0.DualBuilder<_$drizzle_orm0.$Type<_$drizzle_orm0.NotNull<_$drizzle_orm_sqlite_core0.SQLiteTextBuilderInitial<"scope_type", ["global", "workspace", "session", "external"], number | undefined>>, "external" | "session" | "workspace" | "global">, _$drizzle_orm0.$Type<_$drizzle_orm0.NotNull<_$drizzle_orm_pg_core0.PgTextBuilderInitial<"scope_type", ["global", "workspace", "session", "external"]>>, "external" | "session" | "workspace" | "global">>;
   scopeKind: _$_makaio_storage_drizzle0.DualBuilder<_$drizzle_orm0.HasDefault<_$drizzle_orm0.NotNull<_$drizzle_orm_sqlite_core0.SQLiteTextBuilderInitial<"scope_kind", [string, ...string[]], number | undefined>>>, _$drizzle_orm0.HasDefault<_$drizzle_orm0.NotNull<_$drizzle_orm_pg_core0.PgTextBuilderInitial<"scope_kind", [string, ...string[]]>>>>;
   scopeId: _$_makaio_storage_drizzle0.DualBuilder<_$drizzle_orm0.HasDefault<_$drizzle_orm0.NotNull<_$drizzle_orm_sqlite_core0.SQLiteTextBuilderInitial<"scope_id", [string, ...string[]], number | undefined>>>, _$drizzle_orm0.HasDefault<_$drizzle_orm0.NotNull<_$drizzle_orm_pg_core0.PgTextBuilderInitial<"scope_id", [string, ...string[]]>>>>; /** Unique execution identifier. */
   id: _$_makaio_storage_drizzle0.DualBuilder<_$drizzle_orm0.IsPrimaryKey<_$drizzle_orm0.NotNull<_$drizzle_orm_sqlite_core0.SQLiteTextBuilderInitial<"id", [string, ...string[]], number | undefined>>>, _$drizzle_orm0.IsPrimaryKey<_$drizzle_orm0.NotNull<_$drizzle_orm_pg_core0.PgTextBuilderInitial<"id", [string, ...string[]]>>>>; /** Workflow definition or ephemeral source execution identifier. */
@@ -8222,4 +8441,4 @@ declare function patchWorkflowState(db: MakaioDatabase, params: {
   value: JsonValue;
 }>;
 //#endregion
-export { type AllocationRecordingDecision, type AllocationRefEvolution, type AllocationRefEvolutionDecision, type AllocationTerminationDecision, type AttemptOutcomeSubmission, type AttemptOutcomeSubmissionDeps, type AuthorityDispatchRunnerOptions, type BeginProvisioningInput, type DiscoveredAllocationDecision, DuplicateExecutionAttemptError, type DurableOutcome, EXECUTION_ATTEMPT_SETTLEMENT_KINDS, EXECUTION_ATTEMPT_STATUSES, ExecutionAttemptAuthority, type ExecutionAttemptCreate, type ExecutionAttemptOutcomeCommit, type ExecutionAttemptOutcomeDecision, type ExecutionAttemptRecord, type ExecutionAttemptRecoveryOperations, type ExecutionAttemptRepository, type ExecutionAttemptSettlementKind, type ExecutionAttemptStatus, type ExecutionOwnerId, type HandoffProviderOperationInput, type InfrastructureFailureDecision, type InitialProviderOperationClaimContext, type InitialProviderOperationClaimContextSource, type OutcomeCodec, type OutcomeConvergence, type OutcomeConvergenceInput, type OutcomePreCommitValidation, PROVIDER_OPERATION_OBLIGATIONS, type PendingAttemptAbandonmentDecision, type ProcessBoundProvisionerLossProof, type ProviderOperationClaim, type ProviderOperationClaimDecision, type ProviderOperationMutationDecision, type ProviderOperationObligation, type ProviderOperationOwnershipRecord, type ProvisionerIncarnationLossDecision, type ProvisioningAbsenceDecision, type ProvisioningClaimDecision, type RecordAllocationInput, type RecordAllocationTerminatedInput, type RecordInfrastructureFailureInput, type RecordProviderOperationUncertaintyInput, type RecordProvisionerIncarnationLostInput, type RecordProvisioningAbsentInput, type RecoverableAttemptRecord, type RenewProviderOperationClaimInput, type TakeOverProviderOperationInput, WorkflowEngineService, type WorkflowEngineServiceOptions, WorkflowEngineToken, WorkflowExecutor, type WorkflowMaterializationSpecResolution, type WorkflowMaterializationSpecResolver, WorkflowStorageNamespace, WorkflowStorageSubjects, type WorkflowSuccessFinalizer, type WorkflowTriggerPayloadPredicate, WorkflowTriggerReconciler, type WorkflowWorkspaceRootResolver, assertWorkflowTriggerPayload, buildWorkflowExpressionContextFromResolvedInputs, compileWorkflowTriggerBindingFilter, createWorkflowEnginePackage, decodeDurableOutcome, durableOutcome, getWorkflowState, initializeWorkflowState, patchWorkflowState, registerDrizzleWorkflowStorage, runAuthorityDispatchedAttempt, runShellStep, sameAllocationRef, sameDurableOutcome, submitAttemptOutcome, workflowDefinitionsDual, workflowEnginePackage, workflowExecutionStateDual, workflowExecutionStateEventsDual, workflowExecutionsDual, workflowFinalizationsDual, workflowStepSpansDual, worklogFrameEntriesDual, worklogSummariesDual };
+export { ATTEMPT_OPERATION_START_GATES, type AdmitOperationInput, type AllocationRecordingDecision, type AllocationRefEvolution, type AllocationRefEvolutionDecision, type AllocationTerminationDecision, type AttemptControlState, type AttemptOperationStartGate, type AttemptOutcomeDecodingInput, type AttemptOutcomeSubmission, type AttemptOutcomeSubmissionDeps, type AttemptReachability, type AttemptReachabilityDecision, type AuthorityDispatchRunnerOptions, type BeginProvisioningInput, type BootstrapStartAuthority, type BootstrapStartOptions, type BootstrapStartState, type BuildWorkflowAttemptInstructionOptions, type CommittedWorkflowOutcomeIdentity, type CompleteOperationInput, type DiscoveredAllocationDecision, DuplicateExecutionAttemptError, type DurableOutcome, EXECUTION_ATTEMPT_SETTLEMENT_KINDS, EXECUTION_ATTEMPT_STATUSES, ExecutionAttemptAuthority, type ExecutionAttemptCreate, type ExecutionAttemptHandlersDeps, type ExecutionAttemptOutcomeCommit, type ExecutionAttemptOutcomeDecision, type ExecutionAttemptPeerIdentity, type ExecutionAttemptRecord, type ExecutionAttemptRecoveryOperations, type ExecutionAttemptRepository, type ExecutionAttemptSettlementKind, type ExecutionAttemptStatus, type ExecutionOwnerId, type HandoffProviderOperationInput, type InfrastructureFailureDecision, type InitialProviderOperationClaimContext, type InitialProviderOperationClaimContextSource, type MarkRuntimeReadyInput, type OperationAdmissionDecision, type OperationAdmissionDeps, type OperationCompletionDecision, type OutcomeCodec, type OutcomeConvergence, type OutcomeConvergenceInput, type OutcomePreCommitValidation, PROVIDER_OPERATION_OBLIGATIONS, type PendingAttemptAbandonmentDecision, type ProcessBoundProvisionerLossProof, type ProviderOperationClaim, type ProviderOperationClaimDecision, type ProviderOperationMutationDecision, type ProviderOperationObligation, type ProviderOperationOwnershipRecord, type ProvisionerIncarnationLossDecision, type ProvisioningAbsenceDecision, type ProvisioningClaimDecision, RUNTIME_PROBE_DELIVERY_TIMEOUT_MS, type ReadBootstrapStartStateInput, type RecordAllocationInput, type RecordAllocationTerminatedInput, type RecordInfrastructureFailureInput, type RecordProviderOperationUncertaintyInput, type RecordProvisionerIncarnationLostInput, type RecordProvisioningAbsentInput, type RecoverableAttemptRecord, type RegisterRuntimeInput, type RenewProviderOperationClaimInput, type RuntimeOutcomeFence, RuntimeOutcomeFenceMismatchError, type RuntimeReadinessDecision, type RuntimeRegistrationDecision, type RuntimeRegistrationDeps, type TakeOverProviderOperationInput, WORKFLOW_WORKLOAD_KIND, WORKFLOW_WORKLOAD_VERSION, type WorkflowAttemptCancellation, type WorkflowAttemptOutcome, WorkflowAttemptOutcomeSchema, type WorkflowAttemptTechnicalFailure, WorkflowEngineService, type WorkflowEngineServiceOptions, WorkflowEngineToken, WorkflowExecutor, type WorkflowInvocationInput, WorkflowInvocationInputSchema, type WorkflowMaterializationSpecResolution, type WorkflowMaterializationSpecResolver, WorkflowStorageNamespace, WorkflowStorageSubjects, type WorkflowSuccessFinalizer, type WorkflowTriggerPayloadPredicate, WorkflowTriggerReconciler, type WorkflowWorkspaceRootResolver, assertRuntimeOutcomeFence, assertWorkflowTriggerPayload, buildWorkflowAttemptInstruction, buildWorkflowExpressionContextFromResolvedInputs, compileWorkflowTriggerBindingFilter, createWorkflowEnginePackage, decodeDurableOutcome, decodeWorkflowAttemptOutcome, durableOutcome, evaluateAttemptReachability, evaluateOperationAdmission, evaluateOperationCompletion, evaluateRuntimeReadiness, evaluateRuntimeRegistration, getWorkflowState, initializeWorkflowState, parseWorkflowAttemptInstruction, patchWorkflowState, registerBootstrapStartHandler, registerDrizzleWorkflowStorage, registerExecutionAttemptHandlers, registerOperationAdmissionHandler, registerRuntimeRegistrationHandler, resolveExecutionAttemptPeer, runAuthorityDispatchedAttempt, runShellStep, sameAllocationRef, sameDurableOutcome, submitAttemptOutcome, toCommittedWorkflowRunnerResult, workflowAttemptOutcomeCodec, workflowDefinitionsDual, workflowEnginePackage, workflowExecutionStateDual, workflowExecutionStateEventsDual, workflowExecutionsDual, workflowFinalizationsDual, workflowStepSpansDual, worklogFrameEntriesDual, worklogSummariesDual };