@tangle-network/agent-runtime 0.126.0 → 0.128.0

package/dist/{runtime-BzXz7OjS.js → runtime-5uDVVfER.js}

@@ -1,16 +1,17 @@
 import { n as AnalystError, r as BackendTransportError, s as PlannerError, u as ValidationError } from "./errors-DEAvWQPy.js";
 import { i as normalizeBackendStreamEvent, o as newRuntimeSession, s as nowIso } from "./backends-CiOCyRHb.js";
-import { i as InMemorySpawnJournal, r as InMemoryResultBlobStore, v as isTraceAnalysisStore } from "./spawn-journal-DsZKDqeh.js";
+import { i as InMemorySpawnJournal, r as InMemoryResultBlobStore, v as isTraceAnalysisStore, x as contentAddress } from "./spawn-journal-DsZKDqeh.js";
 import { a as randomSuffix, c as stringifySafe, f as zeroTokenUsage, r as isAbortError, s as sleep, t as addTokenUsage } from "./util-MVgdwuIS.js";
 import { i as redactProtectedValue, r as redactProtectedReason } from "./protected-redaction--F3v1oo8.js";
-import { _t as routerChatWithUsage, bt as runBrainLoop, en as isHarnessNativeModel, et as rollingDispatch, ht as routerBrain, l as withDriverExecutor, m as settledToIteration, n as createSupervisor } from "./supervisor-DpjO0Gmy.js";
+import { $t as concreteProfileModel, Qt as concreteModelId, _t as routerChatWithUsage, bt as runBrainLoop, ct as attestRuntimeOwnedExecutor, dt as newExecutionAttemptId, en as isHarnessNativeModel, et as rollingDispatch, ht as routerBrain, l as withDriverExecutor, m as settledToIteration, n as createSupervisor } from "./supervisor-DpjO0Gmy.js";
 import { C as observe, O as strategyAuthorMethod, b as sample, v as refine, x as sampleThenRefine, y as runAgentic } from "./structural-rollout-zY0oqQzO.js";
 import { i as notifyRuntimeHookEvent, t as composeRuntimeHooks } from "./runtime-hooks-C7iJOWm3.js";
 import { a as notifySandboxEventObserver, i as mapSandboxToolEvent, r as mapSandboxEvent, t as createSandboxToolPartState } from "./sandbox-events-Yhd1GYWl.js";
-import { Ct as createWorktreeCliExecutor, Et as createPushTraceSource, Ft as probeSandboxCapabilities, Mt as runAgentRounds, Pt as createSandboxLineage, Qt as kernelPromptRegistry, St as createExecutorRegistry, Zt as formatPromptHandle, jt as defaultSelectWinner, n as supervise, nn as gateOnDeliverable, r as workerFromBackend, xt as createExecutor } from "./supervise-Ds8FtyI9.js";
+import { $t as kernelPromptRegistry, Ct as mergeAbortSignals, Ft as createSandboxLineage, It as probeSandboxCapabilities, Nt as defaultSelectWinner, Ot as createPushTraceSource, Pt as runAgentRounds, Qt as formatPromptHandle, St as createExecutorRegistry, Tt as createWorktreeCliExecutor, Ut as canonicalizeAuthoredProfile, n as supervise, r as workerFromBackend, rn as gateOnDeliverable, wt as taskToPrompt, xt as createExecutor } from "./supervise-CsTKbH9R.js";
 import { CODING_HARNESSES, InMemoryTraceStore, OUTPUT_VALUE, benjaminiHochberg, buildTrajectory, computeFindingId as computeFindingId$1, confidenceInterval, expandProfileAxes, harnessAxisOf, makeFinding as makeFinding$1, pairedBootstrap, paretoFrontier, scoreKnowledgeReadiness, wilcoxonSignedRank, wilson } from "@tangle-network/agent-eval";
 import { heldoutSignificance, runProfileMatrix } from "@tangle-network/agent-eval/campaign";
 import { agentProfileSchema, canonicalCandidateDigest, validateAgentProfileSecurity } from "@tangle-network/agent-interface";
+import { randomUUID } from "node:crypto";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { appendFileSync, chmodSync, constants, copyFileSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readlinkSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
@@ -4593,6 +4594,333 @@ function deriveTurnSignal(callerSignal, timeoutMs) {
 	};
 }
 //#endregion
+//#region src/runtime/supervise/chat-transport-executor.ts
+/**
+* The chat-transport leaf executor: a worker whose runtime is a plain OpenAI-compatible
+* `/v1/chat/completions` transport — the worker IS a model conversation, not a sandboxed process
+* (#721). Tool calls are optional (none, or a caller-provided tool table executed on this host).
+* A chat worker gets everything real workers get through the open `Executor` port: node pinning,
+* conserved spend, settle/verdict, journal + edge ledger.
+*
+* Module home: a standalone leaf-executor module beside `worktree-cli-executor.ts` — a direct
+* `(options) → Executor` constructor, NOT a `createExecutor` backend variant. The reason is
+* continuity: `workerFromBackend` (the backend-as-data path every `ExecutorConfig` rides) creates
+* a fresh executor per spawn with no session re-attachment and deliberately FAILS LOUD on a
+* `continuity: 'resume'` spawn; the documented resume consumer is a session-owning
+* `makeWorkerAgent` seam. {@link chatWorkerSeam} is that seam, and this module ships both halves
+* together so no caller re-derives the resume wiring.
+*
+* Transport shape: NON-streaming, one buffered POST per turn — the simplest honest choice.
+* A streaming executor cannot mark an unmetered turn today (`UsageEvent`'s `tokens` variant has
+* no `tokensKnown: false` twin — see the documented limitation in `./types`), while the one-shot
+* path returns a whole `Spend` that carries both markers. Honesty wins over liveness here.
+*
+* Metering: tokens come from the transport's `usage` fields; a turn without usage marks
+* `tokensKnown: false`. Dollars come ONLY from the response's own cost fields (`usage.cost` /
+* `usage.cost_usd`, the cli-bridge and OpenRouter conventions); a turn without one marks
+* `usdKnown: false`. NEVER estimated from a local price table — this executor speaks to arbitrary
+* OpenAI-compatible endpoints whose models a local table cannot price, and a silent estimate is a
+* fabricated measurement.
+*
+* @experimental
+*/
+/** The default transport: POST `${url}/chat/completions` with an optional bearer. Fail-loud on
+*  any non-2xx — the status and body head become the settle reason. */
+function chatCompletionsTransport(opts) {
+	if (typeof opts.url !== "string" || opts.url.length === 0) throw new ValidationError("chatCompletionsTransport: url required");
+	const endpoint = `${opts.url.replace(/\/$/, "")}/chat/completions`;
+	return async (body, signal) => {
+		const res = await fetch(endpoint, {
+			method: "POST",
+			headers: {
+				"content-type": "application/json",
+				...opts.bearer ? { authorization: `Bearer ${opts.bearer}` } : {}
+			},
+			body: JSON.stringify(body),
+			...signal ? { signal } : {}
+		});
+		if (!res.ok) throw new ValidationError(`chat transport ${res.status}: ${(await res.text()).slice(0, 200)}`);
+		return res.json();
+	};
+}
+/** In-memory `ChatSessionStore`. Entries are detached copies — a caller mutating a saved array
+*  cannot corrupt a recorded session. */
+function createChatSessionStore() {
+	const sessions = /* @__PURE__ */ new Map();
+	return {
+		load: (workerId) => sessions.get(workerId),
+		save: (workerId, messages) => {
+			sessions.set(workerId, structuredClone(messages));
+		}
+	};
+}
+const CHAT_TRANSPORT_RUNTIME = "chat-transport";
+/**
+* Build the chat-transport `Executor`: one `execute` = one conversation SHOT — seed (fresh system
+* prompt, or the resumed session's recorded history) + the task as the next user message, then
+* loop completion → host tool calls → tool messages until the model answers without a tool call
+* (or the turn cap). Settles with the final assistant text as `out`.
+*
+* Fail-loud contract: transport failures (non-2xx, network faults, malformed completions) throw
+* `ValidationError`, which the scope settles as an INFRA failure (`Settled.down.infra`) — never a
+* fake success. The accumulated conversation is still recorded before the throw when a store is
+* configured, because the inference HAPPENED and a resume may continue a failed session (the
+* kernel deliberately allows resume-after-failure; the seam decides).
+*/
+function chatTransportExecutor(opts) {
+	const model = concreteModelId(opts.model);
+	if (!model) throw new ValidationError("chatTransportExecutor: model required");
+	if (!opts.complete && (typeof opts.url !== "string" || opts.url.length === 0)) throw new ValidationError("chatTransportExecutor: url required (or inject `complete`)");
+	for (const tool of opts.tools ?? []) if (typeof tool.spec?.function?.name !== "string" || typeof tool.execute !== "function") throw new ValidationError("chatTransportExecutor: every tools entry needs spec.function.name + execute");
+	const maxTurns = opts.maxTurnsPerShot ?? 200;
+	if (!Number.isInteger(maxTurns) || maxTurns < 1) throw new ValidationError("chatTransportExecutor: maxTurnsPerShot must be a positive integer");
+	if (opts.maxTokens !== void 0 && (!Number.isInteger(opts.maxTokens) || opts.maxTokens < 1)) throw new ValidationError("chatTransportExecutor: maxTokens must be a positive integer");
+	let seed;
+	if (opts.resume) {
+		if (!opts.sessions) throw new ValidationError("chatTransportExecutor: a 'resume' spawn needs `sessions` — the store holding the conversation this shot continues");
+		const prior = opts.sessions.load(opts.resume.ofWorker);
+		if (prior === void 0) throw new ValidationError(`chatTransportExecutor: no recorded conversation for worker '${opts.resume.ofWorker}' — the session store holds only conversations recorded by this process (the kernel’s process-local resume boundary)`);
+		seed = structuredClone(prior);
+	} else seed = opts.system !== void 0 && opts.system.length > 0 ? [{
+		role: "system",
+		content: opts.system
+	}] : [];
+	const transport = opts.complete ?? chatCompletionsTransport({
+		url: opts.url,
+		...opts.bearer ? { bearer: opts.bearer } : {}
+	});
+	const toolSpecs = (opts.tools ?? []).map((tool) => tool.spec);
+	const toolByName = new Map((opts.tools ?? []).map((tool) => [tool.spec.function.name, tool]));
+	const controller = new AbortController();
+	let artifact;
+	let executed = false;
+	const executionId = opts.sessionKey ?? `chat-session-${randomUUID()}`;
+	const attemptId = opts.attemptId ?? newExecutionAttemptId(executionId);
+	const executor = {
+		runtime: CHAT_TRANSPORT_RUNTIME,
+		async execute(task, signal) {
+			if (executed) throw new ValidationError("chatTransportExecutor: execute() called twice on one instance");
+			executed = true;
+			const started = Date.now();
+			const messages = seed;
+			messages.push({
+				role: "user",
+				content: taskToPrompt(task)
+			});
+			const linked = mergeAbortSignals(signal, controller.signal);
+			const tokens = zeroTokenUsage();
+			let tokensKnown = true;
+			let usd = 0;
+			let usdKnown = true;
+			let turns = 0;
+			let lastText = "";
+			try {
+				for (let t = 0; t < maxTurns; t += 1) {
+					const body = {
+						model,
+						messages,
+						...toolSpecs.length > 0 ? {
+							tools: toolSpecs,
+							tool_choice: "auto"
+						} : {},
+						...opts.temperature !== void 0 ? { temperature: opts.temperature } : {},
+						...opts.maxTokens !== void 0 ? { max_tokens: opts.maxTokens } : {}
+					};
+					let raw;
+					try {
+						raw = await transport(body, linked);
+					} catch (cause) {
+						if (cause instanceof Error && cause.name === "AbortError") throw cause;
+						if (cause instanceof ValidationError) throw cause;
+						throw new ValidationError(`chatTransportExecutor: transport failed: ${cause instanceof Error ? cause.message : String(cause)}`);
+					}
+					turns += 1;
+					const data = raw;
+					const usage = data?.usage;
+					if (usage && typeof usage.prompt_tokens === "number" && typeof usage.completion_tokens === "number") {
+						tokens.input += usage.prompt_tokens;
+						tokens.output += usage.completion_tokens;
+					} else tokensKnown = false;
+					const turnCost = typeof usage?.cost === "number" ? usage.cost : typeof usage?.cost_usd === "number" ? usage.cost_usd : void 0;
+					if (turnCost !== void 0) usd += turnCost;
+					else usdKnown = false;
+					const msg = data?.choices?.[0]?.message;
+					if (msg === void 0) throw new ValidationError("chatTransportExecutor: transport returned no choices[0].message");
+					if (typeof msg.content === "string" && msg.content.length > 0) lastText = msg.content;
+					const toolCalls = msg.tool_calls ?? [];
+					if (toolCalls.length === 0 || toolSpecs.length === 0) {
+						messages.push({
+							role: "assistant",
+							content: msg.content ?? ""
+						});
+						break;
+					}
+					messages.push({
+						role: "assistant",
+						content: msg.content ?? "",
+						tool_calls: toolCalls.map((tc, i) => ({
+							id: tc.id ?? `call_${i}`,
+							type: "function",
+							function: {
+								name: tc.function?.name ?? "",
+								arguments: tc.function?.arguments ?? "{}"
+							}
+						}))
+					});
+					for (let i = 0; i < toolCalls.length; i += 1) {
+						const tc = toolCalls[i];
+						const id = tc?.id ?? `call_${i}`;
+						const name = tc?.function?.name ?? "";
+						const tool = toolByName.get(name);
+						if (!tool) {
+							messages.push({
+								role: "tool",
+								tool_call_id: id,
+								content: `error: unknown tool '${name}'`
+							});
+							continue;
+						}
+						let args;
+						try {
+							args = JSON.parse(tc?.function?.arguments ?? "{}");
+						} catch {
+							messages.push({
+								role: "tool",
+								tool_call_id: id,
+								content: "error: tool arguments were not valid JSON"
+							});
+							continue;
+						}
+						let result;
+						try {
+							result = await tool.execute(args, task);
+						} catch (cause) {
+							result = `error: ${cause instanceof Error ? cause.message : String(cause)}`;
+						}
+						messages.push({
+							role: "tool",
+							tool_call_id: id,
+							content: result
+						});
+					}
+				}
+			} finally {
+				if (opts.sessions && opts.sessionKey !== void 0) opts.sessions.save(opts.sessionKey, messages);
+			}
+			const spent = {
+				iterations: turns,
+				tokens,
+				...tokensKnown ? {} : { tokensKnown: false },
+				usd,
+				...usdKnown ? {} : { usdKnown: false },
+				ms: Date.now() - started
+			};
+			artifact = {
+				outRef: contentAddress({
+					kind: "chat-transport",
+					model,
+					content: lastText,
+					turns
+				}),
+				out: lastText,
+				spent
+			};
+			return artifact;
+		},
+		teardown(_grace) {
+			controller.abort();
+			return Promise.resolve({ destroyed: true });
+		},
+		resultArtifact() {
+			if (!artifact) throw new ValidationError("chatTransportExecutor: resultArtifact() read before execute()");
+			return {
+				...artifact,
+				spent: artifact.spent
+			};
+		}
+	};
+	if (opts.profile === void 0) return executor;
+	return attestRuntimeOwnedExecutor(executor, {
+		effectiveProfile: opts.profile,
+		backend: "chat-transport",
+		model: {
+			status: "known",
+			id: model
+		},
+		execution: {
+			kind: "session",
+			id: executionId
+		},
+		materializer: "chat-transport-conversation",
+		plan: {
+			kind: "openai-chat-conversation",
+			model,
+			maxTurnsPerShot: maxTurns,
+			tools: toolSpecs,
+			resumeOf: opts.resume?.ofWorker ?? null
+		}
+	}, {
+		attemptId,
+		binding: {
+			endpoint: opts.complete ? "injected-transport" : opts.url,
+			model,
+			sessionKey: opts.sessionKey ?? null
+		},
+		descriptor: {
+			kind: "chat-transport-session",
+			transport: opts.complete ? "injected" : "http",
+			backend: "chat-transport"
+		}
+	});
+}
+/**
+* The `makeWorkerAgent` seam over {@link chatTransportExecutor} — the continuity consumer
+* `workerFromBackend` refuses to be. Every spawn becomes one conversation shot: the spawned
+* profile's system prompt + instructions (which is where a graph's delegates directive lands)
+* seed a fresh session, and a `'resume'` spawn re-attaches by loading `resume.ofWorker`'s
+* recorded message list from the seam's session store. Conversations are recorded under the
+* kernel node id, which is exactly what a later `resume.ofWorker` names.
+*/
+function chatWorkerSeam(opts) {
+	if (!opts.complete && (typeof opts.url !== "string" || opts.url.length === 0)) throw new ValidationError("chatWorkerSeam: url required (or inject `complete`)");
+	const sessions = opts.sessions ?? createChatSessionStore();
+	return (rawProfile, spawnContext) => {
+		const parsed = agentProfileSchema.safeParse(canonicalizeAuthoredProfile(rawProfile));
+		if (!parsed.success) throw new ValidationError(`chatWorkerSeam: invalid AgentProfile: ${parsed.error.message}`);
+		const profile = parsed.data;
+		const model = concreteProfileModel(profile) ?? concreteModelId(opts.model);
+		if (!model) throw new ValidationError("chatWorkerSeam: no model — set ChatWorkerSeamOptions.model or AgentProfile.model.default");
+		const system = [profile.prompt?.systemPrompt, ...profile.prompt?.instructions ?? []].filter((line) => typeof line === "string" && line.trim().length > 0).join("\n");
+		return {
+			name: profile.name ?? "chat-worker",
+			act: async () => void 0,
+			executorSpec: {
+				profile,
+				harness: null,
+				executorFactory: (executorSpec, ctx) => {
+					const executor = chatTransportExecutor({
+						url: opts.url,
+						...opts.bearer !== void 0 ? { bearer: opts.bearer } : {},
+						model,
+						...system.length > 0 ? { system } : {},
+						...opts.tools !== void 0 ? { tools: opts.tools } : {},
+						...opts.temperature !== void 0 ? { temperature: opts.temperature } : {},
+						...opts.maxTokens !== void 0 ? { maxTokens: opts.maxTokens } : {},
+						...opts.maxTurnsPerShot !== void 0 ? { maxTurnsPerShot: opts.maxTurnsPerShot } : {},
+						...opts.complete !== void 0 ? { complete: opts.complete } : {},
+						sessions,
+						...ctx.node?.nodeId !== void 0 ? { sessionKey: ctx.node.nodeId } : {},
+						...spawnContext?.resume !== void 0 ? { resume: spawnContext.resume } : {},
+						profile: executorSpec.profile,
+						...ctx.node?.attemptId !== void 0 ? { attemptId: ctx.node.attemptId } : {}
+					});
+					return opts.deliverable ? gateOnDeliverable(executor, opts.deliverable) : executor;
+				}
+			}
+		};
+	};
+}
+//#endregion
 //#region src/runtime/supervise/graph.ts
 /**
 *
@@ -4607,8 +4935,8 @@ function deriveTurnSignal(callerSignal, timeoutMs) {
 * NOT A SECOND SCHEDULER. `runGraph` is an interpretation layer over what already runs:
 * `supervise()` is the execution core — the same `supervisorAgent`/`driverAgent` machinery,
 * `makeWorkerAgent` seam, conserved-pool budget, and deliverable-gated settlement every
-* supervised run uses. (`runLoop` is a deprecated alias of `runAgentRounds` and is deliberately
-* NOT the substrate here.) What the graph layer ADDS is exactly what a bespoke driver loop never
+* 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
@@ -4623,6 +4951,12 @@ function deriveTurnSignal(callerSignal, timeoutMs) {
 *     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
@@ -4682,6 +5016,7 @@ function validateGraph(graph, registry, analysts) {
 		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));
@@ -4691,6 +5026,7 @@ function validateGraph(graph, registry, analysts) {
 	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);
@@ -4703,7 +5039,10 @@ function validateGraph(graph, registry, analysts) {
 		} 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));
+		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`);
@@ -4769,6 +5108,7 @@ function runGraph(graph, opts) {
 			},
 			traversal: entry.traversal,
 			outcome: entry.outcome,
+			continuity: entry.continuity,
 			bytes: entry.bytes,
 			...entry.reason !== void 0 ? { reason: entry.reason } : {},
 			seq: ledgerSeq++,
@@ -4803,7 +5143,9 @@ function runGraph(graph, opts) {
 		const edge = delegatesByWorker.get(node.id);
 		const id = edgeId(edge);
 		const cap = edge.maxTraversals ?? 32;
-		if ((traversalCounts.get(id) ?? 0) >= cap) {
+		const used = traversalCounts.get(id) ?? 0;
+		const spawnContinuity = spawnContext?.continuity ?? "fresh";
+		if (used >= cap) {
 			exhausted.add(id);
 			exhaustedDelegates.add(id);
 			record({
@@ -4813,6 +5155,7 @@ function runGraph(graph, opts) {
 				to: edge.to,
 				directive: formatPromptHandle(edge.directive),
 				outcome: "unpropagated",
+				continuity: spawnContinuity,
 				bytes: 0,
 				reason: `traversal-cap-exhausted (max ${cap})`
 			}, true);
@@ -4828,6 +5171,7 @@ function runGraph(graph, opts) {
 			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);
@@ -4862,14 +5206,18 @@ function runGraph(graph, opts) {
 		};
 	});
 	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 cap = delegatesByWorker.get(node.id).maxTraversals ?? 32;
+			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}` : "";
-			return `- '${node.id}'${description} (delegation cap: ${cap} traversals)`;
+			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");
@@ -4904,6 +5252,7 @@ function runGraph(graph, opts) {
 			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 } : {}
@@ -4942,6 +5291,7 @@ function runGraph(graph, opts) {
 				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
@@ -4977,6 +5327,7 @@ function runGraph(graph, opts) {
 				analyzeOnSettle: routes,
 				...opts.analysts ? { analysts: opts.analysts } : {}
 			} : {},
+			...Object.keys(continuityByProfile).length > 0 ? { continuityByProfile } : {},
 			...opts.watchWorkers ? { watchWorkers: opts.watchWorkers } : {},
 			...opts.router ? { router: opts.router } : {},
 			...opts.brain ? { brain: opts.brain } : {},
@@ -6150,6 +6501,6 @@ function tail(s) {
 	return s.slice(-400);
 }
 //#endregion
-export { panel as $, runStrategyEvolution as A, materializeLocalMcp as At, equalKOnCost as B, GraphEdgeCapError as C, renderLeaderboardMarkdown as Ct, streamAgentTurn as D, defaultAuditorInstruction as Dt, collectAgentTurn as E, auditIntent as Et, SandboxRunAbortError as F, resolveMcpServerLaunch as Ft, createShapeRegistry as G, definePersona as H, openSandboxRun as I, resolveSecretEnv as It, InMemoryCorpus as J, registerShape as K, printBenchmarkReport as L, secretEnvOfMcpServer as Lt, assertStrategyContract as M, sanitizeMcpToolSchema as Mt, authorStrategy as N, envKeyProvider as Nt, discriminatingMeans as O, McpSpawnFault as Ot, strategyAuthorContract as P, mcpSecretEnvMetadataKey as Pt, loopUntil as Q, runBenchmark as R, runCoderChecks as S, renderLeaderboardHtml as St, runGraph as T, renderPairwiseMarkdown as Tt, runPersonified as U, trajectoryReport as V, builtinShapes as W, fanout as X, renderCorpusToInstructions as Y, flatWidenGate as Z, settledWorkerOut as _, deterministicCompletion as _t, localShell as a, buildSteerContext as at, analyzeTrace as b, leaderboard as bt, createVerifierEnvironment as c, inProcessSandboxClient as ct, worktreeFanout as d, resolveSandboxClient as dt, pipeline as et, EVIDENCE_MAX_CHARS as f, localSandboxClient as ft, composeWorkerEvidence as g, completionAuthorizes as gt, closingWorkerNote as h, loopDispatch as ht, jjWorkspace as i, assertTraceDerivedFindings as it, selectChampion as j, createMcpEnvironment as jt, pickChampion as k, connectStdioMcp as kt, failuresAnalyst as l, harvestCorpus as lt, VERIFY_TAIL_CHARS as m, loopCampaignDispatch as mt, makeFinding$1 as n, verify as nt, runInWorkspace as o, createScopeAnalyst as ot, NOTE_MAX_CHARS as p, inlineSandboxClient as pt, FileCorpus as q, gitWorkspace as r, widen as rt, createWaterfallCollector as s, registryScopeAnalyst as st, computeFindingId$1 as t, selectValidWinner as tt, superviseSurface as u, defineLeaderboard as ut, copyUntrackedIntoClone as v, sentinelCompletion as vt, defaultEdgeTraversalCap as w, renderLeaderboardSvg as wt, patchDelivered as x, pairwiseSignificance as xt, withUntrackedArtifacts as y, stopSentinel as yt, promotionGate as z };
+export { renderCorpusToInstructions as $, collectAgentTurn as A, auditIntent as At, openSandboxRun as B, resolveSecretEnv as Bt, GraphEdgeCapError as C, stopSentinel as Ct, chatTransportExecutor as D, renderLeaderboardMarkdown as Dt, chatCompletionsTransport as E, renderLeaderboardHtml as Et, selectChampion as F, createMcpEnvironment as Ft, trajectoryReport as G, runBenchmark as H, assertStrategyContract as I, sanitizeMcpToolSchema as It, builtinShapes as J, definePersona as K, authorStrategy as L, envKeyProvider as Lt, discriminatingMeans as M, McpSpawnFault as Mt, pickChampion as N, connectStdioMcp as Nt, chatWorkerSeam as O, renderLeaderboardSvg as Ot, runStrategyEvolution as P, materializeLocalMcp as Pt, InMemoryCorpus as Q, strategyAuthorContract as R, mcpSecretEnvMetadataKey as Rt, runCoderChecks as S, sentinelCompletion as St, runGraph as T, pairwiseSignificance as Tt, promotionGate as U, printBenchmarkReport as V, secretEnvOfMcpServer as Vt, equalKOnCost as W, registerShape as X, createShapeRegistry as Y, FileCorpus as Z, settledWorkerOut as _, inlineSandboxClient as _t, localShell as a, selectValidWinner as at, analyzeTrace as b, completionAuthorizes as bt, createVerifierEnvironment as c, assertTraceDerivedFindings as ct, worktreeFanout as d, registryScopeAnalyst as dt, fanout as et, EVIDENCE_MAX_CHARS as f, inProcessSandboxClient as ft, composeWorkerEvidence as g, localSandboxClient as gt, closingWorkerNote as h, resolveSandboxClient as ht, jjWorkspace as i, pipeline as it, streamAgentTurn as j, defaultAuditorInstruction as jt, createChatSessionStore as k, renderPairwiseMarkdown as kt, failuresAnalyst as l, buildSteerContext as lt, VERIFY_TAIL_CHARS as m, defineLeaderboard as mt, makeFinding$1 as n, loopUntil as nt, runInWorkspace as o, verify as ot, NOTE_MAX_CHARS as p, harvestCorpus as pt, runPersonified as q, gitWorkspace as r, panel as rt, createWaterfallCollector as s, widen as st, computeFindingId$1 as t, flatWidenGate as tt, superviseSurface as u, createScopeAnalyst as ut, copyUntrackedIntoClone as v, loopCampaignDispatch as vt, defaultEdgeTraversalCap as w, leaderboard as wt, patchDelivered as x, deterministicCompletion as xt, withUntrackedArtifacts as y, loopDispatch as yt, SandboxRunAbortError as z, resolveMcpServerLaunch as zt };
 
-//# sourceMappingURL=runtime-BzXz7OjS.js.map
+//# sourceMappingURL=runtime-5uDVVfER.js.map