@tangle-network/agent-runtime 0.165.0 → 0.166.0

package/dist/testing.js

@@ -1,12 +1,12 @@
 import { ct as immutableCandidateValue, et as parseExactAgentProfile, it as canonicalCandidateDigest$1, q as applyExactAgentProfileDiff } from "./prepare-BCScSDCv.js";
-import { f as verifyAgentImprovementProposal } from "./improvement-cycle-BOd5DFeG.js";
-import { c as supervisorAgentWithTestBrain, ft as driverAgent, r as superviseWithTestBrain } from "./supervise-Da20R0PO.js";
-import { i as runGraphWithTestBrain } from "./graph-DGri_zJm.js";
+import { f as verifyAgentImprovementProposal } from "./improvement-cycle-BAWOyeTA.js";
+import { c as supervisorAgentWithTestBrain, ft as driverAgent, r as superviseWithTestBrain } from "./supervise-CnxqHx1P.js";
+import { i as runGraphWithTestBrain } from "./graph-E0U0c2YP.js";
 import { SANDBOX_SIZE_PRESET_NAMES } from "@tangle-network/agent-interface";
 //#region src/testing/fixtures/agent-improvement-proposal.json
 var agent_improvement_proposal_default = {
 	changedSurfaces: ["prompt"],
-	digest: "sha256:0ba07c442bb0221a5286e5a10e408fe7cb4025012be81806c0f4323eaf74efaa",
+	digest: "sha256:139b4e63472943844aeeec1e79c3b010f6bd8330d220803a25555f0f5ab9d625",
 	evaluation: {
 		"decision": {
 			"contributingChecks": [
@@ -4577,7 +4577,7 @@ var agent_improvement_proposal_default = {
 		],
 		"metadata": {
 			"fixture": "agent-improvement-proposal",
-			"runtimeVersion": "0.165.0"
+			"runtimeVersion": "0.166.0"
 		},
 		"objectives": [
 			{
@@ -4688,8 +4688,8 @@ var agent_improvement_proposal_default = {
 			"baselineContentHash": "sha256:5c21ee53e513fc604cb09754e21c392b24a424da0ef37dbf8f1ee4a8a0b08f09",
 			"candidateContentHash": "sha256:60fcbb1c728194bd51d7d19cb732d1c3f1881dce7e0a6266b41c8b98cfd65693",
 			"kind": "agent-eval-loop",
-			"recordDigest": "sha256:266f9da93c06fad8ff0c2a224c97650a3523166fb30d4a368ac97355fee6b4b4",
-			"runId": "agent-runtime-0.165.0-proposal-fixture",
+			"recordDigest": "sha256:81fe3b3e866f49786232541eb7da42bf213399f00c6a558ffd8c2b76b02e5ee1",
+			"runId": "agent-runtime-0.166.0-proposal-fixture",
 			"schema": "agent-candidate-experiment"
 		}
 	},
@@ -4712,13 +4712,13 @@ var agent_improvement_proposal_default = {
 	}],
 	kind: "agent-improvement-proposal",
 	proposedAt: "2026-07-10T01:00:00.000Z",
-	runId: "agent-runtime-0.165.0-proposal-fixture"
+	runId: "agent-runtime-0.166.0-proposal-fixture"
 };
 //#endregion
 //#region src/testing/fixtures/agent-profile-improvement-proposal.json
 var agent_profile_improvement_proposal_default = {
 	changedSurfaces: ["prompt", "skills"],
-	digest: "sha256:ec662aac3600ae0cc42b77703f5d8d9be28af80457c6098b3fa57483ad5f5664",
+	digest: "sha256:ba63ca7bd3bfd70f3a23698db348ddd5d859c3e2180a072d5ceb6af6b67b7f83",
 	evaluation: {
 		"decision": {
 			"contributingChecks": [
@@ -6352,7 +6352,7 @@ var agent_profile_improvement_proposal_default = {
 		],
 		"metadata": {
 			"fixture": "agent-profile-improvement-proposal",
-			"runtimeVersion": "0.165.0"
+			"runtimeVersion": "0.166.0"
 		},
 		"objectives": [
 			{
@@ -6463,7 +6463,7 @@ var agent_profile_improvement_proposal_default = {
 			"baselineContentHash": "sha256:21c495a37c418c10bde64fbaa188beddeed31f1f051ea60a6a6582a9ee0db704",
 			"candidateContentHash": "sha256:103f77bc8481601eef1ad5fe6ba84a40dffabc3a44f421f8c8559121edab84e9",
 			"kind": "agent-eval-loop",
-			"recordDigest": "sha256:faef431643916606d07af2e00432de3ba9b480db074918b4067d77e4d4edc65d",
+			"recordDigest": "sha256:88b11a3cfbf0302f9e70cd2722324f1185606a005e0b57cc82755c127dd20239",
 			"runId": "profile-improvement-1",
 			"schema": "agent-profile-improvement-experiment"
 		}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-runtime",
-  "version": "0.165.0",
+  "version": "0.166.0",
   "description": "Shared task-lifecycle skeleton for agents: a recursive loop kernel for chat turns, one-shot tasks, and multi-attempt loops, with trace capture and eval-gated self-improvement. Domain behavior lives in adapters; scoring and ship-gates in @tangle-network/agent-eval.",
   "homepage": "https://github.com/tangle-network/agent-runtime#readme",
   "repository": {

package/dist/graph-DGri_zJm.js

@@ -1,532 +0,0 @@
-import { m as ValidationError } from "./errors-CDZ8XsVj.js";
-import { i as InMemorySpawnJournal, r as InMemoryResultBlobStore } from "./spawn-journal-Tgvp5VS5.js";
-import { f as harnessRunsAgent } from "./model-policy-Sw4ywhtL.js";
-import { t as composeRuntimeHooks } from "./runtime-hooks-tXpAarhW.js";
-import { h as kernelPromptRegistry, m as formatPromptHandle, n as supervise, r as superviseWithTestBrain } from "./supervise-Da20R0PO.js";
-import { agentProfileSchema, canonicalCandidateDigest } from "@tangle-network/agent-interface";
-//#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;
-	return runGraphInternal(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 runGraphInternal(graph, runtimeOptions, brain);
-}
-function runGraphInternal(graph, opts, brain) {
-	const registry = opts.registry ?? kernelPromptRegistry();
-	const { root, workers, delegatesByWorker, analyzes, analystNodes } = validateGraph(graph, registry, opts.analysts);
-	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");
-	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 { runGraphWithTestBrain as i, defaultEdgeTraversalCap as n, runGraph as r, GraphEdgeCapError as t };
-
-//# sourceMappingURL=graph-DGri_zJm.js.map