@tangle-network/agent-runtime 0.143.0 → 0.153.2

package/dist/{supervisor-s8SfZYbW.js → supervisor-CMZsJ7Wn.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-Dl9J8ek4.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 { i as extractLlmCallEvent, o as mapSandboxToolEvent, r as createSandboxToolPartState, s as notifySandboxEventObserver, t as assertSandboxServedModel } from "./sandbox-events-COwCWUVB.js";
-import { C as unknownExecutionBindingReceipt, D as projectSandboxOutcome, 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-P86EciBw.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 { i as resolveAgentEnvironmentProvider, n as providerAsExecutor, r as providerAsSandboxClient } from "./environment-provider-DCBJ13VP.js";
+import { _ as captureWorkerTraceEvidence, a as aggregateProviderModelEvidence, c as loadSpawnForest, d as replaySpawnTree, f as attestNestedDriverTreeOwner, h as runtimeOwnedNestedDriverTreeRoot, l as materializeTreeView, m as nestedDriverTreeRoot, o as closesCursorSlot, p as driverRuntime, u as pendingWaits, x as contentAddress } from "./spawn-journal-BLnveCRS.js";
+import { _ as unmeteredSpend, a as cloneTokenUsage, b as zeroTokenUsage, 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 withTimeout, y as zeroSpend } from "./util-D6ZEuBMi.js";
+import { c as notifySandboxEventObserver, i as extractLlmCallEvent, l as sandboxEventServedBackend, r as createSandboxToolPartState, s as mapSandboxToolEvent, t as assertSandboxServedModel, u as sandboxProgressEvents } from "./sandbox-events-BVjstFgb.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 { c as linkAbort, i as resolveAgentEnvironmentProvider, l as runAbortable, n as providerAsExecutor, r as providerAsSandboxClient, s as abortError } from "./environment-provider-3eCszBEm.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";
@@ -218,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 "";
@@ -1803,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,
@@ -3328,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",
@@ -3343,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 } : {}
 	});
@@ -3457,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",
@@ -3465,6 +3506,7 @@ function toolCompletionBody(cfg, messages, tools, opts) {
 			"tool_choice",
 			"temperature",
 			"max_tokens",
+			"max_completion_tokens",
 			"seed",
 			"reasoning_effort",
 			"stream",
@@ -3478,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 } : {}
 	};
@@ -5141,14 +5184,47 @@ function hashJson(value) {
 //#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 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" ? [{
@@ -5180,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;
@@ -5192,10 +5269,41 @@ function priceUnreceiptedWork(work) {
 		kind: "cost",
 		usd,
 		usdKnown: false,
-		usdEstimated: usd
+		usdEstimated: usd,
+		provenance: "catalog-estimate"
 	};
 }
 //#endregion
+//#region src/runtime/supervise/node-status.ts
+/**
+* Which {@link NodeStatus} values mean the node is finished.
+*
+* `'waiting'` is deliberately NOT terminal: a wait-state node holds no executor, no box and no
+* conserved budget, so it is neither in flight nor settled. Callers that must also exclude it say
+* so at their own site, because "finished" and "not a live worker" are different questions.
+*/
+const terminalNodeStatuses = /* @__PURE__ */ new Set([
+	"done",
+	"failed",
+	"cancelled"
+]);
+/**
+* True once a node has reached a terminal status.
+*
+* The single owner of this rule. Written per call site it drifts silently: a status added to
+* `NodeStatus` is classified by whichever sites the author remembered, and the ones they missed
+* keep a dead node in the live set — a stop rule that never fires, mail delivered to a worker that
+* cannot read it, or a cancel answered `not_live` for a node that is still running.
+*/
+function isTerminalNodeStatus(status) {
+	return terminalNodeStatuses.has(status);
+}
+/** True while a node has not yet reached a terminal status. The complement of
+*  {@link isTerminalNodeStatus}, so the two can never disagree. */
+function isLiveNodeStatus(status) {
+	return !terminalNodeStatuses.has(status);
+}
+//#endregion
 //#region src/runtime/supervise/peer-mail.ts
 /**
 *
@@ -5281,7 +5389,6 @@ function isPeerMailEnvelope(value) {
 function isPeerMailKind(value) {
 	return value === "ask" || value === "tell" || value === "challenge" || value === "answer";
 }
-const isLiveStatus = (status) => status !== "done" && status !== "failed" && status !== "cancelled";
 /** Create the run's post office. One per manager scope; the manager's siblings are its addresses. */
 function createPeerMailbox(opts) {
 	const limits = Object.freeze({
@@ -5321,7 +5428,7 @@ function createPeerMailbox(opts) {
 		await opts.publish(event);
 		return event;
 	};
-	const liveNodes = () => opts.scope.view.nodes.filter((node) => isLiveStatus(node.status));
+	const liveNodes = () => opts.scope.view.nodes.filter((node) => isLiveNodeStatus(node.status));
 	const mailbox = {
 		limits,
 		setEndpoint(baseUrl) {
@@ -5396,7 +5503,7 @@ function createPeerMailbox(opts) {
 			if (opts.scope.signal.aborted) return record(envelope, "scope-stopped");
 			const node = opts.scope.view.nodes.find((candidate) => candidate.id === to);
 			if (node === void 0) return record(envelope, "unknown-worker");
-			if (!isLiveStatus(node.status)) return record(envelope, "already-settled");
+			if (!isLiveNodeStatus(node.status)) return record(envelope, "already-settled");
 			let delivered = false;
 			try {
 				delivered = opts.scope.send(to, { [PEER_MAIL_WIRE_KEY]: envelope });
@@ -5623,6 +5730,29 @@ function createInbox() {
 }
 //#endregion
 //#region src/runtime/supervise/progress.ts
+/**
+*
+* The LIVE read-model of a still-RUNNING worker — what a driver can see BEFORE the worker settles.
+*
+* Until this existed, `observe_agent` on a running worker returned `{status:'running', spent:{0,0},
+* outRef:null, output:null}`: nothing a brain could act on, so a brain that wanted to steer had no
+* evidence to steer FROM. This is the other half of the steering wire (the first half is
+* `Executor.deliver`): a supervisor cannot correct a worker it cannot watch.
+*
+* Two layers, both pull-based — no timer, no background task, so it is safe to leave on:
+*
+*   - The SCOPE layer, available for EVERY executor with no executor cooperation at all: usage
+*     events are timestamped as they arrive, so `lastActivityAt` / `idleMs` / `stalled` /
+*     `tokens` / `turns` are derived from the stream the conserved pool already meters.
+*   - The EXECUTOR layer, optional enrichment via `Executor.progress()`: the tool/file activity
+*     the harness exposes, its own turn count, and how many steers are queued but unread.
+*
+* `stalled` is a DERIVED read, computed at observation time against `stallAfterMs` — never a
+* background watchdog. A worker that has produced no metered activity for longer than the
+* threshold reads `stalled: true`; nothing is killed, nothing is retried. The driver decides.
+*
+* @experimental
+*/
 /** How long a worker may produce no metered activity before a `progress()` read calls it stalled.
 *  Deliberately generous: a coding harness routinely spends minutes inside one tool call, and a
 *  false stall that provokes a steer is worse than a late one. */
@@ -5665,7 +5795,7 @@ function createActivityLog(limit = 12) {
 /** Fold the scope-derived facts and the executor's optional enrichment into one read. Pure: the
 *  caller supplies `now`, so a test can observe a stall without waiting for one. */
 function readWorkerProgress(scope, executor, now, stallAfterMs = DEFAULT_STALL_AFTER_MS) {
-	const live = scope.status !== "done" && scope.status !== "failed" && scope.status !== "cancelled";
+	const live = isLiveNodeStatus(scope.status);
 	const executorActivityAt = executor?.recentActivity?.length ? executor.recentActivity[executor.recentActivity.length - 1].at : 0;
 	const lastActivityAt = Math.max(scope.lastActivityAt, executorActivityAt);
 	const idleMs = Math.max(0, now - lastActivityAt);
@@ -5915,13 +6045,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;
@@ -5945,7 +6083,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);
@@ -5971,6 +6121,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) {
@@ -6016,7 +6167,10 @@ function createSteerableSandboxSession(args) {
 					} else events = await lineage.continue(handle, prompt, turnController.signal, promptOptions);
 					for await (const event of events) {
 						outcomeTracker.observe(event);
-						recordEvent(event);
+						for (const progress of recordEvent(event)) yield {
+							kind: "progress",
+							progress
+						};
 						const call = extractLlmCallEvent(event, spec.name ?? String(args.harness));
 						if (call) {
 							sawLlmCall = true;
@@ -6040,7 +6194,8 @@ function createSteerableSandboxSession(args) {
 								yield {
 									kind: "cost",
 									usd: call.costUsd,
-									usdKnown: false
+									usdKnown: false,
+									provenance: "uncaptured"
 								};
 							}
 						}
@@ -6087,7 +6242,8 @@ function createSteerableSandboxSession(args) {
 		if (state.turns > 0) yield {
 			kind: "cost",
 			usd: 0,
-			usdKnown: false
+			usdKnown: false,
+			provenance: "uncaptured"
 		};
 		const spent = {
 			iterations: state.turns,
@@ -6099,8 +6255,10 @@ 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;
@@ -6116,6 +6274,60 @@ function createSteerableSandboxSession(args) {
 	}
 	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(),
@@ -6133,14 +6345,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. */
@@ -6341,7 +6555,7 @@ function createWorktreeCliExecutor(options) {
 		runtime: "cli",
 		budgetExempt,
 		async execute(task, signal) {
-			const linked = linkSignals$1(signal, controller.signal);
+			const linked = linkSignals(signal, controller.signal);
 			const started = Date.now();
 			const taskPrompt = executionTaskPrompt(task, options.taskPrompt);
 			run = await runWorktreeHarness({
@@ -6468,7 +6682,7 @@ function executionTaskPrompt(task, configuredPrompt) {
 }
 /** Link two abort signals into one that fires when either does. Returns `undefined` when neither
 *  is present so the harness runner gets no signal at all. */
-function linkSignals$1(a, b) {
+function linkSignals(a, b) {
 	if (a.aborted || b.aborted) {
 		const c = new AbortController();
 		c.abort();
@@ -6548,6 +6762,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";
@@ -6646,36 +6865,6 @@ function contentRef(prefix, value) {
 	return `${prefix}:${(h >>> 0).toString(16).padStart(8, "0")}`;
 }
 /**
-* The spend of work that HAPPENED and reported no usage receipt.
-*
-* Not the same value as a plain zero even though both carry `{0,0}` tokens and `$0`. A bare zero
-* asserts a MEASUREMENT — "this ran and cost nothing" — and every consumer downstream reads it that
-* way: the pool keeps reporting `readout().tokensKnown === true`, the journal totals stay clean, the
-* OTEL span records a priced zero, and a caller's token-denominated ceiling can never fire no matter
-* how much the work really burned. A ceiling that cannot fire is worse than no ceiling, because it
-* reads as protection.
-*
-* `Spend.tokensKnown` is the marker the substrate already threads end to end for exactly this case
-* (`budget.ts`, `otel-spans.ts`, `spawn-journal.ts`, `supervisor.ts`): the work is recorded, the
-* zero is labelled a floor rather than a total, and every rollup that touches it reports its balance
-* as a ceiling rather than a measurement. Use this — never a bare zero — whenever a runtime cannot
-* see what its worker spent.
-*
-* The same rule applies to dollars. A dollar-capped run must refuse an executor whose billed spend
-* is unknowable; `budgetExempt` does not authorize Runtime to relabel unknown spend as a measured
-* zero. Callers that require dollar accounting must use a backend with a trusted billing receipt.
-*/
-function unmeteredSpend(ms) {
-	return {
-		iterations: 0,
-		tokens: zeroTokenUsage(),
-		tokensKnown: false,
-		usd: 0,
-		usdKnown: false,
-		ms
-	};
-}
-/**
 * A direct OpenAI-compatible Router chat-completion. One-shot: resolves a
 * `ExecutorResult` and reports its terminal usage as `UsageEvent`s through the
 * conserved pool. Reports REAL token usage — when the provider omits `usage`,
@@ -6686,18 +6875,26 @@ 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");
 	if (!seam.routerBaseUrl || !seam.routerKey) throw new ValidationError("routerInlineExecutor: RouterSeam.routerBaseUrl + routerKey required");
 	const profileExecution = routerProfileExecution(spec.profile, seam, { multiTurn: false });
 	const requestIdentity = routerRequestIdentity(ctx);
-	const controller = new AbortController();
-	const abortIfSignalled = () => {
-		if (ctx.signal.aborted) controller.abort();
-	};
-	abortIfSignalled();
-	if (!ctx.signal.aborted) ctx.signal.addEventListener("abort", abortIfSignalled, { once: true });
+	const controller = linkAbort(ctx.signal);
 	let artifact;
 	const executionId = ctx.node?.nodeId ?? `router-request-${randomUUID()}`;
 	const attemptId = ctx.node?.attemptId ?? newExecutionAttemptId(executionId);
@@ -6707,7 +6904,7 @@ const routerInlineExecutor = (spec, ctx) => {
 		async execute(task, signal) {
 			const messages = taskToMessages(task, spec, profileExecution.systemPrompt);
 			const started = Date.now();
-			const linked = linkSignals(signal, controller.signal);
+			const linked = linkAbort(signal, controller.signal).signal;
 			const extraBody = {
 				...profileExecution.extraBody ?? {},
 				...profileExecution.reasoningEffort ? { reasoning_effort: profileExecution.reasoningEffort } : {}
@@ -6723,7 +6920,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
@@ -6736,7 +6933,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 } : {},
@@ -6748,7 +6945,7 @@ const routerInlineExecutor = (spec, ctx) => {
 				tokens: r.usage ? cloneTokenUsage({
 					input: r.usage.input,
 					output: r.usage.output,
-					...routerPromptCacheUsage(r.usage.input, r.cache)
+					...promptCacheTokenClasses(r.usage.input, r.cache)
 				}) : zeroTokenUsage(),
 				usd: r.billedCostUsd ?? 0,
 				...r.usage ? {} : { tokensKnown: false },
@@ -6777,6 +6974,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 });
@@ -6805,7 +7006,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,
@@ -6843,22 +7044,6 @@ function mergePromptCache(target, cache) {
 	}
 	if (cache.status !== void 0) target.status = cache.status;
 }
-/** Preserve a complete Router cache split; an incomplete provider receipt stays unknown. */
-function routerPromptCacheUsage(input, cache) {
-	if (cache === void 0) return {};
-	const read = cache.readTokens;
-	const write = cache.writeTokens;
-	if (read === void 0 && write === void 0) return {};
-	if (input === void 0 || !isCacheTokenCount(read) || !isCacheTokenCount(write) || read + write > input) return { cacheBreakdownKnown: false };
-	return {
-		freshInput: input - read - write,
-		cacheRead: read,
-		cacheWrite: write
-	};
-}
-function isCacheTokenCount(value) {
-	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
-}
 async function runRouterTransport(context, call) {
 	try {
 		return await call();
@@ -6886,12 +7071,7 @@ const routerToolsInlineExecutor = (spec, ctx) => {
 	const enabledToolNames = new Set(seam.tools.map((tool) => tool.function.name));
 	const maxTurns = profileExecution.maxTurns ?? 0;
 	const requestIdentity = routerRequestIdentity(ctx);
-	const controller = new AbortController();
-	const abortIfSignalled = () => {
-		if (ctx.signal.aborted) controller.abort();
-	};
-	abortIfSignalled();
-	if (!ctx.signal.aborted) ctx.signal.addEventListener("abort", abortIfSignalled, { once: true });
+	const controller = linkAbort(ctx.signal);
 	const inbox = createInbox();
 	let artifact;
 	const executionId = ctx.node?.nodeId ?? `router-tools-run-${randomUUID()}`;
@@ -6917,6 +7097,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({
@@ -6925,7 +7106,7 @@ const routerToolsInlineExecutor = (spec, ctx) => {
 				});
 				return pending.length > 0;
 			};
-			const external = mergeAbortSignals(signal, controller.signal);
+			const external = linkAbort(signal, controller.signal).signal;
 			try {
 				for (let t = 0; maxTurns === 0 || t < maxTurns; t += 1) {
 					flush();
@@ -6949,7 +7130,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 } : {},
@@ -6978,12 +7159,12 @@ const routerToolsInlineExecutor = (spec, ctx) => {
 						addTokenUsage(tokens, {
 							input: res.usage.input,
 							output: res.usage.output,
-							...routerPromptCacheUsage(res.usage.input, res.cache)
+							...promptCacheTokenClasses(res.usage.input, res.cache)
 						});
 						if (res.usage.reasoning !== void 0) reasoningTokens += res.usage.reasoning;
 						else reasoningKnown = false;
 					} else {
-						addTokenUsage(tokens, routerPromptCacheUsage(void 0, res.cache));
+						addTokenUsage(tokens, promptCacheTokenClasses(void 0, res.cache));
 						tokensKnown = false;
 						reasoningKnown = false;
 					}
@@ -7015,6 +7196,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",
@@ -7085,7 +7271,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 } : {},
@@ -7101,6 +7287,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 });
@@ -7131,7 +7321,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,
@@ -7190,13 +7380,9 @@ 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 = () => {
-		if (ctx.signal.aborted) controller.abort();
-	};
-	abortIfSignalled();
-	if (!ctx.signal.aborted) ctx.signal.addEventListener("abort", abortIfSignalled, { once: true });
+	const controller = linkAbort(ctx.signal);
 	let artifact;
 	const executionId = ctx.node?.nodeId ?? `sandbox-run-${randomUUID()}`;
 	const attemptId = ctx.node?.attemptId ?? newExecutionAttemptId(executionId);
@@ -7220,7 +7406,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 = {
@@ -7255,6 +7442,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);
@@ -7296,6 +7484,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 });
@@ -7307,14 +7499,7 @@ const sandboxExecutor = (spec, ctx) => {
 	}, sandboxMaterialization, sandboxBinding);
 };
 async function* streamSandboxLeaf(args) {
-	const linked = new AbortController();
-	const cascadeExternal = () => linked.abort(abortReasonOf(args.signal));
-	const cascadeScope = () => linked.abort(abortReasonOf(args.controller.signal));
-	if (args.signal.aborted || args.controller.signal.aborted) linked.abort(abortReasonOf(args.signal.aborted ? args.signal : args.controller.signal));
-	else {
-		args.signal.addEventListener("abort", cascadeExternal, { once: true });
-		args.controller.signal.addEventListener("abort", cascadeScope, { once: true });
-	}
+	const linked = linkAbort(args.signal, args.controller.signal);
 	const agentRun = {
 		profile: args.spec.profile,
 		taskToPrompt: (t) => taskToPrompt(t),
@@ -7390,14 +7575,19 @@ 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,
-			...usdKnown ? {} : { usdKnown: false }
+			provenance: "provider-receipt"
+		} : {
+			kind: "cost",
+			usdKnown: false,
+			usd: result.costUsd,
+			provenance: "uncaptured"
 		};
 	} finally {
-		args.signal.removeEventListener("abort", cascadeExternal);
-		args.controller.signal.removeEventListener("abort", cascadeScope);
+		linked.release();
 	}
 }
 /** The loop's own failure, when NO iteration produced an output: the first error it
@@ -7443,12 +7633,7 @@ const cliExecutor = (_spec, ctx) => {
 	const seam = readSeam(ctx, cliSeamKey, "cli");
 	if (!seam.bin) throw new ValidationError("cliExecutor: CliSeam.bin required");
 	const traceEnv = workerTraceEnv(ctx);
-	const controller = new AbortController();
-	const abortIfSignalled = () => {
-		if (ctx.signal.aborted) controller.abort();
-	};
-	abortIfSignalled();
-	if (!ctx.signal.aborted) ctx.signal.addEventListener("abort", abortIfSignalled, { once: true });
+	const controller = linkAbort(ctx.signal);
 	let proc;
 	let artifact;
 	const executionId = ctx.node?.nodeId ?? `cli-process-${randomUUID()}`;
@@ -7592,18 +7777,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}`);
@@ -7613,12 +7800,7 @@ const bridgeExecutor = (spec, ctx) => {
 	const sessionId = seam.sessionId ?? `bridge-${spec.profile.name ?? "worker"}-${randomUUID()}`;
 	const attemptId = ctx.node?.attemptId ?? newExecutionAttemptId(sessionId);
 	const traceHeaders = workerTraceHeaders(ctx);
-	const controller = new AbortController();
-	const abortIfSignalled = () => {
-		if (ctx.signal.aborted) controller.abort();
-	};
-	abortIfSignalled();
-	if (!ctx.signal.aborted) ctx.signal.addEventListener("abort", abortIfSignalled, { once: true });
+	const controller = linkAbort(ctx.signal);
 	const inbox = createInbox();
 	let artifact;
 	const activeRuns = /* @__PURE__ */ new Map();
@@ -7651,7 +7833,7 @@ const bridgeExecutor = (spec, ctx) => {
 			maxReconnects,
 			timeoutMs: seam.timeoutMs ?? null,
 			streaming: true,
-			...seam.maxTokens !== void 0 ? { maxTokens: seam.maxTokens } : {},
+			tokenLimits: bridgeTokenLimits,
 			terminalAcknowledgement: null
 		}
 	};
@@ -7697,11 +7879,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,
@@ -7738,6 +7925,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);
@@ -7803,6 +8025,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) {
@@ -7861,7 +8155,7 @@ function readBridgeRunState(runId, body) {
 async function* streamBridgeSession(args) {
 	const { seam, inbox, observation } = args;
 	const started = Date.now();
-	const external = mergeAbortSignals(args.signal, args.controller.signal);
+	const external = linkAbort(args.signal, args.controller.signal).signal;
 	const tokens = zeroTokenUsage();
 	let tokensKnown = true;
 	let usd = 0;
@@ -7935,6 +8229,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 = "";
@@ -7943,6 +8238,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;
@@ -7965,6 +8261,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,
@@ -7989,9 +8286,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",
@@ -7999,6 +8309,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;
@@ -8022,6 +8341,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;
@@ -8035,7 +8355,9 @@ async function* streamBridgeSession(args) {
 						usd += increment;
 						yield {
 							kind: "cost",
-							usd: increment
+							usdKnown: true,
+							usd: increment,
+							provenance: turnCostProvenance ?? "provider-receipt"
 						};
 					}
 				}
@@ -8080,9 +8402,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;
 		}
@@ -8136,7 +8459,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 (;;) {
@@ -8215,7 +8538,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) => {
@@ -8256,6 +8579,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
@@ -8865,6 +9192,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");
@@ -8955,7 +9283,7 @@ function bridgeWorktreeExecutor(spec, ctx, seam) {
 		execute(task, signal) {
 			return (async function* bridgeWorktreeStream() {
 				const started = Date.now();
-				const linked = mergeAbortSignals(signal, controller.signal);
+				const linked = linkAbort(signal, controller.signal).signal;
 				let bridgeArtifact;
 				try {
 					worktree = await createWorktree({
@@ -9315,13 +9643,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, {
@@ -9423,6 +9752,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
@@ -9472,10 +9810,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. */
@@ -9555,113 +9895,6 @@ function singleShotDriver(maxIterations) {
 		}
 	};
 }
-/** Link two abort signals into one that fires when either does. Returns
-*  `undefined` when neither is present so `fetch` gets no signal at all. */
-function linkSignals(a, b) {
-	if (a.aborted || b.aborted) {
-		const c = new AbortController();
-		c.abort(abortReasonOf(a.aborted ? a : b));
-		return c.signal;
-	}
-	const c = new AbortController();
-	a.addEventListener("abort", () => c.abort(abortReasonOf(a)), { once: true });
-	b.addEventListener("abort", () => c.abort(abortReasonOf(b)), { once: true });
-	return c.signal;
-}
-/** The reason a signal carries, or a named fallback. A cascade that drops the upstream reason
-*  turns every downstream death into the generic "execution aborted": the worker's `down`
-*  record then says nothing about WHY, which is what makes a whole class of child mortality
-*  undiagnosable from the journal alone. */
-function abortReasonOf(signal, fallback = "aborted by parent scope") {
-	const reason = signal.reason;
-	if (typeof reason === "string" && reason.length > 0) return reason;
-	if (reason instanceof Error && reason.name !== "AbortError" && reason.message.length > 0) return reason.message;
-	return fallback;
-}
-/** Combine N abort signals into one that fires when ANY does. Node-portable (no `AbortSignal.any`,
-*  which needs >=20.3 — the package floor is >=20). Module-exported (not package surface) so
-*  sibling leaf executors share the one portable implementation. */
-function mergeAbortSignals(...signals) {
-	const c = new AbortController();
-	const onAbort = () => c.abort();
-	for (const s of signals) {
-		if (s.aborted) {
-			c.abort();
-			break;
-		}
-		s.addEventListener("abort", onAbort, { once: true });
-	}
-	return c.signal;
-}
-//#endregion
-//#region src/runtime/supervise/abortable.ts
-/**
-* One abort race for the supervision tree.
-*
-* Every layer that can be cancelled needs the same two things: an `AbortError` that
-* carries the signal's own reason, and a settle-once race between the work and the
-* signal. Written per layer, the race drifts — the listener stops being removed on
-* one path, or a late resolution overwrites a cancellation that already won.
-*
-* The fallback message is the only thing a layer supplies, so the error still names
-* which layer cancelled.
-*/
-/** An `AbortError` carrying the signal's own string reason, or `fallback` when it states none. */
-function abortError(signal, fallback) {
-	const reason = signal.reason;
-	const error = new Error(typeof reason === "string" && reason.length > 0 ? reason : fallback);
-	error.name = "AbortError";
-	return error;
-}
-/**
-* Settle `act()` against `signal`. The first outcome wins and the listener is always
-* removed, so neither a late resolution nor a late abort can settle the promise twice.
-* The losing promise stays observed, so a late rejection cannot surface as an unhandled
-* process error.
-*
-* The abort rejection is deferred one microtask so a result the action had ALREADY
-* produced still wins. It does not hand the race to a listener the action registers
-* from inside `act()`: this function subscribes before it calls `act()`, so its own
-* abort handler runs first and settles the promise. A caller that must let the action
-* observe the abort itself has to hold a live promise and await that instead.
-*
-* A synchronous throw from `act()` propagates as the rejection, not as an abort.
-*/
-async function runAbortable(act, signal, fallback) {
-	if (signal.aborted) throw abortError(signal, fallback);
-	return await new Promise((resolve, reject) => {
-		let settled = false;
-		const cleanup = () => signal.removeEventListener("abort", onAbort);
-		const onAbort = () => {
-			queueMicrotask(() => {
-				if (settled) return;
-				settled = true;
-				cleanup();
-				reject(abortError(signal, fallback));
-			});
-		};
-		signal.addEventListener("abort", onAbort, { once: true });
-		let work;
-		try {
-			work = Promise.resolve(act());
-		} catch (error) {
-			cleanup();
-			reject(error);
-			return;
-		}
-		work.then((value) => {
-			if (settled) return;
-			settled = true;
-			cleanup();
-			resolve(value);
-		}, (error) => {
-			if (settled) return;
-			settled = true;
-			cleanup();
-			reject(error);
-		});
-	});
-}
 //#endregion
 //#region src/runtime/supervise/budget.ts
 /**
@@ -9758,56 +9991,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
@@ -10610,7 +10848,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,
@@ -10621,7 +10859,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;
 		}
@@ -10686,7 +10924,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,
@@ -10696,7 +10934,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, {
@@ -10704,7 +10945,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,
@@ -10715,9 +10957,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",
@@ -10850,7 +11093,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, {
@@ -10873,7 +11118,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;
 		}
 	}
@@ -10967,12 +11212,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,
@@ -11045,7 +11291,7 @@ function createScope(args) {
 				kind: "done",
 				out: resolution.outcome,
 				outRef,
-				spent: zeroSpend$1(),
+				spent: zeroSpend(),
 				trace: {
 					status: "unavailable",
 					reason: "not-an-executor"
@@ -11096,6 +11342,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;
@@ -11105,6 +11363,21 @@ function createScope(args) {
 			return;
 		}
 	}
+	function interactive(nodeId) {
+		const child = children.get(nodeId);
+		if (!child) return noInteractiveSession("unknown-node");
+		if (child.wait || child.executorDone || isTerminalNodeStatus(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++;
@@ -11152,6 +11425,8 @@ function createScope(args) {
 		wait,
 		progress,
 		traceSource,
+		interactive,
+		cancel,
 		signal: args.signal,
 		meter: (spend, detail) => meterInternal(spend, detail),
 		...resume ? { resume } : {},
@@ -11164,7 +11439,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) => isTerminalNodeStatus(child.status) && !child.cleanupConfirmed).map((child) => Object.freeze({
+					id: child.id,
+					label: child.label,
+					runtime: child.runtime,
+					status: child.status
+				})))
 			};
 		}
 	};
@@ -11404,7 +11685,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 {
@@ -11457,7 +11740,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 {
@@ -11473,6 +11757,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. */
@@ -11784,30 +12088,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
 			});
 		}
@@ -11815,14 +12109,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. */
@@ -11883,13 +12170,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";
@@ -12008,7 +12294,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 = {
@@ -12092,64 +12378,13 @@ 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
-	};
-	for (const ev of settled) {
-		total.iterations += ev.spent.iterations;
-		addTokenUsage(total.tokens, ev.spent.tokens);
-		if (ev.spent.tokensKnown === false) total.tokensKnown = false;
-		total.usd += ev.spent.usd;
-		if (ev.spent.usdKnown === false) total.usdKnown = false;
-		total.ms += ev.spent.ms;
-	}
-	return total;
+	return settled.reduce((total, ev) => addSpend(total, ev.spent), zeroSpend());
 }
 /** Sum the nested tree's `metered` events — the sub-tree's whole driver INFERENCE (this driver's
 *  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
-	};
-	for (const ev of events) {
-		if (ev.kind !== "metered") continue;
-		total.iterations += ev.spend.iterations;
-		addTokenUsage(total.tokens, ev.spend.tokens);
-		if (ev.spend.tokensKnown === false) total.tokensKnown = false;
-		total.usd += ev.spend.usd;
-		if (ev.spend.usdKnown === false) total.usdKnown = false;
-		total.ms += ev.spend.ms;
-	}
-	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
-	};
+	return events.reduce((total, ev) => ev.kind === "metered" ? addSpend(total, ev.spend) : total, zeroSpend());
 }
 /** 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
@@ -12173,7 +12408,7 @@ async function safeRollup(journal, nestedRoot) {
 			metered,
 			accounting: {
 				reported: childWork,
-				reservation: addSpend$1(childWork, metered ?? zeroSpend())
+				reservation: addSpend(childWork, metered ?? zeroSpend())
 			}
 		};
 	} catch {
@@ -12491,7 +12726,7 @@ function rootDeadline(root) {
 }
 /** Child reservations whose spawn was durable but whose terminal record never landed. */
 function uncertainSpawnBudgets(events) {
-	const terminal = new Set(events.filter((event) => event.kind === "settled" || event.kind === "cancelled" || event.kind === "woken").map((event) => event.id));
+	const terminal = new Set(events.filter(closesCursorSlot).map((event) => event.id));
 	return events.filter((event) => event.kind === "spawned" && event.parent !== void 0 && !terminal.has(event.id)).map((event) => event.budget);
 }
 /** Highest `seq` among events matching `pred`, or `-1` when none match (so a resumed scope's
@@ -12591,7 +12826,7 @@ function createSupervisor() {
 					settled,
 					view: materializeTreeView(prior),
 					maxSpawnOrdinal: maxSeqOf(prior, (ev) => ev.kind === "spawned"),
-					maxCursorSeq: maxSeqOf(prior, (ev) => ev.kind === "settled" || ev.kind === "cancelled" || ev.kind === "woken"),
+					maxCursorSeq: maxSeqOf(prior, closesCursorSlot),
 					maxWaitOrdinal: maxSeqOf(prior, (ev) => ev.kind === "waiting"),
 					waits: pendingWaits(prior),
 					keys: keyedAssignments(prior, settled),
@@ -12686,6 +12921,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;
@@ -12707,7 +12944,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,
@@ -12741,6 +12987,7 @@ function createSupervisor() {
 						tree,
 						spentTotal,
 						providerModel,
+						...teardownUnconfirmed.length > 0 ? { teardownUnconfirmed } : {},
 						...gaps.length > 0 ? { spendGaps: gaps } : {},
 						...isNonEmptySpend(driverInference) ? { spentBreakdown: {
 							driverInference,
@@ -12759,6 +13006,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);
@@ -12903,10 +13151,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);
@@ -12918,7 +13163,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. */
@@ -13002,7 +13266,7 @@ function spendGapsFromEvents(events) {
 	const labels = /* @__PURE__ */ new Map();
 	const terminal = /* @__PURE__ */ new Set();
 	for (const ev of events) if (ev.kind === "spawned") labels.set(ev.id, ev.label);
-	else if (ev.kind === "settled" || ev.kind === "cancelled" || ev.kind === "woken") terminal.add(ev.id);
+	else if (closesCursorSlot(ev)) terminal.add(ev.id);
 	const gaps = /* @__PURE__ */ new Map();
 	const record = (id, kind, channels) => {
 		if (channels.length === 0) return;
@@ -13054,52 +13318,15 @@ function sumSpendFromEvents(events) {
 	return totals;
 }
 function sumMeasuredSpendFromEvents(events) {
-	const childWork = {
-		iterations: 0,
-		tokens: zeroTokenUsage(),
-		usd: 0,
-		ms: 0
-	};
-	const driverInference = {
-		iterations: 0,
-		tokens: zeroTokenUsage(),
-		usd: 0,
-		ms: 0
-	};
-	for (const ev of events) if (ev.kind === "settled") accumulate(childWork, ev.spent);
-	else if (ev.kind === "metered") accumulate(driverInference, ev.spend);
+	let childWork = zeroSpend();
+	let driverInference = zeroSpend();
+	for (const ev of events) if (ev.kind === "settled") childWork = addSpend(childWork, ev.spent);
+	else if (ev.kind === "metered") driverInference = addSpend(driverInference, ev.spend);
 	return {
 		childWork,
 		driverInference
 	};
 }
-/** Add `b` into `a` in place, per channel. */
-function accumulate(a, b) {
-	a.iterations += b.iterations;
-	addTokenUsage(a.tokens, b.tokens);
-	if (b.tokensKnown === false) a.tokensKnown = false;
-	a.usd += b.usd;
-	if (b.usdKnown === false) a.usdKnown = false;
-	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`. */
@@ -13107,6 +13334,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 $, LOCAL_HARNESSES as $t, createBudgetPool as A, buildLoopOtelSpans as At, createExecutorRegistry as B, padTraceId as Bt, effectiveConcurrency as C, canonicalObservedModel as Ct, DEFAULT_SUCCESSFUL_SHUTDOWN_MS as D, readTraceContextFromEnv as Dt, rollingDispatch as E, mergeTraceEnv as Et, bridgeRuntimeAttachmentsKey as F, exportEvalRuns as Ft, workerTraceEnv as G, sanitizeKnowledgeReadinessReport as Gt, createWorktreeCliExecutor as H, createRuntimeEventCollector as Ht, bridgeStopSignalKey as I, flatOtelSpan as It, DEFAULT_SANDBOX_STEERING_MAX_TURNS as J, runWorktreeHarness as Jt, workerTraceHeaders as K, sanitizeRuntimeStreamEvent as Kt, captureReusableExecutorConfig as L, generateSpanId as Lt, bindReusableExecutorExecutionId as M, buildRuntimeEventOtelSpans as Mt, bridgeAdmissionRead as N, createOpenInferenceFileExporter as Nt, teardownExecutor as O, traceContextToEnv as Ot, bridgeModelRouteRefusal as P, createOtelExporter as Pt, sandboxSessionTraceSource as Q, DEFAULT_LOCAL_HARNESS as Qt, cliWorktreeExecutor as R, loopEventToOtelSpan as Rt, waitUntil as S, runBrainLoop as St, queueOf as T, createPropagatingTraceEmitter as Tt, WORKER_TRACE_PROPAGATION as U, createRuntimeStreamEventCollector as Ut, snapshotExecutorConfig as V, toOtelAttributes as Vt, readWorkerTraceContext as W, sanitizeAgentRuntimeEvent as Wt, createPushTraceSource as X, createWorktree as Xt, createSteerableSandboxSession as Y, captureWorktreeDiff as Yt, decodeToolPart as Z, removeWorktree as Zt, createWaitProbes as _, unsupportedProfileDimensions as _n, runAgentRounds as _t, pickBestDelivered as a, assertProfileMaterialization as an, PEER_MAIL_WIRE_KEY as at, timerAt as b, acquireSandbox as bt, driverChild as c, fullProfileMaterialization as cn, isPeerMailEnvelope as ct, deriveNodeExecutionIdentity as d, promptModelProfileMaterialization as dn, isLiveNodeStatus as dt, harnessSupportsReasoningEffort as en, createActivityLog as et, meterRuntimeOwnedAccounting as f, promptOnlyProfileMaterialization as fn, isTerminalNodeStatus as ft, settledToIteration as g, sandboxActProfileMaterialization as gn, isTerminalDecision as gt, scopeOwnerExecutorNodeContext as h, renderUnsupported as hn, defaultSelectWinner as ht, collectDelivered as i, AGENT_PROFILE_MATERIALIZATION_AXES as in, DEFAULT_PEER_MAIL_LIMITS as it, spendFromUsageEvents as j, buildLoopSpanNodes as jt, assertValidBudget as k, INTELLIGENCE_WIRE_VERSION as kt, withDriverExecutor as l, profileMaterializationAxes$1 as ln, peerMailTools as lt, recordScopeOwnerMaterialization as m, renderProfileMaterializationIssues as mn, createSandboxForSpec as mt, createSupervisor as n, parseCodexTokenUsage as nn, createInbox as nt, runFinalizer as o, controlProfileMaterialization as on, claimsAuthority as ot, meterRuntimeOwnedProviderAttempt as p, promptResourceProfileMaterialization as pn, TERMINAL_DECISIONS as pt, workerTraceSeamKey as q, runSettledCommand as qt, bestDelivered as r, CodexExecutionDiagnosticError as rn, AUTHORITY_MARKERS as rt, runTree as s, defineProfileMaterializationContract as sn, createPeerMailbox as st, createRootHandle as t, localHarnessExecutable as tn, readWorkerProgress as tt, createScope as u, promptControlProfileMaterialization as un, peerMailVerbNames as ut, isWaitOutcome as v, validateProfileMaterialization as vn, createSandboxLineage as vt, freeSlots as w, observedModelMatchesDeclared as wt, validateWaitSpec as x, routerBrain as xt, pollFor as y, worktreeCliProfileMaterialization as yn, probeSandboxCapabilities as yt, createExecutor as z, padSpanId as zt };
 
-//# sourceMappingURL=supervisor-s8SfZYbW.js.map
+//# sourceMappingURL=supervisor-CMZsJ7Wn.js.map