@tangle-network/agent-runtime 0.163.0 → 0.165.0

package/dist/graph.js

@@ -1,8 +1,9 @@
 import { m as ValidationError } from "./errors-CDZ8XsVj.js";
-import { i as InMemorySpawnJournal, r as InMemoryResultBlobStore, x as contentAddress } from "./spawn-journal-oewq1g2h.js";
-import { A as createBudgetPool, B as createExecutorRegistry, i as collectDelivered, o as runFinalizer, r as bestDelivered, u as createScope } from "./supervisor-DmWq4vkU.js";
-import { i as workerFromBackend, s as supervisorAgent } from "./supervise-Di6xvnOL.js";
-import { t as GraphEdgeCapError } from "./graph-COikUkrj.js";
+import { d as replaySpawnTree, i as InMemorySpawnJournal, l as materializeTreeView, o as closesCursorSlot, r as InMemoryResultBlobStore, u as pendingWaits, x as contentAddress } from "./spawn-journal-Tgvp5VS5.js";
+import { t as addSpend } from "./util-D6ZEuBMi.js";
+import { N as createBudgetPool, U as createExecutorRegistry, a as uncertainSpawnBudgets, i as sumMeasuredSpendFromEvents, l as runFinalizer, o as bestDelivered, p as createScope, r as maxSeqOf, s as collectDelivered } from "./supervisor-DpIKMlPJ.js";
+import { i as workerFromBackend, s as supervisorAgent } from "./supervise-Da20R0PO.js";
+import { t as GraphEdgeCapError } from "./graph-DGri_zJm.js";
 //#region src/runtime/graph/condition.ts
 /**
 * The ONE predicate tree: every guard in a graph — an edge `guard`, a filter projection's
@@ -588,6 +589,211 @@ function createGraphEngine(options) {
 	return engine;
 }
 //#endregion
+//#region src/runtime/graph/fold.ts
+/**
+* The fold (agent-runtime#974): scheduler state is a pure function of the journal, reconstructed
+* by replaying events through the SAME reducer the live scheduler feeds — fold, never checkpoint.
+* Kernel events (`spawned`, `settled`, `waiting`, `woken`) carry what the kernel owns; the engine's
+* events (`node-inputs-resolved`, `edge-verdict`, `join-state`) carry what the scheduler decided,
+* each journaled BEFORE its effect was visible. `edge` stays observability and is skipped here
+* exactly as the kernel's own replay skips it.
+*
+* Events are consumed in APPEND order (the journal file's line order), not by `seq`: kernel and
+* engine events carry independent ordinal counters, and append order is the one total order both
+* share.
+*/
+/** The reducer's zero: every node unvisited, every edge pending, nothing suspended. */
+function emptyFoldState(compiled) {
+	const nodes = /* @__PURE__ */ new Map();
+	for (const id of compiled.nodes.keys()) nodes.set(id, {
+		visits: 0,
+		blocked: false,
+		settles: []
+	});
+	const edges = /* @__PURE__ */ new Map();
+	for (const edge of compiled.edges) edges.set(edge.id, {
+		state: "pending",
+		consumedOnce: false,
+		traversals: 0,
+		judgedSourceSettles: 0,
+		capped: false
+	});
+	return {
+		nodes,
+		edges,
+		instances: /* @__PURE__ */ new Map(),
+		spawnedIds: /* @__PURE__ */ new Map(),
+		suspensions: /* @__PURE__ */ new Map(),
+		exhaustedEdges: /* @__PURE__ */ new Set()
+	};
+}
+function instanceOf(state, label) {
+	return state.instances.get(label);
+}
+/**
+* Apply ONE journal event. The live scheduler calls this right after each append; the restart path
+* calls it over the loaded journal. Unknown kernel events are ignored — the engine folds only what
+* it understands, exactly as the kernel's replay skips the engine's events.
+*/
+function applyGraphFoldEvent(state, ev, compiled) {
+	switch (ev.kind) {
+		case "node-inputs-resolved": {
+			const visit = Number(ev.instance.split("#").at(-1));
+			if (!Number.isSafeInteger(visit)) throw new ValidationError(`graph fold: instance ${ev.instance} carries no visit ordinal`);
+			state.instances.set(ev.instance, {
+				node: ev.node,
+				instance: ev.instance,
+				visit,
+				inputRef: ev.inputRef,
+				status: "released"
+			});
+			const node = state.nodes.get(ev.node);
+			if (node) node.visits = Math.max(node.visits, visit);
+			return;
+		}
+		case "spawned": {
+			const instance = instanceOf(state, ev.label);
+			if (instance) {
+				instance.status = "live";
+				state.spawnedIds.set(ev.id, ev.label);
+			}
+			return;
+		}
+		case "settled": {
+			const label = state.spawnedIds.get(ev.id);
+			const instance = label === void 0 ? void 0 : instanceOf(state, label);
+			if (!instance) return;
+			instance.status = ev.status;
+			const settle = {
+				node: instance.node,
+				visit: instance.visit,
+				status: ev.status,
+				...ev.outRef !== void 0 ? { outRef: ev.outRef } : {},
+				...ev.reason !== void 0 ? { reason: ev.reason } : {}
+			};
+			if (ev.trace?.status === "available") settle.traceRef = ev.trace.traceRef;
+			instance.settle = settle;
+			state.nodes.get(instance.node)?.settles.push(settle);
+			const node = compiled.nodes.get(instance.node);
+			for (const edge of node?.outbound ?? []) {
+				const folded = state.edges.get(edge.id);
+				if (folded?.consumedOnce && folded.state === "pending") {
+					folded.consumedOnce = false;
+					folded.judgedSourceSettles += 1;
+				}
+			}
+			return;
+		}
+		case "edge-verdict": {
+			const folded = state.edges.get(ev.edge);
+			if (!folded) return;
+			if (ev.capped) {
+				folded.capped = true;
+				state.exhaustedEdges.add(ev.edge);
+				const target = compiled.edges.find((edge) => edge.id === ev.edge)?.spec.to.node;
+				const compiledTarget = target === void 0 ? void 0 : compiled.nodes.get(target);
+				if (compiledTarget && (compiledTarget.join === "all" || compiledTarget.join === "all_done")) {
+					const node = state.nodes.get(target);
+					if (node) node.blocked = true;
+				}
+				return;
+			}
+			folded.judgedSourceSettles += 1;
+			if (!ev.fired) {
+				folded.state = ev.sourceStatus === "done" ? "dead" : "failed";
+				folded.payloadRef = void 0;
+				return;
+			}
+			folded.state = "satisfied";
+			folded.payloadRef = ev.inputRef;
+			return;
+		}
+		case "join-state": {
+			for (const edgeId of ev.satisfiedBy) {
+				const folded = state.edges.get(edgeId);
+				if (!folded) continue;
+				folded.traversals += 1;
+				folded.state = "pending";
+				folded.payloadRef = void 0;
+			}
+			const target = compiled.nodes.get(ev.node);
+			for (const edge of target?.inbound ?? []) {
+				const folded = state.edges.get(edge.id);
+				if (!folded) continue;
+				if (ev.consumedPending.includes(edge.id)) folded.consumedOnce = true;
+				else if (folded.state !== "pending" && !ev.satisfiedBy.includes(edge.id)) {
+					folded.state = "pending";
+					folded.payloadRef = void 0;
+				}
+			}
+			return;
+		}
+		case "waiting": {
+			if (ev.spec.kind !== "token") return;
+			const instance = instanceOf(state, ev.label);
+			if (instance) {
+				instance.status = "suspended";
+				if (instance.settle !== void 0) {
+					const settles = state.nodes.get(instance.node)?.settles;
+					if (settles && settles.at(-1) === instance.settle) settles.pop();
+					instance.settle = void 0;
+				}
+			}
+			state.suspensions.set(ev.spec.token, {
+				token: ev.spec.token,
+				node: instance?.node ?? ev.label.split("#")[0] ?? ev.label,
+				instance: ev.label,
+				onExpire: ev.spec.onExpire,
+				...ev.spec.expiresAtMs !== void 0 ? { expiresAtMs: ev.spec.expiresAtMs } : {},
+				...ev.spec.defaultRef !== void 0 ? { defaultRef: ev.spec.defaultRef } : {},
+				status: "pending"
+			});
+			return;
+		}
+		case "woken": {
+			const token = ev.id.startsWith("graphwait:") ? ev.id.slice(10) : void 0;
+			const suspension = token === void 0 ? void 0 : state.suspensions.get(token);
+			if (!suspension) return;
+			const instance = instanceOf(state, suspension.instance);
+			if (ev.by === "expired") {
+				suspension.status = "expired";
+				if (instance) {
+					instance.status = "down";
+					const settle = {
+						node: suspension.node,
+						visit: instance.visit,
+						status: "down",
+						reason: "suspension expired"
+					};
+					instance.settle = settle;
+					state.nodes.get(suspension.node)?.settles.push(settle);
+				}
+				return;
+			}
+			suspension.status = "woken";
+			if (instance) {
+				instance.status = "done";
+				const settle = {
+					node: suspension.node,
+					visit: instance.visit,
+					status: "done",
+					...ev.outRef !== void 0 ? { outRef: ev.outRef } : {}
+				};
+				instance.settle = settle;
+				state.nodes.get(suspension.node)?.settles.push(settle);
+			}
+			return;
+		}
+		default: return;
+	}
+}
+/** Fold a loaded journal (append order) into scheduler state. */
+function foldGraphJournal(events, compiled) {
+	const state = emptyFoldState(compiled);
+	for (const ev of events) applyGraphFoldEvent(state, ev, compiled);
+	return state;
+}
+//#endregion
 //#region src/runtime/graph/kinds.ts
 /**
 * One profile, one run: the kernel's leaf, exactly as `supervise()` derives it from `backend`.
@@ -799,18 +1005,43 @@ function asRecord(value, context) {
 //#endregion
 //#region src/runtime/graph/scheduler.ts
 /**
-* The engine scheduler (agent-runtime#980): run a compiled graph by hosting every node instance on
-* one kernel `Scope` — the pool, the journal, the blob store and cancellation are the kernel's,
-* never re-implemented. The scheduler owns only what a graph adds: joins over guarded edges,
-* traversal and visit caps, directive/payload delivery, terminals and the finalizer reduce.
+* The engine scheduler (agent-runtime#980, durable per #974/#976): run a compiled graph by hosting
+* every node instance on one kernel `Scope` — the pool, the journal, the blob store and
+* cancellation are the kernel's, never re-implemented. The scheduler owns only what a graph adds:
+* joins over guarded edges, traversal and visit caps, directive/payload delivery, suspensions,
+* terminals and the finalizer reduce.
 *
-* Edge semantics are adopted from ADC's workflow graph (agent-runtime#968): an edge settles
-* SATISFIED / DEAD / FAILED per its source's LATEST completion; join rules `all | any | any_failed
-* | all_done` decide release; a release CONSUMES the outcomes that produced it (settled edges
-* re-arm; a pending edge at release is consumed-once, so an OR-diamond's second completer never
-* double-fires). Per-edge `maxTraversals` refuses the consumption and ledgers `unpropagated`; a
-* node entered past `maxVisits` fails the run `cycle-budget-exceeded` (#973).
+* DURABILITY MODEL — fold, never checkpoint. Every scheduling decision is journaled BEFORE its
+* effect is visible (blob-then-journal where a ref is minted), then applied to in-memory state
+* through the SAME pure reducer (`applyGraphFoldEvent`) a restart replays the journal through.
+* Kill the process at any journal boundary and a restart with the same journal re-enters the exact
+* state: settled nodes restore from `outRef` and are never re-executed; a released-but-unspawned
+* instance re-enters from its pinned `inputRef`; an in-flight instance is in-doubt and re-enters
+* per its kind's `onCrash`.
+*
+* Engine `woken` ordinals live in a reserved high band (`ENGINE_WOKEN_SEQ_BASE`+) so they can
+* never collide with the kernel scope's cursor counter, which the kernel owns and advances
+* concurrently.
 */
+/** Engine-appended `woken` ordinals start here — far above any kernel cursor counter. */
+const ENGINE_WOKEN_SEQ_BASE = 1e7;
+const SUSPEND_MARK = "__graphSuspension";
+/** What a kind's executor returns to park its node on a host wake (agent-runtime#976). */
+function suspended(options = {}) {
+	const onExpire = options.onExpire ?? "wait";
+	if (onExpire !== "wait" && options.expiresInMs === void 0) throw new ValidationError(`suspended: onExpire '${onExpire}' requires expiresInMs`);
+	if (onExpire === "wait" && options.expiresInMs !== void 0) throw new ValidationError("suspended: onExpire 'wait' never expires — remove expiresInMs");
+	if (onExpire === "default" && options.default === void 0) throw new ValidationError("suspended: onExpire 'default' requires a default payload");
+	return {
+		[SUSPEND_MARK]: true,
+		onExpire,
+		...options.expiresInMs !== void 0 ? { expiresInMs: options.expiresInMs } : {},
+		...options.default !== void 0 ? { default: options.default } : {}
+	};
+}
+function isSuspensionRequest(value) {
+	return typeof value === "object" && value !== null && value[SUSPEND_MARK] === true;
+}
 /** Admission for every value crossing an edge (#971): JSON round-trip, `undefined` stripped, a
 *  non-representable value becomes a RECORD of that fact — a degraded record beats a vanished
 *  edge. */
@@ -824,12 +1055,45 @@ function admitPayload(value) {
 		return { nonCanonical: error instanceof Error ? error.message : String(error) };
 	}
 }
+/** Run a graph to its result: `createGraphRun` awaited — the one-call form for a run that needs
+*  no live host wakes. */
+async function runEngineGraph(engine, spec, task, options) {
+	return createGraphRun(engine, spec, task, options).done;
+}
 /**
-* Run a graph: host every node instance on one kernel `Scope`, resolve joins over guarded edges,
-* enforce the traversal and visit caps, and reduce the terminal settlements through the finalizer.
+* Start (or resume) a graph run and return its handle: await `done` for the result; deliver host
+* wakes through `resume`/`expire` while it runs (#976).
 */
-async function runEngineGraph(engine, spec, task, options) {
+function createGraphRun(engine, spec, task, options) {
 	const compiled = "nodes" in spec && spec.nodes instanceof Map ? spec : compileGraph(engine, spec);
+	const wakes = [];
+	let notifyWake;
+	const handleState = { finished: false };
+	const done = runGraphLoop(engine, compiled, task, options, wakes, () => notifyWake?.(), (fn) => {
+		notifyWake = fn;
+	}).finally(() => {
+		handleState.finished = true;
+	});
+	const queue = (token, payload, expire) => {
+		if (handleState.finished) return Promise.reject(new ValidationError(`graph resume: run completed; start a new run over the same journal to wake '${token}'`));
+		return new Promise((settle, fail) => {
+			wakes.push({
+				token,
+				payload,
+				expire,
+				settle,
+				fail
+			});
+			notifyWake?.();
+		});
+	};
+	return {
+		done,
+		resume: (token, payload) => queue(token, payload, false),
+		expire: (token) => queue(token, void 0, true)
+	};
+}
+async function runGraphLoop(engine, compiled, task, options, wakes, _notify, onWakeSignal) {
 	const context = "runEngineGraph";
 	for (const node of compiled.nodes.values()) {
 		const missing = node.kind.effects.filter((name) => !(name in engine.effects));
@@ -838,15 +1102,40 @@ async function runEngineGraph(engine, spec, task, options) {
 	}
 	for (const edge of compiled.edges) if (edge.spec.directive !== void 0 && options.prompts === void 0) throw new ValidationError(`${context}: edge ${edge.id} carries a directive but options.prompts is absent`);
 	const now = options.now ?? Date.now;
-	const started = now();
-	const runId = options.runId ?? `graph:${contentAddress({
-		task,
-		at: started
-	}).slice(0, 18)}`;
-	const pool = createBudgetPool(options.budget, () => now() - started);
 	const journal = options.journal ?? new InMemorySpawnJournal();
 	const blobs = options.blobs ?? new InMemoryResultBlobStore();
-	await journal.beginTree(runId, new Date(started).toISOString());
+	const runId = options.runId ?? `graph:${contentAddress({ task }).slice(0, 18)}`;
+	const prior = await journal.loadTree(runId);
+	if (prior !== void 0 && options.resume !== true) throw new ValidationError(`${context}: runId '${runId}' already exists; pass resume: true to continue it or use a new runId`);
+	const resuming = options.resume === true && prior !== void 0 && prior.length > 0;
+	let runEpochMs = now();
+	let rootBudget = options.budget;
+	if (prior === void 0) await journal.beginTree(runId, new Date(runEpochMs).toISOString());
+	if (!resuming) await journal.appendEvent(runId, {
+		kind: "spawned",
+		id: runId,
+		label: "graph-root",
+		budget: options.budget,
+		runtime: "inline",
+		seq: 0,
+		at: new Date(runEpochMs).toISOString()
+	});
+	if (resuming) {
+		const root = prior.find((ev) => ev.kind === "spawned" && ev.id === runId);
+		if (root?.kind === "spawned") {
+			runEpochMs = Date.parse(root.at);
+			rootBudget = root.budget;
+		}
+	}
+	const elapsed = () => now() - runEpochMs;
+	const pool = resuming ? createBudgetPool(rootBudget, elapsed, {
+		committed: (() => {
+			const measured = sumMeasuredSpendFromEvents(prior);
+			return addSpend(measured.childWork, measured.driverInference);
+		})(),
+		uncertainReservations: uncertainSpawnBudgets(prior),
+		...rootBudget.deadlineMs !== void 0 ? { absoluteDeadlineMs: runEpochMs + rootBudget.deadlineMs } : {}
+	}) : createBudgetPool(rootBudget, elapsed);
 	const abort = new AbortController();
 	const onOuterAbort = () => abort.abort(options.signal?.reason);
 	options.signal?.addEventListener("abort", onOuterAbort, { once: true });
@@ -861,343 +1150,670 @@ async function runEngineGraph(engine, spec, task, options) {
 		seams: {},
 		depth: 0,
 		signal: abort.signal,
-		now
-	});
-	const nodes = /* @__PURE__ */ new Map();
-	for (const id of compiled.nodes.keys()) nodes.set(id, {
-		visits: 0,
-		live: 0,
-		settles: [],
-		inputs: /* @__PURE__ */ new Map(),
-		directives: [],
-		traces: [],
-		blocked: false
-	});
-	const edges = /* @__PURE__ */ new Map();
-	for (const edge of compiled.edges) edges.set(edge.id, {
-		edge,
-		state: "pending",
-		consumedOnce: false,
-		traversals: 0,
-		payload: void 0
+		now,
+		...resuming ? { resumeFrom: {
+			settled: await replaySpawnTree(journal, blobs, runId),
+			view: materializeTreeView(prior),
+			maxSpawnOrdinal: maxSeqOf(prior, (ev) => ev.kind === "spawned"),
+			maxCursorSeq: maxSeqOf(prior, closesCursorSlot),
+			maxWaitOrdinal: maxSeqOf(prior, (ev) => ev.kind === "waiting"),
+			waits: pendingWaits(prior),
+			keys: /* @__PURE__ */ new Map(),
+			priorSpend: sumMeasuredSpendFromEvents(prior)
+		} } : {}
 	});
-	const ledger = [];
-	const exhaustedEdges = /* @__PURE__ */ new Set();
-	const settles = [];
-	const liveHandles = /* @__PURE__ */ new Map();
-	const waitingForBudget = [];
-	let ledgerSeq = 0;
-	let liveCount = 0;
-	let failure;
-	const record = (runtime, outcome, reason) => {
-		runtime.traversals += 1;
-		const spec = runtime.edge.spec;
-		const entry = {
-			edge: runtime.edge.id,
-			kind: spec.kind,
-			from: spec.from.node,
-			to: spec.to.node,
-			traversal: runtime.traversals,
-			outcome,
-			...spec.directive !== void 0 ? { directive: `${spec.directive.surface}/v${spec.directive.version}` } : {},
-			...spec.kind === "data" ? { port: runtime.edge.toPort } : {},
-			...reason !== void 0 ? { reason } : {}
+	try {
+		return await runToResult();
+	} finally {
+		options.signal?.removeEventListener("abort", onOuterAbort);
+		abort.abort("run complete");
+	}
+	async function runToResult() {
+		const state = emptyFoldState(compiled);
+		if (resuming) for (const ev of prior) applyGraphFoldEvent(state, ev, compiled);
+		let engineSeq = resuming ? maxEngineSeq(prior) + 1 : 0;
+		let engineWokenSeq = ENGINE_WOKEN_SEQ_BASE + (resuming ? prior.filter((ev) => ev.kind === "woken" && ev.seq >= 1e7).length : 0);
+		const appendAndApply = async (ev) => {
+			await journal.appendEvent(runId, ev);
+			applyGraphFoldEvent(state, ev, compiled);
 		};
-		ledger.push(entry);
-		journal.appendEvent(runId, {
-			kind: "edge",
-			id: `graph:${spec.to.node}`,
-			edge: {
+		const ledger = [];
+		const liveHandles = /* @__PURE__ */ new Map();
+		const waitingForBudget = [];
+		const outCache = /* @__PURE__ */ new Map();
+		let ledgerSeq = resuming ? prior.filter((ev) => ev.kind === "edge").length : 0;
+		let liveCount = 0;
+		let failure;
+		const recordLedger = async (edge, traversal, outcome, reason) => {
+			const spec = edge.spec;
+			const entry = {
+				edge: edge.id,
 				kind: spec.kind,
 				from: spec.from.node,
 				to: spec.to.node,
-				...entry.directive !== void 0 ? { directive: entry.directive } : {},
-				...entry.port !== void 0 ? { port: entry.port } : {}
-			},
-			traversal: entry.traversal,
-			outcome: outcome === "delivered" ? "delivered" : outcome,
-			bytes: 0,
-			...reason !== void 0 ? { reason } : {},
-			seq: ledgerSeq++,
-			at: new Date(now()).toISOString()
-		});
-	};
-	/** Enter a node: count the visit, build its Agent from consumed inputs, spawn on the Scope. */
-	const enter = (id) => {
-		if (failure) return;
-		const node = compiled.nodes.get(id);
-		const runtime = nodes.get(id);
-		if (!node || !runtime) throw new ValidationError(`${context}: unknown node ${id}`);
-		runtime.visits += 1;
-		if (runtime.visits > node.maxVisits) {
+				traversal,
+				outcome,
+				...spec.directive !== void 0 ? { directive: `${spec.directive.surface}/v${spec.directive.version}` } : {},
+				...spec.kind === "data" ? { port: edge.toPort } : {},
+				...reason !== void 0 ? { reason } : {}
+			};
+			ledger.push(entry);
+			await journal.appendEvent(runId, {
+				kind: "edge",
+				id: `graph:${spec.to.node}`,
+				edge: {
+					kind: spec.kind,
+					from: spec.from.node,
+					to: spec.to.node,
+					...entry.directive !== void 0 ? { directive: entry.directive } : {},
+					...entry.port !== void 0 ? { port: entry.port } : {}
+				},
+				traversal,
+				outcome: outcome === "delivered" ? "delivered" : outcome,
+				bytes: 0,
+				...reason !== void 0 ? { reason } : {},
+				seq: ledgerSeq++,
+				at: new Date(now()).toISOString()
+			});
+		};
+		/** Spawn one released instance from its journaled envelope — the ONE entry path, used for a
+		*  fresh release, a budget-parked retry, and a restart re-entry alike. */
+		const spawnInstance = async (instanceLabel) => {
+			if (failure) return;
+			const instance = state.instances.get(instanceLabel);
+			const node = instance === void 0 ? void 0 : compiled.nodes.get(instance.node);
+			if (!instance || !node || instance.inputRef === void 0) throw new ValidationError(`${context}: instance ${instanceLabel} has no journaled envelope`);
+			const envelope = await blobs.get(instance.inputRef);
+			if (envelope === void 0) throw new ValidationError(`${context}: envelope ${instance.inputRef} is not in the blob store`);
+			const effects = narrowEffects(node.kind.effects, engine.effects, `${context}: node ${node.id}`);
+			const agent = node.kind.run({
+				config: node.config,
+				profile: {
+					name: node.id,
+					...node.spec.profile ?? {}
+				},
+				inputs: envelope.inputs,
+				effects
+			});
+			const budget = node.spec.budget ?? options.perNode;
+			const spawned = scope.spawn(agent, envelope.task, {
+				label: instanceLabel,
+				budget
+			});
+			if (spawned.ok) {
+				liveCount += 1;
+				liveHandles.set(spawned.handle.id, instanceLabel);
+				applyGraphFoldEvent(state, {
+					kind: "spawned",
+					id: spawned.handle.id,
+					label: instanceLabel,
+					budget,
+					runtime: "inline",
+					seq: 0,
+					at: ""
+				}, compiled);
+				return;
+			}
+			if (spawned.reason === "budget-exhausted" || spawned.reason === "max-live-workers") {
+				waitingForBudget.push(instanceLabel);
+				return;
+			}
 			failure = {
-				reason: "cycle-budget-exceeded",
+				reason: "driver-failed",
 				error: {
-					name: "GraphCycleBudget",
-					message: `node ${id} entered ${runtime.visits} times; maxVisits ${node.maxVisits}`
+					name: "SpawnRefused",
+					message: `node ${node.id}: ${spawned.reason}`
 				}
 			};
-			abort.abort(`cycle-budget-exceeded: ${id}`);
-			return;
-		}
-		const inputs = {};
-		for (const [port, value] of runtime.inputs) inputs[port] = value;
-		const directives = runtime.directives.splice(0);
-		const traces = runtime.traces.splice(0);
-		const nodeTask = [
-			id === compiled.root ? task : "",
-			...directives,
-			...traces.map((trace) => `trace of ${trace.node}: ${trace.traceRef ?? "(no traceRef)"}`)
-		].filter((part) => part.length > 0).join("\n\n");
-		const effects = narrowEffects(node.kind.effects, engine.effects, `${context}: node ${id}`);
-		const agent = node.kind.run({
-			config: node.config,
-			profile: {
-				name: id,
-				...node.spec.profile ?? {}
-			},
-			inputs,
-			effects
-		});
-		const budget = node.spec.budget ?? options.perNode;
-		const spawned = scope.spawn(agent, nodeTask.length > 0 ? nodeTask : task, {
-			label: id,
-			budget
+			abort.abort(`spawn refused: ${node.id}`);
+		};
+		/** Release a node: journal the wave (join-state + envelope) then spawn. */
+		const release = async (nodeId, satisfiedBy, consumedPending) => {
+			const node = compiled.nodes.get(nodeId);
+			const folded = state.nodes.get(nodeId);
+			if (!node || !folded) return;
+			const visit = folded.visits + 1;
+			if (visit > node.maxVisits) {
+				failure = {
+					reason: "cycle-budget-exceeded",
+					error: {
+						name: "GraphCycleBudget",
+						message: `node ${nodeId} entered ${visit} times; maxVisits ${node.maxVisits}`
+					}
+				};
+				abort.abort(`cycle-budget-exceeded: ${nodeId}`);
+				return;
+			}
+			const instanceLabel = `${nodeId}#${visit}`;
+			const inputs = {};
+			const directives = [];
+			const traces = [];
+			for (const edge of satisfiedBy) {
+				const foldedEdge = state.edges.get(edge.id);
+				const spec = edge.spec;
+				if (spec.kind === "data" && foldedEdge?.state === "satisfied") {
+					let payload = foldedEdge.payloadRef === void 0 ? void 0 : outCache.get(foldedEdge.payloadRef);
+					if (payload === void 0 && foldedEdge.payloadRef !== void 0) payload = admitPayload(await blobs.get(foldedEdge.payloadRef));
+					let outcome = "delivered";
+					let reason;
+					if (spec.projection !== void 0) try {
+						payload = admitPayload(applyProjection(payload, spec.projection, `edge ${edge.id}`));
+					} catch (error) {
+						outcome = "empty";
+						reason = error instanceof Error ? error.message : String(error);
+						payload = void 0;
+					}
+					if (payload === void 0 && outcome === "delivered") outcome = "empty";
+					await recordLedger(edge, (foldedEdge?.traversals ?? 0) + 1, outcome, reason);
+					if (payload !== void 0) inputs[edge.toPort] = payload;
+				} else {
+					if (spec.directive !== void 0 && options.prompts !== void 0) directives.push(options.prompts.resolve(spec.directive).text);
+					if (spec.kind === "analyzes" && foldedEdge?.state === "satisfied") traces.push(`trace of ${spec.from.node}: ${foldedEdge.payloadRef ?? "(no traceRef)"}`);
+					await recordLedger(edge, (foldedEdge?.traversals ?? 0) + 1, "delivered");
+				}
+			}
+			const nodeTask = [
+				nodeId === compiled.root ? task : "",
+				...directives,
+				...traces
+			].filter((part) => part.length > 0).join("\n\n");
+			const envelope = {
+				task: nodeTask.length > 0 ? nodeTask : task,
+				inputs
+			};
+			const inputRef = contentAddress(envelope);
+			await blobs.put(inputRef, envelope);
+			const at = new Date(now()).toISOString();
+			await appendAndApply({
+				kind: "node-inputs-resolved",
+				id: instanceLabel,
+				node: nodeId,
+				instance: instanceLabel,
+				inputRef,
+				seq: engineSeq++,
+				at
+			});
+			await appendAndApply({
+				kind: "join-state",
+				id: instanceLabel,
+				node: nodeId,
+				rule: node.join,
+				satisfiedBy: satisfiedBy.map((edge) => edge.id),
+				consumedPending,
+				instance: instanceLabel,
+				seq: engineSeq++,
+				at
+			});
+			await spawnInstance(instanceLabel);
+		};
+		/** Join evaluation per ADC's rules over the folded edge states. */
+		const tryRelease = async (nodeId) => {
+			const node = compiled.nodes.get(nodeId);
+			const folded = state.nodes.get(nodeId);
+			if (!node || !folded || folded.blocked || failure) return;
+			const gating = node.inbound;
+			if (gating.length === 0) return;
+			const states = gating.map((edge) => ({
+				edge,
+				folded: state.edges.get(edge.id)
+			}));
+			const settled = states.filter((entry) => entry.folded && entry.folded.state !== "pending");
+			const satisfied = states.filter((entry) => entry.folded?.state === "satisfied");
+			const failed = states.filter((entry) => entry.folded?.state === "failed");
+			const allSettled = settled.length === gating.length;
+			let releaseNow = false;
+			switch (node.join) {
+				case "all":
+					releaseNow = satisfied.length === gating.length && !states.some((entry) => entry.folded?.state === "dead" || entry.folded?.state === "failed");
+					break;
+				case "any":
+					releaseNow = satisfied.length > 0;
+					if (!releaseNow && allSettled) folded.blocked = true;
+					break;
+				case "any_failed":
+					releaseNow = failed.length > 0;
+					if (!releaseNow && allSettled) folded.blocked = true;
+					break;
+				case "all_done":
+					releaseNow = allSettled;
+					break;
+			}
+			if (!releaseNow) return;
+			const consuming = node.join === "any" ? [satisfied[0]] : node.join === "any_failed" ? [failed[0]] : settled;
+			for (const entry of consuming) {
+				const cap = entry.edge.spec.maxTraversals;
+				if (cap !== void 0 && (entry.folded?.traversals ?? 0) >= cap) {
+					recordLedger(entry.edge, (entry.folded?.traversals ?? 0) + 1, "unpropagated", `traversal-cap-exhausted (max ${cap})`);
+					await appendAndApply({
+						kind: "edge-verdict",
+						id: `graph:${nodeId}`,
+						edge: entry.edge.id,
+						fired: false,
+						sourceStatus: "done",
+						capped: true,
+						seq: engineSeq++,
+						at: new Date(now()).toISOString()
+					});
+					return;
+				}
+			}
+			const consumedPending = states.filter((entry) => entry.folded?.state === "pending" && hasLiveInstance(state, liveHandles, entry.edge.spec.from.node)).map((entry) => entry.edge.id);
+			await release(nodeId, consuming.map((entry) => entry.edge), consumedPending);
+		};
+		/** Judge every outbound edge of a settle: journal the verdict, apply, then try the joins. */
+		const propagate = async (instanceLabel, settle) => {
+			const node = compiled.nodes.get(settle.node);
+			if (!node) return;
+			const succeeded = settle.status === "done" && settle.valid !== false;
+			const sourceSettles = state.nodes.get(settle.node)?.settles.length ?? 0;
+			for (const edge of node.outbound) {
+				const folded = state.edges.get(edge.id);
+				if (!folded) continue;
+				if (folded.judgedSourceSettles >= sourceSettles) continue;
+				let fired = false;
+				let inputRef;
+				if (succeeded) {
+					const guardContext = {
+						node: settle.node,
+						out: settle.out,
+						visits: state.nodes.get(settle.node)?.visits ?? 0,
+						valid: settle.valid ?? true
+					};
+					fired = edge.spec.guard === void 0 || evaluateCondition(edge.spec.guard, guardContext);
+					if (fired) inputRef = edge.spec.kind === "analyzes" ? settle.traceRef ?? void 0 : settle.outRef;
+				}
+				await appendAndApply({
+					kind: "edge-verdict",
+					id: instanceLabel,
+					edge: edge.id,
+					fired,
+					sourceStatus: settle.status === "down" ? "down" : succeeded ? "done" : "invalid",
+					...inputRef !== void 0 ? { inputRef } : {},
+					seq: engineSeq++,
+					at: new Date(now()).toISOString()
+				});
+			}
+			for (const edge of node.outbound) await tryRelease(edge.spec.to.node);
+		};
+		const mintToken = (instanceLabel) => contentAddress({
+			runId,
+			instance: instanceLabel,
+			kind: "graph-suspension"
 		});
-		if (spawned.ok) {
-			liveCount += 1;
-			runtime.live += 1;
-			liveHandles.set(spawned.handle.id, id);
-			return;
-		}
-		if (spawned.reason === "budget-exhausted" || spawned.reason === "max-live-workers") {
-			waitingForBudget.push(id);
-			runtime.visits -= 1;
-			runtime.directives.unshift(...directives);
-			runtime.traces.unshift(...traces);
-			return;
-		}
-		failure = {
-			reason: "driver-failed",
-			error: {
-				name: "SpawnRefused",
-				message: `node ${id}: ${spawned.reason}`
+		const journalSuspension = async (instanceLabel, request) => {
+			const token = mintToken(instanceLabel);
+			let defaultRef;
+			if (request.default !== void 0) {
+				const admitted = admitPayload(request.default);
+				defaultRef = contentAddress(admitted);
+				await blobs.put(defaultRef, admitted);
 			}
+			await appendAndApply({
+				kind: "waiting",
+				id: `graphwait:${token}`,
+				label: instanceLabel,
+				spec: {
+					kind: "token",
+					token,
+					onExpire: request.onExpire,
+					...request.expiresInMs !== void 0 ? { expiresAtMs: now() + request.expiresInMs } : {},
+					...defaultRef !== void 0 ? { defaultRef } : {}
+				},
+				armedAt: now(),
+				seq: engineSeq++,
+				at: new Date(now()).toISOString()
+			});
 		};
-		abort.abort(`spawn refused: ${id}`);
-	};
-	/** Join evaluation per ADC's rules; returns whether the node released. */
-	const tryRelease = (id) => {
-		const node = compiled.nodes.get(id);
-		const runtime = nodes.get(id);
-		if (!node || !runtime || runtime.blocked || failure) return false;
-		const gating = node.inbound.map((edge) => edges.get(edge.id));
-		if (gating.length === 0) return false;
-		const settled = gating.filter((edge) => edge.state !== "pending");
-		const satisfied = gating.filter((edge) => edge.state === "satisfied");
-		const failed = gating.filter((edge) => edge.state === "failed");
-		const allSettled = settled.length === gating.length;
-		let release = false;
-		switch (node.join) {
-			case "all":
-				if (gating.some((edge) => edge.state === "dead" || edge.state === "failed")) release = false;
-				else release = satisfied.length === gating.length;
-				break;
-			case "any":
-				release = satisfied.length > 0;
-				if (!release && allSettled) runtime.blocked = true;
-				break;
-			case "any_failed":
-				release = failed.length > 0;
-				if (!release && allSettled) runtime.blocked = true;
-				break;
-			case "all_done":
-				release = allSettled;
-				break;
-		}
-		if (!release) return false;
-		const consuming = node.join === "any" ? [satisfied[0]] : node.join === "any_failed" ? [failed[0]] : settled;
-		for (const runtimeEdge of consuming) {
-			const cap = runtimeEdge.edge.spec.maxTraversals;
-			if (cap !== void 0 && runtimeEdge.traversals >= cap) {
-				record(runtimeEdge, "unpropagated", `traversal-cap-exhausted (max ${cap})`);
-				runtimeEdge.traversals -= 1;
-				exhaustedEdges.add(runtimeEdge.edge.id);
-				runtime.blocked = node.join === "any" || node.join === "any_failed" ? runtime.blocked : true;
-				return false;
+		const wake = async (suspension, by, outRef) => {
+			await appendAndApply({
+				kind: "woken",
+				id: `graphwait:${suspension.token}`,
+				by,
+				...outRef !== void 0 ? { outRef } : {},
+				seq: engineWokenSeq++,
+				at: new Date(now()).toISOString()
+			});
+			const settle = state.instances.get(suspension.instance)?.settle;
+			if (settle !== void 0) {
+				const enriched = {
+					...settle,
+					...settle.outRef !== void 0 ? { out: admitPayload(await blobs.get(settle.outRef)) } : {}
+				};
+				if (enriched.outRef !== void 0 && enriched.out !== void 0) outCache.set(enriched.outRef, enriched.out);
+				await propagate(suspension.instance, enriched);
 			}
-		}
-		for (const runtimeEdge of consuming) {
-			const spec = runtimeEdge.edge.spec;
-			if (runtimeEdge.state === "satisfied" && spec.kind === "data") {
-				let payload = runtimeEdge.payload;
-				let outcome = "delivered";
-				let reason;
-				if (spec.projection !== void 0) try {
-					payload = admitPayload(applyProjection(payload, spec.projection, `edge ${runtimeEdge.edge.id}`));
+		};
+		/** Expiries are engine-clocked: judged on every loop turn and before parking (#976). */
+		const sweepExpiries = async () => {
+			for (const suspension of [...state.suspensions.values()]) {
+				if (suspension.status !== "pending") continue;
+				if (suspension.expiresAtMs === void 0 || now() < suspension.expiresAtMs) continue;
+				if (suspension.onExpire === "fail") await wake(suspension, "expired");
+				else if (suspension.onExpire === "default") await wake(suspension, "fired", suspension.defaultRef);
+			}
+		};
+		const processWakes = async () => {
+			while (wakes.length > 0) {
+				const request = wakes.shift();
+				if (!request) break;
+				try {
+					const suspension = state.suspensions.get(request.token);
+					if (!suspension) throw new ValidationError(`graph resume: unknown token '${request.token}'`);
+					if (suspension.status !== "pending") throw new ValidationError(`graph resume: token '${request.token}' already woken`);
+					if (request.expire) if (suspension.onExpire === "fail") await wake(suspension, "expired");
+					else if (suspension.onExpire === "default") await wake(suspension, "fired", suspension.defaultRef);
+					else await wake(suspension, "expired");
+					else {
+						const admitted = admitPayload(request.payload);
+						const outRef = contentAddress(admitted);
+						await blobs.put(outRef, admitted);
+						outCache.set(outRef, admitted);
+						await wake(suspension, "fired", outRef);
+					}
+					request.settle();
 				} catch (error) {
-					outcome = "empty";
-					reason = error instanceof Error ? error.message : String(error);
-					payload = void 0;
+					request.fail(error);
 				}
-				if (payload === void 0 && outcome === "delivered") outcome = "empty";
-				record(runtimeEdge, outcome, reason);
-				if (payload !== void 0) runtime.inputs.set(runtimeEdge.edge.toPort, payload);
-			} else if (runtimeEdge.state === "satisfied" || node.join === "any_failed" || node.join === "all_done") {
-				if (spec.directive !== void 0 && options.prompts !== void 0) runtime.directives.push(options.prompts.resolve(spec.directive).text);
-				if (spec.kind === "analyzes" && runtimeEdge.state === "satisfied") {
-					const trace = runtimeEdge.payload;
-					runtime.traces.push({
-						node: spec.from.node,
-						...trace?.traceRef !== void 0 ? { traceRef: trace.traceRef } : {}
-					});
+			}
+		};
+		const handleSettle = async (settled) => {
+			const instanceLabel = liveHandles.get(settled.handle.id);
+			if (instanceLabel === void 0) return;
+			liveHandles.delete(settled.handle.id);
+			liveCount -= 1;
+			const instance = state.instances.get(instanceLabel);
+			const node = instance === void 0 ? void 0 : compiled.nodes.get(instance.node);
+			if (!instance || !node) return;
+			if (settled.kind === "done" && isSuspensionRequest(settled.out)) {
+				await journalSuspension(instanceLabel, settled.out);
+				return;
+			}
+			applyGraphFoldEvent(state, {
+				kind: "settled",
+				id: settled.handle.id,
+				status: settled.kind === "done" ? "done" : "down",
+				...settled.kind === "done" ? { outRef: settled.outRef } : {},
+				...settled.kind === "down" ? { reason: settled.reason } : {},
+				...settled.kind === "done" && settled.trace?.status === "available" ? { trace: settled.trace } : {},
+				spent: {
+					iterations: 0,
+					tokens: {
+						input: 0,
+						output: 0
+					},
+					usd: 0,
+					ms: 0
+				},
+				seq: 0,
+				at: ""
+			}, compiled);
+			const folded = state.instances.get(instanceLabel)?.settle;
+			if (!folded) return;
+			let enriched = folded;
+			if (settled.kind === "done") {
+				const admitted = admitPayload(settled.out);
+				if (settled.outRef !== void 0) outCache.set(settled.outRef, admitted);
+				let valid;
+				if (node.deliverable !== void 0) try {
+					valid = await node.deliverable.check(admitted);
+				} catch {
+					valid = false;
+				}
+				enriched = {
+					...folded,
+					out: admitted,
+					...valid !== void 0 ? { valid } : {}
+				};
+				state.instances.get(instanceLabel).settle = enriched;
+				const settles = state.nodes.get(instance.node)?.settles;
+				if (settles) settles[settles.length - 1] = enriched;
+			}
+			if (instance.node === compiled.root && enriched.status === "done" && enriched.valid === true) {
+				abort.abort("root delivered");
+				return;
+			}
+			await propagate(instanceLabel, enriched);
+		};
+		const enterEntryNode = async (nodeId) => {
+			const folded = state.nodes.get(nodeId);
+			if (!folded) return;
+			const visit = folded.visits + 1;
+			const node = compiled.nodes.get(nodeId);
+			if (!node) return;
+			if (visit > node.maxVisits) return;
+			const instanceLabel = `${nodeId}#${visit}`;
+			const envelope = {
+				task,
+				inputs: {}
+			};
+			const inputRef = contentAddress(envelope);
+			await blobs.put(inputRef, envelope);
+			await appendAndApply({
+				kind: "node-inputs-resolved",
+				id: instanceLabel,
+				node: nodeId,
+				instance: instanceLabel,
+				inputRef,
+				seq: engineSeq++,
+				at: new Date(now()).toISOString()
+			});
+			await spawnInstance(instanceLabel);
+		};
+		if (!resuming) for (const id of compiled.entries) await enterEntryNode(id);
+		else {
+			for (const instance of [...state.instances.values()]) if (instance.status === "released") await spawnInstance(instance.instance);
+			else if (instance.status === "live") {
+				const node = compiled.nodes.get(instance.node);
+				const folded = state.nodes.get(instance.node);
+				if (!node || !folded) continue;
+				const visit = folded.visits + 1;
+				if (visit > node.maxVisits) {
+					failure = {
+						reason: "cycle-budget-exceeded",
+						error: {
+							name: "GraphCycleBudget",
+							message: `node ${instance.node} entered ${visit} times; maxVisits ${node.maxVisits}`
+						}
+					};
+					break;
+				}
+				const restartLabel = `${instance.node}#${visit}`;
+				instance.status = "down";
+				const at = new Date(now()).toISOString();
+				await journal.appendEvent(runId, {
+					kind: "node-inputs-resolved",
+					id: restartLabel,
+					node: instance.node,
+					instance: restartLabel,
+					inputRef: instance.inputRef,
+					seq: engineSeq++,
+					at
+				});
+				applyGraphFoldEvent(state, {
+					kind: "node-inputs-resolved",
+					id: restartLabel,
+					node: instance.node,
+					instance: restartLabel,
+					inputRef: instance.inputRef,
+					seq: 0,
+					at
+				}, compiled);
+				await spawnInstance(restartLabel);
+			}
+			for (const [nodeId, foldedNode] of state.nodes) {
+				const latest = foldedNode.settles.at(-1);
+				if (latest === void 0) continue;
+				const instanceLabel = `${nodeId}#${latest.visit}`;
+				let enriched = latest;
+				if (latest.status === "done" && latest.outRef !== void 0) {
+					const out = admitPayload(await blobs.get(latest.outRef));
+					if (isSuspensionRequest(out)) {
+						foldedNode.settles.pop();
+						const instance = state.instances.get(instanceLabel);
+						if (instance) instance.settle = void 0;
+						await journalSuspension(instanceLabel, out);
+						continue;
+					}
+					outCache.set(latest.outRef, out);
+					const nodeSpec = compiled.nodes.get(nodeId);
+					let valid;
+					if (nodeSpec?.deliverable !== void 0) try {
+						valid = await nodeSpec.deliverable.check(out);
+					} catch {
+						valid = false;
+					}
+					enriched = {
+						...latest,
+						out,
+						...valid !== void 0 ? { valid } : {}
+					};
 				}
-				record(runtimeEdge, "delivered");
+				await propagate(instanceLabel, enriched);
 			}
+			for (const id of compiled.entries) if ((state.nodes.get(id)?.visits ?? 0) === 0) await enterEntryNode(id);
+			for (const id of compiled.nodes.keys()) await tryRelease(id);
 		}
-		for (const runtimeEdge of gating) if (runtimeEdge.state !== "pending") {
-			runtimeEdge.state = "pending";
-			runtimeEdge.payload = void 0;
-		} else if ((nodes.get(runtimeEdge.edge.spec.from.node)?.live ?? 0) > 0) runtimeEdge.consumedOnce = true;
-		enter(id);
-		return true;
-	};
-	/** Settle every outbound edge of a completed source per its LATEST completion, then try joins. */
-	const propagate = (id, settle) => {
-		const node = compiled.nodes.get(id);
-		if (!node) return;
-		const succeeded = settle.status === "done" && settle.valid !== false;
-		for (const edge of node.outbound) {
-			const runtime = edges.get(edge.id);
-			if (!runtime) continue;
-			if (runtime.consumedOnce && runtime.state === "pending") {
-				runtime.consumedOnce = false;
+		const allTerminalsSettled = () => compiled.terminals.every((id) => (state.nodes.get(id)?.settles.length ?? 0) > 0);
+		let wakeSignal = Promise.resolve();
+		let armWake = () => {};
+		const rearmWakeSignal = () => {
+			wakeSignal = new Promise((fire) => {
+				armWake = fire;
+			});
+			onWakeSignal(() => armWake());
+		};
+		rearmWakeSignal();
+		let inFlightNext;
+		while (!failure) {
+			await sweepExpiries();
+			if (wakes.length > 0) {
+				await processWakes();
 				continue;
 			}
-			if (!succeeded) {
-				runtime.state = "failed";
-				runtime.payload = void 0;
-			} else {
-				const guardContext = {
-					node: id,
-					out: settle.out,
-					visits: nodes.get(id)?.visits ?? 0,
-					valid: settle.valid ?? true
-				};
-				const pass = edge.spec.guard === void 0 || evaluateCondition(edge.spec.guard, guardContext);
-				runtime.state = pass ? "satisfied" : "dead";
-				runtime.payload = pass ? edge.spec.kind === "analyzes" ? { traceRef: settle.traceRef } : settle.out : void 0;
+			if (allTerminalsSettled()) break;
+			if (liveCount === 0) {
+				const pendingSuspensions = [...state.suspensions.values()].filter((suspension) => suspension.status === "pending");
+				if (pendingSuspensions.length > 0) {
+					const nearest = Math.min(...pendingSuspensions.map((suspension) => suspension.expiresAtMs ?? Number.POSITIVE_INFINITY));
+					if (Number.isFinite(nearest) && now() >= nearest) continue;
+					if (options.waitForWakes) {
+						rearmWakeSignal();
+						await wakeSignal;
+						continue;
+					}
+					const defaulting = pendingSuspensions.filter((suspension) => suspension.onExpire === "default");
+					if (defaulting.length > 0) {
+						for (const suspension of defaulting) await wake(suspension, "fired", suspension.defaultRef);
+						continue;
+					}
+					break;
+				}
+				break;
 			}
+			inFlightNext ??= scope.next();
+			const raced = await Promise.race([inFlightNext.then((settle) => ({ settle })), wakeSignal.then(() => "wake")]);
+			if (raced === "wake") {
+				rearmWakeSignal();
+				continue;
+			}
+			inFlightNext = void 0;
+			if (raced.settle === null) break;
+			await handleSettle(raced.settle);
+			for (const parked of waitingForBudget.splice(0)) await spawnInstance(parked);
 		}
-		for (const edge of node.outbound) tryRelease(edge.spec.to.node);
-	};
-	const allTerminalsSettled = () => compiled.terminals.every((id) => (nodes.get(id)?.settles.length ?? 0) > 0);
-	for (const id of compiled.entries) enter(id);
-	while (!failure && liveCount > 0) {
-		const settled = await scope.next();
-		if (settled === null) break;
-		const nodeId = liveHandles.get(settled.handle.id);
-		if (nodeId === void 0) continue;
-		liveHandles.delete(settled.handle.id);
-		liveCount -= 1;
-		const node = compiled.nodes.get(nodeId);
-		const runtime = nodes.get(nodeId);
-		if (!node || !runtime) continue;
-		runtime.live -= 1;
-		let entry;
-		if (settled.kind === "done") {
-			const admitted = admitPayload(settled.out);
-			let valid;
-			if (node.deliverable !== void 0) try {
-				valid = await node.deliverable.check(admitted);
-			} catch (error) {
+		abort.abort("graph loop complete");
+		while (await (inFlightNext ?? scope.next()) !== null) inFlightNext = void 0;
+		const rehydrate = async (settle) => {
+			if (settle.out !== void 0 || settle.outRef === void 0) return settle;
+			const out = outCache.get(settle.outRef) ?? admitPayload(await blobs.get(settle.outRef));
+			const node = compiled.nodes.get(settle.node);
+			let valid = settle.valid;
+			if (valid === void 0 && node?.deliverable !== void 0 && settle.status === "done") try {
+				valid = await node.deliverable.check(out);
+			} catch {
 				valid = false;
 			}
-			entry = {
-				node: nodeId,
-				visit: runtime.visits,
-				status: "done",
-				...valid !== void 0 ? { valid } : {},
-				out: admitted,
-				outRef: settled.outRef
+			return {
+				...settle,
+				out,
+				...valid !== void 0 ? { valid } : {}
 			};
-			if (settled.trace?.status === "available") entry.traceRef = settled.trace.traceRef;
-		} else if (settled.kind === "down") entry = {
-			node: nodeId,
-			visit: runtime.visits,
-			status: "down",
-			reason: settled.reason
 		};
-		else continue;
-		runtime.settles.push(entry);
-		settles.push(entry);
-		if (nodeId === compiled.root && entry.status === "done" && entry.valid === true) {
-			abort.abort("root delivered");
-			break;
-		}
-		propagate(nodeId, entry);
-		if (allTerminalsSettled()) break;
-		for (const parked of waitingForBudget.splice(0)) enter(parked);
-		if (liveCount === 0 && !failure) break;
-	}
-	options.signal?.removeEventListener("abort", onOuterAbort);
-	abort.abort("run complete");
-	while (await scope.next() !== null);
-	const finalize = async () => {
-		const rows = compiled.terminals.flatMap((id) => (nodes.get(id)?.settles ?? []).map((settle) => ({
-			id: settle.node,
-			status: settle.status,
-			valid: settle.status === "done" && settle.valid !== false,
-			...settle.outRef !== void 0 ? { outRef: settle.outRef } : {}
-		})));
-		return runFinalizer(options.finalizer === void 0 || options.finalizer === "bestDelivered" ? bestDelivered : options.finalizer === "collectDelivered" ? collectDelivered : options.finalizer, {
-			settled: rows,
+		const settles = await Promise.all([...compiled.nodes.keys()].flatMap((id) => state.nodes.get(id)?.settles ?? []).map(rehydrate));
+		const terminals = settles.filter((settle) => compiled.nodes.get(settle.node)?.terminal);
+		const finish = (result) => {
+			if (result.kind === "no-winner" && state.exhaustedEdges.size > 0) throw new GraphEdgeCapError(Object.freeze([...state.exhaustedEdges]), Object.freeze([...ledger]), result);
+			return result;
+		};
+		if (failure) return finish({
+			kind: "no-winner",
+			reason: failure.reason,
+			...failure.error ? { error: failure.error } : {},
+			terminals,
+			settles,
+			ledger,
+			unreachable: []
+		});
+		const pendingTokens = [...state.suspensions.values()].filter((suspension) => suspension.status === "pending").map((suspension) => suspension.token);
+		if (pendingTokens.length > 0 && !allTerminalsSettled()) return {
+			kind: "suspended",
+			tokens: pendingTokens,
+			terminals,
+			settles,
+			ledger
+		};
+		if (options.signal?.aborted) return finish({
+			kind: "no-winner",
+			reason: "aborted",
+			terminals,
+			settles,
+			ledger,
+			unreachable: []
+		});
+		const out = terminals.some((settle) => settle.status === "done" && settle.valid !== false) ? await runFinalizer(options.finalizer === void 0 || options.finalizer === "bestDelivered" ? bestDelivered : options.finalizer === "collectDelivered" ? collectDelivered : options.finalizer, {
+			settled: terminals.map((settle) => ({
+				id: settle.node,
+				status: settle.status,
+				valid: settle.status === "done" && settle.valid !== false,
+				...settle.outRef !== void 0 ? { outRef: settle.outRef } : {}
+			})),
 			blobs,
 			tree: scope.view,
 			budget: scope.budget
+		}) : void 0;
+		if (out !== void 0) return {
+			kind: "winner",
+			out,
+			terminals,
+			settles,
+			ledger
+		};
+		const unreachable = [...compiled.nodes.keys()].filter((id) => (state.nodes.get(id)?.settles.length ?? 0) === 0);
+		return finish({
+			kind: "no-winner",
+			reason: compiled.terminals.some((id) => unreachable.includes(id)) ? unreachable.length === compiled.nodes.size ? "budget-exhausted" : "unreachable-terminal" : "all-children-down",
+			terminals,
+			settles,
+			ledger,
+			unreachable
 		});
-	};
-	const terminals = compiled.terminals.flatMap((id) => nodes.get(id)?.settles ?? []);
-	const finish = (result) => {
-		if (result.kind === "no-winner" && exhaustedEdges.size > 0) throw new GraphEdgeCapError(Object.freeze([...exhaustedEdges]), Object.freeze([...ledger]), result);
-		return result;
-	};
-	if (failure) return finish({
-		kind: "no-winner",
-		reason: failure.reason,
-		...failure.error ? { error: failure.error } : {},
-		terminals,
-		settles,
-		ledger,
-		unreachable: []
-	});
-	if (options.signal?.aborted) return finish({
-		kind: "no-winner",
-		reason: "aborted",
-		terminals,
-		settles,
-		ledger,
-		unreachable: []
-	});
-	const out = compiled.terminals.some((id) => (nodes.get(id)?.settles ?? []).some((settle) => settle.status === "done" && settle.valid !== false)) ? await finalize() : void 0;
-	if (out !== void 0) return {
-		kind: "winner",
-		out,
-		terminals,
-		settles,
-		ledger
-	};
-	const unreachable = [...compiled.nodes.keys()].filter((id) => (nodes.get(id)?.settles.length ?? 0) === 0);
-	return finish({
-		kind: "no-winner",
-		reason: compiled.terminals.some((id) => unreachable.includes(id)) ? unreachable.length === compiled.nodes.size ? "budget-exhausted" : "unreachable-terminal" : "all-children-down",
-		terminals,
-		settles,
-		ledger,
-		unreachable
-	});
+	}
+}
+function hasLiveInstance(state, liveHandles, node) {
+	for (const label of liveHandles.values()) if (state.instances.get(label)?.node === node) return true;
+	return false;
+}
+function maxEngineSeq(events) {
+	let max = -1;
+	for (const ev of events) {
+		if (ev.kind === "node-inputs-resolved" || ev.kind === "edge-verdict" || ev.kind === "join-state") {
+			if (ev.seq > max) max = ev.seq;
+		}
+		if (ev.kind === "waiting" && ev.spec.kind === "token" && ev.seq > max) max = ev.seq;
+	}
+	return max;
 }
 //#endregion
-export { CONDITION_OPS, DEFAULT_MAX_NODE_VISITS, JOIN_RULES, MAX_MAX_NODE_VISITS, admitPayload, agentKind, applyProjection, compileGraph, createGraphEngine, createRegistry, evaluateCondition, formatRegistryHandle, kindHandle, narrowEffects, parseRegistryHandle, runEngineGraph, schemaAccepts, scriptKind, subgraphKind, supervisorKind, validateCondition, validateNodeKind, validateProjection };
+export { CONDITION_OPS, DEFAULT_MAX_NODE_VISITS, ENGINE_WOKEN_SEQ_BASE, JOIN_RULES, MAX_MAX_NODE_VISITS, admitPayload, agentKind, applyGraphFoldEvent, applyProjection, compileGraph, createGraphEngine, createGraphRun, createRegistry, emptyFoldState, evaluateCondition, foldGraphJournal, formatRegistryHandle, kindHandle, narrowEffects, parseRegistryHandle, runEngineGraph, schemaAccepts, scriptKind, subgraphKind, supervisorKind, suspended, validateCondition, validateNodeKind, validateProjection };
 
 //# sourceMappingURL=graph.js.map