@tangle-network/agent-runtime 0.142.3 → 0.153.1

package/dist/{supervisor-B_0ISTFG.js → supervisor-DBVlPONC.js}

@@ -1,11 +1,12 @@
+import { C as unknownExecutionBindingReceipt, S as runtimeOwnedScopeOwnerRuntime, a as authoredProfileDigest, b as runtimeOwnedExecutorProviderEvidence, c as knownExecutionBindingReceipt, f as recordRuntimeOwnedProviderAttemptStart, g as runtimeOwnedDeferredExecutorRuntime, h as recordRuntimeOwnedProviderModel, l as knownMaterializationReceipt, m as recordRuntimeOwnedProviderIdentityConflict, n as attestRuntimeOwnedExecutor, o as finalizeRuntimeOwnedPendingExecutor, p as recordRuntimeOwnedProviderDispatchNotStarted, r as attestRuntimeOwnedPendingExecutor, s as inheritRuntimeOwnedExecutorAttestation, t as attestRuntimeOwnedDeferredExecutor, u as newExecutionAttemptId, v as runtimeOwnedExecutorExecutionBinding, w as unknownMaterializationReceipt, x as runtimeOwnedPendingExecutorMaterialization, y as runtimeOwnedExecutorMaterialization } from "./materialization-Bo6j3Hg9.js";
 import { f as RuntimeRunStateError, m as ValidationError, r as BackendTransportError } from "./errors-CDZ8XsVj.js";
 import { t as detachedSnapshot } from "./snapshot-cK9K420n.js";
-import { S as contentAddress, a as aggregateProviderModelEvidence, c as pendingWaits, g as runtimeOwnedNestedDriverTreeRoot, h as nestedDriverTreeRoot, l as replaySpawnTree, m as driverRuntime, o as loadSpawnForest, p as attestNestedDriverTreeOwner, s as materializeTreeView, v as captureWorkerTraceEvidence } from "./spawn-journal-D2HKUImC.js";
-import { _ as zeroTokenUsage, a as hasCompleteCacheBreakdown, c as promptCacheTokenClasses, d as sleep, f as stringifySafe, g as withTimeout, h as usdEstimatedOf, i as deleteBoxSafe, l as randomSuffix, m as throwIfAborted, n as chargedTokens, p as throwAbort, r as cloneTokenUsage, s as mapWithConcurrency, t as addTokenUsage, u as randomUuid } from "./util-C1bv6yog.js";
-import { a as extractLlmCallEvent, c as notifySandboxEventObserver, n as assertSandboxServedModel, t as assertSandboxEventSucceeded } from "./sandbox-events-BK-g19wx.js";
-import { a as concreteProfileModel, l as resolveRouterRetryPolicy, o as profileBridgeWireModel, s as profileModelExecutionSettings, t as assertExecutableAgentProfile, u as agentHarness } from "./model-policy-DgRJIJse.js";
-import { C as unknownExecutionBindingReceipt, E as executableAgentSpecSnapshot, S as runtimeOwnedScopeOwnerRuntime, T as executableAgentProfileSnapshot, a as authoredProfileDigest, b as runtimeOwnedExecutorProviderEvidence, c as knownExecutionBindingReceipt, f as recordRuntimeOwnedProviderAttemptStart, g as runtimeOwnedDeferredExecutorRuntime, h as recordRuntimeOwnedProviderModel, l as knownMaterializationReceipt, m as recordRuntimeOwnedProviderIdentityConflict, n as attestRuntimeOwnedExecutor, o as finalizeRuntimeOwnedPendingExecutor, p as recordRuntimeOwnedProviderDispatchNotStarted, r as attestRuntimeOwnedPendingExecutor, t as attestRuntimeOwnedDeferredExecutor, u as newExecutionAttemptId, v as runtimeOwnedExecutorExecutionBinding, w as unknownMaterializationReceipt, x as runtimeOwnedPendingExecutorMaterialization, y as runtimeOwnedExecutorMaterialization } from "./materialization-CrdcfWXp.js";
-import { i as resolveAgentEnvironmentProvider, n as providerAsExecutor, r as providerAsSandboxClient } from "./environment-provider-DCEACNt9.js";
+import { S as contentAddress, a as aggregateProviderModelEvidence, c as pendingWaits, g as runtimeOwnedNestedDriverTreeRoot, h as nestedDriverTreeRoot, l as replaySpawnTree, m as driverRuntime, o as loadSpawnForest, p as attestNestedDriverTreeOwner, s as materializeTreeView, v as captureWorkerTraceEvidence } from "./spawn-journal-CLguaA2A.js";
+import { _ as withTimeout, a as cloneTokenUsage, d as randomSuffix, f as randomUuid, g as throwIfAborted, h as throwAbort, l as mapWithConcurrency, m as stringifySafe, n as addTokenUsage, o as deleteBoxSafe, p as sleep, r as chargedTokens, s as hasCompleteCacheBreakdown, t as addSpend, u as promptCacheTokenClasses, v as zeroSpend, y as zeroTokenUsage } from "./util-Bncw0o_F.js";
+import { c as sandboxEventServedBackend, i as extractLlmCallEvent, l as sandboxProgressEvents, o as mapSandboxToolEvent, r as createSandboxToolPartState, s as notifySandboxEventObserver, t as assertSandboxServedModel } from "./sandbox-events-DMijDq2p.js";
+import { n as executableAgentSpecSnapshot, r as projectSandboxOutcome, t as executableAgentProfileSnapshot } from "./executable-spec-BUcUcEPk.js";
+import { a as concreteProfileModel, c as profileModelExecutionSettings, d as agentHarness, o as enforceTokenLimits, s as profileBridgeWireModel, t as assertExecutableAgentProfile, u as resolveRouterRetryPolicy } from "./model-policy-Sw4ywhtL.js";
+import { i as resolveAgentEnvironmentProvider, n as providerAsExecutor, r as providerAsSandboxClient } from "./environment-provider-D_MXw3jK.js";
 import { i as notifyRuntimeHookEvent } from "./runtime-hooks-tXpAarhW.js";
 import { AGENT_PROFILE_MATERIALIZATION_AXES, AgentTurnInputSchema, REASONING_EFFORTS, agentProfileSchema, canonicalAgentProfileDigest, canonicalCandidateDigest, profileMaterializationAxes, profileMaterializationAxes as profileMaterializationAxes$1, renderInputPartsAsText, sha256DigestSchema } from "@tangle-network/agent-interface";
 import { estimateCost, isModelPriced } from "@tangle-network/agent-eval";
@@ -17,11 +18,13 @@ import { appendFileSync, constants, createReadStream } from "node:fs";
 import { spawn } from "node:child_process";
 import { homedir, tmpdir } from "node:os";
 import { stripVTControlCharacters } from "node:util";
+import { createAgentRunOutcomeTracker } from "@tangle-network/sandbox/runtime";
 import { request } from "node:http";
 import { request as request$1 } from "node:https";
 import { Readable } from "node:stream";
 import { deriveHexId, isW3CSpanId, isW3CTraceId } from "@tangle-network/agent-trace-contract";
 import { SDKError, generateIdempotencyKey, withRetry } from "@tangle-network/agent-core";
+import { collectAgentFinalMessageText, collectAgentResponseText } from "@tangle-network/sandbox";
 //#region src/agent/profile-materialization.ts
 const KNOWN_AXIS_SET = new Set(AGENT_PROFILE_MATERIALIZATION_AXES);
 /**
@@ -216,6 +219,43 @@ function assertProfileMaterialization(options) {
 	if (issues.length === 0) return;
 	throw new ValidationError(renderProfileMaterializationIssues(issues, options.context));
 }
+/**
+* Throw when the CHOSEN HARNESS has no control for a dimension the profile asks for.
+*
+* The contract above answers which axes a run path carries; this answers whether the harness can
+* execute them. `materializeProfile` is pure, so the verdict costs no process and no IO.
+*
+* `skip` must mirror what the EXECUTING caller skips, or this refuses a profile that would have
+* run: a dimension handled by the executor's own native control is not unsupported, it is simply
+* not the plan's to lower.
+*/
+function assertProfileMaterializes(profile, harness, context, skip) {
+	const plan = materializeProfile(profile, harness, skip ? { skip: [...skip] } : void 0);
+	if (plan.unsupported.length > 0) throw new ValidationError(`${context}: ${harness} cannot materialize the profile: ${renderUnsupported(plan.unsupported)}`);
+	return plan;
+}
+/**
+* Ask the materializer which of `dimensions` this harness has no control for, without executing
+* the profile's own `resources.failOnError` policy.
+*
+* A caller that gates only SOME dimensions needs the verdict as data, not as a throw: the
+* materializer throws while planning when `failOnError` is set (its strict default), which hides
+* the dimension list and would conflate a gated dimension with an ungated one. The query copy sets
+* `failOnError: false` so every dimension comes back on `plan.unsupported` and the caller decides.
+*/
+function unsupportedProfileDimensions(profile, harness, dimensions, skip) {
+	return materializeProfile({
+		...profile,
+		resources: {
+			...profile.resources,
+			failOnError: false
+		}
+	}, harness, skip ? { skip: [...skip] } : void 0).unsupported.filter((entry) => dimensions.includes(entry.dimension));
+}
+/** One clause per dimension the harness cannot execute, carrying the materializer's own reason. */
+function renderUnsupported(unsupported) {
+	return unsupported.map(({ dimension, reason }) => `${dimension}: ${reason}`).join("; ");
+}
 /** Format profile-axis drop issues into a concise operator-facing error. */
 function renderProfileMaterializationIssues(issues, context) {
 	if (issues.length === 0) return "";
@@ -1801,8 +1841,7 @@ function prepareWorktreeProfile(profile, harness) {
 	const workspaceProfile = materializationOnlyProfile(profile);
 	assertSupportedWorktreeProfile(profile, harness);
 	assertSafeProfileResourcePaths(profile);
-	const plan = materializeProfile(workspaceProfile, harness);
-	if (plan.unsupported.length > 0) throw new Error(`runWorktreeHarness: profile cannot be materialized for ${harness}: ${plan.unsupported.map(({ dimension, reason }) => `${dimension}: ${reason}`).join("; ")}`);
+	const plan = assertProfileMaterializes(workspaceProfile, harness, "runWorktreeHarness");
 	assertSafeMaterializedPaths(plan);
 	return {
 		plan,
@@ -3326,12 +3365,14 @@ async function routerChatWithUsage(cfg, messages, opts) {
 	const headers = routerRequestHeaders(cfg, opts);
 	const temperature = opts?.temperature;
 	const maxTokens = opts?.maxTokens ?? cfg.maxTokens;
+	const maxCompletionTokens = opts?.maxCompletionTokens ?? cfg.maxCompletionTokens;
 	const body = () => ({
 		...providerRequestExtras(opts?.extraBody, [
 			"model",
 			"messages",
 			"temperature",
 			"max_tokens",
+			"max_completion_tokens",
 			"seed",
 			"reasoning_effort",
 			"stream",
@@ -3341,6 +3382,7 @@ async function routerChatWithUsage(cfg, messages, opts) {
 		messages,
 		...temperature !== void 0 ? { temperature } : {},
 		...maxTokens !== void 0 ? { max_tokens: maxTokens } : {},
+		...maxCompletionTokens !== void 0 ? { max_completion_tokens: maxCompletionTokens } : {},
 		...opts?.seed !== void 0 ? { seed: opts.seed } : {},
 		...opts?.reasoningEffort ? { reasoning_effort: opts.reasoningEffort } : {}
 	});
@@ -3455,6 +3497,7 @@ async function routerChatWithTools(cfg, messages, tools, opts) {
 /** The OpenAI-shape request body both tool-calling transports send. One builder so the streamed
 *  turn cannot drift from the buffered one on model, temperature, tool_choice, or the ceiling. */
 function toolCompletionBody(cfg, messages, tools, opts) {
+	const maxCompletionTokens = opts?.maxCompletionTokens ?? cfg.maxCompletionTokens;
 	return {
 		...providerRequestExtras(opts?.extraBody, [
 			"model",
@@ -3463,6 +3506,7 @@ function toolCompletionBody(cfg, messages, tools, opts) {
 			"tool_choice",
 			"temperature",
 			"max_tokens",
+			"max_completion_tokens",
 			"seed",
 			"reasoning_effort",
 			"stream",
@@ -3476,6 +3520,7 @@ function toolCompletionBody(cfg, messages, tools, opts) {
 		} : {},
 		...opts?.temperature !== void 0 ? { temperature: opts.temperature } : {},
 		...opts?.maxTokens ? { max_tokens: opts.maxTokens } : {},
+		...maxCompletionTokens !== void 0 ? { max_completion_tokens: maxCompletionTokens } : {},
 		...opts?.seed !== void 0 ? { seed: opts.seed } : {},
 		...opts?.reasoningEffort ? { reasoning_effort: opts.reasoningEffort } : {}
 	};
@@ -3936,7 +3981,7 @@ async function acquireSandbox(client, options, acquire = {}) {
 	while (now() < deadline) {
 		throwIfAborted(acquire.signal);
 		try {
-			return await waitReadyOrDestroy(await client.create(createOpts), deadline, pollMs, acquire.signal, now, sleep$1);
+			return await waitReadyOrDestroy(await client.create(createOpts, acquire.signal === void 0 ? void 0 : { signal: acquire.signal }), deadline, pollMs, acquire.signal, now, sleep$1);
 		} catch (err) {
 			throwIfAborted(acquire.signal);
 			if (!isRetryable(err)) throw err;
@@ -4117,14 +4162,34 @@ async function* pollPromptEvents(box, prompt, sessionId, signal, promptOptions)
 	})).sessionId;
 	const result = await box.session(activeSessionId).result();
 	if (signal.aborted) throwAbort();
+	const resultData = {
+		finalText: result.response ?? "",
+		success: result.success,
+		...result.status ? { status: result.status } : {},
+		...result.error ? { error: result.error } : {},
+		...result.errorCode ? { errorCode: result.errorCode } : {},
+		...result.toolInvocations ? { toolInvocations: result.toolInvocations } : {},
+		...result.approval ? { approval: result.approval } : {},
+		...result.question ? { question: result.question } : {},
+		...result.interaction ? { interaction: result.interaction } : {},
+		...result.plan ? { plan: result.plan } : {},
+		...result.usage ? { usage: result.usage } : {},
+		...result.costUsd !== void 0 ? { costUsd: result.costUsd } : {}
+	};
 	yield {
 		type: "result",
 		id: activeSessionId,
+		data: resultData
+	};
+	yield {
+		type: "done",
+		id: activeSessionId,
 		data: {
-			finalText: result.response ?? "",
-			success: result.success,
-			...result.error ? { error: result.error } : {},
-			...result.usage ? { usage: result.usage } : {}
+			...resultData,
+			outcome: result.status === "awaiting_plan_decision" && result.plan ? {
+				type: "awaiting_plan_decision",
+				plan: result.plan
+			} : { type: "completed" }
 		}
 	};
 }
@@ -4702,14 +4767,14 @@ async function executeIteration(args) {
 			...requestedModel !== void 0 ? { model: requestedModel } : {}
 		};
 		let sawLlmCall = false;
+		const outcomeTracker = createAgentRunOutcomeTracker();
 		for await (const event of stream) {
 			events.push(event);
+			outcomeTracker.observe(event);
 			notifySandboxEventObserver(event, args.ctx.onSandboxEvent, {
 				iterationIndex: args.item.index,
 				agentRunName: slot.agentRunName
 			});
-			assertSandboxEventSucceeded(event);
-			assertSandboxServedModel(event, requested);
 			const llmCall = extractLlmCallEvent(event, slot.agentRunName);
 			if (llmCall) {
 				sawLlmCall = true;
@@ -4728,18 +4793,24 @@ async function executeIteration(args) {
 				});
 				args.ctx.runHandle?.observe(llmCall);
 			}
+			assertSandboxServedModel(event, requested);
 		}
+		const outcome = outcomeTracker.finish();
+		slot.sandboxOutcome = outcome;
 		if (!sawLlmCall) {
 			slot.tokenUsage.tokensKnown = false;
 			slot.costUsdKnown = false;
 		}
 		slot.output = args.output.parse(events);
-		if (args.validator) slot.verdict = await args.validator.validate(slot.output, {
+		const projection = projectSandboxOutcome(outcome);
+		if (projection.status === "failed") throw new Error(projection.reason);
+		if (projection.status === "completed" && args.validator) slot.verdict = await args.validator.validate(slot.output, {
 			iteration: args.item.index,
 			...box ? { box } : {},
 			signal: args.signal,
 			traceEmitter: args.ctx.traceEmitter
 		});
+		else if (projection.status !== "completed") slot.verdict = projection.verdict;
 	} catch (err) {
 		slot.error = err instanceof Error ? err : new Error(String(err));
 	} finally {
@@ -5110,6 +5181,59 @@ function hashJson(value) {
 	return (h >>> 0).toString(16).padStart(8, "0");
 }
 //#endregion
+//#region src/runtime/sandbox-executor-output.ts
+/** Project the complete Sandbox event stream into the standard executor result shape. */
+function sandboxLeafOutputFromEvents(events) {
+	const content = collectAgentFinalMessageText(events) ?? collectAgentResponseText(events);
+	const toolCalls = sandboxToolCalls(events);
+	const servedBackend = lastServedBackend(events);
+	return {
+		events,
+		content,
+		output: sandboxOutputMarker(content, events.some(carriesText)),
+		...servedBackend === void 0 ? {} : { servedBackend },
+		...toolCalls.length === 0 ? {} : { toolCalls }
+	};
+}
+/**
+* Classify observed text into the explicit output marker. `sawTextEvent` says whether the stream
+* carried a text-bearing event at all, which is what separates a box that answered nothing from a
+* box whose answer was never observed.
+*/
+function sandboxOutputMarker(content, sawTextEvent = content !== void 0) {
+	if (content !== void 0 && content.length > 0) return {
+		kind: "text",
+		bytes: Buffer.byteLength(content, "utf8")
+	};
+	return sawTextEvent ? { kind: "empty" } : { kind: "absent" };
+}
+/** True when the event carries a text field a turn's answer could come from, empty or not. */
+function carriesText(event) {
+	if (!event || typeof event !== "object") return false;
+	const data = event.data && typeof event.data === "object" ? event.data : {};
+	if (typeof data.finalText === "string" || typeof data.text === "string") return true;
+	if (typeof data.delta === "string") return true;
+	const part = data.part && typeof data.part === "object" ? data.part : void 0;
+	return part !== void 0 && part.type === "text" && typeof part.text === "string";
+}
+/** The last served identity the platform reported across a turn's events, or `undefined`. */
+function lastServedBackend(events) {
+	let served;
+	for (const event of events) {
+		const next = sandboxEventServedBackend(event);
+		if (next !== void 0) served = next;
+	}
+	return served;
+}
+function sandboxToolCalls(events) {
+	const state = createSandboxToolPartState();
+	return events.flatMap((event) => mapSandboxToolEvent(event, state).flatMap((projected) => projected.type === "tool_call" ? [{
+		...projected.toolCallId === void 0 ? {} : { id: projected.toolCallId },
+		name: projected.toolName,
+		arguments: projected.args ?? {}
+	}] : []));
+}
+//#endregion
 //#region src/runtime/supervise/cost-estimate.ts
 /**
 * Pricing for work that arrived without a provider receipt.
@@ -5132,7 +5256,8 @@ function priceUnreceiptedWork(work) {
 	const unknown = {
 		kind: "cost",
 		usd: 0,
-		usdKnown: false
+		usdKnown: false,
+		provenance: "uncaptured"
 	};
 	const { inputTokens, outputTokens, model } = work;
 	if (model === void 0 || !isModelPriced(model)) return unknown;
@@ -5144,7 +5269,8 @@ function priceUnreceiptedWork(work) {
 		kind: "cost",
 		usd,
 		usdKnown: false,
-		usdEstimated: usd
+		usdEstimated: usd,
+		provenance: "catalog-estimate"
 	};
 }
 //#endregion
@@ -5867,12 +5993,21 @@ function createSteerableSandboxSession(args) {
 	});
 	const state = {
 		turns: 0,
-		lastText: "",
+		/** `undefined` until a text-bearing terminal event is observed; never seeded with `''`. */
+		lastText: void 0,
+		servedBackend: void 0,
 		seenToolCalls: /* @__PURE__ */ new Set(),
+		toolCalls: [],
 		artifact: void 0,
+		latestOutcome: void 0,
+		/** Reads the live lineage handle once a box and session exist, for exact cancellation. */
+		session: void 0,
 		teardown: void 0,
 		note: "starting"
 	};
+	const toolParts = createSandboxToolPartState();
+	/** Record one box event for the trace and the activity window, and return the live output it
+	*  carries so the caller can publish it to the turn stream. */
 	const recordEvent = (event) => {
 		const at = now();
 		const data = event.data;
@@ -5896,7 +6031,19 @@ function createSteerableSandboxSession(args) {
 			}
 		}
 		const text = readFinalText(event);
-		if (text) state.lastText = text;
+		if (text !== void 0) state.lastText = text;
+		const served = sandboxEventServedBackend(event);
+		if (served !== void 0) state.servedBackend = served;
+		const progress = sandboxProgressEvents(event, toolParts);
+		for (const item of progress) {
+			if (item.kind !== "tool_call") continue;
+			state.toolCalls.push({
+				...item.toolCallId === void 0 ? {} : { id: item.toolCallId },
+				name: item.toolName,
+				arguments: item.args ?? {}
+			});
+		}
+		return progress;
 	};
 	async function* stream(task, signal) {
 		const capabilities = await probeSandboxCapabilities(args.sandboxClient);
@@ -5922,6 +6069,7 @@ function createSteerableSandboxSession(args) {
 		let tokensKnown = true;
 		let usd = 0;
 		let handle;
+		state.session = () => handle;
 		let nextPrompt = args.taskToPrompt(task);
 		try {
 			for (let turn = 0; maxTurns === 0 || turn < maxTurns; turn += 1) {
@@ -5958,6 +6106,7 @@ function createSteerableSandboxSession(args) {
 				};
 				let events;
 				let sawLlmCall = false;
+				const outcomeTracker = createAgentRunOutcomeTracker();
 				try {
 					if (!handle) {
 						const opened = await lineage.start(spec, prompt, turnController.signal, promptOptions);
@@ -5965,36 +6114,42 @@ function createSteerableSandboxSession(args) {
 						events = opened.events;
 					} else events = await lineage.continue(handle, prompt, turnController.signal, promptOptions);
 					for await (const event of events) {
-						recordEvent(event);
-						assertSandboxEventSucceeded(event);
-						assertSandboxServedModel(event, requested);
+						outcomeTracker.observe(event);
+						for (const progress of recordEvent(event)) yield {
+							kind: "progress",
+							progress
+						};
 						const call = extractLlmCallEvent(event, spec.name ?? String(args.harness));
-						if (!call) continue;
-						sawLlmCall = true;
-						const callTokensKnown = call.tokensKnown !== false && typeof call.tokensIn === "number" && typeof call.tokensOut === "number";
-						if (!callTokensKnown) tokensKnown = false;
-						const input = call.tokensIn ?? 0;
-						const output = call.tokensOut ?? 0;
-						if (input || output || !callTokensKnown) {
-							const usage = {
-								kind: "tokens",
-								input,
-								output,
-								...callTokensKnown ? {} : { tokensKnown: false },
-								...promptCacheTokenClasses(call.tokensIn, call.promptCache)
-							};
-							addTokenUsage(tokens, usage);
-							yield usage;
-						}
-						if (typeof call.costUsd === "number" && call.costUsd > 0) {
-							usd += call.costUsd;
-							yield {
-								kind: "cost",
-								usd: call.costUsd,
-								usdKnown: false
-							};
+						if (call) {
+							sawLlmCall = true;
+							const callTokensKnown = call.tokensKnown !== false && typeof call.tokensIn === "number" && typeof call.tokensOut === "number";
+							if (!callTokensKnown) tokensKnown = false;
+							const input = call.tokensIn ?? 0;
+							const output = call.tokensOut ?? 0;
+							if (input || output || !callTokensKnown) {
+								const usage = {
+									kind: "tokens",
+									input,
+									output,
+									...callTokensKnown ? {} : { tokensKnown: false },
+									...promptCacheTokenClasses(call.tokensIn, call.promptCache)
+								};
+								addTokenUsage(tokens, usage);
+								yield usage;
+							}
+							if (typeof call.costUsd === "number" && call.costUsd > 0) {
+								usd += call.costUsd;
+								yield {
+									kind: "cost",
+									usd: call.costUsd,
+									usdKnown: false,
+									provenance: "uncaptured"
+								};
+							}
 						}
+						assertSandboxServedModel(event, requested);
 					}
+					state.latestOutcome = outcomeTracker.finish();
 				} catch (e) {
 					cleanup();
 					if (isInterruptAbort(e, interruptSig, signal, args.controller.signal)) {
@@ -6035,7 +6190,8 @@ function createSteerableSandboxSession(args) {
 		if (state.turns > 0) yield {
 			kind: "cost",
 			usd: 0,
-			usdKnown: false
+			usdKnown: false,
+			provenance: "uncaptured"
 		};
 		const spent = {
 			iterations: state.turns,
@@ -6047,20 +6203,79 @@ function createSteerableSandboxSession(args) {
 		};
 		const out = {
 			content: state.lastText,
+			output: sandboxOutputMarker(state.lastText),
+			...state.servedBackend === void 0 ? {} : { servedBackend: state.servedBackend },
 			turns: state.turns,
-			toolCalls: activity.read().filter((n) => n.kind === "tool").map((n) => n.label)
+			toolCalls: state.toolCalls,
+			...state.latestOutcome ? { outcome: state.latestOutcome } : {}
 		};
+		const verdict = state.latestOutcome ? projectSandboxOutcome(state.latestOutcome).verdict : void 0;
 		state.artifact = {
 			outRef: args.contentRef("sandbox-steerable", {
 				harness: args.harness,
 				out
 			}),
 			out,
+			...verdict ? { verdict } : {},
 			spent
 		};
 	}
 	return {
 		stream,
+		async cancel(request) {
+			const live = state.session?.();
+			const observedAt = () => (/* @__PURE__ */ new Date()).toISOString();
+			if (!live) return {
+				status: "unknown",
+				effect: "cancel_requested",
+				observedAt: observedAt(),
+				detail: "no box session exists yet for this worker; nothing remote could be asked"
+			};
+			const session = live.box.session?.(live.sessionId);
+			if (!session || typeof session.interrupt !== "function") return {
+				status: "unknown",
+				effect: "cancel_requested",
+				observedAt: observedAt(),
+				detail: "the sandbox client exposes no session interrupt operation",
+				evidence: { sessionId: live.sessionId }
+			};
+			try {
+				const result = await session.interrupt();
+				const evidence = {
+					sessionId: live.sessionId,
+					operationId: request.operationId,
+					result
+				};
+				if (result?.cancelled === true) {
+					args.controller.abort("executor cancelled");
+					return {
+						status: "accepted",
+						effect: "cancelled",
+						observedAt: observedAt(),
+						detail: "the box reported the running execution cancelled",
+						evidence
+					};
+				}
+				return {
+					status: "already-terminal",
+					effect: "not_live",
+					observedAt: observedAt(),
+					detail: "the box reported no running execution on this session",
+					evidence
+				};
+			} catch (error) {
+				return {
+					status: "unknown",
+					effect: "cancel_requested",
+					observedAt: observedAt(),
+					detail: `the box interrupt failed: ${error instanceof Error ? error.message : String(error)}`,
+					evidence: {
+						sessionId: live.sessionId,
+						operationId: request.operationId
+					}
+				};
+			}
+		},
 		progress: () => ({
 			turns: state.turns,
 			pendingMessages: args.inbox.pending(),
@@ -6078,14 +6293,16 @@ function createSteerableSandboxSession(args) {
 function isInterruptAbort(err, interrupt, external, owned) {
 	return (err instanceof DOMException && err.name === "AbortError" || typeof err === "object" && err !== null && err.name === "AbortError") && interrupt.aborted && !external.aborted && !owned.aborted;
 }
-/** The terminal text a sandbox `result` event carries, when it carries one. */
+/** The terminal text a sandbox `result` event carries, when it carries one. An observed empty
+*  string is returned as `''`, because "the box answered nothing" is not "the box never
+*  answered". */
 function readFinalText(event) {
 	const data = event.data;
 	if (!data || typeof data !== "object") return void 0;
 	const text = data.finalText;
-	if (typeof text === "string" && text.length > 0) return text;
+	if (typeof text === "string") return text;
 	const alt = data.text;
-	return typeof alt === "string" && alt.length > 0 ? alt : void 0;
+	return typeof alt === "string" ? alt : void 0;
 }
 /** Prompt options the composed loop context already carries (agent profile / cwd), forwarded so
 *  a steerable worker runs with the same box configuration as the single-shot path. */
@@ -6493,6 +6710,11 @@ const bridgeSeamKey = "bridge";
 /** Internal control seam used by Runtime-owned external supervisors. A completion request stops
 * the next bridge turn; it must not abort the paid request that is already streaming. */
 const bridgeStopSignalKey = "__bridge_stop_signal";
+/** Internal attachment seam used by Runtime-owned external supervisors. The named MCP servers ride
+* beside the AgentProfile as `runtime_attachments`, so the bridge mounts them for the run and keeps
+* them out of its session profile binding. A rebound coordination port therefore cannot move the
+* authored profile digest that binds a durable session. */
+const bridgeRuntimeAttachmentsKey = "__bridge_runtime_attachments";
 const maxBridgeTimeoutMs = 2147483647;
 const bridgeModelCredentialHeader = "x-cli-bridge-model-credential";
 const bridgeModelBaseUrlHeader = "x-cli-bridge-model-base-url";
@@ -6631,6 +6853,19 @@ function unmeteredSpend(ms) {
 * failures (429/5xx/Cloudflare-origin) retry with backoff before the executor
 * fails the task.
 */
+/**
+* The honest answer for a backend with no cancel operation: the local request stopped, and
+* nothing about the remote run is known. Never `accepted` — a client that advertises provider
+* cancellation from this would claim more than Runtime observed.
+*/
+function localAbortCancellation(detail) {
+	return {
+		status: "unknown",
+		effect: "cancel_requested",
+		observedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		detail
+	};
+}
 const routerInlineExecutor = (spec, ctx) => {
 	const seam = readSeam(ctx, routerSeamKey, "router/inline");
 	const model = exactRouterModel(spec.profile, "routerInlineExecutor");
@@ -6668,7 +6903,7 @@ const routerInlineExecutor = (spec, ctx) => {
 				...profileExecution.temperature !== void 0 ? { temperature: profileExecution.temperature } : {},
 				...linked ? { signal: linked } : {},
 				...profileExecution.toolChoice ? { toolChoice: profileExecution.toolChoice } : {},
-				...profileExecution.maxTokens !== void 0 ? { maxTokens: profileExecution.maxTokens } : {},
+				...profileExecution.tokenLimits.applied,
 				...profileExecution.seed !== void 0 ? { seed: profileExecution.seed } : {},
 				...Object.keys(extraBody).length > 0 ? { extraBody } : {},
 				...requestIdentity
@@ -6681,7 +6916,7 @@ const routerInlineExecutor = (spec, ctx) => {
 			}, messages, {
 				...profileExecution.temperature !== void 0 ? { temperature: profileExecution.temperature } : {},
 				...linked ? { signal: linked } : {},
-				...profileExecution.maxTokens !== void 0 ? { maxTokens: profileExecution.maxTokens } : {},
+				...profileExecution.tokenLimits.applied,
 				...profileExecution.seed !== void 0 ? { seed: profileExecution.seed } : {},
 				...profileExecution.reasoningEffort ? { reasoningEffort: profileExecution.reasoningEffort } : {},
 				...profileExecution.extraBody ? { extraBody: profileExecution.extraBody } : {},
@@ -6722,6 +6957,10 @@ const routerInlineExecutor = (spec, ctx) => {
 			};
 			return artifact;
 		},
+		cancel(_request) {
+			controller.abort("executor cancelled");
+			return Promise.resolve(localAbortCancellation("the Router chat-completions API exposes no cancel operation; the local request was aborted and the provider may still bill the completion"));
+		},
 		teardown(_grace) {
 			controller.abort("executor torn down");
 			return Promise.resolve({ destroyed: true });
@@ -6750,7 +6989,7 @@ const routerInlineExecutor = (spec, ctx) => {
 			model,
 			provider: spec.profile.model?.provider ?? null,
 			temperature: profileExecution.temperature ?? null,
-			maxTokens: profileExecution.maxTokens ?? null,
+			tokenLimits: profileExecution.tokenLimits,
 			retry: profileExecution.retry ?? null,
 			seed: profileExecution.seed ?? null,
 			reasoningEffort: profileExecution.reasoningEffort ?? null,
@@ -6862,6 +7101,7 @@ const routerToolsInlineExecutor = (spec, ctx) => {
 			let reasoningKnown = true;
 			const promptCache = {};
 			let lastText = "";
+			const executedToolCalls = [];
 			const flush = () => {
 				const pending = inbox.drain();
 				if (pending.length) messages.push({
@@ -6894,7 +7134,7 @@ const routerToolsInlineExecutor = (spec, ctx) => {
 							...profileExecution.temperature !== void 0 ? { temperature: profileExecution.temperature } : {},
 							signal: turnController.signal,
 							...profileExecution.toolChoice ? { toolChoice: profileExecution.toolChoice } : {},
-							...profileExecution.maxTokens !== void 0 ? { maxTokens: profileExecution.maxTokens } : {},
+							...profileExecution.tokenLimits.applied,
 							...profileExecution.seed !== void 0 ? { seed: profileExecution.seed } : {},
 							...profileExecution.reasoningEffort ? { reasoningEffort: profileExecution.reasoningEffort } : {},
 							...profileExecution.extraBody ? { extraBody: profileExecution.extraBody } : {},
@@ -6960,6 +7200,11 @@ const routerToolsInlineExecutor = (spec, ctx) => {
 						const tc = toolCalls[i];
 						const id = tc?.id ?? `call_${i}`;
 						const toolName = tc?.name ?? "";
+						executedToolCalls.push({
+							id,
+							name: toolName,
+							arguments: tc?.arguments ?? ""
+						});
 						if (!enabledToolNames.has(toolName)) {
 							messages.push({
 								role: "tool",
@@ -7030,7 +7275,7 @@ const routerToolsInlineExecutor = (spec, ctx) => {
 				...observedModel !== void 0 ? { model: observedModel } : {},
 				messages,
 				turns,
-				toolCalls: messages.filter((message) => message.role === "tool").length,
+				toolCalls: executedToolCalls,
 				transportAttempts,
 				...estimatedUsd !== void 0 ? { estimatedCostUsd: estimatedUsd } : {},
 				...Object.keys(promptCache).length > 0 ? { promptCache } : {},
@@ -7046,6 +7291,10 @@ const routerToolsInlineExecutor = (spec, ctx) => {
 			};
 			return artifact;
 		},
+		cancel(_request) {
+			controller.abort("executor cancelled");
+			return Promise.resolve(localAbortCancellation("the Router chat-completions API exposes no cancel operation; the in-flight turn was aborted and the provider may still bill it"));
+		},
 		teardown(_grace) {
 			controller.abort("executor torn down");
 			return Promise.resolve({ destroyed: true });
@@ -7076,7 +7325,7 @@ const routerToolsInlineExecutor = (spec, ctx) => {
 			maxTurns,
 			tools: seam.tools,
 			temperature: profileExecution.temperature ?? null,
-			maxTokens: profileExecution.maxTokens ?? null,
+			tokenLimits: profileExecution.tokenLimits,
 			retry: profileExecution.retry ?? null,
 			toolChoice: profileExecution.toolChoice ?? null,
 			extraBody: profileExecution.extraBody ?? null,
@@ -7135,6 +7384,7 @@ const sandboxExecutor = (spec, ctx) => {
 	if (!seam.sandboxClient || typeof seam.sandboxClient.create !== "function") throw new ValidationError("sandboxExecutor: SandboxSeam.sandboxClient.create required");
 	const maxIterations = seam.maxIterations ?? 1;
 	if (!Number.isFinite(maxIterations) || maxIterations <= 0) throw new ValidationError("sandboxExecutor: maxIterations must be > 0");
+	const sandboxTokenLimits = enforceTokenLimits(profileModelExecutionSettings(spec.profile, "sandboxExecutor").tokenLimits, "sandbox", "sandboxExecutor");
 	const traceEnv = workerTraceEnv(ctx);
 	const controller = new AbortController();
 	const abortIfSignalled = () => {
@@ -7165,7 +7415,8 @@ const sandboxExecutor = (spec, ctx) => {
 			kind: "sandbox-agent-rounds",
 			harness,
 			maxIterations,
-			steering: seam.steering !== void 0
+			steering: seam.steering !== void 0,
+			tokenLimits: sandboxTokenLimits
 		}
 	};
 	const sandboxBinding = {
@@ -7200,6 +7451,7 @@ const sandboxExecutor = (spec, ctx) => {
 			runtime: "sandbox",
 			deliver: (m) => inbox.deliver(m),
 			progress: () => session.progress(),
+			cancel: (request) => session.cancel(request),
 			traceSource: () => session.traceSource(),
 			execute(task, signal) {
 				return session.stream(task, signal);
@@ -7217,7 +7469,7 @@ const sandboxExecutor = (spec, ctx) => {
 		}, sandboxMaterialization, sandboxBinding);
 	}
 	const output = { parse(events) {
-		return { events };
+		return sandboxLeafOutputFromEvents(events);
 	} };
 	const driver = singleShotDriver(maxIterations);
 	return attestRuntimeOwnedExecutor({
@@ -7241,6 +7493,10 @@ const sandboxExecutor = (spec, ctx) => {
 				}
 			});
 		},
+		cancel(_request) {
+			controller.abort("executor cancelled");
+			return Promise.resolve(localAbortCancellation("the composed sandbox run owns its boxes, so this executor retains no exact session control reference to cancel against"));
+		},
 		teardown(_grace) {
 			controller.abort();
 			return Promise.resolve({ destroyed: true });
@@ -7289,12 +7545,21 @@ async function* streamSandboxLeaf(args) {
 		const result = await runAgentRounds(loopOptions);
 		const failure = failedRound(result);
 		if (failure) throw failure;
-		const out = result.winner?.output ?? { events: [] };
-		const verdict = result.winner?.verdict ?? leafVerdict(result);
+		const winningIteration = result.winner ? result.iterations.find((iteration) => iteration.index === result.winner?.iterationIndex) : result.iterations.at(-1);
+		const out = winningIteration?.output ?? sandboxLeafOutputFromEvents(winningIteration?.events ?? []);
+		const sandboxOutcome = winningIteration?.sandboxOutcome;
+		const outWithOutcome = {
+			...out,
+			...sandboxOutcome ? { outcome: sandboxOutcome } : {}
+		};
+		const verdict = sandboxOutcome && !sandboxOutcome.success ? {
+			valid: false,
+			score: 0
+		} : result.winner?.verdict ?? leafVerdict(result);
 		const tokensKnown = result.tokenUsage.tokensKnown !== false;
 		const usdKnown = result.costUsdKnown !== false;
 		const outWithUsage = {
-			...out,
+			...outWithOutcome,
 			...result.estimatedCostUsd !== void 0 ? { estimatedCostUsd: result.estimatedCostUsd } : {},
 			...result.promptCache ? { promptCache: result.promptCache } : {}
 		};
@@ -7326,10 +7591,16 @@ async function* streamSandboxLeaf(args) {
 			...result.tokenUsage.cacheWrite !== void 0 ? { cacheWrite: result.tokenUsage.cacheWrite } : {},
 			...result.tokenUsage.cacheBreakdownKnown === false ? { cacheBreakdownKnown: false } : {}
 		};
-		if (result.iterations.length > 0 || result.costUsd) yield {
+		if (result.iterations.length > 0 || result.costUsd) yield usdKnown ? {
+			kind: "cost",
+			usdKnown: true,
+			usd: result.costUsd,
+			provenance: "provider-receipt"
+		} : {
 			kind: "cost",
+			usdKnown: false,
 			usd: result.costUsd,
-			...usdKnown ? {} : { usdKnown: false }
+			provenance: "uncaptured"
 		};
 	} finally {
 		args.signal.removeEventListener("abort", cascadeExternal);
@@ -7528,18 +7799,20 @@ function bridgeProfileModel(profile, context) {
 const bridgeExecutor = (spec, ctx) => {
 	const base = readSeam(ctx, bridgeSeamKey, "bridge");
 	const stopSignal = readOptionalAbortSignal(ctx, bridgeStopSignalKey, "bridge");
+	const runtimeAttachments = readOptionalMcpAttachments(ctx, bridgeRuntimeAttachmentsKey, "bridge");
 	const modelCredential = validateBridgeModelCredential(base.modelCredential, base.bridgeUrl, "bridgeExecutor");
 	const effectiveProfile = agentProfileSchema.parse(spec.profile);
 	const model = bridgeProfileModel(effectiveProfile, "bridgeExecutor");
 	const harness = agentHarness(effectiveProfile.harness);
 	const providerModel = harness !== void 0 && model.startsWith(`${harness}/`) ? model.slice(harness.length + 1) : model;
 	const profileExecution = profileModelExecutionSettings(effectiveProfile, "bridgeExecutor");
+	const bridgeTokenLimits = enforceTokenLimits(profileExecution.tokenLimits, "bridge", "bridgeExecutor");
 	const seam = {
 		...base,
 		...modelCredential === void 0 ? {} : { modelCredential },
 		model,
 		providerModel,
-		...profileExecution.maxTokens !== void 0 ? { maxTokens: profileExecution.maxTokens } : {}
+		...bridgeTokenLimits.applied.maxTokens !== void 0 ? { maxTokens: bridgeTokenLimits.applied.maxTokens } : {}
 	};
 	if (!seam.bridgeUrl || !seam.bridgeBearer) throw new ValidationError("bridgeExecutor: bridgeUrl + bridgeBearer are required");
 	if (seam.timeoutMs !== void 0 && (!Number.isSafeInteger(seam.timeoutMs) || seam.timeoutMs < 1 || seam.timeoutMs > maxBridgeTimeoutMs)) throw new ValidationError(`bridgeExecutor: timeoutMs must be an integer from 1 to ${maxBridgeTimeoutMs}`);
@@ -7587,7 +7860,7 @@ const bridgeExecutor = (spec, ctx) => {
 			maxReconnects,
 			timeoutMs: seam.timeoutMs ?? null,
 			streaming: true,
-			...seam.maxTokens !== void 0 ? { maxTokens: seam.maxTokens } : {},
+			tokenLimits: bridgeTokenLimits,
 			terminalAcknowledgement: null
 		}
 	};
@@ -7633,11 +7906,16 @@ const bridgeExecutor = (spec, ctx) => {
 			}
 		},
 		traceSource: () => trace.source,
+		interactive: () => Object.freeze({
+			status: "unavailable",
+			reason: "provider-has-no-interactive-contract"
+		}),
 		execute(task, signal) {
 			return streamBridgeSession({
 				task,
 				signal,
 				...stopSignal === void 0 ? {} : { stopSignal },
+				...runtimeAttachments === void 0 ? {} : { runtimeAttachments },
 				profile: effectiveProfile,
 				seam,
 				sessionId,
@@ -7674,6 +7952,41 @@ const bridgeExecutor = (spec, ctx) => {
 				}
 			});
 		},
+		async cancel(request) {
+			const live = [...activeRuns.values()].filter((run) => !run.terminal);
+			const observedAt = () => (/* @__PURE__ */ new Date()).toISOString();
+			if (live.length === 0) return {
+				status: "already-terminal",
+				effect: "not_live",
+				observedAt: observedAt(),
+				detail: "every bridge run for this session was already terminal",
+				evidence: { runs: [...activeRuns.keys()] }
+			};
+			controller.abort("executor cancelled");
+			const grace = request.signal === void 0 ? "infinity" : BRIDGE_CANCEL_LONG_POLL_MS;
+			const terminal = await Promise.all(live.map((run) => cancelBridgeRunToTerminal(seam, run, grace, request.signal)));
+			const evidence = {
+				operationId: request.operationId,
+				runs: live.map((run, index) => ({
+					id: run.id,
+					terminal: terminal[index] === true
+				}))
+			};
+			if (terminal.every(Boolean)) return {
+				status: "accepted",
+				effect: "cancelled",
+				observedAt: observedAt(),
+				detail: "the bridge reported every run terminal after the cancel operation",
+				evidence
+			};
+			return {
+				status: "unknown",
+				effect: "cancel_requested",
+				observedAt: observedAt(),
+				detail: "the bridge accepted the cancel operation but a run had not reached terminal state within the deadline",
+				evidence
+			};
+		},
 		async teardown(grace) {
 			controller.abort();
 			const remaining = [...activeRuns.values()].filter((run) => !run.terminal);
@@ -7739,6 +8052,78 @@ function scheduleBridgeRunStateRefresh(seam, activeRuns, observation) {
 		}
 	})();
 }
+/** One bridge GET over the `node:http(s)` core client — the same transport every other bridge
+*  read uses, so a computed provider endpoint never reaches global `fetch`. Resolves the status
+*  and the body text; a transport failure rejects. */
+function bridgeGet(seam, path, timeoutMs) {
+	const target = new URL(`${seam.bridgeUrl.replace(/\/$/, "")}${path}`);
+	const requestFn = target.protocol === "https:" ? request$1 : request;
+	return new Promise((resolve, reject) => {
+		const req = requestFn(target, {
+			method: "GET",
+			headers: { authorization: `Bearer ${seam.bridgeBearer}` },
+			timeout: timeoutMs
+		}, (res) => {
+			(async () => {
+				const chunks = [];
+				for await (const chunk of res) chunks.push(Buffer.from(chunk));
+				resolve({
+					status: res.statusCode ?? 0,
+					body: Buffer.concat(chunks).toString("utf8")
+				});
+			})().catch(reject);
+		});
+		req.on("timeout", () => req.destroy(/* @__PURE__ */ new Error(`bridge GET ${path} timed out`)));
+		req.on("error", reject);
+		req.end();
+	});
+}
+/**
+* `GET /v1/capabilities?model=<wire id>` — does this bridge route this model AT ALL.
+*
+* The bridge answers exactly this question and 404s `no backend matches model "…"`, which is the
+* error a child would otherwise discover after it was spawned and metered. Returns `undefined`
+* when the route resolves; otherwise the operator-facing reason it did not. FAIL CLOSED: a
+* transport error and an unexpected status are both reasons, never a silent pass.
+*/
+async function bridgeModelRouteRefusal(seam, wireModel) {
+	const base = seam.bridgeUrl.replace(/\/$/, "");
+	let answer;
+	try {
+		answer = await bridgeGet(seam, `/v1/capabilities?model=${encodeURIComponent(wireModel)}`, BRIDGE_RUN_STATE_TIMEOUT_MS);
+	} catch (error) {
+		return `bridge ${base} did not answer for model ${JSON.stringify(wireModel)}: ${error instanceof Error ? error.message : String(error)}`;
+	}
+	if (answer.status === 200) return void 0;
+	return answer.status === 404 ? `bridge ${base} routes no backend for model ${JSON.stringify(wireModel)}` : `bridge ${base} answered ${answer.status} for model ${JSON.stringify(wireModel)}`;
+}
+/**
+* `GET /health` → `admission.{active,maxActive}`, or `undefined` when the bridge does not report
+* them. ADVISORY by nature — admission fills and drains — so an unanswered or admission-less
+* `/health` is not evidence about capacity and must not be read as one.
+*/
+async function bridgeAdmissionRead(seam) {
+	let answer;
+	try {
+		answer = await bridgeGet(seam, "/health", BRIDGE_RUN_STATE_TIMEOUT_MS);
+	} catch {
+		return;
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(answer.body);
+	} catch {
+		return;
+	}
+	const admission = parsed?.admission;
+	const active = admission?.active;
+	const maxActive = admission?.maxActive;
+	if (typeof active !== "number" || typeof maxActive !== "number" || maxActive <= 0) return;
+	return {
+		active,
+		maxActive
+	};
+}
 /** `GET /v1/runs/:id` — the bridge's durable-run registry read. Resolves `undefined` for any
 *  non-200 or non-conforming body rather than throwing: this is only ever an observability read. */
 function bridgeRunStateGet(seam, runId) {
@@ -7871,6 +8256,7 @@ async function* streamBridgeSession(args) {
 				...seam.timeoutMs !== void 0 ? { timeoutMs: seam.timeoutMs } : {}
 			},
 			agent_profile: args.profile,
+			...args.runtimeAttachments === void 0 ? {} : { runtime_attachments: { mcp: args.runtimeAttachments } },
 			messages
 		};
 		let turnText = "";
@@ -7879,6 +8265,7 @@ async function* streamBridgeSession(args) {
 		let sawTurnCostStatus = false;
 		let turnUsdKnown = true;
 		let turnKnownCostSubtotal = 0;
+		let turnCostProvenance;
 		let turnEstimatedCostSubtotal = 0;
 		let turnInputTokens = 0;
 		let turnOutputTokens = 0;
@@ -7901,6 +8288,7 @@ async function* streamBridgeSession(args) {
 				profile: args.profile,
 				sessionId: args.sessionId,
 				body: requestBody,
+				requiresRuntimeAttachments: args.runtimeAttachments !== void 0,
 				signal: turnController.signal,
 				run: activeRun,
 				maxReconnects: args.maxReconnects,
@@ -7925,9 +8313,22 @@ async function* streamBridgeSession(args) {
 					}
 					observedSystemFingerprint = chunk.systemFingerprint;
 				}
-				if (chunk.content) turnText += chunk.content;
+				if (chunk.content) {
+					turnText += chunk.content;
+					yield {
+						kind: "progress",
+						progress: {
+							kind: "text_delta",
+							text: chunk.content
+						}
+					};
+				}
 				for (const step of chunk.toolCalls ?? []) {
-					toolCalls.push(step.toolName);
+					toolCalls.push({
+						...step.callId === void 0 ? {} : { id: step.callId },
+						name: step.toolName,
+						arguments: step.args
+					});
 					observation.activity.push({
 						at: Date.now(),
 						kind: "tool",
@@ -7935,6 +8336,15 @@ async function* streamBridgeSession(args) {
 						...describeToolArgs(step.args) ? { detail: describeToolArgs(step.args) } : {}
 					});
 					args.record(step);
+					yield {
+						kind: "progress",
+						progress: {
+							kind: "tool_call",
+							toolName: step.toolName,
+							...step.callId === void 0 ? {} : { toolCallId: step.callId },
+							args: step.args
+						}
+					};
 				}
 				if (chunk.usage) {
 					sawTurnTokenUsage = true;
@@ -7958,6 +8368,7 @@ async function* streamBridgeSession(args) {
 						if (chunk.usage.promptCache.writeInput !== void 0) promptCache.writeTokens = (promptCache.writeTokens ?? 0) + chunk.usage.promptCache.writeInput;
 					}
 				}
+				if (chunk.costProvenance !== void 0) turnCostProvenance = chunk.costProvenance;
 				if (chunk.costKnown !== void 0) {
 					sawTurnCostStatus = true;
 					if (!chunk.costKnown) turnUsdKnown = false;
@@ -7971,7 +8382,9 @@ async function* streamBridgeSession(args) {
 						usd += increment;
 						yield {
 							kind: "cost",
-							usd: increment
+							usdKnown: true,
+							usd: increment,
+							provenance: turnCostProvenance ?? "provider-receipt"
 						};
 					}
 				}
@@ -8016,9 +8429,10 @@ async function* streamBridgeSession(args) {
 			}) : {
 				kind: "cost",
 				usd: 0,
-				usdKnown: false
+				usdKnown: false,
+				provenance: "uncaptured"
 			};
-			if (priced.usdEstimated !== void 0) estimatedUsdCharged += priced.usdEstimated;
+			if (priced.usdKnown === false && priced.usdEstimated !== void 0) estimatedUsdCharged += priced.usdEstimated;
 			usd += priced.usd;
 			yield priced;
 		}
@@ -8072,7 +8486,7 @@ const BRIDGE_BRUTAL_KILL_WAIT_MS = 150;
 * cannot prove continuity fails instead of returning a plausible partial answer.
 */
 async function* streamDurableBridgeRun(args) {
-	await assertBridgeExecutionCapabilities(args.seam, args.signal);
+	await assertBridgeExecutionCapabilities(args.seam, args.signal, args.requiresRuntimeAttachments);
 	let reconnects = 0;
 	let pendingUpstreamError;
 	for (;;) {
@@ -8151,7 +8565,7 @@ async function* streamDurableBridgeRun(args) {
 * a process may restart behind the same URL, and a remembered capability from the prior process
 * is not evidence about the process that will receive the next POST. The terminal receipt remains
 * mandatory because the bridge can still restart between this GET and the run request. */
-async function assertBridgeExecutionCapabilities(seam, signal) {
+async function assertBridgeExecutionCapabilities(seam, signal, requiresRuntimeAttachments) {
 	const target = new URL(`${seam.bridgeUrl.replace(/\/$/, "")}/`);
 	const requestFn = target.protocol === "https:" ? request$1 : request;
 	const response = await new Promise((resolve, reject) => {
@@ -8192,6 +8606,10 @@ async function assertBridgeExecutionCapabilities(seam, signal) {
 	}
 	if (body.capabilities?.profileMaterialization !== bridgeProfileMaterializationSchema) throw new ValidationError(`bridgeExecutor: bridge does not advertise ${bridgeProfileMaterializationSchema}`);
 	if (body.capabilities?.usageCostProvenance !== bridgeUsageCostSchema) throw new ValidationError(`bridgeExecutor: bridge does not advertise ${bridgeUsageCostSchema}`);
+	if (requiresRuntimeAttachments) {
+		const attachments = body.capabilities?.runtimeAttachments;
+		if (attachments === null || typeof attachments !== "object" || attachments.mcp !== true) throw new ValidationError(`bridgeExecutor: bridge at ${seam.bridgeUrl} does not advertise capabilities.runtimeAttachments.mcp; upgrade cli-bridge to a version that carries Runtime MCP attachments outside the bound AgentProfile`);
+	}
 }
 /**
 * POST one streamed turn to the cli-bridge over the `node:http(s)` core client
@@ -8801,6 +9219,7 @@ function applyBridgeCostReceipt(out, usage) {
 		if (cost === void 0 || provenance !== "provider-receipt" && provenance !== "billing-receipt" || estimatedCost !== void 0) throw new ValidationError("bridgeExecutor: known cost requires cost plus provider-receipt or billing-receipt provenance");
 		out.costKnown = true;
 		out.cost = cost;
+		out.costProvenance = provenance;
 		return;
 	}
 	if (cost !== void 0) throw new ValidationError("bridgeExecutor: unknown cost cannot carry billed cost");
@@ -9251,13 +9670,14 @@ function createExecutor(config) {
 							}
 						}
 					};
-					return {
-						...sandboxExecutor({
-							...spec,
-							harness
-						}, providerCtx),
+					const executor = sandboxExecutor({
+						...spec,
+						harness
+					}, providerCtx);
+					return inheritRuntimeOwnedExecutorAttestation(executor, {
+						...executor,
 						runtime: providerSeam.runtime ?? provider.name
-					};
+					});
 				}
 				const profileForCreate = providerSeam.profileForCreate;
 				return providerAsExecutor(provider, {
@@ -9359,6 +9779,15 @@ function readOptionalAbortSignal(ctx, key, who) {
 	if (value === null || typeof value !== "object" || typeof value.aborted !== "boolean" || typeof value.addEventListener !== "function") throw new ValidationError(`${who} executor: seam "${key}" must be an AbortSignal`);
 	return value;
 }
+/** Narrow the Runtime-owned MCP attachment seam. Absent means the run mounts nothing; a present
+*  value must be a named map of MCP servers, never an empty one that would silently mount nothing. */
+function readOptionalMcpAttachments(ctx, key, who) {
+	const value = ctx.seams[key];
+	if (value === void 0) return void 0;
+	const entries = value !== null && typeof value === "object" && !Array.isArray(value) ? Object.entries(value) : void 0;
+	if (entries === void 0 || entries.length === 0 || entries.some(([, server]) => server === null || typeof server !== "object")) throw new ValidationError(`${who} executor: seam ${JSON.stringify(key)} must be a non-empty map of MCP servers`);
+	return value;
+}
 /** A leaf task is opaque (`unknown`). A string is the prompt verbatim; an object
 *  with a `prompt`/`content`/`task` string field uses it; otherwise it serializes.
 *  Module-exported (not package surface) so sibling leaf executors read a task
@@ -9408,10 +9837,12 @@ function routerProfileExecution(profile, seam, mode) {
 		if (enabled && !suppliedNames.has(name)) throw new ValidationError(`routerInlineExecutor: AgentProfile enables tool ${JSON.stringify(name)} but the caller supplied no matching schema`);
 		if (!enabled && suppliedNames.has(name)) throw new ValidationError(`routerInlineExecutor: AgentProfile disables tool ${JSON.stringify(name)}`);
 	}
+	const { tokenLimits, ...rest } = settings;
 	return {
 		systemPrompt: renderRouterProfilePrompt(profile),
 		...profileEffort ? { reasoningEffort: profileEffort } : {},
-		...settings
+		...rest,
+		tokenLimits: enforceTokenLimits(tokenLimits, "router", "routerInlineExecutor")
 	};
 }
 /** Resolve the one model id that will cross the Router boundary from the exact profile only. */
@@ -9694,56 +10125,61 @@ function assertValidSpend(spend, label) {
 *  channels; iterations come from `'iteration'` events. Pure; `ms` stays zero (the
 *  pool does not read wall-clock). */
 function spendFromUsageEvents(events) {
-	const tokens = zeroTokenUsage();
-	let tokensKnown = true;
-	let usd = 0;
-	let usdEstimated = 0;
-	let usdKnown = true;
-	let iterations = 0;
-	for (const ev of events) if (ev.kind === "tokens") {
-		addTokenUsage(tokens, ev);
-		if (ev.tokensKnown === false) tokensKnown = false;
-	} else if (ev.kind === "cost") {
-		usd += ev.usd;
-		usdEstimated += ev.usdEstimated ?? 0;
-		if (ev.usdKnown === false) usdKnown = false;
-	} else iterations += 1;
+	const totals = newUsageTotals();
+	for (const ev of events) meterUsageEvent(totals, ev);
+	return spendFromUsageTotals(totals);
+}
+/** Fresh zeroed {@link UsageTotals}. */
+function newUsageTotals() {
 	return {
-		iterations,
-		tokens,
-		...tokensKnown ? {} : { tokensKnown: false },
-		usd,
-		...usdKnown ? {} : { usdKnown: false },
-		...usdEstimated > 0 ? { usdEstimated } : {},
-		ms: 0
+		tokens: zeroTokenUsage(),
+		tokensKnown: true,
+		usd: 0,
+		usdEstimated: 0,
+		usdKnown: true,
+		iterations: 0
 	};
 }
-async function foldUsage(events) {
-	if (Array.isArray(events)) return spendFromUsageEvents(events);
-	const tokens = zeroTokenUsage();
-	let tokensKnown = true;
-	let usd = 0;
-	let usdEstimated = 0;
-	let usdKnown = true;
-	let iterations = 0;
-	for await (const ev of events) if (ev.kind === "tokens") {
-		addTokenUsage(tokens, ev);
-		if (ev.tokensKnown === false) tokensKnown = false;
-	} else if (ev.kind === "cost") {
-		usd += ev.usd;
-		usdEstimated += ev.usdEstimated ?? 0;
-		if (ev.usdKnown === false) usdKnown = false;
-	} else iterations += 1;
+/**
+* Fold ONE usage event into running totals — the single place that decides which event kinds
+* meter. `progress` carries observed output rather than accounting, so it meters nothing; only
+* `iteration` advances the iteration count.
+*/
+function meterUsageEvent(totals, ev) {
+	if (ev.kind === "tokens") {
+		addTokenUsage(totals.tokens, ev);
+		if (ev.tokensKnown === false) totals.tokensKnown = false;
+		return;
+	}
+	if (ev.kind === "cost") {
+		totals.usd += ev.usd;
+		if (ev.usdKnown === false) {
+			totals.usdEstimated += ev.usdEstimated ?? 0;
+			totals.usdKnown = false;
+		}
+		return;
+	}
+	if (ev.kind === "iteration") totals.iterations += 1;
+}
+/** Project folded totals onto the conserved-pool `Spend`. `ms` stays zero — the pool does not
+*  read wall-clock. */
+function spendFromUsageTotals(totals) {
 	return {
-		iterations,
-		tokens,
-		...tokensKnown ? {} : { tokensKnown: false },
-		usd,
-		...usdKnown ? {} : { usdKnown: false },
-		...usdEstimated > 0 ? { usdEstimated } : {},
+		iterations: totals.iterations,
+		tokens: totals.tokens,
+		...totals.tokensKnown ? {} : { tokensKnown: false },
+		usd: totals.usd,
+		...totals.usdKnown ? {} : { usdKnown: false },
+		...totals.usdEstimated > 0 ? { usdEstimated: totals.usdEstimated } : {},
 		ms: 0
 	};
 }
+async function foldUsage(events) {
+	if (Array.isArray(events)) return spendFromUsageEvents(events);
+	const totals = newUsageTotals();
+	for await (const ev of events) meterUsageEvent(totals, ev);
+	return spendFromUsageTotals(totals);
+}
 /**
 * Create a conserved reservation pool from a root `Budget`. `now()` is injected so the
 * deadline readout is deterministic; defaults to `Date.now` for non-test callers. The
@@ -10546,7 +10982,7 @@ function createScope(args) {
 			spec = prepared.spec;
 			identity = prepared.identity;
 			if (opts.key !== void 0 && !isCompleteIdentity(identity)) {
-				args.pool.reconcile(reservation.ticket, zeroSpend$1());
+				args.pool.reconcile(reservation.ticket, zeroSpend());
 				permit.release();
 				return {
 					ok: false,
@@ -10557,7 +10993,7 @@ function createScope(args) {
 			if (!outcome.succeeded) throw new ValidationError(`scope.spawn: ${outcome.error}`);
 			resolved = outcome;
 		} catch (error) {
-			args.pool.reconcile(reservation.ticket, zeroSpend$1());
+			args.pool.reconcile(reservation.ticket, zeroSpend());
 			permit.release();
 			throw error;
 		}
@@ -10622,7 +11058,7 @@ function createScope(args) {
 				label: opts.label,
 				...opts.assignmentId === void 0 ? {} : { assignmentId: opts.assignmentId },
 				...opts.key !== void 0 ? { key: opts.key } : {},
-				spent: zeroSpend$1(),
+				spent: zeroSpend(),
 				settled: void 0,
 				delivered: false,
 				executorDone: false,
@@ -10632,7 +11068,10 @@ function createScope(args) {
 				lastActivityAt: startedAt,
 				...executor.deliver ? { deliver: (message) => executor.deliver?.(message) !== false } : {},
 				...executor.progress ? { readProgress: executor.progress.bind(executor) } : {},
-				...executor.traceSource ? { readTraceSource: executor.traceSource.bind(executor) } : {}
+				...executor.traceSource ? { readTraceSource: executor.traceSource.bind(executor) } : {},
+				...executor.interactive ? { readInteractive: executor.interactive.bind(executor) } : {},
+				...executor.cancel ? { requestCancel: executor.cancel.bind(executor) } : {},
+				abortChild: (reason) => controller.abort(reason)
 			};
 			children.set(id, live);
 			if (opts.key !== void 0) keyed.set(opts.key, {
@@ -10640,7 +11079,8 @@ function createScope(args) {
 				id,
 				identity
 			});
-			const spawnCommitted = args.journal.appendEvent(args.root, {
+			const profileRef = contentAddress(spec.profile);
+			const spawnCommitted = args.blobs.put(profileRef, spec.profile).then(() => args.journal.appendEvent(args.root, {
 				kind: "spawned",
 				id,
 				parent: args.parentId,
@@ -10651,9 +11091,10 @@ function createScope(args) {
 				runtime: executor.runtime,
 				...ownedTreeRoot === void 0 ? {} : { ownedTreeRoot },
 				...identity ? { identity } : {},
+				profileRef,
 				seq: ordinal,
 				at: new Date(now()).toISOString()
-			}).then(async () => {
+			})).then(async () => {
 				if (args.workerTraceUnpropagated === void 0 || workerTrace === void 0) return;
 				await args.journal.appendEvent(args.root, {
 					kind: "trace-unpropagated",
@@ -10786,7 +11227,9 @@ function createScope(args) {
 					runtime: executor.runtime,
 					...identity ? { identity } : {},
 					budget: opts.budget,
-					depth: args.depth
+					depth: args.depth,
+					attemptId,
+					startedAt
 				}
 			}, { signal: args.signal });
 			live.settled = runChild(live, executor, controller, task, opts, args.pool, reservation.ticket, args.blobs, now, materializationCommitted, {
@@ -10809,7 +11252,7 @@ function createScope(args) {
 			permit.release();
 			clearChildDeadline?.();
 			if (cascadeAbort) args.signal.removeEventListener("abort", cascadeAbort);
-			args.pool.reconcile(reservation.ticket, zeroSpend$1());
+			args.pool.reconcile(reservation.ticket, zeroSpend());
 			throw err;
 		}
 	}
@@ -10903,12 +11346,13 @@ function createScope(args) {
 			id,
 			status: "waiting",
 			runtime: "wait",
+			abortChild: (reason) => waitAbort.abort(reason),
 			budget: {
 				maxIterations: 0,
 				maxTokens: 0
 			},
 			label: opts.label,
-			spent: zeroSpend$1(),
+			spent: zeroSpend(),
 			settled: void 0,
 			delivered: false,
 			executorDone: false,
@@ -10981,7 +11425,7 @@ function createScope(args) {
 				kind: "done",
 				out: resolution.outcome,
 				outRef,
-				spent: zeroSpend$1(),
+				spent: zeroSpend(),
 				trace: {
 					status: "unavailable",
 					reason: "not-an-executor"
@@ -11032,6 +11476,18 @@ function createScope(args) {
 			...child.spent.usdKnown === false ? { usdKnown: false } : {}
 		}, fromExecutor, opts.now ?? now(), opts.stallAfterMs ?? 18e4);
 	}
+	async function cancel(nodeId, request) {
+		const child = children.get(nodeId);
+		if (!child) throw new ValidationError(`scope.cancel: unknown node ${JSON.stringify(nodeId)}`);
+		if (child.requestCancel) return await child.requestCancel(request);
+		child.abortChild("cancelled");
+		return {
+			status: "unknown",
+			effect: "cancel_requested",
+			observedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			detail: `executor runtime ${JSON.stringify(child.runtime ?? "unknown")} exposes no cancellation operation; the child was aborted locally`
+		};
+	}
 	function traceSource(nodeId) {
 		const child = children.get(nodeId);
 		if (!child) return void 0;
@@ -11041,6 +11497,24 @@ function createScope(args) {
 			return;
 		}
 	}
+	function terminalNodeStatus(status) {
+		return status === "done" || status === "failed" || status === "cancelled";
+	}
+	function interactive(nodeId) {
+		const child = children.get(nodeId);
+		if (!child) return noInteractiveSession("unknown-node");
+		if (child.wait || child.executorDone || terminalNodeStatus(child.status)) return noInteractiveSession("not-live");
+		if (!child.readInteractive) return noInteractiveSession("executor-exposes-no-interactive-session");
+		let reported;
+		try {
+			reported = child.readInteractive();
+		} catch {
+			return noInteractiveSession("executor-exposes-no-interactive-session");
+		}
+		if (reported?.status === "unavailable" && reported.reason) return reported;
+		if (reported?.status === "available" && reported.handle) return reported;
+		return noInteractiveSession("executor-exposes-no-interactive-session");
+	}
 	async function meterInternal(spend, detail, providerModel, accountingOnly = false) {
 		if (args.signal.aborted) throw new ValidationError("scope.meter: cannot record new driver work after scope abort");
 		const seq = meterSeq++;
@@ -11088,6 +11562,8 @@ function createScope(args) {
 		wait,
 		progress,
 		traceSource,
+		interactive,
+		cancel,
 		signal: args.signal,
 		meter: (spend, detail) => meterInternal(spend, detail),
 		...resume ? { resume } : {},
@@ -11100,7 +11576,13 @@ function createScope(args) {
 		get workerCapacity() {
 			return {
 				live: liveWorkerCapacity.live,
-				freeSlots: freeSlots(liveWorkerCapacity.live, liveWorkerCapacity.max)
+				freeSlots: freeSlots(liveWorkerCapacity.live, liveWorkerCapacity.max),
+				unconfirmed: Object.freeze([...children.values()].filter((child) => (child.status === "done" || child.status === "failed" || child.status === "cancelled") && !child.cleanupConfirmed).map((child) => Object.freeze({
+					id: child.id,
+					label: child.label,
+					runtime: child.runtime,
+					status: child.status
+				})))
 			};
 		}
 	};
@@ -11340,7 +11822,9 @@ async function finalizeSettlement(child, settlement, seq, args, now) {
 				status: "down",
 				reason: settlement.reason,
 				infra: settlement.infra,
-				spent: child.spent
+				spent: child.spent,
+				restartCount: settlement.restartCount,
+				...settledNodeEvidence(child, settlement, settledAt)
 			}
 		}, { signal: args.signal });
 		return {
@@ -11393,7 +11877,8 @@ async function finalizeSettlement(child, settlement, seq, args, now) {
 			outRef: settlement.outRef,
 			score: settlement.verdict?.score,
 			valid: settlement.verdict?.valid,
-			spent: settlement.spent
+			spent: settlement.spent,
+			...settledNodeEvidence(child, settlement, settledAt)
 		}
 	}, { signal: args.signal });
 	return {
@@ -11409,6 +11894,26 @@ async function finalizeSettlement(child, settlement, seq, args, now) {
 		seq
 	};
 }
+/**
+* The evidence a settled node carries beyond its status: the receipts that name what actually
+* ran, the own-inference spend the parent tree re-homes as a `metered` event, and the wall-clock
+* window. One builder feeds BOTH terminal paths, so an observer never sees a `down` node
+* described in different terms from a `done` one. Every field is omitted when the fact is
+* absent — an unreported receipt must not read as an empty one. Snapshots are detached because
+* an observer may serialize them after the live child has moved on.
+*/
+function settledNodeEvidence(child, settlement, settledAt) {
+	return {
+		runtime: child.runtime,
+		startedAt: child.startedAt,
+		settledAt,
+		...settlement.metered ? { metered: detachedSnapshot(settlement.metered, "metered") } : {},
+		...child.providerModel ? { providerModel: detachedSnapshot(child.providerModel, "provider model evidence") } : {},
+		...child.materialization ? { materialization: detachedSnapshot(child.materialization, "materialization receipt") } : {},
+		...child.executionBindings.length > 0 ? { executionBindings: detachedSnapshot([...child.executionBindings], "execution binding receipts") } : {},
+		trace: detachedSnapshot(settlement.trace, "worker trace evidence")
+	};
+}
 /** Journal a wait-state's settlement as a `woken` event and project it onto the same `Settled`
 *  the driver branches on. `by` names WHY it woke — `fired` / `timeout` / `cancelled` — which is
 *  the fact a resumed reader needs and cannot recover from a payload it may never fetch. */
@@ -11720,30 +12225,20 @@ function freezeCorrelation(value) {
 * now reconciles its real partial spend instead of refunding work the provider already billed.
 */
 async function foldStream(stream, onProgress, signal) {
-	const tokens = zeroTokenUsage();
-	let tokensKnown = true;
-	let usd = 0;
-	let usdKnown = true;
-	let iterations = 0;
+	const totals = newUsageTotals();
 	const iterator = stream[Symbol.asyncIterator]();
 	try {
 		for (;;) {
 			const next = signal ? await awaitAbortable(Promise.resolve(iterator.next()), signal) : await iterator.next();
 			if (next.done) break;
 			const ev = next.value;
-			if (ev.kind === "tokens") {
-				addTokenUsage(tokens, ev);
-				if (ev.tokensKnown === false) tokensKnown = false;
-			} else if (ev.kind === "cost") {
-				usd += ev.usd;
-				if (ev.usdKnown === false) usdKnown = false;
-			} else iterations += 1;
+			meterUsageEvent(totals, ev);
 			onProgress?.({
-				iterations,
-				tokens: cloneTokenUsage(tokens),
-				...tokensKnown ? {} : { tokensKnown: false },
-				usd,
-				...usdKnown ? {} : { usdKnown: false },
+				iterations: totals.iterations,
+				tokens: cloneTokenUsage(totals.tokens),
+				...totals.tokensKnown ? {} : { tokensKnown: false },
+				usd: totals.usd,
+				...totals.usdKnown ? {} : { usdKnown: false },
 				ms: 0
 			});
 		}
@@ -11751,14 +12246,7 @@ async function foldStream(stream, onProgress, signal) {
 		Promise.resolve(iterator.return?.()).catch(() => void 0);
 		throw error;
 	}
-	return {
-		iterations,
-		tokens,
-		...tokensKnown ? {} : { tokensKnown: false },
-		usd,
-		...usdKnown ? {} : { usdKnown: false },
-		ms: 0
-	};
+	return spendFromUsageTotals(totals);
 }
 /** Usage events carry measured increments; the terminal artifact carries whether a provider omitted
 * a whole accounting channel. Preserve those unknowns on the common streaming path. */
@@ -11819,13 +12307,12 @@ function downRecord(reason, infra, trace, metered, providerModel) {
 		...metered ? { metered } : {}
 	};
 }
-function zeroSpend$1() {
-	return {
-		iterations: 0,
-		tokens: zeroTokenUsage(),
-		usd: 0,
-		ms: 0
-	};
+/** The one place an absent interactive process is spelled, so every refusal reads the same. */
+function noInteractiveSession(reason) {
+	return Object.freeze({
+		status: "unavailable",
+		reason
+	});
 }
 function isAsyncIterable(value) {
 	return typeof value === "object" && value !== null && typeof value[Symbol.asyncIterator] === "function";
@@ -11944,7 +12431,7 @@ const driverExecutorFactory = (rawSpec, ctx) => {
 				meteredSpend = nonZeroOrUndef(sumMetered(events));
 				accounting = {
 					reported: childWork,
-					reservation: addSpend$1(childWork, meteredSpend ?? zeroSpend())
+					reservation: addSpend(childWork, meteredSpend ?? zeroSpend())
 				};
 				const verdict = deriveDeliveryVerdict(settled, out);
 				artifact = {
@@ -12028,12 +12515,7 @@ function isSettled(ev) {
 /** Sum the conserved spend over the nested tree's settled events — the honest per-channel
 *  roll-up of the whole sub-tree's child WORK. */
 function sumSpend(settled) {
-	const total = {
-		iterations: 0,
-		tokens: zeroTokenUsage(),
-		usd: 0,
-		ms: 0
-	};
+	const total = zeroSpend();
 	for (const ev of settled) {
 		total.iterations += ev.spent.iterations;
 		addTokenUsage(total.tokens, ev.spent.tokens);
@@ -12048,12 +12530,7 @@ function sumSpend(settled) {
 *  own turns + any sub-driver inference already re-homed into this tree). Re-homed up to the parent
 *  as one `metered` event; never reconciled (already pool-debited live via `observe`). */
 function sumMetered(events) {
-	const total = {
-		iterations: 0,
-		tokens: zeroTokenUsage(),
-		usd: 0,
-		ms: 0
-	};
+	const total = zeroSpend();
 	for (const ev of events) {
 		if (ev.kind !== "metered") continue;
 		total.iterations += ev.spend.iterations;
@@ -12065,28 +12542,6 @@ function sumMetered(events) {
 	}
 	return total;
 }
-function zeroSpend() {
-	return {
-		iterations: 0,
-		tokens: zeroTokenUsage(),
-		usd: 0,
-		ms: 0
-	};
-}
-function addSpend$1(a, b) {
-	return {
-		iterations: a.iterations + b.iterations,
-		tokens: (() => {
-			const tokens = cloneTokenUsage(a.tokens);
-			addTokenUsage(tokens, b.tokens);
-			return tokens;
-		})(),
-		...a.tokensKnown === false || b.tokensKnown === false ? { tokensKnown: false } : {},
-		usd: a.usd + b.usd,
-		...a.usdKnown === false || b.usdKnown === false ? { usdKnown: false } : {},
-		ms: a.ms + b.ms
-	};
-}
 /** An all-zero spend that carries an UNKNOWN marker counts as non-zero: a sub-driver whose turns
 *  went unmeasured did real work, and dropping its `metered` event here would re-hide upstream the
 *  very turn the driver refused to skip. */
@@ -12109,7 +12564,7 @@ async function safeRollup(journal, nestedRoot) {
 			metered,
 			accounting: {
 				reported: childWork,
-				reservation: addSpend$1(childWork, metered ?? zeroSpend())
+				reservation: addSpend(childWork, metered ?? zeroSpend())
 			}
 		};
 	} catch {
@@ -12622,6 +13077,8 @@ function createSupervisor() {
 				ok: false,
 				error: new RuntimeRunStateError("supervisor: root execution did not start")
 			};
+			let teardownUnconfirmed = [];
+			let teardownSeq = 0;
 			let executionAborted = controller.signal.aborted;
 			let allChildrenDownAtSettle = false;
 			let downCountAtSettle = 0;
@@ -12643,7 +13100,16 @@ function createSupervisor() {
 				clearRootDeadline?.();
 				const settleGraceMs = actOutcome.ok === false && !controller.signal.aborted ? boundedSettleGrace(opts.childSettleGraceMs, rootDeadlineAtMs, now) : 0;
 				try {
-					await drainLiveChildren(openScope, controller, settleGraceMs);
+					teardownUnconfirmed = await drainLiveChildren(openScope, controller, settleGraceMs);
+					for (const node of teardownUnconfirmed) await opts.journal.appendEvent(opts.runId, {
+						kind: "teardown-unconfirmed",
+						id: node.id,
+						label: node.label,
+						runtime: node.runtime,
+						status: node.status,
+						seq: teardownSeq++,
+						at: new Date(now()).toISOString()
+					});
 				} catch (error) {
 					if (actOutcome?.ok !== false) actOutcome = {
 						ok: false,
@@ -12677,6 +13143,7 @@ function createSupervisor() {
 						tree,
 						spentTotal,
 						providerModel,
+						...teardownUnconfirmed.length > 0 ? { teardownUnconfirmed } : {},
 						...gaps.length > 0 ? { spendGaps: gaps } : {},
 						...isNonEmptySpend(driverInference) ? { spentBreakdown: {
 							driverInference,
@@ -12695,6 +13162,7 @@ function createSupervisor() {
 					downCount: breaker.downCount(),
 					spentTotal,
 					providerModel,
+					...teardownUnconfirmed.length > 0 ? { teardownUnconfirmed } : {},
 					...gaps.length > 0 ? { spendGaps: gaps } : {}
 				};
 				const lifecycle = classifyNoWinner(executionAborted, pool, opts, breaker, deadlineExceeded, allChildrenDownAtSettle, downCountAtSettle);
@@ -12839,10 +13307,7 @@ function wrapJournalForBreaker(journal, breaker) {
 */
 async function drainLiveChildren(scope, controller, settleGraceMs = 0) {
 	const view = scope.view;
-	if (!(view.inFlight > 0 || view.waiting > 0)) {
-		if (scope.workerCapacity.live > 0) throw new RuntimeRunStateError(`supervisor: cleanup ended with ${scope.workerCapacity.live} executor resource(s) not confirmed destroyed`);
-		return;
-	}
+	if (!(view.inFlight > 0 || view.waiting > 0)) return unconfirmedTeardowns(scope);
 	let graceTimer;
 	if (settleGraceMs > 0 && !controller.signal.aborted) {
 		graceTimer = setTimeout(() => controller.abort("root driver failed; child settle grace expired"), settleGraceMs);
@@ -12854,7 +13319,26 @@ async function drainLiveChildren(scope, controller, settleGraceMs = 0) {
 		if (graceTimer !== void 0) clearTimeout(graceTimer);
 	}
 	const after = scope.view;
-	if (after.inFlight > 0 || after.waiting > 0 || scope.workerCapacity.live > 0) throw new RuntimeRunStateError(`supervisor: cleanup ended with ${after.inFlight} running, ${after.waiting} waiting, and ${scope.workerCapacity.live} executor resource(s) not confirmed destroyed`);
+	if (after.inFlight > 0 || after.waiting > 0) throw new RuntimeRunStateError(`supervisor: cleanup ended with ${after.inFlight} running, ${after.waiting} waiting, and ` + describeUnconfirmed(scope));
+	return unconfirmedTeardowns(scope);
+}
+/**
+* The settled children whose executor teardown was never acknowledged.
+*
+* They still hold their capacity slot — the ledger stays poisoned, so replacement work can never
+* exceed the physical live count — but every one of them has already reached a terminal state and
+* journaled its work. That is evidence about an EXECUTOR, not a cause of run failure, so the
+* barrier NAMES them and lets the run reach its real terminal state. Live work after the drain is
+* a different fault and still fails loud.
+*/
+function unconfirmedTeardowns(scope) {
+	return scope.workerCapacity.unconfirmed;
+}
+/** The unconfirmed set as one error clause: the count plus the node ids behind it. One integer is
+*  not actionable after a six-hour run. */
+function describeUnconfirmed(scope) {
+	const named = scope.workerCapacity.unconfirmed.map((node) => `${node.id} (${node.label}, ${node.runtime}, ${node.status})`).join(", ");
+	return `${scope.workerCapacity.live} executor resource(s) not confirmed destroyed${named.length > 0 ? `: ${named}` : ""}`;
 }
 /** The settle window a failed driver's children actually get: the caller's grace, never past the
 *  run's own deadline. `0` (the default) keeps the historical immediate cascade. */
@@ -13019,23 +13503,6 @@ function accumulate(a, b) {
 	if (b.usdEstimated !== void 0) a.usdEstimated = (a.usdEstimated ?? 0) + b.usdEstimated;
 	a.ms += b.ms;
 }
-/** Sum two conserved-spend tallies per channel — the child-work journal sum + the drivers' own
-*  metered inference, so `spentTotal` is the true cost of the run. */
-function addSpend(a, b) {
-	return {
-		iterations: a.iterations + b.iterations,
-		tokens: (() => {
-			const tokens = cloneTokenUsage(a.tokens);
-			addTokenUsage(tokens, b.tokens);
-			return tokens;
-		})(),
-		...a.tokensKnown === false || b.tokensKnown === false ? { tokensKnown: false } : {},
-		usd: a.usd + b.usd,
-		...a.usdKnown === false || b.usdKnown === false ? { usdKnown: false } : {},
-		...usdEstimatedOf(a, b),
-		ms: a.ms + b.ms
-	};
-}
 /** True when any driver metered inference this run (so the winner carries a `spentBreakdown`).
 *  Checks every channel `addSpend` sums — including `ms` — so the gate stays consistent with the
 *  total even though the coordination driver currently stamps `ms: 0`. */
@@ -13043,6 +13510,6 @@ function isNonEmptySpend(s) {
 	return s.iterations > 0 || s.tokens.input > 0 || s.tokens.output > 0 || s.usd > 0 || s.ms > 0 || s.tokensKnown === false || s.usdKnown === false;
 }
 //#endregion
-export { createInbox as $, AGENT_PROFILE_MATERIALIZATION_AXES as $t, createBudgetPool as A, exportEvalRuns as At, WORKER_TRACE_PROPAGATION as B, sanitizeKnowledgeReadinessReport as Bt, effectiveConcurrency as C, traceContextToEnv as Ct, DEFAULT_SUCCESSFUL_SHUTDOWN_MS as D, buildRuntimeEventOtelSpans as Dt, rollingDispatch as E, buildLoopSpanNodes as Et, cliWorktreeExecutor as F, padTraceId as Ft, DEFAULT_SANDBOX_STEERING_MAX_TURNS as G, createWorktree as Gt, workerTraceEnv as H, runSettledCommand as Ht, createExecutor as I, toOtelAttributes as It, decodeToolPart as J, LOCAL_HARNESSES as Jt, createSteerableSandboxSession as K, removeWorktree as Kt, createExecutorRegistry as L, createRuntimeEventCollector as Lt, bindReusableExecutorExecutionId as M, generateSpanId as Mt, bridgeStopSignalKey as N, loopEventToOtelSpan as Nt, teardownExecutor as O, createOpenInferenceFileExporter as Ot, captureReusableExecutorConfig as P, padSpanId as Pt, readWorkerProgress as Q, CodexExecutionDiagnosticError as Qt, snapshotExecutorConfig as R, createRuntimeStreamEventCollector as Rt, waitUntil as S, readTraceContextFromEnv as St, queueOf as T, buildLoopOtelSpans as Tt, workerTraceHeaders as U, runWorktreeHarness as Ut, readWorkerTraceContext as V, sanitizeRuntimeStreamEvent as Vt, workerTraceSeamKey as W, captureWorktreeDiff as Wt, DEFAULT_STALL_AFTER_MS as X, localHarnessExecutable as Xt, sandboxSessionTraceSource as Y, harnessSupportsReasoningEffort as Yt, createActivityLog as Z, parseCodexTokenUsage as Zt, createWaitProbes as _, runBrainLoop as _t, pickBestDelivered as a, promptControlProfileMaterialization as an, isPeerMailEnvelope as at, timerAt as b, createPropagatingTraceEmitter as bt, driverChild as c, promptResourceProfileMaterialization as cn, TERMINAL_DECISIONS as ct, deriveNodeExecutionIdentity as d, validateProfileMaterialization as dn, isTerminalDecision as dt, assertProfileMaterialization as en, AUTHORITY_MARKERS as et, meterRuntimeOwnedAccounting as f, worktreeCliProfileMaterialization as fn, runAgentRounds as ft, settledToIteration as g, routerBrain as gt, scopeOwnerExecutorNodeContext as h, acquireSandbox as ht, collectDelivered as i, profileMaterializationAxes$1 as in, createPeerMailbox as it, spendFromUsageEvents as j, flatOtelSpan as jt, assertValidBudget as k, createOtelExporter as kt, withDriverExecutor as l, renderProfileMaterializationIssues as ln, createSandboxForSpec as lt, recordScopeOwnerMaterialization as m, probeSandboxCapabilities as mt, createSupervisor as n, defineProfileMaterializationContract as nn, PEER_MAIL_WIRE_KEY as nt, runFinalizer as o, promptModelProfileMaterialization as on, peerMailTools as ot, meterRuntimeOwnedProviderAttempt as p, createSandboxLineage as pt, createPushTraceSource as q, DEFAULT_LOCAL_HARNESS as qt, bestDelivered as r, fullProfileMaterialization as rn, claimsAuthority as rt, runTree as s, promptOnlyProfileMaterialization as sn, peerMailVerbNames as st, createRootHandle as t, controlProfileMaterialization as tn, DEFAULT_PEER_MAIL_LIMITS as tt, createScope as u, sandboxActProfileMaterialization as un, defaultSelectWinner as ut, isWaitOutcome as v, canonicalObservedModel as vt, freeSlots as w, INTELLIGENCE_WIRE_VERSION as wt, validateWaitSpec as x, mergeTraceEnv as xt, pollFor as y, observedModelMatchesDeclared as yt, createWorktreeCliExecutor as z, sanitizeAgentRuntimeEvent as zt };
+export { DEFAULT_STALL_AFTER_MS as $, localHarnessExecutable as $t, createBudgetPool as A, buildRuntimeEventOtelSpans as At, createExecutorRegistry as B, createRuntimeEventCollector as Bt, effectiveConcurrency as C, createPropagatingTraceEmitter as Ct, DEFAULT_SUCCESSFUL_SHUTDOWN_MS as D, INTELLIGENCE_WIRE_VERSION as Dt, rollingDispatch as E, traceContextToEnv as Et, bridgeRuntimeAttachmentsKey as F, generateSpanId as Ft, workerTraceEnv as G, runSettledCommand as Gt, createWorktreeCliExecutor as H, sanitizeAgentRuntimeEvent as Ht, bridgeStopSignalKey as I, loopEventToOtelSpan as It, DEFAULT_SANDBOX_STEERING_MAX_TURNS as J, createWorktree as Jt, workerTraceHeaders as K, runWorktreeHarness as Kt, captureReusableExecutorConfig as L, padSpanId as Lt, bindReusableExecutorExecutionId as M, createOtelExporter as Mt, bridgeAdmissionRead as N, exportEvalRuns as Nt, teardownExecutor as O, buildLoopOtelSpans as Ot, bridgeModelRouteRefusal as P, flatOtelSpan as Pt, sandboxSessionTraceSource as Q, harnessSupportsReasoningEffort as Qt, cliWorktreeExecutor as R, padTraceId as Rt, waitUntil as S, observedModelMatchesDeclared as St, queueOf as T, readTraceContextFromEnv as Tt, WORKER_TRACE_PROPAGATION as U, sanitizeKnowledgeReadinessReport as Ut, snapshotExecutorConfig as V, createRuntimeStreamEventCollector as Vt, readWorkerTraceContext as W, sanitizeRuntimeStreamEvent as Wt, createPushTraceSource as X, DEFAULT_LOCAL_HARNESS as Xt, createSteerableSandboxSession as Y, removeWorktree as Yt, decodeToolPart as Z, LOCAL_HARNESSES as Zt, createWaitProbes as _, worktreeCliProfileMaterialization as _n, probeSandboxCapabilities as _t, pickBestDelivered as a, defineProfileMaterializationContract as an, PEER_MAIL_WIRE_KEY as at, timerAt as b, runBrainLoop as bt, driverChild as c, promptControlProfileMaterialization as cn, isPeerMailEnvelope as ct, deriveNodeExecutionIdentity as d, promptResourceProfileMaterialization as dn, TERMINAL_DECISIONS as dt, parseCodexTokenUsage as en, createActivityLog as et, meterRuntimeOwnedAccounting as f, renderProfileMaterializationIssues as fn, createSandboxForSpec as ft, settledToIteration as g, validateProfileMaterialization as gn, createSandboxLineage as gt, scopeOwnerExecutorNodeContext as h, unsupportedProfileDimensions as hn, runAgentRounds as ht, collectDelivered as i, controlProfileMaterialization as in, DEFAULT_PEER_MAIL_LIMITS as it, spendFromUsageEvents as j, createOpenInferenceFileExporter as jt, assertValidBudget as k, buildLoopSpanNodes as kt, withDriverExecutor as l, promptModelProfileMaterialization as ln, peerMailTools as lt, recordScopeOwnerMaterialization as m, sandboxActProfileMaterialization as mn, isTerminalDecision as mt, createSupervisor as n, AGENT_PROFILE_MATERIALIZATION_AXES as nn, createInbox as nt, runFinalizer as o, fullProfileMaterialization as on, claimsAuthority as ot, meterRuntimeOwnedProviderAttempt as p, renderUnsupported as pn, defaultSelectWinner as pt, workerTraceSeamKey as q, captureWorktreeDiff as qt, bestDelivered as r, assertProfileMaterialization as rn, AUTHORITY_MARKERS as rt, runTree as s, profileMaterializationAxes$1 as sn, createPeerMailbox as st, createRootHandle as t, CodexExecutionDiagnosticError as tn, readWorkerProgress as tt, createScope as u, promptOnlyProfileMaterialization as un, peerMailVerbNames as ut, isWaitOutcome as v, acquireSandbox as vt, freeSlots as w, mergeTraceEnv as wt, validateWaitSpec as x, canonicalObservedModel as xt, pollFor as y, routerBrain as yt, createExecutor as z, toOtelAttributes as zt };
 
-//# sourceMappingURL=supervisor-B_0ISTFG.js.map
+//# sourceMappingURL=supervisor-DBVlPONC.js.map