@tangle-network/agent-runtime 0.164.0 → 0.166.0

package/dist/graph-E0U0c2YP.js

@@ -0,0 +1,2668 @@
+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 { f as harnessRunsAgent } from "./model-policy-Sw4ywhtL.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-C8kgh8mf.js";
+import { t as composeRuntimeHooks } from "./runtime-hooks-tXpAarhW.js";
+import { h as kernelPromptRegistry, i as workerFromBackend, m as formatPromptHandle, n as supervise, r as superviseWithTestBrain, s as supervisorAgent } from "./supervise-CnxqHx1P.js";
+import { agentProfileSchema, canonicalCandidateDigest } from "@tangle-network/agent-interface";
+//#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/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: 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.
+*/
+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 };
+		},
+		configSchema: {
+			type: "object",
+			properties: { graph: { type: "object" } },
+			required: ["graph"]
+		},
+		inputs: [],
+		outputs: [],
+		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`);
+		}
+	};
+}
+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/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/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/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/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}`)
+		});
+		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
+//#region src/runtime/graph/preset-run-graph.ts
+/**
+* The `runGraph` preset (agent-runtime#982, #975): today's `AgentGraph` compiled into an engine
+* graph and run by the engine. `runGraph` keeps its signature and becomes this call, so the six
+* consumers measured in #967 change nothing.
+*
+* WHAT THE ENGINE GRAPH LOOKS LIKE. One `supervisor` root carrying the whole graph, one pinned
+* `agent` node per worker, and the `delegates`/`analyzes` edges as authored. A `delegates` edge is
+* MODEL-fired (#971): its target is spawned by the supervisor through the coordination protocol,
+* with the node pin and the directive applied inside the kernel's authorized path. So the engine
+* schedules exactly one node — the supervisor — and the worker nodes are the declarative record of
+* what it may spawn. That record is what makes a `runGraph` graph a first-class engine graph:
+* compiled, type-checked, inspectable, and composable with `data` edges and `script` nodes.
+*
+* WHY THE ROOT NODE RUNS `superviseAgentGraph`. The engine's `supervisor` kind IS `supervisorAgent`
+* (#970), and the graph authority — pinning, the edge ledger, per-edge caps, continuity — already
+* lives in that one function. Executing it as the root node's body preserves every one of #967's
+* load-bearing properties by construction rather than by re-implementation.
+*/
+/** The preset's root kind: one node whose body is the graph's supervise run. */
+const RUN_GRAPH_KIND = "run-graph.supervisor";
+function spendOf(out) {
+	return (out.ok ? out.result.result.spentTotal : void 0) ?? {
+		iterations: 1,
+		tokens: {
+			input: 0,
+			output: 0
+		},
+		usd: 0,
+		ms: 0
+	};
+}
+/**
+* The node kind behind the preset. Its executor runs the graph and reports the run's own measured
+* spend, so the engine pool debits what the graph actually used, never a second copy of it.
+*/
+function runGraphKind() {
+	return {
+		id: RUN_GRAPH_KIND,
+		version: 1,
+		description: "One AgentGraph supervise run as an engine node (the runGraph preset).",
+		validateConfig: (raw, context) => {
+			if (typeof raw !== "object" || raw === null) throw new ValidationError(`${context}: config must carry { graph, options }`);
+			const config = raw;
+			if (config.graph === void 0 || config.options === void 0 || config.run === void 0 || config.capture === void 0) throw new ValidationError(`${context}: config must carry { graph, options, run, capture }`);
+			return config;
+		},
+		configSchema: {
+			type: "object",
+			properties: { graph: { type: "object" } },
+			required: ["graph"]
+		},
+		inputs: [],
+		outputs: [],
+		effects: [],
+		onCrash: "restart",
+		budget: "metered",
+		run: ({ config, profile }) => {
+			let artifact;
+			return {
+				name: profile.name ?? "graph",
+				act: () => Promise.reject(new ValidationError(`${RUN_GRAPH_KIND}: act() is not the execution path`)),
+				executorSpec: {
+					profile,
+					harness: null,
+					executor: {
+						runtime: "inline",
+						async execute() {
+							const out = await config.run(config.graph, config.options, config.brain).then((result) => ({
+								ok: true,
+								result
+							}), (error) => {
+								config.capture.error = error;
+								return {
+									ok: false,
+									error: String(error)
+								};
+							});
+							artifact = {
+								outRef: contentAddress({ runGraph: out.ok }),
+								out,
+								spent: spendOf(out)
+							};
+							return artifact;
+						},
+						teardown: () => Promise.resolve({ destroyed: true }),
+						resultArtifact: () => {
+							if (!artifact) throw new ValidationError(`${RUN_GRAPH_KIND}: resultArtifact() read before execute()`);
+							return artifact;
+						}
+					}
+				}
+			};
+		}
+	};
+}
+/** An engine with the preset kind registered beside the core `agent` kind the workers use. */
+function runGraphEngine() {
+	return createGraphEngine({ coreKinds: [agentKind({}), runGraphKind()] });
+}
+/**
+* Compile an `AgentGraph` into the engine graph that represents it: the supervisor root, one
+* pinned `agent` node per worker, and every authored edge. Pure — nothing runs, so a caller can
+* inspect, diff, or extend the result before handing it to the engine.
+*/
+function graphFromRunGraph(graph, options, run, capture = {}, brain) {
+	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_KIND}/v1`,
+			config: {
+				graph,
+				options,
+				run,
+				capture,
+				...brain !== void 0 ? { brain } : {}
+			},
+			profile: node.profile,
+			budget: graph.budget,
+			terminal: true,
+			deliverable: { check: (out) => out?.ok === true }
+		} : {
+			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
+	};
+}
+/**
+* Run an `AgentGraph` through the engine: compile it with {@link graphFromRunGraph}, schedule it,
+* and answer the caller in `runGraph`'s own vocabulary. A typed failure the graph threw — an
+* exhausted delegates cap — is rethrown as the exact error object it was, never flattened into a
+* settle reason.
+*/
+function runGraphThroughEngine(graph, options, run, brain) {
+	const engine = runGraphEngine();
+	const capture = {};
+	const spec = graphFromRunGraph(graph, options, run, capture, brain);
+	const root = spec.root;
+	const engineRunId = `${options.runId ?? contentAddress({ graph: root }).slice(0, 18)}:engine`;
+	return runEngineGraph(engine, compileGraph(engine, spec, "runGraph"), graphRootTask(graph), {
+		budget: graph.budget,
+		perNode: graph.budget,
+		...options.journal !== void 0 ? { journal: options.journal } : {},
+		...options.blobs !== void 0 ? { blobs: options.blobs } : {},
+		prompts: options.registry ?? kernelPromptRegistry(),
+		runId: engineRunId
+	}).then((finished) => mapEngineResult(finished, root, capture));
+}
+function mapEngineResult(run, root, capture) {
+	if (capture.error !== void 0) throw capture.error;
+	const out = run.settles.find((entry) => entry.node === root)?.out;
+	if (out === void 0) throw new ValidationError(`runGraph: the engine returned no settlement for root node '${root}' (${run.kind}${run.kind === "no-winner" ? `/${run.reason}` : ""})`);
+	if (!out.ok) throw new ValidationError(`runGraph: ${out.error}`);
+	return out.result;
+}
+/** The root's task line, as `runGraph` composes it today. */
+function graphRootTask(graph) {
+	const root = graph.nodes[0];
+	return root === void 0 ? "run the graph" : `run graph from '${root.id}'`;
+}
+//#endregion
+//#region src/runtime/supervise/graph.ts
+/**
+*
+* `runGraph` — agent graphs: profiles as nodes, registry-backed prompt directives as edges.
+*
+* A topology is PLAIN DATA an agent can author in a few lines: nodes are canonical
+* `AgentProfile`s (the ONLY way a node is described — no role-builder functions), edges are typed
+* values carrying versioned {@link PromptHandle} directives, `deliverable` (termination) and
+* `budget` (one conserved pool) are mandatory. Driver↔worker is the two-node cyclic instance;
+* "agent 3 analyzes 1 and 2 and reports to 1" is ONE edge, not a framework.
+*
+* NOT A SECOND SCHEDULER. `runGraph` is an interpretation layer over what already runs:
+* `supervise()` is the execution core — the same `supervisorAgent`/`driverAgent` machinery,
+* backend-derived worker path (authorized, classified, recursive), conserved-pool budget, and
+* deliverable-gated settlement every
+* supervised run uses. (`runAgentRounds` is deliberately NOT the substrate here.) What the graph
+* layer ADDS is exactly what a bespoke driver loop never
+* had:
+*
+*  1. **Node pinning** — a spawn names a node (`profile.name` = node id) and the node's canonical
+*     profile is what runs; a driver cannot smuggle capabilities into a worker it did not define.
+*  2. **Observable edges** — every delegates/analyzes traversal lands in an EDGE LEDGER
+*     (`delivered | stripped | empty | unpropagated`, with byte counts), in memory on
+*     the result AND as `edge` events in the run journal. The motivating incident: a filter
+*     silently replaced 1,700-char steering with 241 chars of boilerplate for three rounds and
+*     NO artifact said so — an unobservable edge cannot be trusted and its directive cannot be
+*     optimized.
+*  3. **Directives as data** — edge text lives in the prompt registry (`<surface>/v<n>`), so every
+*     edge is a versioned optimization target, never prose hardcoded in a builder function.
+*  4. **Per-edge traversal caps** — the cyclic-graph backstop. A delegates edge whose cap is
+*     exhausted REFUSES further traversals (fail loud), so a cycle cannot spin the pool dry.
+*  5. **Continuity as data** — a delegates edge may declare `continuity: 'resume'`, so each spawn
+*     after the node's first re-attaches to its latest SETTLED session (the spawn context hands
+*     the executor seam `resume: { ofWorker, sequence }`; the kernel keeps identity, ordering,
+*     ledger truth, and the one conserved pool). Every ledger row states how its hop continued:
+*     `'fresh' | 'resume'` for spawns, `'steer'` for mid-run deliveries — fresh respawns, session
+*     resumes, and live steers are all plain data, each a ledgered fact.
+*
+* ORACLES ARE ENVIRONMENT, NEVER WORKERS. Graders/verifiers must not be spawnable in the graph —
+* a delegates edge to them leaks the rubric. An `analyzes` edge names its analyst in one of two
+* forms: a LENS id from the environment's registry (a pure function over trace evidence), or the
+* id of a graph NODE — a tool-equipped analyst AGENT spawned on each matching settle with the
+* node's pinned profile, whose settle output IS the findings. Either way the oracle doctrine
+* holds: an analyst node can never be a delegates target (refused loudly), so no driver can hand
+* it work, and an id living in both the registry and the nodes is refused as ambiguous.
+*
+* @experimental
+*/
+/** Default per-edge traversal cap — the cyclic-graph backstop when an edge names none. */
+const defaultEdgeTraversalCap = 32;
+/** A delegates edge exhausted its traversal cap and the run produced no winner: the cap, not the
+*  task, ended it. Carries the full evidence so failing loud loses nothing. */
+var GraphEdgeCapError = class extends Error {
+	exhaustedEdges;
+	ledger;
+	result;
+	constructor(exhaustedEdges, ledger, result) {
+		super(`runGraph: edge traversal cap exhausted on ${exhaustedEdges.join(", ")} and the run delivered no winner — the cap (the cyclic-graph backstop), not the task, ended this run. Raise maxTraversals on the edge or fix the cycle; the full edge ledger and the supervised result ride on this error.`);
+		this.name = "GraphEdgeCapError";
+		this.exhaustedEdges = exhaustedEdges;
+		this.ledger = ledger;
+		this.result = result;
+	}
+};
+/**
+* Forwarded to the root `supervise()` VERBATIM. Everything not owned, transformed, or refused
+* above belongs here — the default is "a graph honors it", not "someone remembered to add it".
+*/
+const GRAPH_FORWARDED_SUPERVISE_OPTIONS = [
+	"backend",
+	"rootHandle",
+	"signal",
+	"execution",
+	"resolveDeliverable",
+	"coordination",
+	"peerMail",
+	"driverBackend",
+	"profileSecurity",
+	"authorizeSpawn",
+	"isDriverProfile",
+	"router",
+	"driveHarness",
+	"driverRetry",
+	"onDriverAttempt",
+	"childSettleGraceMs",
+	"resolveDriveHarness",
+	"driveHarnessMaterialization",
+	"resolveSupervisorTools",
+	"extraTools",
+	"executeExtraTool",
+	"perWorker",
+	"maxLiveWorkers",
+	"watchWorkers",
+	"stallAfterMs",
+	"runDir",
+	"probes",
+	"stopRule",
+	"onProgressStop",
+	"maxDepth",
+	"maxTurns",
+	"compaction",
+	"now",
+	"allowedModels",
+	"finalizer",
+	"otel"
+];
+/** Copy every forwarded option the caller actually set. Absent stays absent: `supervise()` and the
+*  graph must not disagree about what "unset" means. */
+function forwardedSuperviseOptions(opts) {
+	const forwarded = {};
+	for (const key of GRAPH_FORWARDED_SUPERVISE_OPTIONS) {
+		const value = opts[key];
+		if (value !== void 0) forwarded[key] = value;
+	}
+	return forwarded;
+}
+function edgeId(edge) {
+	return edge.kind === "delegates" ? `delegates:${edge.from}->${edge.to}` : `analyzes:${edge.analyst}:${edge.over.join("+")}->${edge.to}`;
+}
+/** Validate the graph and resolve every directive BEFORE any compute is spent — an invalid
+*  topology or an unknown directive is a configuration fault, never a mid-run surprise. */
+function validateGraph(graph, registry, analysts) {
+	if (!Array.isArray(graph.nodes) || graph.nodes.length === 0) throw new ValidationError("runGraph: graph.nodes must be a non-empty array");
+	if (!Array.isArray(graph.edges) || graph.edges.length === 0) throw new ValidationError("runGraph: graph.edges must be a non-empty array");
+	if (typeof graph.deliverable?.check !== "function") throw new ValidationError("runGraph: graph.deliverable is mandatory (termination oracle)");
+	if (typeof graph.budget !== "object" || graph.budget === null) throw new ValidationError("runGraph: graph.budget is mandatory (the conserved pool)");
+	const byId = /* @__PURE__ */ new Map();
+	for (const node of graph.nodes) {
+		if (typeof node.id !== "string" || node.id.length === 0) throw new ValidationError("runGraph: every node needs a non-empty string id");
+		if (byId.has(node.id)) throw new ValidationError(`runGraph: duplicate node id '${node.id}'`);
+		const parsed = agentProfileSchema.safeParse(node.profile);
+		if (!parsed.success) throw new ValidationError(`runGraph: node '${node.id}' has an invalid AgentProfile: ${parsed.error.message}`);
+		if (node.profile.name !== node.id) throw new ValidationError(`runGraph: node '${node.id}' has profile.name ${JSON.stringify(node.profile.name)} — profile.name IS the node identity (node pinning and analyst routing match on it) and must equal the node id`);
+		byId.set(node.id, node);
+	}
+	const requireNode = (id, where) => {
+		const node = byId.get(id);
+		if (!node) throw new ValidationError(`runGraph: ${where} references unknown node '${id}'`);
+		return node;
+	};
+	const delegates = graph.edges.filter((edge) => edge.kind === "delegates");
+	const analyzes = graph.edges.filter((edge) => edge.kind === "analyzes");
+	if (delegates.length === 0) throw new ValidationError("runGraph: at least one delegates edge is required (who spawns whom)");
+	for (const edge of graph.edges) registry.resolve(edge.directive);
+	for (const edge of delegates) {
+		requireNode(edge.from, edgeId(edge));
+		requireNode(edge.to, edgeId(edge));
+		if (edge.from === edge.to) throw new ValidationError(`runGraph: ${edgeId(edge)} delegates to itself — the driver↔worker cycle is the settle-return loop, not a self-edge`);
+		if (edge.continuity !== void 0 && edge.continuity !== "fresh" && edge.continuity !== "resume") throw new ValidationError(`runGraph: ${edgeId(edge)} has invalid continuity ${JSON.stringify(edge.continuity)} — a delegates edge's continuity is 'fresh' or 'resume'`);
+	}
+	const delegatedTo = new Set(delegates.map((edge) => edge.to));
+	const roots = [...new Set(delegates.map((edge) => edge.from))].filter((id) => !delegatedTo.has(id));
+	if (roots.length !== 1) throw new ValidationError(`runGraph: expected exactly ONE root (a node that delegates and is never delegated to), found ${roots.length === 0 ? "none — delegates edges form a cycle with no entry" : roots.join(", ")}. P0 executes driver↔worker(s); nested driver graphs are P3.`);
+	const root = requireNode(roots[0], "root resolution");
+	for (const edge of delegates) if (edge.from !== root.id) throw new ValidationError(`runGraph: ${edgeId(edge)} delegates from a non-root node — P0 executes one driver over its workers (the 2-node cyclic case, star-generalized); deeper delegation is P3`);
+	const analystIds = /* @__PURE__ */ new Set();
+	const analystNodes = /* @__PURE__ */ new Map();
+	for (const edge of analyzes) {
+		if (edge.continuity !== void 0) throw new ValidationError(`runGraph: ${edgeId(edge)} carries continuity — analysts are spawned by the analyst machinery (every analyst run is a fresh session over settled evidence), so continuity is a delegates-edge axis only`);
+		if (analystIds.has(edge.analyst)) throw new ValidationError(`runGraph: two analyzes edges share analyst '${edge.analyst}' — one analyzes edge per analyst lens (traversals are ledgered by analyst id; a second edge would silently absorb the first's). Register the lens under a second id for a second edge.`);
+		analystIds.add(edge.analyst);
+		const analystNode = byId.get(edge.analyst);
+		const inRegistry = analysts?.kinds.some((kind) => kind.id === edge.analyst) === true;
+		if (analystNode !== void 0 && inRegistry) throw new ValidationError(`runGraph: ${edgeId(edge)} analyst '${edge.analyst}' is BOTH a graph node and a lens in the analysts registry — the id alone distinguishes the two analyst forms, so this is ambiguous; rename the node or register the lens under another id`);
+		if (analystNode !== void 0) {
+			if (analystNode.id === root.id) throw new ValidationError(`runGraph: ${edgeId(edge)} names the ROOT as its analyst — the root is the driver; give the analyst its own node with no delegates edge pointing at it`);
+			if (delegatedTo.has(analystNode.id)) throw new ValidationError(`runGraph: ${edgeId(edge)} names node '${edge.analyst}' as its analyst, but that node is a delegates target — oracle doctrine: an analyst is never delegated to. An analyst NODE is legal only with NO delegates edge pointing at it; give the analyst its own delegates-free node or pass a lens id from RunGraphOptions.analysts.`);
+			analystNodes.set(analystNode.id, analystNode);
+		} else if (!analysts) throw new ValidationError(`runGraph: ${edgeId(edge)} analyst '${edge.analyst}' is not a graph node, and no RunGraphOptions.analysts registry was provided to resolve it as a lens`);
+		else if (!inRegistry) throw new ValidationError(`runGraph: ${edgeId(edge)} analyst '${edge.analyst}' is neither a graph node nor in the analysts registry (known lenses: ${analysts.kinds.map((kind) => kind.id).join(", ") || "none"})`);
+		if (edge.over.length === 0) throw new ValidationError(`runGraph: ${edgeId(edge)} must analyze at least one node`);
+		for (const over of edge.over) {
+			requireNode(over, edgeId(edge));
+			if (over === root.id) throw new ValidationError(`runGraph: ${edgeId(edge)} analyzes the ROOT — analysts observe settled workers, and the root never settles as one, so this edge would silently never fire; list delegates-target nodes only`);
+		}
+		requireNode(edge.to, edgeId(edge));
+	}
+	for (const edge of analyzes) for (const over of edge.over) if (analystNodes.has(over)) throw new ValidationError(`runGraph: ${edgeId(edge)} analyzes '${over}', which is an analyst node — an analyst run settles as a finding, never as a worker, so this edge would silently never fire; analyst nodes are not analyzable`);
+	const workers = /* @__PURE__ */ new Map();
+	const delegatesByWorker = /* @__PURE__ */ new Map();
+	for (const edge of delegates) {
+		if (delegatesByWorker.has(edge.to)) throw new ValidationError(`runGraph: node '${edge.to}' is the target of two delegates edges — one delegation directive per worker node (version the directive instead of forking the edge)`);
+		delegatesByWorker.set(edge.to, edge);
+		workers.set(edge.to, requireNode(edge.to, edgeId(edge)));
+	}
+	for (const node of graph.nodes) if (node.id !== root.id && !workers.has(node.id) && !analystNodes.has(node.id)) throw new ValidationError(`runGraph: node '${node.id}' has no delegates edge to it — an unreachable node never runs`);
+	return {
+		root,
+		workers,
+		delegatesByWorker,
+		analyzes,
+		analystNodes
+	};
+}
+const byteLength = (text) => Buffer.byteLength(text, "utf8");
+function stringifyPayload(payload) {
+	if (typeof payload === "string") return payload;
+	try {
+		return JSON.stringify(payload) ?? String(payload);
+	} catch {
+		return String(payload);
+	}
+}
+/**
+* Execute an {@link AgentGraph}. The root node becomes the supervisor (`supervise()` — the
+* execution core), each worker node is spawnable BY NODE ID (`spawn_agent` with
+* `profile: { name: '<node id>' }`; the node's canonical profile is pinned by the graph), each
+* delegates directive is appended to the worker profile's `prompt.instructions` per traversal,
+* and each analyzes edge becomes an analyst-on-settle route with a real DESTINATION. Every
+* traversal is ledgered and journaled.
+*/
+function runGraph(graph, opts) {
+	const { brain, ...runtimeOptions } = opts;
+	assertRunGraphAuthoring(graph, runtimeOptions, brain);
+	return runGraphThroughEngine(graph, runtimeOptions, superviseAgentGraph, brain);
+}
+/** Alias for graph tests written before `RunGraphOptions.brain` was production. The production
+*  entry accepts the same shape; this wrapper only keeps the `/testing` import path working. */
+function runGraphWithTestBrain(graph, opts) {
+	const { brain, ...runtimeOptions } = opts;
+	assertRunGraphAuthoring(graph, runtimeOptions, brain);
+	return runGraphThroughEngine(graph, runtimeOptions, superviseAgentGraph, brain);
+}
+/**
+* The graph supervise run, as its own entry: the engine's `run-graph` preset node executes exactly
+* this, so the preset and `runGraph` are the same code path by construction (agent-runtime#982).
+*/
+/**
+* Every refusal a graph earns before any compute, in one place: the authoring contract. `runGraph`
+* calls it FIRST so a malformed graph throws synchronously, exactly as it did before the engine
+* preset (agent-runtime#982) moved execution behind a promise.
+*/
+function assertRunGraphAuthoring(graph, opts, brain) {
+	const validated = validateGraph(graph, opts.registry ?? kernelPromptRegistry(), opts.analysts);
+	const { root } = validated;
+	if (brain && opts.driverBackend) throw new ValidationError("runGraph: brain and driverBackend are mutually exclusive — a caller brain makes the root model calls, a driverBackend places a harness that makes its own");
+	if (brain && harnessRunsAgent(root.profile.harness)) throw new ValidationError(`runGraph: root node '${root.id}' declares harness '${root.profile.harness}', so the harness drives it — a caller brain applies only to a router-brained root (profile.harness omitted or 'cli-base')`);
+	if (!opts.backend && !opts.makeLeafAgent) throw new ValidationError("runGraph: provide opts.backend (where nodes run) or opts.makeLeafAgent");
+	return validated;
+}
+function superviseAgentGraph(graph, opts, brain) {
+	const registry = opts.registry ?? kernelPromptRegistry();
+	const { root, workers, delegatesByWorker, analyzes, analystNodes } = assertRunGraphAuthoring(graph, opts, brain);
+	const journal = opts.journal ?? new InMemorySpawnJournal();
+	const blobs = opts.blobs ?? new InMemoryResultBlobStore();
+	const runId = opts.runId ?? `graph-${canonicalCandidateDigest(graph.nodes.map((n) => n.id)).slice(7, 19)}`;
+	const now = opts.now ?? Date.now;
+	const ledger = [];
+	const journaled = /* @__PURE__ */ new Set();
+	const traversalCounts = /* @__PURE__ */ new Map();
+	const exhausted = /* @__PURE__ */ new Set();
+	const exhaustedDelegates = /* @__PURE__ */ new Set();
+	const journalWrites = [];
+	let ledgerSeq = 0;
+	const appendJournal = (entry, nodeIdForEvent) => {
+		if (journaled.has(entry)) return Promise.resolve();
+		journaled.add(entry);
+		const write = journal.appendEvent(runId, {
+			kind: "edge",
+			id: nodeIdForEvent,
+			edge: {
+				kind: entry.kind,
+				from: entry.from,
+				to: entry.to,
+				directive: entry.directive
+			},
+			traversal: entry.traversal,
+			outcome: entry.outcome,
+			continuity: entry.continuity,
+			bytes: entry.bytes,
+			...entry.reason !== void 0 ? { reason: entry.reason } : {},
+			seq: ledgerSeq++,
+			at: new Date(now()).toISOString()
+		});
+		journalWrites.push(write);
+		return write;
+	};
+	const record = (entry, journalNow) => {
+		const count = (traversalCounts.get(entry.edge) ?? 0) + 1;
+		traversalCounts.set(entry.edge, count);
+		const row = {
+			...entry,
+			traversal: count
+		};
+		ledger.push(row);
+		if (journalNow) appendJournal(row, row.workerId ?? `graph:${row.to}`);
+		return row;
+	};
+	const nodeByWorkerId = /* @__PURE__ */ new Map();
+	const pendingByAssignment = /* @__PURE__ */ new Map();
+	const pinNode = (input) => {
+		const requested = typeof input.profile?.name === "string" ? input.profile.name : void 0;
+		if (input.analyst !== void 0) {
+			const analystNode = analystNodes.get(input.analyst);
+			if (!analystNode || requested !== analystNode.id) throw new ValidationError(`runGraph: analyst run for ${JSON.stringify(input.analyst)} does not name an analyst node of this graph (analyst nodes: ${[...analystNodes.keys()].join(", ") || "none"})`);
+			return analystNode.profile;
+		}
+		const node = requested !== void 0 ? workers.get(requested) : void 0;
+		if (!node) throw new ValidationError(`runGraph: spawn_agent named profile ${JSON.stringify(requested)} which is not a worker node of this graph (nodes: ${[...workers.keys()].join(", ")}). Spawn by node id: profile.name selects the node; the node profile itself is pinned by the graph.`);
+		const edge = delegatesByWorker.get(node.id);
+		const id = edgeId(edge);
+		const cap = edge.maxTraversals ?? 32;
+		const used = traversalCounts.get(id) ?? 0;
+		const spawnContinuity = input.continuity ?? "fresh";
+		if (used >= cap) {
+			exhausted.add(id);
+			exhaustedDelegates.add(id);
+			record({
+				edge: id,
+				kind: "delegates",
+				from: edge.from,
+				to: edge.to,
+				directive: formatPromptHandle(edge.directive),
+				outcome: "unpropagated",
+				continuity: spawnContinuity,
+				bytes: 0,
+				reason: `traversal-cap-exhausted (max ${cap})`
+			}, true);
+			throw new ValidationError(`runGraph: delegates edge ${id} exhausted its traversal cap (${cap}) — the cyclic-graph backstop refused this spawn`);
+		}
+		const directiveText = registry.resolve(edge.directive).text;
+		const taskText = stringifyPayload(input.task);
+		const bytes = byteLength(directiveText) + byteLength(taskText);
+		const row = record({
+			edge: id,
+			kind: "delegates",
+			from: edge.from,
+			to: edge.to,
+			directive: formatPromptHandle(edge.directive),
+			outcome: bytes === 0 ? "empty" : "delivered",
+			continuity: spawnContinuity,
+			bytes,
+			...bytes === 0 ? { reason: "no directive text and no task payload" } : {}
+		}, false);
+		pendingByAssignment.set(input.assignmentId, row);
+		return directiveText.length === 0 ? node.profile : {
+			...node.profile,
+			prompt: {
+				...node.profile.prompt ?? {},
+				instructions: [...node.profile.prompt?.instructions ?? [], directiveText]
+			}
+		};
+	};
+	const resolveSpawnProfile = (authored) => {
+		const requested = typeof authored.name === "string" ? authored.name : void 0;
+		return ((requested !== void 0 ? workers.get(requested) : void 0) ?? (requested !== void 0 ? analystNodes.get(requested) : void 0))?.profile ?? authored;
+	};
+	const graphAuthorizeSpawn = (input) => {
+		const pinned = pinNode(input);
+		if (!opts.authorizeSpawn) return { profile: pinned };
+		return opts.authorizeSpawn({
+			...input,
+			profile: pinned
+		});
+	};
+	const routes = analyzes.map((edge) => {
+		const analystNode = analystNodes.get(edge.analyst);
+		if (analystNode) return {
+			kind: edge.analyst,
+			over: edge.over,
+			agent: analystNode.profile,
+			directive: registry.resolve(edge.directive).text,
+			...edge.to === root.id ? {} : { to: edge.to }
+		};
+		return edge.to === root.id ? {
+			kind: edge.analyst,
+			over: edge.over
+		} : {
+			kind: edge.analyst,
+			over: edge.over,
+			to: edge.to,
+			directive: registry.resolve(edge.directive).text
+		};
+	});
+	const driverAnalyzesBriefs = analyzes.filter((edge) => edge.to === root.id).map((edge) => analystNodes.has(edge.analyst) ? `Findings from analyst '${edge.analyst}' (a tool-equipped analyst agent node, over: ${edge.over.join(", ")}) will arrive as finding events.` : `Findings from analyst '${edge.analyst}' (over: ${edge.over.join(", ")}) will arrive as finding events.\n${registry.resolve(edge.directive).text}`);
+	const continuityByProfile = {};
+	for (const [nodeId, edge] of delegatesByWorker) if (edge.continuity !== void 0) continuityByProfile[nodeId] = edge.continuity;
+	const graphBrief = [
+		"AGENT GRAPH: you are the driver node of a fixed topology. You may spawn ONLY these worker",
+		"nodes, by EXACT name (spawn_agent with profile: { name: '<node id>' }; the node's full",
+		"profile is pinned by the graph — any other profile fields you author are ignored):",
+		...[...workers.values()].map((node) => {
+			const edge = delegatesByWorker.get(node.id);
+			const cap = edge.maxTraversals ?? 32;
+			const description = typeof node.profile.description === "string" && node.profile.description.length > 0 ? ` — ${node.profile.description}` : "";
+			const continuityNote = edge.continuity === "resume" ? "; continuity: resume — each spawn after the first re-attaches to this node's latest settled session (spawn again to continue it; steer while it is live)" : "";
+			return `- '${node.id}'${description} (delegation cap: ${cap} traversals${continuityNote})`;
+		}),
+		...driverAnalyzesBriefs.length > 0 ? ["", ...driverAnalyzesBriefs] : []
+	].join("\n");
+	const rootProfile = {
+		...root.profile,
+		prompt: {
+			...root.profile.prompt ?? {},
+			instructions: [...root.profile.prompt?.instructions ?? [], graphBrief]
+		}
+	};
+	const strippedByDigest = /* @__PURE__ */ new Map();
+	const authorizeMessage = (input) => {
+		if (!opts.authorizeMessage) return { instruction: input.instruction };
+		const decision = opts.authorizeMessage(input);
+		if (decision.instruction !== input.instruction) strippedByDigest.set(canonicalCandidateDigest(decision.instruction), { composedBytes: byteLength(input.instruction) });
+		return decision;
+	};
+	const routedAnalyzesByAnalyst = /* @__PURE__ */ new Map();
+	const driverAnalyzesByAnalyst = /* @__PURE__ */ new Map();
+	for (const edge of analyzes) (edge.to === root.id ? driverAnalyzesByAnalyst : routedAnalyzesByAnalyst).set(edge.analyst, edge);
+	const analyzesCapReached = (edge) => {
+		const cap = edge.maxTraversals ?? 32;
+		if ((traversalCounts.get(edgeId(edge)) ?? 0) < cap) return false;
+		exhausted.add(edgeId(edge));
+		return true;
+	};
+	const ledgerAnalyzes = (edge, outcome, bytes, reason, workerId) => {
+		const capped = analyzesCapReached(edge);
+		record({
+			edge: edgeId(edge),
+			kind: "analyzes",
+			from: edge.over.join("+"),
+			to: edge.to,
+			directive: formatPromptHandle(edge.directive),
+			outcome: capped ? "unpropagated" : outcome,
+			continuity: "steer",
+			bytes,
+			...capped ? { reason: `traversal-cap-exhausted (max ${edge.maxTraversals ?? 32})` } : reason !== void 0 ? { reason } : {},
+			...workerId !== void 0 ? { workerId } : {}
+		}, true);
+	};
+	const onCoordinationEvent = async (_context, _eventId, recordEnvelope) => {
+		const event = recordEnvelope.event;
+		if (event.type === "finding") {
+			const edge = driverAnalyzesByAnalyst.get(event.finding.analyst);
+			if (!edge) return;
+			const sourceNode = nodeByWorkerId.get(event.finding.fromWorker);
+			if (sourceNode === void 0 || !edge.over.includes(sourceNode)) return;
+			const findingsText = event.finding.findings === void 0 ? "" : stringifyPayload(event.finding.findings);
+			const directiveBytes = byteLength(registry.resolve(edge.directive).text);
+			const empty = findingsText.length === 0;
+			ledgerAnalyzes(edge, empty ? "empty" : "delivered", directiveBytes + byteLength(findingsText), empty ? "analyst returned no findings" : void 0, event.finding.fromWorker);
+			return;
+		}
+		if (event.type === "steer") {
+			const down = event.down;
+			if (event.analyst !== void 0) {
+				const edge = routedAnalyzesByAnalyst.get(event.analyst);
+				if (!edge) return;
+				ledgerAnalyzes(edge, down.delivered ? "delivered" : "unpropagated", byteLength(down.instruction), down.delivered ? void 0 : down.outcome, down.toWorker);
+				return;
+			}
+			const nodeId = nodeByWorkerId.get(down.toWorker);
+			if (nodeId === void 0) return;
+			const edge = delegatesByWorker.get(nodeId);
+			if (!edge) return;
+			const stripped = strippedByDigest.get(down.instructionDigest);
+			record({
+				edge: edgeId(edge),
+				kind: "delegates",
+				from: edge.from,
+				to: edge.to,
+				directive: formatPromptHandle(edge.directive),
+				outcome: !down.delivered ? "unpropagated" : stripped ? "stripped" : "delivered",
+				continuity: "steer",
+				bytes: byteLength(down.instruction),
+				...!down.delivered ? { reason: down.outcome } : stripped ? { reason: `authorization narrowed ${stripped.composedBytes} composed bytes` } : {},
+				workerId: down.toWorker
+			}, true);
+		}
+	};
+	const hooks = composeRuntimeHooks({ onEvent: (event) => {
+		if (event.target !== "agent.spawn" || event.phase !== "after") return;
+		const payload = event.payload;
+		if (typeof payload?.childId !== "string" || typeof payload.assignmentId !== "string") return;
+		const pending = pendingByAssignment.get(payload.assignmentId);
+		if (!pending) return;
+		pendingByAssignment.delete(payload.assignmentId);
+		const bound = {
+			...pending,
+			workerId: payload.childId
+		};
+		ledger[ledger.indexOf(pending)] = bound;
+		nodeByWorkerId.set(payload.childId, bound.to);
+		return appendJournal(bound, payload.childId);
+	} }, opts.hooks);
+	const start = async () => {
+		const superviseOptions = {
+			...forwardedSuperviseOptions(opts),
+			rootDriverFromBackend: false,
+			budget: graph.budget,
+			deliverable: graph.deliverable,
+			authorizeSpawn: graphAuthorizeSpawn,
+			resolveSpawnProfile,
+			...opts.makeLeafAgent ? { makeLeafAgent: opts.makeLeafAgent } : {},
+			journal,
+			blobs,
+			runId,
+			hooks,
+			onCoordinationEvent,
+			...routes.length > 0 ? {
+				analyzeOnSettle: routes,
+				...opts.analysts ? { analysts: opts.analysts } : {}
+			} : {},
+			...Object.keys(continuityByProfile).length > 0 ? { continuityByProfile } : {},
+			authorizeMessage
+		};
+		const result = brain === void 0 ? await supervise(rootProfile, graphTask(graph, root), superviseOptions) : await superviseWithTestBrain(rootProfile, graphTask(graph, root), {
+			...superviseOptions,
+			brain
+		});
+		for (const pending of pendingByAssignment.values()) {
+			const refused = {
+				...pending,
+				outcome: "unpropagated",
+				bytes: 0,
+				reason: `no-live-worker-bound (spawn refused after the factory, or a keyed re-spawn deduplicated to a completed result; ${pending.bytes} composed bytes never crossed)`
+			};
+			ledger[ledger.indexOf(pending)] = refused;
+			await appendJournal(refused, `graph:${refused.to}`);
+		}
+		pendingByAssignment.clear();
+		await Promise.all(journalWrites);
+		const exhaustedEdges = Object.freeze([...exhausted]);
+		const frozenLedger = Object.freeze(ledger.map((row) => Object.freeze({ ...row })));
+		const lifecycleEnded = result.kind === "no-winner" && (result.reason === "aborted" || result.reason === "budget-exhausted");
+		if (result.kind !== "winner" && !lifecycleEnded && exhaustedDelegates.size > 0) throw new GraphEdgeCapError(Object.freeze([...exhaustedDelegates]), frozenLedger, result);
+		return {
+			result,
+			ledger: frozenLedger,
+			exhaustedEdges,
+			runId
+		};
+	};
+	return start();
+}
+/** The root task: the graph's own framing. The deliverable (mandatory) is the termination; the
+*  task names what the topology exists to produce. */
+function graphTask(graph, root) {
+	return graph.deliverable.describe ?? `Deliver the graph's deliverable by driving your worker nodes (root: '${root.id}').`;
+}
+//#endregion
+export { supervisorKind as A, MAX_MAX_NODE_VISITS as B, applyGraphFoldEvent as C, agentKind as D, admitPayload as E, compileGraph as F, validateProjection as G, formatRegistryHandle as H, isEngineFired as I, validateCondition as J, CONDITION_OPS as K, schemaAccepts as L, kindHandle as M, narrowEffects as N, scriptKind as O, validateNodeKind as P, DEFAULT_MAX_NODE_VISITS as R, decideJoin as S, foldGraphJournal as T, parseRegistryHandle as U, createRegistry as V, applyProjection as W, ENGINE_WOKEN_SEQ_BASE as _, RUN_GRAPH_KIND as a, materializeSettles as b, runGraphKind as c, runEngineGraph as d, isSuspensionRequest as f, tokenFromSuspensionNodeId as g, suspensionNodeId as h, runGraphWithTestBrain as i, createGraphEngine as j, subgraphKind as k, runGraphThroughEngine as l, suspended as m, defaultEdgeTraversalCap as n, graphFromRunGraph as o, mintSuspensionToken as p, evaluateCondition as q, runGraph as r, runGraphEngine as s, GraphEdgeCapError as t, createGraphRun as u, openGraphRun as v, emptyFoldState as w, createEdgeLedger as x, assembleGraphResult as y, JOIN_RULES as z };
+
+//# sourceMappingURL=graph-E0U0c2YP.js.map