@tangle-network/agent-runtime 6.0.8 → 8.0.0

package/dist/{supervisor-1A27fE6k.js → supervisor-Dpeu7rnZ.js}

@@ -1,15 +1,16 @@
-import { $ as hasRetriableTeardowns, $r as linkAbort, An as mergeTraceEnv, Ar as recordRuntimeOwnedProviderModel, Br as executableAgentProfileSnapshot, Cr as knownMaterializationReceipt, D as prepareScopeResume, Dn as workerTraceEnv, Dr as recordRuntimeOwnedProviderAttemptStart, E as resolveWorkerSlots, En as WORKER_TRACE_PROPAGATION, Gr as RetainedRunProviderContractError, Ht as scopeRetainedOwnerCheckpointing, Ir as runtimeOwnedScopeOwnerControl, It as scopeRetainedOwnerSettled, Jn as harnessTranscriptFromLines, Jr as exactSession, Jt as ownedTreeRootSpawn, K as assertRecursiveReservationPolicy, Kn as captureHarnessTranscript, Kr as assertEventBinding, Lr as runtimeOwnedScopeOwnerRuntime, Mr as runtimeOwnedExecutorExecutionBinding, N as nestedScopeSeamKey, Nr as runtimeOwnedExecutorMaterialization, O as sumSpendFromEvents, On as workerTraceHeaders, Or as recordRuntimeOwnedProviderDispatchNotStarted, Q as closeScopeAdmission, Qr as abortReason, Qt as nestedDriverTreeRoot, Rr as unknownExecutionBindingReceipt, Sr as knownExecutionBindingReceipt, Tn as environmentGone, Tt as finalizeScopeOwnerMaterialization, U as appendTeardownConfirmation, V as appendSpawnEvents, Vr as executableAgentSpecSnapshot, W as reenteredWorkers, Wn as HARNESS_TRANSCRIPT_SETTLE_TIMEOUT_MS, Wt as bindScopeRetainedOwnerProvider, Xr as sameControlCoordinates, Xt as attestNestedDriverTreeOwner, Yn as harnessTranscriptUnavailable, Yr as freezeControlRef, Z as closeRetainedSlots, Zr as RunCancellationReason, Zt as driverRuntime, br as finalizeRuntimeOwnedPendingExecutor, cn as stopRetainedNativeExecution, ct as releaseRetainedEnvironments, dn as mintRetainedIdentity, dt as startScopeRecoveries, ei as runAbortable, en as encodeResultBlob, fn as reconnectRetainedRun, ft as unconfirmedTeardowns, gr as attestRuntimeOwnedPendingExecutor, hr as attestRuntimeOwnedExecutor, in as executorObservation, ir as describeToolArgs, kr as recordRuntimeOwnedProviderIdentityConflict, ln as verifyWorkspaceMarker, lt as retryUnconfirmedTeardowns, mn as startRetainedRun, mr as attestRuntimeOwnedDeferredExecutor, nn as closesCursorSlot, on as observeModelRequest, or as isLiveNodeStatus, ot as registerNestedTeardownScope, pn as recoverRetainedRun, pr as subscriptionUsageLimitSignal, pt as waitForScopeChildren, qr as awaitAbortable, qt as loadSpawnForest, ri as promptOptionsFromAgentTurnInput, rr as createActivityLog, sn as describeRetainedNativeStops, st as releaseHeldEnvironments, t as createScope, tn as SpawnEventIndex, un as assertRetainedRunReplayMaterial, ut as settleManagerWork, wr as newExecutionAttemptId, xr as inheritRuntimeOwnedExecutorAttestation, zr as unknownMaterializationReceipt } from "./scope-gIYQ5ZiL.js";
-import { f as RuntimeRunStateError, i as ConfigError, m as ValidationError$1, r as BackendTransportError, t as AgentEvalError } from "./errors-AzSuGI23.js";
-import { A as withBudgetResources, C as unreportedSpend, D as addResourceSpend, E as zeroTokenUsage, F as ROOT_DEADLINE_REASON, H as teardownSurfaces, I as armDeadlineTimer, S as unmeteredSpend, T as zeroSpend, _ as roundBoxMinutes, b as throwAbort, c as errorMessage, d as isAbortError, f as isAsyncIterable, g as randomUuid, h as randomSuffix, j as ACCEPTED_RESULT_GRACE_MS, m as promptCacheTokenClasses, n as addSpend, o as cloneTokenUsage, p as mapWithConcurrency, r as addTokenUsage, s as deleteBoxSafe, v as sleep, w as withTimeout, x as throwIfAborted, y as stringifySafe, z as isDeadlineAbortReason } from "./util-C_cdPNC4.js";
+import { $n as harnessTranscriptFromLines, $r as awaitAbortable, $t as ownedTreeRootSpawn, An as environmentGone, Bt as scopeRetainedOwnerSettled, Dr as knownExecutionBindingReceipt, Er as inheritRuntimeOwnedExecutorAttestation, Fn as mergeTraceEnv, Fr as recordRuntimeOwnedProviderModel, G as appendSpawnEvents, Gr as executableAgentProfileSnapshot, Hr as runtimeOwnedScopeOwnerRuntime, J as reenteredWorkers, Jt as bindScopeRetainedOwnerProvider, Kr as executableAgentSpecSnapshot, Kt as scopeRetainedOwnerCheckpointing, L as nestedScopeSeamKey, Lr as runtimeOwnedExecutorExecutionBinding, M as prepareScopeResume, Mn as workerTraceEnv, Mr as recordRuntimeOwnedProviderAttemptStart, Nn as workerTraceHeaders, Nr as recordRuntimeOwnedProviderDispatchNotStarted, Or as knownMaterializationReceipt, Pr as recordRuntimeOwnedProviderIdentityConflict, Qr as assertEventBinding, Qt as loadSpawnForest, Rr as runtimeOwnedExecutorMaterialization, Tr as finalizeRuntimeOwnedPendingExecutor, Ur as unknownExecutionBindingReceipt, Vr as runtimeOwnedScopeOwnerControl, Wr as unknownMaterializationReceipt, X as assertRecursiveReservationPolicy, Yn as HARNESS_TRANSCRIPT_SETTLE_TIMEOUT_MS, Zn as captureHarnessTranscript, Zr as RetainedRunProviderContractError, _n as reconnectRetainedRun, _t as waitForScopeChildren, ai as abortReason, an as encodeResultBlob, br as attestRuntimeOwnedExecutor, cn as executorObservation, cr as createActivityLog, dn as describeRetainedNativeStops, dr as isLiveNodeStatus, dt as releaseHeldEnvironments, ei as exactSession, er as harnessTranscriptUnavailable, fn as stopRetainedNativeExecution, ft as releaseRetainedEnvironments, gn as mintRetainedIdentity, gt as unconfirmedTeardowns, hn as assertRetainedRunReplayMaterial, ht as startScopeRecoveries, ii as RunCancellationReason, j as resolveWorkerSlots, jn as WORKER_TRACE_PROPAGATION, kr as newExecutionAttemptId, kt as finalizeScopeOwnerMaterialization, lr as describeToolArgs, mn as RetainedMaterializationTimeoutError, mt as settleManagerWork, n as terminalAccounting, ni as retainedSessionReplaced, nn as driverRuntime, nt as closeScopeAdmission, oi as linkAbort, on as SpawnEventIndex, pn as verifyWorkspaceMarker, pt as retryUnconfirmedTeardowns, q as appendTeardownConfirmation, r as createScope, ri as sameControlCoordinates, rn as nestedDriverTreeRoot, rt as hasRetriableTeardowns, si as runAbortable, t as isNonEmptySpend, ti as freezeControlRef, tn as attestNestedDriverTreeOwner, tt as closeRetainedSlots, ui as promptOptionsFromAgentTurnInput, un as observeModelRequest, ut as registerNestedTeardownScope, vn as recoverRetainedRun, vr as subscriptionUsageLimitSignal, xr as attestRuntimeOwnedPendingExecutor, yn as startRetainedRun, yr as attestRuntimeOwnedDeferredExecutor } from "./supervisor-accounting-Bw4MJk-b.js";
+import { f as RuntimeRunStateError, i as ConfigError, m as ValidationError$1, r as BackendTransportError, t as AgentEvalError } from "./errors-DG8yufqX.js";
+import { C as unreportedSpend, D as addResourceSpend, E as zeroTokenUsage, F as ROOT_DEADLINE_REASON, H as teardownSurfaces, I as armDeadlineTimer, S as unmeteredSpend, T as zeroSpend, _ as roundBoxMinutes, b as throwAbort, c as errorMessage, d as isAbortError, f as isAsyncIterable, g as randomUuid, h as randomSuffix, j as ACCEPTED_RESULT_GRACE_MS, m as promptCacheTokenClasses, n as addSpend, o as cloneTokenUsage, p as mapWithConcurrency, r as addTokenUsage, s as deleteBoxSafe, v as sleep, w as withTimeout, x as throwIfAborted, y as stringifySafe, z as isDeadlineAbortReason } from "./util-fcckrkKp.js";
 import { t as runTaskQueue } from "./task-queue-DbpZAp6C.js";
-import { B as credentialCommandExit, Ct as parseCodexUsageRecord, D as unavailableResumeAt, E as unavailablePauseMs, F as executorFailureInfra, L as turnFailureOf, M as contentAddress, N as contentRef, O as unavailableSignalOfFailure, R as turnFailurePolicy, T as reportedResetAt, V as isCredentialRefusal, _t as notifySandboxEventObserver, a as runtimeProviderCode, at as sandboxOutputMarker, b as UNAVAILABLE_CODES, bt as sandboxTerminalUsageField, c as DISPATCH_EXECUTION_CHANGED_CODE, d as TRANSPORT_ERROR_CODES, dt as assertSandboxServedModel, ft as canonicalSandboxUsageMode, gt as isSandboxTerminalEvent, i as runtimeFailureRemediationSchema, it as sandboxLeafOutputFromEvents, l as DISPATCH_NOT_ADMITTED_CODE, lt as extractTransportEventIdentity, m as isSchemaRejection, mt as createSandboxUsageLedger, n as runtimeFailureCause, ot as sandboxProgressEvents, p as isProvisioningRefusal, pt as createSandboxTurnEventCollector, q as createBudgetPool, t as reportedFailureCause, tt as createSandboxToolPartState, u as RetainedExecutionPendingError, v as retainedExecutorContext, vt as sameModelId, w as printedStatus, wt as recordValue, x as UNAVAILABLE_STATUSES, y as retainedExecutorSeamKey, yt as sandboxEventServedBackend, z as hashJson } from "./failure-cause-BzjUUsRz.js";
-import { a as errMessage, c as errorText, i as causeChain, l as defaultRedactor, n as detachedSnapshot, o as errorHttpStatus, s as errorProperty } from "./snapshot-Cgj2Wzi6.js";
-import { _ as agentHarness, a as concreteProfileModel, c as profileModelExecutionSettings, d as assertRouterAutoDeclaration, f as assertRouterAutoResponse, g as observedModelMatchesDeclared, h as observedModelHasSnapshot, l as profileProviderModel, m as mergeObservedModelIdentity, o as enforceTokenLimits, s as profileBridgeWireModel, t as assertExecutableAgentProfile, u as resolveRouterRetryPolicy } from "./model-policy-JOcg3NRs.js";
-import { r as nativeSystemPrompt, t as assertSandboxProfileCompatibility } from "./sandbox-profile-compat-oFGWESLn.js";
+import { B as hashJson, D as unavailableResumeAt, E as unavailablePauseMs, F as executorFailureInfra, H as isCredentialRefusal, J as createBudgetPool, M as contentAddress, N as contentRef, O as unavailableSignalOfFailure, R as turnFailureOf, T as reportedResetAt, Tt as recordValue, V as credentialCommandExit, _t as isSandboxTerminalEvent, a as runtimeProviderCode, at as sandboxLeafOutputFromEvents, b as UNAVAILABLE_CODES, bt as sandboxEventServedBackend, c as DISPATCH_EXECUTION_CHANGED_CODE, d as TRANSPORT_ERROR_CODES, ft as assertSandboxServedModel, ht as createSandboxUsageLedger, i as runtimeFailureRemediationSchema, l as DISPATCH_NOT_ADMITTED_CODE, m as isSchemaRejection, mt as createSandboxTurnEventCollector, n as runtimeFailureCause, nt as createSandboxToolPartState, ot as sandboxOutputMarker, p as isProvisioningRefusal, pt as canonicalSandboxUsageMode, st as sandboxProgressEvents, t as reportedFailureCause, u as RetainedExecutionPendingError, ut as extractTransportEventIdentity, v as retainedExecutorContext, vt as notifySandboxEventObserver, w as printedStatus, wt as parseCodexUsageRecord, x as UNAVAILABLE_STATUSES, xt as sandboxTerminalUsageField, y as retainedExecutorSeamKey, yt as sameModelId, z as turnFailurePolicy } from "./failure-cause-CVB-YE88.js";
+import { a as errMessage, i as causeChain, l as errorText, n as detachedSnapshot, o as errorHttpStatus, s as errorProperty, u as defaultRedactor } from "./snapshot-BKI_w3JD.js";
+import { _ as agentHarness, a as concreteProfileModel, c as profileModelExecutionSettings, d as assertRouterAutoDeclaration, f as assertRouterAutoResponse, g as observedModelMatchesDeclared, h as observedModelHasSnapshot, l as profileProviderModel, m as mergeObservedModelIdentity, o as enforceTokenLimits, s as profileBridgeWireModel, t as assertExecutableAgentProfile, u as resolveRouterRetryPolicy } from "./model-policy-yxOrDTTj.js";
+import { r as nativeSystemPrompt, t as assertSandboxProfileCompatibility } from "./sandbox-profile-compat-l-SLQnGb.js";
 import { l as sha256 } from "./jsonl-file-DsxVI0E_.js";
-import { V as hasControlCharacter } from "./workspace-streams-B7yNMahl.js";
+import { V as hasControlCharacter } from "./workspace-streams-DA9R3j-p.js";
+import { i as checkVerdictOf, s as isFiniteNumber } from "./continuation-CIyKnS1Q.js";
 import { a as writeAtomicDurableFile, s as fenceRunWrite } from "./durable-file-DstVeHcj.js";
-import { t as PROTOCOL_VERSION } from "./tool-server-B9q2dtnW.js";
+import { t as PROTOCOL_VERSION } from "./tool-server-DYwRbi0I.js";
 import { i as notifyRuntimeHookEvent } from "./runtime-hooks-CsW2pfFk.js";
 import { AGENT_PROFILE_MATERIALIZATION_AXES, AgentExactRunControlRefSchema, AgentRunCancellationRequestSchema, AgentTurnInputSchema, REASONING_EFFORTS, agentProfileSchema, canonicalAgentProfileDigest, canonicalCandidateDigest, canonicalWorkspaceCwd, harnessTypeSchema, mergeProxySecretBindings, nativeReasoningControl, profileMaterializationAxes, profileMaterializationAxes as profileMaterializationAxes$1, renderInputPartsAsText, sha256DigestSchema } from "@tangle-network/agent-interface";
 import { createAgentRunOutcomeTracker } from "@tangle-network/sandbox/runtime";
@@ -225,23 +226,6 @@ const sandboxActProfileMaterialization = defineProfileMaterializationContract({
 	name: "createSandboxAct",
 	axes: sandboxProfileMaterialization.axes
 });
-defineProfileMaterializationContract({
-	name: "prompt-only-message",
-	axes: ["systemPrompt", "instructions"]
-});
-defineProfileMaterializationContract({
-	name: "prompt-resource-attachment",
-	axes: [
-		"systemPrompt",
-		"instructions",
-		"files",
-		"resourceTools",
-		"skills",
-		"resourceAgents",
-		"commands",
-		"resourceInstructions"
-	]
-});
 /** Define the profile axes a concrete run path actually carries into execution. */
 function defineProfileMaterializationContract(options) {
 	const name = options.name.trim();
@@ -2186,6 +2170,10 @@ async function runSettledCommand(opts) {
 	return new Promise((resolve, reject) => {
 		const child = spawn(opts.command, opts.args ?? [], {
 			cwd: opts.cwd,
+			...opts.env ? { env: {
+				...process.env,
+				...opts.env
+			} } : {},
 			stdio: [
 				"ignore",
 				"pipe",
@@ -2577,9 +2565,11 @@ function bridgeUpstreamError(error, prefix, httpStatus) {
 	const upstreamCode = runtimeProviderCode(safe.type);
 	const remedy = (status === 403 && (httpStatus === 403 || raw.status === 403) ? subscriptionErrorSchema.safeParse(raw) : void 0)?.success ? runtimeFailureRemediationSchema.readonly().safeParse(safe) : void 0;
 	const message = typeof safe.message === "string" ? safe.message : upstreamCode ?? "unknown";
-	return new BackendTransportError("bridge", `${prefix}: ${message}`.slice(0, 512), {
+	const capacity = raw.capacity === true ? "bridge executor at capacity: " : "";
+	return new BackendTransportError("bridge", `${prefix}: ${capacity}${message}`.slice(0, 512), {
 		status,
 		upstreamCode,
+		...capacity ? { capacity: true } : {},
 		...raw.provider_dispatch === "not_started" ? { providerDispatch: "not_started" } : {},
 		...remedy?.success ? { remediation: remedy.data } : {},
 		...typeof redacted.body === "string" ? { body: redacted.body.slice(0, 2048) } : {}
@@ -3972,24 +3962,7 @@ function priceTokens(work) {
 	return Math.max(0, work.inputTokens - cacheRead - cacheWrite) * price.input + cacheRead * (price.cachedInput ?? price.input) + cacheWrite * (price.cacheWrite ?? price.input) + work.outputTokens * price.output;
 }
 // src/runtime/supervise/cost-estimate.ts
-/**
-* Pricing for work that arrived without a provider receipt.
-*
-* A turn whose provider reported no billed dollars used to reach the dollar channel as a
-* known `$0`, so a run that certainly spent money reported a dollar total of zero. A catalog
-* price is not a receipt, so what this module produces is always marked, never promoted.
-* The catalog is the Router's (`src/pricing/router-prices.ts`).
-*/
-/**
-* Price one unit of work that no provider receipt covered.
-*
-* The event always carries `usdKnown: false`: a catalog price approximates what a provider
-* WOULD bill, never measures what it did. The priced amount is repeated in `usdEstimated` so
-* a consumer can subtract it from `usd` and recover the dollars a provider actually billed.
-*
-* A model the Router does not price yields `usd: 0` with `usdKnown: false` and no `usdEstimated`.
-* The turn then reads as unknown dollars, which is true, rather than as a free turn.
-*/
+/** Unreceipted work stays `usdKnown: false`. A subscription seat stays uncaptured. */
 function priceUnreceiptedWork(work) {
 	const unknown = {
 		kind: "cost",
@@ -3997,7 +3970,7 @@ function priceUnreceiptedWork(work) {
 		usdKnown: false,
 		provenance: "uncaptured"
 	};
-	if (work.model === void 0) return unknown;
+	if (work.credentialSource === "subscription" || work.model === void 0) return unknown;
 	const usd = priceTokens({
 		model: work.model,
 		inputTokens: work.inputTokens,
@@ -4029,10 +4002,7 @@ function newTurnTally() {
 		outputTokens: 0
 	};
 }
-/**
-* Open the harness store named on the seam, or nothing when the caller named none. A harness with
-* no reader is REFUSED: ignoring it would hand back the same `{0, 0}` the store was meant to fix.
-*/
+/** Open the named harness store. No reader is a refusal, not a silent `{0, 0}`. */
 function openBridgeHarnessStore(store) {
 	if (store === void 0) return void 0;
 	if (store.harness !== "codex") throw new ValidationError$1(`bridgeExecutor: harnessStore.harness ${JSON.stringify(store.harness)} has no store reader; only "codex" is readable today`);
@@ -4041,8 +4011,7 @@ function openBridgeHarnessStore(store) {
 		...store.workspaceRoot === void 0 ? {} : { workspaceRoot: store.workspaceRoot }
 	});
 }
-/** Read one turn's worth of the harness store. A failed read is noted on the activity log and
-*  returns nothing: the store is extra evidence and must never end a turn whose work happened. */
+/** One turn of the harness store. A failed read is noted and returns nothing. */
 async function readHarnessStoreDelta(reader, observation) {
 	try {
 		return await reader.read();
@@ -4056,16 +4025,8 @@ async function readHarnessStoreDelta(reader, observation) {
 		return;
 	}
 }
-/**
-* The tokens one cli-bridge turn's own materialization receipt states, or the reason it states
-* none. cli-bridge counts the model traffic through its scoped-loopback endpoint and publishes it
-* as `inference.observation.usage`, harness-agnostic BY CONSTRUCTION, so the runtime holds NO
-* per-harness bridge decoder (`harness-usage.ts` serves the sandbox stream).
-*
-* A receipt states a turn's tokens only when it names BOTH totals; anything less leaves the turn
-* unknown with the reason named, never a zero. The counters beside the totals CLASSIFY the prompt
-* total and add nothing to it (the receipt carries no reasoning counter).
-*/
+/** Receipt tokens, or why none. Both totals required; cache counters only classify.
+*  No per-harness bridge decoder. */
 function readBridgeReceiptTokens(usage) {
 	if (usage === void 0) return { reason: "usage-unreadable: the turn receipt carried no bridge inference observation" };
 	const input = usage.inputTokens;
@@ -4090,10 +4051,7 @@ function readBridgeReceiptTokens(usage) {
 		...contradiction
 	} };
 }
-/**
-* The accounting of one cli-bridge session across its turns: what each turn's stream, receipt,
-* and harness store proved, what stayed unknown and why, and the artifact the session settles as.
-*/
+/** One cli-bridge session: what each turn proved, what stayed unknown, and the settled artifact. */
 var BridgeSessionLedger = class {
 	tokens = zeroTokenUsage();
 	tokensKnown = true;
@@ -4177,11 +4135,8 @@ var BridgeSessionLedger = class {
 			this.sawEstimatedUsd = true;
 		}
 	}
-	/**
-	* Close the turn's accounting after its stream: the receipt, the harness store, and a price for
-	* what no receipt billed. Every channel nothing proved stays unknown, never zero.
-	*/
-	async *settleTurn(receiptUsage, harnessStore, observation, providerModel) {
+	/** Close the turn. Every unproven channel stays unknown, never zero. */
+	async *settleTurn(receiptUsage, harnessStore, observation, providerModel, credentialSource) {
 		if (!this.turn.sawTokenUsage) {
 			const receipt = readBridgeReceiptTokens(receiptUsage);
 			if ("event" in receipt) {
@@ -4195,7 +4150,7 @@ var BridgeSessionLedger = class {
 		if (!turn.sawTokenUsage || !turn.tokensKnown) this.tokensKnown = false;
 		if (!turn.sawCostStatus || !turn.usdKnown) {
 			this.usdKnown = false;
-			yield this.priceUnreceiptedTurn(providerModel);
+			yield this.priceUnreceiptedTurn(providerModel, credentialSource);
 		}
 	}
 	async *creditHarnessStore(harnessStore, observation) {
@@ -4222,12 +4177,13 @@ var BridgeSessionLedger = class {
 			this.tokensUnknownReason ??= `harness-store: ${delta.unresolved.length} forked rollout(s) could not be attributed to a turn; ${delta.unresolved[0]?.reason ?? "no reason recorded"}`;
 		}
 	}
-	priceUnreceiptedTurn(providerModel) {
+	priceUnreceiptedTurn(providerModel, credentialSource) {
 		const { turn } = this;
 		const priced = turn.knownCostSubtotal === 0 ? priceUnreceiptedWork({
 			inputTokens: turn.inputTokens,
 			outputTokens: turn.outputTokens,
-			model: this.observedModel ?? providerModel
+			model: this.observedModel ?? providerModel,
+			...credentialSource === "subscription" ? { credentialSource } : {}
 		}) : {
 			kind: "cost",
 			usd: 0,
@@ -4410,9 +4366,14 @@ function silenceBoundRefusal(seam, base, wireModel, route) {
 	};
 }
 /**
-* Read the default bulk lane from `GET /health`. Runtime sends no reserved-client header, so
-* overall capacity can look free while the lane this request will use is already full. Older
-* bridges expose only the overall counters; those retain the prior fallback.
+* Read the gates that decide a spawn from `GET /health`. The host executor
+* (`executor.in_flight` of `executor.max`, `BRIDGE_HOST_MAX_CONCURRENCY`) gates a
+* spawn sooner than the bulk admission lane (default 6 vs 4): a spawn the lane
+* admits still waits on the executor semaphore for `acquire_deadline_ms` and is
+* then refused as capacity (#1186). When the bridge reports executor counters they
+* decide the answer; the bulk admission lane (Runtime sends no reserved-client
+* header, so overall capacity can look free) and then the overall counters remain
+* the fallback for older bridges.
 */
 async function bridgeAdmissionRefusal(seam, signal) {
 	let answer;
@@ -4428,7 +4389,18 @@ async function bridgeAdmissionRefusal(seam, signal) {
 	} catch {
 		return;
 	}
-	const admission = parsed?.admission;
+	const health = parsed;
+	const admission = health?.admission;
+	const executorInFlight = health?.executor?.in_flight;
+	const executorMax = health?.executor?.max;
+	const executorQueued = health?.executor?.queued;
+	if (isFiniteNumber(executorInFlight) && executorInFlight >= 0 && isFiniteNumber(executorMax) && executorMax >= 0) {
+		if (executorInFlight + 1 > executorMax) {
+			const queued = isFiniteNumber(executorQueued) && executorQueued >= 0 ? `, ${executorQueued} queued` : "";
+			return `bridge ${seam.bridgeUrl.replace(/\/$/, "")} executor is full: in_flight ${executorInFlight} of max ${executorMax}${queued}; the spawn would wait on the host semaphore and be refused as capacity`;
+		}
+		return;
+	}
 	const active = admission?.active;
 	const maxActive = admission?.maxActive;
 	const bulkActive = admission?.activeByClass?.bulk;
@@ -4799,474 +4771,6 @@ var BridgeTurnSignals = class {
 		if (this.silenceTimer !== void 0) clearTimeout(this.silenceTimer);
 	}
 };
-// src/finite-number.ts
-function isFiniteNumber(value) {
-	return typeof value === "number" && Number.isFinite(value);
-}
-// src/runtime/supervise/continuation.ts
-/**
-* The continuation: what a manager with a completion check is told when its turn ends and the
-* check is unmet, and the one rule that decides whether it is sent back.
-*
-* Measured on discovery-lab before this module (670 settled runs, 1,596 re-entries):
-* 1,565 re-entries followed a failed turn and resent the original task, and 31 carried note text.
-* The note Runtime wrote itself held seven fixed lines and no field for the check's verdict. Of 40
-* episodes where the director ended on its own and the outside check disagreed, 33 were told
-* nothing before they ended. 100 of 236 resubmits sent the identical packet. So the director
-* mostly graded itself, and when it was wrong it heard nothing it could use.
-*
-* The design (discovery `docs/38-one-loop-and-continuation.md`) makes three things single, and
-* this module holds the part Runtime owns:
-*
-*  - ONE CHECK. A check reading is a {@link CheckVerdict}: pass, the items it read, the composite,
-*    and one `FAIL <item> <where>: <reason>` line per failed item. The same check decides
-*    `submit_result`, runs when a turn ends without an accepted result, scores the finished run,
-*    and ranks versions. A check that could not run gives no verdict ({@link CheckUnavailableError}),
-*    and the loop pauses instead of blaming the director.
-*  - ONE RESEND RULE. {@link ContinuationPolicy} is required for a manager with a check. It holds
-*    `maxBarren`, the re-entered turns in a row that may end without progress before each further
-*    continuation waits a barren pause, and an optional deadline. There is no re-prompt count and
-*    no default: a retry default in source is a research decision.
-*  - ONE NOTE. {@link composeContinuationNote} writes it. Runtime owns the facts and their order;
-*    the {@link ContinuationProfile} owns every instruction word, so an optimizer can change the
-*    words without touching code. A play may append a section, never remove or rewrite one.
-*
-* Evidence behind the note's shape: located errors help (given the first mistake's true location,
-* fix rates rose 23.5 to 43.9 points, Tyen 2023); unsupported pressure does not (threats and tips
-* had no significant effect, Wharton 2025; challenges without evidence flipped correct answers,
-* FlipFlop); repeated summaries drop detail while itemized additions do not (ACE). So the note is
-* a list of located facts, findings are added and marked resolved rather than rewritten, and the
-* profile, not this file, decides how blunt the words are.
-*/
-/** Read a check function's return value into a verdict. Anything but `true` or a passing verdict
-*  is a failure: a check fails closed. */
-function checkVerdictOf(outcome) {
-	if (outcome === true) return { pass: true };
-	if (typeof outcome !== "object" || outcome === null || Array.isArray(outcome)) return { pass: false };
-	const raw = outcome;
-	const items = typeof raw.items === "object" && raw.items !== null && !Array.isArray(raw.items) ? Object.fromEntries(Object.entries(raw.items).filter((entry) => typeof entry[1] === "number" && Number.isFinite(entry[1]))) : void 0;
-	const failures = Array.isArray(raw.failures) ? raw.failures.filter((line) => typeof line === "string" && line.trim() !== "") : void 0;
-	return Object.freeze({
-		pass: raw.pass === true,
-		...items === void 0 ? {} : { items: Object.freeze(items) },
-		...isFiniteNumber(raw.composite) ? { composite: raw.composite } : {},
-		...isFiniteNumber(raw.threshold) ? { threshold: raw.threshold } : {},
-		...failures === void 0 ? {} : { failures: Object.freeze(failures) },
-		...typeof raw.review === "string" && raw.review.trim() !== "" ? { review: raw.review.trim() } : {}
-	});
-}
-/** Items that fail in `verdict`: every item below 1, or the named items of its FAIL lines. */
-function failedItems(verdict) {
-	if (verdict.items !== void 0) return Object.entries(verdict.items).filter(([, value]) => value < 1).map(([name]) => name);
-	return (verdict.failures ?? []).map((line) => line.slice(5).split(/[\s:]/u)[0] ?? "");
-}
-/** Items that pass in `verdict`. */
-function passedItems(verdict) {
-	return Object.entries(verdict.items ?? {}).filter(([, value]) => value >= 1).map(([name]) => name);
-}
-/** Resolve and check a policy before any compute. Returns the deadline in epoch ms, or undefined
-*  when the policy sets none. */
-function admitContinuationPolicy(policy, context) {
-	if (typeof policy !== "object" || policy === null) throw new ValidationError$1(`${context}: continuation must be an object`);
-	const deadlineMs = typeof policy.deadline === "string" ? Date.parse(policy.deadline) : policy.deadline;
-	if (deadlineMs !== void 0 && (typeof deadlineMs !== "number" || !Number.isFinite(deadlineMs) || deadlineMs <= 0)) throw new ValidationError$1(`${context}: continuation.deadline, when set, must be a finite time (epoch ms or ISO 8601)`);
-	if (!Number.isInteger(policy.maxBarren) || policy.maxBarren < 1) throw new ValidationError$1(`${context}: continuation.maxBarren must be an integer >= 1`);
-	if (policy.failures !== "verbatim" && policy.failures !== "off") throw new ValidationError$1(`${context}: continuation.failures must be 'verbatim' or 'off'`);
-	if (policy.panel !== "on" && policy.panel !== "off") throw new ValidationError$1(`${context}: continuation.panel must be 'on' or 'off'`);
-	if (policy.bar !== "on" && policy.bar !== "off") throw new ValidationError$1(`${context}: continuation.bar must be 'on' or 'off'`);
-	if (policy.panel === "on") {
-		if (typeof policy.runPanel !== "function") throw new ValidationError$1(`${context}: continuation.panel 'on' needs runPanel`);
-		const usd = policy.panelUsd;
-		if (usd === void 0 || !isFiniteNumber(usd.perContinuation) || !isFiniteNumber(usd.perRun) || usd.perContinuation <= 0 || usd.perRun < usd.perContinuation) throw new ValidationError$1(`${context}: continuation.panel 'on' needs panelUsd with 0 < perContinuation <= perRun`);
-	}
-	if (policy.append !== void 0 && typeof policy.append !== "function") throw new ValidationError$1(`${context}: continuation.append must be a function`);
-	if (policy.session !== void 0 && policy.session !== "native" && policy.session !== "fresh") throw new ValidationError$1(`${context}: continuation.session must be 'native' or 'fresh'`);
-	admitContinuationProfile(policy.profile, context);
-	return deadlineMs;
-}
-/** The facts a profile template may name. */
-const CONTINUATION_FACTS = [
-	"composite",
-	"threshold",
-	"failed",
-	"total",
-	"reads",
-	"owed",
-	"settled",
-	"delivered",
-	"continuation"
-];
-const factNames = new Set(CONTINUATION_FACTS);
-const placeholder = /\{([a-zA-Z]+)\}/gu;
-function admitContinuationProfile(profile, context) {
-	if (typeof profile !== "object" || profile === null) throw new ValidationError$1(`${context}: continuation.profile must be an object`);
-	if (typeof profile.id !== "string" || profile.id.trim() === "") throw new ValidationError$1(`${context}: continuation.profile.id must be non-empty`);
-	const texts = [
-		["opening", profile.opening],
-		["plan", profile.plan],
-		["rules", profile.rules],
-		...Object.entries(profile.headings ?? {}).map(([key, value]) => [`headings.${key}`, value]),
-		...profile.barRule === void 0 ? [] : [["barRule", profile.barRule]]
-	];
-	for (const key of [
-		"failures",
-		"protected",
-		"changed",
-		"findings",
-		"bar",
-		"plan",
-		"rules"
-	]) if (typeof profile.headings?.[key] !== "string") throw new ValidationError$1(`${context}: continuation.profile.headings.${key} must be a string`);
-	for (const [key, text] of texts) {
-		if (typeof text !== "string") throw new ValidationError$1(`${context}: continuation.profile.${key} must be a string`);
-		for (const match of text.matchAll(placeholder)) if (!factNames.has(match[1] ?? "")) throw new ValidationError$1(`${context}: continuation.profile.${key} names {${match[1]}}, which is not a fact Runtime supplies (${CONTINUATION_FACTS.join(", ")})`);
-	}
-	if (profile.review !== void 0) {
-		if (typeof profile.review !== "string" || profile.review.trim() === "") throw new ValidationError$1(`${context}: continuation.profile.review must be non-empty`);
-		for (const match of profile.review.matchAll(placeholder)) if (![
-			"version",
-			"path",
-			"score"
-		].includes(match[1] ?? "")) throw new ValidationError$1(`${context}: continuation.profile.review names {${match[1]}}; it may name {version}, {path} and {score}`);
-	}
-	if (profile.opening.trim() === "") throw new ValidationError$1(`${context}: continuation.profile.opening must be non-empty`);
-	for (const [index, question] of (profile.questions ?? []).entries()) if (typeof question !== "string" || question.trim() === "") throw new ValidationError$1(`${context}: continuation.profile.questions[${index}] must be a non-empty string`);
-}
-/** Findings reach the note only when every citation resolves, at least two distinct spans are
-*  cited, and the independent verifier agreed. The best method in Who&When found the failing step
-*  14.2% of the time, so an unverified finding is noise with a citation. */
-function admitFinding(finding) {
-	if (!finding.verified) return false;
-	if (finding.citations.length === 0) return false;
-	if (!finding.citations.every((citation) => citation.resolved)) return false;
-	return new Set(finding.citations.map((citation) => citation.uri)).size >= 2;
-}
-/** About 1,500 tokens of findings. */
-const FINDINGS_CHAR_CAP = 6e3;
-/**
-* Rank the admitted findings by how many failed items they explain, drop repeats, and keep them
-* within the note's cap. Earlier findings stay as they were written (ACE: itemized additions keep
-* detail that repeated rewrites lose); a finding whose items all pass now is marked resolved.
-*/
-function distillFindings(prior, proposed, failing, continuation) {
-	const key = (claim) => claim.toLowerCase().replace(/\s+/gu, " ").trim();
-	const known = new Set(prior.map((finding) => key(finding.claim)));
-	const carried = prior.map((finding) => finding.resolvedAt === void 0 && (finding.items?.length ?? 0) > 0 && (finding.items ?? []).every((item) => !failing.has(item)) ? {
-		...finding,
-		resolvedAt: continuation
-	} : finding);
-	const fresh = proposed.filter(admitFinding).filter((finding) => {
-		const k = key(finding.claim);
-		if (known.has(k)) return false;
-		known.add(k);
-		return true;
-	}).map((finding) => ({
-		finding,
-		links: (finding.items ?? []).filter((item) => failing.has(item)).length
-	})).sort((a, b) => b.links - a.links);
-	const out = [...carried];
-	let used = carried.filter((finding) => finding.resolvedAt === void 0).reduce((sum, finding) => sum + finding.claim.length, 0);
-	for (const { finding } of fresh) {
-		if (used + finding.claim.length > FINDINGS_CHAR_CAP) break;
-		used += finding.claim.length;
-		out.push({
-			...finding,
-			admittedAt: continuation
-		});
-	}
-	return out;
-}
-/** Expand the profile's question templates over the failed items and the settled workers. */
-function expandQuestions(templates, failing, workers) {
-	const out = [];
-	for (const template of templates) {
-		const hasItem = template.includes("{item}");
-		const hasWorker = template.includes("{worker}");
-		if (!hasItem && !hasWorker) {
-			out.push(template);
-			continue;
-		}
-		const items = hasItem ? failing : [""];
-		const each = hasWorker ? workers.map((worker) => `${worker.id} (${worker.label})`) : [""];
-		for (const item of items) for (const worker of each) out.push(template.replaceAll("{item}", item).replaceAll("{worker}", worker));
-	}
-	return out;
-}
-/**
-* Write one continuation note, sections 1 to 8 of docs/38. Section 9, the run's state, is
-* `composeReentryTask`, which wraps this text. Pure: the same input writes the same note.
-*/
-function composeContinuationNote(input) {
-	const { profile, verdict } = input;
-	const items = verdict?.items ?? {};
-	const total = Object.keys(items).length;
-	const failing = verdict === void 0 ? [] : failedItems(verdict);
-	const facts = {
-		composite: verdict?.composite === void 0 ? "unknown" : format(verdict.composite),
-		threshold: verdict?.threshold === void 0 ? "unknown" : format(verdict.threshold),
-		failed: verdict === void 0 || total === 0 && (verdict.failures?.length ?? 0) === 0 ? "unknown" : String(failing.length),
-		total: total === 0 ? "unknown" : String(total),
-		reads: String(input.reads),
-		owed: input.owed?.trim() || "not described",
-		settled: String(input.progress.settledCount),
-		delivered: String(input.progress.deliveredCount ?? 0),
-		continuation: String(input.continuation)
-	};
-	const fill = (text) => text.replace(placeholder, (_, name) => facts[name] ?? `{${name}}`);
-	const sections = [verdict === void 0 ? "No check verdict is available yet." + (input.canSubmitResult === true ? " Submit a result through submit_result to request the check." : "") : verdict.pass ? "The check passes on the current state, but no result has been accepted." + (input.canSubmitResult === true ? " Call submit_result to request acceptance." : "") : fill(profile.opening).trim()];
-	const section = (heading, body) => {
-		if (body.length === 0) return;
-		sections.push([...heading.trim() === "" ? [] : [`## ${fill(heading)}`], ...body].join("\n"));
-	};
-	if (input.failures === "verbatim" && verdict !== void 0) {
-		const lines = verdict.failures ?? [];
-		const shown = lines.slice(0, 40);
-		const more = lines.length - shown.length;
-		section(profile.headings.failures, [...shown, ...more > 0 ? [input.canReadMore ? `${more} more failure lines: call read_continuation with continuation ${input.continuation}.` : `${more} more failure lines are not shown.`] : []]);
-		const passing = passedItems(verdict);
-		section(profile.headings.protected, passing.length === 0 ? [] : [passing.join(", ")]);
-		if (input.previous !== void 0) {
-			const before = new Set(failedItems(input.previous));
-			const now = new Set(failing);
-			const fixed = [...before].filter((item) => !now.has(item));
-			const broke = [...now].filter((item) => !before.has(item));
-			section(profile.headings.changed, [
-				...fixed.length === 0 ? [] : [`Now passing: ${fixed.join(", ")}.`],
-				...broke.length === 0 ? [] : [`Newly failing: ${broke.join(", ")}.`],
-				...fixed.length === 0 && broke.length === 0 ? ["No item changed since the last note."] : [],
-				...input.previous.composite !== void 0 && verdict.composite !== void 0 ? [`Composite: ${format(input.previous.composite)} then ${format(verdict.composite)}.`] : []
-			]);
-		}
-	}
-	if (input.findings !== void 0) {
-		const open = input.findings.filter((finding) => finding.resolvedAt === void 0);
-		const resolved = input.findings.filter((finding) => finding.resolvedAt === input.continuation);
-		section(profile.headings.findings, [...open.map((finding) => `- [hypothesis] ${finding.claim}` + (finding.items?.length ? ` (items: ${finding.items.join(", ")})` : "") + ` Evidence: ${finding.citations.map((citation) => citation.uri).join(", ")}`), ...resolved.map((finding) => `- [resolved] ${finding.claim}`)]);
-	}
-	if (input.bar !== void 0 && verdict !== void 0) {
-		const body = [];
-		if (profile.barRule?.trim()) body.push(fill(profile.barRule).trim());
-		for (const [item, value] of Object.entries(items)) {
-			const best = input.bar.best?.verdict.items?.[item];
-			body.push(`- ${item}: ${value >= 1 ? "passes" : `fails (${format(value)})`}` + (best === void 0 ? "" : ` / ${input.bar.best?.label}: ${best >= 1 ? "passes" : `fails (${format(best)})`}`));
-		}
-		if (input.bar.best?.verdict.composite !== void 0) body.push(`Best version ${input.bar.best.label}: composite ${format(input.bar.best.verdict.composite)}.`);
-		if (input.bar.reference?.trim()) body.push(`Reference result: ${input.bar.reference.trim()}`);
-		if (verdict.review?.trim()) body.push(`The check's review: ${verdict.review.trim()}`);
-		section(profile.headings.bar, body);
-	}
-	section(profile.headings.plan, profile.plan.trim() === "" ? [] : [fill(profile.plan).trim()]);
-	section(profile.headings.rules, [...profile.rules.trim() === "" ? [] : [fill(profile.rules).trim()], ...input.sealed ? ["The score comes from cases you cannot see."] : []]);
-	for (const appended of input.appended ?? []) section(appended.heading, appended.text.trim() === "" ? [] : [appended.text.trim()]);
-	return sections.join("\n\n");
-}
-function summarizeVerdict(verdict) {
-	if (verdict === void 0) return null;
-	const total = Object.keys(verdict.items ?? {}).length;
-	return {
-		pass: verdict.pass,
-		...verdict.composite === void 0 ? {} : { composite: verdict.composite },
-		...total === 0 ? {} : {
-			failed: failedItems(verdict).length,
-			total
-		}
-	};
-}
-function noteDigest(note) {
-	return `sha256:${sha256(note)}`;
-}
-/** A run directory's continuation files: the root's at `<runDir>/continuations/<n>/`, a nested
-*  manager's at `<runDir>/continuations/managers/<owner>/<n>/`. */
-const CONTINUATIONS_DIR = "continuations";
-/**
-* Write one continuation's files under `<dir>/<n>/`: `note.md`, `verdict.json`, and
-* `panel.jsonl` when the panel ran. The director reads them through `read_continuation`, because
-* its box cannot read the driver's run directory.
-*/
-async function writeContinuationFiles(dir, continuation, files) {
-	const at = join(dir, String(continuation));
-	await mkdir(at, { recursive: true });
-	writeAtomicDurableFile(join(at, "note.md"), `${files.note}\n`);
-	writeAtomicDurableFile(join(at, "verdict.json"), `${JSON.stringify(files.verdict ?? null, null, 2)}\n`);
-	if (files.panel !== void 0) writeAtomicDurableFile(join(at, "panel.jsonl"), files.panel.map((line) => JSON.stringify(line)).join("\n") + (files.panel.length ? "\n" : ""));
-}
-/** The best composite across `reads`, or `undefined` when no read scored. */
-function bestComposite(reads) {
-	let best;
-	for (const read of reads) {
-		const value = read.verdict?.composite;
-		if (value !== void 0 && (best === void 0 || value > best)) best = value;
-	}
-	return best;
-}
-function format(value) {
-	return Number.isInteger(value) ? String(value) : value.toFixed(3).replace(/0+$/u, "");
-}
-/** Build the continuation state for one manager with a check. */
-function createContinuationKeeper(input) {
-	const { policy } = input;
-	const failures = input.feedback === "pass-only" ? "off" : policy.failures;
-	const entries = [];
-	const notes = [];
-	let findings = [];
-	let panelUsd = 0;
-	let panelUsdKnown = true;
-	const latestVerdict = () => {
-		const reads = input.reads();
-		for (let i = reads.length - 1; i >= 0; i -= 1) {
-			const read = reads[i];
-			if (read?.verdict !== void 0) return {
-				verdict: read.verdict,
-				read: read.read
-			};
-		}
-		return { read: 0 };
-	};
-	const closePrevious = () => {
-		const last = entries.at(-1);
-		const lastNote = notes.at(-1);
-		if (last === void 0 || lastNote === void 0) return;
-		const latest = latestVerdict();
-		entries[entries.length - 1] = {
-			...last,
-			after: latest.read > lastNote.read ? summarizeVerdict(latest.verdict) : null
-		};
-	};
-	return {
-		async compose(context) {
-			closePrevious();
-			const continuation = entries.length + 1;
-			const { verdict, read } = latestVerdict();
-			const failing = verdict === void 0 ? [] : failedItems(verdict);
-			let panelRecord;
-			let panelLines;
-			if (policy.panel === "on" && policy.runPanel !== void 0 && policy.panelUsd !== void 0) {
-				const workers = input.workers();
-				const questions = expandQuestions(policy.profile.questions ?? [], failing, workers);
-				const left = policy.panelUsd.perRun - panelUsd;
-				const usdCap = Math.min(policy.panelUsd.perContinuation, left);
-				const asking = questions.length > 0 && usdCap > 0 && panelUsdKnown;
-				let traces;
-				let unavailable;
-				if (asking) try {
-					traces = await input.traces?.();
-					if (traces === void 0) unavailable = "the run has recorded no trace yet";
-				} catch (error) {
-					unavailable = `the run's traces could not be read: ${error instanceof Error ? error.message : String(error)}`;
-				}
-				if (asking && traces !== void 0) {
-					const result = await policy.runPanel({
-						continuation,
-						task: input.task,
-						...verdict === void 0 ? {} : { verdict },
-						reads: input.reads(),
-						questions,
-						traces,
-						workers,
-						...policy.best === void 0 ? {} : { bar: policy.best },
-						...policy.reference === void 0 ? {} : { reference: policy.reference },
-						usdCap,
-						signal: context.signal
-					});
-					if (result.usd === null) panelUsdKnown = false;
-					else panelUsd += result.usd;
-					findings = distillFindings(findings, result.findings, new Set(failing), continuation);
-					panelRecord = {
-						asked: questions.length,
-						proposed: result.findings.length,
-						admitted: findings.filter((finding) => finding.admittedAt === continuation).length,
-						usd: result.usd
-					};
-					panelLines = [...result.findings.map((finding) => ({
-						kind: "finding",
-						admitted: admitFinding(finding),
-						...finding
-					})), ...result.receipts === void 0 ? [] : [{
-						kind: "receipts",
-						receipts: result.receipts
-					}]];
-				} else panelRecord = {
-					asked: 0,
-					proposed: 0,
-					admitted: 0,
-					usd: 0,
-					...unavailable === void 0 ? {} : { unavailable }
-				};
-			}
-			const appended = policy.append ? await policy.append({
-				continuation,
-				...verdict === void 0 ? {} : { verdict },
-				reads: input.reads(),
-				signal: context.signal
-			}) : void 0;
-			const note = composeContinuationNote({
-				profile: policy.profile,
-				continuation,
-				...verdict === void 0 ? {} : { verdict },
-				...notes.at(-1)?.verdict === void 0 ? {} : { previous: notes.at(-1)?.verdict },
-				reads: input.reads().length,
-				failures,
-				...policy.panel === "on" ? { findings } : {},
-				...policy.bar === "on" ? { bar: {
-					...policy.best === void 0 ? {} : { best: policy.best },
-					...policy.reference === void 0 ? {} : { reference: policy.reference }
-				} } : {},
-				...appended === void 0 ? {} : { appended: [appended] },
-				...input.owed === void 0 ? {} : { owed: input.owed },
-				progress: context.progress,
-				canReadMore: input.canReadMore,
-				canSubmitResult: input.canSubmitResult === true,
-				...input.sealed === true ? { sealed: true } : {}
-			});
-			notes.push({
-				note,
-				...verdict === void 0 ? {} : { verdict },
-				...panelLines === void 0 ? {} : { panel: panelLines },
-				read
-			});
-			entries.push({
-				continuation,
-				attempt: context.attempt,
-				noteDigest: noteDigest(note),
-				profile: policy.profile.id,
-				switches: {
-					failures,
-					panel: policy.panel,
-					bar: policy.bar
-				},
-				before: summarizeVerdict(verdict),
-				after: null,
-				...panelRecord === void 0 ? {} : { panel: panelRecord },
-				appended: appended === void 0 ? 0 : 1
-			});
-			if (input.dir !== void 0) await writeContinuationFiles(input.dir, continuation, {
-				note,
-				...verdict === void 0 ? {} : { verdict },
-				...panelLines === void 0 ? {} : { panel: panelLines }
-			});
-			return note;
-		},
-		read(continuation) {
-			const index = continuation === void 0 ? notes.length - 1 : continuation - 1;
-			const entry = notes[index];
-			if (entry === void 0) return {
-				found: false,
-				reason: notes.length === 0 ? "no continuation has been sent in this run" : `continuations run from 1 to ${notes.length}`
-			};
-			return {
-				found: true,
-				continuation: index + 1,
-				note: entry.note,
-				verdict: failures === "off" && entry.verdict !== void 0 ? { pass: entry.verdict.pass } : entry.verdict ?? null,
-				findings: findings.filter((finding) => finding.admittedAt <= index + 1)
-			};
-		},
-		entries() {
-			closePrevious();
-			return entries.map((entry) => ({ ...entry }));
-		}
-	};
-}
 // src/runtime/supervise/completion-gate.ts
 /**
 * Wrap an `Executor` so its settlement `valid` reflects the deliverable check, not the
@@ -5584,13 +5088,7 @@ async function preflightPublicCoordination(input) {
 /** Sandbox's `PartialFailureError` on `error` or a cause, read by name: packages that hold their own
 *  copy of the class would miss an `instanceof`. */
 const causedByPartialFailure = (error) => causeChain(error).some((cause) => cause instanceof Error && errorProperty(cause, "name") === "PartialFailureError");
-/**
-* The pending invocation a failure left, when abandoning it is the resolution: the provider could
-* not resolve the execution (`unobservable`), or a nested manager's recovery could not be rebuilt
-* (`nested-recovery`). A lost transport waits in the outage window instead, and a capacity refusal
-* pauses, so neither starts a second execution beside one that may still run. A request refused
-* before it ran has nothing to abandon. A contract violation stays terminal (#1204).
-*/
+/** Abandon only `unobservable` or `nested-recovery`. Transport and capacity stay; a refused request and a contract violation do not start a second execution. */
 function abandonablePending(error) {
 	return error instanceof RetainedExecutionPendingError && (error.pendingCause === "unobservable" || error.pendingCause === "nested-recovery") ? error : void 0;
 }
@@ -5602,11 +5100,7 @@ const DETERMINISTIC_BRIDGE_CODES = /* @__PURE__ */ new Set([
 	"MODEL_NOT_FOUND",
 	"SEAT_NOT_LOGGED_IN"
 ]);
-/**
-* A model provider's content-filter refusal, which Codex names only in text under the generic
-* `AGENT_EXECUTION_FAILED`. It stays transient; the retry loop bounds a streak of them and stops
-* with this reason, for the parent to reword or re-scope the task.
-*/
+/** Content-filter text under `AGENT_EXECUTION_FAILED` stays transient; a streak of it stops for the parent to reword. */
 const CONTENT_FILTER_REASON = "refused by the model provider's content filter";
 const isContentFilterRefusal = (error) => causeChain(error).some((cause) => cause instanceof Error && /\bcontent was flagged for possible\b/iu.test(errorProperty(cause, "message") ?? ""));
 /** A completed failed turn enters retry with its producer classification and legacy metadata intact. */
@@ -5681,6 +5175,9 @@ function upstreamUnavailableSignal(error) {
 	};
 	return (harness ? subscriptionUsageLimitSignal(failure) : void 0) ?? unavailableSignalOfFailure(failure);
 }
+function materializationTimedOut(error) {
+	return causeChain(error).some((cause) => cause instanceof Error && errorProperty(cause, "name") === "RetainedMaterializationTimeoutError");
+}
 /** Capacity encountered while reconciling an admitted execution pauses that same execution. */
 function reconciliationCapacityRefusal(error) {
 	if (!(error instanceof RetainedExecutionPendingError) || error.phase !== "execution") return void 0;
@@ -5700,6 +5197,7 @@ function ownCode(error) {
 /** Runtime cancellation/contracts dominate producer policy; untyped foreign failures retain legacy rules. */
 function classifyDriverFailure(error, signal, stopSignal) {
 	if (signal?.aborted) return "terminal";
+	if (materializationTimedOut(error)) return "terminal";
 	if (error instanceof CheckUnavailableError || error instanceof CoordinationUnreachableError) return "unavailable";
 	if (error instanceof RetainedExecutionPendingError && error.pendingCause === "provider-contract") return "terminal";
 	if (undispatchedCredentialExit(error) !== void 0) return "unavailable";
@@ -5765,12 +5263,7 @@ function retainedAdmissionCause(error) {
 		}
 	}
 }
-/**
-* A foreign error's HTTP status, read by the transport branch's rule: 408 and 5xx are a bad
-* moment, any other 4xx fails identically forever. A provider SDK's own classes reach here: a
-* Sandbox create refused `HTTP 400 {"code":"CONFIG_ERROR"}` for a fully reserved key was retried
-* 14-22 times per node as transient. Capacity statuses were answered before this point.
-*/
+/** 408 and 5xx are transient. Any other 4xx fails identically, including a sandbox `CONFIG_ERROR`. Capacity was already classified. */
 function foreignHttpStatusVerdict(error) {
 	if (!(error instanceof Error)) return void 0;
 	const status = errorHttpStatus(error);
@@ -5879,9 +5372,7 @@ function taskToPrompt$1(task) {
 	return JSON.stringify(task);
 }
 // src/runtime/supervise/bridge-session-stream.ts
-/** One resumable cli-bridge session as a streamed turn loop: turn 0 sends the task, each later
-*  turn fires ONLY when the inbox has a steer/answer to fold, re-calling the SAME `session_id`.
-*  Mirrors `routerToolsInlineExecutor`'s take→turn→settle loop with a full harness call per turn. */
+/** Resumable cli-bridge loop. Later turns fire only for a folded steer, on the same session. */
 async function* streamBridgeSession(args) {
 	const { seam, inbox, observation } = args;
 	const started = Date.now();
@@ -5930,7 +5421,7 @@ async function* streamBridgeSession(args) {
 			kind: "turn",
 			label: `turn ${ledger.turns}`
 		});
-		yield* ledger.settleTurn(activeRun.profileMaterialization?.inference?.observation?.usage, harnessStore, observation, seam.providerModel);
+		yield* ledger.settleTurn(activeRun.profileMaterialization?.inference?.observation?.usage, harnessStore, observation, seam.providerModel, args.profile.model?.metadata?.credentialSource);
 		yield { kind: "iteration" };
 		if (!interrupted) {
 			if (ledger.turn.text) ledger.lastText = ledger.turn.text;
@@ -5962,9 +5453,7 @@ function foldTurnMessages(turnLease, inbox, observation) {
 	});
 	return folded;
 }
-/** Prove this bridge can accept the turn before allocating a remote run id. A refusal still becomes
-*  an attempt with no-dispatch evidence; the empty active-run map keeps teardown from cancelling
-*  work the bridge never accepted. */
+/** Prove the bridge can accept the turn before a remote run id. A refusal dispatches nothing. */
 async function preflightBridgeTurn(args, signals, turns) {
 	const { seam, observation } = args;
 	let initialModelCredential;
@@ -6078,10 +5567,7 @@ async function* streamBridgeTurn(args, turn) {
 		interrupted
 	};
 }
-/**
-* A failed turn stream: a forceful steer's interruption returns once the durable run is terminal;
-* anything else throws, as the turn failure it is.
-*/
+/** A forceful steer returns after the run is terminal. Anything else throws. */
 async function settleFailedTurn(error, args, signals, activeRun, external) {
 	const { seam } = args;
 	if (signals.interrupt.aborted && !args.signal.aborted && !args.controller.signal.aborted) {
@@ -6278,39 +5764,9 @@ function bridgeTranscript(seam, sessionId, profile, runs, node) {
 }
 // src/runtime/supervise/peer-mail.ts
 /**
-*
-* PEER MAIL — the sibling-to-sibling channel, and the ONE place its bounds are enforced.
-*
-* Before this, a worker could only be reached by its parent: the inbox understood `steer` and
-* `answer`, both parent-authored, and the only worker-to-worker path fired at SETTLE time through
-* an analyst lens. Two live workers therefore could not compare results, one could not challenge
-* another's claim, and a blocked worker could not ask the peer that already had the fact.
-*
-* The mailbox is a POST OFFICE the parent owns, not a socket between workers. A worker never
-* touches another worker's inbox: it calls `send_mail` on a capability endpoint, and THIS module —
-* running with the parent's `Scope` — decides whether the envelope is admitted and then calls
-* `Scope.send`. Every decision, including every refusal, is published as a coordination event, so
-* the parent stays the auditor of a channel it no longer has to relay.
-*
-* Four properties this module is responsible for, each of which fails CLOSED:
-*
-*  - IDENTITY. `from` is never a tool argument. A capability id is minted per spawn assignment and
-*    bound to that assignment's concrete worker id once the spawn succeeds; the sender is read from
-*    the binding. An unbound capability can send nothing (`sender-unbound`). The capability is the
-*    ONLY thing a worker holds, and it carries no coordination verb — a worker that can send mail
-*    still cannot spawn, steer, or stop anything.
-*  - AUTHORITY. Peer mail is information, never instruction. A body or subject that tries to speak
-*    as the supervisor is refused at intake (`forged-authority`) and the receiver's render fences
-*    what survives — see {@link AUTHORITY_MARKERS} and the inbox's peer block.
-*  - BOUNDS. A per-sender send quota, a per-receiver inbox cap in both count and bytes, a maximum
-*    reply depth, and hard byte caps on subject and body. Every attempt that reaches the quota
-*    check consumes one unit whether or not it delivers, so probing for refusals is not free.
-*  - PROVENANCE. Mail may carry evidence refs for the receiver to re-check. Mail confers no
-*    verification: evidence is judged by the reader and the external claim audit, not by the mail
-*    form. Nothing is promoted because a peer asserted it.
-*
-* Scope is ONE run: siblings under one manager's live scope. No cross-run, no cross-org, no
-* outbound HTTP.
+* The parent mailbox. A worker calls `send_mail`; `from` is the capability binding, never a
+* tool argument. Forged authority is refused. A quota check consumes the attempt. Mail confers
+* no verification. One run only.
 *
 * @experimental
 */
@@ -6575,51 +6031,15 @@ function peerMailTools(mailbox, capabilityId) {
 }
 // src/runtime/supervise/inbox.ts
 /**
-*
-* The worker-side receive end of the down-leg: a per-worker inbox an executor exposes as
-* `Executor.deliver`. The driver's `steer_agent` / `answer_question` land here,
-* and the worker's agent loop takes them at two points:
-*
-*   - QUEUED (default): the message accumulates and is taken at the next step boundary — folded
-*     into the conversation before the next think. A worker also takes before it may settle, so it
-*     can never finish while a steer/answer it never read is still pending.
-*   - FORCEFUL (`interrupt: true`): trips `freshInterrupt()`'s signal so the loop can abort its
-*     in-flight turn immediately, then re-plan with the message folded in — breaking the worker out
-*     of a wrong path mid-task instead of waiting for it to finish the step.
-*
-* Taking is a LEASE, never a removal. A loop calls {@link Inbox.take}, folds the messages into its
-* next model input, and commits each one only once the provider accepted that input. Any failure,
-* abort or re-entry before then releases the lease, and the messages return to the head of the
-* queue ahead of later arrivals. A failed turn therefore cannot lose what it took: in run 18b a
-* director ruling and a failed-check notice were drained into a turn that failed, and the next two
-* prompts said "Events waiting for you: none".
-*
-* Every authority message ends in exactly one receipt to its sender: `consumed`, naming the
-* attempt whose accepted input carried it, or `failed`, naming why. Two rules bound the wait:
-*
-*   - PROMOTION: an authority message still unconsumed {@link AUTHORITY_PROMOTION_MS} after it
-*     arrived becomes an interrupt and aborts the turn in flight, so the next input carries it.
-*     A promoted message gets that one attempt; if the lease holding it is released again, the
-*     message fails instead of waiting another boundary. The sender hears within 15 minutes plus
-*     one attempt.
-*   - SETTLE: a recipient that stops with messages still held calls {@link Inbox.failPending},
-*     which reports each one failed. A recipient that cannot run another turn (no budget, a stop
-*     request, a failed run) therefore settles, and its sender learns the steer was not read.
-*
-* A THIRD kind arrives here too: peer mail from a sibling worker (`./peer-mail`). It is carried on
-* its own wire property, and this file keeps it strictly apart from the two authority kinds:
-*
-*   - It can never be forceful. `interrupt` is written as `false` and the wire field is ignored, so
-*     a peer cannot abort a peer's in-flight turn and hold it at zero progress.
-*   - It never blocks a settle. The pre-settle fence counts {@link Inbox.pendingAuthority}, not
-*     total pending, because a peer that keeps mail arriving would otherwise deny a FINISHED worker
-*     its settlement.
-*   - It renders in its own block, fenced with a per-fold nonce and attributed to its sender. The
-*     `[SUPERVISOR]` header is emitted for authority messages ONLY, so a mixed lease cannot present
-*     a peer's message as an instruction from the parent.
-*
-* `deliver` never throws — a malformed message is ignored and returns `false`, so no caller can
-* report delivery for bytes this inbox discarded.
+* Worker inbox behind `Executor.deliver`. Queued `steer_agent` / `answer_question` messages are
+* taken at the next step boundary, including before settle. `interrupt: true` aborts the turn in
+* flight. {@link Inbox.take} is a lease: commit only after the provider accepts the input, otherwise
+* the messages return to the head of the queue. Each authority message gets one receipt, `consumed`
+* or `failed`. After {@link AUTHORITY_PROMOTION_MS} an unconsumed authority message interrupts once;
+* a released lease then fails it. A recipient that stops calls {@link Inbox.failPending}. Peer mail
+* (`./peer-mail`) is never forceful, never blocks settle ({@link Inbox.pendingAuthority} is the
+* fence), and renders in its own block without the `[SUPERVISOR]` header. `deliver` returns `false`
+* for a malformed message and does not throw.
 *
 * @experimental
 */
@@ -8802,6 +8222,19 @@ function retainedDispatchMaterial(args, retention, selectedTurn, signal) {
 	const environmentKey = priorSession?.idempotencyKey ?? `runtime:${args.executionId}`;
 	const turnId = `${args.executionId}:turn:0`;
 	const restore = priorSession === void 0 ? retention.restoreWorkspace : void 0;
+	const attachments = priorSession && args.options.defaults?.runtimeAttachments?.mcp;
+	const backend = recordValue(selectedTurn.providerOptions?.backend);
+	const mcp = {
+		...attachments,
+		...recordValue(recordValue(backend?.runtimeAttachments)?.mcp)
+	};
+	const providerOptions = {
+		...selectedTurn.providerOptions,
+		backend: {
+			...backend,
+			runtimeAttachments: { mcp }
+		}
+	};
 	return {
 		material: {
 			environment: {
@@ -8816,7 +8249,8 @@ function retainedDispatchMaterial(args, retention, selectedTurn, signal) {
 			},
 			turn: {
 				...selectedTurn,
-				turnId
+				turnId,
+				...attachments ? { providerOptions } : {}
 			},
 			preserveEnvironment: retention.preserveEnvironment,
 			...priorSession === void 0 ? {} : {
@@ -8921,7 +8355,8 @@ async function retainedExecution(args, retention, turn, selectedTurn, signal) {
 			retained: true
 		};
 	} catch (error) {
-		if (proof.admitted) throw new RetainedExecutionPendingError(error, proof.executionAdmitted ? "execution" : "admission");
+		if (error instanceof RetainedMaterializationTimeoutError) throw error;
+		if (proof.admitted && !retainedSessionReplaced(error)) throw new RetainedExecutionPendingError(error, proof.executionAdmitted ? "execution" : "admission");
 		throw error;
 	}
 }
@@ -9504,7 +8939,7 @@ var ProviderTurnSettlement = class {
 	async *fail(error) {
 		const { args } = this;
 		yield* this.usage.settleTurn();
-		this.failure = this.retained ? new RetainedExecutionPendingError(error) : error;
+		this.failure = this.retained && !retainedSessionReplaced(error) ? new RetainedExecutionPendingError(error) : error;
 		this.failed = true;
 		await this.stopEndedHarness();
 		args.scope.state.settleTranscript();
@@ -9543,6 +8978,8 @@ var ProviderUsageAccount = class {
 	ledger;
 	worker;
 	tokens = zeroTokenUsage();
+	/** Live-stream tokens captured at the first broken-stream event, before its exact result replaces them. */
+	streamedTokens;
 	usd = 0;
 	usdEstimated = 0;
 	sawCompleteTokenReceipt = false;
@@ -9569,18 +9006,16 @@ var ProviderUsageAccount = class {
 		this.sawUnknownCostReceipt = true;
 	}
 	*observe(event) {
+		if (this.streamedTokens === void 0 && streamBroke(event)) this.streamedTokens = cloneTokenUsage(this.tokens);
 		yield* this.credit(this.ledger.observe(event, this.worker), event);
 	}
 	*settleTurn() {
 		yield* this.credit(this.ledger.settleTurn(this.worker));
 	}
-	/**
-	* Interim missing prices and catalog estimates may be covered by a later cumulative bill.
-	* Only unresolved work becomes unknown at settlement; do not add a quote to that bill.
-	*/
+	/** Unresolved work stays unknown. Do not add a quote to a bill that already arrived. */
 	*settleUnpricedWork() {
 		if (!this.pendingUnpricedWork) return;
-		const estimated = this.pendingEstimate ?? (this.usd === 0 ? this.catalogPrice() : void 0);
+		const estimated = this.subscriptionSeat() ? void 0 : this.pendingEstimate ?? (this.usd === 0 ? this.catalogPrice() : void 0);
 		const estimate = estimated ?? 0;
 		this.sawUnknownCostReceipt = true;
 		this.usd += estimate;
@@ -9605,7 +9040,8 @@ var ProviderUsageAccount = class {
 			usd: this.usd,
 			usdKnown: this.sawCostReceipt && !this.sawUnknownCostReceipt,
 			...this.sawCostEstimate ? { usdEstimated: this.usdEstimated } : {},
-			ms: Date.now() - started
+			ms: Date.now() - started,
+			...this.streamBreak()
 		};
 		const { carried } = this.args;
 		return carried === void 0 ? spent : {
@@ -9616,13 +9052,27 @@ var ProviderUsageAccount = class {
 			ms: Date.now() - this.args.executionStartedAt
 		};
 	}
-	/**
-	* The catalog price of the execution's whole token total under the first model id the catalog
-	* knows, or undefined: absence says "nothing could be priced", a zero would say "priced at
-	* nothing". Candidates run most specific first: the id a receipt reported, the turn's model,
-	* the profile's (a provider on its own default declares none, so a reported id is the only match).
-	*/
+	/** What the live stream carried, and the exact-result remainder when that result exceeded it. */
+	streamBreak() {
+		if (this.streamedTokens === void 0) return {};
+		const streamedTokens = cloneTokenUsage(this.streamedTokens);
+		const gap = tokenGap(streamedTokens, this.tokens);
+		const unobservedTokens = gap === void 0 ? void 0 : cloneTokenUsage(gap);
+		return {
+			streamedTokens,
+			...unobservedTokens === void 0 ? {} : {
+				unobservedTokens,
+				iterationsKnown: false
+			}
+		};
+	}
+	/** A subscription seat is unpriced. Its profile declares no per-call bill. */
+	subscriptionSeat() {
+		return [this.args.profile, this.args.createProfile].some((profile) => profile.model?.metadata?.credentialSource === "subscription");
+	}
+	/** Catalog price of the whole token total, or undefined when nothing could be priced. */
 	catalogPrice() {
+		if (this.subscriptionSeat()) return void 0;
 		const { tokens } = this;
 		for (const model of [
 			this.observedModel,
@@ -9640,8 +9090,7 @@ var ProviderUsageAccount = class {
 			if (priced.usdKnown === false && priced.usdEstimated !== void 0) return priced.usdEstimated;
 		}
 	}
-	/** This invocation's cumulative tokens as the execution's: a continuation adds what its earlier
-	*  invocations already reported. */
+	/** This invocation's tokens plus what a continuation already carried. */
 	executionTokens(own) {
 		const { carried } = this.args;
 		if (carried === void 0) return own;
@@ -9699,6 +9148,36 @@ var ProviderUsageAccount = class {
 		} else if (input > 0 || output > 0 || receipt.tokensKnown === false) this.pendingUnpricedWork = true;
 	}
 };
+function streamBroke(event) {
+	return event.data.eventStreamComplete === false;
+}
+/** Counters gained after `streamed`. A cache class past the input gap is omitted. */
+function tokenGap(streamed, recorded) {
+	const input = Math.max(0, recorded.input - streamed.input);
+	const output = Math.max(0, recorded.output - streamed.output);
+	const gap = {
+		input,
+		output
+	};
+	for (const key of [
+		"freshInput",
+		"cacheRead",
+		"cacheWrite"
+	]) {
+		const next = recorded[key];
+		if (next === void 0) continue;
+		const delta = next - (streamed[key] ?? 0);
+		if (delta > 0) gap[key] = delta;
+	}
+	if ((gap.freshInput ?? 0) + (gap.cacheRead ?? 0) + (gap.cacheWrite ?? 0) > input) {
+		delete gap.freshInput;
+		delete gap.cacheRead;
+		delete gap.cacheWrite;
+		gap.cacheBreakdownKnown = false;
+	}
+	if (input === 0 && output === 0 && gap.cacheBreakdownKnown !== false) return void 0;
+	return gap;
+}
 // src/runtime/environment-provider/provider-invocation.ts
 /** The turn this invocation sends: the task's turn under the provider's defaults and placement rules. */
 function invocationTurn(args) {
@@ -9722,7 +9201,7 @@ async function* streamProviderExecutor(args) {
 	recordRuntimeOwnedProviderAttemptStart(args.scope.executor());
 	const source = await providerExecutionSource(args, turn, args.signal);
 	const environment = source.environment;
-	args.onEnvironment(environment);
+	await args.onEnvironment(environment);
 	const usage = new ProviderUsageAccount(args, turn.model);
 	const observer = new ProviderTurnObserver(args, usage, source.retained, turn.model);
 	const settlement = new ProviderTurnSettlement(args, environment, source.retained, observer, usage, started);
@@ -9738,19 +9217,52 @@ async function* streamProviderExecutor(args) {
 }
 // src/runtime/environment-provider/provider-execution-loop.ts
 /** A new environment now backs this execution; the identity the provider issued is evidence. */
-function adoptEnvironment(scope, env) {
+async function adoptEnvironment(scope, env, signal) {
 	const { state, materialization } = scope;
 	state.environment = env;
 	state.resetWorkspace(env);
 	if (state.harnessTranscript.status === "unavailable" && state.harnessTranscript.reason === "execution-never-started") state.harnessTranscript = harnessTranscriptUnavailable("capture-did-not-run");
+	const resources = await appliedResources(env, signal);
 	finalizeRuntimeOwnedPendingExecutor(scope.executor(), {
 		...materialization.plannedDeclaration,
+		resources,
 		execution: {
 			kind: "environment",
 			id: env.id
 		}
 	}, materialization.plannedBinding);
 }
+/** Read the applied box sizes from the created environment's normalized observation. Unknown is
+* the honest answer whenever the environment offers no observation, reports no known effective
+* size, or fails to answer; the request the create input carried is never a substitute. */
+async function appliedResources(env, signal) {
+	if (env.observe === void 0) return {
+		status: "unknown",
+		reason: "created environment offers no observation"
+	};
+	try {
+		const effective = (await env.observe({ signal })).resources?.effective;
+		if (effective?.state !== "known") return {
+			status: "unknown",
+			reason: `created environment reported effective resources as ${effective === void 0 ? "none" : effective.state}`
+		};
+		const { value, provenance } = effective;
+		return {
+			status: "known",
+			...value.cpu === void 0 ? {} : { cpu: value.cpu },
+			...value.memoryMb === void 0 ? {} : { memoryMb: value.memoryMb },
+			...value.diskMb === void 0 ? {} : { diskMb: value.diskMb },
+			...value.accelerator === void 0 ? {} : { accelerator: value.accelerator },
+			origin: provenance.origin,
+			observedAt: provenance.observedAt
+		};
+	} catch (error) {
+		return {
+			status: "unknown",
+			reason: `created environment observation failed: ${errorMessage(error)}`
+		};
+	}
+}
 /** The seams one invocation reports through; `continued` marks a continuation of the execution. */
 function invocationArgs(scope, invocation, signal, carried, executionStartedAt, continued) {
 	const { state, options, provider, node, nativeControl } = scope;
@@ -9776,8 +9288,8 @@ function invocationArgs(scope, invocation, signal, carried, executionStartedAt,
 			state.providerSessionId = state.workspaceControlRef.sessionId;
 			nativeControl.cancelRetainedOnManagerStop(handle);
 		},
-		onEnvironment: (env) => {
-			if (!continued) return adoptEnvironment(scope, env);
+		onEnvironment: async (env) => {
+			if (!continued) return adoptEnvironment(scope, env, signal);
 			if (env.id !== state.environment?.id) throw new ValidationError(`providerAsExecutor(${provider.name}): a continuation ran in environment ${env.id}, not ${state.environment?.id ?? "<none>"}`);
 			state.environment = env;
 		}
@@ -10608,12 +10120,13 @@ function throwRouterFailureWithAttempts(error, attempts) {
 function routerErrorIdentity(error) {
 	return typeof error === "object" && error !== null || typeof error === "function" ? error : void 0;
 }
+/** The parsed body; a usage with no cost takes the Router's exact `x-tangle-cost-usd` (#1587). */
 async function routerResponseJson(response, attempts) {
-	try {
-		return await response.json();
-	} catch (error) {
-		throwRouterFailureWithAttempts(error, attempts);
-	}
+	const body = await response.json().catch((error) => throwRouterFailureWithAttempts(error, attempts));
+	const cost = Number(response.headers.get("x-tangle-cost-usd") || NaN);
+	const usage = body?.usage;
+	if (cost >= 0 && usage?.cost === void 0 && usage?.cost_usd === void 0 && usage) usage.cost = cost;
+	return body;
 }
 function agentCoreRetryConfig(retry, callerSignal) {
 	return {
@@ -15583,312 +15096,6 @@ function parkingRecordOf(record) {
 		wakeAt: record.wakeAt
 	};
 }
-// src/durable/spawn-journal/provider-model-evidence.ts
-/**
-* Aggregate provider-served model evidence across one recursively owned journal forest.
-*
-* The parent tree records an owned driver's terminal summary, while that driver's own inference
-* and descendants live in its owned tree. This reducer follows the forest reader's explicit tree
-* edges and consumes each tree's metered attempts plus terminal leaf settlements exactly once.
-* A summary node is skipped because its owned tree supplies the source records. Plan materialization
-* is intentionally not read: it proves only what Runtime requested, not what a provider served.
-*
-* Missing legacy evidence, an unfinished node, an unopened owned tree, an identity conflict, and a
-* paid attempt without a qualified served snapshot all return unknown. An explicit
-* `providerDispatch: "not_started"` arm and Runtime accounting-only metered records are ignored
-* for served-model identity, while absent or malformed legacy data remains unknown here.
-*/
-function aggregateProviderModelEvidence(forest) {
-	const attempts = [];
-	const observedModels = /* @__PURE__ */ new Set();
-	const canonicalModels = /* @__PURE__ */ new Set();
-	const nodes = /* @__PURE__ */ new Map();
-	let reason;
-	let sawProviderEvidence = false;
-	for (const node of forest.nodes) nodes.set(forestNodeKey(node.treeRoot, node.id), node);
-	if (forest.missingTrees.length > 0 || forest.inDoubt.length > 0) reason = "provider-model-missing";
-	const markMissing = () => {
-		reason ??= "provider-model-missing";
-	};
-	const markConflict = () => {
-		reason = "provider-model-conflict";
-	};
-	const append = (raw) => {
-		sawProviderEvidence = true;
-		if (!isProviderEvidenceObject(raw)) {
-			markMissing();
-			return;
-		}
-		if (raw.status === "unknown") {
-			if (raw.reason === "provider-model-conflict") markConflict();
-			else if (!hasOnlyNotStartedAttempts(raw)) markMissing();
-		} else if (raw.status !== "known") {
-			markMissing();
-			return;
-		}
-		if (!Array.isArray(raw.attempts) || !Array.isArray(raw.models)) {
-			markMissing();
-			return;
-		}
-		const declared = /* @__PURE__ */ new Set();
-		for (const model of raw.models) if (typeof model !== "string" || model.length === 0) markMissing();
-		else declared.add(model);
-		const observedInRecord = /* @__PURE__ */ new Set();
-		for (const rawAttempt of raw.attempts) {
-			if (!isProviderAttemptEvidence(rawAttempt)) {
-				markMissing();
-				continue;
-			}
-			if (rawAttempt.identityConflict === true) markConflict();
-			const observations = [...rawAttempt.observations];
-			if (rawAttempt.providerDispatch === "not_started") {
-				if (observations.length > 0) markMissing();
-				attempts.push(Object.freeze({
-					observations: Object.freeze([]),
-					providerDispatch: "not_started",
-					...rawAttempt.identityConflict === true ? { identityConflict: true } : {}
-				}));
-				continue;
-			}
-			if (observations.length === 0) {
-				markMissing();
-				attempts.push(Object.freeze({
-					observations: Object.freeze([]),
-					...rawAttempt.identityConflict === true ? { identityConflict: true } : {}
-				}));
-				continue;
-			}
-			let base;
-			let snapshot;
-			for (const model of observations) {
-				if (typeof model !== "string" || model.length === 0) {
-					markMissing();
-					continue;
-				}
-				observedInRecord.add(model);
-				observedModels.add(model);
-				const identity = servedIdentityParts(model);
-				if (identity === void 0) {
-					markMissing();
-					continue;
-				}
-				if (base !== void 0 && base !== identity.base) markConflict();
-				if (snapshot !== void 0 && identity.snapshot !== void 0 && snapshot !== identity.snapshot) markConflict();
-				base = identity.base;
-				snapshot ??= identity.snapshot;
-				if (identity.snapshot !== void 0) {
-					canonicalModels.add(`${identity.base}@${identity.snapshot}`);
-					if (canonicalModels.size > 1) markConflict();
-				}
-			}
-			if (base === void 0 || snapshot === void 0) markMissing();
-			attempts.push(Object.freeze({
-				observations: Object.freeze(observations),
-				...rawAttempt.identityConflict === true ? { identityConflict: true } : {}
-			}));
-		}
-		if (declared.size !== observedInRecord.size || [...declared].some((model) => !observedInRecord.has(model))) markMissing();
-	};
-	const terminal = (treeRoot, event) => {
-		const node = nodes.get(forestNodeKey(treeRoot, event.id));
-		if (node === void 0) {
-			markMissing();
-			return;
-		}
-		if (node.ownedTreeRoot !== void 0) return;
-		if (event.kind === "cancelled" && event.providerModel === void 0) {
-			markMissing();
-			return;
-		}
-		append(event.providerModel ?? node.providerModel);
-	};
-	for (const tree of forest.trees) for (const event of tree.events) if (event.kind === "metered") {
-		if (event.accountingOnly === true) {
-			if (event.providerModel !== void 0) markMissing();
-			continue;
-		}
-		if (nodes.get(forestNodeKey(tree.root, event.id))?.ownedTreeRoot !== void 0) continue;
-		const evidence = event.providerModel;
-		if (evidence === void 0) markMissing();
-		else append(evidence);
-	} else if (event.kind === "settled" || event.kind === "cancelled") terminal(tree.root, event);
-	if (!sawProviderEvidence || attempts.length === 0 || observedModels.size === 0) reason ??= "provider-model-missing";
-	const models = Object.freeze([...observedModels]);
-	const frozenAttempts = Object.freeze(attempts);
-	return Object.freeze(reason === void 0 ? {
-		status: "known",
-		attempts: frozenAttempts,
-		models
-	} : {
-		status: "unknown",
-		attempts: frozenAttempts,
-		models,
-		reason
-	});
-}
-function forestNodeKey(treeRoot, nodeId) {
-	return `${treeRoot}\u0000${nodeId}`;
-}
-function isProviderEvidenceObject(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value) && "status" in value;
-}
-function hasOnlyNotStartedAttempts(evidence) {
-	return Array.isArray(evidence.attempts) && evidence.attempts.length > 0 && evidence.attempts.every((attempt) => isProviderAttemptEvidence(attempt) && attempt.providerDispatch === "not_started" && attempt.observations.length === 0 && attempt.identityConflict !== true);
-}
-function isProviderAttemptEvidence(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value) && Array.isArray(value.observations) && (value.providerDispatch === void 0 || value.providerDispatch === "not_started");
-}
-function servedIdentityParts(model) {
-	const at = model.lastIndexOf("@");
-	const rawBase = at < 0 ? model : model.slice(0, at);
-	const base = rawBase.slice(rawBase.lastIndexOf("/") + 1);
-	if (base.length === 0) return void 0;
-	const snapshot = at < 0 ? void 0 : model.slice(at + 1);
-	if (snapshot !== void 0 && snapshot.length === 0) return void 0;
-	return snapshot === void 0 ? { base } : {
-		base,
-		snapshot
-	};
-}
-// src/runtime/supervise/supervisor-accounting.ts
-/**
-* The run's terminal accounting, read off the one journal ledger — the honest per-channel
-* sums (input/output/usd/iterations all preserved), the named usage gaps, and the wall-clock
-* duration stamped onto `spentTotal.ms`. Computed AFTER the join barrier so every child's
-* settlement is recorded. Fails loud if the tree was never journaled (the supervisor always
-* `beginTree`s, so a missing tree is a corrupted journal, not a normal path).
-*
-* `spentTotal.ms` is `elapsedMs`, never the per-event sum: executors under-report their own
-* `ms` (most stamp 0) and parallel children overlap, so the sum cannot state the run's real
-* duration. The breakdown keeps the executor-reported sums.
-*
-* `tokensKnown`/`usdKnown` are stamped explicitly on the terminal total: `true` is a checked
-* claim (every spawn reached a terminal record AND every settled/metered record carried a
-* complete receipt on that channel), never the absence of bad news. The conjunction with the
-* summed flags is deliberately redundant — a future divergence between the sum and the gap
-* scan can only make the claim more conservative, never falsely `true`.
-*/
-async function terminalAccounting(journal, root, elapsedMs) {
-	const events = await journal.loadTree(root);
-	if (events === void 0) throw new RuntimeRunStateError(`supervisor: spawn tree '${root}' is missing from the journal after run (corrupted log)`);
-	const { childWork, driverInference } = sumSpendFromEvents(events);
-	const gaps = spendGapsFromEvents(events);
-	const forest = await loadSpawnForest(journal, root);
-	const providerModel = aggregateProviderModelEvidence(forest);
-	const fleetYield = fleetYieldFromForest(forest);
-	const summed = addSpend(childWork, driverInference);
-	return {
-		spentTotal: {
-			...summed,
-			ms: Math.max(0, elapsedMs),
-			tokensKnown: summed.tokensKnown !== false && !gaps.some((gap) => gap.channels.includes("tokens")),
-			usdKnown: summed.usdKnown !== false && !gaps.some((gap) => gap.channels.includes("usd"))
-		},
-		childWork,
-		driverInference,
-		gaps,
-		providerModel,
-		fleetYield
-	};
-}
-/** How the run's spawned children ended, by node id across every tree of the forest. Read after
-*  the join barrier and the release sweep, so the terminal records the sweep wrote are in it.
-*  Spawned records without a parent are exempt: the run root, and the re-rooted owner copy a
-*  nested driver writes as its tree's first record (`ownedTreeRootSpawn` strips the parent), so
-*  a manager is counted once, in its parent's tree. Buckets are id sets rather than record counts
-*  because the journal guards seq uniqueness, not one-terminal-per-node, and the invariant
-*  `spawned === done + down + cancelled + neverSettled` must not rest on scope discipline alone;
-*  it is asserted here so a future root-id terminal record cannot silently break the tally. */
-function fleetYieldFromForest(forest) {
-	const spawned = /* @__PURE__ */ new Set();
-	const terminal = /* @__PURE__ */ new Map();
-	const released = /* @__PURE__ */ new Set();
-	const unconfirmed = /* @__PURE__ */ new Set();
-	for (const { event } of forest.events) if (event.kind === "spawned") {
-		if (event.parent !== void 0) spawned.add(event.id);
-	} else if (event.kind === "settled" || event.kind === "cancelled") {
-		const bucket = event.kind === "cancelled" ? "cancelled" : event.status;
-		terminal.set(event.id, bucket);
-		released.delete(event.id);
-		unconfirmed.delete(event.id);
-		if (bucket !== "done" && event.retainedExecution === "released") released.add(event.id);
-		if (bucket !== "done" && event.retainedExecution === "release-unconfirmed") unconfirmed.add(event.id);
-	}
-	const count = (bucket) => [...terminal.values()].filter((value) => value === bucket).length;
-	const fleetYield = {
-		spawned: spawned.size,
-		done: count("done"),
-		down: count("down"),
-		cancelled: count("cancelled"),
-		neverSettled: forest.inDoubt.length,
-		releasedUnrecovered: released.size,
-		releaseUnconfirmed: unconfirmed.size
-	};
-	if (fleetYield.done + fleetYield.down + fleetYield.cancelled + fleetYield.neverSettled !== fleetYield.spawned) throw new RuntimeRunStateError(`supervisor: fleet yield does not partition the spawned children of '${forest.root}' (${JSON.stringify(fleetYield)})`);
-	if (fleetYield.releasedUnrecovered + fleetYield.releaseUnconfirmed > fleetYield.down + fleetYield.cancelled) throw new RuntimeRunStateError(`supervisor: released children exceed down + cancelled for '${forest.root}' (${JSON.stringify(fleetYield)})`);
-	return fleetYield;
-}
-/** The journaled nodes whose usage accounting is incomplete — one `SpendGap` per node+kind,
-*  channels merged. A spawn with no terminal record (`settled`/`cancelled`/`woken`) is
-*  unaccounted on every channel; a settled or metered record that flags a channel unknown is
-*  a floor on that channel. The root's own spawned event is exempt: its terminal state is the
-*  result this list rides on. */
-function spendGapsFromEvents(events) {
-	const labels = /* @__PURE__ */ new Map();
-	const budgets = /* @__PURE__ */ new Map();
-	const terminal = /* @__PURE__ */ new Set();
-	for (const ev of events) if (ev.kind === "spawned") {
-		labels.set(ev.id, ev.label);
-		budgets.set(ev.id, ev.budget);
-	} else if (closesCursorSlot(ev)) terminal.add(ev.id);
-	const gaps = /* @__PURE__ */ new Map();
-	const record = (id, kind, channels) => {
-		if (channels.length === 0) return;
-		const key = `${kind}:${id}`;
-		const existing = gaps.get(key);
-		if (existing !== void 0) for (const channel of channels) existing.channels.add(channel);
-		else gaps.set(key, {
-			id,
-			kind,
-			channels: new Set(channels)
-		});
-	};
-	for (const ev of events) if (ev.kind === "spawned" && ev.parent !== void 0 && !terminal.has(ev.id)) record(ev.id, "never-settled", [
-		"tokens",
-		"usd",
-		...Object.keys(ev.budget.resources ?? {}).map((name) => `resource:${name}`)
-	]);
-	else if (ev.kind === "cancelled" && ev.spent === void 0) record(ev.id, "unreported", [
-		"tokens",
-		"usd",
-		...Object.keys(budgets.get(ev.id)?.resources ?? {}).map((name) => `resource:${name}`)
-	]);
-	else if (ev.kind === "settled" || ev.kind === "cancelled" && ev.spent !== void 0) record(ev.id, "unreported", unknownChannels(withBudgetResources(ev.spent, budgets.get(ev.id) ?? {})));
-	else if (ev.kind === "metered") record(ev.id, "unreported", unknownChannels(ev.spend));
-	return [...gaps.values()].map((gap) => {
-		const label = labels.get(gap.id);
-		return {
-			id: gap.id,
-			...label !== void 0 ? { label } : {},
-			kind: gap.kind,
-			channels: [...gap.channels]
-		};
-	});
-}
-/** The channels a single spend record explicitly marks incomplete. */
-function unknownChannels(spend) {
-	const channels = [];
-	if (spend.tokensKnown === false) channels.push("tokens");
-	if (spend.usdKnown === false) channels.push("usd");
-	for (const [name, resource] of Object.entries(spend.resources ?? {})) if (!resource.known) channels.push(`resource:${name}`);
-	return channels;
-}
-/** 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`. */
-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 || Object.values(s.resources ?? {}).some((resource) => resource.amount > 0 || !resource.known);
-}
 // src/runtime/supervise/supervisor-child-join.ts
 /**
 * Drain the root scope's live set so every still-running/acquiring child is torn down
@@ -16324,13 +15531,14 @@ function guardRunPersistence(journal, blobs, interrupt) {
 /** Read every caller-owned field once, then detach and freeze all decision data before the first
 *  await; stateful collaborators stay live by reference, but later opts mutation cannot redirect the run. */
 function admitSupervisorRun(task, opts) {
-	const { budget, rootIdentity, rootSegment, rootMaterialization, runId, journal: journalStore, blobs: blobStore, executors: executorRegistry, recoverExecutor, maxDepth, workerSlots, reservationPolicy, deadlineCheckIn, budgetStopHoldMs, maxRestarts, withinMs, childSettleGraceMs, teardownConfirmMs, resume, retainedAtSettlement: requestedRetainedAtSettlement, now: suppliedNow, signal, hooks, workerTrace, workerTraceUnpropagated, interactiveBindingDir } = opts;
+	const { budget, rootIdentity, requestedProfile, rootSegment, rootMaterialization, runId, journal: journalStore, blobs: blobStore, executors: executorRegistry, recoverExecutor, maxDepth, workerSlots, reservationPolicy, deadlineCheckIn, budgetStopHoldMs, maxRestarts, withinMs, childSettleGraceMs, teardownConfirmMs, resume, retainedAtSettlement: requestedRetainedAtSettlement, now: suppliedNow, signal, hooks, workerTrace, workerTraceUnpropagated, interactiveBindingDir } = opts;
 	const input = detachedSnapshot({
 		task,
 		options: {
 			budget,
 			runId,
 			...rootIdentity === void 0 ? {} : { rootIdentity },
+			...requestedProfile === void 0 ? {} : { requestedProfile },
 			...rootSegment === void 0 ? {} : { rootSegment },
 			...rootMaterialization === void 0 ? {} : { rootMaterialization },
 			...maxDepth === void 0 ? {} : { maxDepth },
@@ -16860,20 +16068,21 @@ async function settleRootResult(settled) {
 			pool.assertNoOpenTickets();
 			const outRef = contentAddress(out);
 			await settled.opts.blobs.put(outRef, out);
-			const { spentTotal, childWork, driverInference, gaps, providerModel, fleetYield } = await terminalAccounting(settled.journal, settled.opts.runId, settled.now() - settled.runEpochMs);
+			const accounting = await terminalAccounting(settled.journal, settled.opts.runId, settled.now() - settled.runEpochMs, settled.opts.requestedProfile);
 			return {
 				kind: "winner",
 				out,
 				outRef,
-				tree: settled.tree,
-				spentTotal,
-				providerModel,
+				tree: accounting.tree,
+				spentTotal: accounting.spentTotal,
+				usage: accounting.usage,
+				providerModel: accounting.providerModel,
 				...teardownUnconfirmed.length > 0 ? { teardownUnconfirmed } : {},
-				...gaps.length > 0 ? { spendGaps: gaps } : {},
-				fleetYield,
-				...isNonEmptySpend(driverInference) ? { spentBreakdown: {
-					driverInference,
-					childWork
+				...accounting.gaps.length > 0 ? { spendGaps: accounting.gaps } : {},
+				fleetYield: accounting.fleetYield,
+				...isNonEmptySpend(accounting.driverInference) ? { spentBreakdown: {
+					driverInference: accounting.driverInference,
+					childWork: accounting.childWork
 				} } : {}
 			};
 		}
@@ -16884,12 +16093,13 @@ async function settleRootResult(settled) {
 /** A no-winner still carries `spentTotal`, summed off the SAME journal the winner path reads. */
 async function noWinner(settled, rejection) {
 	const { controller, teardownUnconfirmed, leakedReservations } = settled;
-	const { spentTotal, gaps, providerModel, fleetYield } = await terminalAccounting(settled.journal, settled.opts.runId, settled.now() - settled.runEpochMs);
+	const { tree, spentTotal, gaps, providerModel, fleetYield, usage } = await terminalAccounting(settled.journal, settled.opts.runId, settled.now() - settled.runEpochMs, settled.opts.requestedProfile);
 	const common = {
 		kind: "no-winner",
-		tree: settled.tree,
+		tree,
 		downCount: settled.breaker.downCount(),
 		spentTotal,
+		usage,
 		providerModel,
 		...teardownUnconfirmed.length > 0 ? { teardownUnconfirmed } : {},
 		...leakedReservations.length > 0 ? { leakedReservations } : {},
@@ -16926,6 +16136,6 @@ async function noWinner(settled, rejection) {
 		reason: "no-result-selected"
 	};
 }
-export { DEFAULT_PEER_MAIL_LIMITS as $, renderUnsupported as $t, createSandboxForSpec as A, priceTokens as At, createRouterTranscript as B, runSettledCommand as Bt, createExecutor as C, bestComposite as Ct, runAgentRounds as D, isFiniteNumber as Dt, createSteerableSandboxSession as E, failedItems as Et, codeModeArguments as F, readCodexRolloutSession as Ft, LEAF_CONTINUATION_TASK as G, assertProfileMaterialization as Gt, createAgentEnvironmentProviderRegistry as H, LOCAL_HARNESSES as Ht, codeModeModelOutput as I, createPushTraceSource as It, createInPlaceCliExecutor as J, defineProfileMaterializationContract as Jt, providerAsSandboxClient as K, assertProfileMaterializes as Kt, createCodeModeTools as L, bridgeRuntimeAttachmentsKey as Lt, acquireSandbox as M, addHarnessUsage as Mt, TERMINAL_DECISIONS as N, createCodexRolloutStoreReader as Nt, assertBoxlessPromptOptions as O, bridgeAdmissionRefusal as Ot, defaultSelectWinner as P, harnessUsageIsEmpty as Pt, AUTHORITY_MARKERS as Q, promptModelProfileMaterialization as Qt, runCodeMode as R, bridgeStopSignalKey as Rt, captureReusableExecutorConfig as S, admitContinuationPolicy as St, DEFAULT_SANDBOX_STEERING_MAX_TURNS as T, createContinuationKeeper as Tt, resolveAgentEnvironmentProvider as U, harnessInvocation as Ut, routerBrain as V, runWorktreeHarness as Vt, providerAsExecutor as W, terminateProcessTreeAndConfirm as Wt, createInbox as X, profileMaterializationAxes$1 as Xt, INBOX_RECEIPT_KEY as Y, fullProfileMaterialization as Yt, failPendingAfter as Z, promptControlProfileMaterialization as Zt, withDriverExecutor as _, gateFactoryOnDeliverable as _t, assertRunParking as a, readSandboxOutcome as an, peerMailVerbNames as at, createExecutorRegistry as b, verdictFromJudgeScore as bt, sleepScopeWait as c, HarnessTurnFailedError as ct, runFinalizer as d, summarizeDriverAttempts as dt, sandboxActProfileMaterialization as en, PEER_MAIL_WIRE_KEY as et, runTree as f, transientFailureKind as ft, isDriverSpec as g, CheckUnavailableError as gt, driverExecutorFactory as h, preflightPublicCoordination as ht, RunParkedError as i, projectSandboxOutcome as in, peerMailTools as it, createSandboxLineage as j, ROUTER_PRICE_SOURCE as jt, readPromptOptions as k, bridgeModelRouteRefusal as kt, withRunParking as l, abandonablePending as lt, driverChild as m, upstreamUnavailableSignal as mt, createSupervisor as n, unsupportedProfileDimensions as nn, createPeerMailbox as nt, bindScopeParkingDrain as o, taskToPrompt$1 as ot, createRootHandle as p, undispatchedCredentialExit as pt, createWorktreeCliExecutor as q, controlProfileMaterialization as qt, assertResumeLimits as r, worktreeCliProfileMaterialization as rn, isPeerMailEnvelope as rt, readRunParking as s, DriverAttemptsExhaustedError as st, DEFAULT_MAX_DEPTH as t, sandboxProfileMaterialization as tn, claimsAuthority as tt, bestDelivered as u, classifyDriverFailure as ut, InMemoryResultBlobStore as v, gateOnDeliverable as vt, snapshotExecutorConfig as w, checkVerdictOf as wt, bindReusableExecutorExecutionId as x, CONTINUATIONS_DIR as xt, InMemorySpawnJournal as y, mapExecutorResult as yt, toolResultText as z, defaultRunCommand as zt };
+export { DEFAULT_PEER_MAIL_LIMITS as $, createSandboxForSpec as A, bridgeRuntimeAttachmentsKey as At, createRouterTranscript as B, controlProfileMaterialization as Bt, createExecutor as C, priceTokens as Ct, runAgentRounds as D, harnessUsageIsEmpty as Dt, createSteerableSandboxSession as E, createCodexRolloutStoreReader as Et, codeModeArguments as F, LOCAL_HARNESSES as Ft, LEAF_CONTINUATION_TASK as G, promptModelProfileMaterialization as Gt, createAgentEnvironmentProviderRegistry as H, fullProfileMaterialization as Ht, codeModeModelOutput as I, harnessInvocation as It, createInPlaceCliExecutor as J, sandboxProfileMaterialization as Jt, providerAsSandboxClient as K, renderUnsupported as Kt, createCodeModeTools as L, terminateProcessTreeAndConfirm as Lt, acquireSandbox as M, defaultRunCommand as Mt, TERMINAL_DECISIONS as N, runSettledCommand as Nt, assertBoxlessPromptOptions as O, readCodexRolloutSession as Ot, defaultSelectWinner as P, runWorktreeHarness as Pt, AUTHORITY_MARKERS as Q, readSandboxOutcome as Qt, runCodeMode as R, assertProfileMaterialization as Rt, captureReusableExecutorConfig as S, bridgeModelRouteRefusal as St, DEFAULT_SANDBOX_STEERING_MAX_TURNS as T, addHarnessUsage as Tt, resolveAgentEnvironmentProvider as U, profileMaterializationAxes$1 as Ut, routerBrain as V, defineProfileMaterializationContract as Vt, providerAsExecutor as W, promptControlProfileMaterialization as Wt, createInbox as X, worktreeCliProfileMaterialization as Xt, INBOX_RECEIPT_KEY as Y, unsupportedProfileDimensions as Yt, failPendingAfter as Z, projectSandboxOutcome as Zt, withDriverExecutor as _, gateFactoryOnDeliverable as _t, assertRunParking as a, peerMailVerbNames as at, createExecutorRegistry as b, verdictFromJudgeScore as bt, sleepScopeWait as c, HarnessTurnFailedError as ct, runFinalizer as d, summarizeDriverAttempts as dt, PEER_MAIL_WIRE_KEY as et, runTree as f, transientFailureKind as ft, isDriverSpec as g, CheckUnavailableError as gt, driverExecutorFactory as h, preflightPublicCoordination as ht, RunParkedError as i, peerMailTools as it, createSandboxLineage as j, bridgeStopSignalKey as jt, readPromptOptions as k, createPushTraceSource as kt, withRunParking as l, abandonablePending as lt, driverChild as m, upstreamUnavailableSignal as mt, createSupervisor as n, createPeerMailbox as nt, bindScopeParkingDrain as o, taskToPrompt$1 as ot, createRootHandle as p, undispatchedCredentialExit as pt, createWorktreeCliExecutor as q, sandboxActProfileMaterialization as qt, assertResumeLimits as r, isPeerMailEnvelope as rt, readRunParking as s, DriverAttemptsExhaustedError as st, DEFAULT_MAX_DEPTH as t, claimsAuthority as tt, bestDelivered as u, classifyDriverFailure as ut, InMemoryResultBlobStore as v, gateOnDeliverable as vt, snapshotExecutorConfig as w, ROUTER_PRICE_SOURCE as wt, bindReusableExecutorExecutionId as x, bridgeAdmissionRefusal as xt, InMemorySpawnJournal as y, mapExecutorResult as yt, toolResultText as z, assertProfileMaterializes as zt };
 
-//# sourceMappingURL=supervisor-1A27fE6k.js.map
+//# sourceMappingURL=supervisor-Dpeu7rnZ.js.map