@tangle-network/agent-runtime 0.123.1 → 0.128.0

package/dist/{runtime-DZblIf3R.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-Cx24b3lw.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";
@@ -1295,106 +1296,13 @@ function resolveSandboxClient(opts) {
 	}
 }
 //#endregion
-//#region src/runtime/steering-drivers.ts
-/**
-* Interpret a {@link SteeringDirectiveData} as a loop `Driver` — the ONE interpreter both
-* control policies share. The directive is data; only `applyContinuation` (how the caller's
-* opaque Task carries a steering string) remains code, exactly as `taskToPrompt` does.
-*/
-function steeringDriver(directive, applyContinuation, name) {
-	const driverName = name ?? directive.kind;
-	const maxIterations = directive.maxTraversals;
-	const continuationFor = (passed) => directive.kind === "naive" ? directive.continuation : passed ? directive.onPass : directive.onFail;
-	const rationale = directive.kind === "naive" ? "naive fixed continuation (no grade signal)" : "dumb pass/fail-only continuation (no grader findings)";
-	return {
-		name: driverName,
-		plan(task, history) {
-			if (history.length === 0) return Promise.resolve([task]);
-			const passed = history[history.length - 1]?.verdict?.valid === true;
-			if (passed) return Promise.resolve([]);
-			if (history.length >= maxIterations) return Promise.resolve([]);
-			return Promise.resolve([applyContinuation(task, continuationFor(passed))]);
-		},
-		decide(history) {
-			return decideUntilValidOrCapped(history, maxIterations);
-		},
-		describePlan() {
-			return {
-				kind: "refine",
-				rationale
-			};
-		}
-	};
-}
-/**
-* Shared `decide()` for the steering drivers. Verbatim semantics of the
-* reference refine driver: a valid iteration anywhere → terminal `'pick-winner'`;
-* otherwise `'refine'` (non-terminal, run another shot) while history is under
-* the shot cap, else terminal `'fail'`. Pure over history; reads only
-* `verdict.valid` (never notes/scores) so it adds no leak of its own.
-*/
-function decideUntilValidOrCapped(history, maxIterations) {
-	if (history.some((it) => it.verdict?.valid)) return "pick-winner";
-	return history.length < maxIterations ? "refine" : "fail";
-}
-/**
-* `naiveDriver` — the no-signal steering control.
-*
-* `plan()` runs the initial `task` at shot 0, then issues the SAME fixed
-* `continuation` every subsequent round until a shot is valid or the cap is
-* hit. It reads NOTHING from `history[last].verdict` — not `.valid`, not
-* `.notes`, not `.scores`. It is the floor a coached loop must beat to earn its
-* coaching: any lift over naive that is not also present in `dumb` is
-* attributable to the pass/fail bit, and any lift of `refine` over `dumb` is
-* attributable to the grader's findings.
-*/
-/** Thin compatibility wrapper over {@link steeringDriver} for the naive (no-signal) control.
-*  @deprecated The policy is DATA now — build the directive and interpret it:
-*  `steeringDriver({ kind: 'naive', continuation, maxTraversals }, applyContinuation)`. This
-*  wrapper survives for existing callers and will be removed in the next major. */
-function naiveDriver(options) {
-	const { continuation, applyContinuation, maxIterations, name = "naive" } = options;
-	return steeringDriver({
-		kind: "naive",
-		continuation,
-		maxTraversals: maxIterations
-	}, applyContinuation, name);
-}
-/**
-* `dumbDriver` — the pass/fail-only steering control.
-*
-* `plan()` runs the initial `task` at shot 0, then reads ONLY
-* `history[last].verdict.valid` (the boolean) and issues `onPass` or `onFail`
-* accordingly. It MUST NOT read `.notes` or `.scores` — that boundary is the
-* leak-free firewall. A `verdict` with no `valid` set (or no verdict) is
-* treated as not-valid, so the driver is total and never throws on a
-* grader/transport gap.
-*
-* The `dumb → refine` gap is the headline measurement: refine reads the
-* grader's `notes`, dumb reads only the pass/fail bit, so the difference is
-* exactly the value the findings add over a bare boolean.
-*/
-/** Thin compatibility wrapper over {@link steeringDriver} for the dumb (pass/fail-only) control.
-*  @deprecated The policy is DATA now — build the directive and interpret it:
-*  `steeringDriver({ kind: 'dumb', onPass, onFail, maxTraversals }, applyContinuation)`. This
-*  wrapper survives for existing callers and will be removed in the next major. */
-function dumbDriver(options) {
-	const { onPass, onFail, applyContinuation, maxIterations, name = "dumb" } = options;
-	return steeringDriver({
-		kind: "dumb",
-		onPass,
-		onFail,
-		maxTraversals: maxIterations
-	}, applyContinuation, name);
-}
-//#endregion
 //#region src/runtime/define-leaderboard.ts
 /**
 * `defineLeaderboard` — the declarative eval-leaderboard facade.
 *
 * A product's harness×model leaderboard is always the same assembly: expand a
 * base profile across the harness×model axes (`expandProfileAxes`), run every
-* (profile, case) cell as a driven loop (`loopDispatch` + the naive steering directive), score
+* (profile, case) cell as a driven loop (`loopDispatch` + the naive retry driver), score
 * with the domain's grader, and emit ONE `runProfileMatrix` call. Each product
 * hand-rolled that assembly (~650 lines each) and re-hit the same footguns:
 * stale cell-cache reuse, zero-token stub cells, missing model snapshots.
@@ -1420,6 +1328,36 @@ function dumbDriver(options) {
 *
 * @experimental
 */
+/**
+* The no-signal retry floor as a bare `Driver` literal: re-run the case VERBATIM as an
+* independent attempt until one shot scores (`verdict.valid`) or the shot cap. It reads ONLY
+* `verdict.valid` — never `notes`/`scores` — so a leaderboard cell's retries carry no grader
+* findings into the next shot (the leak-free firewall). Steering POLICY texts are registry data
+* (`delegates/naive-continuation` and siblings in the kernel prompt registry) attached to graph
+* edges; this loop-kernel control folds no text in — each shot is the same task object, and the
+* per-shot nonce in `taskToPrompt` keeps the attempts independent at the router.
+*/
+function naiveRetryDriver(shots) {
+	return {
+		name: "naive",
+		plan(task, history) {
+			if (history.length === 0) return Promise.resolve([task]);
+			if (history[history.length - 1]?.verdict?.valid === true) return Promise.resolve([]);
+			if (history.length >= shots) return Promise.resolve([]);
+			return Promise.resolve([task]);
+		},
+		decide(history) {
+			if (history.some((it) => it.verdict?.valid)) return "pick-winner";
+			return history.length < shots ? "refine" : "fail";
+		},
+		describePlan() {
+			return {
+				kind: "refine",
+				rationale: "naive fixed continuation (no grade signal)"
+			};
+		}
+	};
+}
 /** Read `--name <value>` from an argv array. */
 function argOf(argv, name) {
 	const i = argv.indexOf(`--${name}`);
@@ -1588,11 +1526,7 @@ function defineLeaderboard(spec) {
 						...!isHarnessNativeModel(modelId) || backendName === "cli-bridge" ? { model: modelId } : {}
 					};
 					return {
-						driver: steeringDriver({
-							kind: "naive",
-							continuation: "",
-							maxTraversals: shots
-						}, (task) => task, "naive"),
+						driver: naiveRetryDriver(shots),
 						agentRun: {
 							profile: cellProfile,
 							taskToPrompt: (s) => `${promptOf(s)}\n\n<!-- independent-attempt:${shotNonce++} -->`,
@@ -4660,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
 /**
 *
@@ -4674,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
@@ -4690,11 +4951,20 @@ 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 NODES. Graders/verifiers must not be addressable in the graph —
-* an edge to them leaks the rubric. Analysts (`analyzes` edges) are LENSES from the environment's
-* registry reading trace evidence; they are not nodes either, and a graph that names a node id as
-* its analyst is refused.
+* ORACLES ARE ENVIRONMENT, NEVER WORKERS. Graders/verifiers must not be spawnable in the graph —
+* a delegates edge to them leaks the rubric. An `analyzes` edge names its analyst in one of two
+* forms: a LENS id from the environment's registry (a pure function over trace evidence), or the
+* id of a graph NODE — a tool-equipped analyst AGENT spawned on each matching settle with the
+* node's pinned profile, whose settle output IS the findings. Either way the oracle doctrine
+* holds: an analyst node can never be a delegates target (refused loudly), so no driver can hand
+* it work, and an id living in both the registry and the nodes is refused as ambiguous.
 *
 * @experimental
 */
@@ -4746,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));
@@ -4753,16 +5024,28 @@ function validateGraph(graph, registry, analysts) {
 	const root = requireNode(roots[0], "root resolution");
 	for (const edge of delegates) if (edge.from !== root.id) throw new ValidationError(`runGraph: ${edgeId(edge)} delegates from a non-root node — P0 executes one driver over its workers (the 2-node cyclic case, star-generalized); deeper delegation is P3`);
 	const analystIds = /* @__PURE__ */ new Set();
+	const analystNodes = /* @__PURE__ */ new Map();
 	for (const edge of analyzes) {
+		if (edge.continuity !== void 0) throw new ValidationError(`runGraph: ${edgeId(edge)} carries continuity — analysts are spawned by the analyst machinery (every analyst run is a fresh session over settled evidence), so continuity is a delegates-edge axis only`);
 		if (analystIds.has(edge.analyst)) throw new ValidationError(`runGraph: two analyzes edges share analyst '${edge.analyst}' — one analyzes edge per analyst lens (traversals are ledgered by analyst id; a second edge would silently absorb the first's). Register the lens under a second id for a second edge.`);
 		analystIds.add(edge.analyst);
-		if (byId.has(edge.analyst)) throw new ValidationError(`runGraph: ${edgeId(edge)} names node '${edge.analyst}' as its analyst — oracles and analysts are ENVIRONMENT, never nodes; pass a lens id from RunGraphOptions.analysts`);
-		if (!analysts) throw new ValidationError(`runGraph: ${edgeId(edge)} needs RunGraphOptions.analysts (the lens registry its analyst resolves against)`);
-		if (!analysts.kinds.some((kind) => kind.id === edge.analyst)) throw new ValidationError(`runGraph: ${edgeId(edge)} analyst '${edge.analyst}' is not in the analysts registry (known: ${analysts.kinds.map((kind) => kind.id).join(", ") || "none"})`);
+		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));
+		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) {
@@ -4770,12 +5053,13 @@ function validateGraph(graph, registry, analysts) {
 		delegatesByWorker.set(edge.to, edge);
 		workers.set(edge.to, requireNode(edge.to, edgeId(edge)));
 	}
-	for (const node of graph.nodes) if (node.id !== root.id && !workers.has(node.id)) throw new ValidationError(`runGraph: node '${node.id}' has no delegates edge to it — an unreachable node never runs`);
+	for (const node of graph.nodes) if (node.id !== root.id && !workers.has(node.id) && !analystNodes.has(node.id)) throw new ValidationError(`runGraph: node '${node.id}' has no delegates edge to it — an unreachable node never runs`);
 	return {
 		root,
 		workers,
 		delegatesByWorker,
-		analyzes
+		analyzes,
+		analystNodes
 	};
 }
 const byteLength = (text) => Buffer.byteLength(text, "utf8");
@@ -4797,7 +5081,7 @@ function stringifyPayload(payload) {
 */
 function runGraph(graph, opts) {
 	const registry = opts.registry ?? kernelPromptRegistry();
-	const { root, workers, delegatesByWorker, analyzes } = validateGraph(graph, registry, opts.analysts);
+	const { root, workers, delegatesByWorker, analyzes, analystNodes } = validateGraph(graph, registry, opts.analysts);
 	if (!opts.backend && !opts.makeWorkerAgent) throw new ValidationError("runGraph: provide opts.backend (where nodes run) or opts.makeWorkerAgent");
 	const journal = opts.journal ?? new InMemorySpawnJournal();
 	const blobs = opts.blobs ?? new InMemoryResultBlobStore();
@@ -4824,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++,
@@ -4848,12 +5133,19 @@ function runGraph(graph, opts) {
 	const pendingByAssignment = /* @__PURE__ */ new Map();
 	const graphWorker = (authoredProfile, spawnContext) => {
 		const requested = typeof authoredProfile?.name === "string" ? authoredProfile.name : void 0;
+		if (spawnContext?.analyst !== void 0) {
+			const analystNode = analystNodes.get(spawnContext.analyst);
+			if (!analystNode || requested !== analystNode.id) throw new ValidationError(`runGraph: analyst run for ${JSON.stringify(spawnContext.analyst)} does not name an analyst node of this graph (analyst nodes: ${[...analystNodes.keys()].join(", ") || "none"})`);
+			return makeLeaf(analystNode.profile, spawnContext);
+		}
 		const node = requested !== void 0 ? workers.get(requested) : void 0;
 		if (!node) throw new ValidationError(`runGraph: spawn_agent named profile ${JSON.stringify(requested)} which is not a worker node of this graph (nodes: ${[...workers.keys()].join(", ")}). Spawn by node id: profile.name selects the node; the node profile itself is pinned by the graph.`);
 		const edge = delegatesByWorker.get(node.id);
 		const id = edgeId(edge);
 		const cap = edge.maxTraversals ?? 32;
-		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({
@@ -4863,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);
@@ -4878,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);
@@ -4892,24 +5186,38 @@ function runGraph(graph, opts) {
 		};
 		return makeLeaf(pinned, spawnContext);
 	};
-	const routes = analyzes.map((edge) => 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 routes = analyzes.map((edge) => {
+		const analystNode = analystNodes.get(edge.analyst);
+		if (analystNode) return {
+			kind: edge.analyst,
+			over: edge.over,
+			agent: analystNode.profile,
+			directive: registry.resolve(edge.directive).text,
+			...edge.to === root.id ? {} : { to: edge.to }
+		};
+		return edge.to === root.id ? {
+			kind: edge.analyst,
+			over: edge.over
+		} : {
+			kind: edge.analyst,
+			over: edge.over,
+			to: edge.to,
+			directive: registry.resolve(edge.directive).text
+		};
 	});
-	const driverAnalyzesBriefs = analyzes.filter((edge) => edge.to === root.id).map((edge) => `Findings from analyst '${edge.analyst}' (over: ${edge.over.join(", ")}) will arrive as finding events.\n${registry.resolve(edge.directive).text}`);
+	const driverAnalyzesBriefs = analyzes.filter((edge) => edge.to === root.id).map((edge) => analystNodes.has(edge.analyst) ? `Findings from analyst '${edge.analyst}' (a tool-equipped analyst agent node, over: ${edge.over.join(", ")}) will arrive as finding events.` : `Findings from analyst '${edge.analyst}' (over: ${edge.over.join(", ")}) will arrive as finding events.\n${registry.resolve(edge.directive).text}`);
+	const continuityByProfile = {};
+	for (const [nodeId, edge] of delegatesByWorker) if (edge.continuity !== void 0) continuityByProfile[nodeId] = edge.continuity;
 	const graphBrief = [
 		"AGENT GRAPH: you are the driver node of a fixed topology. You may spawn ONLY these worker",
 		"nodes, by EXACT name (spawn_agent with profile: { name: '<node id>' }; the node's full",
 		"profile is pinned by the graph — any other profile fields you author are ignored):",
 		...[...workers.values()].map((node) => {
-			const 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");
@@ -4944,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 } : {}
@@ -4982,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
@@ -5013,10 +5323,12 @@ function runGraph(graph, opts) {
 			runId,
 			hooks,
 			onCoordinationEvent,
-			...routes.length > 0 && opts.analysts ? {
-				analysts: opts.analysts,
-				analyzeOnSettle: routes
+			...routes.length > 0 ? {
+				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 } : {},
 			...authorizeMessage ? { authorizeMessage } : {},
@@ -6189,6 +6501,6 @@ function tail(s) {
 	return s.slice(-400);
 }
 //#endregion
-export { panel as $, runStrategyEvolution as A, defaultAuditorInstruction as At, equalKOnCost as B, secretEnvOfMcpServer as Bt, GraphEdgeCapError as C, leaderboard as Ct, streamAgentTurn as D, renderLeaderboardSvg as Dt, collectAgentTurn as E, renderLeaderboardMarkdown as Et, SandboxRunAbortError as F, sanitizeMcpToolSchema as Ft, createShapeRegistry as G, definePersona as H, openSandboxRun as I, envKeyProvider as It, InMemoryCorpus as J, registerShape as K, printBenchmarkReport as L, mcpSecretEnvMetadataKey as Lt, assertStrategyContract as M, connectStdioMcp as Mt, authorStrategy as N, materializeLocalMcp as Nt, discriminatingMeans as O, renderPairwiseMarkdown as Ot, strategyAuthorContract as P, createMcpEnvironment as Pt, loopUntil as Q, runBenchmark as R, resolveMcpServerLaunch as Rt, runCoderChecks as S, stopSentinel as St, runGraph as T, renderLeaderboardHtml as Tt, runPersonified as U, trajectoryReport as V, builtinShapes as W, fanout as X, renderCorpusToInstructions as Y, flatWidenGate as Z, settledWorkerOut as _, loopCampaignDispatch as _t, localShell as a, buildSteerContext as at, analyzeTrace as b, deterministicCompletion as bt, createVerifierEnvironment as c, inProcessSandboxClient as ct, worktreeFanout as d, dumbDriver as dt, pipeline as et, EVIDENCE_MAX_CHARS as f, naiveDriver as ft, composeWorkerEvidence as g, inlineSandboxClient as gt, closingWorkerNote as h, localSandboxClient as ht, jjWorkspace as i, assertTraceDerivedFindings as it, selectChampion as j, McpSpawnFault as jt, pickChampion as k, auditIntent as kt, failuresAnalyst as l, harvestCorpus as lt, VERIFY_TAIL_CHARS as m, resolveSandboxClient as mt, makeFinding$1 as n, verify as nt, runInWorkspace as o, createScopeAnalyst as ot, NOTE_MAX_CHARS as p, steeringDriver 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, loopDispatch as vt, defaultEdgeTraversalCap as w, pairwiseSignificance as wt, patchDelivered as x, sentinelCompletion as xt, withUntrackedArtifacts as y, completionAuthorizes as yt, promotionGate as z, resolveSecretEnv as zt };
+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-DZblIf3R.js.map
+//# sourceMappingURL=runtime-5uDVVfER.js.map