@tangle-network/agent-runtime 7.0.0 → 8.0.1

package/dist/graph-BjQF2syl.js

@@ -1,579 +0,0 @@
-import { Wr as runtimeFlowBrain } from "./supervisor-accounting-DxLQ_TQe.js";
-import { i as ConfigError, m as ValidationError } from "./errors-AzSuGI23.js";
-import { M as contentAddress } from "./failure-cause-rJTm_Tx8.js";
-import { zt as defaultRunCommand } from "./supervisor-gC-u_PRk.js";
-import { v as harnessRunsAgent } from "./model-policy-JOcg3NRs.js";
-import { a as readCommittedJsonLines, c as appendCommittedJsonLine, s as withJsonlFileLock } from "./jsonl-file-DsxVI0E_.js";
-import { t as composeRuntimeHooks } from "./runtime-hooks-CsW2pfFk.js";
-import { f as createFileRunContext, m as withRunContext, p as createInMemoryRunContext } from "./coordination-manager-DQZ2u6L-.js";
-import { M as kernelPromptRegistry, S as validateFlowGraph, T as validateGraphTopology, _ as GraphRouteError, b as journaledGateDecider, g as createGraphOverlay, i as profileGuidanceComposer, r as superviseWithTestBrain, t as supervise, v as createFlowRun, w as graphRootProfile, x as routeFlowOf, y as flowRootProfile } from "./supervise-xwl2D6q3.js";
-import { canonicalCandidateDigest } from "@tangle-network/agent-interface";
-import { mkdirSync, realpathSync } from "node:fs";
-import { isAbsolute, join, relative, resolve } from "node:path";
-// src/runtime/supervise/graph-backend.ts
-/** Graph nodes expose JSON outputs through Runtime's resumable execution transports. */
-function graphExecutionOptions(options) {
-	if (options.makeLeafAgent) return options;
-	const backend = options.backend;
-	if (backend) return backend.backend === "bridge" || backend.backend === "provider" ? {
-		...options,
-		backend: {
-			...backend,
-			outputFormat: "json"
-		}
-	} : options;
-	const bridgeUrl = process.env.CLI_BRIDGE_URL;
-	const bridgeBearer = process.env.BRIDGE_BEARER ?? process.env.CLI_BRIDGE_BEARER;
-	if (!bridgeUrl || !bridgeBearer) throw new ValidationError("runGraph: start CLI Bridge and supply backend: { backend: \"bridge\", bridgeUrl, bridgeBearer, cwd }, or configure CLI_BRIDGE_URL and BRIDGE_BEARER");
-	return {
-		...options,
-		backend: {
-			backend: "bridge",
-			bridgeUrl,
-			bridgeBearer,
-			cwd: process.cwd(),
-			outputFormat: "json"
-		}
-	};
-}
-// src/runtime/supervise/stored-graph-check.ts
-/** Driver-owned journal identity. Worker output never supplies any part of this authority. */
-function receiptKey(receipt) {
-	return contentAddress({
-		binding: receipt.binding,
-		checkDigest: receipt.checkDigest,
-		nodeName: receipt.nodeName,
-		nodeId: receipt.nodeId,
-		attemptId: receipt.attemptId,
-		outputDigest: receipt.outputDigest
-	});
-}
-function isReceipt(value) {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-	const row = value;
-	if (row.version !== 1 || ![
-		"key",
-		"binding",
-		"checkDigest",
-		"nodeName",
-		"nodeId",
-		"attemptId",
-		"outputDigest",
-		"output"
-	].every((key) => typeof row[key] === "string") || !row.nodeName || !row.nodeId || !row.attemptId || !(row.exitCode === null || Number.isSafeInteger(row.exitCode)) || typeof row.outputTruncated !== "boolean" || typeof row.nativeValid !== "boolean" || typeof row.valid !== "boolean") return false;
-	const receipt = value;
-	return receipt.key === receiptKey(receipt) && receipt.valid === (receipt.exitCode === 0 && receipt.nativeValid);
-}
-function within(directory, path) {
-	const offset = relative(directory, path);
-	return offset === "" || !isAbsolute(offset) && offset !== ".." && !offset.startsWith("../");
-}
-/** Lower a named check onto the local workspace, with evidence in the driver's durable state.
-* The run directory has the same trust boundary as RunContext journals: keep it outside the
-* worker workspace and do not mount it into the worker. A remote Bridge cannot run a host check.
-* Provider validators are refused because their context does not identify the admitted node.
-*/
-function bindGraphCommand(graph, options) {
-	const { command: definition, ...deliverable } = graph.deliverable;
-	if (!definition) return {
-		graph,
-		options
-	};
-	const { command, timeoutMs = 6e4 } = definition;
-	if (!command.trim() || !Number.isSafeInteger(timeoutMs) || timeoutMs <= 0) throw new ValidationError("graphFromStored: command check needs a command and positive timeoutMs");
-	const backend = options.backend;
-	if (options.makeLeafAgent || !backend) throw new ValidationError("runGraph: command checks require an explicit execution backend");
-	const workspace = backend.backend === "bridge" ? backend.cwd : backend.backend === "cli-in-place" ? backend.workspacePath : void 0;
-	if (!workspace || backend.backend === "bridge" && ![
-		"localhost",
-		"127.0.0.1",
-		"[::1]"
-	].includes(new URL(backend.bridgeUrl).hostname)) throw new ValidationError("runGraph: command checks require a loopback Bridge or local CLI workspace; provider node binding is unsupported");
-	if (!options.runDir) throw new ValidationError("runGraph: command checks require a driver-owned runDir outside the workspace");
-	const cwd = realpathSync(workspace);
-	mkdirSync(options.runDir, { recursive: true });
-	const runDir = realpathSync(options.runDir);
-	if (within(cwd, runDir)) throw new ValidationError("runGraph: command check runDir must be outside the worker workspace");
-	const file = join(runDir, "command-checks.jsonl");
-	const checkDigest = contentAddress({
-		command,
-		timeoutMs,
-		cwd
-	});
-	const binding = contentAddress({
-		graph: {
-			...graph,
-			deliverable: {
-				...deliverable,
-				check: void 0
-			}
-		},
-		runId: options.runId ?? options.runContext?.runId,
-		checkDigest
-	});
-	const nodeNames = new Set(graph.nodes.map((node) => node.id));
-	const checkFinal = async (out) => {
-		if (!out || typeof out !== "object" || Array.isArray(out)) return false;
-		const entries = Object.entries(out);
-		if (entries.length === 0 || entries.some(([name]) => !nodeNames.has(name))) return false;
-		return withJsonlFileLock(file, async (canonicalPath) => {
-			if (within(cwd, canonicalPath)) return false;
-			const latest = /* @__PURE__ */ new Map();
-			for await (const raw of readCommittedJsonLines(canonicalPath, { allowMissing: true })) {
-				if (!isReceipt(raw)) return false;
-				if (raw.binding !== binding || raw.checkDigest !== checkDigest) continue;
-				latest.set(contentAddress([raw.nodeName, raw.outputDigest]), raw);
-			}
-			return entries.every(([name, output]) => latest.get(contentAddress([name, contentAddress(output)]))?.valid === true);
-		});
-	};
-	const checkLeaf = async (out, context) => {
-		const node = context.node;
-		const nodeName = context.profile.name;
-		if (!node || !node.nodeId || !node.attemptId || !nodeName || !nodeNames.has(nodeName)) return false;
-		const outputDigest = contentAddress(out);
-		let result;
-		try {
-			result = await defaultRunCommand({
-				command,
-				cwd,
-				timeoutMs,
-				signal: context.signal
-			});
-		} catch (error) {
-			result = {
-				exitCode: null,
-				output: error instanceof Error ? error.message : String(error)
-			};
-		}
-		const bytes = Buffer.from(result.output);
-		const limit = 65536;
-		const receipt = {
-			version: 1,
-			binding,
-			checkDigest,
-			nodeName,
-			nodeId: node.nodeId,
-			attemptId: node.attemptId,
-			outputDigest,
-			exitCode: result.exitCode,
-			output: bytes.subarray(0, limit).toString("utf8"),
-			outputTruncated: bytes.length > limit,
-			nativeValid: context.originalVerdict?.valid !== false,
-			valid: result.exitCode === 0 && context.originalVerdict?.valid !== false
-		};
-		await withJsonlFileLock(file, async (canonicalPath) => {
-			if (within(cwd, canonicalPath)) throw new ValidationError("runGraph: command receipt journal resolves inside worker workspace");
-			await appendCommittedJsonLine(canonicalPath, {
-				...receipt,
-				key: receiptKey(receipt)
-			});
-		});
-		return receipt.valid;
-	};
-	return {
-		graph: {
-			...graph,
-			deliverable: {
-				...deliverable,
-				check: (out, context) => context === void 0 ? checkFinal(out) : checkLeaf(out, context)
-			}
-		},
-		options
-	};
-}
-// 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/maps/routes traversal lands in an EDGE LEDGER
-*     (`delivered | stripped | empty | unpropagated | failed`, 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.
-*  6. **Fan-out over a run-time list** — a `maps` edge takes the array a JSON pointer selects in a
-*     node's settled result and runs one item per element, then hands the ordered results to a
-*     join node. The runtime spawns every item and the join when the source settles, so the
-*     driver spends no model turn on them; each item is a spawn through the same authorized path,
-*     reserving from the same conserved pool, and every expansion, item and join is a ledger row.
-*  7. **Flow graphs** — with `entry` set, no node is a root: Runtime spawns the entries and fires
-*     `routes` edges on each settle (`graph-flow.ts`), so a fixed order, a branch, a bounded repair
-*     loop and a stop rule are graph data. The root manager is Runtime's own and never calls a
-*     model; every entry and route spawn takes the same authorized path a map item takes.
-*
-* 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
-*/
-/** 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;
-	}
-};
-/**
-* Every `SuperviseOptions` key, partitioned by what `runGraph` does with it.
-*
-* `runGraph` starts one `supervise()` run, so every option that run honors is a graph option too
-* unless the graph itself owns the value. This used to be an opt-in list written by hand, and the
-* hand lost: 25 of 49 keys never reached `supervise()` from a graph, including `childSettleGraceMs`
-* (a root-driver failure tore down children that had ALREADY computed the deliverable) and
-* `driverRetry` (agent-runtime#963). Each absence was discovered by losing a run.
-*
-* The four lists below must cover `keyof SuperviseOptions` exactly. `everySuperviseOptionIsClassified`
-* below fails to COMPILE, naming the offender, when a key belongs to none of them — so the next
-* option added to `supervise()` cannot go missing here silently. It has to be classified, and
-* classifying it as forwarded is one word.
-*/
-/** The graph derives these from the `AgentGraph` itself; a caller value would be overwritten. */
-const GRAPH_OWNED_SUPERVISE_OPTIONS = [
-	"rootDriverFromBackend",
-	"resolveSpawnProfile",
-	"budget",
-	"deliverable",
-	"makeWorkerAgent",
-	"onCoordinationEvent",
-	"analyzeOnSettle",
-	"mapOnSettle",
-	"routeFlow",
-	"continuityByProfile",
-	"inheritSpawnRights",
-	"promptRegistry"
-];
-/** Caller-facing on `RunGraphOptions`, but the graph wraps or defaults the value before it goes in:
-*  `hooks` composes with the graph's own spawn-binding hook, `authorizeMessage` is wrapped so a
-*  narrowed instruction ledgers `stripped`, `authorizeSpawn` runs AFTER the graph has pinned the
-*  node (so a product sees the canonical profile, never the driver's stub), `makeLeafAgent` is the
-*  caller's leaf override slotted under the graph's pinning, `analysts` rides only with analyze
-*  routes, and `journal`/`blobs`/`runId` get graph defaults. */
-const GRAPH_TRANSFORMED_SUPERVISE_OPTIONS = [
-	"hooks",
-	"authorizeMessage",
-	"authorizeSpawn",
-	"makeLeafAgent",
-	"analysts",
-	"journal",
-	"blobs",
-	"runId",
-	"decideGate"
-];
-/** Not reachable from a graph, with the reason. `registry` is a NAME COLLISION, not a policy:
-*  `RunGraphOptions.registry` is the directive `PromptRegistry` and `SuperviseOptions.registry` is
-*  the `SuperviseRegistry` name→value table. Two different types under one name; the graph's wins.
-*  Giving the supervise one a graph channel means renaming a public option, so it is recorded here
-*  rather than silently dropped. */
-const GRAPH_REFUSED_SUPERVISE_OPTIONS = ["registry"];
-/**
-* 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 = [
-	"parking",
-	"backend",
-	"profileGuidance",
-	"escalateQuestion",
-	"rootHandle",
-	"signal",
-	"execution",
-	"resolveDeliverable",
-	"coordination",
-	"peerMail",
-	"peerAudit",
-	"traceTools",
-	"driverBackend",
-	"profileSecurity",
-	"authorizeSpawn",
-	"router",
-	"driveHarness",
-	"selectSeat",
-	"driverRetry",
-	"onDriverAttempt",
-	"continuation",
-	"childSettleGraceMs",
-	"teardownConfirmMs",
-	"retainedAtSettlement",
-	"resolveDriveHarness",
-	"driveHarnessMaterialization",
-	"resolveSupervisorTools",
-	"extraTools",
-	"executeExtraTool",
-	"recoverExecutor",
-	"perWorker",
-	"reservationPolicy",
-	"deadlineCheckIn",
-	"budgetStopHoldMs",
-	"workerSlots",
-	"watchWorkers",
-	"stallAfterMs",
-	"wake",
-	"runDir",
-	"resume",
-	"segment",
-	"runContext",
-	"steerDir",
-	"stopRule",
-	"onProgressStop",
-	"maxDepth",
-	"maxTurns",
-	"compaction",
-	"now",
-	"allowedModels",
-	"finalizer",
-	"otel",
-	"graphRegistry"
-];
-/**
-* Every key `RunGraphOptions` accepts, as data: the forwarded and transformed `SuperviseOptions`
-* keys, the name-colliding `registry`, and the graph's own `brain`. `GRAPH_OWNED_SUPERVISE_OPTIONS`
-* is deliberately absent — a caller value for one of those is overwritten by the graph, so it is
-* refused by name rather than discarded.
-*
-* The assignment below fails to COMPILE, naming the key, when `RunGraphOptions` declares something
-* this list does not carry.
-*/
-const runGraphOptionKeys = [
-	...GRAPH_FORWARDED_SUPERVISE_OPTIONS,
-	...GRAPH_TRANSFORMED_SUPERVISE_OPTIONS,
-	...GRAPH_REFUSED_SUPERVISE_OPTIONS,
-	"brain"
-];
-const runGraphOptionKeySet = new Set(runGraphOptionKeys);
-const graphOwnedOptionKeySet = new Set(GRAPH_OWNED_SUPERVISE_OPTIONS);
-/**
-* Refuse an option key the graph would not read, naming it and saying which kind it is.
-*
-* A graph-owned key is the sharper case: it type-checks against a widened `SuperviseOptions`
-* value, the graph derives its own value and overwrites the caller's, the run succeeds, and the
-* capability the caller asked for is not there. The rename of the leaf seam from `makeWorkerAgent`
-* to `makeLeafAgent` is the shape of the failure — the old name stayed a valid `SuperviseOptions`
-* key AND a graph-owned one, so a caller that kept passing it got a run with no leaf override and
-* no complaint.
-*/
-function assertRunGraphOptionKeys(opts) {
-	const graphOwned = [];
-	const unknown = [];
-	for (const key of Object.keys(opts)) {
-		if (runGraphOptionKeySet.has(key)) continue;
-		if (graphOwnedOptionKeySet.has(key)) graphOwned.push(key);
-		else unknown.push(key);
-	}
-	if (graphOwned.length > 0) throw new ConfigError(`runGraph: ${graphOwned.sort().join(", ")} — the graph derives this from the AgentGraph itself, so a caller value is overwritten and the capability it asks for would silently be absent`);
-	if (unknown.length > 0) throw new ConfigError(`runGraph: unknown option ${unknown.sort().join(", ")} — no reader consults that name, so the value would be discarded and the capability it asks for would silently be absent`);
-}
-/** 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;
-}
-/** 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 (graph.entry === void 0) {
-		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)");
-	if (graph.entry !== void 0) return validateFlowGraph(graph, registry, analysts);
-	if (graph.gates !== void 0) throw new ValidationError("runGraph: graph.gates needs graph.entry");
-	return validateGraphTopology(graph.nodes, graph.edges, registry, analysts);
-}
-/**
-* Execute an {@link AgentGraph}. A flow graph (`entry` set) runs from its entries and routes edges
-* under a runtime-owned root that places no model call. Otherwise the root node becomes the
-* supervisor (`supervise()` — the execution core), each worker node is spawnable BY NODE ID
-* (`spawn_worker` 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 } = graphExecutionOptions(opts);
-	return superviseAgentGraph(graph, runtimeOptions, 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;
-	return superviseAgentGraph(graph, runtimeOptions, 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) {
-	assertRunGraphOptionKeys(opts);
-	const validated = validateGraph(graph, opts.registry ?? kernelPromptRegistry(), opts.analysts);
-	const requireLeaves = () => {
-		if (!opts.backend && !opts.makeLeafAgent) throw new ValidationError("runGraph: provide opts.backend (where nodes run) or opts.makeLeafAgent");
-	};
-	if (validated.flow !== void 0) {
-		const rootOptions = [...brain ? ["brain"] : [], ...[
-			"driverBackend",
-			"finalizer",
-			"maxTurns",
-			"compaction"
-		].filter((key) => opts[key] !== void 0)];
-		if (rootOptions.length > 0) throw new ValidationError(`runGraph: ${rootOptions.join(", ")} with graph.entry — a flow graph has no root manager: Runtime spawns its entries and traverses its routes edges, and the graph owns the run's output`);
-		if ((graph.gates?.length ?? 0) > 0 && opts.decideGate === void 0) throw new ValidationError("runGraph: graph.gates needs opts.decideGate to answer them");
-		requireLeaves();
-		return validated;
-	}
-	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')`);
-	requireLeaves();
-	return validated;
-}
-function superviseAgentGraph(graph, opts, brain) {
-	if (graph.deliverable.command !== void 0) {
-		const bound = bindGraphCommand(graph, opts);
-		return superviseAgentGraph(bound.graph, bound.options, brain);
-	}
-	const registry = opts.registry ?? kernelPromptRegistry();
-	if (opts.runContext?.acquire !== void 0) return withRunContext(opts.runContext, opts.signal, (runContext, signal) => superviseAgentGraph(graph, {
-		...opts,
-		runContext,
-		...signal === void 0 ? {} : { signal }
-	}, brain));
-	const validated = assertRunGraphAuthoring(graph, opts, brain);
-	const context = opts.runContext ?? (opts.runDir === void 0 ? createInMemoryRunContext() : createFileRunContext(resolve(opts.runDir)));
-	const journal = opts.journal ?? context.journal;
-	const blobs = opts.blobs ?? context.blobs;
-	const runId = opts.runId ?? opts.runContext?.runId ?? `graph-${canonicalCandidateDigest(graph.nodes.map((n) => n.id)).slice(7, 19)}`;
-	const now = opts.now ?? Date.now;
-	const guidance = profileGuidanceComposer(opts.profileGuidance);
-	const overlay = createGraphOverlay(validated, {
-		registry,
-		journal,
-		runId,
-		now,
-		...guidance ? { guidance } : {},
-		...opts.authorizeSpawn ? { authorizeSpawn: opts.authorizeSpawn } : {}
-	});
-	const flow = validated.flow === void 0 ? void 0 : createFlowRun(overlay.nodeOfWorker);
-	const callerAuthorizeMessage = opts.authorizeMessage;
-	const authorizeMessage = overlay.observeMessages((input) => callerAuthorizeMessage ? callerAuthorizeMessage(input) : { instruction: input.instruction });
-	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;
-		return overlay.bindSpawn(event.parentId, payload.assignmentId, payload.childId);
-	} }, opts.hooks);
-	const rootProfile = flow === void 0 ? graphRootProfile(validated, registry) : flowRootProfile;
-	const rootBrain = flow === void 0 ? brain : runtimeFlowBrain();
-	const task = flow === void 0 ? graph.deliverable.describe ?? `Deliver the graph's deliverable by driving your worker nodes (root: '${validated.root.id}').` : graph.deliverable.describe ?? "Runtime runs this flow graph from its entries.";
-	const start = async () => {
-		const superviseOptions = {
-			...forwardedSuperviseOptions(opts),
-			rootDriverFromBackend: flow !== void 0,
-			budget: graph.budget,
-			deliverable: flow?.routeCheck(graph.deliverable) ?? graph.deliverable,
-			authorizeSpawn: overlay.authorizeSpawn,
-			resolveSpawnProfile: overlay.resolveSpawnProfile,
-			inheritSpawnRights: false,
-			promptRegistry: registry,
-			...opts.makeLeafAgent ? { makeLeafAgent: opts.makeLeafAgent } : {},
-			journal,
-			blobs,
-			runId,
-			hooks,
-			onCoordinationEvent: async (context, _eventId, record) => {
-				if (record.event.type === "route" && context.depth !== 0) return;
-				overlay.onCoordinationEvent(record.event);
-				flow?.observe(record.event);
-			},
-			...overlay.routes.length > 0 ? {
-				analyzeOnSettle: overlay.routes,
-				...opts.analysts ? { analysts: opts.analysts } : {}
-			} : {},
-			...overlay.maps.length > 0 ? { mapOnSettle: overlay.maps } : {},
-			...Object.keys(overlay.continuityByProfile).length > 0 ? { continuityByProfile: overlay.continuityByProfile } : {},
-			...flow === void 0 ? {} : {
-				routeFlow: routeFlowOf(validated),
-				...opts.decideGate && { decideGate: journaledGateDecider(opts.decideGate, journal, runId) },
-				finalizer: flow.finalizer,
-				wake: {
-					debounceMs: 0,
-					...opts.wake
-				}
-			},
-			authorizeMessage
-		};
-		const supervised = rootBrain === void 0 ? await supervise(rootProfile, task, superviseOptions) : await superviseWithTestBrain(rootProfile, task, {
-			...superviseOptions,
-			brain: rootBrain
-		});
-		const { ledger, exhaustedEdges, exhaustedDelegates } = await overlay.settle();
-		const concluded = flow?.conclude(supervised);
-		if (concluded?.kind === "unrouted") throw new GraphRouteError(concluded.unrouted, ledger, supervised);
-		const result = concluded?.result ?? supervised;
-		const stopped = concluded?.stopped;
-		const lifecycleEnded = result.kind === "no-winner" && (result.reason === "aborted" || result.reason === "cancelled" || result.reason === "budget-exhausted" || result.reason === "deadline");
-		if (result.kind !== "winner" && !lifecycleEnded && exhaustedDelegates.length > 0) throw new GraphEdgeCapError(exhaustedDelegates, ledger, result);
-		return {
-			result,
-			ledger,
-			exhaustedEdges,
-			runId,
-			...stopped ? { stopped } : {}
-		};
-	};
-	return start();
-}
-export { graphExecutionOptions as a, superviseAgentGraph as i, runGraph as n, runGraphWithTestBrain as r, GraphEdgeCapError as t };
-
-//# sourceMappingURL=graph-BjQF2syl.js.map