@tangle-network/agent-runtime 0.326.1 → 0.328.0

package/dist/{supervise-DZMOajvP.js → supervise-9WPjMFrH.js}

@@ -5,7 +5,7 @@ import { $ as isAsyncIterable$1, Ot as teardownExecutor, U as addSpend, Y as err
 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-CwisRZNE.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-B7Z9jgFr.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";
@@ -650,6 +650,7 @@ async function serveCoordinationMcpForManager(opts, lifetime) {
 		...opts.onStop ? { onStop: opts.onStop } : {},
 		...opts.analysts ? { analysts: opts.analysts } : {},
 		...opts.analyzeOnSettle ? { analyzeOnSettle: opts.analyzeOnSettle } : {},
+		...opts.mapOnSettle ? { mapOnSettle: opts.mapOnSettle } : {},
 		...opts.sourceEvidenceRefs ? { sourceEvidenceRefs: opts.sourceEvidenceRefs } : {},
 		...opts.peerAudit ? { peerAudit: opts.peerAudit } : {},
 		...opts.watchWorkers ? { watchWorkers: opts.watchWorkers } : {},
@@ -1059,14 +1060,19 @@ function kernelPromptRegistry() {
 * 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).
+* (`authorizeSpawn`, `resolveSpawnProfile`, `analyzeOnSettle`, `mapOnSettle`,
+* `continuityByProfile`) and observes what the kernel reports back (spawn bindings, steers,
+* findings, map steps).
 */
 /** Default per-edge traversal cap — the cyclic-graph backstop when an edge names none. */
 const defaultEdgeTraversalCap = 32;
+const mapItemFailurePolicies = ["all-or-refuse", "settled-subset"];
 function edgeId(edge) {
-	return edge.kind === "delegates" ? `delegates:${edge.from}->${edge.to}` : `analyzes:${edge.analyst}:${edge.over.join("+")}->${edge.to}`;
+	if (edge.kind === "delegates") return `delegates:${edge.from}->${edge.to}`;
+	if (edge.kind === "maps") return `maps:${edge.from}->${edge.to ?? "graph"}->${edge.join}`;
+	return `analyzes:${edge.analyst}:${edge.over.join("+")}->${edge.to}`;
 }
+const isPositiveInteger = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 1;
 /** 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) {
@@ -1087,8 +1093,13 @@ function validateGraphTopology(nodes, edges, registry, analysts) {
 		if (!node) throw new ValidationError(`runGraph: ${where} references unknown node '${id}'`);
 		return node;
 	};
+	for (const edge of edges) {
+		const kind = edge.kind;
+		if (kind !== "delegates" && kind !== "analyzes" && kind !== "maps") throw new ValidationError(`runGraph: edge kind ${JSON.stringify(kind)} is not 'delegates', 'analyzes' or 'maps'`);
+	}
 	const delegates = edges.filter((edge) => edge.kind === "delegates");
 	const analyzes = edges.filter((edge) => edge.kind === "analyzes");
+	const maps = edges.filter((edge) => edge.kind === "maps");
 	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) {
@@ -1133,31 +1144,101 @@ function validateGraphTopology(nodes, edges, registry, analysts) {
 		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`);
+	const { mapNodes, mapItemNames } = validateMaps(maps, {
+		byId,
+		root,
+		workers,
+		analystNodes,
+		registry,
+		analysts
+	});
+	for (const node of nodes) if (node.id !== root.id && !workers.has(node.id) && !analystNodes.has(node.id) && !mapNodes.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
+		analystNodes,
+		maps,
+		mapNodes,
+		mapItemNames
+	};
+}
+/**
+* Refuse a maps edge the runtime could not run as authored. A map's item and join nodes are the
+* runtime's to spawn, so neither may be the root, a delegates target, an analyst, or a node of
+* another map: a second way to reach the node would make its ledger rows and its pinning ambiguous.
+* The source must be a node that settles as a worker: a delegates target, or another map's join.
+*/
+function validateMaps(maps, graph) {
+	const mapNodes = /* @__PURE__ */ new Map();
+	const mapItemNames = /* @__PURE__ */ new Map();
+	const joins = /* @__PURE__ */ new Set();
+	for (const edge of maps) {
+		const id = edgeId(edge);
+		const refuse = (why) => {
+			throw new ValidationError(`runGraph: ${id} ${why}`);
+		};
+		if (edge.continuity !== void 0) refuse("carries continuity — every map item is a fresh session over its own element");
+		if (typeof edge.pointer !== "string" || edge.pointer !== "" && !edge.pointer.startsWith("/")) refuse(`has pointer ${JSON.stringify(edge.pointer)} — a JSON pointer is '' or starts with '/'`);
+		if (!isPositiveInteger(edge.maxItems)) refuse("needs maxItems as a positive integer");
+		if (!isPositiveInteger(edge.concurrency)) refuse(`has concurrency ${JSON.stringify(edge.concurrency)} — it needs a positive integer; concurrency throttles the items, so a value below 1 could never start one`);
+		if (!mapItemFailurePolicies.includes(edge.onItemFailure)) refuse(`needs onItemFailure 'all-or-refuse' or 'settled-subset'`);
+		if (edge.itemBudget !== void 0 && (typeof edge.itemBudget !== "object" || edge.itemBudget === null || Array.isArray(edge.itemBudget))) refuse("has an itemBudget that is not a budget object");
+		if (edge.to === void 0 === (edge.graph === void 0)) refuse("needs exactly one of to (an item node) or graph (a graph run per item)");
+		if (typeof edge.join !== "string") refuse("needs a join node");
+		if (edge.to !== void 0 && edge.to === edge.join) refuse("joins into its own item node");
+		for (const nodeId of edge.to === void 0 ? [edge.join] : [edge.to, edge.join]) {
+			const node = graph.byId.get(nodeId);
+			if (!node) refuse(`references unknown node '${nodeId}'`);
+			if (nodeId === graph.root.id || graph.workers.has(nodeId) || graph.analystNodes.has(nodeId) || mapNodes.has(nodeId)) refuse(`names node '${nodeId}', which the graph already reaches another way — a map's item and join nodes are spawned only by their maps edge, never as the root, a delegates target, an analyst, or a node of another map`);
+			mapNodes.set(nodeId, node);
+		}
+		joins.add(edge.join);
+		if (edge.to !== void 0) mapItemNames.set(id, edge.to);
+		else try {
+			const prepared = prepareGraphSubtask(parseGraphSubtaskTopology(edge.graph), {
+				registry: graph.registry,
+				...graph.analysts ? { analysts: graph.analysts } : {}
+			});
+			mapItemNames.set(id, prepared.root);
+		} catch (error) {
+			refuse(`has a graph item that cannot run: ${errMessage(error)}`);
+		}
+	}
+	for (const edge of maps) {
+		if (!graph.byId.has(edge.from)) throw new ValidationError(`runGraph: ${edgeId(edge)} references unknown node '${edge.from}'`);
+		if (!graph.workers.has(edge.from) && !joins.has(edge.from)) throw new ValidationError(`runGraph: ${edgeId(edge)} maps over '${edge.from}', which never settles as a worker — a map's source is a delegates target or another map's join`);
+		if (edge.from === edge.join) throw new ValidationError(`runGraph: ${edgeId(edge)} maps over its own join`);
+	}
+	return {
+		mapNodes,
+		mapItemNames
 	};
 }
 /** 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 { root, workers, delegatesByWorker, analyzes, analystNodes, maps, mapItemNames } = 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 workerLines = [...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})`;
+	});
+	const mapLines = maps.map((edge) => `- when '${edge.from}' settles, the runtime runs '${mapItemNames.get(edgeId(edge))}'${edge.to === void 0 ? " (a graph)" : ""} once per element of ${edge.pointer === "" ? "its result" : `${JSON.stringify(edge.pointer)} in its result`} (at most ${edge.maxItems} elements, ${edge.concurrency} at a time), then '${edge.join}' with the ordered results; '${edge.join}' settles to you like a worker, and a refused map arrives as a map event`);
 	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})`;
-		}),
+		...workerLines,
+		...mapLines.length > 0 ? [
+			"",
+			"MAPS (the runtime spawns these nodes; never spawn them yourself):",
+			...mapLines
+		] : [],
 		...driverAnalyzesBriefs.length > 0 ? ["", ...driverAnalyzesBriefs] : []
 	].join("\n");
 	return {
@@ -1177,14 +1258,37 @@ function stringifyPayload(payload) {
 		return String(payload);
 	}
 }
+/** Each graph's pinning, mapped to the product authority it wraps. */
+const productAuthorities = /* @__PURE__ */ new WeakMap();
+/**
+* The product authority behind a spawn authority. A graph started inside a run composes its own
+* pinning with the run's product authority. When that run is itself a graph (`runGraph`), the run's
+* `authorizeSpawn` is the outer graph's pinning, which would refuse every node of the inner graph,
+* so the inner graph composes with the authority the outer pinning wraps instead.
+*/
+function productSpawnAuthority(authorize) {
+	return authorize !== void 0 && productAuthorities.has(authorize) ? productAuthorities.get(authorize) : authorize;
+}
+/** A node profile with an edge directive appended to its standing instructions. */
+function withDirective(profile, directiveText) {
+	if (directiveText.length === 0) return profile;
+	return {
+		...profile,
+		prompt: {
+			...profile.prompt ?? {},
+			instructions: [...profile.prompt?.instructions ?? [], directiveText]
+		}
+	};
+}
 /**
 * 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 { root, workers, delegatesByWorker, analyzes, analystNodes, maps, mapNodes, mapItemNames } = validated;
 	const { registry, journal, runId, now } = opts;
+	const mapsById = new Map(maps.map((edge) => [edgeId(edge), edge]));
 	const ledger = [];
 	const journaled = /* @__PURE__ */ new Set();
 	const traversalCounts = /* @__PURE__ */ new Map();
@@ -1215,6 +1319,7 @@ function createGraphOverlay(validated, opts) {
 			continuity: entry.continuity,
 			bytes: entry.bytes,
 			...entry.reason !== void 0 ? { reason: entry.reason } : {},
+			...entry.map !== void 0 ? { map: entry.map } : {},
 			seq: ledgerSeq++,
 			at: new Date(now()).toISOString()
 		});
@@ -1256,6 +1361,7 @@ function createGraphOverlay(validated, opts) {
 			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.map !== void 0) return pinMapSpawn(input, requested);
 		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.`);
@@ -1298,18 +1404,31 @@ function createGraphOverlay(validated, opts) {
 		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]
-			}
+		return withDirective(node.profile, directiveText);
+	};
+	const pinMapSpawn = (input, requested) => {
+		const marker = input.map;
+		const edge = mapsById.get(marker.edge);
+		const refuse = (why) => {
+			throw new ValidationError(`runGraph: map spawn for ${JSON.stringify(marker.edge)} ${why}`);
 		};
+		if (edge === void 0) return refuse("names no maps edge of this graph");
+		if (marker.role === "join") {
+			if (requested !== edge.join) refuse(`names ${JSON.stringify(requested)}, not its join`);
+			return mapNodes.get(edge.join).profile;
+		}
+		if (edge.to !== void 0) {
+			if (requested !== edge.to) refuse(`names ${JSON.stringify(requested)}, not its item node`);
+			return withDirective(mapNodes.get(edge.to).profile, registry.resolve(edge.directive).text);
+		}
+		const carried = graphSubtaskOf(input.profile);
+		if (carried === void 0 || canonicalCandidateDigest(carried) !== canonicalCandidateDigest(parseGraphSubtaskTopology(edge.graph))) refuse("carries a graph other than its maps edge's");
+		return input.profile;
 	};
 	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);
+		const node = requested === void 0 ? void 0 : workers.get(requested) ?? analystNodes.get(requested) ?? mapNodes.get(requested);
 		return node ? composeGuidance(node.profile) : authored;
 	};
 	const authorizeSpawn = (input) => {
@@ -1320,6 +1439,7 @@ function createGraphOverlay(validated, opts) {
 			profile: pinned
 		});
 	};
+	productAuthorities.set(authorizeSpawn, opts.authorizeSpawn);
 	const routes = analyzes.map((edge) => {
 		const analystNode = analystNodes.get(edge.analyst);
 		if (analystNode) return {
@@ -1339,6 +1459,17 @@ function createGraphOverlay(validated, opts) {
 			directive: registry.resolve(edge.directive).text
 		};
 	});
+	const mapRoutes = maps.map((edge) => ({
+		edge: edgeId(edge),
+		from: edge.from,
+		pointer: edge.pointer,
+		item: edge.to !== void 0 ? { profile: mapNodes.get(edge.to).profile } : { graph: edge.graph },
+		join: mapNodes.get(edge.join).profile,
+		maxItems: edge.maxItems,
+		concurrency: edge.concurrency,
+		onItemFailure: edge.onItemFailure,
+		...edge.itemBudget !== void 0 ? { itemBudget: edge.itemBudget } : {}
+	}));
 	const continuityByProfile = {};
 	for (const [nodeId, edge] of delegatesByWorker) if (edge.continuity !== void 0) continuityByProfile[nodeId] = edge.continuity;
 	const strippedByDigest = /* @__PURE__ */ new Map();
@@ -1374,6 +1505,31 @@ function createGraphOverlay(validated, opts) {
 		}, true);
 	};
 	const onCoordinationEvent = (event) => {
+		if (event.type === "map") {
+			const step = event.map;
+			const edge = mapsById.get(step.edge);
+			if (!edge) return;
+			const itemName = mapItemNames.get(step.edge);
+			if (step.workerId !== void 0) nodeByWorkerId.set(step.workerId, step.phase === "join" ? edge.join : itemName);
+			const directiveBytes = step.phase === "item" && step.workerId !== void 0 && edge.to !== void 0 ? byteLength(registry.resolve(edge.directive).text) : 0;
+			record({
+				edge: step.edge,
+				kind: "maps",
+				from: step.phase === "join" ? itemName : edge.from,
+				to: step.phase === "join" ? edge.join : itemName,
+				directive: formatPromptHandle(edge.directive),
+				outcome: step.outcome,
+				continuity: "fresh",
+				bytes: step.bytes + directiveBytes,
+				...step.reason !== void 0 ? { reason: step.reason } : {},
+				workerId: step.phase === "expand" ? step.sourceWorker : step.workerId,
+				map: {
+					phase: step.phase,
+					...step.index !== void 0 ? { index: step.index } : {}
+				}
+			}, true);
+			return;
+		}
 		if (event.type === "finding") {
 			const edge = driverAnalyzesByAnalyst.get(event.finding.analyst);
 			if (!edge) return;
@@ -1438,6 +1594,7 @@ function createGraphOverlay(validated, opts) {
 	};
 	return {
 		routes,
+		maps: mapRoutes,
 		continuityByProfile,
 		authorizeSpawn,
 		resolveSpawnProfile,
@@ -1491,7 +1648,11 @@ function parseGraphSubtaskTopology(raw) {
 				...edge,
 				directive
 			};
-			throw new ValidationError(`run_graph: ${where}.kind must be 'delegates' or 'analyzes'`);
+			if (edge.kind === "maps") return {
+				...edge,
+				directive
+			};
+			throw new ValidationError(`run_graph: ${where}.kind must be 'delegates', 'analyzes' or 'maps'`);
 		})
 	};
 }
@@ -1969,7 +2130,7 @@ function stateLines(state, full, tools) {
 	else if (full) lines.push("Workers settled: none.");
 	if (state.waiting.length > 0) lines.push(`Events waiting for you: ${state.waiting.length} (${state.waiting.map((event) => event.worker === void 0 ? event.type : `${event.type} from ${event.worker}`).join("; ")}).`);
 	else if (full) lines.push("Events waiting for you: none.");
-	if (state.unacknowledged.length > 0) lines.push(`Events delivered to a turn that has not finished, so treat them as unread: ${state.unacknowledged.map((event) => `#${event.seq} ${event.type}${event.worker === void 0 ? "" : ` from ${event.worker}`}`).join("; ")}.`);
+	if (state.unacknowledged.length > 0) lines.push(`Events delivered to a turn that has not finished, so treat them as unread (${state.unacknowledged.length}):`, ...state.unacknowledged.map((event) => `- ${JSON.stringify(event.event)}`));
 	if (state.lastRejection !== void 0) lines.push(`Your last submit_result was refused: ${state.lastRejection.reason}`);
 	return lines;
 }
@@ -2587,6 +2748,7 @@ function buildSupervisorAgent(profile, deps, testBrain) {
 			...deps.executeExtraTool ? { executeExtraTool: deps.executeExtraTool } : {},
 			...deps.analysts ? { analysts: deps.analysts } : {},
 			...deps.analyzeOnSettle ? { analyzeOnSettle: deps.analyzeOnSettle } : {},
+			...deps.mapOnSettle ? { mapOnSettle: deps.mapOnSettle } : {},
 			...deps.sourceEvidenceRefs ? { sourceEvidenceRefs: deps.sourceEvidenceRefs } : {},
 			...deps.peerAudit ? { peerAudit: deps.peerAudit } : {},
 			...deps.escalateQuestion ? { escalateQuestion: deps.escalateQuestion } : {},
@@ -2706,6 +2868,7 @@ function buildSupervisorAgent(profile, deps, testBrain) {
 				},
 				...deps.analysts ? { analysts: deps.analysts } : {},
 				...deps.analyzeOnSettle ? { analyzeOnSettle: deps.analyzeOnSettle } : {},
+				...deps.mapOnSettle ? { mapOnSettle: deps.mapOnSettle } : {},
 				...deps.sourceEvidenceRefs ? { sourceEvidenceRefs: deps.sourceEvidenceRefs } : {},
 				...deps.peerAudit ? { peerAudit: deps.peerAudit } : {},
 				...deps.escalateQuestion ? { escalateQuestion: deps.escalateQuestion } : {},
@@ -4543,6 +4706,7 @@ const superviseOptionKeySet = /* @__PURE__ */ new Set([
 	"allowedModels",
 	"analysts",
 	"analyzeOnSettle",
+	"mapOnSettle",
 	"authorizeMessage",
 	"authorizeSpawn",
 	"backend",
@@ -5311,6 +5475,7 @@ function superviseInternal(profile, task, opts, testBrain) {
 			};
 		}
 	} } : void 0;
+	const productAuthority = productSpawnAuthority(options.authorizeSpawn);
 	const graphOverlayFor = (topology) => {
 		const registry = kernelPromptRegistry();
 		const overlay = createGraphOverlay(validateGraphTopology(topology.nodes, topology.edges, registry, analysts), {
@@ -5319,7 +5484,7 @@ function superviseInternal(profile, task, opts, testBrain) {
 			runId,
 			now,
 			...guidanceComposer ? { guidance: guidanceComposer } : {},
-			...options.authorizeSpawn ? { authorizeSpawn: options.authorizeSpawn } : {},
+			...productAuthority ? { authorizeSpawn: productAuthority } : {},
 			subtask: true
 		});
 		graphOverlays.add(overlay);
@@ -5347,6 +5512,7 @@ function superviseInternal(profile, task, opts, testBrain) {
 					...spawnContext.key !== void 0 ? { key: spawnContext.key } : {},
 					depth,
 					...spawnContext.analyst !== void 0 ? { analyst: spawnContext.analyst } : {},
+					...spawnContext.map !== void 0 ? { map: spawnContext.map } : {},
 					...spawnContext.continuity !== void 0 ? { continuity: spawnContext.continuity } : {}
 				});
 				const authorize = graph?.authorizeSpawn ?? options.authorizeSpawn;
@@ -5389,7 +5555,7 @@ 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");
+				if (subtask !== void 0 && graph !== void 0 && spawnContext.map === 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 ownSubmission = selectedDeliverable === void 0 && (subtreeGraph !== void 0 || deliverable !== void 0);
@@ -5413,6 +5579,7 @@ function superviseInternal(profile, task, opts, testBrain) {
 				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 nestedMapOnSettle = subtreeGraph ? subtreeGraph.maps.length > 0 ? subtreeGraph.maps : void 0 : options.mapOnSettle;
 				const nestedContinuity = subtreeGraph ? Object.keys(subtreeGraph.continuityByProfile).length > 0 ? subtreeGraph.continuityByProfile : void 0 : options.continuityByProfile;
 				const runResolveSpawnProfile = options.resolveSpawnProfile;
 				const nestedResolveSpawnProfile = subtreeGraph ? (authored) => {
@@ -5464,6 +5631,7 @@ function superviseInternal(profile, task, opts, testBrain) {
 					...options.watchWorkers ? { watchWorkers: options.watchWorkers } : {},
 					...options.stallAfterMs !== void 0 ? { stallAfterMs: options.stallAfterMs } : {},
 					...options.wake !== void 0 ? { wake: options.wake } : {},
+					...nestedMapOnSettle ? { mapOnSettle: nestedMapOnSettle } : {},
 					...nestedContinuity ? { continuityByProfile: nestedContinuity } : {},
 					...spawnPreflight ? { preflightSpawn: spawnPreflight } : {},
 					...nestedResolveSpawnProfile ? { resolveSpawnProfile: nestedResolveSpawnProfile } : {},
@@ -5590,6 +5758,7 @@ function superviseInternal(profile, task, opts, testBrain) {
 			...options.watchWorkers ? { watchWorkers: options.watchWorkers } : {},
 			...options.stallAfterMs !== void 0 ? { stallAfterMs: options.stallAfterMs } : {},
 			...options.wake !== void 0 ? { wake: options.wake } : {},
+			...options.mapOnSettle ? { mapOnSettle: options.mapOnSettle } : {},
 			...options.continuityByProfile ? { continuityByProfile: options.continuityByProfile } : {},
 			...options.stopRule ? { stopRule: stopRuleOf(options.stopRule) } : {},
 			...options.onProgressStop ? { onProgressStop: options.onProgressStop } : {},
@@ -5756,4 +5925,4 @@ function rootProviderModelEvidenceFromExecution(evidence) {
 //#endregion
 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-DZMOajvP.js.map
+//# sourceMappingURL=supervise-9WPjMFrH.js.map