@tangle-network/agent-runtime 0.166.0 → 0.167.0

package/dist/graph.js

@@ -1,2 +1,2073 @@
-import { A as supervisorKind, B as MAX_MAX_NODE_VISITS, C as applyGraphFoldEvent, D as agentKind, E as admitPayload, F as compileGraph, G as validateProjection, H as formatRegistryHandle, I as isEngineFired, J as validateCondition, K as CONDITION_OPS, L as schemaAccepts, M as kindHandle, N as narrowEffects, O as scriptKind, P as validateNodeKind, R as DEFAULT_MAX_NODE_VISITS, S as decideJoin, T as foldGraphJournal, U as parseRegistryHandle, V as createRegistry, W as applyProjection, _ as ENGINE_WOKEN_SEQ_BASE, a as RUN_GRAPH_KIND, b as materializeSettles, c as runGraphKind, d as runEngineGraph, f as isSuspensionRequest, g as tokenFromSuspensionNodeId, h as suspensionNodeId, j as createGraphEngine, k as subgraphKind, l as runGraphThroughEngine, m as suspended, o as graphFromRunGraph, p as mintSuspensionToken, q as evaluateCondition, s as runGraphEngine, u as createGraphRun, v as openGraphRun, w as emptyFoldState, x as createEdgeLedger, y as assembleGraphResult, z as JOIN_RULES } from "./graph-E0U0c2YP.js";
-export { CONDITION_OPS, DEFAULT_MAX_NODE_VISITS, ENGINE_WOKEN_SEQ_BASE, JOIN_RULES, MAX_MAX_NODE_VISITS, RUN_GRAPH_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, runGraphEngine, runGraphKind, runGraphThroughEngine, schemaAccepts, scriptKind, subgraphKind, supervisorKind, suspended, suspensionNodeId, tokenFromSuspensionNodeId, validateCondition, validateNodeKind, validateProjection };
+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-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
+* predicate — is this shape, evaluated by this evaluator, so `contains`, ordering and equality can
+* never mean two different things on two surfaces (adopted from ADC's `workflow-conditions`,
+* agent-runtime#968). A declarative tree keeps an untrusted predicate incapable of code execution;
+* the size and depth bounds keep a predicate authored once from burning CPU on every settle.
+*
+* No zod: the kernel's grain is a hand-written validator that throws `ValidationError` by name.
+*/
+/** The leaf comparison operators; `exists`/`truthy` are unary, the rest compare against `value`. */
+const CONDITION_OPS = [
+	"eq",
+	"neq",
+	"gt",
+	"gte",
+	"lt",
+	"lte",
+	"in",
+	"contains",
+	"exists",
+	"truthy"
+];
+/** Operators that compare against `value`; `exists`/`truthy` are unary and must omit it. */
+const OPS_NEEDING_VALUE = new Set(CONDITION_OPS.filter((op) => op !== "exists" && op !== "truthy"));
+const MAX_PATH_LENGTH = 256;
+const MAX_PATH_SEGMENTS = 16;
+const PATH_SEGMENT = /^[A-Za-z_$][A-Za-z0-9_$-]*$/u;
+/** Parse `a.b[0].c` into steps; refuse anything outside the bounded grammar. */
+function parseConditionPath(path, context) {
+	if (typeof path !== "string" || path.length === 0 || path.length > MAX_PATH_LENGTH) throw new ValidationError(`${context}: path must be a non-empty string of at most ${MAX_PATH_LENGTH} chars`);
+	const steps = [];
+	for (const part of path.split(".")) {
+		const open = part.indexOf("[");
+		const head = open === -1 ? part : part.slice(0, open);
+		if (head.length > 0) {
+			if (!PATH_SEGMENT.test(head)) throw new ValidationError(`${context}: path segment ${JSON.stringify(head)} is not addressable`);
+			steps.push(head);
+		} else if (open !== 0 || steps.length === 0) throw new ValidationError(`${context}: path ${JSON.stringify(path)} has an empty segment`);
+		let rest = open === -1 ? "" : part.slice(open);
+		while (rest.length > 0) {
+			const match = /^\[(\d{1,6})\]/u.exec(rest);
+			if (!match) throw new ValidationError(`${context}: path index in ${JSON.stringify(part)} must be [N]`);
+			steps.push(Number(match[1]));
+			rest = rest.slice(match[0].length);
+		}
+		if (steps.length > MAX_PATH_SEGMENTS) throw new ValidationError(`${context}: path exceeds ${MAX_PATH_SEGMENTS} segments`);
+	}
+	if (steps.length === 0) throw new ValidationError(`${context}: path resolves no segment`);
+	return steps;
+}
+/** Walk a parsed path; any miss resolves `undefined`, never a throw — absence is an answer. */
+function resolveConditionPath(context, steps) {
+	let current = context;
+	for (const step of steps) {
+		if (current === null || current === void 0) return void 0;
+		if (typeof step === "number") {
+			if (!Array.isArray(current)) return void 0;
+			current = current[step];
+		} else {
+			if (typeof current !== "object" || Array.isArray(current)) return void 0;
+			current = current[step];
+		}
+	}
+	return current;
+}
+function isLeaf(condition) {
+	return typeof condition.path === "string";
+}
+/** Validate shape, bounds, and per-leaf path/operator rules; returns the input for chaining. */
+function validateCondition(raw, context) {
+	let nodes = 0;
+	const walk = (value, depth) => {
+		nodes += 1;
+		if (nodes > 40) throw new ValidationError(`${context}: condition exceeds 40 nodes`);
+		if (depth > 6) throw new ValidationError(`${context}: condition exceeds depth 6`);
+		if (typeof value !== "object" || value === null || Array.isArray(value)) throw new ValidationError(`${context}: a condition must be an object`);
+		const record = value;
+		const combinators = [
+			"all",
+			"any",
+			"not"
+		].filter((key) => record[key] !== void 0);
+		if (combinators.length > 1) throw new ValidationError(`${context}: a condition carries ONE of all/any/not, got ${combinators.join("+")}`);
+		if (record.all !== void 0 || record.any !== void 0) {
+			const key = record.all !== void 0 ? "all" : "any";
+			const branch = record[key];
+			if (!Array.isArray(branch) || branch.length === 0) throw new ValidationError(`${context}: ${key} must be a non-empty array`);
+			for (const child of branch) walk(child, depth + 1);
+			return value;
+		}
+		if (record.not !== void 0) {
+			walk(record.not, depth + 1);
+			return value;
+		}
+		const op = record.op;
+		if (typeof record.path !== "string" || typeof op !== "string") throw new ValidationError(`${context}: a leaf needs { path, op }`);
+		if (!CONDITION_OPS.includes(op)) throw new ValidationError(`${context}: unknown op ${JSON.stringify(op)}; known: ${CONDITION_OPS.join(", ")}`);
+		parseConditionPath(record.path, context);
+		const needsValue = OPS_NEEDING_VALUE.has(op);
+		if (needsValue && !("value" in record)) throw new ValidationError(`${context}: op ${JSON.stringify(op)} requires a value`);
+		if (!needsValue && "value" in record) throw new ValidationError(`${context}: op ${JSON.stringify(op)} is unary — remove value`);
+		if (op === "in" && !Array.isArray(record.value)) throw new ValidationError(`${context}: op "in" takes an array value`);
+		return value;
+	};
+	return walk(raw, 1);
+}
+function canonicalEquals(a, b) {
+	if (Object.is(a, b)) return true;
+	if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+	try {
+		return JSON.stringify(a) === JSON.stringify(b);
+	} catch {
+		return false;
+	}
+}
+function ordering(op, left, right) {
+	if (typeof left === "number" && typeof right === "number") {
+		if (Number.isNaN(left) || Number.isNaN(right)) return false;
+		if (op === "gt") return left > right;
+		if (op === "gte") return left >= right;
+		if (op === "lt") return left < right;
+		return left <= right;
+	}
+	if (typeof left === "string" && typeof right === "string") {
+		if (op === "gt") return left > right;
+		if (op === "gte") return left >= right;
+		if (op === "lt") return left < right;
+		return left <= right;
+	}
+	return false;
+}
+/** Walk a validated condition over a context to a boolean. Never throws on data shape. */
+function evaluateCondition(condition, context) {
+	if (isLeaf(condition)) {
+		const resolved = resolveConditionPath(context, parseConditionPath(condition.path, "evaluate"));
+		switch (condition.op) {
+			case "exists": return resolved !== void 0 && resolved !== null;
+			case "truthy": return Boolean(resolved);
+			case "eq": return canonicalEquals(resolved, condition.value);
+			case "neq": return !canonicalEquals(resolved, condition.value);
+			case "in": return Array.isArray(condition.value) ? condition.value.some((candidate) => canonicalEquals(resolved, candidate)) : false;
+			case "contains":
+				if (Array.isArray(resolved)) return resolved.some((element) => canonicalEquals(element, condition.value));
+				return typeof resolved === "string" && typeof condition.value === "string" ? resolved.includes(condition.value) : false;
+			default: return ordering(condition.op, resolved, condition.value);
+		}
+	}
+	if ("all" in condition) return condition.all.every((child) => evaluateCondition(child, context));
+	if ("any" in condition) return condition.any.some((child) => evaluateCondition(child, context));
+	return !evaluateCondition(condition.not, context);
+}
+//#endregion
+//#region src/runtime/graph/projection.ts
+/**
+* The ONE pure projection a `data` edge may carry (agent-runtime#971): the bounded,
+* schema-preserving subset of ADC's collection helpers. Anything richer is a `script` NODE, so it
+* is journaled (`inputRef` → `outRef`), typed, and visible. Exactly one operator per projection.
+*/
+const PROJECTION_KEYS = [
+	"path",
+	"pick",
+	"map",
+	"filter",
+	"first",
+	"last",
+	"count"
+];
+/** Validate a projection: exactly one known operator, its argument well-formed. */
+function validateProjection(raw, context) {
+	if (typeof raw !== "object" || raw === null || Array.isArray(raw)) throw new ValidationError(`${context}: a projection must be an object`);
+	const record = raw;
+	const keys = PROJECTION_KEYS.filter((key) => record[key] !== void 0);
+	const unknown = Object.keys(record).filter((key) => !PROJECTION_KEYS.includes(key));
+	if (unknown.length > 0) throw new ValidationError(`${context}: unknown projection key(s) ${unknown.join(", ")}; known: ${PROJECTION_KEYS.join(", ")}`);
+	if (keys.length !== 1) throw new ValidationError(`${context}: a projection carries exactly ONE of ${PROJECTION_KEYS.join("/")}`);
+	const key = keys[0];
+	if (key === "path" || key === "map") parseConditionPath(record[key], context);
+	if (key === "pick") {
+		const fields = record.pick;
+		if (!Array.isArray(fields) || fields.length === 0 || fields.some((f) => typeof f !== "string")) throw new ValidationError(`${context}: pick must be a non-empty array of field names`);
+	}
+	if (key === "filter") validateCondition(record.filter, context);
+	if ((key === "first" || key === "last" || key === "count") && record[key] !== true) throw new ValidationError(`${context}: ${key} must be literally true`);
+	return raw;
+}
+/**
+* Apply a validated projection to an admitted payload. Collection operators over a non-array
+* refuse by name — a shape the author did not expect is a graph defect, not an empty result.
+*/
+function applyProjection(value, projection, context) {
+	if ("path" in projection) return resolveConditionPath(value, parseConditionPath(projection.path, context));
+	if ("pick" in projection) {
+		if (typeof value !== "object" || value === null || Array.isArray(value)) throw new ValidationError(`${context}: pick needs an object payload`);
+		const record = value;
+		const out = {};
+		for (const field of projection.pick) if (field in record) out[field] = record[field];
+		return out;
+	}
+	const collection = value;
+	if (!Array.isArray(collection)) throw new ValidationError(`${context}: this projection needs an array payload`);
+	if ("map" in projection) {
+		const steps = parseConditionPath(projection.map, context);
+		return collection.map((element) => resolveConditionPath(element, steps));
+	}
+	if ("filter" in projection) return collection.filter((element) => evaluateCondition(projection.filter, element));
+	if ("first" in projection) return collection[0];
+	if ("last" in projection) return collection[collection.length - 1];
+	return collection.length;
+}
+//#endregion
+//#region src/runtime/graph/registry.ts
+/**
+* `Registry<T>` — the ONE name→thing shape for the graph engine.
+*
+* The kernel grew fourteen of these (agent-runtime#978) that differ in three properties:
+* whether names can be listed, what a miss does, and whether the table is global. This one
+* fixes all three — enumerable, a miss is refused BY NAME listing what is registered, and every
+* registry is per-instance — and it is lifted from `AgentEnvironmentProviderRegistry`, the
+* richest and best-tested of the fourteen, not invented.
+*
+* Entries are addressed by a versioned handle, `<id>/v<n>`, the same way the prompt registry
+* addresses directives. A graph names a kind by handle; a host registers exact versions; a
+* missing version is refused, never served by a newer one.
+*/
+/** `<id>/v<n>` — the only spelling a handle has on the wire, in a journal, or in an error. */
+function formatRegistryHandle(handle) {
+	return `${handle.id}/v${handle.version}`;
+}
+/** Parse the wire spelling back. Refuses anything that is not exactly `<id>/v<n>`. */
+function parseRegistryHandle(text, context) {
+	const match = /^([A-Za-z0-9][A-Za-z0-9._-]*)\/v(\d+)$/u.exec(text);
+	if (!match) throw new ValidationError(`${context}: ${JSON.stringify(text)} is not a registry handle; expected "<id>/v<n>"`);
+	const version = Number(match[2]);
+	if (!Number.isSafeInteger(version) || version < 1) throw new ValidationError(`${context}: handle version must be a positive integer`);
+	return {
+		id: match[1],
+		version
+	};
+}
+/**
+* Create a registry. Per-instance by construction: two engines in one process may hold
+* different kind sets, a test is hermetic, and a run can print its own table. There is
+* deliberately no module-level singleton — `builtinShapes` was the one mutable global in the
+* kernel and it had zero tests.
+*/
+function createRegistry(label, seed = []) {
+	const table = /* @__PURE__ */ new Map();
+	const registry = {
+		register(entry, options = {}) {
+			if (typeof entry.id !== "string" || entry.id.length === 0) throw new ValidationError(`${label}: an entry must carry a non-empty id`);
+			if (!Number.isSafeInteger(entry.version) || entry.version < 1) throw new ValidationError(`${label}: ${JSON.stringify(entry.id)} must carry a positive integer version`);
+			const key = formatRegistryHandle(entry);
+			if (!options.replace && table.has(key)) throw new ValidationError(`${label}: ${JSON.stringify(key)} is already registered`);
+			table.set(key, entry);
+		},
+		has(handle) {
+			return table.has(formatRegistryHandle(handle));
+		},
+		get(handle) {
+			return table.get(formatRegistryHandle(handle));
+		},
+		require(handle, context = label) {
+			const key = formatRegistryHandle(handle);
+			const entry = table.get(key);
+			if (entry === void 0) {
+				const known = registry.names();
+				const suffix = known.length > 0 ? `; registered: ${known.join(", ")}` : "; nothing is registered";
+				throw new ValidationError(`${context}: ${JSON.stringify(key)} is not registered${suffix}`);
+			}
+			return entry;
+		},
+		names() {
+			return Array.from(table.keys()).sort();
+		},
+		entries() {
+			return registry.names().map((key) => table.get(key));
+		}
+	};
+	for (const entry of seed) registry.register(entry);
+	return registry;
+}
+//#endregion
+//#region src/runtime/graph/definition.ts
+/** Which gating-edge outcomes release a node (adopted from ADC, agent-runtime#968). */
+const JOIN_RULES = [
+	"all",
+	"any",
+	"any_failed",
+	"all_done"
+];
+/** ADC-compatible visit backstop: nothing may be ENTERED more than this many times. */
+const DEFAULT_MAX_NODE_VISITS = 25;
+/** The hard ceiling an author's `maxVisits`/`maxNodeVisits` override may reach. */
+const MAX_MAX_NODE_VISITS = 100;
+/** Structural validation only — everything a registry is not needed for. */
+function validateEngineGraphSpec(spec, context = "compileGraph") {
+	if (!Array.isArray(spec.nodes) || spec.nodes.length === 0) throw new ValidationError(`${context}: a graph needs at least one node`);
+	const ids = /* @__PURE__ */ new Set();
+	for (const node of spec.nodes) {
+		if (typeof node.id !== "string" || node.id.length === 0) throw new ValidationError(`${context}: every node needs a non-empty id`);
+		if (ids.has(node.id)) throw new ValidationError(`${context}: duplicate node id ${JSON.stringify(node.id)}`);
+		ids.add(node.id);
+		parseRegistryHandle(node.kind, `${context}: node ${node.id} kind`);
+		if (node.join !== void 0 && !JOIN_RULES.includes(node.join)) throw new ValidationError(`${context}: node ${node.id} join ${JSON.stringify(node.join)}; known: ${JOIN_RULES.join(", ")}`);
+		if (node.maxVisits !== void 0) {
+			if (!Number.isSafeInteger(node.maxVisits) || node.maxVisits < 1 || node.maxVisits > 100) throw new ValidationError(`${context}: node ${node.id} maxVisits must be an integer in [1, 100]`);
+		}
+	}
+	if (!Array.isArray(spec.edges)) throw new ValidationError(`${context}: edges must be an array`);
+	for (const [index, edge] of spec.edges.entries()) {
+		const who = `${context}: edge[${index}]`;
+		if (edge.kind !== "delegates" && edge.kind !== "analyzes" && edge.kind !== "data") throw new ValidationError(`${who}: kind must be delegates | analyzes | data`);
+		for (const end of ["from", "to"]) {
+			const ref = edge[end];
+			if (typeof ref !== "object" || ref === null || typeof ref.node !== "string" || !ids.has(ref.node)) throw new ValidationError(`${who}: ${end}.node must name a node in this graph`);
+		}
+		if (edge.guard !== void 0) validateCondition(edge.guard, `${who} guard`);
+		if (edge.projection !== void 0) {
+			if (edge.kind !== "data") throw new ValidationError(`${who}: only a data edge carries a projection`);
+			validateProjection(edge.projection, `${who} projection`);
+		}
+		if (edge.maxTraversals !== void 0) {
+			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`);
+	}
+	if (spec.root !== void 0 && !ids.has(spec.root)) throw new ValidationError(`${context}: root ${JSON.stringify(spec.root)} names no node`);
+	if (spec.maxNodeVisits !== void 0) {
+		if (!Number.isSafeInteger(spec.maxNodeVisits) || spec.maxNodeVisits < 1 || spec.maxNodeVisits > 100) throw new ValidationError(`${context}: maxNodeVisits must be an integer in [1, 100]`);
+	}
+}
+//#endregion
+//#region src/runtime/graph/compile.ts
+/**
+* Compile an authored graph against an engine's kind registry into the schedulable form. Every
+* refusal here happens before any spend: an unknown kind, a port that does not exist, a `data`
+* binding whose schemas cannot fit, a `delegates`/`data` edge into an oracle, a terminal with no
+* completion check (agent-runtime#971, #973).
+*/
+/** 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) => {
+		if (own === void 0 || own.length === 0) return declared;
+		const names = new Set(own.map((port) => port.name));
+		return [...own, ...declared.filter((port) => !names.has(port.name))];
+	};
+	return {
+		inputs: merge(kind.inputs, node.ports?.inputs),
+		outputs: merge(kind.outputs, node.ports?.outputs)
+	};
+}
+function outputPort(ports, port) {
+	if (IMPLICIT_OUTPUT_PORTS.includes(port)) return {
+		name: port,
+		schema: {}
+	};
+	return ports.outputs.find((candidate) => candidate.name === port);
+}
+function inputPort(ports, port) {
+	return ports.inputs.find((candidate) => candidate.name === port);
+}
+/**
+* Bounded structural acceptance: does a value of `source`'s shape fit `target`? Schemas with no
+* `type` accept anything; object targets require their `required` properties to be present and
+* accepted when the source declares properties. Depth-bounded — this is a compile-time tripwire,
+* not a full JSON Schema validator.
+*/
+function schemaAccepts(source, target, depth = 0) {
+	if (depth > 6) return true;
+	const sourceType = source.type;
+	const targetType = target.type;
+	if (targetType === void 0 || sourceType === void 0) return true;
+	const targets = Array.isArray(targetType) ? targetType : [targetType];
+	const sources = Array.isArray(sourceType) ? sourceType : [sourceType];
+	if (sources.filter((candidate) => targets.includes(candidate === "integer" ? "number" : candidate) || targets.includes(candidate)).length === 0) return false;
+	if (targets.includes("object") && sources.includes("object")) {
+		const required = Array.isArray(target.required) ? target.required : [];
+		const sourceProps = source.properties;
+		const targetProps = target.properties;
+		if (sourceProps !== void 0) for (const name of required) {
+			const sourceProp = sourceProps[name];
+			if (sourceProp === void 0) return false;
+			const targetProp = targetProps?.[name];
+			if (targetProp !== void 0 && !schemaAccepts(sourceProp, targetProp, depth + 1)) return false;
+		}
+	}
+	if (targets.includes("array") && sources.includes("array")) {
+		const sourceItems = source.items;
+		const targetItems = target.items;
+		if (sourceItems !== void 0 && targetItems !== void 0) return schemaAccepts(sourceItems, targetItems, depth + 1);
+	}
+	return true;
+}
+/**
+* Lower an authored graph against an engine's kind registry into the schedulable form, refusing
+* every structural defect before any spend.
+*/
+function compileGraph(engine, spec, context = "compileGraph") {
+	validateEngineGraphSpec(spec, context);
+	const kinds = /* @__PURE__ */ new Map();
+	const configs = /* @__PURE__ */ new Map();
+	for (const node of spec.nodes) {
+		const handle = parseRegistryHandle(node.kind, `${context}: node ${node.id}`);
+		const kind = engine.kinds.require(handle, `${context}: node ${node.id}`);
+		kinds.set(node.id, kind);
+		configs.set(node.id, kind.validateConfig(node.config ?? {}, `${context}: node ${node.id}`));
+		if (node.flags?.pure && kind.id !== "script") throw new ValidationError(`${context}: node ${node.id} sets pure, which only a script node may claim`);
+	}
+	const compiledEdges = [];
+	const inbound = /* @__PURE__ */ new Map();
+	const outbound = /* @__PURE__ */ new Map();
+	for (const [index, edge] of spec.edges.entries()) {
+		const who = `${context}: edge[${index}] ${edge.from.node}->${edge.to.node}`;
+		const fromKind = kinds.get(edge.from.node);
+		const toKind = kinds.get(edge.to.node);
+		if (!fromKind || !toKind) throw new ValidationError(`${who}: unresolved endpoint`);
+		const toNode = spec.nodes.find((node) => node.id === edge.to.node);
+		if (edge.kind !== "analyzes" && toNode?.flags?.oracle) throw new ValidationError(`${who}: a ${edge.kind} edge may not target oracle node ${edge.to.node}; use analyzes`);
+		const fromPort = edge.from.port ?? (edge.kind === "analyzes" ? "trace" : "out");
+		if (edge.kind === "analyzes" && fromPort !== "trace") throw new ValidationError(`${who}: an analyzes edge reads the trace port, got ${fromPort}`);
+		const fromPorts = nodePorts(fromKind, spec.nodes.find((node) => node.id === edge.from.node));
+		const toPorts = nodePorts(toKind, toNode);
+		const sourcePort = outputPort(fromPorts, fromPort);
+		if (!sourcePort) {
+			const known = [...IMPLICIT_OUTPUT_PORTS, ...fromPorts.outputs.map((port) => port.name)];
+			throw new ValidationError(`${who}: ${formatRegistryHandle(fromKind)} has no output port ${JSON.stringify(fromPort)}; known: ${known.join(", ")}`);
+		}
+		let toPort = edge.to.port ?? "";
+		if (edge.kind === "data") {
+			if (toPort === "") if (toPorts.inputs.length === 1) toPort = toPorts.inputs[0]?.name ?? "";
+			else throw new ValidationError(`${who}: a data edge needs to.port; ${formatRegistryHandle(toKind)} declares ${toPorts.inputs.length} inputs`);
+			const targetPort = inputPort(toPorts, toPort);
+			if (!targetPort) throw new ValidationError(`${who}: ${formatRegistryHandle(toKind)} has no input port ${JSON.stringify(toPort)}; known: ${toPorts.inputs.map((port) => port.name).join(", ") || "(none)"}`);
+			if (edge.projection === void 0 && !schemaAccepts(sourcePort.schema, targetPort.schema)) throw new ValidationError(`${who}: output ${fromPort} (${JSON.stringify(sourcePort.schema.type ?? "any")}) cannot fit input ${toPort} (${JSON.stringify(targetPort.schema.type ?? "any")})`);
+		}
+		const compiled = {
+			id: edge.id ?? `${edge.from.node}->${edge.to.node}#${index}`,
+			spec: edge,
+			fromPort,
+			toPort: toPort === "" ? "out" : toPort
+		};
+		compiledEdges.push(compiled);
+		outbound.set(edge.from.node, [...outbound.get(edge.from.node) ?? [], compiled]);
+		inbound.set(edge.to.node, [...inbound.get(edge.to.node) ?? [], compiled]);
+	}
+	const dupes = /* @__PURE__ */ new Set();
+	for (const edge of compiledEdges) {
+		if (dupes.has(edge.id)) throw new ValidationError(`${context}: duplicate edge id ${edge.id}`);
+		dupes.add(edge.id);
+	}
+	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 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, {
+			id: node.id,
+			kind,
+			config: configs.get(node.id),
+			join: node.join ?? "all",
+			maxVisits: node.maxVisits ?? spec.maxNodeVisits ?? 25,
+			oracle: node.flags?.oracle ?? false,
+			pure: node.flags?.pure ?? false,
+			terminal,
+			...deliverable === void 0 ? {} : { deliverable },
+			inbound: engineInbound(node.id),
+			outbound: outbound.get(node.id) ?? [],
+			modelFired,
+			spec: node
+		});
+	}
+	if (terminals.filter((id) => nodes.get(id)?.deliverable === void 0).length === terminals.length) throw new ValidationError(`${context}: no terminal declares a completion check (terminals: ${terminals.join(", ")}); give a node a deliverable or set spec.deliverable`);
+	return {
+		nodes,
+		edges: compiledEdges,
+		entries,
+		terminals,
+		root,
+		maxNodeVisits: spec.maxNodeVisits ?? 25
+	};
+}
+//#endregion
+//#region src/runtime/graph/kind.ts
+/** Validate a kind declaration at registration — so a malformed kind is refused by name once,
+*  not at the first node that uses it. */
+function validateNodeKind(kind, context = "registerNodeKind") {
+	const who = `${context}: kind ${JSON.stringify(`${kind.id}/v${kind.version}`)}`;
+	if (typeof kind.id !== "string" || kind.id.length === 0) throw new ValidationError(`${context}: a kind must carry a non-empty id`);
+	if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/u.test(kind.id)) throw new ValidationError(`${who}: id may contain only letters, digits, ".", "_" and "-"`);
+	if (!Number.isSafeInteger(kind.version) || kind.version < 1) throw new ValidationError(`${who}: version must be a positive integer`);
+	if (typeof kind.description !== "string" || kind.description.trim().length === 0) throw new ValidationError(`${who}: description is required`);
+	if (typeof kind.validateConfig !== "function") throw new ValidationError(`${who}: validateConfig must be a function`);
+	if (!isRecord(kind.configSchema)) throw new ValidationError(`${who}: configSchema must be a JSON Schema object`);
+	for (const [field, ports] of [["inputs", kind.inputs], ["outputs", kind.outputs]]) {
+		if (!Array.isArray(ports)) throw new ValidationError(`${who}: ${field} must be an array`);
+		const seen = /* @__PURE__ */ new Set();
+		for (const port of ports) {
+			if (!port || typeof port.name !== "string" || port.name.length === 0) throw new ValidationError(`${who}: every ${field} port needs a non-empty name`);
+			if (field === "outputs" && (port.name === "out" || port.name === "trace")) throw new ValidationError(`${who}: output port ${JSON.stringify(port.name)} is implicit on every node and cannot be declared`);
+			if (seen.has(port.name)) throw new ValidationError(`${who}: duplicate ${field} port ${JSON.stringify(port.name)}`);
+			seen.add(port.name);
+			if (!isRecord(port.schema)) throw new ValidationError(`${who}: ${field} port ${JSON.stringify(port.name)} needs a JSON Schema`);
+		}
+	}
+	if (!Array.isArray(kind.effects) || kind.effects.some((e) => typeof e !== "string" || e.length === 0)) throw new ValidationError(`${who}: effects must be an array of non-empty names`);
+	if (new Set(kind.effects).size !== kind.effects.length) throw new ValidationError(`${who}: effects must not repeat a name`);
+	if (kind.onCrash !== "restart" && kind.onCrash !== "resume") throw new ValidationError(`${who}: onCrash must be "restart" or "resume"`);
+	if (kind.budget !== "metered" && kind.budget !== "exempt") throw new ValidationError(`${who}: budget must be "metered" or "exempt"`);
+	if (typeof kind.run !== "function") throw new ValidationError(`${who}: run must be a function`);
+	return kind;
+}
+/** The handle a graph writes to name this kind. */
+function kindHandle(kind) {
+	return {
+		id: kind.id,
+		version: kind.version
+	};
+}
+/**
+* Narrow a host's effect table to exactly what one kind declared. Anything the kind did not
+* declare is absent — `undefined` on read — so a kind cannot reach past its declaration, and the
+* engine can list a graph's required effects before spending a token.
+*/
+function narrowEffects(declared, provided, context) {
+	const out = {};
+	const missing = [];
+	for (const name of declared) {
+		if (!(name in provided)) {
+			missing.push(name);
+			continue;
+		}
+		out[name] = provided[name];
+	}
+	if (missing.length > 0) throw new ValidationError(`${context}: host provides no effect for ${missing.map((m) => JSON.stringify(m)).join(", ")}; provided: ${Object.keys(provided).sort().join(", ") || "none"}`);
+	return Object.freeze(out);
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region src/runtime/graph/engine.ts
+/**
+* `createGraphEngine` — one engine instance: its kind registry (core kinds pre-registered, host
+* kinds added by the caller), its effect table, and nothing global.
+*
+* The scheduler (#980), journal fold (#981) and the `runGraph` preset (#982) attach here; this
+* file is the part that must exist first so a host can register kinds and a compiler can ask
+* "which effects does this graph need" before a token is spent.
+*/
+/**
+* Build one engine: a kind registry seeded with the core kinds plus the host's, and the host's
+* effect values. Every kind is validated by name at construction, so a malformed host kind fails
+* here, never at its first node.
+*/
+function createGraphEngine(options) {
+	const kinds = createRegistry("graph kinds");
+	for (const kind of options.coreKinds) kinds.register(validateNodeKind(kind, "createGraphEngine"));
+	for (const kind of options.kinds ?? []) kinds.register(validateNodeKind(kind, "createGraphEngine"));
+	const effects = Object.freeze({ ...options.effects ?? {} });
+	if (Object.keys(effects).some((name) => name.length === 0)) throw new ValidationError("createGraphEngine: an effect name must be non-empty");
+	const engine = {
+		kinds,
+		effects,
+		requiredEffects() {
+			const names = /* @__PURE__ */ new Set();
+			for (const kind of kinds.entries()) for (const name of kind.effects) names.add(name);
+			return Array.from(names).sort();
+		},
+		missingEffects() {
+			return engine.requiredEffects().filter((name) => !(name in effects));
+		}
+	};
+	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/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`.
+* The model cannot decide this — it is what gets run.
+*/
+function agentKind(defaults) {
+	return {
+		id: "agent",
+		version: 1,
+		description: "One AgentProfile run as a leaf on a backend; the kernel derives the executor.",
+		validateConfig: (raw, context) => {
+			const config = asRecord(raw, `${context}: agent config`);
+			return {
+				...config.backend !== void 0 ? { backend: config.backend } : {},
+				...config.deliverable !== void 0 ? { deliverable: config.deliverable } : {}
+			};
+		},
+		configSchema: {
+			type: "object",
+			properties: {
+				backend: { type: "object" },
+				deliverable: { type: "object" }
+			},
+			additionalProperties: false
+		},
+		inputs: [],
+		outputs: [],
+		effects: [],
+		onCrash: "restart",
+		budget: "metered",
+		run: ({ config, profile, spawn }) => {
+			const backend = config.backend ?? defaults.backend;
+			if (!backend) throw new ValidationError(`agent kind: node ${JSON.stringify(profile.name)} has no backend — set config.backend or the engine default`);
+			return workerFromBackend(backend, config.deliverable ?? defaults.deliverable)(profile, spawn);
+		}
+	};
+}
+/**
+* The thing that DECIDES: a nested `supervisorAgent` with the coordination verbs. Its children
+* are its own tree — the graph sees one node in, one `Settled` out. A `subgraph` constrains what
+* it may spawn; without one it is free-form under `profileSecurity` and `allowedModels`.
+*/
+function supervisorKind(deps) {
+	return {
+		id: "supervisor",
+		version: 1,
+		description: "A nested supervisor: spawns, observes, steers and awaits its own children with the coordination verbs.",
+		validateConfig: (raw, context) => {
+			const config = asRecord(raw, `${context}: supervisor config`);
+			return {
+				perWorker: asRecord(config.perWorker, `${context}: supervisor config.perWorker`),
+				...config.maxLiveWorkers !== void 0 ? { maxLiveWorkers: Number(config.maxLiveWorkers) } : {}
+			};
+		},
+		configSchema: {
+			type: "object",
+			properties: {
+				perWorker: { type: "object" },
+				maxLiveWorkers: { type: "integer" }
+			},
+			required: ["perWorker"],
+			additionalProperties: false
+		},
+		inputs: [],
+		outputs: [],
+		effects: [],
+		onCrash: "restart",
+		budget: "metered",
+		run: ({ config, profile }) => supervisorAgent(profile, {
+			blobs: deps.blobs,
+			makeWorkerAgent: deps.makeWorkerAgent,
+			perWorker: config.perWorker,
+			...config.maxLiveWorkers !== void 0 ? { maxLiveWorkers: config.maxLiveWorkers } : {},
+			...deps.router ? { router: deps.router } : {},
+			...deps.driveHarness ? { driveHarness: deps.driveHarness } : {}
+		})
+	};
+}
+/** The script kind's handle; it also names the kind in every script node's identity. */
+const SCRIPT = {
+	id: "script",
+	version: 1
+};
+/**
+* Caller code as a node. The one kind with no kernel primitive behind it: the kernel has no
+* "data→data with no execution" concept (agent-runtime#970 fact-finding), so this is new. It is
+* still a leaf `Agent` carrying an `Executor`, so the journal, the gate and the pool treat it like
+* any other node.
+*/
+function scriptKind() {
+	return {
+		...SCRIPT,
+		description: "Run caller code over the resolved inputs; pure scripts are exempt and restorable.",
+		validateConfig: (raw, context) => {
+			const config = asRecord(raw, `${context}: script config`);
+			if (typeof config.body !== "function") throw new ValidationError(`${context}: script config.body must be a function`);
+			if (config.pure !== void 0 && typeof config.pure !== "boolean") throw new ValidationError(`${context}: script config.pure must be a boolean`);
+			if (config.pure === true && config.spent !== void 0) throw new ValidationError(`${context}: a pure script is budget-exempt and cannot report spent`);
+			return {
+				body: config.body,
+				...config.pure !== void 0 ? { pure: config.pure } : {},
+				...config.spent !== void 0 ? { spent: config.spent } : {}
+			};
+		},
+		configSchema: {
+			type: "object",
+			properties: {
+				pure: { type: "boolean" },
+				spent: { type: "object" }
+			},
+			additionalProperties: true
+		},
+		inputs: [],
+		outputs: [],
+		effects: [],
+		onCrash: "restart",
+		budget: "metered",
+		run: ({ config, profile, inputs }) => scriptAgent(profile, config, inputs, SCRIPT)
+	};
+}
+function scriptAgent(profile, config, inputs, kind) {
+	let artifact;
+	const spec = {
+		profile,
+		harness: null,
+		executor: {
+			runtime: "inline",
+			...config.pure ? { budgetExempt: true } : {},
+			async execute(_task, signal) {
+				const startedAt = Date.now();
+				const out = await config.body(inputs, signal);
+				const ms = Date.now() - startedAt;
+				const spent = config.pure ? {
+					iterations: 0,
+					tokens: {
+						input: 0,
+						output: 0
+					},
+					usd: 0,
+					ms
+				} : config.spent ?? {
+					iterations: 1,
+					tokens: {
+						input: 0,
+						output: 0,
+						tokensKnown: false
+					},
+					tokensKnown: false,
+					usd: 0,
+					usdKnown: false,
+					ms
+				};
+				artifact = {
+					outRef: contentAddress(out),
+					out,
+					spent
+				};
+				return artifact;
+			},
+			teardown: () => Promise.resolve({ destroyed: true }),
+			resultArtifact() {
+				if (!artifact) throw new ValidationError("script: resultArtifact() read before execute()");
+				return artifact;
+			}
+		},
+		execution: { correlation: { nodeKind: formatRegistryHandle(kind) } }
+	};
+	return {
+		name: profile.name ?? "script",
+		act: () => Promise.reject(new ValidationError("script: act() is not the execution path")),
+		executorSpec: spec
+	};
+}
+/** 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",
+		version: 1,
+		description: "A node that runs its own graph; constrains a supervisor at depth>1.",
+		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,
+				...config.budget === void 0 ? {} : { budget: config.budget },
+				...config.perNode === void 0 ? {} : { perNode: config.perNode }
+			};
+		},
+		configSchema: {
+			type: "object",
+			properties: { graph: { type: "object" } },
+			required: ["graph"]
+		},
+		inputs: [],
+		outputs: [],
+		effects: [],
+		onCrash: "restart",
+		budget: "metered",
+		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;
+						}
+					}
+				}
+			};
+		}
+	};
+}
+function asRecord(value, context) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new ValidationError(`${context} must be an object`);
+	return value;
+}
+//#endregion
+//#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
+/**
+* `runGraph` as an engine graph (agent-runtime#982, #975) — a COMPILER, not a second runtime.
+*
+* `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.
+*
+* 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, 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";
+/** 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`);
+	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 } : {}
+	};
+}
+/** 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;
+}
+/** 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}`;
+}
+/** 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;
+}
+/**
+* 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).
+*/
+function createGraphRun(engine, spec, task, options) {
+	const compiled = asCompiled(engine, spec);
+	const wakes = [];
+	let signalWake = () => {};
+	let finished = false;
+	const done = runGraphLoop(engine, compiled, task, options, wakes, (fn) => {
+		signalWake = fn;
+	}).finally(() => {
+		finished = true;
+	});
+	const queue = (token, payload, expire) => {
+		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,
+				payload,
+				expire,
+				settle,
+				fail
+			});
+			signalWake();
+		});
+	};
+	return {
+		done,
+		resume: (token, payload) => queue(token, payload, false),
+		expire: (token) => queue(token, void 0, true)
+	};
+}
+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 (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 runId = options.runId ?? `graph:${contentAddress({ task }).slice(0, 18)}`;
+	let detachOuterAbort = () => {};
+	const context = await openGraphRun({
+		compiled,
+		runId,
+		budget: options.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 { abort, blobs, journal, scope, state } = context;
+	const ledger = createEdgeLedger({
+		journal,
+		runId,
+		now,
+		startSeq: context.ledgerSeq
+	});
+	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
+			}
+		};
+		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;
+			}
+			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
+		};
+	};
+	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: `graph:${nodeId}`,
+					edge: entry.edge.id,
+					fired: false,
+					sourceStatus: "done",
+					capped: true,
+					seq: engineSeq++,
+					at: stamp()
+				});
+				return;
+			}
+		}
+		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 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: stamp()
+			});
+		}
+		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 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
+				},
+				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.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;
+			}
+			instance.status = "down";
+			const label = `${instance.node}#${visit}`;
+			await emit({
+				kind: "node-inputs-resolved",
+				id: label,
+				node: instance.node,
+				instance: label,
+				inputRef: instance.inputRef,
+				seq: engineSeq++,
+				at: stamp()
+			});
+			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;
+				}
+				outCache.set(latest.outRef, out);
+				const node = compiled.nodes.get(nodeId);
+				await propagate(label, {
+					...latest,
+					out,
+					...node === void 0 ? {} : await checkDeliverable(node, out)
+				});
+				continue;
+			}
+			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;
+			}
+			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;
+		}
+		pendingNext ??= scope.next();
+		const raced = await Promise.race([pendingNext.then((settle) => ({ settle })), wakeSignal.then(() => "wake")]);
+		if (raced === "wake") {
+			rearmWakeSignal();
+			continue;
+		}
+		pendingNext = void 0;
+		if (raced.settle === null) break;
+		await handleSettle(raced.settle);
+		for (const label of waitingForBudget.splice(0)) await spawnInstance(label);
+	}
+	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, 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