@tangle-network/agent-runtime 0.297.2 → 0.297.4

package/dist/{supervisor-Rov7xW0j.js → supervisor-tuUW4dMo.js}

@@ -8449,46 +8449,6 @@ function assertRetainedCapabilityRequirements(providerName, capabilities) {
 	if (retained?.exactRunIdentity !== true || retained.resultIdentity !== true || retained.eventIdentity !== true || retained.cancellationIdempotency !== true || !capabilities.streaming.detach || !capabilities.streaming.replay || !capabilities.streaming.turnIdempotency) throw new Error(`provider "${providerName}" cannot control a retry-safe retained run`);
 }
 //#endregion
-//#region 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.
-*/
-/**
-* 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 with no catalog entry 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.
-*/
-function priceUnreceiptedWork(work) {
-	const unknown = {
-		kind: "cost",
-		usd: 0,
-		usdKnown: false,
-		provenance: "uncaptured"
-	};
-	const { inputTokens, outputTokens, model } = work;
-	if (model === void 0 || !isModelPriced(model)) return unknown;
-	if (!Number.isFinite(inputTokens) || !Number.isFinite(outputTokens)) return unknown;
-	if (inputTokens < 0 || outputTokens < 0) return unknown;
-	const usd = estimateCost(inputTokens, outputTokens, model);
-	if (!Number.isFinite(usd) || usd <= 0) return unknown;
-	return {
-		kind: "cost",
-		usd,
-		usdKnown: false,
-		usdEstimated: usd,
-		provenance: "catalog-estimate"
-	};
-}
-//#endregion
 //#region src/runtime/supervise/error-message.ts
 const maxCauseDepth = 4;
 const maxMessageLength = 32768;
@@ -8550,6 +8510,121 @@ function errMessage(error) {
 	return parts.join(": caused by ").slice(0, maxMessageLength);
 }
 //#endregion
+//#region src/runtime/retained-native-stop.ts
+/** One request per run: every caller that stops the same execution replays one provider operation,
+*  so the operation id and its reason never disagree across a teardown and a release. */
+const NATIVE_STOP_REASON = "Runtime stopped the native harness: its execution is no longer observed";
+/** How often a stop the provider accepted asynchronously reads the run's status. */
+const STOP_STATUS_POLL_MS = 1e3;
+/**
+* Stop the native harness process of a retained execution that Runtime no longer observes.
+*
+* A retained execution outlives its local stream by design, so an aborted observer can reconnect.
+* Keeping its environment preserves the files; it must not keep the harness running. Measured on
+* Discovery: after `disco cancel` on 2026-10-04 the kept root box ran `claude --print` for two
+* more minutes, untraced and charged to the subscription, until an operator stopped the box; on
+* 2026-10-03 a cancelled run kept 18 boxes whose `claude` processes ran until an operator stopped
+* them. The provider's exact cancellation stops the process; the box and its files stay.
+*
+* The operation id is derived from the run reference, so a repeated stop replays the first one.
+* Never rejects: the answer is evidence for the teardown receipt.
+*/
+async function stopRetainedNativeExecution(options) {
+	const now = options.now ?? Date.now;
+	const executionId = options.controlRef.executionId;
+	const operationId = `runtime-native-stop-${canonicalCandidateDigest({
+		kind: "runtime-native-stop.v1",
+		run: options.controlRef
+	}).slice(7)}`;
+	let effect = "unknown";
+	const stop = async () => {
+		const handle = options.handle ?? await reconnectRetainedRun({
+			provider: options.provider,
+			controlRef: options.controlRef
+		});
+		if (handle === null) return "not_live";
+		const cancellation = await handle.cancel({
+			operationId,
+			reason: NATIVE_STOP_REASON,
+			signal: options.signal
+		});
+		effect = cancellation.status === "conflict" ? "unknown" : cancellation.effect;
+		while (effect === "cancel_requested") {
+			await sleep(STOP_STATUS_POLL_MS, options.signal);
+			const current = await handle.status({ signal: options.signal });
+			if (current.effect === "cancelled" || current.effect === "not_live") effect = current.effect;
+		}
+		return effect;
+	};
+	try {
+		effect = await awaitAbortable$1(stop(), options.signal);
+		return {
+			executionId,
+			effect,
+			at: new Date(now()).toISOString()
+		};
+	} catch (error) {
+		return {
+			executionId,
+			effect: effect === "cancel_requested" ? effect : "unknown",
+			at: new Date(now()).toISOString(),
+			error: errorText(error instanceof Error ? error.message : error).slice(0, 512)
+		};
+	}
+}
+/**
+* The teardown-receipt text for stopped executions. A killed harness never reports the usage of
+* its last turn, so the receipt says so instead of letting a reader take the settled spend as
+* complete.
+*/
+function describeRetainedNativeStops(stops) {
+	return stops.map((stop) => {
+		if (stop.effect === "cancelled") return `native execution ${stop.executionId} stopped at ${stop.at}; usage unknown: killed at ${stop.at}`;
+		if (stop.effect === "not_live") return `native execution ${stop.executionId} was not live at ${stop.at}`;
+		return `native execution ${stop.executionId} stop unconfirmed at ${stop.at} (effect ${stop.effect}${stop.error === void 0 ? "" : `: ${stop.error}`}); it may still be running`;
+	}).join("; ");
+}
+//#endregion
+//#region 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.
+*/
+/**
+* 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 with no catalog entry 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.
+*/
+function priceUnreceiptedWork(work) {
+	const unknown = {
+		kind: "cost",
+		usd: 0,
+		usdKnown: false,
+		provenance: "uncaptured"
+	};
+	const { inputTokens, outputTokens, model } = work;
+	if (model === void 0 || !isModelPriced(model)) return unknown;
+	if (!Number.isFinite(inputTokens) || !Number.isFinite(outputTokens)) return unknown;
+	if (inputTokens < 0 || outputTokens < 0) return unknown;
+	const usd = estimateCost(inputTokens, outputTokens, model);
+	if (!Number.isFinite(usd) || usd <= 0) return unknown;
+	return {
+		kind: "cost",
+		usd,
+		usdKnown: false,
+		usdEstimated: usd,
+		provenance: "catalog-estimate"
+	};
+}
+//#endregion
 //#region src/runtime/supervise/budget.ts
 /**
 *
@@ -11150,6 +11225,9 @@ function createProviderExecutor(provider, profile, ctx, options, placement) {
 	let workspaceRunActive = false;
 	let providerSessionId = null;
 	let workspaceControlRef;
+	let nativeStop;
+	let runSignal;
+	const cancelledExplicitly = () => ctx.signal?.reason instanceof RunCancellationReason || runSignal?.reason instanceof RunCancellationReason;
 	const runtime = options.runtime ?? provider.name;
 	const createProfile = options.profileForCreate?.(profile) ?? profile;
 	if (placement && canonicalAgentProfileDigest(createProfile) !== canonicalAgentProfileDigest(profile)) throw new ValidationError("provider placement: profileForCreate cannot change the selected profile");
@@ -11312,6 +11390,51 @@ function createProviderExecutor(provider, profile, ctx, options, placement) {
 		workspaceCleanupPromise = cleanupReference;
 		return await cleanupReference;
 	};
+	/**
+	* Stop the native harness of this executor's retained execution. Local observation ending does
+	* not stop a retained execution, so an environment kept after it keeps its harness spending
+	* unless the provider is asked to stop it. Undefined when nothing was dispatched.
+	*/
+	const stopNativeExecution = () => {
+		if (nativeStop !== void 0) return nativeStop;
+		const controlRef = retained?.controlRef ?? admittedControlRef(retention);
+		if (controlRef === void 0) return Promise.resolve(void 0);
+		const stopping = stopRetainedNativeExecution({
+			provider,
+			controlRef,
+			...retained === void 0 ? {} : { handle: retained },
+			signal: AbortSignal.timeout(NATIVE_STOP_TIMEOUT_MS)
+		}).then((stop) => {
+			if (stop.effect !== "cancelled" && stop.effect !== "not_live" && nativeStop === stopping) nativeStop = void 0;
+			return stop;
+		});
+		nativeStop = stopping;
+		return stopping;
+	};
+	/**
+	* A release that keeps an environment keeps its files, never its running harness. The root has
+	* settled and no process will reconcile this execution, so its native process stops before the
+	* release records what it kept.
+	*/
+	const withoutRunningHarness = (release) => async (signal) => {
+		const receipts = await release(signal);
+		if (receipts.every((receipt) => receipt.destroyed)) return receipts;
+		const stop = await awaitAbortable$1(stopNativeExecution(), signal).catch((error) => {
+			const controlRef = retained?.controlRef ?? admittedControlRef(retention);
+			return controlRef === void 0 ? void 0 : {
+				executionId: controlRef.executionId,
+				effect: "unknown",
+				at: (/* @__PURE__ */ new Date()).toISOString(),
+				error: errorText(error instanceof Error ? error.message : error)
+			};
+		});
+		if (stop === void 0) return receipts;
+		const stopped = describeRetainedNativeStops([stop]);
+		return receipts.map((receipt) => receipt.destroyed ? receipt : {
+			...receipt,
+			detail: receipt.detail ? `${receipt.detail}; ${stopped}` : stopped
+		});
+	};
 	const attemptId = node?.attemptId ?? newExecutionAttemptId(executionId);
 	const trace = createPushTraceSource({ runId: executionId });
 	const providerModel = concreteProfileModel(createProfile);
@@ -11362,6 +11485,7 @@ function createProviderExecutor(provider, profile, ctx, options, placement) {
 	const run = async function* (task, signal, recovering = false) {
 		beginWorkspaceExecution();
 		const linked = linkAbort(ctx.signal, signal, controller.signal);
+		runSignal = linked.signal;
 		try {
 			const executionStartedAt = Date.now() - (retention?.priorSpent?.ms ?? 0);
 			let invocation = {
@@ -11507,6 +11631,7 @@ function createProviderExecutor(provider, profile, ctx, options, placement) {
 		},
 		async teardown(_grace) {
 			controller.abort();
+			if (pending && cancelledExplicitly()) stopNativeExecution();
 			if (options.workspaceRetention !== void 0 && workspaceRunActive) return {
 				destroyed: false,
 				detail: "provider workspace retention: source preserved while the execution is still active"
@@ -11529,7 +11654,7 @@ function createProviderExecutor(provider, profile, ctx, options, placement) {
 				...preserved ? { keptFor: "evidence" } : {}
 			}];
 		},
-		async releaseRetained(signal) {
+		releaseRetained: withoutRunningHarness(async (signal) => {
 			controller.abort();
 			if (!pending) return [];
 			const environmentId = retained?.controlRef.environmentId ?? environment?.id ?? admittedEnvironmentId(retention);
@@ -11577,7 +11702,7 @@ function createProviderExecutor(provider, profile, ctx, options, placement) {
 			});
 			retainedReleasePromise = releaseReference;
 			return await releaseReference;
-		},
+		}),
 		resultArtifact() {
 			if (!artifact) throw new ValidationError(`providerAsExecutor(${provider.name}): resultArtifact() read before stream drained`);
 			return artifact;
@@ -11587,6 +11712,12 @@ function createProviderExecutor(provider, profile, ctx, options, placement) {
 	};
 	return attestRuntimeOwnedPendingExecutor(executor, runtime, plannedDeclaration, plannedBinding);
 }
+/** The exact run the latest durable dispatch names, when dispatch got that far. */
+function admittedControlRef(retention) {
+	for (const admission of [...retention?.admissions ?? []].reverse()) if (admission.phase === "dispatched") return admission.controlRef;
+}
+/** Bounds one provider stop: a reconnect, the exact cancellation and its status read. */
+const NATIVE_STOP_TIMEOUT_MS = 3e4;
 /** The environment id the latest durable admission names, when creation got that far. */
 function admittedEnvironmentId(retention) {
 	for (const admission of [...retention?.admissions ?? []].reverse()) {
@@ -23303,6 +23434,19 @@ async function releaseScopeRetainedOwnerEnvironment(scope) {
 				if (!permanent) retriable = true;
 			}
 		}
+		if (!destroyed) {
+			const runs = unsettledOwnerRuns(events, args.nodeId, environmentId);
+			if (runs.length > 0) {
+				const stops = await Promise.all(runs.map((controlRef) => stopRetainedNativeExecution({
+					provider,
+					controlRef,
+					signal: AbortSignal.timeout(3e4),
+					now: args.now
+				})));
+				detail = `${detail}; ${describeRetainedNativeStops(stops)}`;
+				lastDetail = detail;
+			}
+		}
 		await args.journal.appendEvent(args.rootId, {
 			kind: "environment-teardown",
 			id: args.nodeId,
@@ -23345,6 +23489,26 @@ async function releaseScopeRetainedOwnerEnvironment(scope) {
 		...lastDetail === void 0 ? {} : { detail: lastDetail }
 	}, ...checkpointTeardowns] : checkpointTeardowns;
 }
+/**
+* The owner's dispatched executions in one environment whose turn committed no result. A turn
+* with a result has ended; one without may still be running even after a later turn started.
+*/
+function unsettledOwnerRuns(events, nodeId, environmentId) {
+	const runs = /* @__PURE__ */ new Map();
+	let turn = [];
+	const close = () => {
+		for (const controlRef of turn) runs.set(contentAddress(controlRef), controlRef);
+		turn = [];
+	};
+	for (const event of events) {
+		if (!("id" in event) || event.id !== nodeId) continue;
+		if (event.kind === "execution-input") close();
+		else if (event.kind === "execution-result") turn = [];
+		else if (event.kind === "execution-admitted" && event.admission.phase === "dispatched" && event.admission.controlRef.environmentId === environmentId) turn.push(event.admission.controlRef);
+	}
+	close();
+	return [...runs.values()];
+}
 /** Group owner admissions by input and require a verified workspace receipt before deletion. */
 async function ownerWorkspaceRetentionFailures(events, nodeId, blobs) {
 	const attempts = [];
@@ -28893,4 +29057,4 @@ function isNonEmptySpend(s) {
 //#endregion
 export { bindScopeRetainedOwnerProvider as $, detachedFrozen as $i, parseWorkerToolTraceArtifact as $n, sanitizeRuntimeStreamEvent as $r, isPeerMailEnvelope as $t, driverExecutorFactory as A, addResourceSpend as Aa, prepareJsonlAppend as Ai, resolveAgentEnvironmentProvider as An, contentAddress as Ar, createExecutor as At, recordScopeOwnerDriverAttempt as B, promptFromAgentTurnInput as Ba, newExecutionAttemptId as Bi, InMemoryResultBlobStore as Bn, buildRuntimeEventOtelSpans as Br, workerTraceEnv as Bt, createContinuationKeeper as C, sleep as Ca, renderProfileMaterializationIssues as Ci, readPromptOptions as Cn, runAbortable as Cr, freeSlots as Ct, passedItems as D, unmeteredSpend as Da, validateProfileMaterialization as Di, createAgentEnvironmentProviderRegistry as Dn, readHarnessTranscript as Dr, captureReusableExecutorConfig as Dt, failedItems as E, throwIfAborted as Ea, unsupportedProfileDimensions as Ei, LEAF_CONTINUATION_TASK as En, persistHarnessTranscript as Er, bindReusableExecutorExecutionId as Et, beginScopeOwnerAttempt as F, awaitAbortable$1 as Fa, authoredProfileDigest as Fi, sandboxSessionTraceSource as Fn, defaultRedactor as Fr, createSteerableSandboxSession as Ft, settledToIteration as G, runtimeOwnedExecutorMaterialization as Gi, insideCursorNamespace as Gn, loopEventToOtelSpan as Gr, createActivityLog as Gt, recordScopeOwnerPause as H, providerMessageText as Ha, recordRuntimeOwnedDriveHarnessProviderEvidence as Hi, SpawnEventIndex as Hn, createOtelExporter as Hr, workerTraceSeamKey as Ht, createScope as I, DEFAULT_SUCCESSFUL_SHUTDOWN_MS as Ia, finalizeRuntimeOwnedPendingExecutor as Ii, registerRetainedExecutorPreparation as In, defaultRedactorIdentityMaterial as Ir, createRouterTranscript as It, pollFor as J, runtimeOwnedScopeOwnerRuntime as Ji, pendingWaits as Jn, toOtelAttributes as Jr, AUTHORITY_MARKERS as Jt, createWaitProbes as K, runtimeOwnedExecutorProviderEvidence as Ki, loadSpawnForest as Kn, padSpanId as Kr, readWorkerProgress as Kt, deriveNodeExecutionIdentity as L, armDeadlineTimer as La, inheritRuntimeOwnedExecutorAttestation as Li, retainedExecutorSeamKey as Ln, resolveRedactor as Lr, createInPlaceCliExecutor as Lt, withDriverExecutor as M, withBudgetResources as Ma, writeAllBytes as Mi, unavailableSignalOfFailure as Mn, mergeTraceEnv as Mr, snapshotExecutorConfig as Mt, SUBTREE_RESULT_LIMIT as N, decodeHarnessUsage as Na, attestRuntimeOwnedPendingExecutor as Ni, createPushTraceSource as Nn, readTraceContextFromEnv as Nr, createWorktreeCliExecutor as Nt, verdictFromJudgeScore as O, withTimeout as Oa, worktreeCliProfileMaterialization as Oi, providerAsExecutor as On, resolveHarnessTranscriptCapture as Or, cliInPlaceExecutor as Ot, assertRecursiveReservationPolicy as P, abortError$2 as Pa, attestRuntimeOwnedScopeOwner as Pi, decodeToolPart as Pn, traceContextToEnv as Pr, DEFAULT_SANDBOX_STEERING_MAX_TURNS as Pt, bindScopeRetainedOwnerEnvironmentId as Q, executableAgentSpecSnapshot as Qi, isTraceAnalysisStore as Qn, sanitizeKnowledgeReadinessReport as Qr, createPeerMailbox as Qt, meterRuntimeOwnedAccounting as R, teardownExecutor as Ra, knownExecutionBindingReceipt as Ri, FileResultBlobStore as Rn, buildLoopOtelSpans as Rr, WORKER_TRACE_PROPAGATION as Rt, composeContinuationNote as S, randomSuffix as Sa, promptResourceProfileMaterialization as Si, assertBoxlessPromptOptions as Sn, linkAbort as Sr, startRetainedInteractiveRun as St, expandQuestions as T, throwAbort as Ta, sandboxActProfileMaterialization as Ti, runBrainLoop as Tn, harnessTranscriptArtifact as Tr, rollingDispatch as Tt, restoreScopeOwnerAcceptedExecution as U, runtimeOwnedDriveHarnessProviderEvidence as Ui, assertContentAddress as Un, flatOtelSpan as Ur, taskToPrompt as Ut, recordScopeOwnerMaterialization as V, promptOptionsFromAgentTurnInput as Va, providerAttemptEvidence as Vi, InMemorySpawnJournal as Vn, createOpenInferenceFileExporter as Vr, workerTraceHeaders as Vt, scopeOwnerExecutorNodeContext as W, runtimeOwnedExecutorExecutionBinding as Wi, encodeResultBlob as Wn, generateSpanId as Wr, DEFAULT_STALL_AFTER_MS as Wt, validateWaitSpec as X, unknownMaterializationReceipt as Xi, WORKER_TOOL_TRACE_SCHEMA_VERSION as Xn, createRuntimeStreamEventCollector as Xr, PEER_MAIL_WIRE_KEY as Xt, timerAt as Y, unknownExecutionBindingReceipt as Yi, replaySpawnTree as Yn, createRuntimeEventCollector as Yr, DEFAULT_PEER_MAIL_LIMITS as Yt, waitUntil as Z, executableAgentProfileSnapshot as Zi, captureWorkerTraceEvidence as Zn, sanitizeAgentRuntimeEvent as Zr, claimsAuthority as Zt, CheckUnavailableError as _, cloneSpend as _a, fullProfileMaterialization as _i, createSandboxLineage as _n, environmentGone as _r, readWorkerInteractiveBinding as _t, collectDelivered as a, createSandboxToolPartState as aa, DEFAULT_LOCAL_HARNESS as ai, bridgeModelRouteRefusal as an, createBudgetPool as ar, scopeRetainedOwnerPriorSpend as at, bestComposite as b, isAbortError$2 as ba, promptModelProfileMaterialization as bi, SandboxEvidenceRetentionError as bn, RunCancellationReason as br, reconnectRetainedInteractiveRun as bt, runTree as c, isSandboxTerminalEvent as ca, harnessSupportsReasoningEffort as ci, harnessUsageIsEmpty as cn, spendFromUsageEvents as cr, scopeRetainedOwnerResult as ct, classifyDriverFailure as d, notifySandboxEventObserver as da, CodexExecutionDiagnosticError as di, bridgeStopSignalKey as dn, reconnectRetainedRun as dr, hostDirectoryReader as dt, detachedSnapshot as ea, runSettledCommand as ei, peerMailTools as en, workerTraceAnalysisStore as er, consumeScopeRetainedOwnerResult as et, runDriverWithRetry as f, sandboxEventServedBackend as fa, terminateProcessTreeAndConfirm as fi, TERMINAL_DECISIONS as fn, recoverRetainedRun as fr, resolveSpawnResourcePaths as ft, CONTINUATION_FACTS as g, chargedTokens as ga, defineProfileMaterializationContract as gi, runAgentRounds as gn, destroyInteractiveEnvironment as gr, attachWorker as gt, CONTINUATIONS_DIR as h, addSpend as ha, controlProfileMaterialization as hi, isTerminalDecision as hn, retainedCreateMaterial as hr, workerInteractiveAdmissionFile as ht, bestDelivered as i, canonicalStreamEventFromSandboxEvent as ia, removeWorktree as ii, bridgeAdmissionRefusal as in, assertValidBudget as ir, scopeRetainedOwnerContext as it, isDriverSpec as j, resourceTelemetry as ja, readCommittedJsonLines as ji, unavailablePauseMs as jn, createPropagatingTraceEmitter as jr, createExecutorRegistry as jt, driverChild as k, zeroSpend as ka, isNoEntError as ki, providerAsSandboxClient as kn, retainHarnessTranscript as kr, cliWorktreeExecutor as kt, DriverAttemptsExhaustedError as l, mapSandboxEvent as la, localHarnessExecutable as li, readCodexRolloutSession as ln, spendFromUsageTotals as lr, SPAWN_RESOURCE_PATH_MAX_BYTES as lt, upstreamUnavailableSignal as m, sumSandboxUsage as ma, assertProfileMaterialization as mi, defaultSelectWinner as mn, startRetainedRunInEnvironment as mr, readWorkerInteractiveAdmissions as mt, createRootHandle as n, readSandboxOutcome as na, captureWorktreeDiff as ni, isLiveNodeStatus as nn, BudgetReconcileFault as nr, prepareScopeRetainedOwnerTask as nt, pickBestDelivered as o, createSandboxUsageLedger as oa, LOCAL_HARNESSES as oi, addHarnessUsage as on, meterUsageEvent as or, scopeRetainedOwnerResourceReader as ot, summarizeDriverAttempts as p, sandboxProgressEvents as pa, AGENT_PROFILE_MATERIALIZATION_AXES as pi, createSandboxForSpec as pn, startRetainedRun as pr, interactiveAdmissionSeamKey as pt, isWaitOutcome as q, runtimeOwnedPendingExecutorMaterialization as qi, materializeTreeView as qn, padTraceId as qr, createInbox as qt, createSupervisor as r, assertSandboxServedModel as ra, createWorktree as ri, isTerminalNodeStatus as rn, ReservationWaitRefused as rr, reconcileScopeRetainedOwnerEnvironment as rt, runFinalizer as s, extractLlmCallEvent as sa, harnessInvocation as si, createCodexRolloutStoreReader as sn, newUsageTotals as sr, scopeRetainedOwnerRestorePoint as st, DEFAULT_MAX_DEPTH as t, projectSandboxOutcome as ta, runWorktreeHarness as ti, peerMailVerbNames as tn, executorFailure as tr, noteScopeRetainedOwnerCoordination as tt, HarnessTurnFailedError as u, mapSandboxToolEvent as ua, parseCodexTokenUsage as ui, bridgeRuntimeAttachmentsKey as un, errMessage as ur, environmentReader as ut, admitContinuationPolicy as v, deleteBoxSafe as va, profileMaterializationAxes$1 as vi, probeSandboxCapabilities as vn, createWorkerSlots as vr, workerInteractiveBindingFile as vt, distillFindings as w, stringifySafe as wa, renderUnsupported as wi, routerBrain as wn, captureHarnessTranscript as wr, queueOf as wt, checkVerdictOf as x, promptCacheTokenClasses as xa, promptOnlyProfileMaterialization as xi, captureBeforeDestroy as xn, abortError as xr, recoverRetainedInteractiveRun as xt, admitFinding as y, hasCompleteCacheBreakdown as ya, promptControlProfileMaterialization as yi, acquireSandbox as yn, openSlotGroup as yr, workerInteractiveBindingsDir as yt, meterRuntimeOwnedProviderAttempt as z, teardownSurfaces as za, knownMaterializationReceipt as zi, FileSpawnJournal as zn, buildLoopSpanNodes as zr, readWorkerTraceContext as zt };
 
-//# sourceMappingURL=supervisor-Rov7xW0j.js.map
+//# sourceMappingURL=supervisor-tuUW4dMo.js.map