create-safest-tools 0.2.0

package/template/src/workflow-dynamic-runtime.ts

@@ -0,0 +1,613 @@
+import {
+  createDynamicWorkflowEntrypoint,
+  DynamicWorkflowBinding,
+  wrapWorkflowBinding,
+  type WorkflowRunner,
+} from "@cloudflare/dynamic-workflows";
+import { WorkerEntrypoint } from "cloudflare:workers";
+import { canonicalJson } from "./audit";
+import {
+  ComponentExecutionError,
+  executeReadOnlyComponent,
+  loadWorkflowExecutionContext,
+} from "./component-executor";
+import { executeAgentProposal } from "./agent-executor";
+import { sha256 } from "./report-crypto";
+import { evaluateInputMapping, evaluateWorkflowExpression } from "./workflow-expressions";
+import {
+  handoffWorkflowReport,
+  recordWorkflowDecision,
+  sendWorkflowMessage,
+  WorkflowEffectError,
+} from "./workflow-effects";
+import { completeWorkflowAction, prepareWorkflowAction } from "./workflow-actions";
+import { createLinkedWorkflowRun } from "./workflow-runs";
+import { parseWorkflowGraph } from "./workflow-platform-validation";
+import type { JsonObject, JsonValue, WorkflowAuthorityMode, WorkflowGraphV1, WorkflowNodeV1 } from "./workflow-platform-types";
+
+export { DynamicWorkflowBinding };
+
+interface RuntimeProps {
+  artifactId: string;
+  workflowVersionId: string;
+}
+
+interface RuntimeNodeRequest {
+  runId: string;
+  nodeId: string;
+  nodeKind: string;
+  branchKey?: string;
+  authorityMode: WorkflowAuthorityMode;
+  input?: JsonObject;
+}
+
+interface RuntimeWaitRequest {
+  runId: string;
+  nodeId: string;
+  nodeKind: "human_task" | "wait_for_event";
+  branchKey?: string;
+  authorityMode: WorkflowAuthorityMode;
+}
+
+interface RuntimeCompleteWaitRequest {
+  runId: string;
+  nodeId: string;
+  branchKey?: string;
+  authorityMode: WorkflowAuthorityMode;
+  eventResult: { status: "received"; event: unknown } | { status: "timed_out" };
+}
+
+interface RuntimeActionRequest extends RuntimeNodeRequest {
+  nodeKind: "action";
+}
+
+interface RuntimeCompleteActionRequest extends RuntimeActionRequest {
+  proposalId: string;
+  eventResult: { status: "received"; event: unknown } | { status: "timed_out" };
+}
+
+interface RuntimeFailureRequest extends RuntimeNodeRequest {
+  errorCode: string;
+}
+
+interface ArtifactRow {
+  id: string;
+  workflowVersionId: string;
+  compatibilityDate: string;
+  bundleDigest: string;
+  bundleR2Key: string | null;
+  inlineSourceText: string | null;
+  status: string;
+}
+
+interface AuthorizedRun {
+  id: string;
+  workflowVersionId: string;
+  authorityMode: WorkflowAuthorityMode;
+  state: string;
+  graph: WorkflowGraphV1;
+}
+
+function now(): string {
+  return new Date().toISOString();
+}
+
+function cleanIdentifier(value: unknown, name: string, maximum = 200): string {
+  if (typeof value !== "string" || value.length < 1 || value.length > maximum || !/^[A-Za-z0-9._:-]+$/u.test(value)) {
+    throw new Error(`runtime_invalid_${name}`);
+  }
+  return value;
+}
+
+async function artifactRow(env: Env, artifactId: string, workflowVersionId: string): Promise<ArtifactRow> {
+  const row = await env.DB.prepare(`
+    SELECT a.id, v.id AS workflowVersionId, a.compatibility_date AS compatibilityDate,
+      a.bundle_digest AS bundleDigest, a.bundle_r2_key AS bundleR2Key,
+      a.inline_source_text AS inlineSourceText, a.status
+    FROM workflow_artifacts a JOIN workflow_versions v ON v.artifact_id = a.id
+    WHERE a.id = ?1 AND v.id = ?2 AND v.retired_at IS NULL LIMIT 1
+  `).bind(artifactId, workflowVersionId).first<ArtifactRow>();
+  if (!row || row.status !== "ready") throw new Error("workflow_artifact_not_ready");
+  return row;
+}
+
+async function artifactSource(env: Env, artifact: ArtifactRow): Promise<string> {
+  let source = artifact.inlineSourceText;
+  if (!source && artifact.bundleR2Key) source = await (await env.WORKFLOW_ARTIFACTS.get(artifact.bundleR2Key))?.text() ?? null;
+  if (!source) throw new Error("workflow_artifact_missing");
+  if (`sha256:${await sha256(source)}` !== artifact.bundleDigest) throw new Error("workflow_artifact_digest_mismatch");
+  return source;
+}
+
+function runtimeStub(ctx: ExecutionContext, props: RuntimeProps): Fetcher {
+  return ctx.exports.WorkflowRuntimeCapability({ props }) as unknown as Fetcher;
+}
+
+async function loadCompiledWorkflow(env: Env, ctx: ExecutionContext, metadata: RuntimeProps) {
+  const artifact = await artifactRow(env, metadata.artifactId, metadata.workflowVersionId);
+  const stub = env.LOADER.get(`workflow-version:${metadata.workflowVersionId}`, async () => ({
+    compatibilityDate: artifact.compatibilityDate,
+    mainModule: "workflow.mjs",
+    modules: { "workflow.mjs": await artifactSource(env, artifact) },
+    env: {
+      WORKFLOWS: wrapWorkflowBinding({
+        artifactId: metadata.artifactId,
+        workflowVersionId: metadata.workflowVersionId,
+      }),
+      RUNTIME: runtimeStub(ctx, metadata),
+    },
+    globalOutbound: null,
+    limits: { cpuMs: 30_000, subRequests: 50 },
+  }));
+  return stub;
+}
+
+export const DynamicWorkflow = createDynamicWorkflowEntrypoint<Env>(
+  async ({ env, ctx, metadata }) => {
+    const artifactId = cleanIdentifier(metadata.artifactId, "artifact_id");
+    const workflowVersionId = cleanIdentifier(metadata.workflowVersionId, "workflow_version_id");
+    const stub = await loadCompiledWorkflow(env, ctx, { artifactId, workflowVersionId });
+    return stub.getEntrypoint("TenantWorkflow") as unknown as WorkflowRunner;
+  },
+);
+
+async function authorizedRun(env: Env, props: RuntimeProps, input: RuntimeNodeRequest | RuntimeWaitRequest | RuntimeCompleteWaitRequest): Promise<AuthorizedRun> {
+  const runId = cleanIdentifier(input.runId, "run_id");
+  const row = await env.DB.prepare(`
+    SELECT r.id, r.workflow_version_id AS workflowVersionId,
+      r.authority_mode AS authorityMode, r.state, v.graph_json AS graphJson,
+      v.artifact_id AS artifactId
+    FROM workflow_runs r JOIN workflow_versions v ON v.id = r.workflow_version_id
+    WHERE r.id = ?1 LIMIT 1
+  `).bind(runId).first<{
+    id: string;
+    workflowVersionId: string;
+    authorityMode: WorkflowAuthorityMode;
+    state: string;
+    graphJson: string;
+    artifactId: string;
+  }>();
+  if (!row || row.workflowVersionId !== props.workflowVersionId || row.artifactId !== props.artifactId) throw new Error("runtime_capability_denied");
+  if (row.authorityMode !== input.authorityMode) throw new Error("runtime_authority_mismatch");
+  if (["succeeded", "failed", "terminated", "superseded"].includes(row.state)) throw new Error("runtime_run_terminal");
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(row.graphJson);
+  } catch {
+    throw new Error("runtime_graph_invalid");
+  }
+  return { id: row.id, workflowVersionId: row.workflowVersionId, authorityMode: row.authorityMode, state: row.state, graph: parseWorkflowGraph(parsed) };
+}
+
+function authorizedNode(run: AuthorizedRun, nodeIdValue: unknown, nodeKindValue?: unknown): WorkflowNodeV1 {
+  const nodeId = cleanIdentifier(nodeIdValue, "node_id", 100);
+  const node = run.graph.nodes.find((candidate) => candidate.id === nodeId);
+  if (!node || (nodeKindValue !== undefined && node.kind !== nodeKindValue)) throw new Error("runtime_node_denied");
+  return node;
+}
+
+function stepRunId(runId: string, nodeId: string, branchKey: string): string {
+  return `${runId}:${nodeId}:${branchKey || "main"}:1`;
+}
+
+function outputPort(node: WorkflowNodeV1): string {
+  switch (node.kind) {
+    case "start": return "success";
+    case "join": return "success";
+    case "delay":
+    case "delay_until": return "completed";
+    case "end": return "terminal";
+    default: throw new Error(`runtime_node_output_port_invalid:${node.kind}`);
+  }
+}
+
+function shadowSimulation(node: WorkflowNodeV1): Record<string, unknown> | null {
+  const ports: Partial<Record<WorkflowNodeV1["kind"], string>> = {
+    human_task: "completed",
+    send_message: "sent",
+    decision: "recorded",
+    handoff: "handed_off",
+    start_linked_workflow: "started",
+  };
+  const port = ports[node.kind];
+  return port ? {
+    port,
+    simulated: true,
+    effectSuppressed: true,
+    simulationCode: `shadow_${node.kind}_suppressed`,
+  } : null;
+}
+
+function conditionCases(node: WorkflowNodeV1): { port: string; when: JsonValue }[] {
+  const configured = node.config.cases;
+  if (Array.isArray(configured)) {
+    return configured.flatMap((entry) => {
+      if (!entry || typeof entry !== "object" || Array.isArray(entry)) return [];
+      const port = typeof entry.port === "string" ? entry.port : null;
+      return port && "when" in entry ? [{ port, when: entry.when }] : [];
+    });
+  }
+  if (configured && typeof configured === "object") {
+    return Object.entries(configured).map(([port, when]) => ({ port, when }));
+  }
+  return [];
+}
+
+async function executeCondition(
+  env: Env,
+  run: AuthorizedRun,
+  node: WorkflowNodeV1,
+  branchKey: string,
+): Promise<Record<string, unknown>> {
+  const loaded = await loadWorkflowExecutionContext(env, run.id, branchKey);
+  const nodeInput = evaluateInputMapping(node.inputMapping, loaded.context);
+  const context = { ...loaded.context, node_input: nodeInput };
+  const matched = conditionCases(node).filter((candidate) => evaluateWorkflowExpression(candidate.when, context) === true);
+  if (matched.length > 1) throw new Error("condition_not_mutually_exclusive");
+  const port = matched[0]?.port ?? (typeof node.config.default_port === "string" ? node.config.default_port : null);
+  const allowed = Array.isArray(node.config.case_ports) ? node.config.case_ports.filter((entry): entry is string => typeof entry === "string") : [];
+  if (!port || (!allowed.includes(port) && port !== node.config.default_port)) throw new Error("condition_port_invalid");
+  return { port, matched: matched[0]?.port ?? null, input: nodeInput };
+}
+
+async function recordSuccessfulStep(
+  env: Env,
+  run: AuthorizedRun,
+  node: WorkflowNodeV1,
+  branchKey: string,
+  output: Record<string, unknown>,
+): Promise<void> {
+  const timestamp = now();
+  const id = stepRunId(run.id, node.id, branchKey);
+  const outputJson = canonicalJson(output);
+  const outputDigest = `sha256:${await sha256(outputJson)}`;
+  await env.DB.batch([
+    env.DB.prepare(`
+      INSERT INTO workflow_step_runs (
+        id, run_id, node_id, node_type, branch_key, occurrence, state,
+        output_digest, started_at, finished_at, updated_at
+      ) VALUES (?1, ?2, ?3, ?4, ?5, 1, 'succeeded', ?6, ?7, ?7, ?7)
+      ON CONFLICT(run_id, node_id, branch_key, occurrence) DO UPDATE SET
+        state = 'succeeded', output_digest = excluded.output_digest,
+        finished_at = excluded.finished_at, updated_at = excluded.updated_at
+    `).bind(id, run.id, node.id, node.kind, branchKey, outputDigest, timestamp),
+    env.DB.prepare(`
+      INSERT INTO workflow_step_outputs (
+        step_run_id, inline_json, digest, size_bytes, data_classification_json, created_at
+      ) VALUES (?1, ?2, ?3, ?4, '[]', ?5)
+      ON CONFLICT(step_run_id) DO UPDATE SET
+        inline_json = excluded.inline_json, digest = excluded.digest,
+        size_bytes = excluded.size_bytes
+    `).bind(id, outputJson, outputDigest, new TextEncoder().encode(outputJson).byteLength, timestamp),
+    env.DB.prepare(`
+      UPDATE workflow_runs SET state = CASE WHEN state IN ('created','dispatch_pending','queued','waiting') THEN 'running' ELSE state END,
+        current_node_id = ?2, started_at = COALESCE(started_at, ?3), waiting_at = NULL,
+        updated_at = ?3, revision = revision + 1 WHERE id = ?1
+    `).bind(run.id, node.id, timestamp),
+  ]);
+}
+
+async function recordDelayPreparation(
+  env: Env,
+  run: AuthorizedRun,
+  node: WorkflowNodeV1,
+  branchKey: string,
+  timestamp: string,
+): Promise<void> {
+  const updatedAt = now();
+  const id = stepRunId(run.id, node.id, branchKey);
+  await env.DB.batch([
+    env.DB.prepare(`
+      INSERT INTO workflow_step_runs (
+        id, run_id, node_id, node_type, branch_key, occurrence, state,
+        started_at, waiting_at, updated_at
+      ) VALUES (?1, ?2, ?3, ?4, ?5, 1, 'waiting', ?6, ?6, ?6)
+      ON CONFLICT(run_id, node_id, branch_key, occurrence) DO UPDATE SET
+        state = 'waiting', waiting_at = excluded.waiting_at,
+        started_at = COALESCE(workflow_step_runs.started_at, excluded.started_at),
+        updated_at = excluded.updated_at
+    `).bind(id, run.id, node.id, node.kind, branchKey, updatedAt),
+    env.DB.prepare(`
+      UPDATE workflow_runs SET state = 'waiting', current_node_id = ?2,
+        waiting_at = ?3, started_at = COALESCE(started_at, ?3),
+        updated_at = ?3, revision = revision + 1 WHERE id = ?1
+    `).bind(run.id, node.id, updatedAt),
+    env.DB.prepare(`
+      INSERT OR IGNORE INTO audit_events (
+        id, idempotency_key, action, actor_type, actor_id,
+        target_type, target_id, details_json, created_at
+      ) VALUES (?1, ?2, 'workflow.delay_scheduled', 'system', 'workflow-runtime',
+        'workflow_run', ?3, ?4, ?5)
+    `).bind(crypto.randomUUID(), `workflow-delay:${id}`, run.id, canonicalJson({ nodeId: node.id, resumeAt: timestamp }), updatedAt),
+  ]);
+}
+
+export class WorkflowRuntimeCapability extends WorkerEntrypoint<Env, RuntimeProps> {
+  async executeNode(input: RuntimeNodeRequest): Promise<Record<string, unknown>> {
+    const run = await authorizedRun(this.env, this.ctx.props, input);
+    const node = authorizedNode(run, input.nodeId, input.nodeKind);
+    const branchKey = input.branchKey ? cleanIdentifier(input.branchKey, "branch_key", 100) : "";
+    let output: Record<string, unknown>;
+    try {
+      const simulated = run.authorityMode === "shadow" ? shadowSimulation(node) : null;
+      if (simulated) {
+        output = simulated;
+      } else if (node.kind === "enrichment") {
+        output = await executeReadOnlyComponent(this.env, {
+          runId: run.id,
+          node,
+          branchKey,
+          stepRunId: stepRunId(run.id, node.id, branchKey),
+        });
+      } else if (node.kind === "ai_proposal") {
+        const executionInput = {
+          runId: run.id, node, branchKey,
+          stepRunId: stepRunId(run.id, node.id, branchKey),
+        };
+        const executed = typeof node.config.component_version_id === "string"
+          ? await executeReadOnlyComponent(this.env, executionInput)
+          : await executeAgentProposal(this.env, executionInput);
+        const data = executed.data && typeof executed.data === "object" && !Array.isArray(executed.data)
+          ? executed.data as Record<string, unknown> : {};
+        const resultCode = [data.result_code, data.outcome, data.conclusion, data.classification]
+          .find((value): value is string => typeof value === "string");
+        const allowed = Array.isArray(node.config.result_ports)
+          ? node.config.result_ports.filter((entry): entry is string => typeof entry === "string") : [];
+        if (!resultCode || !allowed.includes(resultCode)) throw new ComponentExecutionError("ai_result_port_invalid", false);
+        output = { ...executed, port: resultCode };
+      } else if (node.kind === "condition") {
+        output = await executeCondition(this.env, run, node, branchKey);
+      } else if (node.kind === "send_message") {
+        output = await sendWorkflowMessage(this.env, { runId: run.id, node, branchKey });
+      } else if (node.kind === "decision") {
+        output = await recordWorkflowDecision(this.env, { runId: run.id, node, branchKey });
+      } else if (node.kind === "handoff") {
+        output = await handoffWorkflowReport(this.env, { runId: run.id, node, branchKey });
+      } else if (node.kind === "start_linked_workflow") {
+        const workflowVersionId = typeof node.config.workflow_version_id === "string" ? node.config.workflow_version_id : null;
+        if (!workflowVersionId) throw new WorkflowEffectError("linked_workflow_version_required");
+        const loaded = await loadWorkflowExecutionContext(this.env, run.id, branchKey);
+        const payload = evaluateInputMapping(node.inputMapping, loaded.context);
+        const linked = await createLinkedWorkflowRun(this.env, {
+          parentRunId: run.id,
+          nodeId: node.id,
+          workflowVersionId,
+          payload,
+        });
+        output = { port: "started", linkedRunId: linked.runId, workflowVersionId: linked.workflowVersionId, idempotentReplay: linked.idempotentReplay };
+      } else if (node.kind === "delay_until" && input.input?.prepare === true) {
+        const loaded = await loadWorkflowExecutionContext(this.env, run.id, branchKey);
+        const mapped = evaluateInputMapping(node.inputMapping, loaded.context);
+        if (typeof mapped.timestamp !== "string") throw new Error("delay_timestamp_invalid");
+        const timestamp = new Date(mapped.timestamp);
+        if (!Number.isFinite(timestamp.getTime()) || timestamp.getTime() < Date.now() - 1_000 || timestamp.getTime() > Date.now() + 31_536_000_000) throw new Error("delay_timestamp_invalid");
+        output = { port: "completed", timestamp: timestamp.toISOString(), prepared: true };
+        await recordDelayPreparation(this.env, run, node, branchKey, timestamp.toISOString());
+        return output;
+      } else {
+        const port = outputPort(node);
+        output = node.kind === "end"
+          ? { port, terminalCode: node.config.terminal_code ?? "complete" }
+          : { port, ...(input.input ?? {}) };
+      }
+    } catch (error) {
+      if ((error instanceof ComponentExecutionError || error instanceof WorkflowEffectError) && !error.retryable) {
+        output = { port: node.errorPort ?? "error", errorCode: error.code, retryable: false };
+      } else {
+        throw error;
+      }
+    }
+    await recordSuccessfulStep(this.env, run, node, branchKey, output);
+    if (node.kind === "end") {
+      const timestamp = now();
+      await this.env.DB.prepare(`
+        UPDATE workflow_runs SET state = 'succeeded', output_json = ?2,
+          current_node_id = ?3, finished_at = ?4, updated_at = ?4, revision = revision + 1
+        WHERE id = ?1 AND state NOT IN ('succeeded','failed','terminated','superseded')
+      `).bind(run.id, canonicalJson(output), node.id, timestamp).run();
+    }
+    return output;
+  }
+
+  async prepareWait(input: RuntimeWaitRequest): Promise<{ eventType: string; timeoutMs: number; taskId?: string }> {
+    const run = await authorizedRun(this.env, this.ctx.props, input);
+    const node = authorizedNode(run, input.nodeId, input.nodeKind);
+    const branchKey = input.branchKey ? cleanIdentifier(input.branchKey, "branch_key", 100) : "";
+    if (run.authorityMode === "shadow" && node.kind === "human_task") throw new Error("shadow_human_wait_prohibited");
+    const id = stepRunId(run.id, node.id, branchKey);
+    const waitId = `${id}:wait`;
+    const taskId = node.kind === "human_task" ? `${id}:task` : undefined;
+    const eventType = node.kind === "human_task" ? `task.${taskId}.completed` : String(node.config.event_type);
+    const timeoutSeconds = Number(node.config.timeout_seconds ?? node.timeoutPolicy?.timeout_seconds ?? 86_400);
+    if (!Number.isInteger(timeoutSeconds) || timeoutSeconds < 1 || timeoutSeconds > 31_536_000) throw new Error("runtime_wait_timeout_invalid");
+    const timestamp = now();
+    const deadlineAt = new Date(Date.now() + timeoutSeconds * 1_000).toISOString();
+    const statements: D1PreparedStatement[] = [
+      this.env.DB.prepare(`
+        INSERT INTO workflow_step_runs (
+          id, run_id, node_id, node_type, branch_key, occurrence, state,
+          started_at, waiting_at, updated_at
+        ) VALUES (?1, ?2, ?3, ?4, ?5, 1, 'waiting', ?6, ?6, ?6)
+        ON CONFLICT(run_id, node_id, branch_key, occurrence) DO UPDATE SET
+          state = 'waiting', waiting_at = excluded.waiting_at, updated_at = excluded.updated_at
+      `).bind(id, run.id, node.id, node.kind, branchKey, timestamp),
+      this.env.DB.prepare(`
+        INSERT INTO workflow_waits (
+          id, run_id, step_run_id, wait_type, event_type, state, deadline_at, created_at
+        ) VALUES (?1, ?2, ?3, ?4, ?5, 'waiting', ?6, ?7)
+        ON CONFLICT(step_run_id) DO NOTHING
+      `).bind(waitId, run.id, id, node.kind === "human_task" ? "human_task" : "event", eventType, deadlineAt, timestamp),
+      this.env.DB.prepare(`
+        UPDATE workflow_runs SET state = 'waiting', current_node_id = ?2,
+          waiting_at = ?3, started_at = COALESCE(started_at, ?3),
+          updated_at = ?3, revision = revision + 1 WHERE id = ?1
+      `).bind(run.id, node.id, timestamp),
+    ];
+    if (taskId) {
+      statements.push(this.env.DB.prepare(`
+        INSERT INTO human_tasks (
+          id, installation_id, report_id, appeal_id, run_id, step_run_id,
+          task_type, state, queue_id, context_json, context_digest,
+          response_schema_json, due_at, created_at, updated_at
+        ) SELECT
+          ?1, r.installation_id, r.report_id, r.appeal_id, r.id, ?2,
+          ?3, 'open', COALESCE(?4, r.queue_id), ?5, ?6, ?7, ?8, ?9, ?9
+        FROM workflow_runs r WHERE r.id = ?10
+        ON CONFLICT(step_run_id) DO NOTHING
+      `).bind(
+        taskId, id, String(node.config.task_type ?? "review"),
+        typeof node.config.queue_id === "string" && node.config.queue_id !== "run-queue" ? node.config.queue_id : null,
+        canonicalJson({ nodeId: node.id, inputMapping: node.inputMapping }),
+        `sha256:${await sha256(canonicalJson({ nodeId: node.id, inputMapping: node.inputMapping }))}`,
+        canonicalJson(node.config.response_schema ?? { type: "object" }), deadlineAt, timestamp, run.id,
+      ));
+    }
+    await this.env.DB.batch(statements);
+    return { eventType, timeoutMs: timeoutSeconds * 1_000, ...(taskId ? { taskId } : {}) };
+  }
+
+  async prepareAction(input: RuntimeActionRequest): Promise<Record<string, unknown>> {
+    const run = await authorizedRun(this.env, this.ctx.props, input);
+    const node = authorizedNode(run, input.nodeId, "action");
+    const branchKey = input.branchKey ? cleanIdentifier(input.branchKey, "branch_key", 100) : "";
+    if (run.authorityMode === "off") throw new Error("action_authority_insufficient");
+    const id = stepRunId(run.id, node.id, branchKey);
+    if (run.authorityMode === "shadow") {
+      const result = { port: "applied", status: "simulated", simulated: true, effectSuppressed: true, simulationCode: "shadow_action_suppressed" };
+      await recordSuccessfulStep(this.env, run, node, branchKey, result);
+      return result;
+    }
+    const timestamp = now();
+    await this.env.DB.prepare(`
+      INSERT INTO workflow_step_runs (
+        id, run_id, node_id, node_type, branch_key, occurrence,
+        state, started_at, updated_at
+      ) VALUES (?1, ?2, ?3, 'action', ?4, 1, 'running', ?5, ?5)
+      ON CONFLICT(run_id, node_id, branch_key, occurrence) DO UPDATE SET
+        state = CASE WHEN workflow_step_runs.state = 'succeeded' THEN 'succeeded' ELSE 'running' END,
+        started_at = COALESCE(workflow_step_runs.started_at, excluded.started_at),
+        updated_at = excluded.updated_at
+    `).bind(id, run.id, node.id, branchKey, timestamp).run();
+    const result = await prepareWorkflowAction(this.env, {
+      runId: run.id,
+      node,
+      branchKey,
+      stepRunId: id,
+      authorityMode: run.authorityMode,
+    });
+    if (result.status === "approval_required" || result.status === "delivery_pending") {
+      await this.env.DB.batch([
+        this.env.DB.prepare(`UPDATE workflow_step_runs SET state = 'waiting', waiting_at = ?2, updated_at = ?2 WHERE id = ?1`).bind(id, timestamp),
+        this.env.DB.prepare(`UPDATE workflow_runs SET state = 'waiting', current_node_id = ?2, waiting_at = ?3, started_at = COALESCE(started_at, ?3), updated_at = ?3, revision = revision + 1 WHERE id = ?1`)
+          .bind(run.id, node.id, timestamp),
+      ]);
+      return result;
+    }
+    await recordSuccessfulStep(this.env, run, node, branchKey, result);
+    return result;
+  }
+
+  async completeAction(input: RuntimeCompleteActionRequest): Promise<Record<string, unknown>> {
+    const run = await authorizedRun(this.env, this.ctx.props, input);
+    const node = authorizedNode(run, input.nodeId, "action");
+    const branchKey = input.branchKey ? cleanIdentifier(input.branchKey, "branch_key", 100) : "";
+    const expectedProposalId = `${stepRunId(run.id, node.id, branchKey)}:proposal`;
+    if (cleanIdentifier(input.proposalId, "proposal_id", 500) !== expectedProposalId) throw new Error("action_proposal_denied");
+    const result = await completeWorkflowAction(this.env, { proposalId: expectedProposalId, eventResult: input.eventResult });
+    if (result.status === "delivery_pending") {
+      const timestamp = now();
+      await this.env.DB.batch([
+        this.env.DB.prepare(`UPDATE workflow_step_runs SET state = 'waiting', waiting_at = ?2, updated_at = ?2 WHERE id = ?1`).bind(expectedProposalId.replace(/:proposal$/u, ""), timestamp),
+        this.env.DB.prepare(`UPDATE workflow_runs SET state = 'waiting', current_node_id = ?2, waiting_at = ?3, updated_at = ?3, revision = revision + 1 WHERE id = ?1`)
+          .bind(run.id, node.id, timestamp),
+      ]);
+      return result;
+    }
+    await recordSuccessfulStep(this.env, run, node, branchKey, result);
+    return result;
+  }
+
+  async failNode(input: RuntimeFailureRequest): Promise<Record<string, unknown>> {
+    const run = await authorizedRun(this.env, this.ctx.props, input);
+    const node = authorizedNode(run, input.nodeId, input.nodeKind);
+    const branchKey = input.branchKey ? cleanIdentifier(input.branchKey, "branch_key", 100) : "";
+    const errorPort = node.errorPort;
+    if (!errorPort || !run.graph.edges.some((edge) => edge.from.nodeId === node.id && edge.from.port === errorPort)) {
+      const timestamp = now();
+      await this.env.DB.prepare(`
+        UPDATE workflow_runs SET state = 'repair_required', error_code = 'workflow_node_failed',
+          error_summary = ?2, updated_at = ?3, revision = revision + 1
+        WHERE id = ?1 AND state NOT IN ('succeeded','failed','terminated','superseded')
+      `).bind(run.id, `Node ${node.id} failed without a declared error port.`, timestamp).run();
+      throw new Error("workflow_node_failure_unhandled");
+    }
+    const output = {
+      port: errorPort,
+      errorCode: cleanIdentifier(input.errorCode, "error_code", 100),
+      exhausted: true,
+    };
+    await recordSuccessfulStep(this.env, run, node, branchKey, output);
+    return output;
+  }
+
+  async completeWait(input: RuntimeCompleteWaitRequest): Promise<Record<string, unknown>> {
+    const run = await authorizedRun(this.env, this.ctx.props, input);
+    const node = authorizedNode(run, input.nodeId);
+    if (node.kind !== "human_task" && node.kind !== "wait_for_event") throw new Error("runtime_wait_node_denied");
+    const branchKey = input.branchKey ? cleanIdentifier(input.branchKey, "branch_key", 100) : "";
+    const id = stepRunId(run.id, node.id, branchKey);
+    const timestamp = now();
+    const timedOut = input.eventResult.status === "timed_out";
+    const output = input.eventResult.status === "timed_out"
+      ? { port: "timeout", status: "timed_out" }
+      : { port: node.kind === "human_task" ? "completed" : "received", status: "received", event: input.eventResult.event };
+    const outputJson = canonicalJson(output);
+    const outputDigest = `sha256:${await sha256(outputJson)}`;
+    await this.env.DB.batch([
+      this.env.DB.prepare(`
+        UPDATE workflow_waits SET state = ?2, satisfied_at = ?3
+        WHERE step_run_id = ?1 AND state = 'waiting'
+      `).bind(id, timedOut ? "timed_out" : "satisfied", timestamp),
+      this.env.DB.prepare(`
+        UPDATE workflow_step_runs SET state = ?2, output_digest = ?3,
+          finished_at = ?4, updated_at = ?4 WHERE id = ?1 AND state = 'waiting'
+      `).bind(id, timedOut ? "timed_out" : "succeeded", outputDigest, timestamp),
+      this.env.DB.prepare(`
+        INSERT INTO workflow_step_outputs (
+          step_run_id, inline_json, digest, size_bytes, data_classification_json, created_at
+        ) VALUES (?1, ?2, ?3, ?4, '[]', ?5)
+        ON CONFLICT(step_run_id) DO UPDATE SET
+          inline_json = excluded.inline_json, digest = excluded.digest, size_bytes = excluded.size_bytes
+      `).bind(id, outputJson, outputDigest, new TextEncoder().encode(outputJson).byteLength, timestamp),
+      this.env.DB.prepare(`
+        UPDATE workflow_runs SET state = 'running', waiting_at = NULL,
+          updated_at = ?2, revision = revision + 1 WHERE id = ?1 AND state = 'waiting'
+      `).bind(run.id, timestamp),
+      ...(node.kind === "human_task" ? [this.env.DB.prepare(`
+        UPDATE human_tasks SET state = CASE WHEN ?2 = 1 THEN 'expired' ELSE 'completed' END,
+          completed_at = ?3, updated_at = ?3 WHERE step_run_id = ?1 AND state IN ('open','claimed')
+      `).bind(id, timedOut ? 1 : 0, timestamp)] : []),
+    ]);
+    return output;
+  }
+}
+
+export async function startDynamicWorkflow(
+  env: Env,
+  ctx: ExecutionContext,
+  input: { artifactId: string; workflowVersionId: string; instanceId: string; runId: string },
+): Promise<string> {
+  const metadata: RuntimeProps = {
+    artifactId: cleanIdentifier(input.artifactId, "artifact_id"),
+    workflowVersionId: cleanIdentifier(input.workflowVersionId, "workflow_version_id"),
+  };
+  const stub = await loadCompiledWorkflow(env, ctx, metadata);
+  const starter = stub.getEntrypoint() as unknown as {
+    start(params: { instanceId: string; runId: string }): Promise<{ id: string }>;
+  };
+  const result = await starter.start({
+    instanceId: cleanIdentifier(input.instanceId, "instance_id"),
+    runId: cleanIdentifier(input.runId, "run_id"),
+  });
+  return result.id;
+}