@tangle-network/agent-runtime 0.128.0 → 0.131.0

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

@@ -1,20 +1,24 @@
-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, 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 { n as AnalystError, s as PlannerError, u as ValidationError } from "./errors-DEAvWQPy.js";
+import "./stream-agent-turn-rYgaOLO0.js";
+import { i as InMemorySpawnJournal, r as InMemoryResultBlobStore, v as isTraceAnalysisStore, x as contentAddress } from "./spawn-journal-saHQzqYi.js";
+import { a as randomSuffix, c as stringifySafe, f as zeroTokenUsage, r as isAbortError, s as sleep, t as addTokenUsage } from "./util-Bw6srryQ.js";
 import { i as redactProtectedValue, r as redactProtectedReason } from "./protected-redaction--F3v1oo8.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 { $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 { a as notifySandboxEventObserver } from "./sandbox-events-CRDwc5WN.js";
+import { c as profileProviderModel, i as concreteModelId, s as profileModelExecutionSettings, t as assertExecutableAgentProfile } from "./model-policy-CqziaqS1.js";
+import { v as executableAgentProfileSnapshot, y as executableAgentSpecSnapshot } from "./materialization-COJ1UYQ-.js";
+import { $ as createSandboxLineage, I as createWorktreeCliExecutor, N as createExecutor, P as createExecutorRegistry, Q as runAgentRounds, U as createPushTraceSource, Z as defaultSelectWinner, et as probeSandboxCapabilities, l as withDriverExecutor, m as settledToIteration, n as createSupervisor, nt as routerBrain, rt as runBrainLoop, w as rollingDispatch } from "./supervisor-CV6Jh28D.js";
+import "./environment-provider-Dyg8DtLK.js";
+import { i as notifyRuntimeHookEvent } from "./runtime-hooks-C7iJOWm3.js";
+import { C as observe, O as strategyAuthorMethod, T as profileChatClient, b as sample, v as refine, x as sampleThenRefine, y as runAgentic } from "./structural-rollout-3uxVGcg2.js";
+import { It as gateOnDeliverable, Lt as mapExecutorResult, n as supervise } from "./supervise-iPN27pO0.js";
+import "./authoring-CvHwo1oW.js";
+import "./graph-BJTxGOFB.js";
+import { CODING_HARNESSES, InMemoryTraceStore, OUTPUT_VALUE, benjaminiHochberg, buildTrajectory, computeFindingId as computeFindingId$1, confidenceInterval, expandProfileAxes, makeFinding as makeFinding$1, pairedBootstrap, paretoFrontier, 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 { agentProfileSchema, canonicalAgentProfileDigest, validateAgentProfileSecurity } from "@tangle-network/agent-interface";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 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";
 import { execFileSync, spawn, spawnSync } from "node:child_process";
 import { tmpdir } from "node:os";
 import { createInterface } from "node:readline";
@@ -531,13 +535,13 @@ const auditSchema = {
 };
 /** The route-rigor analyst: compare declared vs revealed vs user intent over a trajectory and return aligned / drifting / diverged with evidence and one recommended intervention. */
 async function auditIntent(input, opts) {
-	const res = await opts.chat.chat({
-		...opts.model ? { model: opts.model } : {},
+	const res = await profileChatClient({
+		profile: opts.profile,
+		executor: opts.executor,
+		context: "intent auditor"
+	}).chat({
 		jsonSchema: auditSchema,
 		messages: [{
-			role: "system",
-			content: opts.auditorInstruction ?? "You audit whether an AI agent is on the RIGHT ROUTE — not whether it works hard, but whether its actions serve the stated intents. Infer the REVEALED intent from the action pattern (what the trajectory is actually optimizing). Compare against the declared task intent, the user intent when given, and the meta-intent when given. Flawless execution down the wrong route is DIVERGED. Busy-work that neither advances nor harms is DRIFTING. Judge only from the trajectory — be specific about which actions ground your verdict. Recommend abort only when continuing cannot serve the intent."
-		}, {
 			role: "user",
 			content: `DECLARED INTENT (the task):\n${input.declaredIntent}\n\n` + (input.userIntent ? `USER INTENT (the principal's actual goal):\n${input.userIntent}\n\n` : "") + (input.metaIntent ? `META-INTENT (what the whole run is for):\n${input.metaIntent}\n\n` : "") + `TRAJECTORY (in order):\n${summarize(input.trace, opts.maxTraceLines ?? 80)}\n\nAudit the route: revealed intent, verdict, evidence, one recommendation.`
 		}]
@@ -1036,7 +1040,10 @@ function loopCostReceipt(result, model) {
 		model,
 		inputTokens: result.tokenUsage.input,
 		outputTokens: result.tokenUsage.output,
-		...result.costUsd > 0 ? { actualCostUsd: result.costUsd } : {}
+		...result.tokenUsage.tokensKnown === false ? { usageUnknown: true } : {},
+		...result.costUsdKnown !== false ? { actualCostUsd: result.costUsd } : {},
+		...result.costUsdKnown === false ? { costUnknown: true } : {},
+		...result.estimatedCostUsd !== void 0 ? { estimatedCostUsd: result.estimatedCostUsd } : {}
 	};
 }
 function modelFromLoopOptions(options) {
@@ -1071,6 +1078,20 @@ function loopDispatch(opts) {
 }
 //#endregion
 //#region src/runtime/inline-sandbox-client.ts
+/**
+* The ONE pseudo-box adapter: present any one-shot `Executor` (router / bridge /
+* BYO) as a `SandboxClient` so the round-synchronous `runAgentRounds` can drive it
+* without each call site re-faking a box. This is the single shell that
+* `bench/src/router-executor.ts`, generate-eval's old `bridgeSandboxClient`, and
+* the search-bench bridge transport were each re-implementing.
+*
+* It is deliberately for NON-box executors only — a real sandbox harness already
+* IS a `SandboxClient` (boxes, sessions, fs, fork are real there). Here each
+* `streamPrompt` runs the executor once and emits the terminal
+* `{type:'result', data:{finalText, tokenUsage, costUsd}}` event that
+* `answerOutput`/the kernel's cost ledger already parse — no sessions, no fs,
+* no fork (those degrade gracefully via the optional `SandboxClient` methods).
+*/
 function isAsyncIterable$1(v) {
 	return typeof v === "object" && v !== null && Symbol.asyncIterator in v;
 }
@@ -1088,7 +1109,8 @@ async function settle(exec, task, signal) {
 * instantiated fresh per `streamPrompt` (mirrors the per-spawn executor lifecycle):
 * run once on the prompt, emit the terminal result event, tear down.
 */
-function inlineSandboxClient(factory) {
+function inlineSandboxClient(factory, defaults = {}) {
+	const capturedDefaultProfile = defaults.profile === void 0 ? void 0 : agentProfileSchema.parse(structuredClone(defaults.profile));
 	let seq = 0;
 	return { async create(options) {
 		const id = `inline-${seq++}`;
@@ -1101,8 +1123,11 @@ function inlineSandboxClient(factory) {
 				const onAbort = () => controller.abort(callerSignal?.reason ?? /* @__PURE__ */ new Error("prompt aborted"));
 				if (callerSignal) if (callerSignal.aborted) onAbort();
 				else callerSignal.addEventListener("abort", onAbort, { once: true });
+				const requestedProfile = (options?.backend && typeof options.backend === "object" ? options.backend.profile : void 0) ?? capturedDefaultProfile;
+				const parsedProfile = agentProfileSchema.safeParse(requestedProfile);
+				if (!parsedProfile.success) throw new Error("inlineSandboxClient: an exact AgentProfile is required; pass defaults.profile or create({ backend: { profile } })");
 				const exec = factory({
-					profile: { name: id },
+					profile: parsedProfile.data,
 					harness: null
 				}, {
 					signal: controller.signal,
@@ -1114,23 +1139,43 @@ function inlineSandboxClient(factory) {
 					const tokensIn = artifact.spent.tokens.input;
 					const tokensOut = artifact.spent.tokens.output;
 					const costUsd = artifact.spent.usd;
-					if (tokensIn || tokensOut || costUsd) yield {
+					const estimatedCostUsd = out?.estimatedCostUsd;
+					if (artifact.spent.iterations > 0 || artifact.spent.tokensKnown === false || artifact.spent.usdKnown === false || tokensIn > 0 || tokensOut > 0 || costUsd > 0 || estimatedCostUsd !== void 0) yield {
 						type: "llm_call",
 						data: {
-							tokensIn,
-							tokensOut,
-							costUsd
+							...artifact.spent.tokensKnown === false ? {} : {
+								tokensIn,
+								tokensOut
+							},
+							...artifact.spent.usdKnown !== false ? { costUsd } : {},
+							...artifact.spent.tokensKnown === false ? { tokensKnown: false } : {},
+							...artifact.spent.usdKnown === false ? { costKnown: false } : {},
+							...artifact.spent.usdKnown !== false ? {
+								costKnown: true,
+								costProvenance: "provider-receipt"
+							} : {},
+							...estimatedCostUsd !== void 0 ? { estimatedCostUsd } : {},
+							...out?.promptCache ? { promptCache: out.promptCache } : {}
 						}
 					};
 					yield {
 						type: "result",
 						data: {
 							finalText: out?.content ?? "",
-							tokenUsage: {
+							...artifact.spent.tokensKnown === false ? { tokensKnown: false } : { tokenUsage: {
 								inputTokens: tokensIn,
 								outputTokens: tokensOut
+							} },
+							...artifact.spent.usdKnown === false ? {
+								costKnown: false,
+								...costUsd > 0 ? { costUsd } : {}
+							} : {
+								costUsd,
+								costKnown: true,
+								costProvenance: "provider-receipt"
 							},
-							costUsd
+							...estimatedCostUsd !== void 0 ? { estimatedCostUsd } : {},
+							...out?.promptCache ? { promptCache: out.promptCache } : {}
 						}
 					};
 				} finally {
@@ -1159,36 +1204,52 @@ function inlineSandboxClient(factory) {
 * local MCP process applies only when its full canonical bytes match the fixed
 * constructor profile; a different generated profile is refused.
 *
-* Event protocol matches `inlineSandboxClient`: one `llm_call` metering event
-* + one terminal `result` event with finalText/tokenUsage/costUsd.
+* Event protocol matches `inlineSandboxClient`: known token usage is emitted as one `llm_call`;
+* Router catalog cost remains a separately-labelled estimate, never billed spend.
 */
 /** A same-host `SandboxClient` adapter with no process isolation. Local MCP is
 * refused unless the caller explicitly supplies a policy that allows it. */
 function localSandboxClient(opts) {
-	if (opts.profileSecurityPolicy?.allowLocalMcp && opts.profile === void 0) throw new ValidationError("localSandboxClient: allowLocalMcp requires a fixed author-controlled profile; dynamic profiles need a real sandbox");
-	const trustedProfileDigest = opts.profileSecurityPolicy?.allowLocalMcp && opts.profile !== void 0 ? canonicalCandidateDigest(opts.profile) : void 0;
-	const maxTurns = opts.maxTurns ?? 8;
+	const defaultProfile = opts.profile === void 0 ? void 0 : executableAgentProfileSnapshot(opts.profile, "localSandboxClient default profile");
+	const router = Object.freeze({ ...opts.router });
+	if (opts.profileSecurityPolicy?.allowLocalMcp && defaultProfile === void 0) throw new ValidationError("localSandboxClient: allowLocalMcp requires a fixed author-controlled profile; dynamic profiles need a real sandbox");
+	const trustedProfileDigest = opts.profileSecurityPolicy?.allowLocalMcp && defaultProfile !== void 0 ? canonicalAgentProfileDigest(defaultProfile) : void 0;
 	let seq = 0;
 	return { async create(options) {
-		const profile = (options?.backend)?.profile ?? opts.profile ?? {};
-		const policyApplies = opts.profileSecurityPolicy !== void 0 && (!opts.profileSecurityPolicy.allowLocalMcp || trustedProfileDigest !== void 0 && canonicalCandidateDigest(profile) === trustedProfileDigest);
+		const profile = executableAgentProfileSnapshot((options?.backend)?.profile ?? defaultProfile, "localSandboxClient");
+		const model = profileProviderModel(profile);
+		const settings = profileModelExecutionSettings(profile, "localSandboxClient");
+		const policyApplies = opts.profileSecurityPolicy !== void 0 && (!opts.profileSecurityPolicy.allowLocalMcp || trustedProfileDigest !== void 0 && canonicalAgentProfileDigest(profile) === trustedProfileDigest);
 		const mcp = await materializeLocalMcp(profile, {
 			...opts.keys ? { keys: opts.keys } : {},
 			...policyApplies ? { profileSecurityPolicy: opts.profileSecurityPolicy } : {}
 		});
 		const brain = routerBrain({
-			routerBaseUrl: opts.router.baseUrl,
-			routerKey: opts.router.key,
-			model: opts.router.model
-		}, opts.temperature !== void 0 ? { temperature: opts.temperature } : {});
+			routerBaseUrl: router.baseUrl,
+			routerKey: router.key,
+			model,
+			...settings.retry !== void 0 ? { retry: settings.retry } : {},
+			...settings.maxTokens !== void 0 ? { maxTokens: settings.maxTokens } : {},
+			...settings.stream !== void 0 ? { stream: settings.stream } : {}
+		}, {
+			...settings.temperature !== void 0 ? { temperature: settings.temperature } : {},
+			...settings.seed !== void 0 ? { seed: settings.seed } : {},
+			...settings.toolChoice !== void 0 ? { toolChoice: settings.toolChoice } : {},
+			...settings.extraBody !== void 0 ? { extraBody: settings.extraBody } : {},
+			...profile.model?.reasoningEffort ? { reasoningEffort: profile.model.reasoningEffort } : {}
+		});
 		const system = [profile.prompt?.systemPrompt, ...profile.prompt?.instructions ?? []].filter((s) => typeof s === "string" && s.trim().length > 0).join("\n\n");
 		return {
 			id: `local-${seq++}`,
 			async *streamPrompt(message, popts) {
-				let costUsd = 0;
+				let estimatedCostUsd = 0;
+				let sawEstimatedCost = false;
 				const chat = async (messages, tools) => {
 					const r = await brain(messages, tools);
-					if (r.costUsd) costUsd += r.costUsd;
+					if (r.costProvenance === "catalog-estimate" && r.costUsd !== void 0) {
+						estimatedCostUsd += r.costUsd;
+						sawEstimatedCost = true;
+					}
 					return r;
 				};
 				const r = await runBrainLoop({
@@ -1202,26 +1263,31 @@ function localSandboxClient(opts) {
 						role: "user",
 						content: message
 					}],
-					maxTurns,
+					maxTurns: settings.maxTurns ?? 0,
 					hooks: { stopBefore: () => popts?.signal?.aborted === true }
 				});
-				if (r.usage.input || r.usage.output || costUsd) yield {
+				if (r.turns > 0) yield {
 					type: "llm_call",
 					data: {
-						tokensIn: r.usage.input,
-						tokensOut: r.usage.output,
-						costUsd
+						model,
+						...r.tokensKnown === false ? { tokensKnown: false } : {
+							tokensIn: r.usage.input,
+							tokensOut: r.usage.output
+						},
+						costKnown: false,
+						...sawEstimatedCost ? { estimatedCostUsd } : {}
 					}
 				};
 				yield {
 					type: "result",
 					data: {
 						finalText: r.final,
-						tokenUsage: {
+						...r.tokensKnown === false ? { tokensKnown: false } : { tokenUsage: {
 							inputTokens: r.usage.input,
 							outputTokens: r.usage.output
-						},
-						costUsd
+						} },
+						costKnown: false,
+						...sawEstimatedCost ? { estimatedCostUsd } : {}
 					}
 				};
 			},
@@ -1269,28 +1335,26 @@ function resolveSandboxClient(opts) {
 			return opts.sandboxClient;
 		case "bridge": {
 			const bridge = opts.bridge;
-			if (!bridge?.bearer || !bridge.model) throw new Error("resolveSandboxClient: backend 'bridge' requires bridge.bearer and bridge.model");
+			if (!bridge?.bearer) throw new Error("resolveSandboxClient: backend 'bridge' requires bridge.bearer");
 			return inlineSandboxClient(createExecutor({
 				backend: "bridge",
 				bridgeUrl: bridge.url ?? "http://127.0.0.1:3355",
 				bridgeBearer: bridge.bearer,
-				model: bridge.model,
 				timeoutMs: bridge.timeoutMs
 			}));
 		}
 		case "router": {
 			const router = opts.router;
-			if (!router?.baseUrl || !router.key || !router.model) throw new Error("resolveSandboxClient: backend 'router' requires router.baseUrl, router.key and router.model");
+			if (!router?.baseUrl || !router.key) throw new Error("resolveSandboxClient: backend 'router' requires router.baseUrl and router.key");
 			return inlineSandboxClient(createExecutor({
 				backend: "router",
 				routerBaseUrl: router.baseUrl,
-				routerKey: router.key,
-				model: router.model
+				routerKey: router.key
 			}));
 		}
 		case "local": {
 			const local = opts.local;
-			if (!local?.router?.baseUrl || !local.router.key || !local.router.model) throw new Error("resolveSandboxClient: backend 'local' requires local.router.baseUrl, local.router.key and local.router.model");
+			if (!local?.router?.baseUrl || !local.router.key) throw new Error("resolveSandboxClient: backend 'local' requires local.router.baseUrl and local.router.key");
 			return localSandboxClient(local);
 		}
 	}
@@ -1314,7 +1378,7 @@ function resolveSandboxClient(opts) {
 *
 *   - LEVEL 0 (declarative): `cases` / `prompt` / `score` / `axis`.
 *   - LEVEL 1 (seams): `backends`, `flags`, `parseOutput`, `onCellEvents`,
-*     `resolveModel`, `setup`/`teardown`, `export`, `modelBackend`, `matrix`
+*     `resolveModel`, `setup`/`teardown`, `export`, `matrix`
 *     passthrough.
 *   - LEVEL 2 (replacement): `dispatch` and `judges` swap out the whole
 *     loop wiring or scoring; `runProfileMatrix` itself stays public as the
@@ -1373,10 +1437,6 @@ function splitList(v) {
 function withSnapshot(model, snapshot) {
 	return model.includes("@") ? model : `${model}@${snapshot}`;
 }
-/** The bare model id the backend actually serves (identity snapshot stripped). */
-function bareModel(model) {
-	return model.split("@")[0] ?? model;
-}
 function gitSha() {
 	try {
 		return execFileSync("git", ["rev-parse", "HEAD"], { encoding: "utf8" }).trim();
@@ -1458,13 +1518,11 @@ function defineLeaderboard(spec) {
 		if (!rawModels || rawModels.length === 0) throw new Error(`defineLeaderboard(${spec.name}): no models — pass --models, set spec.axis.models, or give spec.baseProfile a model.default`);
 		const models = rawModels.map((m) => withSnapshot(m, snapshot));
 		const profiles = expandProfileAxes({
-			base: spec.baseProfile ?? {
-				name: spec.name,
-				model: { default: bareModel(models[0] ?? "") }
-			},
+			base: spec.baseProfile,
 			harnesses,
 			models
 		});
+		for (const profile of profiles) assertExecutableAgentProfile(profile, `defineLeaderboard(${spec.name})`);
 		const ctx = {
 			name: spec.name,
 			backend: backendName,
@@ -1489,7 +1547,6 @@ function defineLeaderboard(spec) {
 					bridge: {
 						url: process.env.CLI_BRIDGE_URL,
 						bearer,
-						model: bareModel(models[0] ?? ""),
 						timeoutMs: 9e5
 					}
 				});
@@ -1519,21 +1576,11 @@ function defineLeaderboard(spec) {
 					return [...served][0] ?? cellProfile.model?.default;
 				},
 				toLoopOptions: (cellScenario, cellProfile) => {
-					const axis = harnessAxisOf(cellProfile);
-					const modelId = bareModel(axis?.model ?? models[0] ?? "");
-					const backendModel = {
-						...spec.modelBackend,
-						...!isHarnessNativeModel(modelId) || backendName === "cli-bridge" ? { model: modelId } : {}
-					};
 					return {
 						driver: naiveRetryDriver(shots),
 						agentRun: {
 							profile: cellProfile,
-							taskToPrompt: (s) => `${promptOf(s)}\n\n<!-- independent-attempt:${shotNonce++} -->`,
-							...axis ? { sandboxOverrides: { backend: {
-								type: axis.harness,
-								...Object.keys(backendModel).length > 0 ? { model: backendModel } : {}
-							} } } : {}
+							taskToPrompt: (s) => `${promptOf(s)}\n\n<!-- independent-attempt:${shotNonce++} -->`
 						},
 						output: { parse: (events) => spec.parseOutput ? spec.parseOutput(events, cellScenario.case) : collectAgentResponseText(events) ?? "" },
 						validator: { validate: async (output) => {
@@ -1654,11 +1701,10 @@ async function harvestCorpus(opts) {
 			if (opts.signal?.aborted) return;
 			try {
 				const obs = await observe(input, {
-					chat: opts.chat,
-					...opts.model ? { model: opts.model } : {},
+					profile: opts.profile,
+					executor: opts.executor,
 					corpus: opts.corpus,
 					tags: opts.tags ?? [],
-					...opts.analystInstruction ? { analystInstruction: opts.analystInstruction } : {},
 					...opts.signal ? { signal: opts.signal } : {}
 				});
 				report.runsObserved += 1;
@@ -1942,7 +1988,7 @@ function observedBestScore(settledSoFar) {
 * CONCRETE blocker (never an eager over-fan, never a silent drop), and a `blocked` outcome always
 * names at least one blocker (a shape that cannot finish MUST say why — `blocked([])` throws).
 *
-* @experimental
+* @stable
 */
 /**
 * The single content-free valid-only winner selector. Among the gated-VALID children only
@@ -1977,6 +2023,8 @@ function selectValidWinner(opts) {
 * pool would not admit, or a stage whose `collect` chose to block) short-circuits — its blockers
 * ARE the pipeline's blockers, never coerced past a failed stage. The terminal stage's `done`
 * deliverable is the pipeline's deliverable.
+*
+* @stable
 */
 function pipeline(stages) {
 	if (stages.length === 0) throw new ValidationError("pipeline: at least one stage is required");
@@ -2013,6 +2061,8 @@ function pipeline(stages) {
 * `opts.width` swaps the single round for `rollingDispatch`: at most `width` items live at once,
 * refilled the instant one settles. Selection, blockers, and the conserved pool are unchanged —
 * the refill behavior lives in the existing combinator rather than in a rival primitive.
+*
+* @stable
 */
 function fanout(items, opts) {
 	if (opts.synthesize && opts.selectWinner) throw new ValidationError("fanout: pass at most one of `synthesize` or `selectWinner`");
@@ -2096,6 +2146,8 @@ function fanout(items, opts) {
 * `until` on the resulting trace-derived findings (the analyst spawns into THIS scope, so its
 * compute is conserved-pooled — equal-k holds by construction). Absent an analyst the findings
 * argument is the empty array — never a fabricated finding (fail-loud honesty over a silent default).
+*
+* @stable
 */
 function loopUntil(seed, spec) {
 	return (ctx) => ({
@@ -2144,6 +2196,8 @@ function loopUntil(seed, spec) {
 * reaches another judge's task; the merge never spawns or re-ranks). A `down` judge carries no
 * verdict and is excluded from the merge denominator. A panel that admitted no judge is a
 * concrete blocker before `merge` is consulted.
+*
+* @stable
 */
 function panel(spec) {
 	if (spec.judges.length === 0) throw new ValidationError("panel: at least one judge is required");
@@ -2193,6 +2247,8 @@ function panel(spec) {
 * it; only a `valid` verifier verdict ships. Any other outcome (implement down, verifier down,
 * verifier verdict absent or not `valid`) is a concrete blocker carrying the failure verbatim —
 * never a coerced "done". The implement child does not grade itself.
+*
+* @stable
 */
 function verify(spec) {
 	return (ctx) => ({
@@ -2237,6 +2293,8 @@ function verify(spec) {
 * the widen loop sees it. The shipped default (`flatWidenGate`) never widens, so no widen child is
 * ever live when the analyst runs and the wire is exact; a non-flat gate must drive the analyst on
 * a scope whose siblings are quiesced, or read findings without the shared-cursor drain.
+*
+* @stable
 */
 function widen(spec) {
 	return (ctx) => ({
@@ -2686,19 +2744,22 @@ function registerShape(name, factory) {
 * receive a ctx with the persona seams merged in — so a persona never has to pre-close its
 * factories by hand. A persona may instead supply a fully-built `registry` and skip the wrap.
 *
-* @experimental
+* @stable
 */
 /**
 * Build a frozen `Persona`. Fails loud on the executors-supplied invariant: a persona with
 * neither a pre-built registry nor a seam bag cannot resolve its built-in runtimes, so it is
 * unrunnable — refuse it at definition time, not at the first spawn. Pure; no I/O.
+*
+* @stable
 */
 function definePersona(input) {
 	if (!input.executors.registry && !input.executors.seams) throw new ValidationError(`definePersona("${input.name}"): executors must supply a registry or a seams bag (built-in runtimes read their seams off ExecutorContext; neither was provided)`);
 	if (!input.root || typeof input.root !== "object" || !("harness" in input.root)) throw new ValidationError(`definePersona("${input.name}"): root must be an AgentSpec`);
+	const root = executableAgentSpecSnapshot(input.root, `definePersona("${input.name}")`);
 	return Object.freeze({
 		name: input.name,
-		root: input.root,
+		root,
 		directive: input.directive,
 		context: input.context,
 		executors: input.executors,
@@ -2741,6 +2802,8 @@ function createShapeContext(persona, budget, analyst) {
 * `ShapeContext`, and runs the resulting root `Agent` to a typed `SupervisedResult<Outcome>`.
 * Fail loud on an unknown shape name or an unresolvable persona registry — never a silent
 * default-shape fallback.
+*
+* @stable
 */
 async function runPersonified(options) {
 	const { persona } = options;
@@ -3291,22 +3354,34 @@ async function pool(items, limit, fn) {
 async function preflightModels(cfg) {
 	if (cfg.modelPreflight === false) return;
 	if (cfg.worker.complete && !cfg.modelPreflight) return;
-	const models = [.../* @__PURE__ */ new Set([cfg.worker.model, cfg.worker.analystModel ?? cfg.worker.model])];
+	const profiles = [cfg.worker.workerProfile, cfg.worker.analystProfile ?? cfg.worker.workerProfile];
+	const profilesByModel = /* @__PURE__ */ new Map();
+	for (const [index, profile] of profiles.entries()) {
+		const model = concreteModelId(profile.model?.default);
+		if (!model) throw new Error(`Benchmark ${index === 0 ? "worker" : "analyst"} AgentProfile.model.default must name an exact model`);
+		if (!profilesByModel.has(model)) profilesByModel.set(model, profile);
+	}
+	const models = [...profilesByModel.keys()];
 	const timeoutMs = cfg.modelPreflightTimeoutMs ?? 3e4;
 	if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) throw new Error("modelPreflightTimeoutMs must be a positive finite number");
 	const check = cfg.modelPreflight ?? (async (model, worker, signal) => {
-		await routerChatWithUsage({
-			routerBaseUrl: worker.routerBaseUrl,
-			routerKey: worker.routerKey,
-			model
-		}, [{
-			role: "user",
-			content: "Reply OK."
-		}], {
-			maxTokens: 1,
-			reasoningEffort: "none",
-			signal
-		});
+		const profile = profilesByModel.get(model);
+		if (!profile) throw new Error(`Benchmark preflight has no AgentProfile for model ${model}`);
+		await profileChatClient({
+			profile,
+			context: `runBenchmark model preflight (${model})`,
+			executor: {
+				backend: "router",
+				routerBaseUrl: worker.routerBaseUrl,
+				routerKey: worker.routerKey
+			}
+		}).chat({
+			model,
+			messages: [{
+				role: "user",
+				content: "Reply OK."
+			}]
+		}, { signal });
 	});
 	const failures = (await Promise.allSettled(models.map(async (model) => {
 		const controller = new AbortController();
@@ -3362,8 +3437,10 @@ async function runBenchmark(cfg) {
 					resolved: r.resolved,
 					progression: r.progression,
 					usd: r.usd,
+					usdKnown: r.usdKnown,
 					ms: r.ms,
-					tokens: r.tokens
+					tokens: r.tokens,
+					tokensKnown: r.tokensKnown
 				};
 			} catch (e) {
 				errors[s.name] = e instanceof Error ? e.message.slice(0, 300) : String(e);
@@ -3372,11 +3449,13 @@ async function runBenchmark(cfg) {
 					resolved: false,
 					progression: [],
 					usd: 0,
+					usdKnown: true,
 					ms: 0,
 					tokens: {
 						input: 0,
 						output: 0
-					}
+					},
+					tokensKnown: true
 				};
 			}
 			row = {
@@ -3403,6 +3482,7 @@ async function runBenchmark(cfg) {
 			score: mean(cells.map((c) => c.score)),
 			resolved: mean(cells.map((c) => c.resolved ? 1 : 0)),
 			usd: mean(cells.map((c) => c.usd)),
+			usdKnownRate: mean(cells.map((c) => c.usdKnown ? 1 : 0)),
 			ms: mean(cells.map((c) => c.ms))
 		};
 	}
@@ -3794,6 +3874,8 @@ export default defineStrategy('your-strategy-name', async ({ surface, task, budg
   // your composition (listTools comes from the destructured context — it is NOT a global)
 })
 `;
+/** Standing behavior callers put in the strategy-author AgentProfile. */
+const strategyAuthorSystemPrompt = "You are a senior researcher authoring optimization strategies for agent loops: you read per-task losses like experimental data, form a mechanism-level hypothesis, and author the one composition that tests it. Output exactly one fenced ```ts code block and nothing else.";
 /** Static CONTRACT lint over an authored strategy module — the module-boundary
 *  enforcement of the harness's two measurement invariants:
 *    - author blindness: the only import allowed is the kernel surface. A body that could
@@ -3820,21 +3902,17 @@ function assertStrategyContract(code) {
 }
 /** One authoring attempt: chat with the given model, extract the fenced module. Throws
 *  when the reply carries no code block. */
-async function requestAuthoredCode(opts, model) {
-	const res = await opts.chat.chat({
-		...model ? { model } : {},
-		...opts.temperature !== void 0 ? { temperature: opts.temperature } : {},
-		...opts.maxTokens !== void 0 ? { maxTokens: opts.maxTokens } : {},
-		messages: [{
-			role: "system",
-			content: "You are a senior researcher authoring optimization strategies for agent loops: you read per-task losses like experimental data, form a mechanism-level hypothesis, and author the one composition that tests it. Output exactly one fenced ```ts code block and nothing else."
-		}, {
-			role: "user",
-			content: `${opts.contract ?? strategyAuthorContract}\n\nBASELINE RESULTS on the "${opts.environmentName}" environment (budget=${opts.budget}) — the per-task losses are your gradient:\n${opts.lossesJson}\n\nAuthor ONE new strategy that you expect to beat the baselines on THIS environment at the same budget.\n${strategyAuthorMethod}\n\nOutput only the module code block.`
-		}]
-	}, { ...opts.signal ? { signal: opts.signal } : {} });
+async function requestAuthoredCode(opts, profile) {
+	const res = await profileChatClient({
+		profile,
+		executor: opts.executor,
+		context: "strategy author"
+	}).chat({ messages: [{
+		role: "user",
+		content: `${opts.contract ?? strategyAuthorContract}\n\nBASELINE RESULTS on the "${opts.environmentName}" environment (budget=${opts.budget}) — the per-task losses are your gradient:\n${opts.lossesJson}\n\nAuthor ONE new strategy that you expect to beat the baselines on THIS environment at the same budget.\n${strategyAuthorMethod}\n\nOutput only the module code block.`
+	}] }, { ...opts.signal ? { signal: opts.signal } : {} });
 	const match = res.content.match(/```(?:ts|typescript)?\s*\n([\s\S]*?)```/);
-	if (!match?.[1]) throw new Error(`authorStrategy: no code block in the author's reply (model=${model ?? "default"}): ${res.content.slice(0, 300)}`);
+	if (!match?.[1]) throw new Error(`authorStrategy: no code block in the author's reply: ${res.content.slice(0, 300)}`);
 	return match[1];
 }
 /** Author + load a strategy from losses. Throws when the author emits no loadable module;
@@ -3842,10 +3920,10 @@ async function requestAuthoredCode(opts, model) {
 async function authorStrategy(opts) {
 	let code;
 	try {
-		code = await requestAuthoredCode(opts, opts.model);
+		code = await requestAuthoredCode(opts, opts.profile);
 	} catch (primaryError) {
-		if (!opts.fallbackModel) throw primaryError;
-		code = await requestAuthoredCode(opts, opts.fallbackModel);
+		if (!opts.fallbackProfile) throw primaryError;
+		code = await requestAuthoredCode(opts, opts.fallbackProfile);
 	}
 	assertStrategyContract(code);
 	mkdirSync(opts.outDir, { recursive: true });
@@ -3883,6 +3961,8 @@ async function authorStrategy(opts) {
 * Lineage fields (`parent`, `generation`) are recorded on every archive node so a
 * descendant-productivity parent-selection policy can be added without changing the
 * report schema; the v1 search authors from the latest tournament's losses.
+*
+* @experimental
 */
 /** Strategy means recomputed over the DISCRIMINATING tasks only — tasks where the field
 *  strategies did not all score identically. Zero-spread tasks (everyone 1.0, everyone
@@ -4084,11 +4164,9 @@ async function runStrategyEvolution(cfg) {
 			const contract = `${strategyAuthorContract}${cfg.objective === "cost" ? `\n\nYOUR OBJECTIVE: match or exceed the incumbent's SCORE while spending LESS (the losses include usd per task). Promotion requires proven score non-inferiority PLUS significant cost savings — a strategy that ties the score at half the cost WINS; a cheaper strategy that loses score by more than ${((cfg.scoreTolerance ?? .05) * 100).toFixed(0)}pp LOSES.` : ""}\n\nEXAMPLE TOOLS FROM ONE TASK (tool sets VARY per task on this domain — a strategy MUST select tool names from await listTools(handle) at runtime; hardcoding these example names will zero your score on most tasks):\n${toolCatalog}\n\nSTRATEGIES ALREADY IN THE TOURNAMENT (author something MEANINGFULLY different — a new composition, not a rename):\n${fieldSummary(archive)}\n\nYou are authoring candidate ${i + 1} of ${populationSize} this generation; explore a distinct region of the strategy space from your siblings.`;
 			try {
 				const authored = await authorStrategy({
-					chat: cfg.author.chat,
-					...cfg.author.model ? { model: cfg.author.model } : {},
-					...cfg.author.fallbackModel ? { fallbackModel: cfg.author.fallbackModel } : {},
-					...cfg.author.temperature !== void 0 ? { temperature: cfg.author.temperature } : {},
-					...cfg.author.maxTokens !== void 0 ? { maxTokens: cfg.author.maxTokens } : {},
+					profile: cfg.author.profile,
+					executor: cfg.author.executor,
+					...cfg.author.fallbackProfile ? { fallbackProfile: cfg.author.fallbackProfile } : {},
 					contract,
 					environmentName: cfg.environment.name,
 					lossesJson,
@@ -4225,24 +4303,24 @@ async function runStrategyEvolution(cfg) {
 		const tolerance = cfg.reproducerCheck.tolerance ?? .05;
 		const championHoldoutScore = holdout.perStrategy[incumbent.name]?.score ?? 0;
 		try {
-			const summary = (await cfg.author.chat.chat({
-				...cfg.author.model ? { model: cfg.author.model } : {},
-				temperature: .2,
-				maxTokens: 512,
-				messages: [{
-					role: "system",
-					content: `Summarize the optimization strategy implemented by this code in at most ${words} words. Describe the COMPOSITION (shots, critique, artifact handling, restarts, stopping) — not the code. Output only the summary.`
-				}, {
-					role: "user",
-					content: championCode
-				}]
-			})).content.trim();
+			const summary = (await profileChatClient({
+				profile: {
+					...cfg.author.profile,
+					prompt: {
+						...cfg.author.profile.prompt,
+						systemPrompt: `Summarize the optimization strategy implemented by this code in at most ${words} words. Describe the COMPOSITION (shots, critique, artifact handling, restarts, stopping) — not the code. Output only the summary.`
+					}
+				},
+				executor: cfg.author.executor,
+				context: "strategy reproducer summary"
+			}).chat({ messages: [{
+				role: "user",
+				content: championCode
+			}] })).content.trim();
 			const reproduced = await authorStrategy({
-				chat: cfg.author.chat,
-				...cfg.author.model ? { model: cfg.author.model } : {},
-				...cfg.author.fallbackModel ? { fallbackModel: cfg.author.fallbackModel } : {},
-				...cfg.author.maxTokens !== void 0 ? { maxTokens: cfg.author.maxTokens } : {},
-				temperature: .2,
+				profile: cfg.author.profile,
+				executor: cfg.author.executor,
+				...cfg.author.fallbackProfile ? { fallbackProfile: cfg.author.fallbackProfile } : {},
 				contract: `${strategyAuthorContract}\n\nIMPLEMENT EXACTLY THIS STRATEGY (a colleague's description — do not invent a different approach):\n${summary}`,
 				environmentName: cfg.environment.name,
 				lossesJson: "[]",
@@ -4289,631 +4367,121 @@ async function runStrategyEvolution(cfg) {
 	};
 }
 //#endregion
-//#region src/runtime/stream-agent-turn.ts
-/**
-* `streamAgentTurn` — the ONE run-a-turn event-stream contract over every
-* execution substrate: a sandbox box (`SandboxInstance.streamPrompt`), a
-* one-shot `Executor` (cli-bridge / router / BYO, via `ExecutorFactory`), and
-* an in-process `AgentExecutionBackend` (the `resolveAgentBackend` output).
-*
-* One function, one vocabulary: every backend kind yields the existing
-* `RuntimeStreamEvent` union incrementally and ALWAYS terminates with a
-* `final` event whose `text` is the turn's final text and whose
-* `metadata.tokenUsage` / `metadata.costUsd` / `metadata.model` carry the
-* turn's metered usage. `collectAgentTurn` drains a stream into that terminal
-* summary plus the full event list.
-*
-* This is a UNIFICATION seam, not a new stream parser — each kind is a thin
-* adapter over code that already exists and is already hardened:
-*   - `box`      — `mapSandboxEvent` + `extractLlmCallEvent` (sandbox-events.ts)
-*                  project the sandbox event stream; nothing is re-mapped here.
-*   - `executor` — `inlineSandboxClient` (the ONE executor→box adapter) turns
-*                  the factory into a box, then the box path drives it. The
-*                  executor's settle/teardown lifecycle stays in that adapter.
-*   - `chat`     — the backend's own `stream()` surface, normalized by
-*                  `normalizeBackendStreamEvent` (the same projection
-*                  `runAgentTaskStream` applies).
-*
-* Distinct from `openSandboxRun` (box-only, session resume over one persistent
-* artifact, raw `SandboxEvent` deliverables) and from `runAgentTaskStream`
-* (full task lifecycle: knowledge preflight, session store, resume). This is
-* the minimal turn primitive underneath both worlds: prompt in, one normalized
-* event stream out, terminal result+usage guaranteed on every non-thrown path.
-*
-* Stream envelope: `backend_start` → incremental events → (`backend_error` on
-* failure) → `final`. A caller-initiated abort terminates with
-* `final.status: 'aborted'`; an expired `timeoutMs` deadline with
-* `final.status: 'failed'` — so cancellation stays distinguishable from a
-* blown deadline.
-*
-* Mid-stream lifecycle work needs NO extra API: the generator is pull-based,
-* so the producer is suspended between yields and resumes only when the caller
-* pulls again. A consumer can therefore run arbitrary async work between
-* events — sync state on each `tool_result`, decide a no-op retry after
-* draining, run a pre-`done` flush when it receives `final` and BEFORE it
-* forwards its own terminal event downstream. The interleaving is guaranteed
-* (and locked by test): nothing is produced past the event the caller is
-* holding.
-*
-* @experimental
-*/
+//#region src/runtime/supervise/chat-transport-executor.ts
 /**
-* Run ONE agent turn on any backend kind and stream its events. Yields the
-* `RuntimeStreamEvent` vocabulary incrementally and always ends with a `final`
-* event carrying the turn's text and usage (`metadata.tokenUsage`,
-* `metadata.costUsd?`, `metadata.model?`) — on success, failure, abort, and
-* timeout alike. The generator never throws; failures surface in-band as
-* `backend_error` + `final` with a typed `error` detail.
+* A session-owning composition over Runtime's canonical Router tool-loop executor.
 *
-* @experimental
-*/
-async function* streamAgentTurn(backend, prompt, opts = {}) {
-	const label = backend.kind === "chat" ? backend.backend.kind : backend.kind;
-	const task = {
-		id: `turn-${crypto.randomUUID()}`,
-		intent: prompt
-	};
-	const acc = {
-		deltaText: "",
-		input: 0,
-		output: 0,
-		costUsd: 0
-	};
-	const deadline = deriveTurnSignal(opts.signal, opts.timeoutMs ?? 0);
-	let session;
-	try {
-		session = await startTurnSession(backend, task, prompt, deadline.signal, label);
-		yield {
-			type: "backend_start",
-			task,
-			session,
-			backend: label,
-			timestamp: nowIso()
-		};
-		const inner = backend.kind === "chat" ? driveChatTurn(backend.backend, task, session, prompt, deadline.signal, acc) : driveBoxTurn(backend.kind === "executor" ? await inlineSandboxClient(backend.factory).create() : backend.box, prompt, deadline.signal, backend.agentRunName ?? "agent", acc, {
-			...backend.kind !== "executor" && backend.options ? { options: backend.options } : {},
-			preserveToolParts: opts.preserveToolParts === true,
-			...opts.onRawEvent ? { onRawEvent: opts.onRawEvent } : {}
-		});
-		for await (const event of inner) {
-			yield event;
-			throwIfAborted(deadline.signal);
-		}
-		yield buildFinalEvent(task, session, acc, {
-			status: "completed",
-			reason: "turn completed"
-		});
-	} catch (err) {
-		const callerAborted = opts.signal?.aborted === true;
-		const status = callerAborted ? "aborted" : "failed";
-		const message = err instanceof Error ? err.message : String(err);
-		const error = err instanceof BackendTransportError ? {
-			kind: "transport",
-			message,
-			status: err.status,
-			body: err.body
-		} : {
-			kind: "backend",
-			message
-		};
-		yield {
-			type: "backend_error",
-			task,
-			...session ? { session } : {},
-			backend: label,
-			message,
-			recoverable: !callerAborted,
-			error,
-			timestamp: nowIso()
-		};
-		yield buildFinalEvent(task, session, acc, {
-			status,
-			reason: message,
-			error
-		});
-	} finally {
-		deadline.dispose();
-	}
-}
-/**
-* Drain a `streamAgentTurn` stream (or any `RuntimeStreamEvent` stream that
-* honors its terminal contract) into the turn summary plus the full event
-* list. Fail-loud: throws when the stream ends without a terminal `final`
-* event — a stream that violates the contract must not read as an empty turn.
+* This module adds conversation persistence for graph-edge `resume` continuity. It does not own
+* model selection, prompts, generation controls, retries, tool policy, or provider accounting:
+* those are lowered from one exact `AgentProfile` by `createExecutor({ backend: 'router-tools' })`.
 *
 * @experimental
 */
-async function collectAgentTurn(stream) {
-	const events = [];
-	for await (const event of stream) events.push(event);
-	const final = events.at(-1);
-	if (final?.type !== "final") throw new Error(`collectAgentTurn: stream ended without a terminal 'final' event (last: ${final ? final.type : "none"})`);
-	const metadata = final.metadata ?? {};
-	const tokenUsage = metadata.tokenUsage && typeof metadata.tokenUsage === "object" ? metadata.tokenUsage : {};
-	const usage = {
-		input: finiteNumber(tokenUsage.input) ?? 0,
-		output: finiteNumber(tokenUsage.output) ?? 0
-	};
-	const costUsd = finiteNumber(metadata.costUsd);
-	if (costUsd !== void 0) usage.costUsd = costUsd;
-	if (typeof metadata.model === "string" && metadata.model.length > 0) usage.model = metadata.model;
-	return {
-		finalText: final.text ?? "",
-		usage,
-		events,
-		status: final.status,
-		...final.error ? { error: final.error } : {}
-	};
-}
-/** Start the backend's session when it owns one (`chat` kind); mint a local
-*  correlation session otherwise. Box/executor turns carry no server session
-*  here — resume lives in `openSandboxRun`/`SandboxLineage`, not this primitive. */
-async function startTurnSession(backend, task, prompt, signal, label) {
-	if (backend.kind === "chat" && backend.backend.start) return backend.backend.start({
-		task,
-		message: prompt
-	}, {
-		task,
-		knowledge: emptyReadiness(task),
-		signal
-	});
-	return newRuntimeSession(label);
-}
-/**
-* One turn over a box: `box.streamPrompt` projected through the existing
-* `mapSandboxEvent` (text/reasoning deltas +
-* cost-bearing `llm_call`s), plus the opt-in `mapSandboxToolEvent` tool-part
-* projection. Usage accumulates off the mapped `llm_call` events — the same
-* fold `sumSandboxUsage` applies. Final text prefers the terminal
-* `result`/`done`/`final` payload over concatenated deltas, because the
-* sandbox `message.part.updated` fallback may carry running accumulations.
-*/
-async function* driveBoxTurn(box, prompt, signal, agentRunName, acc, cfg) {
-	const callOptions = {
-		...cfg.options ?? {},
-		signal
-	};
-	const stream = box.streamPrompt(prompt, callOptions);
-	const toolParts = cfg.preserveToolParts ? createSandboxToolPartState() : void 0;
-	for await (const event of stream) {
-		if (cfg.onRawEvent) await cfg.onRawEvent(event);
-		const terminalText = terminalTextFromSandboxEvent(event);
-		if (terminalText !== void 0) acc.terminalText = terminalText;
-		if (toolParts) for (const toolEvent of mapSandboxToolEvent(event, toolParts)) yield toolEvent;
-		const mapped = mapSandboxEvent(event, { agentRunName });
-		if (!mapped) continue;
-		foldEvent(mapped, acc, agentRunName);
-		yield mapped;
-	}
-}
-/** One turn over an in-process backend: its own `stream()` surface, projected
-*  through the same `normalizeBackendStreamEvent` the task lifecycle applies. */
-async function* driveChatTurn(backend, task, session, prompt, signal, acc) {
-	const input = {
-		task,
-		message: prompt
-	};
-	const context = {
-		task,
-		knowledge: emptyReadiness(task),
-		session,
-		signal
-	};
-	for await (const raw of backend.stream(input, context)) {
-		const event = normalizeBackendStreamEvent(raw, task, session);
-		foldEvent(event, acc);
-		yield event;
-	}
-}
-/** Fold one normalized event into the turn accumulator (text + usage).
-*  `fallbackModelLabel` — a mapper-stamped run label to exclude from
-*  `usage.model` (it is not a backend-reported model). */
-function foldEvent(event, acc, fallbackModelLabel) {
-	if (event.type === "text_delta") {
-		acc.deltaText += event.text;
-		return;
-	}
-	if (event.type === "llm_call") {
-		acc.input += event.tokensIn ?? 0;
-		acc.output += event.tokensOut ?? 0;
-		acc.costUsd += event.costUsd ?? 0;
-		if (event.model && event.model !== fallbackModelLabel) acc.model = event.model;
-	}
-}
-/** Read the final text off a terminal sandbox event, when present. */
-function terminalTextFromSandboxEvent(event) {
-	if (!event || typeof event !== "object") return void 0;
-	const type = String(event.type ?? "");
-	if (type !== "result" && type !== "done" && type !== "final") return void 0;
-	const data = event.data && typeof event.data === "object" ? event.data : {};
-	for (const key of [
-		"finalText",
-		"text",
-		"response",
-		"content"
-	]) {
-		const value = data[key];
-		if (typeof value === "string") return value;
-	}
-}
-function buildFinalEvent(task, session, acc, outcome) {
-	const finalText = acc.terminalText ?? acc.deltaText;
+/** In-memory, process-local conversation store with detached reads and writes. */
+function createChatSessionStore() {
+	const sessions = /* @__PURE__ */ new Map();
 	return {
-		type: "final",
-		task,
-		...session ? { session } : {},
-		status: outcome.status,
-		reason: outcome.reason,
-		...finalText ? { text: finalText } : {},
-		metadata: {
-			tokenUsage: {
-				input: acc.input,
-				output: acc.output
-			},
-			...acc.costUsd > 0 ? { costUsd: acc.costUsd } : {},
-			...acc.model ? { model: acc.model } : {}
+		load(workerId) {
+			const messages = sessions.get(workerId);
+			return messages === void 0 ? void 0 : structuredClone(messages);
 		},
-		...outcome.error ? { error: outcome.error } : {},
-		timestamp: nowIso()
-	};
-}
-/** Minimal ready-by-construction readiness report for a requirement-free turn. */
-function emptyReadiness(task) {
-	return scoreKnowledgeReadiness({
-		taskId: task.id,
-		requirements: []
-	});
-}
-function finiteNumber(value) {
-	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
-}
-function throwIfAborted(signal) {
-	if (!signal.aborted) return;
-	throw signal.reason instanceof Error ? signal.reason : new Error(String(signal.reason));
-}
-/**
-* Derive the turn's effective abort signal: fires when EITHER the caller's
-* signal aborts OR the `timeoutMs` deadline elapses. `dispose()` clears the
-* timer so a finished turn never leaks a pending timeout. `timeoutMs <= 0`
-* disables the deadline. Node-portable (no `AbortSignal.any`, which needs
-* >=20.3 — the package floor is >=20).
-*/
-function deriveTurnSignal(callerSignal, timeoutMs) {
-	const controller = new AbortController();
-	const timer = timeoutMs > 0 ? setTimeout(() => controller.abort(/* @__PURE__ */ new Error(`agent turn timed out after ${timeoutMs}ms`)), timeoutMs) : void 0;
-	if (timer && typeof timer.unref === "function") timer.unref();
-	const onCallerAbort = () => controller.abort(callerSignal?.reason ?? /* @__PURE__ */ new Error("agent turn aborted"));
-	if (callerSignal) if (callerSignal.aborted) onCallerAbort();
-	else callerSignal.addEventListener("abort", onCallerAbort, { once: true });
-	return {
-		signal: controller.signal,
-		dispose: () => {
-			if (timer) clearTimeout(timer);
-			callerSignal?.removeEventListener("abort", onCallerAbort);
+		save(workerId, messages) {
+			sessions.set(workerId, structuredClone(messages));
 		}
 	};
 }
-//#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}` } : {}
+function exactProfile(profile, context) {
+	const parsed = agentProfileSchema.safeParse(profile);
+	if (!parsed.success) throw new ValidationError(`${context}: invalid AgentProfile: ${parsed.error.message}`);
+	assertExecutableAgentProfile(parsed.data, context);
+	return parsed.data;
+}
+function initialMessages(opts) {
+	if (!opts.resume) return void 0;
+	if (!opts.sessions) throw new ValidationError("chat transport: a 'resume' spawn needs the session store holding the prior conversation");
+	const prior = opts.sessions.load(opts.resume.ofWorker);
+	if (prior === void 0) throw new ValidationError(`chat transport: no recorded conversation for worker '${opts.resume.ofWorker}'`);
+	return prior;
+}
+function executorConfig(opts) {
+	const profile = exactProfile(opts.profile, "chat transport");
+	if (!opts.complete && !opts.url) throw new ValidationError("chat transport: url required unless complete is injected");
+	const tools = opts.tools ?? [];
+	for (const tool of tools) if (!tool.spec.function.name || typeof tool.execute !== "function") throw new ValidationError("chat transport: every tool needs spec.function.name and execute");
+	const resumed = initialMessages(opts);
+	return {
+		profile,
+		config: {
+			backend: "router-tools",
+			routerBaseUrl: opts.url ?? "http://injected.invalid",
+			routerKey: opts.bearer ?? (opts.complete ? "injected-transport" : ""),
+			tools: tools.map((tool) => tool.spec),
+			executeToolCall: async (name, args, task) => {
+				const tool = tools.find((candidate) => candidate.spec.function.name === name);
+				if (!tool) throw new ValidationError(`chat transport: unknown tool ${JSON.stringify(name)}`);
+				return tool.execute(args, task);
 			},
-			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();
+			...opts.complete ? { complete: opts.complete } : {},
+			...resumed ? { initialMessages: resumed } : {},
+			...opts.sessions && opts.sessionKey ? { onMessages: (messages) => {
+				opts.sessions?.save(opts.sessionKey, messages);
+			} } : {}
+		}
 	};
 }
-/** 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));
-		}
+function buildChatTransportExecutor(opts, context) {
+	const { config, profile } = executorConfig(opts);
+	const spec = {
+		profile,
+		harness: null
 	};
+	return mapExecutorResult(createExecutor(config)(spec, context), (result) => {
+		const raw = result.out;
+		const content = typeof raw?.content === "string" ? raw.content : "";
+		return {
+			outRef: contentAddress({
+				kind: "chat-transport",
+				profile,
+				content
+			}),
+			out: content,
+			...result.verdict ? { verdict: result.verdict } : {}
+		};
+	});
 }
-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).
+* Build one exact profile-driven chat executor through `createExecutor`.
+* Prefer `chatWorkerSeam` for supervised work because it supplies trusted node identity.
 */
 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"
-		}
+	return buildChatTransportExecutor(opts, {
+		signal: new AbortController().signal,
+		seams: {}
 	});
 }
-/**
-* 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.
-*/
+/** Session-owning worker factory for graph continuity. */
 function chatWorkerSeam(opts) {
-	if (!opts.complete && (typeof opts.url !== "string" || opts.url.length === 0)) throw new ValidationError("chatWorkerSeam: url required (or inject `complete`)");
+	if (!opts.complete && !opts.url) throw new ValidationError("chatWorkerSeam: url required unless complete is injected");
 	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");
+		const profile = exactProfile(rawProfile, "chatWorkerSeam");
 		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 } : {},
+				executorFactory: (executorSpec, context) => {
+					const executor = buildChatTransportExecutor({
 						profile: executorSpec.profile,
-						...ctx.node?.attemptId !== void 0 ? { attemptId: ctx.node.attemptId } : {}
-					});
+						...opts.url ? { url: opts.url } : {},
+						...opts.bearer ? { bearer: opts.bearer } : {},
+						...opts.tools ? { tools: opts.tools } : {},
+						...opts.complete ? { complete: opts.complete } : {},
+						sessions,
+						...context.node?.nodeId ? { sessionKey: context.node.nodeId } : {},
+						...spawnContext?.resume ? { resume: spawnContext.resume } : {}
+					}, context);
 					return opts.deliverable ? gateOnDeliverable(executor, opts.deliverable) : executor;
 				}
 			}
@@ -4921,457 +4489,6 @@ function chatWorkerSeam(opts) {
 	};
 }
 //#endregion
-//#region src/runtime/supervise/graph.ts
-/**
-*
-* `runGraph` — agent graphs: profiles as nodes, registry-backed prompt directives as edges.
-*
-* A topology is PLAIN DATA an agent can author in a few lines: nodes are canonical
-* `AgentProfile`s (the ONLY way a node is described — no role-builder functions), edges are typed
-* values carrying versioned {@link PromptHandle} directives, `deliverable` (termination) and
-* `budget` (one conserved pool) are mandatory. Driver↔worker is the two-node cyclic instance;
-* "agent 3 analyzes 1 and 2 and reports to 1" is ONE edge, not a framework.
-*
-* NOT A SECOND SCHEDULER. `runGraph` is an interpretation layer over what already runs:
-* `supervise()` is the execution core — the same `supervisorAgent`/`driverAgent` machinery,
-* `makeWorkerAgent` seam, conserved-pool budget, and deliverable-gated settlement every
-* supervised run uses. (`runAgentRounds` is deliberately NOT the substrate here.) What the graph
-* layer ADDS is exactly what a bespoke driver loop never
-* had:
-*
-*  1. **Node pinning** — a spawn names a node (`profile.name` = node id) and the node's canonical
-*     profile is what runs; a driver cannot smuggle capabilities into a worker it did not define.
-*  2. **Observable edges** — every delegates/analyzes traversal lands in an EDGE LEDGER
-*     (`delivered | stripped | empty | unpropagated`, with byte counts), in memory on
-*     the result AND as `edge` events in the run journal. The motivating incident: a filter
-*     silently replaced 1,700-char steering with 241 chars of boilerplate for three rounds and
-*     NO artifact said so — an unobservable edge cannot be trusted and its directive cannot be
-*     optimized.
-*  3. **Directives as data** — edge text lives in the prompt registry (`<surface>/v<n>`), so every
-*     edge is a versioned optimization target, never prose hardcoded in a builder function.
-*  4. **Per-edge traversal caps** — the cyclic-graph backstop. A delegates edge whose cap is
-*     exhausted REFUSES further traversals (fail loud), so a cycle cannot spin the pool dry.
-*  5. **Continuity as data** — a delegates edge may declare `continuity: 'resume'`, so each spawn
-*     after the node's first re-attaches to its latest SETTLED session (the spawn context hands
-*     the executor seam `resume: { ofWorker, sequence }`; the kernel keeps identity, ordering,
-*     ledger truth, and the one conserved pool). Every ledger row states how its hop continued:
-*     `'fresh' | 'resume'` for spawns, `'steer'` for mid-run deliveries — fresh respawns, session
-*     resumes, and live steers are all plain data, each a ledgered fact.
-*
-* ORACLES ARE ENVIRONMENT, NEVER WORKERS. Graders/verifiers must not be spawnable in the graph —
-* a delegates edge to them leaks the rubric. An `analyzes` edge names its analyst in one of two
-* forms: a LENS id from the environment's registry (a pure function over trace evidence), or the
-* id of a graph NODE — a tool-equipped analyst AGENT spawned on each matching settle with the
-* node's pinned profile, whose settle output IS the findings. Either way the oracle doctrine
-* holds: an analyst node can never be a delegates target (refused loudly), so no driver can hand
-* it work, and an id living in both the registry and the nodes is refused as ambiguous.
-*
-* @experimental
-*/
-/** Default per-edge traversal cap — the cyclic-graph backstop when an edge names none. */
-const defaultEdgeTraversalCap = 32;
-/** A delegates edge exhausted its traversal cap and the run produced no winner: the cap, not the
-*  task, ended it. Carries the full evidence so failing loud loses nothing. */
-var GraphEdgeCapError = class extends Error {
-	exhaustedEdges;
-	ledger;
-	result;
-	constructor(exhaustedEdges, ledger, result) {
-		super(`runGraph: edge traversal cap exhausted on ${exhaustedEdges.join(", ")} and the run delivered no winner — the cap (the cyclic-graph backstop), not the task, ended this run. Raise maxTraversals on the edge or fix the cycle; the full edge ledger and the supervised result ride on this error.`);
-		this.name = "GraphEdgeCapError";
-		this.exhaustedEdges = exhaustedEdges;
-		this.ledger = ledger;
-		this.result = result;
-	}
-};
-function edgeId(edge) {
-	return edge.kind === "delegates" ? `delegates:${edge.from}->${edge.to}` : `analyzes:${edge.analyst}:${edge.over.join("+")}->${edge.to}`;
-}
-/** Validate the graph and resolve every directive BEFORE any compute is spent — an invalid
-*  topology or an unknown directive is a configuration fault, never a mid-run surprise. */
-function validateGraph(graph, registry, analysts) {
-	if (!Array.isArray(graph.nodes) || graph.nodes.length === 0) throw new ValidationError("runGraph: graph.nodes must be a non-empty array");
-	if (!Array.isArray(graph.edges) || graph.edges.length === 0) throw new ValidationError("runGraph: graph.edges must be a non-empty array");
-	if (typeof graph.deliverable?.check !== "function") throw new ValidationError("runGraph: graph.deliverable is mandatory (termination oracle)");
-	if (typeof graph.budget !== "object" || graph.budget === null) throw new ValidationError("runGraph: graph.budget is mandatory (the conserved pool)");
-	const byId = /* @__PURE__ */ new Map();
-	for (const node of graph.nodes) {
-		if (typeof node.id !== "string" || node.id.length === 0) throw new ValidationError("runGraph: every node needs a non-empty string id");
-		if (byId.has(node.id)) throw new ValidationError(`runGraph: duplicate node id '${node.id}'`);
-		const parsed = agentProfileSchema.safeParse(node.profile);
-		if (!parsed.success) throw new ValidationError(`runGraph: node '${node.id}' has an invalid AgentProfile: ${parsed.error.message}`);
-		if (node.profile.name !== node.id) throw new ValidationError(`runGraph: node '${node.id}' has profile.name ${JSON.stringify(node.profile.name)} — profile.name IS the node identity (node pinning and analyst routing match on it) and must equal the node id`);
-		byId.set(node.id, node);
-	}
-	const requireNode = (id, where) => {
-		const node = byId.get(id);
-		if (!node) throw new ValidationError(`runGraph: ${where} references unknown node '${id}'`);
-		return node;
-	};
-	const delegates = graph.edges.filter((edge) => edge.kind === "delegates");
-	const analyzes = graph.edges.filter((edge) => edge.kind === "analyzes");
-	if (delegates.length === 0) throw new ValidationError("runGraph: at least one delegates edge is required (who spawns whom)");
-	for (const edge of graph.edges) registry.resolve(edge.directive);
-	for (const edge of delegates) {
-		requireNode(edge.from, edgeId(edge));
-		requireNode(edge.to, edgeId(edge));
-		if (edge.from === edge.to) throw new ValidationError(`runGraph: ${edgeId(edge)} delegates to itself — the driver↔worker cycle is the settle-return loop, not a self-edge`);
-		if (edge.continuity !== void 0 && edge.continuity !== "fresh" && edge.continuity !== "resume") throw new ValidationError(`runGraph: ${edgeId(edge)} has invalid continuity ${JSON.stringify(edge.continuity)} — a delegates edge's continuity is 'fresh' or 'resume'`);
-	}
-	const delegatedTo = new Set(delegates.map((edge) => edge.to));
-	const roots = [...new Set(delegates.map((edge) => edge.from))].filter((id) => !delegatedTo.has(id));
-	if (roots.length !== 1) throw new ValidationError(`runGraph: expected exactly ONE root (a node that delegates and is never delegated to), found ${roots.length === 0 ? "none — delegates edges form a cycle with no entry" : roots.join(", ")}. P0 executes driver↔worker(s); nested driver graphs are P3.`);
-	const root = requireNode(roots[0], "root resolution");
-	for (const edge of delegates) if (edge.from !== root.id) throw new ValidationError(`runGraph: ${edgeId(edge)} delegates from a non-root node — P0 executes one driver over its workers (the 2-node cyclic case, star-generalized); deeper delegation is P3`);
-	const analystIds = /* @__PURE__ */ new Set();
-	const analystNodes = /* @__PURE__ */ new Map();
-	for (const edge of analyzes) {
-		if (edge.continuity !== void 0) throw new ValidationError(`runGraph: ${edgeId(edge)} carries continuity — analysts are spawned by the analyst machinery (every analyst run is a fresh session over settled evidence), so continuity is a delegates-edge axis only`);
-		if (analystIds.has(edge.analyst)) throw new ValidationError(`runGraph: two analyzes edges share analyst '${edge.analyst}' — one analyzes edge per analyst lens (traversals are ledgered by analyst id; a second edge would silently absorb the first's). Register the lens under a second id for a second edge.`);
-		analystIds.add(edge.analyst);
-		const analystNode = byId.get(edge.analyst);
-		const inRegistry = analysts?.kinds.some((kind) => kind.id === edge.analyst) === true;
-		if (analystNode !== void 0 && inRegistry) throw new ValidationError(`runGraph: ${edgeId(edge)} analyst '${edge.analyst}' is BOTH a graph node and a lens in the analysts registry — the id alone distinguishes the two analyst forms, so this is ambiguous; rename the node or register the lens under another id`);
-		if (analystNode !== void 0) {
-			if (analystNode.id === root.id) throw new ValidationError(`runGraph: ${edgeId(edge)} names the ROOT as its analyst — the root is the driver; give the analyst its own node with no delegates edge pointing at it`);
-			if (delegatedTo.has(analystNode.id)) throw new ValidationError(`runGraph: ${edgeId(edge)} names node '${edge.analyst}' as its analyst, but that node is a delegates target — oracle doctrine: an analyst is never delegated to. An analyst NODE is legal only with NO delegates edge pointing at it; give the analyst its own delegates-free node or pass a lens id from RunGraphOptions.analysts.`);
-			analystNodes.set(analystNode.id, analystNode);
-		} else if (!analysts) throw new ValidationError(`runGraph: ${edgeId(edge)} analyst '${edge.analyst}' is not a graph node, and no RunGraphOptions.analysts registry was provided to resolve it as a lens`);
-		else if (!inRegistry) throw new ValidationError(`runGraph: ${edgeId(edge)} analyst '${edge.analyst}' is neither a graph node nor in the analysts registry (known lenses: ${analysts.kinds.map((kind) => kind.id).join(", ") || "none"})`);
-		if (edge.over.length === 0) throw new ValidationError(`runGraph: ${edgeId(edge)} must analyze at least one node`);
-		for (const over of edge.over) {
-			requireNode(over, edgeId(edge));
-			if (over === root.id) throw new ValidationError(`runGraph: ${edgeId(edge)} analyzes the ROOT — analysts observe settled workers, and the root never settles as one, so this edge would silently never fire; list delegates-target nodes only`);
-		}
-		requireNode(edge.to, edgeId(edge));
-	}
-	for (const edge of analyzes) for (const over of edge.over) if (analystNodes.has(over)) throw new ValidationError(`runGraph: ${edgeId(edge)} analyzes '${over}', which is an analyst node — an analyst run settles as a finding, never as a worker, so this edge would silently never fire; analyst nodes are not analyzable`);
-	const workers = /* @__PURE__ */ new Map();
-	const delegatesByWorker = /* @__PURE__ */ new Map();
-	for (const edge of delegates) {
-		if (delegatesByWorker.has(edge.to)) throw new ValidationError(`runGraph: node '${edge.to}' is the target of two delegates edges — one delegation directive per worker node (version the directive instead of forking the edge)`);
-		delegatesByWorker.set(edge.to, edge);
-		workers.set(edge.to, requireNode(edge.to, edgeId(edge)));
-	}
-	for (const node of graph.nodes) if (node.id !== root.id && !workers.has(node.id) && !analystNodes.has(node.id)) throw new ValidationError(`runGraph: node '${node.id}' has no delegates edge to it — an unreachable node never runs`);
-	return {
-		root,
-		workers,
-		delegatesByWorker,
-		analyzes,
-		analystNodes
-	};
-}
-const byteLength = (text) => Buffer.byteLength(text, "utf8");
-function stringifyPayload(payload) {
-	if (typeof payload === "string") return payload;
-	try {
-		return JSON.stringify(payload) ?? String(payload);
-	} catch {
-		return String(payload);
-	}
-}
-/**
-* Execute an {@link AgentGraph}. The root node becomes the supervisor (`supervise()` — the
-* execution core), each worker node is spawnable BY NODE ID (`spawn_agent` with
-* `profile: { name: '<node id>' }`; the node's canonical profile is pinned by the graph), each
-* delegates directive is appended to the worker profile's `prompt.instructions` per traversal,
-* and each analyzes edge becomes an analyst-on-settle route with a real DESTINATION. Every
-* traversal is ledgered and journaled.
-*/
-function runGraph(graph, opts) {
-	const registry = opts.registry ?? kernelPromptRegistry();
-	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();
-	const runId = opts.runId ?? `graph-${canonicalCandidateDigest(graph.nodes.map((n) => n.id)).slice(7, 19)}`;
-	const now = opts.now ?? Date.now;
-	const ledger = [];
-	const journaled = /* @__PURE__ */ new Set();
-	const traversalCounts = /* @__PURE__ */ new Map();
-	const exhausted = /* @__PURE__ */ new Set();
-	const exhaustedDelegates = /* @__PURE__ */ new Set();
-	const journalWrites = [];
-	let ledgerSeq = 0;
-	const appendJournal = (entry, nodeIdForEvent) => {
-		if (journaled.has(entry)) return Promise.resolve();
-		journaled.add(entry);
-		const write = journal.appendEvent(runId, {
-			kind: "edge",
-			id: nodeIdForEvent,
-			edge: {
-				kind: entry.kind,
-				from: entry.from,
-				to: entry.to,
-				directive: entry.directive
-			},
-			traversal: entry.traversal,
-			outcome: entry.outcome,
-			continuity: entry.continuity,
-			bytes: entry.bytes,
-			...entry.reason !== void 0 ? { reason: entry.reason } : {},
-			seq: ledgerSeq++,
-			at: new Date(now()).toISOString()
-		});
-		journalWrites.push(write);
-		return write;
-	};
-	const record = (entry, journalNow) => {
-		const count = (traversalCounts.get(entry.edge) ?? 0) + 1;
-		traversalCounts.set(entry.edge, count);
-		const row = {
-			...entry,
-			traversal: count
-		};
-		ledger.push(row);
-		if (journalNow) appendJournal(row, row.workerId ?? `graph:${row.to}`);
-		return row;
-	};
-	const makeLeaf = opts.makeWorkerAgent ?? workerFromBackend(opts.backend, graph.deliverable);
-	const nodeByWorkerId = /* @__PURE__ */ new Map();
-	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;
-		const used = traversalCounts.get(id) ?? 0;
-		const spawnContinuity = spawnContext?.continuity ?? "fresh";
-		if (used >= cap) {
-			exhausted.add(id);
-			exhaustedDelegates.add(id);
-			record({
-				edge: id,
-				kind: "delegates",
-				from: edge.from,
-				to: edge.to,
-				directive: formatPromptHandle(edge.directive),
-				outcome: "unpropagated",
-				continuity: spawnContinuity,
-				bytes: 0,
-				reason: `traversal-cap-exhausted (max ${cap})`
-			}, true);
-			throw new ValidationError(`runGraph: delegates edge ${id} exhausted its traversal cap (${cap}) — the cyclic-graph backstop refused this spawn`);
-		}
-		const directiveText = registry.resolve(edge.directive).text;
-		const taskText = stringifyPayload(spawnContext?.task);
-		const bytes = byteLength(directiveText) + byteLength(taskText);
-		const row = record({
-			edge: id,
-			kind: "delegates",
-			from: edge.from,
-			to: edge.to,
-			directive: formatPromptHandle(edge.directive),
-			outcome: bytes === 0 ? "empty" : "delivered",
-			continuity: spawnContinuity,
-			bytes,
-			...bytes === 0 ? { reason: "no directive text and no task payload" } : {}
-		}, false);
-		if (spawnContext?.assignmentId !== void 0) pendingByAssignment.set(spawnContext.assignmentId, row);
-		else appendJournal(row, `graph:${row.to}`);
-		const pinned = directiveText.length === 0 ? node.profile : {
-			...node.profile,
-			prompt: {
-				...node.profile.prompt ?? {},
-				instructions: [...node.profile.prompt?.instructions ?? [], directiveText]
-			}
-		};
-		return makeLeaf(pinned, spawnContext);
-	};
-	const routes = analyzes.map((edge) => {
-		const analystNode = analystNodes.get(edge.analyst);
-		if (analystNode) return {
-			kind: edge.analyst,
-			over: edge.over,
-			agent: analystNode.profile,
-			directive: registry.resolve(edge.directive).text,
-			...edge.to === root.id ? {} : { to: edge.to }
-		};
-		return edge.to === root.id ? {
-			kind: edge.analyst,
-			over: edge.over
-		} : {
-			kind: edge.analyst,
-			over: edge.over,
-			to: edge.to,
-			directive: registry.resolve(edge.directive).text
-		};
-	});
-	const driverAnalyzesBriefs = analyzes.filter((edge) => edge.to === root.id).map((edge) => analystNodes.has(edge.analyst) ? `Findings from analyst '${edge.analyst}' (a tool-equipped analyst agent node, over: ${edge.over.join(", ")}) will arrive as finding events.` : `Findings from analyst '${edge.analyst}' (over: ${edge.over.join(", ")}) will arrive as finding events.\n${registry.resolve(edge.directive).text}`);
-	const continuityByProfile = {};
-	for (const [nodeId, edge] of delegatesByWorker) if (edge.continuity !== void 0) continuityByProfile[nodeId] = edge.continuity;
-	const graphBrief = [
-		"AGENT GRAPH: you are the driver node of a fixed topology. You may spawn ONLY these worker",
-		"nodes, by EXACT name (spawn_agent with profile: { name: '<node id>' }; the node's full",
-		"profile is pinned by the graph — any other profile fields you author are ignored):",
-		...[...workers.values()].map((node) => {
-			const edge = delegatesByWorker.get(node.id);
-			const cap = edge.maxTraversals ?? 32;
-			const description = typeof node.profile.description === "string" && node.profile.description.length > 0 ? ` — ${node.profile.description}` : "";
-			const continuityNote = edge.continuity === "resume" ? "; continuity: resume — each spawn after the first re-attaches to this node's latest settled session (spawn again to continue it; steer while it is live)" : "";
-			return `- '${node.id}'${description} (delegation cap: ${cap} traversals${continuityNote})`;
-		}),
-		...driverAnalyzesBriefs.length > 0 ? ["", ...driverAnalyzesBriefs] : []
-	].join("\n");
-	const rootProfile = {
-		...root.profile,
-		prompt: {
-			...root.profile.prompt ?? {},
-			instructions: [...root.profile.prompt?.instructions ?? [], graphBrief]
-		}
-	};
-	const strippedByDigest = /* @__PURE__ */ new Map();
-	const authorizeMessage = opts.authorizeMessage ? (input) => {
-		const decision = opts.authorizeMessage(input);
-		if (decision.instruction !== input.instruction) strippedByDigest.set(canonicalCandidateDigest(decision.instruction), { composedBytes: byteLength(input.instruction) });
-		return decision;
-	} : void 0;
-	const routedAnalyzesByAnalyst = /* @__PURE__ */ new Map();
-	const driverAnalyzesByAnalyst = /* @__PURE__ */ new Map();
-	for (const edge of analyzes) (edge.to === root.id ? driverAnalyzesByAnalyst : routedAnalyzesByAnalyst).set(edge.analyst, edge);
-	const analyzesCapReached = (edge) => {
-		const cap = edge.maxTraversals ?? 32;
-		if ((traversalCounts.get(edgeId(edge)) ?? 0) < cap) return false;
-		exhausted.add(edgeId(edge));
-		return true;
-	};
-	const ledgerAnalyzes = (edge, outcome, bytes, reason, workerId) => {
-		const capped = analyzesCapReached(edge);
-		record({
-			edge: edgeId(edge),
-			kind: "analyzes",
-			from: edge.over.join("+"),
-			to: edge.to,
-			directive: formatPromptHandle(edge.directive),
-			outcome: capped ? "unpropagated" : outcome,
-			continuity: "steer",
-			bytes,
-			...capped ? { reason: `traversal-cap-exhausted (max ${edge.maxTraversals ?? 32})` } : reason !== void 0 ? { reason } : {},
-			...workerId !== void 0 ? { workerId } : {}
-		}, true);
-	};
-	const onCoordinationEvent = async (_context, _eventId, recordEnvelope) => {
-		const event = recordEnvelope.event;
-		if (event.type === "finding") {
-			const edge = driverAnalyzesByAnalyst.get(event.finding.analyst);
-			if (!edge) return;
-			const sourceNode = nodeByWorkerId.get(event.finding.fromWorker);
-			if (sourceNode === void 0 || !edge.over.includes(sourceNode)) return;
-			const findingsText = event.finding.findings === void 0 ? "" : stringifyPayload(event.finding.findings);
-			const directiveBytes = byteLength(registry.resolve(edge.directive).text);
-			const empty = findingsText.length === 0;
-			ledgerAnalyzes(edge, empty ? "empty" : "delivered", directiveBytes + byteLength(findingsText), empty ? "analyst returned no findings" : void 0, event.finding.fromWorker);
-			return;
-		}
-		if (event.type === "steer") {
-			const down = event.down;
-			if (event.analyst !== void 0) {
-				const edge = routedAnalyzesByAnalyst.get(event.analyst);
-				if (!edge) return;
-				ledgerAnalyzes(edge, down.delivered ? "delivered" : "unpropagated", byteLength(down.instruction), down.delivered ? void 0 : down.outcome, down.toWorker);
-				return;
-			}
-			const nodeId = nodeByWorkerId.get(down.toWorker);
-			if (nodeId === void 0) return;
-			const edge = delegatesByWorker.get(nodeId);
-			if (!edge) return;
-			const stripped = strippedByDigest.get(down.instructionDigest);
-			record({
-				edge: edgeId(edge),
-				kind: "delegates",
-				from: edge.from,
-				to: edge.to,
-				directive: formatPromptHandle(edge.directive),
-				outcome: !down.delivered ? "unpropagated" : stripped ? "stripped" : "delivered",
-				continuity: "steer",
-				bytes: byteLength(down.instruction),
-				...!down.delivered ? { reason: down.outcome } : stripped ? { reason: `authorization narrowed ${stripped.composedBytes} composed bytes` } : {},
-				workerId: down.toWorker
-			}, true);
-		}
-	};
-	const hooks = composeRuntimeHooks({ onEvent: (event) => {
-		if (event.target !== "agent.spawn" || event.phase !== "after") return;
-		const payload = event.payload;
-		if (typeof payload?.childId !== "string" || typeof payload.assignmentId !== "string") return;
-		const pending = pendingByAssignment.get(payload.assignmentId);
-		if (!pending) return;
-		pendingByAssignment.delete(payload.assignmentId);
-		const bound = {
-			...pending,
-			workerId: payload.childId
-		};
-		ledger[ledger.indexOf(pending)] = bound;
-		nodeByWorkerId.set(payload.childId, bound.to);
-		return appendJournal(bound, payload.childId);
-	} }, opts.hooks);
-	const start = async () => {
-		const result = await supervise(rootProfile, graphTask(graph, root), {
-			budget: graph.budget,
-			deliverable: graph.deliverable,
-			makeWorkerAgent: graphWorker,
-			journal,
-			blobs,
-			runId,
-			hooks,
-			onCoordinationEvent,
-			...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 } : {},
-			...opts.perWorker ? { perWorker: opts.perWorker } : {},
-			...opts.maxTurns !== void 0 ? { maxTurns: opts.maxTurns } : {},
-			...opts.maxLiveWorkers !== void 0 ? { maxLiveWorkers: opts.maxLiveWorkers } : {},
-			...opts.signal ? { signal: opts.signal } : {},
-			...opts.now ? { now: opts.now } : {},
-			...opts.otel ? { otel: opts.otel } : {},
-			...opts.stallAfterMs !== void 0 ? { stallAfterMs: opts.stallAfterMs } : {},
-			...opts.allowedModels ? { allowedModels: opts.allowedModels } : {}
-		});
-		for (const pending of pendingByAssignment.values()) {
-			const refused = {
-				...pending,
-				outcome: "unpropagated",
-				bytes: 0,
-				reason: `no-live-worker-bound (spawn refused after the factory, or a keyed re-spawn deduplicated to a completed result; ${pending.bytes} composed bytes never crossed)`
-			};
-			ledger[ledger.indexOf(pending)] = refused;
-			await appendJournal(refused, `graph:${refused.to}`);
-		}
-		pendingByAssignment.clear();
-		await Promise.all(journalWrites);
-		const exhaustedEdges = Object.freeze([...exhausted]);
-		const frozenLedger = Object.freeze(ledger.map((row) => Object.freeze({ ...row })));
-		const lifecycleEnded = result.kind === "no-winner" && (result.reason === "aborted" || result.reason === "budget-exhausted");
-		if (result.kind !== "winner" && !lifecycleEnded && exhaustedDelegates.size > 0) throw new GraphEdgeCapError(Object.freeze([...exhaustedDelegates]), frozenLedger, result);
-		return {
-			result,
-			ledger: frozenLedger,
-			exhaustedEdges,
-			runId
-		};
-	};
-	return start();
-}
-/** The root task: the graph's own framing. The deliverable (mandatory) is the termination; the
-*  task names what the topology exists to produce. */
-function graphTask(graph, root) {
-	return graph.deliverable.describe ?? `Deliver the graph's deliverable by driving your worker nodes (root: '${root.id}').`;
-}
-//#endregion
 //#region src/runtime/supervise/patch-checks.ts
 const DEFAULT_MAX_DIFF_LINES = 400;
 /**
@@ -5810,7 +4927,6 @@ function worktreeFanout(options) {
 			return gateOnDeliverable(createWorktreeCliExecutor({
 				repoRoot: options.repoRoot,
 				profile: item.profile,
-				harness: item.harness,
 				taskPrompt: options.taskPrompt,
 				executionAttemptId: ctx.node.attemptId,
 				...item.budgetExempt !== void 0 ? { budgetExempt: item.budgetExempt } : {},
@@ -5983,7 +5099,7 @@ function surfaceWorkerExecutor(surface, task, worker, strategy) {
 			const guidance = typeof brief === "string" ? brief.trim() : brief ? JSON.stringify(brief) : "";
 			const attemptTask = guidance ? {
 				...task,
-				systemPrompt: `${task.systemPrompt ?? ""}\n\n— Supervisor guidance for THIS attempt (incorporate it; do not just repeat a prior approach) —\n${guidance}`
+				userPrompt: `${task.userPrompt}\n\n— Supervisor guidance for THIS attempt (incorporate it; do not just repeat a prior approach) —\n${guidance}`
 			} : task;
 			const r = await runAgentic({
 				surface: traced.surface,
@@ -5992,8 +5108,8 @@ function surfaceWorkerExecutor(surface, task, worker, strategy) {
 				budget: worker.budget ?? 1,
 				routerBaseUrl: worker.routerBaseUrl,
 				routerKey: worker.routerKey,
-				model: worker.model,
-				...worker.maxTokens !== void 0 ? { maxTokens: worker.maxTokens } : {},
+				workerProfile: worker.profile,
+				...worker.analystProfile ? { analystProfile: worker.analystProfile } : {},
 				...worker.innerTurns !== void 0 ? { innerTurns: worker.innerTurns } : {}
 			});
 			const out = {
@@ -6006,7 +5122,9 @@ function surfaceWorkerExecutor(surface, task, worker, strategy) {
 			const spent = {
 				iterations: r.completions,
 				tokens: r.tokens,
+				...r.tokensKnown ? {} : { tokensKnown: false },
 				usd: r.usd,
+				...r.usdKnown ? {} : { usdKnown: false },
 				ms: r.ms
 			};
 			artifact = {
@@ -6036,13 +5154,13 @@ async function superviseSurface(profile, task, opts) {
 	const innerTurns = opts.worker.innerTurns ?? 6;
 	const router = opts.router ?? {
 		routerBaseUrl: opts.worker.routerBaseUrl,
-		routerKey: opts.worker.routerKey,
-		model: opts.worker.model
+		routerKey: opts.worker.routerKey
 	};
 	const budget = opts.budget ?? {
 		maxIterations: (innerTurns + 2) * 5 + 16,
-		maxTokens: (opts.worker.maxTokens ?? 4e3) * 8
+		maxTokens: 1e9
 	};
+	const workerMaxTokens = profileMaxTokens(opts.worker.profile) ?? Math.max(1, Math.floor(budget.maxTokens / 8));
 	const makeWorkerAgent = (rawProfile) => {
 		const p = rawProfile ?? {};
 		return {
@@ -6067,7 +5185,7 @@ async function superviseSurface(profile, task, opts) {
 		maxLiveWorkers: opts.maxLiveWorkers ?? 1,
 		perWorker: {
 			maxIterations: innerTurns + 2,
-			maxTokens: opts.worker.maxTokens ?? 4e3
+			maxTokens: workerMaxTokens
 		},
 		router,
 		...analysts ? {
@@ -6087,6 +5205,12 @@ async function superviseSurface(profile, task, opts) {
 		completions: sp.iterations
 	};
 }
+function profileMaxTokens(profile) {
+	const value = profile.model?.metadata?.maxTokens;
+	if (value === void 0) return void 0;
+	if (!Number.isSafeInteger(value) || value < 1) throw new Error("superviseSurface: AgentProfile.model.metadata.maxTokens must be a positive safe integer");
+	return value;
+}
 //#endregion
 //#region src/runtime/verifier-environment.ts
 const submitTool = {
@@ -6501,6 +5625,6 @@ function tail(s) {
 	return s.slice(-400);
 }
 //#endregion
-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 };
+export { pipeline as $, assertStrategyContract as A, createMcpEnvironment as At, trajectoryReport as B, chatTransportExecutor as C, renderLeaderboardSvg as Ct, pickChampion as D, McpSpawnFault as Dt, discriminatingMeans as E, defaultAuditorInstruction as Et, openSandboxRun as F, resolveSecretEnv as Ft, registerShape as G, runPersonified as H, printBenchmarkReport as I, secretEnvOfMcpServer as It, renderCorpusToInstructions as J, FileCorpus as K, runBenchmark as L, strategyAuthorContract as M, envKeyProvider as Mt, strategyAuthorSystemPrompt as N, mcpSecretEnvMetadataKey as Nt, runStrategyEvolution as O, connectStdioMcp as Ot, SandboxRunAbortError as P, resolveMcpServerLaunch as Pt, panel as Q, promotionGate as R, runCoderChecks as S, renderLeaderboardMarkdown as St, createChatSessionStore as T, auditIntent as Tt, builtinShapes as U, definePersona as V, createShapeRegistry as W, flatWidenGate as X, fanout as Y, loopUntil as Z, settledWorkerOut as _, sentinelCompletion as _t, localShell as a, createScopeAnalyst as at, analyzeTrace as b, pairwiseSignificance as bt, createVerifierEnvironment as c, harvestCorpus as ct, worktreeFanout as d, localSandboxClient as dt, selectValidWinner as et, EVIDENCE_MAX_CHARS as f, inlineSandboxClient as ft, composeWorkerEvidence as g, deterministicCompletion as gt, closingWorkerNote as h, completionAuthorizes as ht, jjWorkspace as i, buildSteerContext as it, authorStrategy as j, sanitizeMcpToolSchema as jt, selectChampion as k, materializeLocalMcp as kt, failuresAnalyst as l, defineLeaderboard as lt, VERIFY_TAIL_CHARS as m, loopDispatch as mt, makeFinding$1 as n, widen as nt, runInWorkspace as o, registryScopeAnalyst as ot, NOTE_MAX_CHARS as p, loopCampaignDispatch as pt, InMemoryCorpus as q, gitWorkspace as r, assertTraceDerivedFindings as rt, createWaterfallCollector as s, inProcessSandboxClient as st, computeFindingId$1 as t, verify as tt, superviseSurface as u, resolveSandboxClient as ut, copyUntrackedIntoClone as v, stopSentinel as vt, chatWorkerSeam as w, renderPairwiseMarkdown as wt, patchDelivered as x, renderLeaderboardHtml as xt, withUntrackedArtifacts as y, leaderboard as yt, equalKOnCost as z };
 
-//# sourceMappingURL=runtime-5uDVVfER.js.map
+//# sourceMappingURL=runtime-hiAABiTk.js.map