@atom-workflow-agent/workflow-engine 0.1.0

package/dist/runtime/durable-workflow-engine.js

@@ -0,0 +1,1593 @@
+import { setTimeout as delay } from "node:timers/promises";
+import { AtomWorkflowError, toAtomWorkflowError, validateJsonSchemaInstance, } from "@atom-workflow-agent/contracts";
+import { InProcessAtomAttemptRunner, withTimeout, ManagedAttemptResources, } from "@atom-workflow-agent/atom-executor";
+import { createAtomLifecycleHelpers, } from "@atom-workflow-agent/atom-sdk";
+import { FileCache, stableCacheKey } from "../cache/cache.js";
+import { HostHandoffManager } from "../handoff/host-handoff.js";
+import { createSignalResumeDirective } from "./resume-directive.js";
+import { assertSameResumeSubmission, createResumeDelivery, markResumeDeliveryFailed, markResumeDeliveryUnknownOutcome, resumeDeliveryId, } from "./resume-delivery.js";
+import { assertNodeRunTransition, assertRunTransition } from "./state-machines.js";
+import { cloneSnapshot } from "../store/runtime-snapshot.js";
+const TERMINAL = new Set(["succeeded", "failed", "cancelled", "unknown_outcome"]);
+function nowIso(now) { return now().toISOString(); }
+function asJson(value) {
+    try {
+        return JSON.parse(JSON.stringify(value));
+    }
+    catch {
+        return String(value);
+    }
+}
+function errorRecord(error) {
+    const normalized = toAtomWorkflowError(error);
+    return {
+        code: normalized.code,
+        message: normalized.message,
+        retryable: normalized.retryable,
+        ...(normalized.cause !== undefined ? { details: asJson(normalized.cause) } : {}),
+    };
+}
+function valueAtPath(root, path) {
+    let current = root;
+    for (const segment of path) {
+        if (Array.isArray(current) && /^\d+$/.test(segment))
+            current = current[Number(segment)];
+        else if (current !== null && typeof current === "object" && !Array.isArray(current) && segment in current)
+            current = current[segment];
+        else
+            return undefined;
+    }
+    return current;
+}
+function sameLineage(left, right) {
+    return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+/**
+ * A successful activation is visible to a consumer when both activations are
+ * on the same comparable control path. A source may be above the consumer
+ * (pre-fork data) or one joined fork level below it (branch data after fan-in).
+ *
+ * Frozen IR dependency validation remains the authority that proves the source
+ * executes on every path to the consumer. Runtime lineage only correlates the
+ * right fork/revisit instance; it must not contradict that static guarantee.
+ */
+function lineageVisibleFrom(source, consumer) {
+    const prefix = (shorter, longer) => shorter.length <= longer.length
+        && shorter.every((value, index) => value === longer[index]);
+    return prefix(source, consumer) || prefix(consumer, source);
+}
+function latestSuccess(snapshot, nodeId, nodeRun) {
+    return [...snapshot.nodeRuns]
+        .filter((candidate) => candidate.nodeId === nodeId && candidate.status === "succeeded"
+        && (!nodeRun || lineageVisibleFrom(candidate.controlLineage, nodeRun.controlLineage)))
+        .sort((a, b) => b.activationIndex - a.activationIndex)[0];
+}
+function resolvedNodeOutput(snapshot, nodeId, nodeRun) {
+    const node = snapshot.ir.nodes.find((candidate) => candidate.id === nodeId);
+    const mapScope = node?.mapScope;
+    if (mapScope && nodeRun?.mapRunId && nodeRun.mapIndex !== undefined) {
+        return [...snapshot.nodeRuns]
+            .filter((candidate) => candidate.nodeId === nodeId && candidate.status === "succeeded" && candidate.mapRunId === nodeRun.mapRunId && candidate.mapIndex === nodeRun.mapIndex)
+            .sort((left, right) => right.activationIndex - left.activationIndex)[0]?.output;
+    }
+    if (mapScope) {
+        const mapped = snapshot.nodeRuns.filter((candidate) => candidate.nodeId === nodeId && candidate.status === "succeeded" && candidate.mapRunId);
+        const latestRunId = [...mapped].sort((left, right) => right.activationIndex - left.activationIndex)[0]?.mapRunId;
+        if (latestRunId)
+            return mapped.filter((candidate) => candidate.mapRunId === latestRunId)
+                .sort((left, right) => (left.mapIndex ?? 0) - (right.mapIndex ?? 0)).map((candidate) => candidate.output ?? null);
+        if (snapshot.mapRuns.some((run) => run.mapNodeId === mapScope && run.status === "succeeded" && run.items.length === 0))
+            return [];
+    }
+    return latestSuccess(snapshot, nodeId, nodeRun)?.output;
+}
+function resolveReference(reference, snapshot, nodeRun) {
+    if (reference === "workflow.inputs" || reference.startsWith("workflow.inputs.")) {
+        const inputs = { ...snapshot.ir.inputs, ...snapshot.run.inputs };
+        const resolved = valueAtPath(inputs, reference === "workflow.inputs" ? [] : reference.split(".").slice(2));
+        if (resolved === undefined)
+            throw new AtomWorkflowError("REFERENCE_RESOLUTION_FAILED", `Workflow input is missing: ${reference}`);
+        return resolved;
+    }
+    if (reference === "map.item" || reference.startsWith("map.item.")) {
+        const item = nodeRun?.mapItem;
+        if (item === undefined)
+            throw new AtomWorkflowError("REFERENCE_RESOLUTION_FAILED", `${reference} is outside MapNode`);
+        const resolved = valueAtPath(item, reference.endsWith(".item") ? [] : reference.split(".").slice(2));
+        if (resolved === undefined)
+            throw new AtomWorkflowError("REFERENCE_RESOLUTION_FAILED", `Map item is missing: ${reference}`);
+        return resolved;
+    }
+    if (reference === "map.index") {
+        const index = nodeRun?.mapIndex;
+        if (index === undefined)
+            throw new AtomWorkflowError("REFERENCE_RESOLUTION_FAILED", `${reference} is outside MapNode`);
+        return index;
+    }
+    const dependency = /^dependencies\.([a-z][a-z0-9-]*)\.output(?:\.(.*))?$/.exec(reference);
+    const activation = /^nodes\.([a-z][a-z0-9-]*)\.activations\.lastSuccessful\.output(?:\.(.*))?$/.exec(reference);
+    const match = dependency ?? activation;
+    if (match) {
+        const output = resolvedNodeOutput(snapshot, match[1], nodeRun);
+        if (output === undefined)
+            throw new AtomWorkflowError("REFERENCE_RESOLUTION_FAILED", `Node output is unavailable: ${reference}`);
+        const path = match[2] ? match[2].split(".") : [];
+        const sourceNode = snapshot.ir.nodes.find((candidate) => candidate.id === match[1]);
+        const sourceGroup = sourceNode?.mapScope;
+        const sameGroup = sourceGroup !== undefined && nodeRun?.mapRunId !== undefined
+            && snapshot.mapRuns.some((run) => run.mapRunId === nodeRun.mapRunId && run.mapNodeId === sourceGroup);
+        const resolved = sourceGroup && !sameGroup && Array.isArray(output)
+            ? output.map((item) => valueAtPath(item, path)).filter((item) => item !== undefined)
+            : valueAtPath(output, path);
+        if (resolved === undefined)
+            throw new AtomWorkflowError("REFERENCE_RESOLUTION_FAILED", `Node output path is missing: ${reference}`);
+        return resolved;
+    }
+    throw new AtomWorkflowError("REFERENCE_RESOLUTION_FAILED", `Unsupported runtime reference: ${reference}`);
+}
+function resolveValue(value, snapshot, nodeRun) {
+    if (Array.isArray(value))
+        return value.map((item) => resolveValue(item, snapshot, nodeRun));
+    if (value !== null && typeof value === "object") {
+        if (Object.keys(value).length === 1 && typeof value.$ref === "string")
+            return resolveReference(value.$ref, snapshot, nodeRun);
+        return Object.fromEntries(Object.entries(value).map(([key, nested]) => [key, resolveValue(nested, snapshot, nodeRun)]));
+    }
+    return value;
+}
+function nodeInput(snapshot, node, nodeRun) {
+    const base = resolveValue(node.input, snapshot, nodeRun);
+    if (Object.keys(nodeRun.inputOverlay).length === 0)
+        return base;
+    if (base === null || typeof base !== "object" || Array.isArray(base)) {
+        throw new AtomWorkflowError("EDGE_INPUT_INVALID", `Edge overlay requires object input: ${node.id}`);
+    }
+    return { ...base, ...nodeRun.inputOverlay };
+}
+function runtimeLogger(append) {
+    return {
+        debug: (message, fields = {}) => append("debug", message, fields),
+        info: (message, fields = {}) => append("info", message, fields),
+        warn: (message, fields = {}) => append("warn", message, fields),
+        error: (message, fields = {}) => append("error", message, fields),
+    };
+}
+function snapshotAsJson(snapshot) {
+    return JSON.parse(JSON.stringify(snapshot));
+}
+function sleepMs(policy, attemptIndex) {
+    const raw = policy.strategy === "exponential"
+        ? policy.baseDelayMs * 2 ** Math.max(0, attemptIndex - 1)
+        : policy.baseDelayMs;
+    const limited = Math.min(policy.maxDelayMs, raw);
+    return policy.jitter ? Math.round(limited * (0.8 + Math.random() * 0.4)) : limited;
+}
+/** Durable scheduler and executor for one frozen WorkflowIR revision. */
+export class DurableWorkflowEngine {
+    options;
+    cache;
+    controllers = new Map();
+    resumeProcessing = new Map();
+    now;
+    atomAttemptRunner;
+    constructor(options) {
+        this.options = options;
+        this.cache = new FileCache(options.cacheDirectory);
+        this.now = options.now ?? (() => new Date());
+        this.atomAttemptRunner = options.atomAttemptRunner ?? new InProcessAtomAttemptRunner();
+    }
+    async createRun(input) {
+        if (!Object.isFrozen(input.ir))
+            throw new AtomWorkflowError("WORKFLOW_IR_NOT_FROZEN", "Runtime only accepts an immutable WorkflowIR");
+        if (input.revision.workflowIrHash !== input.ir.hash)
+            throw new AtomWorkflowError("WORKFLOW_REVISION_IR_HASH_MISMATCH", "WorkflowRevision does not match the supplied immutable IR");
+        const inputIssues = validateJsonSchemaInstance(input.revision.inputSchema, input.inputs, "$.inputs");
+        if (inputIssues.length > 0)
+            throw new AtomWorkflowError("WORKFLOW_INPUT_INVALID", "Workflow inputs do not match the frozen input contract", false, { cause: inputIssues });
+        const createdAt = nowIso(this.now);
+        let snapshot = {
+            schemaVersion: "1.0",
+            run: {
+                schemaVersion: "1.0",
+                runId: input.runId,
+                goal: input.goal,
+                cwd: input.cwd,
+                projectScope: input.projectScope ?? input.cwd,
+                hostScope: input.hostScope ?? "local-host",
+                status: "created",
+                ...(input.planId ? { planId: input.planId } : {}),
+                workflowRevisionId: input.revision.workflowRevisionId,
+                inputs: { ...input.inputs },
+                createdAt,
+                updatedAt: createdAt,
+            },
+            revision: input.revision,
+            ir: input.ir,
+            nodeRuns: [],
+            attempts: [],
+            artifacts: [],
+            signals: [],
+            hostTasks: [],
+            resumeDeliveries: [],
+            resourceLeases: [],
+            events: [],
+            eventSequence: 0,
+            transitionCount: 0,
+            edgeTraversals: {},
+            activationCounts: {},
+            pendingEdges: [],
+            decisions: [],
+            mapRuns: [],
+        };
+        const entryLineage = input.ir.control.entry.length > 1 ? [`${snapshot.revision.workflowRevisionId}:entry`] : [];
+        for (const nodeId of input.ir.control.entry)
+            snapshot = this.activate(snapshot, nodeId, {}, undefined, undefined, entryLineage);
+        snapshot = this.event(snapshot, "run.created", { workflowIrHash: input.ir.hash });
+        await this.options.store.create(snapshot);
+        return snapshot;
+    }
+    async execute(runId) {
+        const existing = await this.options.store.load(runId);
+        if (TERMINAL.has(existing.run.status))
+            return existing;
+        assertRunTransition(existing.run.status, "running");
+        const controller = this.controllers.get(runId) ?? new AbortController();
+        this.controllers.set(runId, controller);
+        const started = Date.now();
+        await this.options.store.update(runId, (snapshot) => ({
+            ...snapshot,
+            run: {
+                ...snapshot.run,
+                status: "running",
+                startedAt: snapshot.run.startedAt ?? nowIso(this.now),
+                updatedAt: nowIso(this.now),
+                error: undefined,
+            },
+        }));
+        try {
+            while (true) {
+                if (controller.signal.aborted)
+                    return this.cancel(runId);
+                const runTimeoutMs = this.options.runTimeoutMs ?? null;
+                if (runTimeoutMs !== null && runTimeoutMs <= Date.now() - started) {
+                    throw new AtomWorkflowError("RUN_TIMEOUT", "Workflow active execution timeout exceeded", true);
+                }
+                let snapshot = await this.options.store.load(runId);
+                if (TERMINAL.has(snapshot.run.status))
+                    return snapshot;
+                snapshot = await this.flushReadyJoins(snapshot);
+                const ready = snapshot.nodeRuns.filter((nodeRun) => nodeRun.status === "ready");
+                if (ready.length === 0) {
+                    const waitingSignal = snapshot.nodeRuns.some((nodeRun) => nodeRun.status === "awaiting_signal");
+                    const waitingHost = snapshot.nodeRuns.some((nodeRun) => nodeRun.status === "awaiting_host");
+                    if (waitingSignal || waitingHost) {
+                        return this.options.store.update(runId, (current) => ({
+                            ...current,
+                            run: { ...current.run, status: waitingSignal ? "awaiting_signal" : "awaiting_host", updatedAt: nowIso(this.now) },
+                        }));
+                    }
+                    throw new AtomWorkflowError("WORKFLOW_DEADLOCK", "Workflow has no runnable or waiting node");
+                }
+                const settled = await Promise.allSettled(ready.map((nodeRun) => this.executeNode(runId, nodeRun.activationId, controller.signal)));
+                const failed = settled.find((result) => result.status === "rejected");
+                if (failed)
+                    throw failed.reason;
+            }
+        }
+        catch (error) {
+            const normalized = toAtomWorkflowError(error);
+            if (normalized.code === "CANCELLED")
+                return this.cancel(runId);
+            return this.options.store.update(runId, (snapshot) => this.event({
+                ...snapshot,
+                mapRuns: snapshot.mapRuns.map((mapRun) => mapRun.status === "running" ? {
+                    ...mapRun,
+                    status: "failed",
+                    updatedAt: nowIso(this.now),
+                    endedAt: nowIso(this.now),
+                } : mapRun),
+                run: {
+                    ...snapshot.run,
+                    status: "failed",
+                    updatedAt: nowIso(this.now),
+                    endedAt: nowIso(this.now),
+                    error: errorRecord(normalized),
+                },
+            }, "run.failed", { code: normalized.code, message: normalized.message }));
+        }
+        finally {
+            this.controllers.delete(runId);
+        }
+    }
+    async signal(runId, signalId, response) {
+        const snapshot = await this.options.store.load(runId);
+        const signal = snapshot.signals.find((candidate) => candidate.signalId === signalId);
+        if (!signal)
+            throw new AtomWorkflowError("SIGNAL_NOT_FOUND", `Signal not found: ${signalId}`);
+        if (signal.expiresAt && this.now().getTime() >= Date.parse(signal.expiresAt)) {
+            await this.options.store.update(runId, (current) => ({
+                ...current,
+                signals: current.signals.map((item) => item.signalId === signalId ? { ...item, status: "expired" } : item),
+            }));
+            throw new AtomWorkflowError("SIGNAL_EXPIRED", `Signal expired: ${signalId}`);
+        }
+        const deliveryId = resumeDeliveryId("signal", signalId);
+        await this.options.store.update(runId, (current) => {
+            const existing = current.resumeDeliveries.find((delivery) => delivery.resumeDeliveryId === deliveryId);
+            if (existing) {
+                assertSameResumeSubmission(existing, response);
+                return current;
+            }
+            const waiting = current.signals.find((candidate) => candidate.signalId === signalId);
+            if (!waiting)
+                throw new AtomWorkflowError("SIGNAL_NOT_FOUND", `Signal not found: ${signalId}`);
+            if (waiting.status !== "waiting")
+                throw new AtomWorkflowError("SIGNAL_ALREADY_CONSUMED", `Signal is ${waiting.status}`);
+            if (waiting.expiresAt && this.now().getTime() >= Date.parse(waiting.expiresAt)) {
+                throw new AtomWorkflowError("SIGNAL_EXPIRED", `Signal expired: ${signalId}`);
+            }
+            const issues = validateJsonSchemaInstance(waiting.responseSchema, response, "$.response");
+            if (issues.length > 0) {
+                throw new AtomWorkflowError("SIGNAL_RESPONSE_INVALID", "Signal response failed Schema validation", false, { cause: issues });
+            }
+            const attempt = current.attempts.find((candidate) => candidate.attemptId === waiting.attemptId);
+            if (!attempt)
+                throw new AtomWorkflowError("ATTEMPT_NOT_RESUMABLE", `Attempt is not resumable: ${waiting.attemptId}`);
+            const resume = {
+                schemaVersion: "1.0",
+                kind: "signal",
+                signalId,
+                key: waiting.key,
+                response,
+            };
+            const delivery = createResumeDelivery({
+                runId,
+                workflowRevisionId: current.revision.workflowRevisionId,
+                nodeId: attempt.nodeId,
+                activationId: attempt.activationId,
+                attemptId: attempt.attemptId,
+                kind: "signal",
+                sourceId: signalId,
+                submission: response,
+                payload: resume,
+                now: this.now(),
+            });
+            return this.event({
+                ...current,
+                signals: current.signals.map((item) => item.signalId === signalId ? {
+                    ...item,
+                    status: "consumed",
+                    response,
+                    consumedAt: nowIso(this.now),
+                } : item),
+                resumeDeliveries: [...current.resumeDeliveries, delivery],
+                run: { ...current.run, status: "running", updatedAt: nowIso(this.now) },
+            }, "resume.accepted", { kind: "signal", sourceId: signalId, resumeDeliveryId: deliveryId }, attempt.nodeId, attempt.activationId, attempt.attemptId);
+        });
+        return this.processResumeDelivery(runId, deliveryId);
+    }
+    async resumeHost(runId, raw) {
+        const deliveryId = resumeDeliveryId("host", raw.hostTaskId);
+        await this.options.store.update(runId, (current) => {
+            const existing = current.resumeDeliveries.find((delivery) => delivery.resumeDeliveryId === deliveryId);
+            if (existing) {
+                assertSameResumeSubmission(existing, raw);
+                return current;
+            }
+            const record = current.hostTasks.find((item) => item.request.hostTaskId === raw.hostTaskId);
+            if (!record)
+                throw new AtomWorkflowError("HOST_TASK_NOT_FOUND", `HostTask not found: ${raw.hostTaskId}`);
+            const manager = this.hostManager(current);
+            const request = record.request;
+            const resume = manager.resume(raw, {
+                runId,
+                workflowRevisionId: request.workflowRevisionId,
+                nodeId: request.nodeId,
+                activationId: request.activationId,
+                attemptId: request.attemptId,
+                workflowIrHash: request.continuation.workflowIrHash,
+                projectScope: request.projectScope,
+                hostScope: request.hostScope,
+            });
+            const delivery = createResumeDelivery({
+                runId,
+                workflowRevisionId: request.workflowRevisionId,
+                nodeId: request.nodeId,
+                activationId: request.activationId,
+                attemptId: request.attemptId,
+                kind: "host",
+                sourceId: request.hostTaskId,
+                submission: raw,
+                payload: resume,
+                now: this.now(),
+            });
+            return this.event({
+                ...current,
+                hostTasks: manager.exportRecords(),
+                resumeDeliveries: [...current.resumeDeliveries, delivery],
+                run: { ...current.run, status: "running", updatedAt: nowIso(this.now) },
+            }, "resume.accepted", { kind: "host", sourceId: request.hostTaskId, resumeDeliveryId: deliveryId }, request.nodeId, request.activationId, request.attemptId);
+        });
+        return this.processResumeDelivery(runId, deliveryId);
+    }
+    async cancel(runId) {
+        this.controllers.get(runId)?.abort(new AtomWorkflowError("CANCELLED", "Workflow cancelled"));
+        return this.options.store.update(runId, (snapshot) => {
+            if (snapshot.run.status === "succeeded" || snapshot.run.status === "cancelled")
+                return snapshot;
+            assertRunTransition(snapshot.run.status, "cancelled");
+            const manager = this.hostManager(snapshot);
+            for (const task of manager.listResumable())
+                manager.cancel(task.hostTaskId);
+            return this.event({
+                ...snapshot,
+                hostTasks: manager.exportRecords(),
+                signals: snapshot.signals.map((signal) => signal.status === "waiting" ? { ...signal, status: "cancelled" } : signal),
+                nodeRuns: snapshot.nodeRuns.map((nodeRun) => TERMINAL.has(nodeRun.status) ? nodeRun : {
+                    ...nodeRun,
+                    status: "cancelled",
+                    updatedAt: nowIso(this.now),
+                    endedAt: nowIso(this.now),
+                }),
+                run: { ...snapshot.run, status: "cancelled", updatedAt: nowIso(this.now), endedAt: nowIso(this.now) },
+            }, "run.cancelled", {});
+        });
+    }
+    async retry(runId, activationId) {
+        await this.options.store.update(runId, (snapshot) => ({
+            ...snapshot,
+            nodeRuns: snapshot.nodeRuns.map((nodeRun) => {
+                if (nodeRun.activationId !== activationId)
+                    return nodeRun;
+                assertNodeRunTransition(nodeRun.status, "ready");
+                const { error: _error, endedAt: _endedAt, ...rest } = nodeRun;
+                return { ...rest, status: "ready", updatedAt: nowIso(this.now) };
+            }),
+            run: { ...snapshot.run, status: "running", error: undefined, endedAt: undefined, updatedAt: nowIso(this.now) },
+        }));
+        return this.execute(runId);
+    }
+    async resume(runId) {
+        const snapshot = await this.options.store.load(runId);
+        const pendingDelivery = snapshot.resumeDeliveries.find((delivery) => delivery.status === "accepted" || delivery.status === "processing" || delivery.status === "retry_wait");
+        if (pendingDelivery)
+            return this.processResumeDelivery(runId, pendingDelivery.resumeDeliveryId);
+        if (snapshot.run.status === "awaiting_host" || snapshot.run.status === "awaiting_signal")
+            return snapshot;
+        assertRunTransition(snapshot.run.status, "running");
+        await this.options.store.update(runId, (current) => ({
+            ...current,
+            run: { ...current.run, status: "running", error: undefined, endedAt: undefined, updatedAt: nowIso(this.now) },
+            nodeRuns: current.nodeRuns.map((nodeRun) => nodeRun.status === "interrupted"
+                ? { ...nodeRun, status: "ready", updatedAt: nowIso(this.now) }
+                : nodeRun),
+        }));
+        return this.execute(runId);
+    }
+    async recover(autoResume = true) {
+        const recovered = [];
+        for (const stale of await this.options.store.listNonTerminal()) {
+            const next = await this.options.store.update(stale.run.runId, (snapshot) => {
+                let unknown = false;
+                const activeDeliveries = snapshot.resumeDeliveries.filter((delivery) => delivery.status === "accepted" || delivery.status === "processing" || delivery.status === "retry_wait");
+                const unknownResumeAttemptIds = new Set(activeDeliveries
+                    .filter((delivery) => {
+                    if (delivery.status !== "processing")
+                        return false;
+                    const node = snapshot.ir.nodes.find((candidate) => candidate.id === delivery.nodeId);
+                    return node?.kind === "atom" && !node.atom.manifest.idempotent;
+                })
+                    .map((delivery) => delivery.attemptId));
+                const pendingDeliveries = activeDeliveries.filter((delivery) => !unknownResumeAttemptIds.has(delivery.attemptId));
+                const pendingByAttempt = new Map(pendingDeliveries.map((delivery) => [delivery.attemptId, delivery]));
+                const attempts = snapshot.attempts.map((attempt) => {
+                    if (unknownResumeAttemptIds.has(attempt.attemptId)) {
+                        unknown = true;
+                        return {
+                            ...attempt,
+                            state: "unknown_outcome",
+                            phase: "complete",
+                            endedAt: nowIso(this.now),
+                            updatedAt: nowIso(this.now),
+                            error: { code: "RESUME_UNKNOWN_OUTCOME", message: "Runtime stopped during a non-idempotent resume invocation", retryable: false },
+                        };
+                    }
+                    const pending = pendingByAttempt.get(attempt.attemptId);
+                    if (pending) {
+                        return {
+                            ...attempt,
+                            state: pending.kind === "signal" ? "awaiting_signal" : "awaiting_host",
+                            phase: "resume",
+                            updatedAt: nowIso(this.now),
+                        };
+                    }
+                    if (attempt.state !== "running")
+                        return attempt;
+                    const node = snapshot.ir.nodes.find((candidate) => candidate.id === attempt.nodeId);
+                    if (node.kind !== "atom")
+                        throw new AtomWorkflowError("CONTROL_NODE_ATTEMPT_INVALID", `Control node cannot own an Atom Attempt: ${node.id}`);
+                    if (!node.atom.manifest.idempotent)
+                        unknown = true;
+                    return {
+                        ...attempt,
+                        state: node.atom.manifest.idempotent ? "interrupted" : "unknown_outcome",
+                        phase: "complete",
+                        endedAt: nowIso(this.now),
+                        updatedAt: nowIso(this.now),
+                        error: { code: "PROCESS_INTERRUPTED", message: "Runtime stopped before Attempt completion was committed", retryable: node.atom.manifest.idempotent },
+                    };
+                });
+                const nodeRuns = snapshot.nodeRuns.map((nodeRun) => {
+                    if (activeDeliveries.some((delivery) => delivery.activationId === nodeRun.activationId && unknownResumeAttemptIds.has(delivery.attemptId))) {
+                        return {
+                            ...nodeRun,
+                            status: "unknown_outcome",
+                            error: { code: "RESUME_UNKNOWN_OUTCOME", message: "Runtime stopped during a non-idempotent resume invocation", retryable: false },
+                            updatedAt: nowIso(this.now),
+                        };
+                    }
+                    const pending = pendingDeliveries.find((delivery) => delivery.activationId === nodeRun.activationId);
+                    if (pending) {
+                        return {
+                            ...nodeRun,
+                            status: pending.status === "retry_wait"
+                                ? "retry_wait"
+                                : pending.kind === "signal" ? "awaiting_signal" : "awaiting_host",
+                            updatedAt: nowIso(this.now),
+                        };
+                    }
+                    if (nodeRun.status !== "running" && nodeRun.status !== "retry_wait")
+                        return nodeRun;
+                    const node = snapshot.ir.nodes.find((candidate) => candidate.id === nodeRun.nodeId);
+                    if (node.kind !== "atom")
+                        return { ...nodeRun, status: "ready", updatedAt: nowIso(this.now) };
+                    return {
+                        ...nodeRun,
+                        status: node.atom.manifest.idempotent ? "interrupted" : "unknown_outcome",
+                        updatedAt: nowIso(this.now),
+                    };
+                });
+                return this.event({
+                    ...snapshot,
+                    attempts,
+                    nodeRuns,
+                    resumeDeliveries: snapshot.resumeDeliveries.map((delivery) => unknownResumeAttemptIds.has(delivery.attemptId)
+                        ? markResumeDeliveryUnknownOutcome(delivery, {
+                            code: "RESUME_UNKNOWN_OUTCOME",
+                            message: "Runtime stopped during a non-idempotent resume invocation",
+                            retryable: false,
+                        }, this.now())
+                        : delivery),
+                    resourceLeases: snapshot.resourceLeases.map((lease) => lease.status === "active" ? {
+                        ...lease,
+                        status: "compensated",
+                        releasedAt: nowIso(this.now),
+                    } : lease),
+                    run: {
+                        ...snapshot.run,
+                        status: unknown ? "unknown_outcome" : pendingDeliveries.length > 0 ? "interrupted"
+                            : snapshot.run.status === "awaiting_host" || snapshot.run.status === "awaiting_signal"
+                                ? snapshot.run.status : "interrupted",
+                        updatedAt: nowIso(this.now),
+                    },
+                }, "run.recovered", { unknownOutcome: unknown });
+            });
+            recovered.push(next);
+            if (autoResume && next.run.status === "interrupted")
+                recovered[recovered.length - 1] = await this.resume(next.run.runId);
+        }
+        return recovered;
+    }
+    /** Applies one already accepted continuation. The persisted payload is the sole retry source. */
+    processResumeDelivery(runId, deliveryId) {
+        const key = `${runId}:${deliveryId}`;
+        const active = this.resumeProcessing.get(key);
+        if (active)
+            return active;
+        const processing = this.processResumeDeliveryExclusive(runId, deliveryId)
+            .finally(() => this.resumeProcessing.delete(key));
+        this.resumeProcessing.set(key, processing);
+        return processing;
+    }
+    async processResumeDeliveryExclusive(runId, deliveryId) {
+        while (true) {
+            let snapshot = await this.options.store.load(runId);
+            let delivery = snapshot.resumeDeliveries.find((candidate) => candidate.resumeDeliveryId === deliveryId);
+            if (!delivery)
+                throw new AtomWorkflowError("RESUME_DELIVERY_NOT_FOUND", `ResumeDelivery not found: ${deliveryId}`);
+            if (delivery.status === "applied" || delivery.status === "failed")
+                return snapshot;
+            const node = snapshot.ir.nodes.find((candidate) => candidate.id === delivery.nodeId);
+            if (!node || node.kind !== "atom") {
+                throw new AtomWorkflowError("RESUME_DELIVERY_NODE_INVALID", `ResumeDelivery does not target an Atom node: ${delivery.nodeId}`);
+            }
+            const attempt = snapshot.attempts.find((candidate) => candidate.attemptId === delivery.attemptId);
+            if (!attempt?.lifecycleSnapshot) {
+                throw new AtomWorkflowError("ATTEMPT_NOT_RESUMABLE", `Attempt is not resumable: ${delivery.attemptId}`);
+            }
+            if (delivery.status === "retry_wait" && delivery.nextRetryAt) {
+                const remainingMs = Date.parse(delivery.nextRetryAt) - this.now().getTime();
+                if (remainingMs > 0)
+                    await delay(remainingMs);
+            }
+            const invocationAttempt = delivery.invocationAttempt + 1;
+            snapshot = await this.options.store.update(runId, (current) => this.event({
+                ...current,
+                resumeDeliveries: current.resumeDeliveries.map((candidate) => candidate.resumeDeliveryId === deliveryId ? {
+                    ...candidate,
+                    status: "processing",
+                    invocationAttempt,
+                    nextRetryAt: undefined,
+                    error: undefined,
+                    updatedAt: nowIso(this.now),
+                } : candidate),
+                attempts: current.attempts.map((candidate) => candidate.attemptId === delivery.attemptId ? {
+                    ...candidate,
+                    state: "running",
+                    phase: "resume",
+                    endedAt: undefined,
+                    error: undefined,
+                    updatedAt: nowIso(this.now),
+                } : candidate),
+                nodeRuns: current.nodeRuns.map((candidate) => candidate.activationId === delivery.activationId ? {
+                    ...candidate,
+                    status: "running",
+                    endedAt: undefined,
+                    error: undefined,
+                    updatedAt: nowIso(this.now),
+                } : candidate),
+                run: {
+                    ...current.run,
+                    status: "running",
+                    endedAt: undefined,
+                    error: undefined,
+                    updatedAt: nowIso(this.now),
+                },
+            }, "resume.processing", { resumeDeliveryId: deliveryId, invocationAttempt }, delivery.nodeId, delivery.activationId, delivery.attemptId));
+            delivery = snapshot.resumeDeliveries.find((candidate) => candidate.resumeDeliveryId === deliveryId);
+            try {
+                await this.resumeAttempt(runId, delivery.attemptId, delivery.payload);
+                await this.options.store.update(runId, (current) => {
+                    const timestamp = nowIso(this.now);
+                    return this.event({
+                        ...current,
+                        resumeDeliveries: current.resumeDeliveries.map((candidate) => candidate.resumeDeliveryId === deliveryId ? {
+                            ...candidate,
+                            status: "applied",
+                            appliedAt: timestamp,
+                            updatedAt: timestamp,
+                            nextRetryAt: undefined,
+                            error: undefined,
+                        } : candidate),
+                    }, "resume.applied", { resumeDeliveryId: deliveryId, invocationAttempt }, delivery.nodeId, delivery.activationId, delivery.attemptId);
+                });
+                return this.execute(runId);
+            }
+            catch (error) {
+                const normalized = toAtomWorkflowError(error);
+                const maxAttempts = node.atom.manifest.idempotent ? node.effectivePolicy.retry.maxAttempts : 1;
+                const canRetry = normalized.retryable && node.atom.manifest.idempotent && invocationAttempt < maxAttempts;
+                if (canRetry) {
+                    const retryAfterMs = sleepMs(node.effectivePolicy.retry, invocationAttempt);
+                    const nextRetryAt = new Date(this.now().getTime() + retryAfterMs).toISOString();
+                    await this.options.store.update(runId, (current) => this.event({
+                        ...current,
+                        resumeDeliveries: current.resumeDeliveries.map((candidate) => candidate.resumeDeliveryId === deliveryId ? {
+                            ...candidate,
+                            status: "retry_wait",
+                            nextRetryAt,
+                            error: errorRecord(normalized),
+                            updatedAt: nowIso(this.now),
+                        } : candidate),
+                        attempts: current.attempts.map((candidate) => candidate.attemptId === delivery.attemptId ? {
+                            ...candidate,
+                            state: delivery.kind === "signal" ? "awaiting_signal" : "awaiting_host",
+                            phase: "resume",
+                            error: errorRecord(normalized),
+                            updatedAt: nowIso(this.now),
+                        } : candidate),
+                        nodeRuns: current.nodeRuns.map((candidate) => candidate.activationId === delivery.activationId ? {
+                            ...candidate,
+                            status: "retry_wait",
+                            error: errorRecord(normalized),
+                            updatedAt: nowIso(this.now),
+                        } : candidate),
+                    }, "resume.retry_scheduled", {
+                        resumeDeliveryId: deliveryId,
+                        invocationAttempt,
+                        retryAfterMs,
+                        code: normalized.code,
+                    }, delivery.nodeId, delivery.activationId, delivery.attemptId));
+                    if (retryAfterMs > 0)
+                        await delay(retryAfterMs);
+                    continue;
+                }
+                return this.options.store.update(runId, (current) => {
+                    const timestamp = nowIso(this.now);
+                    const failedDelivery = current.resumeDeliveries.find((candidate) => candidate.resumeDeliveryId === deliveryId);
+                    return this.event({
+                        ...current,
+                        resumeDeliveries: current.resumeDeliveries.map((candidate) => candidate.resumeDeliveryId === deliveryId
+                            ? markResumeDeliveryFailed(failedDelivery, errorRecord(normalized), this.now())
+                            : candidate),
+                        attempts: current.attempts.map((candidate) => candidate.attemptId === delivery.attemptId ? {
+                            ...candidate,
+                            state: "failed",
+                            phase: "complete",
+                            error: errorRecord(normalized),
+                            endedAt: timestamp,
+                            updatedAt: timestamp,
+                        } : candidate),
+                        nodeRuns: current.nodeRuns.map((candidate) => candidate.activationId === delivery.activationId ? {
+                            ...candidate,
+                            status: "failed",
+                            error: errorRecord(normalized),
+                            endedAt: timestamp,
+                            updatedAt: timestamp,
+                        } : candidate),
+                        mapRuns: current.mapRuns.map((mapRun) => mapRun.status === "running" ? {
+                            ...mapRun,
+                            status: "failed",
+                            endedAt: timestamp,
+                            updatedAt: timestamp,
+                        } : mapRun),
+                        run: {
+                            ...current.run,
+                            status: "failed",
+                            error: errorRecord(normalized),
+                            endedAt: timestamp,
+                            updatedAt: timestamp,
+                        },
+                    }, "resume.failed", {
+                        resumeDeliveryId: deliveryId,
+                        invocationAttempt,
+                        code: normalized.code,
+                        message: normalized.message,
+                    }, delivery.nodeId, delivery.activationId, delivery.attemptId);
+                });
+            }
+        }
+    }
+    async executeNode(runId, activationId, parentSignal) {
+        let snapshot = await this.options.store.load(runId);
+        let nodeRun = snapshot.nodeRuns.find((candidate) => candidate.activationId === activationId);
+        const node = snapshot.ir.nodes.find((candidate) => candidate.id === nodeRun.nodeId);
+        if (node.kind !== "atom") {
+            try {
+                if (node.kind === "switch")
+                    await this.executeSwitch(runId, nodeRun, node);
+                else if (node.kind === "map")
+                    await this.executeMap(runId, nodeRun, node);
+                else if (node.kind === "merge") {
+                    const output = { ...nodeRun.inputOverlay };
+                    const issues = validateJsonSchemaInstance(node.outputSchema, output, "$.output");
+                    if (issues.length > 0)
+                        throw new AtomWorkflowError("BRANCH_MERGE_OUTPUT_INVALID", `Branch merge input failed for ${node.id}`, false, { cause: issues });
+                    await this.commitControlCompletion(runId, activationId, output, "merge.completed");
+                }
+                else
+                    await this.commitControlCompletion(runId, activationId, {}, "join.completed");
+            }
+            catch (error) {
+                const normalized = toAtomWorkflowError(error);
+                await this.options.store.update(runId, (current) => this.event({
+                    ...current,
+                    nodeRuns: current.nodeRuns.map((run) => run.activationId === activationId ? {
+                        ...run,
+                        status: "failed",
+                        error: errorRecord(normalized),
+                        updatedAt: nowIso(this.now),
+                        endedAt: nowIso(this.now),
+                    } : run),
+                    mapRuns: current.mapRuns.map((mapRun) => mapRun.activationId === activationId && mapRun.status === "running" ? {
+                        ...mapRun,
+                        status: "failed",
+                        updatedAt: nowIso(this.now),
+                        endedAt: nowIso(this.now),
+                    } : mapRun),
+                }, "control.failed", { code: normalized.code, message: normalized.message }, node.id, activationId));
+                throw error;
+            }
+            return;
+        }
+        const input = nodeInput(snapshot, node, nodeRun);
+        const issues = validateJsonSchemaInstance(node.atom.manifest.inputSchema, input, "$.input");
+        if (issues.length > 0)
+            throw new AtomWorkflowError("ATOM_INPUT_SCHEMA_MISMATCH", `Runtime input failed for ${node.id}`, false, { cause: issues });
+        const cacheKey = stableCacheKey({ runId, atom: node.atom.key, input });
+        if (node.effectivePolicy.cache.enabled) {
+            const cached = await this.cache.get(cacheKey);
+            if (cached) {
+                await this.commitCompletion(runId, activationId, cached, "node.cache_hit");
+                return;
+            }
+        }
+        const primaryAttempts = node.effectivePolicy.retry.maxAttempts;
+        const automaticMaxAttempts = node.atom.manifest.idempotent ? primaryAttempts : 1;
+        // A persisted node with every automatic attempt consumed can only become
+        // ready again through the explicit operator retry command. Grant exactly
+        // one new attempt while preserving prior Attempt records for auditability.
+        // Repeating the command after another failure grants one more attempt.
+        const maxAttempts = nodeRun.status === "ready" && nodeRun.attemptIds.length >= automaticMaxAttempts
+            ? nodeRun.attemptIds.length + 1
+            : automaticMaxAttempts;
+        let lastError;
+        for (let attemptIndex = nodeRun.attemptIds.length; attemptIndex < maxAttempts; attemptIndex += 1) {
+            snapshot = await this.options.store.load(runId);
+            nodeRun = snapshot.nodeRuns.find((candidate) => candidate.activationId === activationId);
+            const attemptId = `${activationId}:attempt:${attemptIndex}`;
+            const timestamp = nowIso(this.now);
+            const attempt = {
+                schemaVersion: "1.0",
+                attemptId,
+                runId,
+                workflowRevisionId: snapshot.revision.workflowRevisionId,
+                activationId,
+                nodeId: node.id,
+                attemptIndex,
+                state: "created",
+                phase: "created",
+                tickCount: 0,
+                activeDurationMs: 0,
+                startedAt: timestamp,
+                updatedAt: timestamp,
+            };
+            await this.options.store.update(runId, (current) => this.event({
+                ...current,
+                attempts: [...current.attempts, attempt],
+                nodeRuns: current.nodeRuns.map((item) => item.activationId === activationId ? {
+                    ...item,
+                    status: "running",
+                    input,
+                    attemptIds: [...item.attemptIds, attemptId],
+                    startedAt: item.startedAt ?? timestamp,
+                    updatedAt: timestamp,
+                } : item),
+            }, attemptIndex > 0 ? "attempt.retry" : "attempt.started", {
+                attemptIndex,
+            }, node.id, activationId, attemptId));
+            try {
+                const completion = await this.runNewAttempt(runId, activationId, attemptId, input, node, parentSignal);
+                if (!completion)
+                    return;
+                if (node.effectivePolicy.cache.enabled) {
+                    await this.cache.set(cacheKey, { ...completion, cachedAt: nowIso(this.now) }, node.effectivePolicy.cache.ttlMs ?? 86_400_000);
+                }
+                await this.commitCompletion(runId, activationId, completion, "node.succeeded");
+                return;
+            }
+            catch (error) {
+                lastError = error;
+                const normalized = toAtomWorkflowError(error);
+                await this.options.store.update(runId, (current) => this.event({
+                    ...current,
+                    attempts: current.attempts.map((item) => item.attemptId === attemptId ? {
+                        ...item,
+                        state: normalized.code === "CANCELLED" ? "cancelled" : "failed",
+                        phase: "complete",
+                        error: errorRecord(normalized),
+                        endedAt: nowIso(this.now),
+                        updatedAt: nowIso(this.now),
+                    } : item),
+                    nodeRuns: current.nodeRuns.map((item) => item.activationId === activationId ? {
+                        ...item,
+                        status: attemptIndex + 1 < maxAttempts && normalized.retryable ? "retry_wait" : "failed",
+                        error: errorRecord(normalized),
+                        updatedAt: nowIso(this.now),
+                        ...(attemptIndex + 1 < maxAttempts && normalized.retryable ? {} : { endedAt: nowIso(this.now) }),
+                    } : item),
+                }, "attempt.failed", { code: normalized.code, retryable: normalized.retryable }, node.id, activationId, attemptId));
+                if (!normalized.retryable || attemptIndex + 1 >= maxAttempts)
+                    break;
+                const wait = sleepMs(node.effectivePolicy.retry, attemptIndex + 1);
+                if (wait > 0)
+                    await delay(wait, undefined, { signal: parentSignal });
+            }
+        }
+        throw lastError ?? new AtomWorkflowError("ATTEMPT_FAILED", `Node failed: ${node.id}`);
+    }
+    async executeSwitch(runId, nodeRun, node) {
+        const snapshot = await this.options.store.load(runId);
+        const selected = resolveReference(node.select.$ref, snapshot, nodeRun);
+        if (typeof selected !== "string") {
+            throw new AtomWorkflowError("SWITCH_SELECTION_INVALID", `SwitchNode selection is not a string: ${node.id}`);
+        }
+        const dependencyId = node.dependsOn[0];
+        const payload = dependencyId ? resolvedNodeOutput(snapshot, dependencyId, nodeRun) : undefined;
+        if (payload === undefined)
+            throw new AtomWorkflowError("SWITCH_PAYLOAD_UNAVAILABLE", `SwitchNode dependency output is unavailable: ${node.id}`);
+        await this.commitControlCompletion(runId, nodeRun.activationId, payload, "switch.completed");
+    }
+    async executeMap(runId, nodeRun, node) {
+        await this.options.store.update(runId, (snapshot) => {
+            const existing = snapshot.mapRuns.find((run) => run.activationId === nodeRun.activationId);
+            if (existing) {
+                if (existing.status === "succeeded")
+                    return snapshot;
+                if (existing.status === "failed")
+                    throw new AtomWorkflowError("MAP_RUN_FAILED", `MapRun already failed: ${existing.mapRunId}`);
+                const timestamp = nowIso(this.now);
+                let next = {
+                    ...snapshot,
+                    nodeRuns: snapshot.nodeRuns.map((run) => run.activationId === nodeRun.activationId
+                        ? { ...run, status: "running", startedAt: run.startedAt ?? timestamp, updatedAt: timestamp }
+                        : run),
+                };
+                if (existing.completedIndices.length === existing.items.length) {
+                    return this.finishMap(next, existing.mapRunId, node, this.mapOutput(next, existing.mapRunId, node));
+                }
+                return this.scheduleMapItems(next, existing.mapRunId, node);
+            }
+            const resolved = resolveReference(node.items.$ref, snapshot, nodeRun);
+            if (!Array.isArray(resolved))
+                throw new AtomWorkflowError("MAP_ITEMS_NOT_ARRAY", `MapNode items did not resolve to an array: ${node.id}`);
+            if (resolved.length > node.maxItems) {
+                throw new AtomWorkflowError("MAP_ITEMS_LIMIT_EXCEEDED", `MapNode received ${resolved.length} items but maxItems is ${node.maxItems}: ${node.id}`);
+            }
+            const timestamp = nowIso(this.now);
+            const mapRun = {
+                mapRunId: `${nodeRun.activationId}:map`,
+                mapNodeId: node.id,
+                activationId: nodeRun.activationId,
+                status: "running",
+                items: resolved,
+                nextIndex: 0,
+                activeIndices: [],
+                completedIndices: [],
+                createdAt: timestamp,
+                updatedAt: timestamp,
+            };
+            let next = {
+                ...snapshot,
+                mapRuns: [...snapshot.mapRuns, mapRun],
+                nodeRuns: snapshot.nodeRuns.map((run) => run.activationId === nodeRun.activationId
+                    ? { ...run, status: "running", startedAt: run.startedAt ?? timestamp, updatedAt: timestamp }
+                    : run),
+            };
+            next = this.event(next, "map.started", { itemCount: resolved.length, maxConcurrency: node.maxConcurrency }, node.id, nodeRun.activationId);
+            if (resolved.length === 0)
+                return this.finishMap(next, mapRun.mapRunId, node, []);
+            return this.scheduleMapItems(next, mapRun.mapRunId, node);
+        });
+    }
+    async commitControlCompletion(runId, activationId, output, eventType) {
+        await this.options.store.update(runId, (snapshot) => {
+            const timestamp = nowIso(this.now);
+            const nodeRun = snapshot.nodeRuns.find((candidate) => candidate.activationId === activationId);
+            if (!nodeRun)
+                throw new AtomWorkflowError("NODE_ACTIVATION_NOT_FOUND", `Control activation not found: ${activationId}`);
+            const next = {
+                ...snapshot,
+                nodeRuns: snapshot.nodeRuns.map((candidate) => candidate.activationId === activationId ? {
+                    ...candidate,
+                    status: "succeeded",
+                    output,
+                    startedAt: candidate.startedAt ?? timestamp,
+                    endedAt: timestamp,
+                    updatedAt: timestamp,
+                } : candidate),
+            };
+            return this.event(this.advance(next, activationId, output), eventType, {}, nodeRun.nodeId, activationId);
+        });
+    }
+    async runNewAttempt(runId, activationId, attemptId, input, node, parentSignal) {
+        const lease = this.options.atoms.acquire(node.atom.id, node.atom.version);
+        const resources = this.resources(runId, attemptId);
+        const started = Date.now();
+        try {
+            const attemptSnapshot = await this.options.store.load(runId);
+            const hostManager = this.hostManager(attemptSnapshot);
+            let lifecycle = await this.tickTimeout(async (tickSignal) => {
+                const context = await this.context(runId, activationId, attemptId, node, resources, tickSignal);
+                return this.atomAttemptRunner.start({
+                    definition: lease.definition,
+                    ...(lease.executionSource ? { executionSource: lease.executionSource } : {}),
+                    input,
+                    context,
+                    lifecycle: this.lifecycleOptions(attemptSnapshot, hostManager, node, input, context, activationId, attemptId),
+                });
+            }, node, parentSignal, started);
+            while (lifecycle.state === "running") {
+                if (lifecycle.nextPollAfterMs)
+                    await delay(lifecycle.nextPollAfterMs, undefined, { signal: parentSignal });
+                lifecycle = await this.tickTimeout(async (tickSignal) => {
+                    const context = await this.context(runId, activationId, attemptId, node, resources, tickSignal);
+                    return this.atomAttemptRunner.continue({
+                        definition: lease.definition,
+                        ...(lease.executionSource ? { executionSource: lease.executionSource } : {}),
+                        input,
+                        context,
+                        snapshot: lifecycle,
+                        lifecycle: this.lifecycleOptions(attemptSnapshot, hostManager, node, input, context, activationId, attemptId),
+                    });
+                }, node, parentSignal, started);
+            }
+            await this.persistLifecycle(runId, activationId, attemptId, lifecycle, hostManager, Date.now() - started);
+            if (lifecycle.state !== "succeeded") {
+                await resources.disposeAll("interrupted");
+                return undefined;
+            }
+            await resources.disposeAll("completed");
+            return {
+                output: lifecycle.completion.output,
+                artifacts: lifecycle.completion.artifacts ?? [],
+            };
+        }
+        catch (error) {
+            await resources.disposeAll(toAtomWorkflowError(error).code === "CANCELLED" ? "cancelled" : toAtomWorkflowError(error).code.includes("TIMEOUT") ? "timeout" : "failed").catch(() => undefined);
+            throw error;
+        }
+        finally {
+            lease.release();
+        }
+    }
+    async resumeAttempt(runId, attemptId, resume) {
+        const snapshot = await this.options.store.load(runId);
+        const attempt = snapshot.attempts.find((candidate) => candidate.attemptId === attemptId);
+        if (!attempt || !attempt.lifecycleSnapshot)
+            throw new AtomWorkflowError("ATTEMPT_NOT_RESUMABLE", `Attempt is not resumable: ${attemptId}`);
+        const nodeRun = snapshot.nodeRuns.find((candidate) => candidate.activationId === attempt.activationId);
+        const node = snapshot.ir.nodes.find((candidate) => candidate.id === attempt.nodeId);
+        if (node.kind !== "atom")
+            throw new AtomWorkflowError("CONTROL_NODE_ATTEMPT_INVALID", `Control node cannot resume an Atom Attempt: ${node.id}`);
+        const input = nodeRun.input ?? nodeInput(snapshot, node, nodeRun);
+        const lease = this.options.atoms.acquire(node.atom.id, node.atom.version);
+        const resources = this.resources(runId, attemptId);
+        const activeStarted = Date.now();
+        const budgetStarted = activeStarted - attempt.activeDurationMs;
+        try {
+            const hostManager = this.hostManager(snapshot);
+            let lifecycle = await this.tickTimeout(async (tickSignal) => {
+                const context = await this.context(runId, attempt.activationId, attemptId, node, resources, tickSignal);
+                return this.atomAttemptRunner.continue({
+                    definition: lease.definition,
+                    ...(lease.executionSource ? { executionSource: lease.executionSource } : {}),
+                    input,
+                    context,
+                    snapshot: attempt.lifecycleSnapshot,
+                    lifecycle: this.lifecycleOptions(snapshot, hostManager, node, input, context, attempt.activationId, attemptId),
+                    resume,
+                });
+            }, node, new AbortController().signal, budgetStarted);
+            while (lifecycle.state === "running") {
+                if (lifecycle.nextPollAfterMs)
+                    await delay(lifecycle.nextPollAfterMs);
+                lifecycle = await this.tickTimeout(async (tickSignal) => {
+                    const context = await this.context(runId, attempt.activationId, attemptId, node, resources, tickSignal);
+                    return this.atomAttemptRunner.continue({
+                        definition: lease.definition,
+                        ...(lease.executionSource ? { executionSource: lease.executionSource } : {}),
+                        input,
+                        context,
+                        snapshot: lifecycle,
+                        lifecycle: this.lifecycleOptions(snapshot, hostManager, node, input, context, attempt.activationId, attemptId),
+                    });
+                }, node, new AbortController().signal, budgetStarted);
+            }
+            await this.persistLifecycle(runId, attempt.activationId, attemptId, lifecycle, hostManager, Date.now() - activeStarted);
+            if (lifecycle.state === "succeeded") {
+                await resources.disposeAll("completed");
+                await this.commitCompletion(runId, attempt.activationId, {
+                    output: lifecycle.completion.output,
+                    artifacts: lifecycle.completion.artifacts ?? [],
+                }, "node.resumed_succeeded");
+            }
+            else
+                await resources.disposeAll("interrupted");
+        }
+        catch (error) {
+            const normalized = toAtomWorkflowError(error);
+            await resources.disposeAll(normalized.code === "CANCELLED" ? "cancelled" : normalized.code.includes("TIMEOUT") ? "timeout" : "failed").catch(() => undefined);
+            throw error;
+        }
+        finally {
+            lease.release();
+        }
+    }
+    async context(runId, activationId, attemptId, node, resources, signal) {
+        const snapshot = await this.options.store.load(runId);
+        const appendLog = (level, message, fields) => {
+            void this.options.store.update(runId, (current) => this.event(current, "atom.log", { level, message, ...fields }, node.id, activationId, attemptId));
+        };
+        const cwd = snapshot.run.cwd;
+        const base = {
+            runtime: {
+                runId,
+                workflowRevisionId: snapshot.revision.workflowRevisionId,
+                nodeId: node.id,
+                attemptId,
+                attempt: snapshot.attempts.find((candidate) => candidate.attemptId === attemptId)?.attemptIndex ?? 0,
+                cwd,
+            },
+            cwd,
+            signal,
+            artifacts: this.options.artifacts.forAttempt(runId, attemptId, async (artifact) => {
+                await this.options.store.update(runId, (current) => ({ ...current, artifacts: [...current.artifacts, artifact] }));
+            }),
+            resources,
+            logger: runtimeLogger(appendLog),
+            metadata: { projectScope: snapshot.run.projectScope, hostScope: snapshot.run.hostScope },
+            ...(node.decisionBranches ? { decision: { branches: node.decisionBranches } } : {}),
+            ...createAtomLifecycleHelpers(),
+        };
+        return base;
+    }
+    lifecycleOptions(snapshot, hostManager, node, input, context, activationId, attemptId) {
+        return {
+            maxLifecycleTicks: node.effectivePolicy.maxLifecycleTicks,
+            persistTick: (tick) => this.persistTick(snapshot.run.runId, attemptId, tick),
+            issueHostTask: (declaration) => hostManager.issue({
+                manifest: node.atom.manifest,
+                declaration,
+                input,
+                runId: snapshot.run.runId,
+                workflowRevisionId: context.runtime.workflowRevisionId,
+                nodeId: node.id,
+                activationId,
+                attemptId,
+                workflowIrHash: snapshot.ir.hash,
+                projectScope: context.metadata.projectScope,
+                hostScope: context.metadata.hostScope,
+            }),
+        };
+    }
+    resources(runId, attemptId) {
+        const persist = (resource, status) => {
+            void this.options.store.update(runId, (snapshot) => ({
+                ...snapshot,
+                resourceLeases: status === "active"
+                    ? [...snapshot.resourceLeases, {
+                            schemaVersion: "1.0",
+                            leaseId: `${attemptId}:${resource.id}`,
+                            runId,
+                            attemptId,
+                            kind: resource.kind,
+                            ...(resource.recoveryLease !== undefined ? { recoveryLease: resource.recoveryLease } : {}),
+                            status,
+                            createdAt: nowIso(this.now),
+                        }]
+                    : snapshot.resourceLeases.map((lease) => lease.leaseId === `${attemptId}:${resource.id}` ? {
+                        ...lease,
+                        status,
+                        releasedAt: nowIso(this.now),
+                    } : lease),
+            }));
+        };
+        return new ManagedAttemptResources((resource) => persist(resource, "active"), (resource) => persist(resource, "released"));
+    }
+    async tickTimeout(operation, node, signal, started) {
+        const attemptTimeoutMs = node.effectivePolicy.attemptTimeoutMs;
+        const remaining = attemptTimeoutMs === null ? null : attemptTimeoutMs - (Date.now() - started);
+        if (remaining !== null && remaining <= 0)
+            throw new AtomWorkflowError("ATTEMPT_TIMEOUT", `Attempt timeout exceeded: ${node.id}`, true);
+        const limits = [remaining, this.options.nodeTimeoutMs ?? null, node.effectivePolicy.lifecycleTickTimeoutMs]
+            .filter((value) => value !== null);
+        const timeoutMs = limits.length > 0 ? Math.min(...limits) : null;
+        return withTimeout(operation, timeoutMs, signal);
+    }
+    async persistTick(runId, attemptId, tick) {
+        await this.options.store.update(runId, (snapshot) => {
+            const attempts = snapshot.attempts.map((attempt) => attempt.attemptId === attemptId ? {
+                ...attempt,
+                state: "running",
+                phase: tick.phase,
+                tickCount: tick.tickIndex + 1,
+                ...(tick.checkpoint !== undefined ? { checkpoint: tick.checkpoint } : {}),
+                ...(tick.checkpointHash !== undefined ? { checkpointHash: tick.checkpointHash } : {}),
+                updatedAt: nowIso(this.now),
+            } : attempt);
+            return this.event({ ...snapshot, attempts }, "lifecycle.tick", {
+                tickIndex: tick.tickIndex,
+                phase: tick.phase,
+                status: tick.status,
+                ...(tick.checkpointHash ? { checkpointHash: tick.checkpointHash } : {}),
+            }, attempts.find((attempt) => attempt.attemptId === attemptId)?.nodeId, undefined, attemptId);
+        });
+    }
+    async persistLifecycle(runId, activationId, attemptId, lifecycle, manager, activeDurationDeltaMs) {
+        await this.options.store.update(runId, (snapshot) => {
+            const timestamp = nowIso(this.now);
+            const attempts = snapshot.attempts.map((attempt) => attempt.attemptId === attemptId ? {
+                ...attempt,
+                state: lifecycle.state,
+                phase: lifecycle.state === "succeeded" ? "complete" : "resume",
+                checkpoint: lifecycle.checkpoint,
+                lifecycleSnapshot: snapshotAsJson(lifecycle),
+                tickCount: lifecycle.ticks.length,
+                activeDurationMs: attempt.activeDurationMs + Math.max(0, activeDurationDeltaMs),
+                updatedAt: timestamp,
+                ...(lifecycle.state === "succeeded" ? { endedAt: timestamp } : {}),
+            } : attempt);
+            const nodeStatus = lifecycle.state === "succeeded" ? "running" : lifecycle.state;
+            let signals = snapshot.signals;
+            if (lifecycle.state === "awaiting_signal") {
+                const pending = lifecycle.pendingSignal;
+                const existing = signals.some((signal) => signal.signalId === pending.signalId);
+                if (!existing) {
+                    const created = this.now();
+                    const signal = {
+                        schemaVersion: "1.0",
+                        signalId: pending.signalId,
+                        runId,
+                        workflowRevisionId: snapshot.revision.workflowRevisionId,
+                        nodeId: attempts.find((attempt) => attempt.attemptId === attemptId).nodeId,
+                        activationId,
+                        attemptId,
+                        projectScope: snapshot.run.projectScope,
+                        hostScope: snapshot.run.hostScope,
+                        key: pending.request.key,
+                        prompt: pending.request.prompt,
+                        context: pending.request.context,
+                        responseSchema: pending.request.responseSchema,
+                        resume: createSignalResumeDirective(runId, pending.signalId),
+                        status: "waiting",
+                        createdAt: created.toISOString(),
+                        ...(pending.request.expiresInMs !== undefined ? { expiresAt: new Date(created.getTime() + pending.request.expiresInMs).toISOString() } : {}),
+                    };
+                    signals = [...signals, signal];
+                }
+            }
+            return this.event({
+                ...snapshot,
+                attempts,
+                signals,
+                hostTasks: manager.exportRecords(),
+                nodeRuns: snapshot.nodeRuns.map((nodeRun) => nodeRun.activationId === activationId ? {
+                    ...nodeRun,
+                    status: nodeStatus,
+                    updatedAt: timestamp,
+                } : nodeRun),
+                run: lifecycle.state === "awaiting_host" || lifecycle.state === "awaiting_signal" ? {
+                    ...snapshot.run,
+                    status: lifecycle.state,
+                    updatedAt: timestamp,
+                } : snapshot.run,
+            }, `attempt.${lifecycle.state}`, {}, attempts.find((attempt) => attempt.attemptId === attemptId)?.nodeId, activationId, attemptId);
+        });
+    }
+    async commitCompletion(runId, activationId, completion, eventType) {
+        await this.options.store.update(runId, (snapshot) => {
+            const timestamp = nowIso(this.now);
+            const completing = snapshot.nodeRuns.find((nodeRun) => nodeRun.activationId === activationId);
+            if (completing)
+                assertNodeRunTransition(completing.status, "succeeded");
+            let next = {
+                ...snapshot,
+                nodeRuns: snapshot.nodeRuns.map((nodeRun) => nodeRun.activationId === activationId ? {
+                    ...nodeRun,
+                    status: "succeeded",
+                    output: completion.output,
+                    artifacts: [...completion.artifacts],
+                    updatedAt: timestamp,
+                    endedAt: timestamp,
+                } : nodeRun),
+            };
+            next = this.advance(next, activationId, completion.output);
+            return this.event(next, eventType, {}, completing?.nodeId, activationId);
+        });
+    }
+    advance(snapshot, activationId, output) {
+        const source = snapshot.nodeRuns.find((nodeRun) => nodeRun.activationId === activationId);
+        const node = snapshot.ir.nodes.find((candidate) => candidate.id === source.nodeId);
+        let selectedBranch;
+        let edge = snapshot.ir.control.edges.find((candidate) => candidate.sourceNodeId === source.nodeId
+            && (candidate.kind === "next" || candidate.kind === "join-next" || candidate.kind === "map-return"));
+        if (node.kind === "switch") {
+            const selected = resolveReference(node.select.$ref, snapshot, source);
+            if (typeof selected !== "string")
+                throw new AtomWorkflowError("SWITCH_SELECTION_INVALID", `SwitchNode selection is not a string: ${node.id}`);
+            selectedBranch = selected;
+            edge = snapshot.ir.control.edges.find((candidate) => candidate.sourceNodeId === source.nodeId && candidate.kind === "switch-case" && candidate.branchId === selected)
+                ?? snapshot.ir.control.edges.find((candidate) => candidate.sourceNodeId === source.nodeId && candidate.kind === "switch-default");
+        }
+        if (edge?.kind === "map-return")
+            return this.returnFromMap(snapshot, source, output, edge);
+        if (!edge)
+            throw new AtomWorkflowError("WORKFLOW_EDGE_NOT_FOUND", `No frozen control edge for ${source.nodeId}`);
+        return this.routeEdge(snapshot, source, output, edge, selectedBranch);
+    }
+    routeEdge(snapshot, source, output, edge, selectedBranch) {
+        if (snapshot.transitionCount >= snapshot.ir.effectiveRuntimePolicy.maxWorkflowTransitions) {
+            throw new AtomWorkflowError("WORKFLOW_TRANSITION_BUDGET_EXHAUSTED", "Workflow transition budget exhausted");
+        }
+        const traversals = snapshot.edgeTraversals[edge.id] ?? 0;
+        const limit = edge.maxTraversals ?? (edge.backEdge ? snapshot.ir.effectiveRuntimePolicy.maxEdgeTraversals : undefined);
+        if (limit !== undefined && traversals >= limit)
+            throw new AtomWorkflowError("WORKFLOW_EDGE_BUDGET_EXHAUSTED", `Edge budget exhausted: ${edge.id}`);
+        let next = {
+            ...snapshot,
+            transitionCount: snapshot.transitionCount + 1,
+            edgeTraversals: { ...snapshot.edgeTraversals, [edge.id]: traversals + 1 },
+            ...(selectedBranch !== undefined ? { decisions: [...snapshot.decisions, { activationId: source.activationId, nodeId: source.nodeId, selectedBranch, matched: edge.kind === "switch-case", edgeId: edge.id, selectedAt: nowIso(this.now) }] } : {}),
+        };
+        if (selectedBranch !== undefined) {
+            next = this.event(next, "switch.selected", { selectedBranch, matched: edge.kind === "switch-case", edgeId: edge.id }, source.nodeId, source.activationId);
+        }
+        if (edge.terminal) {
+            const status = edge.terminal === "$end" ? "succeeded" : edge.terminal === "$cancelled" ? "cancelled" : "failed";
+            const outputs = status === "succeeded" ? this.workflowOutputs(next) : undefined;
+            if (outputs) {
+                const issues = validateJsonSchemaInstance(snapshot.revision.outputSchema, outputs, "$.outputs");
+                if (issues.length)
+                    throw new AtomWorkflowError("WORKFLOW_OUTPUT_INVALID", "Workflow outputs do not satisfy the frozen output contract", false, { cause: issues });
+            }
+            return {
+                ...next,
+                run: {
+                    ...next.run,
+                    status,
+                    ...(outputs ? { outputs } : {}),
+                    updatedAt: nowIso(this.now),
+                    endedAt: nowIso(this.now),
+                },
+            };
+        }
+        const overlay = Object.fromEntries(Object.entries(edge.with).map(([key, value]) => [key, this.resolveEdgeValue(value, output, next, source)]));
+        const sourceNode = next.ir.nodes.find((candidate) => candidate.id === source.nodeId);
+        const mapContext = source.mapRunId && sourceNode.mapScope ? {
+            mapRunId: source.mapRunId,
+            ...(source.mapItem !== undefined ? { mapItem: source.mapItem } : {}),
+            ...(source.mapIndex !== undefined ? { mapIndex: source.mapIndex } : {}),
+        } : undefined;
+        let targetLineage = source.controlLineage;
+        if (edge.kind === "join-next")
+            targetLineage = targetLineage.slice(0, -1);
+        else if (edge.targets.length > 1)
+            targetLineage = [...targetLineage, `${source.activationId}:${edge.id}`];
+        for (const target of edge.targets) {
+            const targetNode = next.ir.nodes.find((node) => node.id === target);
+            const targetContext = targetNode.mapScope && targetNode.mapScope === sourceNode.mapScope ? mapContext : undefined;
+            if (targetNode.kind === "join") {
+                if (!next.pendingEdges.some((pending) => pending.edgeId === edge.id && pending.targetNodeId === target
+                    && pending.mapRunId === targetContext?.mapRunId && pending.mapIndex === targetContext?.mapIndex
+                    && sameLineage(pending.controlLineage, targetLineage))) {
+                    next = { ...next, pendingEdges: [...next.pendingEdges, { edgeId: edge.id, targetNodeId: target, overlay, controlLineage: targetLineage, ...(targetContext ?? {}) }] };
+                }
+            }
+            else
+                next = this.activate(next, target, overlay, edge.id, targetContext, targetLineage);
+        }
+        return this.flushReadyJoinsSync(next);
+    }
+    returnFromMap(snapshot, source, output, edge) {
+        if (!source.mapRunId || source.mapIndex === undefined) {
+            throw new AtomWorkflowError("MAP_CONTEXT_MISSING", `Map processor activation has no durable MapRun context: ${source.activationId}`);
+        }
+        if (snapshot.transitionCount >= snapshot.ir.effectiveRuntimePolicy.maxWorkflowTransitions) {
+            throw new AtomWorkflowError("WORKFLOW_TRANSITION_BUDGET_EXHAUSTED", "Workflow transition budget exhausted");
+        }
+        const traversals = snapshot.edgeTraversals[edge.id] ?? 0;
+        const limit = edge.maxTraversals ?? (edge.backEdge ? snapshot.ir.effectiveRuntimePolicy.maxEdgeTraversals : undefined);
+        if (limit !== undefined && traversals >= limit)
+            throw new AtomWorkflowError("WORKFLOW_EDGE_BUDGET_EXHAUSTED", `Edge budget exhausted: ${edge.id}`);
+        let next = {
+            ...snapshot,
+            transitionCount: snapshot.transitionCount + 1,
+            edgeTraversals: { ...snapshot.edgeTraversals, [edge.id]: traversals + 1 },
+        };
+        const mapRun = next.mapRuns.find((run) => run.mapRunId === source.mapRunId);
+        if (!mapRun)
+            throw new AtomWorkflowError("MAP_RUN_NOT_FOUND", `MapRun does not exist: ${source.mapRunId}`);
+        const mapNode = next.ir.nodes.find((candidate) => candidate.id === mapRun.mapNodeId && candidate.kind === "map");
+        if (!mapNode)
+            throw new AtomWorkflowError("MAP_NODE_NOT_FOUND", `MapNode does not exist: ${mapRun.mapNodeId}`);
+        const itemComplete = mapNode.bodyExitNodeIds.every((nodeId) => next.nodeRuns.some((run) => run.nodeId === nodeId && run.mapRunId === mapRun.mapRunId && run.mapIndex === source.mapIndex && run.status === "succeeded"));
+        if (!itemComplete || mapRun.completedIndices.includes(source.mapIndex))
+            return next;
+        const timestamp = nowIso(this.now);
+        next = {
+            ...next,
+            mapRuns: next.mapRuns.map((run) => run.mapRunId === mapRun.mapRunId ? {
+                ...run,
+                activeIndices: run.activeIndices.filter((index) => index !== source.mapIndex),
+                completedIndices: [...run.completedIndices, source.mapIndex].sort((left, right) => left - right),
+                updatedAt: timestamp,
+            } : run),
+        };
+        const updated = next.mapRuns.find((run) => run.mapRunId === mapRun.mapRunId);
+        if (updated.completedIndices.length === updated.items.length) {
+            return this.finishMap(next, mapRun.mapRunId, mapNode, this.mapOutput(next, mapRun.mapRunId, mapNode));
+        }
+        return this.scheduleMapItems(next, mapRun.mapRunId, mapNode);
+    }
+    scheduleMapItems(snapshot, mapRunId, node) {
+        let next = snapshot;
+        let run = next.mapRuns.find((candidate) => candidate.mapRunId === mapRunId);
+        while (run.nextIndex < run.items.length && run.activeIndices.length < node.maxConcurrency) {
+            const index = run.nextIndex;
+            const item = run.items[index];
+            const controller = next.nodeRuns.find((candidate) => candidate.activationId === run.activationId);
+            if (!controller)
+                throw new AtomWorkflowError("MAP_ACTIVATION_NOT_FOUND", `MapNode activation does not exist: ${run.activationId}`);
+            const itemLineage = node.bodyEntries.length > 1
+                ? [...controller.controlLineage, `${controller.activationId}:${node.id}:item:${index}`]
+                : controller.controlLineage;
+            for (const entry of node.bodyEntries) {
+                next = this.activate(next, entry, {}, `${node.id}:enter`, { mapRunId, mapItem: item, mapIndex: index }, itemLineage);
+            }
+            const timestamp = nowIso(this.now);
+            next = {
+                ...next,
+                mapRuns: next.mapRuns.map((candidate) => candidate.mapRunId === mapRunId ? {
+                    ...candidate,
+                    nextIndex: index + 1,
+                    activeIndices: [...candidate.activeIndices, index],
+                    updatedAt: timestamp,
+                } : candidate),
+            };
+            run = next.mapRuns.find((candidate) => candidate.mapRunId === mapRunId);
+        }
+        return next;
+    }
+    mapOutput(snapshot, mapRunId, node) {
+        const outputFor = (nodeId) => snapshot.nodeRuns
+            .filter((run) => run.nodeId === nodeId && run.mapRunId === mapRunId && run.status === "succeeded")
+            .sort((left, right) => (left.mapIndex ?? 0) - (right.mapIndex ?? 0))
+            .map((run) => run.output ?? null);
+        if (node.bodyExitNodeIds.length === 1)
+            return outputFor(node.bodyExitNodeIds[0]);
+        return Object.fromEntries(node.bodyExitNodeIds.map((nodeId) => [nodeId, outputFor(nodeId)]));
+    }
+    finishMap(snapshot, mapRunId, node, output) {
+        const mapRun = snapshot.mapRuns.find((candidate) => candidate.mapRunId === mapRunId);
+        const timestamp = nowIso(this.now);
+        let next = {
+            ...snapshot,
+            mapRuns: snapshot.mapRuns.map((candidate) => candidate.mapRunId === mapRunId ? {
+                ...candidate,
+                status: "succeeded",
+                activeIndices: [],
+                updatedAt: timestamp,
+                endedAt: timestamp,
+            } : candidate),
+            nodeRuns: snapshot.nodeRuns.map((run) => run.activationId === mapRun.activationId ? {
+                ...run,
+                status: "succeeded",
+                output,
+                updatedAt: timestamp,
+                endedAt: timestamp,
+            } : run),
+        };
+        next = this.event(next, "map.completed", { itemCount: mapRun.items.length }, node.id, mapRun.activationId);
+        const completionEdges = next.ir.control.edges.filter((edge) => edge.sourceNodeId === node.id && edge.kind === "map-complete");
+        if (completionEdges.length === 0)
+            throw new AtomWorkflowError("MAP_COMPLETION_EDGE_NOT_FOUND", `MapNode has no completion edge: ${node.id}`);
+        const source = next.nodeRuns.find((run) => run.activationId === mapRun.activationId);
+        for (const edge of completionEdges) {
+            next = this.routeEdge(next, source, output, edge);
+            if (next.run.status !== "running")
+                break;
+        }
+        return next;
+    }
+    resolveEdgeValue(value, output, snapshot, source) {
+        if (Array.isArray(value))
+            return value.map((item) => this.resolveEdgeValue(item, output, snapshot, source));
+        if (value !== null && typeof value === "object") {
+            if (Object.keys(value).length === 1 && typeof value.$ref === "string") {
+                const reference = value.$ref;
+                if (reference === "node.output" || reference.startsWith("node.output.")) {
+                    const resolved = valueAtPath(output, reference === "node.output" ? [] : reference.split(".").slice(2));
+                    if (resolved === undefined)
+                        throw new AtomWorkflowError("ROUTE_BINDING_RESOLUTION_FAILED", `Missing ${reference}`);
+                    return resolved;
+                }
+                return resolveReference(reference, snapshot, source);
+            }
+            return Object.fromEntries(Object.entries(value).map(([key, nested]) => [key, this.resolveEdgeValue(nested, output, snapshot, source)]));
+        }
+        return value;
+    }
+    activate(snapshot, nodeId, overlay, edgeId, mapContext, controlLineage = []) {
+        const node = snapshot.ir.nodes.find((candidate) => candidate.id === nodeId);
+        if (!node)
+            throw new AtomWorkflowError("NODE_NOT_FOUND", `Node not found in frozen IR: ${nodeId}`);
+        const current = snapshot.activationCounts[nodeId] ?? 0;
+        const create = () => {
+            const index = current;
+            if (index >= snapshot.ir.effectiveRuntimePolicy.maxNodeActivations) {
+                throw new AtomWorkflowError("WORKFLOW_NODE_ACTIVATION_BUDGET_EXHAUSTED", `Activation budget exhausted: ${nodeId}`);
+            }
+            const timestamp = nowIso(this.now);
+            return {
+                schemaVersion: "1.0",
+                activationId: `${encodeURIComponent(snapshot.revision.workflowRevisionId)}:${nodeId}:${index}`,
+                workflowRevisionId: snapshot.revision.workflowRevisionId,
+                nodeId,
+                activationIndex: index,
+                status: "ready",
+                attemptIds: [],
+                inputOverlay: { ...overlay },
+                controlLineage: [...controlLineage],
+                ...(mapContext?.mapRunId ? {
+                    mapRunId: mapContext.mapRunId,
+                    ...(mapContext.mapItem !== undefined ? { mapItem: mapContext.mapItem } : {}),
+                    ...(mapContext.mapIndex !== undefined ? { mapIndex: mapContext.mapIndex } : {}),
+                } : {}),
+                ...(edgeId ? { triggeredByEdgeId: edgeId } : {}),
+                artifacts: [],
+                createdAt: timestamp,
+                updatedAt: timestamp,
+            };
+        };
+        const created = [create()];
+        return {
+            ...snapshot,
+            nodeRuns: [...snapshot.nodeRuns, ...created],
+            activationCounts: { ...snapshot.activationCounts, [nodeId]: current + created.length },
+        };
+    }
+    flushReadyJoinsSync(snapshot) {
+        let next = snapshot;
+        const grouped = new Map();
+        for (const pending of snapshot.pendingEdges) {
+            const key = `${pending.targetNodeId}|${pending.mapRunId ?? ""}|${pending.mapIndex ?? ""}|${JSON.stringify(pending.controlLineage)}`;
+            const current = grouped.get(key);
+            grouped.set(key, { target: pending.targetNodeId, pending: [...(current?.pending ?? []), pending] });
+        }
+        for (const { target, pending } of grouped.values()) {
+            const node = next.ir.nodes.find((candidate) => candidate.id === target);
+            if (node.kind !== "join")
+                throw new AtomWorkflowError("JOIN_NODE_INVALID", `Pending fan-in target is not a JoinNode: ${target}`);
+            const first = pending[0];
+            const arrived = new Set(pending.map((item) => item.edgeId));
+            if (!node.incomingEdgeIds.every((edgeId) => arrived.has(edgeId)))
+                continue;
+            const overlay = {};
+            for (const item of pending)
+                for (const [key, value] of Object.entries(item.overlay)) {
+                    if (key in overlay && JSON.stringify(overlay[key]) !== JSON.stringify(value)) {
+                        throw new AtomWorkflowError("JOIN_OVERLAY_CONFLICT", `JoinNode received conflicting values for ${key}: ${target}`);
+                    }
+                    overlay[key] = value;
+                }
+            next = this.activate({
+                ...next,
+                pendingEdges: next.pendingEdges.filter((item) => !(item.targetNodeId === target
+                    && item.mapRunId === first?.mapRunId && item.mapIndex === first?.mapIndex
+                    && sameLineage(item.controlLineage, first?.controlLineage ?? []))),
+            }, target, overlay, first?.edgeId, first?.mapRunId ? {
+                mapRunId: first.mapRunId,
+                ...(first.mapItem !== undefined ? { mapItem: first.mapItem } : {}),
+                ...(first.mapIndex !== undefined ? { mapIndex: first.mapIndex } : {}),
+            } : undefined, first?.controlLineage ?? []);
+        }
+        return next;
+    }
+    async flushReadyJoins(snapshot) {
+        const next = this.flushReadyJoinsSync(snapshot);
+        if (next === snapshot)
+            return snapshot;
+        await this.options.store.save(next);
+        return next;
+    }
+    workflowOutputs(snapshot) {
+        return Object.fromEntries(Object.entries(snapshot.ir.outputs).map(([name, reference]) => [name, resolveReference(reference.$ref, snapshot)]));
+    }
+    hostManager(snapshot) {
+        const manager = new HostHandoffManager();
+        manager.importRecords(snapshot.hostTasks, (id, version) => this.options.atoms.get(id, version).manifest);
+        return manager;
+    }
+    event(snapshot, type, data, nodeId, activationId, attemptId, sessionId) {
+        const event = {
+            schemaVersion: "1.0",
+            sequence: snapshot.eventSequence,
+            timestamp: nowIso(this.now),
+            runId: snapshot.run.runId,
+            workflowRevisionId: snapshot.revision.workflowRevisionId,
+            ...(nodeId ? { nodeId } : {}),
+            ...(activationId ? { activationId } : {}),
+            ...(attemptId ? { attemptId } : {}),
+            ...(sessionId ? { sessionId } : {}),
+            type,
+            data,
+        };
+        try {
+            this.options.onEvent?.(event);
+        }
+        catch { /* Observability must not break execution. */ }
+        return { ...snapshot, events: [...snapshot.events, event], eventSequence: snapshot.eventSequence + 1 };
+    }
+}
+//# sourceMappingURL=durable-workflow-engine.js.map