@tangle-network/agent-runtime 0.128.0 → 0.131.1

package/dist/{structural-rollout-zY0oqQzO.js → structural-rollout-3uxVGcg2.js}

@@ -1,14 +1,17 @@
-import { i as InMemorySpawnJournal, r as InMemoryResultBlobStore } from "./spawn-journal-DsZKDqeh.js";
-import { l as withDriverExecutor, n as createSupervisor, vt as routerToolLoop } from "./supervisor-DpjO0Gmy.js";
-import { createChatClient, estimateCost, isModelPriced, makeProposalFinding } from "@tangle-network/agent-eval";
+import { n as streamAgentTurn, t as collectAgentTurn } from "./stream-agent-turn-rYgaOLO0.js";
+import { i as InMemorySpawnJournal, r as InMemoryResultBlobStore } from "./spawn-journal-saHQzqYi.js";
+import { i as concreteModelId, s as profileModelExecutionSettings, t as assertExecutableAgentProfile } from "./model-policy-CqziaqS1.js";
+import { v as executableAgentProfileSnapshot } from "./materialization-COJ1UYQ-.js";
+import { N as createExecutor, j as captureReusableExecutorConfig, l as withDriverExecutor, n as createSupervisor } from "./supervisor-CV6Jh28D.js";
+import { costForTokenPricing, makeProposalFinding } from "@tangle-network/agent-eval";
+import { agentProfileSchema, canonicalAgentProfileDigest, canonicalCandidateDigest } from "@tangle-network/agent-interface";
 import { randomBytes } from "node:crypto";
 import { assertProposalFindings } from "@tangle-network/agent-eval/analyst";
 //#region src/improvement/optimizer-prompt.ts
 /**
 * The senior scientific-method optimizer doctrine — the ONE substantial prompt
 * core shared by every builder/author surface (tool build, MCP build, codebase
-* improvement, strategy authoring) and by the driver that steers build workers
-* (`driverLoopGenerator`).
+* improvement, and strategy authoring).
 *
 * Seeded from the proven senior prompts rather than invented: GEPA's
 * `REFLECTION_SYSTEM` (localize → diagnose → minimal generalizable fix →
@@ -58,69 +61,6 @@ const optimizerMethod = [
 	"   what you would try next if the measured lift comes back null."
 ].join("\n");
 /**
-* The driver's stance for `driverLoopGenerator` — the build-domain instance of
-* the supervisor doctrine (observe → rate → decide; refine / re-scope /
-* decompose; the check decides delivery, never the driver's prose).
-*/
-const buildDriverSystem = [
-	"You are the DRIVER of a build loop: a senior engineering lead steering a coding WORKER inside",
-	"an isolated git worktree toward a verified artifact. You never edit files yourself — your only",
-	"levers are the tools below. Your intelligence goes into three places: how you AUTHOR each",
-	"worker instruction, how you OBSERVE and RATE what a session actually produced, and what you",
-	"DECIDE next.",
-	"",
-	"TOOLS",
-	"- run_worker{instruction}: one full coding-harness session in the worktree, with your",
-	"  instruction as its entire goal. Sessions are expensive and capped — author each one well.",
-	"  The worktree PERSISTS between sessions: a later worker resumes on top of earlier edits.",
-	"- inspect_worktree{}: current git status + diff — what has actually changed so far.",
-	"- read_file{path,maxBytes?}: read one file from the worktree (new untracked files do not show",
-	"  in the diff — read them to rate the work).",
-	"- run_verifier{}: the intrinsic check of the surface (compile+tests for a tool, boot-and-probe",
-	"  for an MCP server). Its exit decides what counts as delivered — your opinion does not.",
-	"",
-	"AUTHOR RICHLY. A worker handed a one-line label will flail. Each instruction must carry: the",
-	"outcome in concrete terms; the hypothesis and sub-goal it serves; what already exists in the",
-	"tree that it must build on, not duplicate; where the deliverable must land; and the exact check",
-	"it will be held to. The worker sees NOTHING you were given (no findings, no method, no prior",
-	"session context) unless you fold it into the instruction.",
-	"",
-	"THE LOOP — every turn: observe, rate, decide.",
-	"- OBSERVE: after each session, inspect the worktree and run the verifier. Read WHAT failed and",
-	"  WHY — \"it failed\" alone tells you nothing.",
-	"- RATE: judge with a reason. Verified and complete → stop. Close, one correctable fault →",
-	"  REFINE: author \"continue from the current tree; the check fails because X; fix X\" (depth,",
-	"  not a fresh start — never let a worker revert its own near-miss). Empty tree, or it solved a",
-	"  different problem → RE-SCOPE: re-author narrower and more concrete; a second identical",
-	"  instruction fails identically. Too big for one session → DECOMPOSE: author the first",
-	"  self-contained slice, verify it, then author the next on top.",
-	"- DECIDE: exactly one move per turn, with the reason stated in one line.",
-	"",
-	"STOP when the verifier passes — reply with no tool call and a short reflection: what you",
-	"predicted, what the verifier showed, what you would try next if the measured lift comes back",
-	"null. If the session budget runs out first, say plainly what remains and why. An honest",
-	"no-winner is a real result; a claimed success is not — the final keep/discard decision is made",
-	"by code from the verifier exit and the tree state, never from your words."
-].join("\n");
-/**
-* The driver's ADOPT-not-build doctrine, appended to `buildDriverSystem` when
-* a `research` tool is wired into the loop (`DriverLoopGeneratorOptions.
-* research`). Kept separate so a driver WITHOUT the tool is never told to
-* call a tool it does not have.
-*/
-const researchDriverNote = [
-	"RESEARCH — ADOPT BEFORE BUILD. A research{query} tool is provisioned for this run. Before",
-	"authoring a from-scratch build, spend one turn researching whether an EXISTING external MCP",
-	"server already provides the missing capability — registries and vendor docs list maintained",
-	"servers for most common gaps (web search, fetch, GitHub, filesystems, databases).",
-	"- If a maintained server fits, ADOPT it: report in your final reflection its endpoint or",
-	"  launch command and the API key it needs BY NAME (e.g. EXA_API_KEY) — never a key value —",
-	"  so the dispatch can emit a connection candidate with provisioned secrets. Adopting a fit",
-	"  server beats rebuilding it: less code to verify, maintained upstream, same measured gate.",
-	"- If nothing fits (unmaintained, wrong tool surface, heavier than the gap), build — and state",
-	"  in one line why adoption lost."
-].join("\n");
-/**
 * The senior authoring process for `authorStrategy` — the same method, shaped
 * to the strategy contract (author-blind, conserved budget, one module out).
 */
@@ -143,6 +83,285 @@ const strategyAuthorMethod = [
 	"   comment at the top of the module — the holdout verdict will be read against it."
 ].join("\n");
 //#endregion
+//#region src/runtime/profile-chat-client.ts
+/** Profile-exact adapter for packages that consume agent-eval's ChatClient contract.
+* Every call still enters Runtime through createExecutor -> streamAgentTurn, and every
+* behavioral field is checked against the exact AgentProfile before any transport runs. */
+function profileChatClient(args) {
+	const binding = bindProfileChat(args);
+	return {
+		transport: "custom",
+		defaultModel: binding.model,
+		...binding.settings.retry?.maxAttempts !== void 0 ? { maximumAttempts: binding.settings.retry.maxAttempts } : {},
+		async chat(req, callOpts) {
+			const run = await runBoundProfileChat(binding, req, callOpts);
+			if (!run.succeeded) throw new Error(run.error);
+			return run.response;
+		}
+	};
+}
+/** Profile-exact adapter for agent-eval's external optimizer callback.
+* Eval validates and freezes the provider-neutral request; Runtime owns the exact
+* AgentProfile, execution route, retries, usage, and finite execution evidence. */
+function profileOptimizerModelCall(args) {
+	const binding = bindProfileChat(args);
+	const profileDigest = canonicalAgentProfileDigest(binding.profile);
+	return async (request) => {
+		const requestDigest = canonicalCandidateDigest({
+			callId: request.callId,
+			request: request.request,
+			endpointFormat: request.endpointFormat ?? null
+		});
+		let run;
+		try {
+			run = await runBoundProfileChat(binding, structuredClone(request.request), {
+				signal: request.signal,
+				idempotencyKey: request.callId,
+				correlationId: request.callId
+			});
+		} catch (error) {
+			return {
+				succeeded: false,
+				error: errorMessage(error),
+				receipt: unknownOptimizerReceipt(binding.model),
+				execution: {
+					kind: "agent-runtime-profile-model-call",
+					profileDigest,
+					requestDigest,
+					callId: request.callId,
+					endpointFormat: request.endpointFormat ?? null,
+					executed: false,
+					error: errorMessage(error)
+				}
+			};
+		}
+		const execution = optimizerExecution(profileDigest, requestDigest, request, run);
+		try {
+			const receipt = optimizerReceipt(binding.model, run, args.pricing);
+			return run.succeeded ? {
+				succeeded: true,
+				response: {
+					...run.response,
+					costUsd: optimizerResponseCostUsd(receipt)
+				},
+				receipt,
+				execution
+			} : {
+				succeeded: false,
+				error: run.error,
+				receipt,
+				execution
+			};
+		} catch (error) {
+			const message = `profile optimizer receipt normalization failed after execution: ${errorMessage(error)}`;
+			return {
+				succeeded: false,
+				error: message,
+				receipt: rawOptimizerReceipt(binding.model, run, args.pricing),
+				execution: {
+					...execution,
+					succeeded: false,
+					postCallError: message
+				}
+			};
+		}
+	};
+}
+function bindProfileChat(args) {
+	const profile = executableAgentProfileSnapshot(args.profile, args.context);
+	const model = concreteModelId(profile.model?.default);
+	if (!model) throw new Error(`${args.context}: AgentProfile.model.default must be concrete`);
+	return {
+		profile,
+		executor: captureReusableExecutorConfig(args.executor, args.context),
+		context: args.context,
+		model,
+		settings: profileModelExecutionSettings(profile, args.context)
+	};
+}
+async function runBoundProfileChat(binding, req, callOpts) {
+	assertProfileChatRequest(req, binding.model, binding.profile.model?.reasoningEffort, binding.settings, binding.context);
+	assertSupportedChatCallOptions(callOpts, binding.context);
+	const turnProfile = responseProfile(binding.profile, req, binding.context);
+	const startedAt = performance.now();
+	const turn = await collectAgentTurn(streamAgentTurn({
+		kind: "executor",
+		profile: turnProfile,
+		factory: createExecutor(binding.executor)
+	}, { messages: req.messages }, {
+		...req.timeoutMs !== void 0 ? { timeoutMs: req.timeoutMs } : {},
+		...callOpts?.signal ? { signal: callOpts.signal } : {},
+		...callOpts?.idempotencyKey ? { callId: callOpts.idempotencyKey } : {},
+		...callOpts?.correlationId ? { correlationId: callOpts.correlationId } : {}
+	}));
+	if (turn.status !== "completed") return {
+		succeeded: false,
+		error: `${binding.context} failed: ${turn.error?.message ?? turn.status}`,
+		turn
+	};
+	const observedModel = turn.usage.model;
+	if (observedModel === void 0) return {
+		succeeded: false,
+		error: `${binding.context}: Runtime turn did not report the model actually used; refusing to label the response with the requested model`,
+		turn
+	};
+	if (observedModel !== binding.model) return {
+		succeeded: false,
+		error: `${binding.context}: Runtime reported model ${JSON.stringify(observedModel)} but AgentProfile requires ${JSON.stringify(binding.model)}`,
+		turn
+	};
+	const resultOut = turn.output;
+	const promptTokens = turn.usage.input;
+	const completionTokens = turn.usage.output;
+	return {
+		succeeded: true,
+		turn,
+		response: {
+			content: turn.finalText,
+			usage: {
+				promptTokens,
+				completionTokens,
+				totalTokens: promptTokens + completionTokens,
+				...turn.usage.tokensKnown === false ? { captured: false } : {},
+				...typeof turn.usage.promptCache?.readTokens === "number" ? { cachedPromptTokens: turn.usage.promptCache.readTokens } : {},
+				...turn.usage.reasoningTokens !== void 0 ? { reasoningTokens: turn.usage.reasoningTokens } : {}
+			},
+			costUsd: turn.usage.usdKnown === false || turn.usage.costUsd === void 0 ? null : turn.usage.costUsd,
+			model: observedModel,
+			durationMs: terminalDurationMs(turn.events, performance.now() - startedAt),
+			finishReason: resultOut?.finishReason ?? null,
+			contentEmpty: turn.finalText.trim().length === 0,
+			raw: {
+				...turn.usage.estimatedCostUsd !== void 0 ? { estimatedCostUsd: turn.usage.estimatedCostUsd } : {},
+				...turn.usage.promptCache ? { promptCache: turn.usage.promptCache } : {},
+				...turn.transportAttempts !== void 0 ? { transportAttempts: turn.transportAttempts } : {}
+			}
+		}
+	};
+}
+/** @internal Exported for the adapter's fail-honest duration contract test. */
+function terminalDurationMs(events, measuredWallMs) {
+	const final = events.at(-1)?.metadata?.timing;
+	if (final && typeof final === "object") {
+		const duration = final.durationMs;
+		if (typeof duration === "number" && Number.isFinite(duration) && duration >= 0) return duration;
+	}
+	if (Number.isFinite(measuredWallMs) && measuredWallMs >= 0) return measuredWallMs;
+	throw new Error("profileChatClient: measured wall duration must be a finite non-negative number");
+}
+function assertSupportedChatCallOptions(opts, context) {
+	if (opts?.maxCostUsd !== void 0) throw new Error(`${context}: maxCostUsd is not enforced by Runtime's exact turn path; refusing to treat it as a limit`);
+}
+function responseProfile(profile, req, context) {
+	const responseFormat = req.jsonSchema ? {
+		type: "json_schema",
+		json_schema: req.jsonSchema
+	} : req.jsonMode ? { type: "json_object" } : void 0;
+	if (!responseFormat) return profile;
+	const existing = profile.model?.metadata?.extraBody;
+	if (existing !== void 0 && (typeof existing !== "object" || existing === null || Array.isArray(existing))) throw new Error(`${context}: AgentProfile.model.metadata.extraBody must be an object`);
+	const existingFormat = existing?.response_format;
+	if (existingFormat !== void 0 && JSON.stringify(existingFormat) !== JSON.stringify(responseFormat)) throw new Error(`${context}: requested response format conflicts with AgentProfile`);
+	return agentProfileSchema.parse({
+		...profile,
+		model: {
+			...profile.model,
+			metadata: {
+				...profile.model?.metadata ?? {},
+				extraBody: {
+					...existing,
+					response_format: responseFormat
+				}
+			}
+		}
+	});
+}
+function assertProfileChatRequest(req, model, reasoningEffort, settings, context) {
+	if (req.model !== void 0 && req.model !== model) throw new Error(`${context}: request model ${JSON.stringify(req.model)} conflicts with AgentProfile model ${JSON.stringify(model)}`);
+	if (req.temperature !== void 0 && req.temperature !== settings.temperature) throw new Error(`${context}: request temperature conflicts with AgentProfile model metadata`);
+	if (req.maxTokens !== void 0 && req.maxTokens !== settings.maxTokens) throw new Error(`${context}: request maxTokens conflicts with AgentProfile model metadata`);
+	if (req.thinking !== void 0) {
+		const expected = reasoningEffort === void 0 ? void 0 : reasoningEffort === "none" ? "disabled" : "enabled";
+		if (req.thinking !== expected) throw new Error(`${context}: request thinking conflicts with AgentProfile.model.reasoningEffort`);
+	}
+}
+function optimizerReceipt(model, run, pricing) {
+	const usage = run.turn.usage;
+	const actualCostUsd = usage.usdKnown === false ? void 0 : usage.costUsd;
+	if (usage.tokensKnown === false) return {
+		model,
+		inputTokens: 0,
+		outputTokens: 0,
+		usageUnknown: true,
+		...actualCostUsd !== void 0 ? { actualCostUsd } : usage.estimatedCostUsd !== void 0 ? { estimatedCostUsd: usage.estimatedCostUsd } : { costUnknown: true }
+	};
+	const cachedTokens = optimizerTokenCount(usage.promptCache?.readTokens, "cache read tokens");
+	const cacheWriteTokens = optimizerTokenCount(usage.promptCache?.writeTokens, "cache write tokens");
+	const classified = (cachedTokens ?? 0) + (cacheWriteTokens ?? 0);
+	if (classified > usage.input) throw new Error("profile optimizer cache classes exceed total input tokens");
+	return {
+		model,
+		inputTokens: usage.input - classified,
+		outputTokens: usage.output,
+		...cachedTokens !== void 0 ? { cachedTokens } : {},
+		...cacheWriteTokens !== void 0 ? { cacheWriteTokens } : {},
+		...usage.reasoningTokens !== void 0 ? { reasoningTokens: usage.reasoningTokens } : {},
+		...actualCostUsd !== void 0 ? { actualCostUsd } : usage.estimatedCostUsd !== void 0 ? { estimatedCostUsd: usage.estimatedCostUsd } : pricing ? { customTokenPricing: pricing } : { costUnknown: true }
+	};
+}
+/** Preserve the observed call totals when finer receipt classification is inconsistent. */
+function rawOptimizerReceipt(model, run, pricing) {
+	const usage = run.turn.usage;
+	const tokensKnown = usage.tokensKnown !== false;
+	const actualCostUsd = usage.usdKnown === false ? void 0 : usage.costUsd;
+	return {
+		model,
+		inputTokens: tokensKnown ? usage.input : 0,
+		outputTokens: tokensKnown ? usage.output : 0,
+		...tokensKnown ? {} : { usageUnknown: true },
+		...usage.reasoningTokens !== void 0 ? { reasoningTokens: usage.reasoningTokens } : {},
+		...actualCostUsd !== void 0 ? { actualCostUsd } : usage.estimatedCostUsd !== void 0 ? { estimatedCostUsd: usage.estimatedCostUsd } : pricing ? { customTokenPricing: pricing } : { costUnknown: true }
+	};
+}
+function optimizerExecution(profileDigest, requestDigest, request, run) {
+	return {
+		kind: "agent-runtime-profile-model-call",
+		profileDigest,
+		requestDigest,
+		callId: request.callId,
+		endpointFormat: request.endpointFormat ?? null,
+		executed: true,
+		succeeded: run.succeeded,
+		status: run.turn.status,
+		model: run.turn.usage.model ?? null,
+		transportAttempts: run.turn.transportAttempts ?? null,
+		eventTypes: run.turn.events.map((event) => event.type)
+	};
+}
+function unknownOptimizerReceipt(model) {
+	return {
+		model,
+		inputTokens: 0,
+		outputTokens: 0,
+		usageUnknown: true,
+		costUnknown: true
+	};
+}
+function optimizerResponseCostUsd(receipt) {
+	if (receipt.actualCostUsd !== void 0) return receipt.actualCostUsd;
+	if (receipt.estimatedCostUsd !== void 0) return receipt.estimatedCostUsd;
+	if (receipt.customTokenPricing !== void 0 && receipt.usageUnknown !== true) return costForTokenPricing(receipt.customTokenPricing, receipt);
+	return null;
+}
+function optimizerTokenCount(value, label) {
+	if (value === void 0) return void 0;
+	if (!Number.isSafeInteger(value) || value < 0) throw new Error(`profile optimizer ${label} must be a non-negative integer`);
+	return value;
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
 //#region src/runtime/observe.ts
 /**
 * The third-person observer — the connective tissue that closes the loop.
@@ -241,17 +460,18 @@ const findingsSchema = {
 /** The third-person trace analyst: read a worker's trace and produce steer findings for the next attempt plus durable `learned` facts for the cross-run corpus. */
 async function observe(input, opts) {
 	const traceSummary = summarizeTrace(input.trace, opts.maxTraceLines ?? 80);
-	const parsed = parseFindings((await opts.chat.chat({
-		...opts.model ? { model: opts.model } : {},
+	const res = await profileChatClient({
+		profile: opts.profile,
+		executor: opts.executor,
+		context: "observe analyst"
+	}).chat({
 		jsonSchema: findingsSchema,
 		messages: [{
-			role: "system",
-			content: opts.analystInstruction ?? "You are a third-person OBSERVER watching an AI agent work. You see its TRACE (what it did), not its grader. From the trace, name SPECIFIC, behavior-grounded findings: wasted/duplicated tool calls, thrash/retries, token/cost waste, missing verification, failure patterns. For each, a concrete recommended_action, and whether the AGENT (fix its skills/prompt/tools) or the OPERATOR (fix framing/decomposition/config) should act. Only claim what the trace shows. No findings if the run was clean."
-		}, {
 			role: "user",
 			content: `TASK: ${input.task}\n\nOUTCOME: ${input.outcome ?? "unknown"}\n\nFINAL OUTPUT (truncated):\n${input.output.slice(0, 1200)}\n\nTRACE (in order; "xN" = repeated):\n${traceSummary}`
 		}]
-	}, { ...opts.signal ? { signal: opts.signal } : {} })).content);
+	}, { ...opts.signal ? { signal: opts.signal } : {} });
+	const parsed = parseFindings(res.content);
 	const producedAt = input.runId ? `${input.runId}` : observerId;
 	const findings = assertProposalFindings(parsed.map((f) => makeProposalFinding({
 		analyst_id: observerId,
@@ -285,10 +505,18 @@ async function observe(input, opts) {
 		};
 		if ((await opts.corpus.append(record)).succeeded) learned.push(record);
 	}
+	const usage = res.usage;
+	const inputTokens = usage?.promptTokens;
+	const outputTokens = usage?.completionTokens;
 	return {
 		findings: [...findings],
 		learned,
-		report: renderReport(findings)
+		report: renderReport(findings),
+		usage: {
+			input: inputTokens ?? 0,
+			output: outputTokens ?? 0,
+			known: usage?.captured !== false && typeof inputTokens === "number" && typeof outputTokens === "number"
+		}
 	};
 }
 function parseFindings(content) {
@@ -314,32 +542,35 @@ function renderReport(findings) {
 }
 //#endregion
 //#region src/runtime/strategy.ts
-/**
-* The general agentic primitive — sequential (depth) and parallel (breadth) over a shared,
-* checkable artifact, driven through the keystone Supervisor as one recursive `Agent.act`.
-*
-* The domain lives behind ONE seam — `AgenticSurface` (open an artifact, list tools, call a tool,
-* score the artifact, close it). EnterpriseOps implements it (seed a gym DB, MCP tools, SQL
-* verifier); Commit0/AppWorld/terminal-bench implement it the same way (a repo workspace, shell
-* tools, the test suite). The drivers below are domain-blind: they run over any surface.
-*
-* Two shapes, the agent's POMDP rollout as the unit:
-*  - DEPTH   one persistent artifact carried across shots. Each shot the agent works the tool loop;
-*            between shots a trace-analyst (selector≠judge: reads the trajectory, never the score)
-*            steers the resumed session toward what's unfinished. shot n stands on shot n-1's
-*            artifact state + history. This is continuation — long-horizon, same artifact.
-*  - BREADTH K independent artifacts, each a fresh rollout, the deployable verifier picks the best.
-*
-* Both are an `Agent` whose `act` spawns leaf shots through `scope.spawn` and reacts via
-* `scope.next()` — so the conserved budget pool meters them (equal-k by construction), the journal
-* records the tree, and the same primitive nests. `runAgentic` runs the chosen driver through
-* `createSupervisor().run`. The leaf (one shot over a handle) is resolved per-spawn from a
-* surface-closed registry — the open `Executor` seam, not bespoke per-benchmark glue.
-*/
 const taskNudge = "Use the available tools to bring the artifact to the required final state. Address EVERY distinct change the request implies. After each tool result, check what remains and continue. Re-read the values you set to confirm they took. Reply DONE only once every required change is made and verified.";
+function exactAgenticProfile(profile, context) {
+	const parsed = agentProfileSchema.safeParse(profile);
+	if (!parsed.success) throw new Error(`${context}: invalid AgentProfile: ${parsed.error.message}`);
+	return parsed.data;
+}
+function requiredProfileModel(profile, context) {
+	assertExecutableAgentProfile(profile, context);
+	const model = concreteModelId(profile.model?.default);
+	if (!model) throw new Error(`${context}: AgentProfile.model.default must name the exact provider model; runtime-selected and missing models are not executable`);
+	return model;
+}
+function profileSystemPrompt(profile) {
+	const sections = [profile.prompt?.systemPrompt, ...profile.prompt?.instructions ?? []].filter((value) => typeof value === "string" && value.trim().length > 0);
+	const instructions = profile.resources?.instructions;
+	if (typeof instructions === "string" && instructions.trim()) sections.push(instructions);
+	else if (instructions && typeof instructions === "object" && instructions.kind === "inline" && instructions.content.trim()) sections.push(instructions.content);
+	else if (instructions && typeof instructions === "object" && instructions.kind === "github") throw new Error("agentic profile: github resource instructions require a workspace materializer; use inline instructions for the direct Router worker");
+	return sections.join("\n\n");
+}
+function assertProfileTools(profile, tools, context) {
+	const supplied = new Set(tools.map((tool) => tool.function.name));
+	const declared = profile.tools ?? {};
+	for (const name of supplied) if (declared[name] !== true) throw new Error(`${context}: tool ${JSON.stringify(name)} is not enabled by AgentProfile.tools`);
+	for (const [name, enabled] of Object.entries(declared)) if (enabled && !supplied.has(name)) throw new Error(`${context}: AgentProfile enables tool ${JSON.stringify(name)} but the surface did not supply it`);
+}
 /** One shot: run the agent's tool loop (≤ innerTurns) over the handle, mutating the artifact via
 *  `surface.call`, carrying `messages`. Returns the updated conversation + counts. */
-async function runShot(surface, _task, handle, tools, messages, opts, modelOverride) {
+async function runShot(surface, _task, handle, tools, messages, opts, profileOverride) {
 	let toolErrors = 0;
 	const execute = async (name, args) => {
 		try {
@@ -351,23 +582,34 @@ async function runShot(surface, _task, handle, tools, messages, opts, modelOverr
 			return `ERROR: ${e instanceof Error ? e.message : String(e)}`;
 		}
 	};
-	const r = await routerToolLoop({
-		routerBaseUrl: opts.routerBaseUrl,
-		routerKey: opts.routerKey,
-		model: modelOverride ?? opts.model,
-		...opts.complete ? { complete: opts.complete } : {}
-	}, "", "", tools, execute, {
-		maxTurns: opts.innerTurns ?? 4,
-		temperature: opts.temperature ?? .7,
-		initialMessages: messages,
-		...opts.maxTokens ? { maxTokens: opts.maxTokens } : {}
-	});
+	const profile = exactAgenticProfile(profileOverride ?? opts.workerProfile, "agentic shot");
+	requiredProfileModel(profile, "agentic shot");
+	profileModelExecutionSettings(profile, "agentic shot");
+	assertProfileTools(profile, tools, "agentic shot");
+	const turn = await collectAgentTurn(streamAgentTurn({
+		kind: "executor",
+		profile,
+		factory: createExecutor({
+			backend: "router-tools",
+			routerBaseUrl: opts.routerBaseUrl,
+			routerKey: opts.routerKey,
+			tools,
+			executeToolCall: execute,
+			...opts.complete ? { complete: opts.complete } : {}
+		})
+	}, { messages }));
+	if (turn.status !== "completed") throw new Error(`agentic shot failed: ${turn.error?.message ?? turn.status}`);
+	const out = turn.output;
 	return {
-		messages: r.messages,
-		completions: r.turns,
-		toolCalls: r.toolCalls,
+		messages: out?.messages ?? messages,
+		completions: out?.turns ?? 0,
+		toolCalls: out?.toolCalls ?? 0,
 		toolErrors,
-		tokens: r.usage
+		tokens: {
+			input: turn.usage.input,
+			output: turn.usage.output
+		},
+		...turn.usage.tokensKnown === false ? { tokensKnown: false } : {}
 	};
 }
 /** The firewall's input shape: the trajectory as compacted text — calls, results,
@@ -384,41 +626,15 @@ function compactTrajectory(messages) {
 *  worker and the analyst share the one injected responder, exactly as a localhost mock would
 *  serve both). The critic speaks the OpenAI request shape; we forward it to `complete` and lift
 *  the parsed `/chat/completions` JSON back into a `ChatResponse`. */
-function analystChat(opts, defaultModel) {
-	if (!opts.complete) return createChatClient({
-		transport: "router",
-		apiKey: opts.routerKey,
-		baseUrl: opts.routerBaseUrl,
-		defaultModel
-	});
-	const complete = opts.complete;
-	return createChatClient({
-		transport: "mock",
-		defaultModel,
-		handler: async (req) => {
-			const raw = await complete({
-				model: req.model ?? defaultModel,
-				messages: req.messages,
-				...req.temperature !== void 0 ? { temperature: req.temperature } : {},
-				...req.maxTokens !== void 0 ? { max_tokens: req.maxTokens } : {}
-			});
-			const content = raw.choices?.[0]?.message?.content ?? "";
-			const promptTokens = raw.usage?.prompt_tokens ?? 0;
-			const completionTokens = raw.usage?.completion_tokens ?? 0;
-			return {
-				content,
-				usage: {
-					promptTokens,
-					completionTokens,
-					totalTokens: promptTokens + completionTokens
-				},
-				costUsd: null,
-				model: req.model ?? defaultModel,
-				durationMs: 0,
-				finishReason: raw.choices?.[0]?.finish_reason ?? null,
-				contentEmpty: content.trim().length === 0,
-				raw
-			};
+function analystChat(opts, profile) {
+	return profileChatClient({
+		profile,
+		context: "agentic analyst",
+		executor: {
+			backend: "router",
+			routerBaseUrl: opts.routerBaseUrl,
+			routerKey: opts.routerKey,
+			...opts.complete ? { complete: opts.complete } : {}
 		}
 	});
 }
@@ -429,70 +645,59 @@ function analystChat(opts, defaultModel) {
 *  trajectory in, never scores. */
 async function consultAnalyst(task, messages, instruction, opts) {
 	const trajectory = compactTrajectory(messages);
-	const analystModel = opts.analystModel ?? opts.model;
-	const chat = analystChat(opts, analystModel);
-	const consultMessages = trajectory ? [{
-		role: "system",
-		content: instruction
-	}, {
-		role: "user",
-		content: `TASK: ${task.userPrompt.slice(0, 1500)}\n\nTRAJECTORY:\n${trajectory}`
-	}] : [{
+	const analystProfile = exactAgenticProfile(opts.analystProfile ?? opts.workerProfile, "agentic analyst");
+	const analystModel = requiredProfileModel(analystProfile, "agentic analyst");
+	const chat = analystChat(opts, analystProfile);
+	const consultMessages = [{
 		role: "user",
-		content: `${instruction}\n\nTASK:\n${task.userPrompt.slice(0, 1500)}`
+		content: trajectory ? `${instruction}\n\nTASK: ${task.userPrompt.slice(0, 1500)}\n\nTRAJECTORY:\n${trajectory}` : `${instruction}\n\nTASK:\n${task.userPrompt.slice(0, 1500)}`
 	}];
 	const res = await chat.chat({
 		model: analystModel,
-		temperature: .2,
-		maxTokens: 1024,
 		messages: consultMessages
 	});
 	const usage = res.usage;
+	const input = usage?.promptTokens ?? usage?.prompt_tokens;
+	const output = usage?.completionTokens ?? usage?.completion_tokens;
+	const tokensKnown = usage?.captured !== false && typeof input === "number" && typeof output === "number";
 	return {
 		steer: res.content.trim(),
 		tokens: {
-			input: usage?.promptTokens ?? usage?.prompt_tokens ?? 0,
-			output: usage?.completionTokens ?? usage?.completion_tokens ?? 0
-		}
+			input: input ?? 0,
+			output: output ?? 0
+		},
+		...tokensKnown ? {} : { tokensKnown: false }
 	};
 }
 async function analyze(task, messages, opts) {
 	const trajectory = compactTrajectory(messages);
-	const analystModel = opts.analystModel ?? opts.model;
-	const inner = analystChat(opts, analystModel);
-	const tokens = {
-		input: 0,
-		output: 0
-	};
-	const chat = {
-		...inner,
-		chat: async (req, callOpts) => {
-			const res = await inner.chat(req, callOpts);
-			const u = res.usage;
-			if (u) {
-				tokens.input += u.promptTokens ?? u.prompt_tokens ?? 0;
-				tokens.output += u.completionTokens ?? u.completion_tokens ?? 0;
-			}
-			return res;
-		}
-	};
+	const analystProfile = exactAgenticProfile(opts.analystProfile ?? opts.workerProfile, "agentic analyst");
+	const obs = await observe({
+		task: task.userPrompt,
+		output: trajectory,
+		trace: messages,
+		outcome: "failed",
+		runId: task.id
+	}, {
+		profile: analystProfile,
+		executor: {
+			backend: "router",
+			routerBaseUrl: opts.routerBaseUrl,
+			routerKey: opts.routerKey,
+			...opts.complete ? { complete: opts.complete } : {}
+		},
+		...opts.corpus ? {
+			corpus: opts.corpus,
+			tags: opts.corpusTags ?? []
+		} : {}
+	});
 	return {
-		steer: (await observe({
-			task: task.userPrompt,
-			output: trajectory,
-			trace: messages,
-			outcome: "failed",
-			runId: task.id
-		}, {
-			chat,
-			model: analystModel,
-			...opts.analystInstruction ? { analystInstruction: opts.analystInstruction } : {},
-			...opts.corpus ? {
-				corpus: opts.corpus,
-				tags: opts.corpusTags ?? []
-			} : {}
-		})).findings.map((f) => f.recommended_action).filter((a) => typeof a === "string" && a.trim().length > 0).join("\n").trim() || "COMPLETE",
-		tokens
+		steer: obs.findings.map((f) => f.recommended_action).filter((a) => typeof a === "string" && a.trim().length > 0).join("\n").trim() || "COMPLETE",
+		tokens: {
+			input: obs.usage.input,
+			output: obs.usage.output
+		},
+		...obs.usage.known ? {} : { tokensKnown: false }
 	};
 }
 async function renderCorpusReadback(opts) {
@@ -533,22 +738,24 @@ function shotExecutor(surface, opts) {
 					const want = new Set(t.tools);
 					tools = allTools.filter((tool) => want.has(tool.function.name));
 				}
-				const messages = t.messages?.length ? [...t.messages] : [{
+				const profile = exactAgenticProfile(t.profile ?? opts.workerProfile, "agentic shot");
+				const systemPrompt = profileSystemPrompt(profile);
+				const messages = t.messages?.length ? [...t.messages] : [...systemPrompt ? [{
 					role: "system",
-					content: t.persona?.systemPrompt ?? t.task.systemPrompt
-				}, {
+					content: systemPrompt
+				}] : [], {
 					role: "user",
 					content: `${t.task.userPrompt}\n\n${taskNudge}`
 				}];
-				if (t.messages?.length && t.persona?.systemPrompt) messages.push({
+				if (t.messages?.length && t.profile && systemPrompt) messages.push({
 					role: "user",
-					content: `[hand-off] You are now acting as: ${t.persona.systemPrompt}`
+					content: `[hand-off] You are now acting as: ${systemPrompt}`
 				});
 				if (t.steer) messages.push({
 					role: "user",
 					content: t.steer
 				});
-				const shot = await runShot(surface, t.task, handle, tools, messages, opts, t.persona?.model);
+				const shot = await runShot(surface, t.task, handle, tools, messages, opts, profile);
 				const s = await surface.score(t.task, handle);
 				const score = s.total > 0 ? s.passes / s.total : 0;
 				const out = {
@@ -569,7 +776,9 @@ function shotExecutor(surface, opts) {
 					spent: {
 						iterations: shot.completions,
 						tokens: shot.tokens,
-						usd: isModelPriced(opts.model) ? estimateCost(shot.tokens.input, shot.tokens.output, opts.model) : 0,
+						...shot.tokensKnown === false ? { tokensKnown: false } : {},
+						usd: 0,
+						usdKnown: false,
 						ms: 0
 					}
 				};
@@ -591,15 +800,16 @@ function analystExecutor(opts) {
 		runtime: "agentic-analyst",
 		async execute(task) {
 			const t = task;
-			const { steer, tokens } = t.rawInstruction ? await consultAnalyst(t.task, t.messages, t.rawInstruction, opts) : await analyze(t.task, t.messages, opts);
-			const analystModel = opts.analystModel ?? opts.model;
+			const { steer, tokens, tokensKnown } = t.rawInstruction ? await consultAnalyst(t.task, t.messages, t.rawInstruction, opts) : await analyze(t.task, t.messages, opts);
 			artifact = {
 				outRef: `analyst:${steer.length}`,
 				out: steer,
 				spent: {
 					iterations: 1,
 					tokens,
-					usd: isModelPriced(analystModel) ? estimateCost(tokens.input, tokens.output, analystModel) : 0,
+					...tokensKnown === false ? { tokensKnown: false } : {},
+					usd: 0,
+					usdKnown: false,
 					ms: 0
 				}
 			};
@@ -634,13 +844,18 @@ function agenticRegistry(surface, opts) {
 		}
 	});
 }
-function leaf(name, role) {
+function leaf(name, role, profile) {
+	const exactProfile = exactAgenticProfile(profile, `agentic ${role}`);
 	return {
 		name,
 		executorSpec: {
 			profile: {
+				...exactProfile,
 				name,
-				metadata: { role }
+				metadata: {
+					...exactProfile.metadata,
+					role
+				}
 			},
 			harness: null
 		},
@@ -655,13 +870,17 @@ async function drainOne(scope) {
 	if (!s) throw new Error("agentic: spawned child never settled");
 	return s;
 }
-const perChild = (innerTurns) => ({
-	maxIterations: innerTurns + 1,
+const UNBOUNDED_TURN_RESERVATION = 1e9;
+function profileTurnLimit(profile, context) {
+	return profileModelExecutionSettings(profile, context).maxTurns ?? 0;
+}
+const perChild = (maxTurns) => ({
+	maxIterations: maxTurns === 0 ? UNBOUNDED_TURN_RESERVATION : maxTurns + 1,
 	maxTokens: 1e6
 });
 /** DEPTH: one persistent artifact, carried across analyst-steered shots. */
 function depthStrategy(surface, task, opts, cfg) {
-	const innerTurns = opts.innerTurns ?? 4;
+	const innerTurns = profileTurnLimit(opts.workerProfile, "depth worker");
 	let pendingSteer;
 	return {
 		name: "depth",
@@ -673,7 +892,7 @@ function depthStrategy(surface, task, opts, cfg) {
 			let shots = 0;
 			try {
 				for (shots = 0; shots < cfg.maxShots; shots += 1) {
-					const child = leaf(`shot:${shots}`, "shot");
+					const child = leaf(`shot:${shots}`, "shot", opts.workerProfile);
 					const memorySteer = await renderCorpusReadback(opts);
 					const steer = [shots === 0 ? void 0 : pendingSteer, memorySteer].filter((part) => typeof part === "string" && part.trim().length > 0).join("\n\n");
 					if (!scope.spawn(child, {
@@ -692,7 +911,7 @@ function depthStrategy(surface, task, opts, cfg) {
 					completions += out.completions;
 					progression.push(out.score);
 					if (out.score >= 1 || shots === cfg.maxShots - 1) break;
-					const aChild = leaf(`analyst:${shots}`, "analyst");
+					const aChild = leaf(`analyst:${shots}`, "analyst", opts.analystProfile ?? opts.workerProfile);
 					if (!scope.spawn(aChild, {
 						task,
 						messages
@@ -727,12 +946,12 @@ function depthStrategy(surface, task, opts, cfg) {
 }
 /** BREADTH: K independent rollouts (each own artifact), verifier picks the best. */
 function breadthStrategy(_surface, task, opts, cfg) {
-	const innerTurns = opts.innerTurns ?? 4;
+	const innerTurns = profileTurnLimit(opts.workerProfile, "breadth worker");
 	return {
 		name: "breadth",
 		async act(_t, scope) {
 			let opened = 0;
-			for (let k = 0; k < cfg.width; k += 1) if (scope.spawn(leaf(`rollout:${k}`, "shot"), { task }, {
+			for (let k = 0; k < cfg.width; k += 1) if (scope.spawn(leaf(`rollout:${k}`, "shot", opts.workerProfile), { task }, {
 				budget: perChild(innerTurns),
 				label: `rollout:${k}`
 			}).ok) opened += 1;
@@ -788,7 +1007,6 @@ function defineStrategy(name, run) {
 			name,
 			async act(_t, scope) {
 				let seq = 0;
-				const innerTurns = opts.innerTurns ?? 4;
 				let verifiedBest = 0;
 				let verifiedResolved = false;
 				const openHandles = /* @__PURE__ */ new Set();
@@ -811,14 +1029,16 @@ function defineStrategy(name, run) {
 					budget,
 					scope,
 					async shot(spec) {
-						const child = leaf(`shot:${seq}`, "shot");
+						const profile = spec?.profile ?? opts.workerProfile;
+						const innerTurns = profileTurnLimit(profile, "authored strategy shot");
+						const child = leaf(`shot:${seq}`, "shot", profile);
 						seq += 1;
 						if (!scope.spawn(child, {
 							task,
 							handle: spec?.handle,
 							messages: spec?.messages,
 							steer: spec?.steer,
-							persona: spec?.persona,
+							profile,
 							tools: spec?.tools
 						}, {
 							budget: perChild(innerTurns),
@@ -838,7 +1058,7 @@ function defineStrategy(name, run) {
 						}));
 					},
 					async critique(messages) {
-						const child = leaf(`analyst:${seq}`, "analyst");
+						const child = leaf(`analyst:${seq}`, "analyst", opts.analystProfile ?? opts.workerProfile);
 						seq += 1;
 						if (!scope.spawn(child, {
 							task,
@@ -853,7 +1073,7 @@ function defineStrategy(name, run) {
 						return /^\s*COMPLETE\b/i.test(findings) ? null : findings;
 					},
 					async consult(messages, instruction) {
-						const child = leaf(`analyst:${seq}`, "analyst");
+						const child = leaf(`analyst:${seq}`, "analyst", opts.analystProfile ?? opts.workerProfile);
 						seq += 1;
 						if (!scope.spawn(child, {
 							task,
@@ -1002,11 +1222,21 @@ const sampleThenRefine = defineStrategy("sampleThenRefine", async ({ surface, ta
 });
 /** Run a Strategy through the keystone Supervisor — `Agent.act` over a conserved-budget Scope. */
 async function runAgentic(opts) {
+	const workerProfile = exactAgenticProfile(opts.workerProfile, "runAgentic worker");
+	requiredProfileModel(workerProfile, "runAgentic worker");
+	const analystProfile = exactAgenticProfile(opts.analystProfile ?? workerProfile, "runAgentic analyst");
+	requiredProfileModel(analystProfile, "runAgentic analyst");
+	const exactOpts = {
+		...opts,
+		workerProfile,
+		analystProfile
+	};
 	const strategy = opts.strategy ?? (opts.mode === "breadth" ? sample : refine);
-	const driver = strategy.driver(opts.surface, opts.task, opts, opts.budget);
+	const driver = strategy.driver(opts.surface, opts.task, exactOpts, opts.budget);
 	const supervisor = createSupervisor();
+	const rootTurnLimit = profileTurnLimit(workerProfile, "runAgentic worker");
 	const root = opts.rootBudget ?? {
-		maxIterations: opts.budget * ((opts.innerTurns ?? 4) + 2),
+		maxIterations: opts.budget * ((rootTurnLimit === 0 ? UNBOUNDED_TURN_RESERVATION : rootTurnLimit) + 2),
 		maxTokens: 1e9
 	};
 	const started = Date.now();
@@ -1015,7 +1245,7 @@ async function runAgentic(opts) {
 		runId: `agentic:${strategy.name}:${opts.task.id}`,
 		journal: new InMemorySpawnJournal(),
 		blobs: new InMemoryResultBlobStore(),
-		executors: agenticRegistry(opts.surface, opts),
+		executors: agenticRegistry(opts.surface, exactOpts),
 		maxDepth: 3,
 		...opts.hooks ? { hooks: opts.hooks } : {}
 	});
@@ -1026,7 +1256,9 @@ async function runAgentic(opts) {
 	return {
 		...result.out.deliverable,
 		usd: result.spentTotal.usd,
+		usdKnown: result.spentTotal.usdKnown !== false,
 		tokens: result.spentTotal.tokens,
+		tokensKnown: result.spentTotal.tokensKnown !== false,
 		ms: Date.now() - started
 	};
 }
@@ -1315,7 +1547,7 @@ function structuralRollout(config = {}) {
 	const checkSource = config.checkSource ?? composeCheckSources(officialChecksFromMeta(), modelAuthoredChecks());
 	const checkRunner = config.checkRunner ?? sandboxCheckRunner();
 	const extract = config.extractCandidate ?? defaultExtractCandidate;
-	const inner = defineStrategy("structuralRollout", async (ctx) => {
+	return defineStrategy("structuralRollout", async (ctx) => {
 		const { task, shot } = ctx;
 		const progression = [];
 		const receipts = [];
@@ -1431,16 +1663,8 @@ function structuralRollout(config = {}) {
 			authoredChecks
 		};
 	});
-	if (policy.temperature === void 0) return inner;
-	return {
-		name: inner.name,
-		driver: (surface, task, opts, budget) => inner.driver(surface, task, {
-			...opts,
-			temperature: policy.temperature
-		}, budget)
-	};
 }
 //#endregion
-export { observe as C, researchDriverNote as D, optimizerMethod as E, strategyAuthorMethod as O, defaultAnalystInstruction as S, buildDriverSystem as T, depthStrategy as _, defaultStructuralRolloutPolicy as a, sample as b, officialChecksFromMeta as c, selectBestIndex as d, structuralRollout as f, defineStrategy as g, breadthStrategy as h, defaultExtractCandidate as i, resolveEntrySymbol as l, adaptiveRefine as m, compareCheckOutcomes as n, filterAuthoredAsserts as o, visibleCheckScore as p, composeCheckSources as r, modelAuthoredChecks as s, canDisplace as t, sandboxCheckRunner as u, refine as v, renderReport as w, sampleThenRefine as x, runAgentic as y };
+export { observe as C, optimizerMethod as D, profileOptimizerModelCall as E, strategyAuthorMethod as O, defaultAnalystInstruction as S, profileChatClient as T, depthStrategy as _, defaultStructuralRolloutPolicy as a, sample as b, officialChecksFromMeta as c, selectBestIndex as d, structuralRollout as f, defineStrategy as g, breadthStrategy as h, defaultExtractCandidate as i, resolveEntrySymbol as l, adaptiveRefine as m, compareCheckOutcomes as n, filterAuthoredAsserts as o, visibleCheckScore as p, composeCheckSources as r, modelAuthoredChecks as s, canDisplace as t, sandboxCheckRunner as u, refine as v, renderReport as w, sampleThenRefine as x, runAgentic as y };
 
-//# sourceMappingURL=structural-rollout-zY0oqQzO.js.map
+//# sourceMappingURL=structural-rollout-3uxVGcg2.js.map