@tangle-network/agent-runtime 0.324.0 → 0.325.0

package/dist/{supervise-FOCAUADN.js → supervise-BlaB4CeL.js}

@@ -1,12 +1,13 @@
 import { n as assertNoSymlinkDescendant } from "./durable-file-B_eJr6Mb.js";
-import { $t as PEER_MAIL_WIRE_KEY, A as scopeOwnerExecutorNodeContext, Ai as registerRetainedExecutorPreparation, An as resolveAgentEnvironmentProvider, At as captureReusableExecutorConfig, B as consumeScopeRetainedOwnerResult, C as deriveNodeExecutionIdentity, Ct as createContinuationKeeper, D as recordScopeOwnerMaterialization, E as recordScopeOwnerDriverAttempt, F as seatExecutionProfile, Fn as bridgeStopSignalKey, Ft as snapshotExecutorConfig, G as scopeRetainedOwnerContext, Gn as RunCancellationReason, Gr as fullProfileMaterialization, H as prepareScopeRetainedOwnerSeatSwitch, I as abandonScopeRetainedOwnerInvocation, J as scopeRetainedOwnerResourceReader, Jn as runAbortable, Jr as promptModelProfileMaterialization, Jt as createActivityLog, K as scopeRetainedOwnerJournalRoot, Kr as profileMaterializationAxes$1, L as beginScopeRetainedOwnerDrive, M as SeatChain, N as SeatChainExhaustedError, Nt as createExecutor, O as recordScopeOwnerPause, P as authoredSeatStages, Pn as bridgeRuntimeAttachmentsKey, Qn as readHarnessTranscript, Qr as renderUnsupported, R as bindScopeRetainedOwnerEnvironmentId, St as checkVerdictOf, T as meterRuntimeOwnedProviderAttempt, U as prepareScopeRetainedOwnerTask, Ur as controlProfileMaterialization, V as noteScopeRetainedOwnerCoordination, Vr as assertProfileMaterialization, Vt as WORKER_TRACE_PROPAGATION, W as reconcileScopeRetainedOwnerEnvironment, Wr as defineProfileMaterializationContract, X as scopeRetainedOwnerResult, Xt as createInbox, Y as scopeRetainedOwnerRestorePoint, Z as scopeRetainedOwnerTurnEnded, Zn as persistHarnessTranscript, _ as isDriverSpec, _a as meterUsageEvent, _i as runtimeOwnedExecutorProviderEvidence, _r as generateSpanId, ai as authoredAgentIdentity, an as isLiveNodeStatus, b as assertRecursiveReservationPolicy, ba as spendFromUsageTotals, c as runTree, ca as contentAddress, ci as inheritRuntimeOwnedExecutorAttestation, cn as bridgeModelRouteRefusal, da as executorFailure, ei as unsupportedProfileDimensions, f as runDriverWithRetry, fa as errMessage, fi as providerAttemptEvidence, g as driverExecutorFactory, gi as runtimeOwnedExecutorMaterialization, gt as CONTINUATIONS_DIR, h as driverChild, ha as assertValidBudget, hi as runtimeOwnedExecutorExecutionBinding, hr as createOtelExporter, i as bestDelivered, ii as attestRuntimeOwnedScopeOwner, it as providerVisibleProfile, ji as retainedExecutorSeamKey, k as restoreScopeOwnerAcceptedExecution, kt as bindReusableExecutorExecutionId, mi as runtimeOwnedDriveHarnessProviderEvidence, mt as gateOnDeliverable, n as createRootHandle, ni as worktreeCliProfileMaterialization, nn as isPeerMailEnvelope, nt as coordinationMcpAlias, oa as parseWorkerToolTraceArtifact, p as summarizeDriverAttempts, pi as recordRuntimeOwnedDriveHarnessProviderEvidence, q as scopeRetainedOwnerPriorSpend, qn as linkAbort, qr as promptControlProfileMaterialization, r as createSupervisor, rt as coordinationProfileToolPrefix, s as runFinalizer, sn as bridgeAdmissionRefusal, u as HarnessTurnFailedError, ua as detachedSnapshot, va as newUsageTotals, vi as runtimeOwnedPendingExecutorMaterialization, vt as CheckUnavailableError, w as meterRuntimeOwnedAccounting, wn as routerBrain, x as beginScopeOwnerAttempt, xr as toOtelAttributes, xt as bestComposite, yi as runtimeOwnedScopeOwnerRuntime, yt as admitContinuationPolicy, z as bindScopeRetainedOwnerProvider, zt as createRouterTranscript } from "./supervisor-DnKhkhKc.js";
+import { $n as readHarnessTranscript, $r as renderUnsupported, A as scopeOwnerExecutorNodeContext, At as bindReusableExecutorExecutionId, B as consumeScopeRetainedOwnerResult, Bt as createRouterTranscript, C as deriveNodeExecutionIdentity, Ct as checkVerdictOf, D as recordScopeOwnerMaterialization, E as recordScopeOwnerDriverAttempt, F as seatExecutionProfile, Fn as bridgeRuntimeAttachmentsKey, G as scopeRetainedOwnerContext, Gr as defineProfileMaterializationContract, H as prepareScopeRetainedOwnerSeatSwitch, Hr as assertProfileMaterialization, Ht as WORKER_TRACE_PROPAGATION, I as abandonScopeRetainedOwnerInvocation, In as bridgeStopSignalKey, It as snapshotExecutorConfig, J as scopeRetainedOwnerResourceReader, Jn as linkAbort, Jr as promptControlProfileMaterialization, K as scopeRetainedOwnerJournalRoot, Kn as RunCancellationReason, Kr as fullProfileMaterialization, L as beginScopeRetainedOwnerDrive, M as SeatChain, Mi as retainedExecutorSeamKey, N as SeatChainExhaustedError, O as recordScopeOwnerPause, P as authoredSeatStages, Pt as createExecutor, Qn as persistHarnessTranscript, R as bindScopeRetainedOwnerEnvironmentId, Sr as toOtelAttributes, St as bestComposite, T as meterRuntimeOwnedProviderAttempt, Tn as routerBrain, U as prepareScopeRetainedOwnerTask, V as noteScopeRetainedOwnerCoordination, W as reconcileScopeRetainedOwnerEnvironment, Wr as controlProfileMaterialization, X as scopeRetainedOwnerResult, Y as scopeRetainedOwnerRestorePoint, Yn as runAbortable, Yr as promptModelProfileMaterialization, Yt as createActivityLog, Z as scopeRetainedOwnerTurnEnded, Zt as createInbox, _ as isDriverSpec, _i as runtimeOwnedExecutorMaterialization, _t as CONTINUATIONS_DIR, ai as attestRuntimeOwnedScopeOwner, at as runtimeGraphMetadataKey, b as assertRecursiveReservationPolicy, bi as runtimeOwnedScopeOwnerRuntime, bt as admitContinuationPolicy, c as runTree, cn as bridgeAdmissionRefusal, da as detachedSnapshot, en as PEER_MAIL_WIRE_KEY, f as runDriverWithRetry, fa as executorFailure, g as driverExecutorFactory, ga as assertValidBudget, gi as runtimeOwnedExecutorExecutionBinding, gr as createOtelExporter, h as driverChild, hi as runtimeOwnedDriveHarnessProviderEvidence, ht as gateOnDeliverable, i as bestDelivered, it as providerVisibleProfile, ji as registerRetainedExecutorPreparation, jn as resolveAgentEnvironmentProvider, jt as captureReusableExecutorConfig, k as restoreScopeOwnerAcceptedExecution, la as contentAddress, li as inheritRuntimeOwnedExecutorAttestation, ln as bridgeModelRouteRefusal, mi as recordRuntimeOwnedDriveHarnessProviderEvidence, n as createRootHandle, nt as coordinationMcpAlias, oi as authoredAgentIdentity, on as isLiveNodeStatus, p as summarizeDriverAttempts, pa as errMessage, pi as providerAttemptEvidence, q as scopeRetainedOwnerPriorSpend, qr as profileMaterializationAxes$1, r as createSupervisor, ri as worktreeCliProfileMaterialization, rn as isPeerMailEnvelope, rt as coordinationProfileToolPrefix, s as runFinalizer, sa as parseWorkerToolTraceArtifact, ti as unsupportedProfileDimensions, u as HarnessTurnFailedError, va as meterUsageEvent, vi as runtimeOwnedExecutorProviderEvidence, vr as generateSpanId, w as meterRuntimeOwnedAccounting, wt as createContinuationKeeper, x as beginScopeOwnerAttempt, xa as spendFromUsageTotals, ya as newUsageTotals, yi as runtimeOwnedPendingExecutorMaterialization, yt as CheckUnavailableError, z as bindScopeRetainedOwnerProvider } from "./supervisor-fq4JGynd.js";
 import { f as RuntimeRunStateError, i as ConfigError, m as ValidationError } from "./errors-DodWX-cb.js";
 import { Dt as teardownSurfaces, Et as teardownExecutor, V as addSpend, Z as isAsyncIterable$1, ct as withTimeout, dt as addResourceSpend, lt as zeroSpend, mt as withBudgetResources, pt as resourceTelemetry, q as errorMessage, rt as sleep, st as unmeteredSpend, yt as DEFAULT_SUCCESSFUL_SHUTDOWN_MS } from "./workspace-streams-CcoARX4v.js";
 import { a as readCommittedJsonLines, n as isNoEntError, r as prepareJsonlAppend } from "./jsonl-file-DBv31uPi.js";
 import { _ as agentHarness, a as concreteProfileModel, c as profileModelExecutionSettings, n as assertModelAllowed, o as enforceTokenLimits, r as assertProfileModelsAllowed, s as profileBridgeWireModel, t as assertExecutableAgentProfile, v as harnessRunsAgent } from "./model-policy-CyCUwHed.js";
 import { t as composeRuntimeHooks } from "./runtime-hooks-tXpAarhW.js";
-import { C as createFileRunContext, F as createCoordinationToolsForManager, N as coordinationVerbNames, O as applyRunCancellation, T as withRunContext, c as refreshedWake, g as progressStop, h as plateau, k as watchRunCancellation, l as resolveWakePolicy, n as createSteerAcknowledger, o as composeWakeInput, p as createProgressTracker, r as driverAgent, s as deadlineWarningAt, t as createCancelAcknowledger, w as createInMemoryRunContext } from "./coordination-driver-CNEeqMoh.js";
+import { C as createFileRunContext, F as createCoordinationToolsForManager, N as coordinationVerbNames, O as applyRunCancellation, T as withRunContext, c as refreshedWake, g as progressStop, h as plateau, k as watchRunCancellation, l as resolveWakePolicy, n as createSteerAcknowledger, o as composeWakeInput, p as createProgressTracker, r as driverAgent, s as deadlineWarningAt, t as createCancelAcknowledger, w as createInMemoryRunContext } from "./coordination-driver-DkkUVe9g.js";
 import { r as createStdioToolServer, t as PROTOCOL_VERSION } from "./tool-server-Dqer2M4_.js";
+import { c as loadGraph, i as graphRegistry } from "./graph-registry-DAI6KNXB.js";
 import { k as writeRunCancellation, o as readRunCancelRequest, s as readRunCancellation } from "./run-layout-Cu8H7aeh.js";
 import { agentProfileSchema, canonicalAgentProfileDigest, canonicalCandidateDigest, canonicalCandidateJson, validateAgentProfileSecurity } from "@tangle-network/agent-interface";
 import { toolSpansToTraceAnalysisStore } from "@tangle-network/agent-eval";
@@ -641,6 +642,7 @@ async function serveCoordinationMcpForManager(opts, lifetime) {
 		scope: opts.scope,
 		blobs: opts.blobs,
 		makeWorkerAgent: opts.makeWorkerAgent,
+		...opts.graphs ? { graphs: opts.graphs } : {},
 		...opts.authorizeDownMessage ? { authorizeDownMessage: opts.authorizeDownMessage } : {},
 		perWorker: opts.perWorker,
 		...opts.deliverable ? { deliverable: opts.deliverable } : {},
@@ -912,6 +914,620 @@ async function serveCoordinationMcpForManager(opts, lifetime) {
 	};
 }
 //#endregion
+//#region src/runtime/supervise/prompt-registry.ts
+/**
+*
+* The kernel prompt registry — versioned prompt text as DATA, addressed by `PromptHandle`.
+*
+* A role expressed as a builder FUNCTION is a role that can never improve: the only optimizable
+* surface it leaves is whatever thin string a caller happens to inject, while the real doctrine
+* sits hardcoded in TypeScript. This registry is the inverse: every standing instruction is a
+* versioned entry (`<surface>` + `v<n>`), so a graph edge, a supervisor front door, or an
+* optimizer names a handle and the TEXT is swappable, sweepable, and diffable without a code
+* change. Graph edges (`runGraph`) carry handles, never inline prose.
+*
+* A profile or graph may opt into one of these versioned texts. Runtime does not select a standing
+* supervisor policy when the profile omits one.
+*
+* @experimental
+*/
+const HANDLE_PATTERN = /^(.+)\/v(\d+)$/;
+/**
+* Parse `'<surface>/v<n>'` into a {@link PromptHandle}. The shorthand for authoring a graph edge:
+* `directive: promptHandle('delegates/worker-brief/v1')`.
+*/
+function promptHandle(ref) {
+	if (typeof ref !== "string" || ref.length === 0) throw new ValidationError("promptHandle: ref must be a non-empty string");
+	const match = HANDLE_PATTERN.exec(ref);
+	if (!match) throw new ValidationError(`promptHandle: ${JSON.stringify(ref)} is not a versioned prompt reference (<surface>/v<n>)`);
+	const version = Number(match[2]);
+	if (!Number.isSafeInteger(version) || version < 0) throw new ValidationError(`promptHandle: invalid version in ${JSON.stringify(ref)}`);
+	return {
+		surface: match[1],
+		version
+	};
+}
+/** The string form of a handle: `<surface>/v<n>`. */
+function formatPromptHandle(handle) {
+	return `${handle.surface}/v${handle.version}`;
+}
+/** Create a registry, optionally seeded. Entries are copied; the registry never aliases caller state. */
+function createPromptRegistry(seed) {
+	const entries = /* @__PURE__ */ new Map();
+	const keyOf = (surface, version) => `${surface}/v${version}`;
+	const register = (entry) => {
+		if (typeof entry.surface !== "string" || entry.surface.length === 0) throw new ValidationError("prompt registry: entry.surface must be a non-empty string");
+		if (!Number.isSafeInteger(entry.version) || entry.version < 0) throw new ValidationError("prompt registry: entry.version must be a non-negative integer");
+		if (typeof entry.text !== "string" || entry.text.length === 0) throw new ValidationError(`prompt registry: entry ${keyOf(entry.surface, entry.version)} has no text — an empty directive is the silent-substitution failure this registry exists to prevent`);
+		const key = keyOf(entry.surface, entry.version);
+		if (entries.has(key)) throw new ValidationError(`prompt registry: ${key} is already registered — versions are immutable; register a new version instead`);
+		entries.set(key, Object.freeze({ ...entry }));
+	};
+	for (const entry of seed ?? []) register(entry);
+	return {
+		resolve(handle) {
+			const found = entries.get(keyOf(handle.surface, handle.version));
+			if (!found) throw new ValidationError(`prompt registry: no entry for ${formatPromptHandle(handle)} — a directive must resolve or fail loud, never fall back silently (registered: ${[...entries.keys()].join(", ") || "none"})`);
+			return found;
+		},
+		register,
+		list() {
+			return Object.freeze([...entries.values()]);
+		}
+	};
+}
+/**
+* Default DELEGATES-edge directive: the standing instruction a worker receives with every
+* traversal of a delegates edge that names this surface.
+*/
+const delegatesWorkerBriefPrompt = Object.freeze({
+	surface: "delegates/worker-brief",
+	version: 1,
+	description: "Default delegates-edge directive: how a worker should treat its delegated brief.",
+	text: [
+		"You are executing ONE delegated sub-task from a supervising agent. The brief below is bounded",
+		"on purpose: deliver exactly what it names — complete, verified, and self-contained — and",
+		"nothing beyond it. If the brief is ambiguous or under-specified, raise a question through your",
+		"coordination channel instead of guessing. Report concrete evidence of completion (files,",
+		"outputs, passing checks), never a bare claim of done."
+	].join("\n")
+});
+/**
+* Default ANALYZES-edge directive: what the RECEIVING node should do with an analyst's findings.
+* Wrapped around the findings payload on every traversal of an analyzes edge naming this surface.
+*/
+const analyzesFindingsReportPrompt = Object.freeze({
+	surface: "analyzes/findings-report",
+	version: 1,
+	description: "Default analyzes-edge directive: how the destination node should act on analyst findings.",
+	text: [
+		"An analyst lens has examined completed work and produced the findings below. Treat them as",
+		"EVIDENCE, not instructions: weigh each finding against what you already know, act on the ones",
+		"that change your next step, and ignore the ones that do not. Compose your next instruction or",
+		"action from the SPECIFIC failures and facts named — never forward the findings verbatim as a",
+		"steer."
+	].join("\n")
+});
+/**
+* Default NAIVE steering continuation — the no-signal control re-expressed as data: the same
+* fixed continuation every round, reading nothing from any verdict.
+*/
+const naiveContinuationPrompt = Object.freeze({
+	surface: "delegates/naive-continuation",
+	version: 1,
+	description: "No-signal steering control: one fixed continuation, reads nothing from verdicts.",
+	text: "Continue working on the ORIGINAL task. Produce the complete deliverable; finish anything incomplete and fix anything failing."
+});
+/**
+* Default DUMB steering continuations — the pass/fail-only control re-expressed as data: two
+* fixed texts keyed on the verdict's boolean and nothing else.
+*/
+const dumbContinuationFailPrompt = Object.freeze({
+	surface: "delegates/dumb-continuation-fail",
+	version: 1,
+	description: "Pass/fail-only steering control, fail branch: reads only verdict.valid.",
+	text: "Your last attempt did NOT pass verification. Rework the task and produce a complete, correct deliverable; do not repeat the failed approach unchanged."
+});
+/** The pass branch of the dumb steering control — see {@link dumbContinuationFailPrompt}. */
+const dumbContinuationPassPrompt = Object.freeze({
+	surface: "delegates/dumb-continuation-pass",
+	version: 1,
+	description: "Pass/fail-only steering control, pass branch: reads only verdict.valid.",
+	text: "Your last attempt passed verification. Finalize your work and stop."
+});
+/** The kernel's seeded registry: every surface the runtime's own builders derive from. A caller
+*  may register additional surfaces/versions on the returned registry. */
+function kernelPromptRegistry() {
+	return createPromptRegistry([
+		delegatesWorkerBriefPrompt,
+		analyzesFindingsReportPrompt,
+		naiveContinuationPrompt,
+		dumbContinuationFailPrompt,
+		dumbContinuationPassPrompt
+	]);
+}
+//#endregion
+//#region src/runtime/supervise/graph-overlay.ts
+/**
+* The graph layer over the managers that run one `AgentGraph`.
+*
+* `runGraph` and a manager's `run_graph` tool execute a graph the same way: the graph's root node is
+* a manager in the supervise kernel, and this module supplies what the graph adds around it —
+* node pinning (spawn authorization), the driver brief, analyst routes, edge continuity defaults,
+* and the edge ledger with its journal twin. `runGraph` composes it into the root `supervise()`
+* call; `supervise()` composes it into the nested manager a `run_graph` spawn starts, so a graph
+* run as a subtask is one subtree of the caller's run, spending from the caller's conserved pool.
+*
+* Nothing here schedules anything. It produces the values a manager's construction takes
+* (`authorizeSpawn`, `resolveSpawnProfile`, `analyzeOnSettle`, `continuityByProfile`) and
+* observes what the kernel reports back (spawn bindings, steers, findings).
+*/
+/** Default per-edge traversal cap — the cyclic-graph backstop when an edge names none. */
+const defaultEdgeTraversalCap = 32;
+function edgeId(edge) {
+	return edge.kind === "delegates" ? `delegates:${edge.from}->${edge.to}` : `analyzes:${edge.analyst}:${edge.over.join("+")}->${edge.to}`;
+}
+/** Validate a topology 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 validateGraphTopology(nodes, edges, registry, analysts) {
+	if (!Array.isArray(nodes) || nodes.length === 0) throw new ValidationError("runGraph: graph.nodes must be a non-empty array");
+	if (!Array.isArray(edges) || edges.length === 0) throw new ValidationError("runGraph: graph.edges must be a non-empty array");
+	const byId = /* @__PURE__ */ new Map();
+	for (const node of 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`);
+		if (node.profile.metadata?.["agentRuntimeGraph"] !== void 0) throw new ValidationError(`runGraph: node '${node.id}' carries metadata.${runtimeGraphMetadataKey}, which Runtime writes only for the root of a graph started by run_graph; a node cannot hold a graph`);
+		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 = edges.filter((edge) => edge.kind === "delegates");
+	const analyzes = 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 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");
+	if (root.profile.tools?.[`${coordinationProfileToolPrefix}spawn_worker`] !== true) throw new ValidationError(`runGraph: root node '${root.id}' has delegates edges but does not declare ${JSON.stringify(`${coordinationProfileToolPrefix}spawn_worker`)} — the graph cannot spawn any declared worker`);
+	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 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
+	};
+}
+/** The root node's canonical profile with the graph brief appended: which nodes the driver may
+*  spawn, by exact name, each with its delegation cap and continuity. */
+function graphRootProfile(validated, registry) {
+	const { root, workers, delegatesByWorker, analyzes, analystNodes } = validated;
+	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 graphBrief = [
+		"AGENT GRAPH: you are the driver node of a fixed topology. You may spawn ONLY these worker",
+		"nodes, by EXACT name (spawn_worker 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");
+	return {
+		...root.profile,
+		prompt: {
+			...root.profile.prompt ?? {},
+			instructions: [...root.profile.prompt?.instructions ?? [], graphBrief]
+		}
+	};
+}
+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);
+	}
+}
+/**
+* Build the graph layer for one validated graph. Each delegates directive is appended to the
+* worker profile's `prompt.instructions` per traversal, each analyzes edge becomes an
+* analyst-on-settle route with a real DESTINATION, and every traversal is ledgered and journaled.
+*/
+function createGraphOverlay(validated, opts) {
+	const { root, workers, delegatesByWorker, analyzes, analystNodes } = validated;
+	const { registry, journal, runId, now } = opts;
+	const ledger = [];
+	const journaled = /* @__PURE__ */ new Set();
+	const traversalCounts = /* @__PURE__ */ new Map();
+	const capSpend = /* @__PURE__ */ new Map();
+	const spend = (edge) => {
+		capSpend.set(edge, (capSpend.get(edge) ?? 0) + 1);
+	};
+	const exhausted = /* @__PURE__ */ new Set();
+	const exhaustedDelegates = /* @__PURE__ */ new Set();
+	const journalWrites = [];
+	let ledgerSeq = 0;
+	let graphNodeId;
+	const appendJournal = (entry, nodeIdForEvent) => {
+		if (journaled.has(entry)) return Promise.resolve();
+		journaled.add(entry);
+		const write = journal.appendEvent(runId, {
+			kind: "edge",
+			id: nodeIdForEvent,
+			...graphNodeId === void 0 ? {} : { graph: graphNodeId },
+			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 settleUnbound = (pending) => {
+		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;
+		return appendJournal(refused, `graph:${refused.to}`);
+	};
+	const record = (entry, final) => {
+		const count = (traversalCounts.get(entry.edge) ?? 0) + 1;
+		traversalCounts.set(entry.edge, count);
+		const row = {
+			...entry,
+			traversal: count
+		};
+		ledger.push(row);
+		if (final) {
+			spend(row.edge);
+			appendJournal(row, row.workerId ?? `graph:${row.to}`);
+		}
+		return row;
+	};
+	const nodeByWorkerId = /* @__PURE__ */ new Map();
+	const pendingByAssignment = /* @__PURE__ */ new Map();
+	const pendingKey = (parentNodeId, assignmentId) => `${parentNodeId ?? ""}\u0000${assignmentId}`;
+	const pinNode = (input) => {
+		if (opts.subtask === true) graphNodeId ??= input.parentNodeId;
+		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;
+		}
+		if (input.profile.metadata?.["agentRuntimeGraph"] !== void 0) throw new ValidationError("runGraph: a node of a graph cannot start another graph — run_graph inside a graph is refused; add the work as nodes of this graph instead");
+		const node = requested !== void 0 ? workers.get(requested) : void 0;
+		if (!node) throw new ValidationError(`runGraph: spawn_worker 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 = capSpend.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);
+		const key = pendingKey(input.parentNodeId, input.assignmentId);
+		const stale = pendingByAssignment.get(key);
+		if (stale !== void 0) settleUnbound(stale);
+		pendingByAssignment.set(key, row);
+		return directiveText.length === 0 ? node.profile : {
+			...node.profile,
+			prompt: {
+				...node.profile.prompt ?? {},
+				instructions: [...node.profile.prompt?.instructions ?? [], directiveText]
+			}
+		};
+	};
+	const composeGuidance = (profile) => opts.guidance ? opts.guidance(profile) : profile;
+	const resolveSpawnProfile = (authored) => {
+		const requested = typeof authored.name === "string" ? authored.name : void 0;
+		const node = (requested !== void 0 ? workers.get(requested) : void 0) ?? (requested !== void 0 ? analystNodes.get(requested) : void 0);
+		return node ? composeGuidance(node.profile) : authored;
+	};
+	const authorizeSpawn = (input) => {
+		const pinned = composeGuidance(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 continuityByProfile = {};
+	for (const [nodeId, edge] of delegatesByWorker) if (edge.continuity !== void 0) continuityByProfile[nodeId] = edge.continuity;
+	const strippedByDigest = /* @__PURE__ */ new Map();
+	const observeMessages = (authorize) => {
+		return (input) => {
+			const decision = authorize(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 ((capSpend.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 = (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 bindSpawn = (parentNodeId, assignmentId, childId) => {
+		const key = pendingKey(parentNodeId, assignmentId);
+		const pending = pendingByAssignment.get(key);
+		if (!pending) return void 0;
+		pendingByAssignment.delete(key);
+		const bound = {
+			...pending,
+			workerId: childId
+		};
+		ledger[ledger.indexOf(pending)] = bound;
+		nodeByWorkerId.set(childId, bound.to);
+		spend(bound.edge);
+		return appendJournal(bound, childId);
+	};
+	const settle = async () => {
+		for (const pending of pendingByAssignment.values()) await settleUnbound(pending);
+		pendingByAssignment.clear();
+		await Promise.all(journalWrites);
+		return {
+			ledger: Object.freeze(ledger.map((row) => Object.freeze({ ...row }))),
+			exhaustedEdges: Object.freeze([...exhausted]),
+			exhaustedDelegates: Object.freeze([...exhaustedDelegates])
+		};
+	};
+	return {
+		routes,
+		continuityByProfile,
+		authorizeSpawn,
+		resolveSpawnProfile,
+		observeMessages,
+		onCoordinationEvent,
+		bindSpawn,
+		settle
+	};
+}
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseDirective(raw, where) {
+	if (typeof raw === "string") return promptHandle(raw);
+	if (isRecord$1(raw) && typeof raw.surface === "string" && typeof raw.version === "number") return {
+		surface: raw.surface,
+		version: raw.version
+	};
+	throw new ValidationError(`run_graph: ${where}.directive must be a versioned directive reference such as 'delegates/worker-brief/v1'`);
+}
+/**
+* Read graph data a model wrote, or a stored graph's topology. Edge directives may be written as
+* `'<surface>/v<n>'` strings. The budget and deliverable are the tool's arguments, so a graph that
+* carries its own is refused rather than one of the two silently ignored.
+*/
+function parseGraphSubtaskTopology(raw) {
+	if (!isRecord$1(raw)) throw new ValidationError("run_graph: graph must be an object { nodes, edges }");
+	for (const key of Object.keys(raw)) {
+		if (key === "nodes" || key === "edges") continue;
+		if (key === "budget" || key === "deliverable") throw new ValidationError(`run_graph: graph.${key} is not read — pass ${key} as run_graph's own argument`);
+		throw new ValidationError(`run_graph: graph.${key} is not part of a graph; use nodes and edges`);
+	}
+	if (!Array.isArray(raw.nodes) || !Array.isArray(raw.edges)) throw new ValidationError("run_graph: graph.nodes and graph.edges must be arrays");
+	return {
+		nodes: raw.nodes.map((node, index) => {
+			if (!isRecord$1(node) || typeof node.id !== "string" || !isRecord$1(node.profile)) throw new ValidationError(`run_graph: graph.nodes[${index}] must be { id, profile }`);
+			return {
+				id: node.id,
+				profile: node.profile
+			};
+		}),
+		edges: raw.edges.map((edge, index) => {
+			const where = `graph.edges[${index}]`;
+			if (!isRecord$1(edge)) throw new ValidationError(`run_graph: ${where} must be an object`);
+			const directive = parseDirective(edge.directive, where);
+			if (edge.kind === "delegates") return {
+				...edge,
+				directive
+			};
+			if (edge.kind === "analyzes") return {
+				...edge,
+				directive
+			};
+			throw new ValidationError(`run_graph: ${where}.kind must be 'delegates' or 'analyzes'`);
+		})
+	};
+}
+/**
+* Validate a `run_graph` graph and compose the profile its spawn runs: the root node's canonical
+* profile, the driver brief, and the topology under `metadata.agentRuntimeGraph`. That metadata is
+* part of the profile's identity, so a keyed `run_graph` that resumes runs the same graph, and the
+* provider-visible projection removes it before any provider sees the profile.
+*/
+function prepareGraphSubtask(topology, opts) {
+	const validated = validateGraphTopology(topology.nodes, topology.edges, opts.registry, opts.analysts);
+	const brief = graphRootProfile(validated, opts.registry);
+	const marked = {
+		...brief,
+		metadata: {
+			...brief.metadata ?? {},
+			[runtimeGraphMetadataKey]: {
+				nodes: topology.nodes,
+				edges: topology.edges
+			}
+		}
+	};
+	const parsed = agentProfileSchema.safeParse(opts.guidance ? opts.guidance(marked) : marked);
+	if (!parsed.success) throw new ValidationError(`run_graph: the graph's root profile is not a valid AgentProfile: ${parsed.error.message}`);
+	return {
+		profile: parsed.data,
+		root: validated.root.id,
+		nodes: topology.nodes.map((node) => node.id)
+	};
+}
+/** The topology a `run_graph` root profile carries, or `undefined` for any other profile. */
+function graphSubtaskOf(profile) {
+	const raw = profile.metadata?.[runtimeGraphMetadataKey];
+	return raw === void 0 ? void 0 : parseGraphSubtaskTopology(raw);
+}
+//#endregion
 //#region src/runtime/supervise/otel-spans.ts
 /**
 * Supervisor tree → OTLP spans. OPT-IN, off by default.
@@ -1941,6 +2557,7 @@ function buildSupervisorAgent(profile, deps, testBrain) {
 			...deps.onProviderModel ? { onProviderModel: deps.onProviderModel } : {},
 			blobs: deps.blobs,
 			makeWorkerAgent: deps.makeWorkerAgent,
+			...deps.graphs ? { graphs: deps.graphs } : {},
 			...deps.authorizeDownMessage ? { authorizeDownMessage: deps.authorizeDownMessage } : {},
 			perWorker: deps.perWorker,
 			...deps.preserveOwnerTurns ? { preserveOwnerTurns: true } : {},
@@ -2054,6 +2671,7 @@ function buildSupervisorAgent(profile, deps, testBrain) {
 				scope,
 				blobs: deps.blobs,
 				makeWorkerAgent: deps.makeWorkerAgent,
+				...deps.graphs ? { graphs: deps.graphs } : {},
 				...deps.authorizeDownMessage ? { authorizeDownMessage: deps.authorizeDownMessage } : {},
 				perWorker: deps.perWorker,
 				...coordination ?? {},
@@ -3897,10 +4515,12 @@ async function verifyProfilePromotions(table) {
 	const { verifySealedExperiment } = await import("@tangle-network/agent-eval/experiment");
 	for (const [name, entry] of promoted) if (!await verifySealedExperiment(entry.promotion.experiment)) throw new ValidationError(`supervise: opts.registry.profiles ${JSON.stringify(name)} cites a sealed play whose digest does not match its spec`);
 }
-/** Capabilities a data-only consumer may require before building an opted-in run. */
+/** Capabilities a data-only consumer may require before building an opted-in run. `graphTools`:
+*  a manager whose profile grants `run_graph` can start an agent graph as one subtask. */
 const superviseFleetCapabilities = Object.freeze({
 	peerAudit: true,
-	traceTools: true
+	traceTools: true,
+	graphTools: true
 });
 const superviseOptionKeySet = /* @__PURE__ */ new Set([
 	"allowedModels",
@@ -3927,6 +4547,7 @@ const superviseOptionKeySet = /* @__PURE__ */ new Set([
 	"execution",
 	"extraTools",
 	"finalizer",
+	"graphRegistry",
 	"hooks",
 	"inheritSpawnRights",
 	"journal",
@@ -4341,6 +4962,31 @@ function superviseWithTestBrain(profile, task, opts) {
 	const { brain, ...runtimeOptions } = opts;
 	return superviseWithContext(profile, task, runtimeOptions, brain);
 }
+/** A stored graph's topology, from the registry `SuperviseOptions.graphRegistry` names. */
+async function storedGraphTopology(dir, digest) {
+	if (dir === void 0) throw new ValidationError("run_graph: this run names no graph registry (SuperviseOptions.graphRegistry), so a graphDigest cannot resolve; pass the graph as data");
+	const stored = await loadGraph(graphRegistry(dir), digest);
+	if (stored === void 0) throw new ValidationError(`run_graph: the graph registry holds no graph ${digest}`);
+	return parseGraphSubtaskTopology({
+		nodes: stored.nodes,
+		edges: stored.edges
+	});
+}
+/**
+* What a `run_graph` subtask settles with once its root manager returned and its subtree closed:
+* the root's result and the graph's edge ledger. A delegates cap that refused work while the root
+* delivered nothing ended the graph, not the task, so that fails loud with the cap named, as
+* `runGraph` fails a root graph with `GraphEdgeCapError`.
+*/
+async function graphSubtaskOutput(overlay, out) {
+	const { ledger, exhaustedEdges, exhaustedDelegates } = await overlay.settle();
+	if ((out === void 0 || out === null) && exhaustedDelegates.length > 0) throw new ValidationError(`run_graph: edge traversal cap exhausted on ${exhaustedDelegates.join(", ")} and the graph delivered nothing — the cap (the cyclic-graph backstop), not the task, ended it; the edge ledger is in the run journal`);
+	return {
+		deliverable: out === void 0 ? null : out,
+		edges: ledger,
+		...exhaustedEdges.length === 0 ? {} : { exhaustedEdges }
+	};
+}
 /**
 * The composer `profileGuidance` selects, or `undefined` when no guidance is selected. The result
 * is re-validated as an AgentProfile, and a composition that breaks the schema is refused as a
@@ -4604,13 +5250,51 @@ function superviseInternal(profile, task, opts, testBrain) {
 	let spans;
 	const traceUnpropagated = options.backend ? workerTraceUnpropagatedDeclaration(options.backend.backend) : void 0;
 	const recoveryFactories = /* @__PURE__ */ new WeakMap();
+	const graphOverlays = /* @__PURE__ */ new Set();
+	const graphSubtasks = options.makeWorkerAgent === void 0 ? { prepare: async (input) => {
+		try {
+			const topology = input.graphDigest === void 0 ? parseGraphSubtaskTopology(input.graph) : await storedGraphTopology(options.graphRegistry, input.graphDigest);
+			const prepared = prepareGraphSubtask(topology, {
+				registry: kernelPromptRegistry(),
+				...analysts ? { analysts } : {},
+				...guidanceComposer ? { guidance: guidanceComposer } : {}
+			});
+			for (const profile of [prepared.profile, ...topology.nodes.filter((node) => node.id !== prepared.root).map((node) => guidanceComposer?.(node.profile) ?? node.profile)]) {
+				assertProfileModelsAllowed(profile, options.allowedModels);
+				options.resolveSpawnProfile?.(profile);
+			}
+			return {
+				ok: true,
+				...prepared
+			};
+		} catch (error) {
+			return {
+				ok: false,
+				reason: errMessage(error)
+			};
+		}
+	} } : void 0;
+	const graphOverlayFor = (topology) => {
+		const registry = kernelPromptRegistry();
+		const overlay = createGraphOverlay(validateGraphTopology(topology.nodes, topology.edges, registry, analysts), {
+			registry,
+			journal,
+			runId,
+			now,
+			...guidanceComposer ? { guidance: guidanceComposer } : {},
+			...options.authorizeSpawn ? { authorizeSpawn: options.authorizeSpawn } : {},
+			subtask: true
+		});
+		graphOverlays.add(overlay);
+		return overlay;
+	};
 	let makeWorkerAgent = options.makeWorkerAgent;
 	if (!makeWorkerAgent) {
 		if (!options.backend && !options.makeLeafAgent) throw new ValidationError("supervise: provide opts.backend (where workers run), opts.makeLeafAgent, or opts.makeWorkerAgent");
 		const withRetry = (make) => withWorkerSpawnRetry(make, options.workerRetry, { ...options.onWorkerRetry ? { onRetry: options.onWorkerRetry } : {} });
 		const makeLeaf = withRetry(options.makeLeafAgent ?? workerFromBackend(options.backend, deliverable));
 		const securityPolicy = options.profileSecurity ?? DEFAULT_AUTHORED_PROFILE_SECURITY_POLICY;
-		const makeRecursiveWorkerFor = (parent, parentIdentity, depth, parentOwnerId, analystLineage = false, peerRootOwnerId) => {
+		const makeRecursiveWorkerFor = (parent, parentIdentity, depth, parentOwnerId, analystLineage = false, peerRootOwnerId, graph) => {
 			const makeRecursiveWorker = (authoredProfile, spawnContext, recovering = false) => {
 				if (!spawnContext) throw new ValidationError("supervise: backend-derived workers require spawn context");
 				const input = freezeDetachedProfile(authoredProfile);
@@ -4628,7 +5312,8 @@ function superviseInternal(profile, task, opts, testBrain) {
 					...spawnContext.analyst !== void 0 ? { analyst: spawnContext.analyst } : {},
 					...spawnContext.continuity !== void 0 ? { continuity: spawnContext.continuity } : {}
 				});
-				const decision = !recovering && options.authorizeSpawn ? freezeDetached(options.authorizeSpawn(authorizationInput)) : Object.freeze({
+				const authorize = graph?.authorizeSpawn ?? options.authorizeSpawn;
+				const decision = !recovering && authorize ? freezeDetached(authorize(authorizationInput)) : Object.freeze({
 					profile: input,
 					...spawnContext.execution ? { execution: spawnContext.execution } : {}
 				});
@@ -4666,6 +5351,10 @@ function superviseInternal(profile, task, opts, testBrain) {
 					}));
 				}
 				const ownerId = childCoordinationOwner(parentOwnerId, childExecution.identity, spawnContext, depth);
+				const subtask = graphSubtaskOf(authorized);
+				if (subtask !== void 0 && graph !== void 0) throw new ValidationError("supervise: a node of a graph cannot start another graph; add the work as nodes");
+				const ownGraph = subtask === void 0 ? void 0 : graphOverlayFor(subtask);
+				const subtreeGraph = ownGraph ?? graph;
 				const nestedDriveHarness = isExternalSupervisor(authorized) ? driveHarnessForOwner(freezeDetached({
 					runId,
 					runNamespace,
@@ -4680,9 +5369,22 @@ function superviseInternal(profile, task, opts, testBrain) {
 				assertProfileContract(authorized, isExternalSupervisor(authorized) ? driverMaterialization : promptModelProfileMaterialization, `supervise driver ${JSON.stringify(spawnContext.label)}`, true);
 				if (managerBackend) assertBridgeProfileMaterializes(profileWithoutDeclaredRuntimeCoordinationTools(authorized), managerBackend, `supervise driver ${JSON.stringify(spawnContext.label)}`);
 				const rootPeerOwner = options.peerAudit ? depth === 1 ? ownerId : peerRootOwnerId : void 0;
-				const childFactory = makeRecursiveWorkerFor(authorized, childExecution.identity, depth + 1, ownerId, analystLineage || spawnContext.analyst !== void 0 || spawnContext.assignmentId.startsWith("analyst:"), rootPeerOwner);
+				const childFactory = makeRecursiveWorkerFor(authorized, childExecution.identity, depth + 1, ownerId, analystLineage || spawnContext.analyst !== void 0 || spawnContext.assignmentId.startsWith("analyst:"), rootPeerOwner, subtreeGraph);
 				const nestedPerWorker = defaultPerWorker(spawnContext.budget, ownerShare);
-				const authorizeNestedMessage = authorizeDownFor(authorized, depth + 1);
+				const runMessageAuthority = authorizeDownFor(authorized, depth + 1);
+				const authorizeNestedMessage = subtreeGraph && runMessageAuthority ? subtreeGraph.observeMessages(runMessageAuthority) : runMessageAuthority;
+				const nestedAnalyzeOnSettle = subtreeGraph ? subtreeGraph.routes.length > 0 ? subtreeGraph.routes : void 0 : options.analyzeOnSettle;
+				const nestedContinuity = subtreeGraph ? Object.keys(subtreeGraph.continuityByProfile).length > 0 ? subtreeGraph.continuityByProfile : void 0 : options.continuityByProfile;
+				const runResolveSpawnProfile = options.resolveSpawnProfile;
+				const nestedResolveSpawnProfile = subtreeGraph ? (authored) => {
+					const pinned = subtreeGraph.resolveSpawnProfile(authored);
+					return runResolveSpawnProfile && pinned !== authored ? runResolveSpawnProfile(pinned) : pinned;
+				} : runResolveSpawnProfile;
+				const nestedComposeSpawnProfile = subtreeGraph ? composeSpawnProfile : composeSpawnProfileFor(authorized);
+				const nestedObserveNodeEvent = subtreeGraph ? async (context, event, record) => {
+					await observeNodeEvent?.(context, event, record);
+					subtreeGraph.onCoordinationEvent(event);
+				} : observeNodeEvent;
 				let acceptedSubmission = false;
 				let unassessedOutput = false;
 				const peerAudit = depth === 1 ? peerAuditFor(spawnContext.parentNodeId) : void 0;
@@ -4695,6 +5397,7 @@ function superviseInternal(profile, task, opts, testBrain) {
 					},
 					...spawnResourceRoot === void 0 ? {} : { spawnResourceRoot },
 					makeWorkerAgent: childFactory,
+					...graphSubtasks ? { graphs: graphSubtasks } : {},
 					...spawnContext.sourceEvidenceRefs ? { sourceEvidenceRefs: spawnContext.sourceEvidenceRefs } : {},
 					...authorizeNestedMessage ? { authorizeDownMessage: authorizeNestedMessage } : {},
 					perWorker: nestedPerWorker,
@@ -4712,20 +5415,20 @@ function superviseInternal(profile, task, opts, testBrain) {
 						...rootPeerOwner ? { peerRootOwnerId: rootPeerOwner } : {}
 					},
 					...options.resolveSupervisorTools ? { resolveSupervisorTools: options.resolveSupervisorTools } : {},
-					...observeNodeEvent ? {
-						observeNodeEvent,
+					...nestedObserveNodeEvent ? {
+						observeNodeEvent: nestedObserveNodeEvent,
 						replaySettlements: true
 					} : {},
 					...analysts ? { analysts } : {},
 					...options.escalateQuestion ? { escalateQuestion: options.escalateQuestion } : {},
-					...!analystLineage && spawnContext.analyst === void 0 && !spawnContext.assignmentId.startsWith("analyst:") && options.analyzeOnSettle ? { analyzeOnSettle: options.analyzeOnSettle } : {},
+					...!analystLineage && spawnContext.analyst === void 0 && !spawnContext.assignmentId.startsWith("analyst:") && nestedAnalyzeOnSettle ? { analyzeOnSettle: nestedAnalyzeOnSettle } : {},
 					...options.watchWorkers ? { watchWorkers: options.watchWorkers } : {},
 					...options.stallAfterMs !== void 0 ? { stallAfterMs: options.stallAfterMs } : {},
 					...options.wake !== void 0 ? { wake: options.wake } : {},
-					...options.continuityByProfile ? { continuityByProfile: options.continuityByProfile } : {},
+					...nestedContinuity ? { continuityByProfile: nestedContinuity } : {},
 					...spawnPreflight ? { preflightSpawn: spawnPreflight } : {},
-					...options.resolveSpawnProfile ? { resolveSpawnProfile: options.resolveSpawnProfile } : {},
-					...composeSpawnProfileFor(authorized) ? { composeSpawnProfile: composeSpawnProfileFor(authorized) } : {},
+					...nestedResolveSpawnProfile ? { resolveSpawnProfile: nestedResolveSpawnProfile } : {},
+					...nestedComposeSpawnProfile ? { composeSpawnProfile: nestedComposeSpawnProfile } : {},
 					...profileTable ? { profiles: profileTable } : {},
 					...options.peerMail ? { peerMail: options.peerMail } : {},
 					...options.stopRule ? { stopRule: stopRuleOf(options.stopRule) } : {},
@@ -4753,7 +5456,7 @@ function superviseInternal(profile, task, opts, testBrain) {
 					},
 					...options.steerDir === void 0 ? {} : { steerDir: resolve(options.steerDir) },
 					...options.runDir === void 0 && options.steerDir === void 0 ? {} : { controlScope: "subtree" }
-				}), journal, childExecution.ref, () => acceptedSubmission, recoveryFactories.get(childFactory), () => unassessedOutput, seatManagedLeaf ? childDeliverable : void 0);
+				}), journal, childExecution.ref, () => acceptedSubmission, recoveryFactories.get(childFactory), () => unassessedOutput, seatManagedLeaf ? childDeliverable : void 0, ownGraph ? (out) => graphSubtaskOutput(ownGraph, out) : void 0);
 			};
 			if (options.makeLeafAgent === void 0 && options.backend?.backend === "provider" && !options.backend.steering) {
 				const factory = registerRetainedExecutorPreparation(createExecutor(options.backend), ({ spawned, profile, task }) => {
@@ -4805,6 +5508,7 @@ function superviseInternal(profile, task, opts, testBrain) {
 			...rootPeerAudit ? { peerAudit: rootPeerAudit } : {},
 			blobs,
 			makeWorkerAgent: workerFactory,
+			...graphSubtasks ? { graphs: graphSubtasks } : {},
 			...authorizeRootMessage ? { authorizeDownMessage: authorizeRootMessage } : {},
 			perWorker,
 			...ownerShare > 0 ? { preserveOwnerTurns: true } : {},
@@ -4883,7 +5587,19 @@ function superviseInternal(profile, task, opts, testBrain) {
 			now
 		}) : void 0;
 		const recorder = spans;
-		const hooks = recorder ? composeRuntimeHooks(options.hooks, recorder.hooks) : options.hooks;
+		const graphSpawnBinder = graphSubtasks ? { onEvent: (event) => {
+			if (graphOverlays.size === 0) return;
+			if (event.target !== "agent.spawn" || event.phase !== "after") return;
+			const payload = event.payload;
+			if (typeof payload?.childId !== "string" || typeof payload.assignmentId !== "string") return;
+			const writes = [];
+			for (const overlay of graphOverlays) {
+				const write = overlay.bindSpawn(event.parentId, payload.assignmentId, payload.childId);
+				if (write !== void 0) writes.push(write);
+			}
+			return writes.length === 0 ? void 0 : Promise.all(writes).then(() => void 0);
+		} } : void 0;
+		const hooks = recorder || graphSpawnBinder ? composeRuntimeHooks(options.hooks, recorder?.hooks, graphSpawnBinder) : options.hooks;
 		const supervisor = createSupervisor();
 		if (runControl !== void 0) supervisor.attach(runControl);
 		const cancellation = options.runDir !== void 0 && runControl !== void 0 ? watchRunCancellation(resolve(options.runDir), cancelDurableRun) : void 0;
@@ -4999,6 +5715,6 @@ function rootProviderModelEvidenceFromExecution(evidence) {
 	return evidence ?? rootProviderModelEvidence([]);
 }
 //#endregion
-export { serveCoordinationMcp as S, readRootStream as _, superviseRootProfile as a, composeReentryTask as b, isPreSpawnExecutorFailure as c, withWorkerSpawnRetry as d, assertCoordinationBinding as f, ROOT_STREAM_FILE as g, supervisorAgentWithTestBrain as h, superviseFleetCapabilities as i, resolveWorkerSpawnRetry as l, supervisorAgent as m, profileGuidanceComposer as n, superviseWithTestBrain as o, resolveSupervisorProfile as p, supervise as r, workerFromBackend as s, DEFAULT_AUTHORED_PROFILE_SECURITY_POLICY as t, retryPreSpawnRefusals as u, readRootStreamReceipt as v, createSupervisorSpanRecorder as x, UNPROVEN_CONTINUITY as y };
+export { dumbContinuationPassPrompt as A, defaultEdgeTraversalCap as C, createPromptRegistry as D, analyzesFindingsReportPrompt as E, serveCoordinationMcp as F, kernelPromptRegistry as M, naiveContinuationPrompt as N, delegatesWorkerBriefPrompt as O, promptHandle as P, createGraphOverlay as S, validateGraphTopology as T, readRootStream as _, superviseRootProfile as a, composeReentryTask as b, isPreSpawnExecutorFailure as c, withWorkerSpawnRetry as d, assertCoordinationBinding as f, ROOT_STREAM_FILE as g, supervisorAgentWithTestBrain as h, superviseFleetCapabilities as i, formatPromptHandle as j, dumbContinuationFailPrompt as k, resolveWorkerSpawnRetry as l, supervisorAgent as m, profileGuidanceComposer as n, superviseWithTestBrain as o, resolveSupervisorProfile as p, supervise as r, workerFromBackend as s, DEFAULT_AUTHORED_PROFILE_SECURITY_POLICY as t, retryPreSpawnRefusals as u, readRootStreamReceipt as v, graphRootProfile as w, createSupervisorSpanRecorder as x, UNPROVEN_CONTINUITY as y };
 
-//# sourceMappingURL=supervise-FOCAUADN.js.map
+//# sourceMappingURL=supervise-BlaB4CeL.js.map