@tangle-network/agent-runtime 0.165.0 → 0.167.0

package/dist/graph.js

@@ -1,9 +1,9 @@
 import { m as ValidationError } from "./errors-CDZ8XsVj.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";
+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-B-mmmiOU.js";
+import { i as workerFromBackend, s as supervisorAgent } from "./supervise-rEE46ruH.js";
+import { t as GraphEdgeCapError } from "./graph-ZDMygFIo.js";
 //#region src/runtime/graph/condition.ts
 /**
 * The ONE predicate tree: every guard in a graph — an edge `guard`, a filter projection's
@@ -327,7 +327,7 @@ function validateEngineGraphSpec(spec, context = "compileGraph") {
 			validateProjection(edge.projection, `${who} projection`);
 		}
 		if (edge.maxTraversals !== void 0) {
-			if (!Number.isSafeInteger(edge.maxTraversals) || edge.maxTraversals < 1) throw new ValidationError(`${who}: maxTraversals must be a positive integer`);
+			if (!Number.isSafeInteger(edge.maxTraversals) || edge.maxTraversals < 0) throw new ValidationError(`${who}: maxTraversals must be a non-negative integer`);
 		}
 		if (edge.kind === "data" && edge.directive !== void 0) throw new ValidationError(`${who}: a data edge carries a port binding, never a directive`);
 	}
@@ -346,6 +346,12 @@ function validateEngineGraphSpec(spec, context = "compileGraph") {
 */
 /** A node's ports: its kind's declared outputs plus the two implicit ones every node has. */
 const IMPLICIT_OUTPUT_PORTS = ["out", "trace"];
+/** `delegates` is the one MODEL-fired edge kind (agent-runtime#971): its payload is a directive and
+*  its target is spawned by the source supervisor through the coordination protocol, not released
+*  by the scheduler. `data` and `analyzes` are engine-fired. */
+function isEngineFired(edge) {
+	return edge.spec.kind !== "delegates";
+}
 /** A node's ports: node-level declarations merged OVER its kind's (the node wins on a name). */
 function nodePorts(kind, node) {
 	const merge = (declared, own) => {
@@ -457,17 +463,23 @@ function compileGraph(engine, spec, context = "compileGraph") {
 		if (dupes.has(edge.id)) throw new ValidationError(`${context}: duplicate edge id ${edge.id}`);
 		dupes.add(edge.id);
 	}
-	const entries = spec.nodes.filter((node) => (inbound.get(node.id) ?? []).length === 0);
-	if (entries.length === 0) throw new ValidationError(`${context}: no entry node — every node has an inbound edge`);
-	const root = spec.root ?? (entries.length === 1 ? entries[0]?.id ?? "" : (() => {
-		throw new ValidationError(`${context}: ${entries.length} entry nodes (${entries.map((node) => node.id).join(", ")}) — name spec.root`);
+	const engineInbound = (id) => (inbound.get(id) ?? []).filter(isEngineFired);
+	const engineOutbound = (id) => (outbound.get(id) ?? []).filter(isEngineFired);
+	const unfed = spec.nodes.filter((node) => (inbound.get(node.id) ?? []).length === 0);
+	if (unfed.length === 0 && spec.root === void 0) throw new ValidationError(`${context}: no entry node — every node has an inbound edge`);
+	const root = spec.root ?? (unfed.length === 1 ? unfed[0]?.id ?? "" : (() => {
+		throw new ValidationError(`${context}: ${unfed.length} entry nodes (${unfed.map((node) => node.id).join(", ")}) — name spec.root`);
 	})());
+	const declaredOut = new Set(spec.nodes.filter((node) => node.entry === false).map((node) => node.id));
+	const entries = [root, ...unfed.map((node) => node.id).filter((id) => id !== root)].filter((id) => !declaredOut.has(id));
+	if (entries.length === 0) throw new ValidationError(`${context}: every entry node declares entry: false — nothing starts`);
 	const nodes = /* @__PURE__ */ new Map();
 	const terminals = [];
 	for (const node of spec.nodes) {
 		const kind = kinds.get(node.id);
 		if (!kind) throw new ValidationError(`${context}: unresolved node ${node.id}`);
-		const terminal = node.terminal ?? (outbound.get(node.id) ?? []).length === 0;
+		const modelFired = (inbound.get(node.id) ?? []).some((edge) => !isEngineFired(edge));
+		const terminal = node.terminal ?? (!modelFired && engineOutbound(node.id).length === 0);
 		const deliverable = node.deliverable ?? (node.id === root ? spec.deliverable : void 0);
 		if (terminal) terminals.push(node.id);
 		nodes.set(node.id, {
@@ -480,8 +492,9 @@ function compileGraph(engine, spec, context = "compileGraph") {
 			pure: node.flags?.pure ?? false,
 			terminal,
 			...deliverable === void 0 ? {} : { deliverable },
-			inbound: inbound.get(node.id) ?? [],
+			inbound: engineInbound(node.id),
 			outbound: outbound.get(node.id) ?? [],
+			modelFired,
 			spec: node
 		});
 	}
@@ -489,7 +502,7 @@ function compileGraph(engine, spec, context = "compileGraph") {
 	return {
 		nodes,
 		edges: compiledEdges,
-		entries: entries.map((node) => node.id),
+		entries,
 		terminals,
 		root,
 		maxNodeVisits: spec.maxNodeVisits ?? 25
@@ -794,6 +807,63 @@ function foldGraphJournal(events, compiled) {
 	return state;
 }
 //#endregion
+//#region src/runtime/graph/join.ts
+const NOTHING = {
+	release: false,
+	consuming: [],
+	blocked: false
+};
+/** Decide whether a node's gating edges release it, and which of them the release consumes. */
+function decideJoin(rule, gating) {
+	if (gating.length === 0) return NOTHING;
+	const settled = gating.filter((entry) => entry.folded && entry.folded.state !== "pending");
+	const satisfied = gating.filter((entry) => entry.folded?.state === "satisfied");
+	const failed = gating.filter((entry) => entry.folded?.state === "failed");
+	const allSettled = settled.length === gating.length;
+	switch (rule) {
+		case "all": {
+			const release = !gating.some((entry) => entry.folded?.state === "dead" || entry.folded?.state === "failed") && satisfied.length === gating.length;
+			return {
+				release,
+				consuming: release ? settled : [],
+				blocked: false
+			};
+		}
+		case "any": {
+			const first = satisfied[0];
+			if (first === void 0) return {
+				release: false,
+				consuming: [],
+				blocked: allSettled
+			};
+			return {
+				release: true,
+				consuming: [first],
+				blocked: false
+			};
+		}
+		case "any_failed": {
+			const first = failed[0];
+			if (first === void 0) return {
+				release: false,
+				consuming: [],
+				blocked: allSettled
+			};
+			return {
+				release: true,
+				consuming: [first],
+				blocked: false
+			};
+		}
+		case "all_done": return {
+			release: allSettled,
+			consuming: allSettled ? settled : [],
+			blocked: false
+		};
+		default: return NOTHING;
+	}
+}
+//#endregion
 //#region src/runtime/graph/kinds.ts
 /**
 * One profile, one run: the kernel's leaf, exactly as `supervise()` derives it from `backend`.
@@ -967,12 +1037,7 @@ function scriptAgent(profile, config, inputs, kind) {
 		executorSpec: spec
 	};
 }
-/**
-* A node carrying its own graph: the constraint on what a supervisor may spawn at depth>1. Its
-* executor is a nested engine run; that needs the scheduler (#980), so until then this kind is
-* registered and REFUSES at run time by name rather than being absent — a graph that names it
-* compiles, and the refusal says exactly what is missing.
-*/
+/** A node carrying its own graph: it runs as a full engine run on the host's kinds and effects. */
 function subgraphKind() {
 	return {
 		id: "subgraph",
@@ -981,7 +1046,11 @@ function subgraphKind() {
 		validateConfig: (raw, context) => {
 			const config = asRecord(raw, `${context}: subgraph config`);
 			if (config.graph === void 0) throw new ValidationError(`${context}: subgraph config.graph is required`);
-			return { graph: config.graph };
+			return {
+				graph: config.graph,
+				...config.budget === void 0 ? {} : { budget: config.budget },
+				...config.perNode === void 0 ? {} : { perNode: config.perNode }
+			};
 		},
 		configSchema: {
 			type: "object",
@@ -993,8 +1062,55 @@ function subgraphKind() {
 		effects: [],
 		onCrash: "restart",
 		budget: "metered",
-		run: ({ profile }) => {
-			throw new ValidationError(`subgraph kind: node ${JSON.stringify(profile.name)} cannot run yet — the scheduler that executes a nested graph lands in agent-runtime#980`);
+		run: ({ config, profile, host }) => {
+			const name = profile.name ?? "subgraph";
+			if (!host) throw new ValidationError(`subgraph kind: node ${JSON.stringify(name)} needs its hosting engine; run it through the scheduler, which supplies one`);
+			let artifact;
+			return {
+				name,
+				act: () => Promise.reject(new ValidationError("subgraph: act() is not the execution path")),
+				executorSpec: {
+					profile,
+					harness: null,
+					executor: {
+						runtime: "inline",
+						async execute(_task, signal) {
+							const inner = await host.runNested(config.graph, name, {
+								budget: config.budget ?? {
+									maxIterations: 1,
+									maxTokens: 0
+								},
+								...config.perNode === void 0 ? {} : { perNode: config.perNode },
+								runId: `${name}:subgraph`,
+								signal
+							});
+							const out = {
+								kind: inner.kind,
+								out: inner.out
+							};
+							artifact = {
+								outRef: contentAddress(out),
+								out,
+								spent: {
+									iterations: 1,
+									tokens: {
+										input: 0,
+										output: 0
+									},
+									usd: 0,
+									ms: 0
+								}
+							};
+							return artifact;
+						},
+						teardown: () => Promise.resolve({ destroyed: true }),
+						resultArtifact: () => {
+							if (!artifact) throw new ValidationError(`subgraph: resultArtifact() read before execute()`);
+							return artifact;
+						}
+					}
+				}
+			};
 		}
 	};
 }
@@ -1003,30 +1119,337 @@ function asRecord(value, context) {
 	return value;
 }
 //#endregion
-//#region src/runtime/graph/scheduler.ts
+//#region src/runtime/graph/ledger.ts
+/** Open a ledger for one run; its ordinals continue past whatever a prior process recorded. */
+function createEdgeLedger(args) {
+	const entries = [];
+	let seq = args.startSeq;
+	return {
+		entries,
+		async record(edge, traversal, outcome, reason) {
+			const spec = edge.spec;
+			const entry = {
+				edge: edge.id,
+				kind: spec.kind,
+				from: spec.from.node,
+				to: spec.to.node,
+				traversal,
+				outcome,
+				...spec.directive !== void 0 ? { directive: `${spec.directive.surface}/v${spec.directive.version}` } : {},
+				...spec.kind === "data" ? { port: edge.toPort } : {},
+				...reason !== void 0 ? { reason } : {}
+			};
+			entries.push(entry);
+			await args.journal.appendEvent(args.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,
+				bytes: 0,
+				...reason !== void 0 ? { reason } : {},
+				seq: seq++,
+				at: new Date(args.now()).toISOString()
+			});
+		}
+	};
+}
+//#endregion
+//#region src/runtime/graph/preset-run-graph.ts
 /**
-* 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.
+* `runGraph` as an engine graph (agent-runtime#982, #975) — a COMPILER, not a second runtime.
 *
-* 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`.
+* `graphFromRunGraph` lowers today's `AgentGraph` into the engine's vocabulary: one supervisor
+* root carrying the graph, one pinned `agent` node per worker, the authored `delegates`/`analyzes`
+* edges. That gives a `runGraph` consumer a first-class engine graph it can inspect, diff, and use
+* as the starting point for authoring one natively — the migration path #975 asked for.
 *
-* 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.
+* WHAT THIS DELIBERATELY DOES NOT DO: run it. `runGraph` executes through `superviseAgentGraph`,
+* exactly as it always has. An earlier version of this module wrapped that call in a one-node
+* engine run, which read as "runGraph runs on the engine" while changing nothing about execution
+* and costing a second journal tree, a second budget pool and a second `Scope`. A wrapper that
+* moves no behaviour is a second source of truth, so it is gone: the graph a consumer runs and the
+* graph they can inspect are produced from the same `AgentGraph`, and only one of them executes.
+*
+* The engine EXECUTES a graph a consumer authors directly (`runEngineGraph`), where nodes are
+* scheduled over `data` edges, guards decide traversal, and the fold makes it restartable.
+*/
+/** The kind id the root node carries: a supervisor holding the whole `AgentGraph`. */
+const RUN_GRAPH_ROOT_KIND = "supervisor/v1";
+/**
+* Compile an `AgentGraph` into the engine graph that describes it. Pure: nothing runs, nothing is
+* registered, no executor is built. A `delegates` edge is MODEL-fired (#971) — its target is
+* spawned by the supervisor through the coordination protocol — so every worker node is marked
+* `entry: false`, which is exactly what the engine's scheduler would honour if this graph were
+* handed to it.
+*/
+function graphFromRunGraph(graph, options) {
+	const root = graph.nodes[0];
+	if (root === void 0) throw new ValidationError("graphFromRunGraph: a graph needs a root node");
+	return {
+		nodes: graph.nodes.map((node, index) => index === 0 ? {
+			id: node.id,
+			kind: RUN_GRAPH_ROOT_KIND,
+			config: {
+				perWorker: options.perWorker ?? graph.budget,
+				...options.maxLiveWorkers === void 0 ? {} : { maxLiveWorkers: options.maxLiveWorkers }
+			},
+			profile: node.profile,
+			budget: graph.budget,
+			terminal: true,
+			deliverable: graph.deliverable
+		} : {
+			id: node.id,
+			kind: "agent/v1",
+			profile: node.profile,
+			entry: false,
+			terminal: false,
+			budget: options.perWorker ?? graph.budget
+		}),
+		edges: graph.edges.flatMap((edge) => edge.kind === "delegates" ? [{
+			kind: "delegates",
+			from: { node: edge.from },
+			to: { node: edge.to },
+			directive: edge.directive,
+			...edge.maxTraversals !== void 0 ? { maxTraversals: edge.maxTraversals } : {}
+		}] : edge.over.map((source) => ({
+			kind: "analyzes",
+			from: {
+				node: source,
+				port: "trace"
+			},
+			to: { node: edge.to },
+			directive: edge.directive,
+			...edge.maxTraversals !== void 0 ? { maxTraversals: edge.maxTraversals } : {}
+		}))),
+		root: root.id,
+		deliverable: graph.deliverable
+	};
+}
+//#endregion
+//#region src/runtime/graph/admit.ts
+/**
+* Edge payload admission (agent-runtime#971): every value crossing an edge is JSON round-tripped,
+* `undefined` stripped to absence, and a non-representable value (a cycle, a BigInt, a function)
+* becomes a RECORD of that fact. This is the kernel's existing findings-guard rule, and it is what
+* makes `inputRef` stable and `onCrash: 'restart'` well defined — a degraded record beats a
+* vanished edge.
+*/
+function admitPayload(value) {
+	if (value === void 0) return void 0;
+	try {
+		const text = JSON.stringify(value);
+		if (text === void 0) return { nonCanonical: `payload of type ${typeof value}` };
+		return JSON.parse(text);
+	} catch (error) {
+		return { nonCanonical: error instanceof Error ? error.message : String(error) };
+	}
+}
+//#endregion
+//#region src/runtime/graph/result.ts
+/**
+* Turning a finished run into its result: rehydrate each settle's output, reduce the terminals
+* through the kernel's finalizer seam, and name the honest cause when nothing delivered
+* (agent-runtime#973). Separate from the loop so "what happened" is readable without reading
+* "what ran".
+*/
+function resolveFinalizer(choice) {
+	if (choice === void 0 || choice === "bestDelivered") return bestDelivered;
+	if (choice === "collectDelivered") return collectDelivered;
+	return choice;
+}
+/** Every node settlement with its output rehydrated and its completion check applied. */
+async function materializeSettles(compiled, state, blobs, outCache) {
+	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;
+		}
+		return {
+			...settle,
+			out,
+			...valid !== void 0 ? { valid } : {}
+		};
+	};
+	return Promise.all([...compiled.nodes.keys()].flatMap((id) => state.nodes.get(id)?.settles ?? []).map(rehydrate));
+}
+/** Turn a finished run into its result: rehydrate, reduce the terminals, classify a no-winner. */
+async function assembleGraphResult(args) {
+	const settles = await materializeSettles(args.compiled, args.state, args.blobs, args.outCache);
+	const terminals = settles.filter((settle) => args.compiled.nodes.get(settle.node)?.terminal);
+	const ledger = args.ledger;
+	const finish = (result) => {
+		if (result.kind === "no-winner" && args.state.exhaustedEdges.size > 0) throw new GraphEdgeCapError(Object.freeze([...args.state.exhaustedEdges]), Object.freeze([...ledger]), result);
+		return result;
+	};
+	if (args.failure) return finish({
+		kind: "no-winner",
+		reason: args.failure.reason,
+		...args.failure.error ? { error: args.failure.error } : {},
+		terminals,
+		settles,
+		ledger,
+		unreachable: []
+	});
+	const allTerminalsSettled = args.compiled.terminals.every((id) => (args.state.nodes.get(id)?.settles.length ?? 0) > 0);
+	const pendingTokens = [...args.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 (args.aborted) return finish({
+		kind: "no-winner",
+		reason: "aborted",
+		terminals,
+		settles,
+		ledger,
+		unreachable: []
+	});
+	const out = terminals.filter((settle) => settle.status === "done" && settle.valid !== false).length === 0 ? void 0 : await runFinalizer(resolveFinalizer(args.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: args.blobs,
+		tree: args.scope.view,
+		budget: args.scope.budget
+	});
+	if (out !== void 0) return {
+		kind: "winner",
+		out,
+		terminals,
+		settles,
+		ledger
+	};
+	const unreachable = [...args.compiled.nodes.keys()].filter((id) => (args.state.nodes.get(id)?.settles.length ?? 0) === 0);
+	return finish({
+		kind: "no-winner",
+		reason: args.compiled.terminals.some((id) => unreachable.includes(id)) ? unreachable.length === args.compiled.nodes.size ? "budget-exhausted" : "unreachable-terminal" : "all-children-down",
+		terminals,
+		settles,
+		ledger,
+		unreachable
+	});
+}
+//#endregion
+//#region src/runtime/graph/run-context.ts
+/**
+* Opening a graph run: begin or resume the journaled tree, rebuild the pool and the kernel `Scope`
+* on the SAME recipe the kernel supervisor uses for its own resume, and fold the prior journal
+* into scheduler state. Extracted so the restart contract is one readable unit rather than a
+* preamble inside the loop.
 */
-/** Engine-appended `woken` ordinals start here — far above any kernel cursor counter. */
+/** Engine-appended `woken` ordinals start here — far above any kernel cursor counter, so the two
+*  counters can advance independently without ever colliding. */
 const ENGINE_WOKEN_SEQ_BASE = 1e7;
+/** Begin or resume a run's journaled tree, pool, scope and folded state. */
+async function openGraphRun(args) {
+	const journal = args.journal ?? new InMemorySpawnJournal();
+	const blobs = args.blobs ?? new InMemoryResultBlobStore();
+	const loaded = await journal.loadTree(args.runId);
+	if (loaded !== void 0 && args.resume !== true) throw new ValidationError(`runEngineGraph: runId '${args.runId}' already exists; pass resume: true to continue it or use a new runId`);
+	const prior = loaded ?? [];
+	const resuming = args.resume === true && prior.length > 0;
+	let runEpochMs = args.now();
+	let rootBudget = args.budget;
+	if (loaded === void 0) await journal.beginTree(args.runId, new Date(runEpochMs).toISOString());
+	if (resuming) {
+		const root = prior.find((ev) => ev.kind === "spawned" && ev.id === args.runId);
+		if (root?.kind === "spawned") {
+			runEpochMs = Date.parse(root.at);
+			rootBudget = root.budget;
+		}
+	} else await journal.appendEvent(args.runId, {
+		kind: "spawned",
+		id: args.runId,
+		label: "graph-root",
+		budget: args.budget,
+		runtime: "inline",
+		seq: 0,
+		at: new Date(runEpochMs).toISOString()
+	});
+	const elapsed = () => args.now() - runEpochMs;
+	const measured = resuming ? sumMeasuredSpendFromEvents([...prior]) : void 0;
+	const pool = createBudgetPool(rootBudget, elapsed, measured === void 0 ? void 0 : {
+		committed: addSpend(measured.childWork, measured.driverInference),
+		uncertainReservations: uncertainSpawnBudgets([...prior]),
+		...rootBudget.deadlineMs !== void 0 ? { absoluteDeadlineMs: runEpochMs + rootBudget.deadlineMs } : {}
+	});
+	const abort = new AbortController();
+	if (args.signal !== void 0) {
+		const forward = () => abort.abort(args.signal?.reason);
+		args.signal.addEventListener("abort", forward, { once: true });
+		args.onAbort(() => args.signal?.removeEventListener("abort", forward));
+		if (args.signal.aborted) abort.abort(args.signal.reason);
+	}
+	const scope = createScope({
+		parentId: args.runId,
+		root: args.runId,
+		pool,
+		journal,
+		blobs,
+		executors: createExecutorRegistry(),
+		seams: {},
+		depth: 0,
+		signal: abort.signal,
+		now: args.now,
+		...resuming ? { resumeFrom: {
+			settled: await replaySpawnTree(journal, blobs, args.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 state = emptyFoldState(args.compiled);
+	if (resuming) for (const ev of prior) applyGraphFoldEvent(state, ev, args.compiled);
+	return {
+		runId: args.runId,
+		journal,
+		blobs,
+		scope,
+		abort,
+		state,
+		resuming,
+		prior,
+		engineSeq: resuming ? maxEngineSeq(prior) + 1 : 0,
+		engineWokenSeq: ENGINE_WOKEN_SEQ_BASE + (resuming ? prior.filter((ev) => ev.kind === "woken" && ev.seq >= 1e7).length : 0),
+		ledgerSeq: prior.filter((ev) => ev.kind === "edge").length
+	};
+}
+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" || ev.kind === "waiting" && ev.spec.kind === "token") && ev.seq > max) max = ev.seq;
+	return max;
+}
+//#endregion
+//#region src/runtime/graph/suspension.ts
+/**
+* Suspensions (agent-runtime#976): a node parks on a host wake as the kernel's `waiting`/`woken`
+* pair. The engine owns the transition table; a host owns only how the wake arrives.
+*/
 const SUSPEND_MARK = "__graphSuspension";
-/** What a kind's executor returns to park its node on a host wake (agent-runtime#976). */
+/** Build a suspension request. `wait` never expires; `fail` settles the node down at its deadline;
+*  `default` resolves with the given payload. */
 function suspended(options = {}) {
 	const onExpire = options.onExpire ?? "wait";
 	if (onExpire !== "wait" && options.expiresInMs === void 0) throw new ValidationError(`suspended: onExpire '${onExpire}' requires expiresInMs`);
@@ -1039,24 +1462,48 @@ function suspended(options = {}) {
 		...options.default !== void 0 ? { default: options.default } : {}
 	};
 }
+/** Whether a node's output is a park request rather than its result. */
 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. */
-function admitPayload(value) {
-	if (value === void 0) return void 0;
-	try {
-		const text = JSON.stringify(value);
-		if (text === void 0) return { nonCanonical: `payload of type ${typeof value}` };
-		return JSON.parse(text);
-	} catch (error) {
-		return { nonCanonical: error instanceof Error ? error.message : String(error) };
-	}
+/** Content-addressed over the run identity, so a restart recomputes it and needs no token table. */
+function mintSuspensionToken(runId, instance) {
+	return contentAddress({
+		runId,
+		instance,
+		kind: "graph-suspension"
+	});
+}
+/** The journal id one suspension's `waiting`/`woken` pair shares. */
+function suspensionNodeId(token) {
+	return `graphwait:${token}`;
 }
-/** Run a graph to its result: `createGraphRun` awaited — the one-call form for a run that needs
-*  no live host wakes. */
+/** The token inside a suspension node id, or `undefined` for any other id. */
+function tokenFromSuspensionNodeId(id) {
+	return id.startsWith("graphwait:") ? id.slice(10) : void 0;
+}
+//#endregion
+//#region src/runtime/graph/scheduler.ts
+/**
+* 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; the scheduler owns only what a graph adds — releasing nodes over
+* guarded edges, delivering payloads and directives, the two cycle caps, and suspensions.
+*
+* DURABILITY — fold, never checkpoint. Every decision is journaled BEFORE its effect is visible
+* (blob-then-journal where a ref is minted), then applied to live state through the SAME reducer
+* (`applyGraphFoldEvent`) a restart replays the journal through. Kill the process at any journal
+* boundary and a restart re-enters the exact state: settled nodes restore from `outRef` and never
+* re-execute; 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`.
+*
+* The parts this file does NOT own, so it stays a loop and not a god object: payload admission
+* (`admit.ts`), the edge ledger (`ledger.ts`), the join rule (`join.ts`), suspension vocabulary
+* (`suspension.ts`), the journal/pool/scope bootstrap (`run-context.ts`), and result assembly
+* (`result.ts`).
+*/
+/** 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;
 }
@@ -1065,17 +1512,17 @@ async function runEngineGraph(engine, spec, task, options) {
 * wakes through `resume`/`expire` while it runs (#976).
 */
 function createGraphRun(engine, spec, task, options) {
-	const compiled = "nodes" in spec && spec.nodes instanceof Map ? spec : compileGraph(engine, spec);
+	const compiled = asCompiled(engine, spec);
 	const wakes = [];
-	let notifyWake;
-	const handleState = { finished: false };
-	const done = runGraphLoop(engine, compiled, task, options, wakes, () => notifyWake?.(), (fn) => {
-		notifyWake = fn;
+	let signalWake = () => {};
+	let finished = false;
+	const done = runGraphLoop(engine, compiled, task, options, wakes, (fn) => {
+		signalWake = fn;
 	}).finally(() => {
-		handleState.finished = true;
+		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}'`));
+		if (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,
@@ -1084,7 +1531,7 @@ function createGraphRun(engine, spec, task, options) {
 				settle,
 				fail
 			});
-			notifyWake?.();
+			signalWake();
 		});
 	};
 	return {
@@ -1093,727 +1540,534 @@ function createGraphRun(engine, spec, task, options) {
 		expire: (token) => queue(token, void 0, true)
 	};
 }
-async function runGraphLoop(engine, compiled, task, options, wakes, _notify, onWakeSignal) {
+function asCompiled(engine, spec) {
+	return "nodes" in spec && spec.nodes instanceof Map ? spec : compileGraph(engine, spec);
+}
+/** Everything a run must be able to satisfy before it spends anything. */
+function assertRunnable(engine, compiled, options) {
 	const context = "runEngineGraph";
 	for (const node of compiled.nodes.values()) {
 		const missing = node.kind.effects.filter((name) => !(name in engine.effects));
 		if (missing.length > 0) throw new ValidationError(`${context}: node ${node.id} needs effect(s) ${missing.join(", ")} the host did not provide`);
 		if (node.spec.budget === void 0 && options.perNode === void 0) throw new ValidationError(`${context}: node ${node.id} declares no budget and options.perNode is absent — the engine invents no split`);
 	}
-	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`);
+	for (const edge of compiled.edges) if (isEngineFired(edge) && edge.spec.directive !== void 0 && options.prompts === void 0) throw new ValidationError(`${context}: edge ${edge.id} carries a directive but options.prompts is absent`);
+}
+async function runGraphLoop(engine, compiled, task, options, wakes, onWakeSignal) {
+	assertRunnable(engine, compiled, options);
 	const now = options.now ?? Date.now;
-	const journal = options.journal ?? new InMemorySpawnJournal();
-	const blobs = options.blobs ?? new InMemoryResultBlobStore();
 	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",
+	let detachOuterAbort = () => {};
+	const context = await openGraphRun({
+		compiled,
+		runId,
 		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;
+		...options.journal !== void 0 ? { journal: options.journal } : {},
+		...options.blobs !== void 0 ? { blobs: options.blobs } : {},
+		now,
+		...options.resume !== void 0 ? { resume: options.resume } : {},
+		...options.signal !== void 0 ? { signal: options.signal } : {},
+		onAbort: (detach) => {
+			detachOuterAbort = detach;
 		}
-	}
-	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 });
-	if (options.signal?.aborted) abort.abort(options.signal.reason);
-	const scope = createScope({
-		parentId: runId,
-		root: runId,
-		pool,
+	});
+	const { abort, blobs, journal, scope, state } = context;
+	const ledger = createEdgeLedger({
 		journal,
-		blobs,
-		executors: createExecutorRegistry(),
-		seams: {},
-		depth: 0,
-		signal: abort.signal,
+		runId,
 		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)
-		} } : {}
+		startSeq: context.ledgerSeq
 	});
-	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);
-		};
-		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,
-				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: "driver-failed",
-				error: {
-					name: "SpawnRefused",
-					message: `node ${node.id}: ${spawned.reason}`
-				}
-			};
-			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");
-				}
+	let engineSeq = context.engineSeq;
+	let wokenSeq = context.engineWokenSeq;
+	const liveHandles = /* @__PURE__ */ new Map();
+	const waitingForBudget = [];
+	const outCache = /* @__PURE__ */ new Map();
+	let liveCount = 0;
+	let failure;
+	/** Journal one engine event, then apply it through the reducer a restart will replay. */
+	const emit = async (ev) => {
+		await journal.appendEvent(runId, ev);
+		applyGraphFoldEvent(state, ev, compiled);
+	};
+	const stamp = () => new Date(now()).toISOString();
+	const fail = (reason, name, message) => {
+		failure = {
+			reason,
+			error: {
+				name,
+				message
 			}
-			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;
+		abort.abort(`${reason}: ${message}`);
+	};
+	/** The ONE entry path: spawn a released instance from its journaled envelope. Used by a fresh
+	*  release, a budget-parked retry, and a restart re-entry alike. */
+	const spawnInstance = async (label) => {
+		if (failure) return;
+		const instance = state.instances.get(label);
+		const node = instance === void 0 ? void 0 : compiled.nodes.get(instance.node);
+		if (!instance || !node || instance.inputRef === void 0) throw new ValidationError(`runEngineGraph: instance ${label} has no journaled envelope`);
+		const envelope = await blobs.get(instance.inputRef);
+		if (envelope === void 0) throw new ValidationError(`runEngineGraph: envelope ${instance.inputRef} is not in the blob store`);
+		const agent = node.kind.run({
+			config: node.config,
+			profile: {
+				name: node.id,
+				...node.spec.profile ?? {}
+			},
+			inputs: envelope.inputs,
+			effects: narrowEffects(node.kind.effects, engine.effects, `runEngineGraph: node ${node.id}`),
+			host: { runNested: (inner, task, opts) => runEngineGraph(engine, inner, task, {
+				budget: opts.budget,
+				...opts.perNode === void 0 ? {} : { perNode: opts.perNode },
+				journal,
+				blobs,
+				...options.prompts === void 0 ? {} : { prompts: options.prompts },
+				runId: `${runId}:${opts.runId}`,
+				...opts.signal === void 0 ? {} : { signal: opts.signal },
+				now
+			}).then((result) => ({
+				kind: result.kind,
+				...result.kind === "winner" ? { out: result.out } : {}
+			})) }
+		});
+		const budget = node.spec.budget ?? options.perNode;
+		const spawned = scope.spawn(agent, envelope.task, {
+			label,
+			budget
+		});
+		if (spawned.ok) {
+			liveCount += 1;
+			liveHandles.set(spawned.handle.id, label);
+			applyGraphFoldEvent(state, {
+				kind: "spawned",
+				id: spawned.handle.id,
+				label,
+				budget,
+				runtime: "inline",
+				seq: 0,
+				at: ""
+			}, compiled);
+			return;
+		}
+		if (spawned.reason === "budget-exhausted" || spawned.reason === "max-live-workers") {
+			waitingForBudget.push(label);
+			return;
+		}
+		fail("driver-failed", "SpawnRefused", `node ${node.id}: ${spawned.reason}`);
+	};
+	/** Pin an instance's envelope (inputs + task) by content address; answers the instance label. */
+	const openInstance = async (nodeId, visit, envelope) => {
+		const label = `${nodeId}#${visit}`;
+		const inputRef = contentAddress(envelope);
+		await blobs.put(inputRef, envelope);
+		await emit({
+			kind: "node-inputs-resolved",
+			id: label,
+			node: nodeId,
+			instance: label,
+			inputRef,
+			seq: engineSeq++,
+			at: stamp()
+		});
+		return label;
+	};
+	const enterEntryNode = async (nodeId) => {
+		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) return;
+		await spawnInstance(await openInstance(nodeId, visit, {
+			task,
+			inputs: {}
+		}));
+	};
+	/** Build the released instance's envelope from its wave: data payloads projected and admitted,
+	*  directives resolved, trace refs lined up — every consumption ledgered as it is taken. */
+	const consumeWave = async (nodeId, consuming) => {
+		const inputs = {};
+		const directives = [];
+		const traces = [];
+		for (const { edge, folded } of consuming) {
+			const spec = edge.spec;
+			const traversal = (folded?.traversals ?? 0) + 1;
+			if (spec.kind === "data" && folded?.state === "satisfied") {
+				let payload = folded.payloadRef === void 0 ? void 0 : outCache.get(folded.payloadRef) ?? admitPayload(await blobs.get(folded.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 = "empty";
+				await ledger.record(edge, traversal, outcome, reason);
+				if (payload !== void 0) inputs[edge.toPort] = payload;
+				continue;
 			}
-			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);
+			if (spec.directive !== void 0 && options.prompts !== void 0) directives.push(options.prompts.resolve(spec.directive).text);
+			if (spec.kind === "analyzes" && folded?.state === "satisfied") traces.push(`trace of ${spec.from.node}: ${folded.payloadRef ?? "(no traceRef)"}`);
+			await ledger.record(edge, traversal, "delivered");
+		}
+		const composed = [
+			nodeId === compiled.root ? task : "",
+			...directives,
+			...traces
+		].filter((part) => part.length > 0).join("\n\n");
+		return {
+			task: composed.length > 0 ? composed : task,
+			inputs
 		};
-		/** 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({
+	};
+	const release = async (nodeId, consuming, 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) {
+			fail("cycle-budget-exceeded", "GraphCycleBudget", `node ${nodeId} entered ${visit} times; maxVisits ${node.maxVisits}`);
+			return;
+		}
+		const envelope = await consumeWave(nodeId, consuming);
+		const label = await openInstance(nodeId, visit, envelope);
+		await emit({
+			kind: "join-state",
+			id: label,
+			node: nodeId,
+			rule: node.join,
+			satisfiedBy: consuming.map(({ edge }) => edge.id),
+			consumedPending: [...consumedPending],
+			instance: label,
+			seq: engineSeq++,
+			at: stamp()
+		});
+		await spawnInstance(label);
+	};
+	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.map((edge) => ({
+			edge,
+			folded: state.edges.get(edge.id)
+		}));
+		const decision = decideJoin(node.join, gating);
+		if (decision.blocked) folded.blocked = true;
+		if (!decision.release) return;
+		for (const entry of decision.consuming) {
+			const cap = entry.edge.spec.maxTraversals;
+			if (cap !== void 0 && (entry.folded?.traversals ?? 0) >= cap) {
+				await ledger.record(entry.edge, (entry.folded?.traversals ?? 0) + 1, "unpropagated", `traversal-cap-exhausted (max ${cap})`);
+				await emit({
 					kind: "edge-verdict",
-					id: instanceLabel,
-					edge: edge.id,
-					fired,
-					sourceStatus: settle.status === "down" ? "down" : succeeded ? "done" : "invalid",
-					...inputRef !== void 0 ? { inputRef } : {},
+					id: `graph:${nodeId}`,
+					edge: entry.edge.id,
+					fired: false,
+					sourceStatus: "done",
+					capped: true,
 					seq: engineSeq++,
-					at: new Date(now()).toISOString()
+					at: stamp()
 				});
+				return;
 			}
-			for (const edge of node.outbound) await tryRelease(edge.spec.to.node);
-		};
-		const mintToken = (instanceLabel) => contentAddress({
-			runId,
-			instance: instanceLabel,
-			kind: "graph-suspension"
-		});
-		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);
+		}
+		const consumedPending = gating.filter((entry) => entry.folded?.state === "pending" && hasLiveInstance(entry.edge.spec.from.node)).map((entry) => entry.edge.id);
+		await release(nodeId, decision.consuming, consumedPending);
+	};
+	const hasLiveInstance = (nodeId) => {
+		for (const label of liveHandles.values()) if (state.instances.get(label)?.node === nodeId) return true;
+		return false;
+	};
+	/** Journal a verdict for every unaccounted outbound edge of a settle, then try the joins. */
+	const propagate = async (label, 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) {
+			if (!isEngineFired(edge)) continue;
+			const folded = state.edges.get(edge.id);
+			if (!folded || folded.judgedSourceSettles >= sourceSettles) continue;
+			let fired = false;
+			let inputRef;
+			if (succeeded) {
+				fired = edge.spec.guard === void 0 || evaluateCondition(edge.spec.guard, {
+					node: settle.node,
+					out: settle.out,
+					visits: state.nodes.get(settle.node)?.visits ?? 0,
+					valid: settle.valid ?? true
+				});
+				if (fired) inputRef = edge.spec.kind === "analyzes" ? settle.traceRef : settle.outRef;
 			}
-			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(),
+			await emit({
+				kind: "edge-verdict",
+				id: label,
+				edge: edge.id,
+				fired,
+				sourceStatus: settle.status === "down" ? "down" : succeeded ? "done" : "invalid",
+				...inputRef !== void 0 ? { inputRef } : {},
 				seq: engineSeq++,
-				at: new Date(now()).toISOString()
-			});
-		};
-		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()
+				at: stamp()
 			});
-			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);
-			}
-		};
-		/** 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) {
-					request.fail(error);
+		}
+		for (const edge of node.outbound) if (isEngineFired(edge)) await tryRelease(edge.spec.to.node);
+	};
+	const park = async (label, request) => {
+		const token = mintSuspensionToken(runId, label);
+		let defaultRef;
+		if (request.default !== void 0) {
+			const admitted = admitPayload(request.default);
+			defaultRef = contentAddress(admitted);
+			await blobs.put(defaultRef, admitted);
+		}
+		await emit({
+			kind: "waiting",
+			id: suspensionNodeId(token),
+			label,
+			spec: {
+				kind: "token",
+				token,
+				onExpire: request.onExpire,
+				...request.expiresInMs !== void 0 ? { expiresAtMs: now() + request.expiresInMs } : {},
+				...defaultRef !== void 0 ? { defaultRef } : {}
+			},
+			armedAt: now(),
+			seq: engineSeq++,
+			at: stamp()
+		});
+	};
+	const wake = async (suspension, by, outRef) => {
+		await emit({
+			kind: "woken",
+			id: suspensionNodeId(suspension.token),
+			by,
+			...outRef !== void 0 ? { outRef } : {},
+			seq: wokenSeq++,
+			at: stamp()
+		});
+		const settle = state.instances.get(suspension.instance)?.settle;
+		if (settle === void 0) return;
+		const out = settle.outRef === void 0 ? void 0 : admitPayload(await blobs.get(settle.outRef));
+		if (settle.outRef !== void 0 && out !== void 0) outCache.set(settle.outRef, out);
+		await propagate(suspension.instance, out === void 0 ? settle : {
+			...settle,
+			out
+		});
+	};
+	/** Expiries are engine-clocked, so an offline run transitions them without a host sweep (#976). */
+	const expireDue = async () => {
+		let transitioned = false;
+		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);
+			else continue;
+			transitioned = true;
+		}
+		return transitioned;
+	};
+	const drainWakes = async () => {
+		while (wakes.length > 0) {
+			const request = wakes.shift();
+			if (!request) return;
+			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) await wake(suspension, suspension.onExpire === "default" ? "fired" : "expired", suspension.onExpire === "default" ? suspension.defaultRef : void 0);
+				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) {
+				request.fail(error);
 			}
-		};
-		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
+		}
+	};
+	const handleSettle = async (settled) => {
+		const label = liveHandles.get(settled.handle.id);
+		if (label === void 0) return;
+		liveHandles.delete(settled.handle.id);
+		liveCount -= 1;
+		const instance = state.instances.get(label);
+		const node = instance === void 0 ? void 0 : compiled.nodes.get(instance.node);
+		if (!instance || !node) return;
+		if (settled.kind === "done" && isSuspensionRequest(settled.out)) {
+			await park(label, 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
 				},
-				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;
+				usd: 0,
+				ms: 0
+			},
+			seq: 0,
+			at: ""
+		}, compiled);
+		const folded = state.instances.get(label)?.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);
+			enriched = {
+				...folded,
+				out: admitted,
+				...await checkDeliverable(node, admitted)
+			};
+			const settles = state.nodes.get(instance.node)?.settles;
+			if (settles) settles[settles.length - 1] = enriched;
+			state.instances.get(label).settle = enriched;
+		}
+		if (instance.node === compiled.root && enriched.status === "done" && enriched.valid === true) {
+			abort.abort("root delivered");
+			return;
+		}
+		await propagate(label, enriched);
+	};
+	const checkDeliverable = async (node, out) => {
+		if (node.deliverable === void 0) return {};
+		try {
+			return { valid: await node.deliverable.check(out) };
+		} catch {
+			return { valid: false };
+		}
+	};
+	if (!context.resuming) for (const id of compiled.entries) await enterEntryNode(id);
+	else await reenterAfterCrash();
+	/** Kill-anywhere re-entry: finish every half-done transition the crashed process left, from the
+	*  pinned envelopes and journaled settles only — never by re-deriving anything (#974). */
+	async function reenterAfterCrash() {
+		for (const instance of [...state.instances.values()]) {
+			if (instance.status === "released") {
+				await spawnInstance(instance.instance);
+				continue;
 			}
-			if (instance.node === compiled.root && enriched.status === "done" && enriched.valid === true) {
-				abort.abort("root delivered");
+			if (instance.status !== "live") continue;
+			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) {
+				fail("cycle-budget-exceeded", "GraphCycleBudget", `node ${instance.node} entered ${visit} times; maxVisits ${node.maxVisits}`);
 				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({
+			instance.status = "down";
+			const label = `${instance.node}#${visit}`;
+			await emit({
 				kind: "node-inputs-resolved",
-				id: instanceLabel,
-				node: nodeId,
-				instance: instanceLabel,
-				inputRef,
+				id: label,
+				node: instance.node,
+				instance: label,
+				inputRef: instance.inputRef,
 				seq: engineSeq++,
-				at: new Date(now()).toISOString()
+				at: stamp()
 			});
-			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;
+			await spawnInstance(label);
+		}
+		for (const [nodeId, folded] of state.nodes) {
+			const latest = folded.settles.at(-1);
+			if (latest === void 0) continue;
+			const label = `${nodeId}#${latest.visit}`;
+			if (latest.status === "done" && latest.outRef !== void 0) {
+				const out = admitPayload(await blobs.get(latest.outRef));
+				if (isSuspensionRequest(out)) {
+					folded.settles.pop();
+					const instance = state.instances.get(label);
+					if (instance) instance.settle = void 0;
+					await park(label, out);
+					continue;
 				}
-				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
+				outCache.set(latest.outRef, out);
+				const node = compiled.nodes.get(nodeId);
+				await propagate(label, {
+					...latest,
+					out,
+					...node === void 0 ? {} : await checkDeliverable(node, out)
 				});
-				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 } : {}
-					};
-				}
-				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);
-		}
-		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 (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") {
+			await propagate(label, latest);
+		}
+		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);
+	}
+	const allTerminalsSettled = () => compiled.terminals.every((id) => (state.nodes.get(id)?.settles.length ?? 0) > 0);
+	let wakeSignal = Promise.resolve();
+	const rearmWakeSignal = () => {
+		wakeSignal = new Promise((fire) => {
+			onWakeSignal(fire);
+		});
+	};
+	rearmWakeSignal();
+	let pendingNext;
+	while (!failure) {
+		if (await expireDue()) continue;
+		if (wakes.length > 0) {
+			await drainWakes();
+			continue;
+		}
+		if (allTerminalsSettled()) break;
+		if (liveCount === 0) {
+			const parked = [...state.suspensions.values()].filter((suspension) => suspension.status === "pending");
+			if (parked.length === 0) break;
+			if (options.waitForWakes) {
 				rearmWakeSignal();
+				await wakeSignal;
 				continue;
 			}
-			inFlightNext = void 0;
-			if (raced.settle === null) break;
-			await handleSettle(raced.settle);
-			for (const parked of waitingForBudget.splice(0)) await spawnInstance(parked);
+			const defaulting = parked.filter((suspension) => suspension.onExpire === "default");
+			if (defaulting.length === 0) break;
+			for (const suspension of defaulting) await wake(suspension, "fired", suspension.defaultRef);
+			continue;
 		}
-		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;
-			}
-			return {
-				...settle,
-				out,
-				...valid !== void 0 ? { valid } : {}
-			};
-		};
-		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
-		});
-	}
-}
-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;
+		pendingNext ??= scope.next();
+		const raced = await Promise.race([pendingNext.then((settle) => ({ settle })), wakeSignal.then(() => "wake")]);
+		if (raced === "wake") {
+			rearmWakeSignal();
+			continue;
 		}
-		if (ev.kind === "waiting" && ev.spec.kind === "token" && ev.seq > max) max = ev.seq;
+		pendingNext = void 0;
+		if (raced.settle === null) break;
+		await handleSettle(raced.settle);
+		for (const label of waitingForBudget.splice(0)) await spawnInstance(label);
 	}
-	return max;
+	detachOuterAbort();
+	abort.abort("graph loop complete");
+	while (await (pendingNext ?? scope.next()) !== null) pendingNext = void 0;
+	return assembleGraphResult({
+		compiled,
+		state,
+		blobs,
+		scope,
+		outCache,
+		ledger: ledger.entries,
+		...options.finalizer !== void 0 ? { finalizer: options.finalizer } : {},
+		...failure !== void 0 ? { failure } : {},
+		aborted: options.signal?.aborted ?? false
+	});
 }
 //#endregion
-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 };
+export { CONDITION_OPS, DEFAULT_MAX_NODE_VISITS, ENGINE_WOKEN_SEQ_BASE, JOIN_RULES, MAX_MAX_NODE_VISITS, RUN_GRAPH_ROOT_KIND, admitPayload, agentKind, applyGraphFoldEvent, applyProjection, assembleGraphResult, compileGraph, createEdgeLedger, createGraphEngine, createGraphRun, createRegistry, decideJoin, emptyFoldState, evaluateCondition, foldGraphJournal, formatRegistryHandle, graphFromRunGraph, isEngineFired, isSuspensionRequest, kindHandle, materializeSettles, mintSuspensionToken, narrowEffects, openGraphRun, parseRegistryHandle, runEngineGraph, schemaAccepts, scriptKind, subgraphKind, supervisorKind, suspended, suspensionNodeId, tokenFromSuspensionNodeId, validateCondition, validateNodeKind, validateProjection };
 
 //# sourceMappingURL=graph.js.map