@tangle-network/agent-runtime 0.261.0 → 0.262.0

package/dist/{supervisor-yavsoQQo.js → supervisor-BGGvnXvV.js}

@@ -16773,7 +16773,7 @@ var SpawnEventIndex = class {
 	/** Called only after validation and, for the file writer, a successful durable append. */
 	add(event) {
 		if (!outsideCursorNamespace(event)) this.cursors.add(event.seq);
-		if (event.kind !== "spawned" && event.kind !== "materialized" && event.kind !== "execution-bound" && event.kind !== "execution-input" && event.kind !== "execution-admitted" && event.kind !== "execution-result" && !closesCursorSlot(event)) return;
+		if (event.kind !== "spawned" && event.kind !== "materialized" && event.kind !== "execution-bound" && event.kind !== "execution-input" && event.kind !== "execution-admitted" && event.kind !== "execution-result" && event.kind !== "environment-teardown" && !closesCursorSlot(event)) return;
 		let node = this.nodes.get(event.id);
 		if (!node) {
 			node = {
@@ -16784,10 +16784,16 @@ var SpawnEventIndex = class {
 				inputs: /* @__PURE__ */ new Set(),
 				input: false,
 				result: false,
-				admissions: /* @__PURE__ */ new Map()
+				admissions: /* @__PURE__ */ new Map(),
+				destroyedEnvironments: /* @__PURE__ */ new Set()
 			};
 			this.nodes.set(event.id, node);
 		}
+		if (event.kind === "environment-teardown") {
+			if (event.destroyed) node.destroyedEnvironments.add(event.environmentId);
+			return;
+		}
+		if (event.kind === "execution-admitted" && event.admission.phase === "environment") node.lastEnvironmentId = event.admission.environmentId;
 		if (event.kind === "spawned") node.spawned = true;
 		else if (event.kind === "materialized") node.materialized = true;
 		else if (event.kind === "execution-bound") node.bindings.add(event.binding.attemptId);
@@ -16810,7 +16816,10 @@ var SpawnEventIndex = class {
 		if (event.kind === "execution-input") {
 			if (!/^sha256:[0-9a-f]{64}$/.test(event.taskRef)) fail("has an invalid task reference");
 			if (node.inputs.has(event.seq)) fail("has duplicate input sequence");
-			if (node.input && !node.result) fail("input replaces an unfinished invocation");
+			const environment = node.admissions.get("environment");
+			const ranIn = environment?.phase === "environment" ? environment.environmentId : node.lastEnvironmentId;
+			const abandoned = ranIn !== void 0 && node.destroyedEnvironments.has(ranIn);
+			if (node.input && !node.result && !abandoned) fail("input replaces an unfinished invocation");
 			return;
 		}
 		if (event.kind === "execution-result") {
@@ -21732,6 +21741,86 @@ function hasDurableWorkspaceSnapshot(value) {
 	const parsed = agentCandidateWorkspaceSnapshotEvidenceSchema.safeParse(value);
 	return parsed.success && "locator" in parsed.data.manifest && "locator" in parsed.data.archive;
 }
+/** Environment ids this owner's provider confirmed gone, from their teardown receipts. */
+function destroyedEnvironmentIds(owned) {
+	return new Set(owned.flatMap((event) => event.kind === "environment-teardown" && event.destroyed ? [event.environmentId] : []));
+}
+/** The environment the owner's next invocation would continue in, when there is one: the latest
+*  environment admission of this owner, which is either the current invocation's own (recovered
+*  in place) or the one a deliberate later invocation reuses after an accepted result. `inFlight`
+*  says whether the latest invocation has no result yet. */
+function continuedEnvironment(owned) {
+	const latestInput = [...owned].reverse().find((event) => event.kind === "execution-input");
+	if (latestInput === void 0) return void 0;
+	const attempt = owned.slice(owned.indexOf(latestInput));
+	const admission = [...owned].reverse().flatMap((event) => event.kind === "execution-admitted" && event.admission.phase === "environment" ? [event.admission] : [])[0];
+	if (admission === void 0) return void 0;
+	return {
+		admission,
+		inFlight: !attempt.some((event) => event.kind === "execution-result")
+	};
+}
+/**
+* Confirm, before a new drive, that the environment the owner would continue in still exists.
+*
+* A retained invocation whose environment is gone can never be recovered: the retained path asked
+* the provider to reconnect, the provider answered `Sandbox not found`, and every later attempt
+* repeated that refusal until the barren streak ended the run. Measured on the real opencode path
+* (autopsy-a-before-20260924a, agent-runtime 5c22fbb2): the root sandbox was deleted 17 s after it
+* dispatched a child, four attempts in 64 s each refused "retained provider execution requires
+* reconciliation before replacement", and the run settled `driver-failed` while the child it had
+* commissioned settled `done` two minutes later, unread.
+*
+* The reconciliation refusal protects against paying twice for an execution that may still run.
+* An environment the provider no longer holds runs nothing, so there is nothing to reconcile: the
+* loss is journaled as a destroyed teardown receipt, and the next prepare starts a new invocation.
+*/
+async function reconcileScopeRetainedOwnerEnvironment(scope) {
+	const state = owners.get(scope);
+	if (!state?.provider) return { state: "none" };
+	const { provider, args } = state;
+	const owned = (await args.journal.loadTree(args.rootId) ?? []).filter((event) => event.id === args.nodeId);
+	const continued = continuedEnvironment(owned);
+	if (continued === void 0) return { state: "none" };
+	const environmentId = continued.admission.environmentId;
+	if (destroyedEnvironmentIds(owned).has(environmentId)) return {
+		state: "lost",
+		environmentId
+	};
+	if (!provider.get) return {
+		state: "unknown",
+		environmentId
+	};
+	let environment;
+	try {
+		environment = await runAbortable(() => provider.get(environmentId), AbortSignal.any([scope.signal, AbortSignal.timeout(3e4)]), "retained owner environment check timed out");
+	} catch {
+		return {
+			state: "unknown",
+			environmentId
+		};
+	}
+	if (environment !== null) return {
+		state: "live",
+		environmentId,
+		inFlight: continued.inFlight
+	};
+	scope.signal.throwIfAborted();
+	await args.journal.appendEvent(args.rootId, {
+		kind: "environment-teardown",
+		id: args.nodeId,
+		provider: provider.name,
+		environmentId,
+		destroyed: true,
+		detail: "lost: the provider no longer holds this environment, so the next invocation starts in a new one",
+		seq: state.nextSequence(),
+		at: new Date(args.now()).toISOString()
+	});
+	return {
+		state: "lost",
+		environmentId
+	};
+}
 /** Resume the original backend prompt; rebuilt coordination observations cannot replace it. */
 async function prepareScopeRetainedOwnerTask(scope, task) {
 	const state = owners.get(scope);
@@ -21748,6 +21837,14 @@ async function prepareScopeRetainedOwnerTask(scope, task) {
 		const accepted = [...attempt].reverse().find((event) => event.kind === "execution-result");
 		if (accepted?.kind === "execution-result") state.acceptedRef = accepted;
 	}
+	const destroyed = destroyedEnvironmentIds(owned);
+	const inFlight = continuedEnvironment(owned);
+	if (inFlight?.inFlight && destroyed.has(inFlight.admission.environmentId)) {
+		delete state.inputSequence;
+		delete state.taskRef;
+		state.admissions.length = 0;
+		delete state.priorSession;
+	}
 	if (state.prepared && state.acceptedRef && state.acceptedConsumed) {
 		const currentEnvironment = [...state.admissions].reverse().find((admission) => admission.phase === "environment");
 		if (currentEnvironment?.phase === "environment") state.priorSession = currentEnvironment;
@@ -21758,6 +21855,7 @@ async function prepareScopeRetainedOwnerTask(scope, task) {
 		state.admissions.length = 0;
 		delete state.acceptedConsumed;
 	}
+	if (state.priorSession !== void 0 && destroyed.has(state.priorSession.environmentId)) delete state.priorSession;
 	state.prepared = true;
 	if (state.taskRef !== void 0) {
 		const original = await args.blobs.get(state.taskRef);
@@ -24778,9 +24876,22 @@ function unreportedSpend(total, prior) {
 * driver that RETURNED with the contract unmet ended the run silently — 376 of 376 winning lab runs
 * ended on this loop's own `stop: 'completed'`, with the completion gate left to label the result
 * rather than to change it. A completed drive whose contract is unmet is now a first-class moment:
-* `reprompt.maxReprompts` re-enters the SAME live session with the unmet items, and every re-entry
-* crosses the same budget, deadline, and abort bounds. Successful continuations do not consume
-* the failure retry allowance.
+* `reprompt.maxReprompts` re-enters the driver with the unmet items, and every re-entry crosses the
+* same budget, deadline, and abort bounds. Successful continuations do not consume the failure
+* retry allowance.
+*
+* This loop decides WHETHER to re-enter; it does not know WHERE the next drive runs. Whether the
+* re-entered driver continues the same harness session, the same environment, or a replacement is
+* the drive harness's fact, and the caller composes the re-entry task from it (see
+* `./reentry.ts`). A re-prompt re-enters the same session only on a backend that proves it.
+*
+* Progress bounds the re-prompts too. The same delivery reading that resets the barren failure
+* counter decides whether a re-prompted drive earned another: `reprompt.maxBarren` consecutive
+* re-entered drives that completed without a delivery end the loop with `repromptRefusedBy:
+* 'no-progress'`. Before this, a completed drive reset the barren counter and `decideReprompt`
+* read only the count cap, budget, and deadline, so a director with `repromptOnUnmet: 100` or
+* `'until-complete'` that delivered nothing was re-prompted until the budget or deadline ended it;
+* the old prompt-owned loop logged 896 of 1,011 rounds with no progress.
 */
 /**
 * The instruction a completed-but-undelivered drive is re-entered with when the caller supplies no
@@ -24802,6 +24913,8 @@ function defaultUnmetContractSteer(context) {
 }
 const DEFAULT_MAX_CONSECUTIVE_FAILURES = 3;
 const DEFAULT_MAX_ATTEMPTS = 8;
+/** Two re-prompted drives in a row that deliver nothing end the re-prompts. */
+const DEFAULT_MAX_BARREN_REPROMPTS = 2;
 const DEFAULT_INITIAL_BACKOFF_MS = 2e3;
 const DEFAULT_MAX_BACKOFF_MS = 3e4;
 /**
@@ -24920,6 +25033,21 @@ var DriverAttemptsExhaustedError = class extends RuntimeRunStateError {
 		this.stop = stop;
 	}
 };
+/** Count a loop's attempt records into its {@link DriverLoopRecord}. */
+function summarizeDriverAttempts(records) {
+	let barren = 0;
+	for (const record of records) if (record.madeProgress) barren = 0;
+	else if (record.error === void 0 && record.reentry !== void 0 && record.contract === "unmet") barren += 1;
+	const last = records.at(-1);
+	return {
+		attempts: records.length,
+		reprompts: records.filter((record) => record.reprompted === true).length,
+		failureRetries: records.filter((record) => record.error !== void 0 && record.retryInMs !== void 0).length,
+		barrenReentries: barren,
+		ended: last?.stop ?? "unrecorded",
+		...last?.repromptRefusedBy === void 0 ? {} : { repromptRefusedBy: last.repromptRefusedBy }
+	};
+}
 async function defaultSleep(ms, signal) {
 	if (ms <= 0 || signal.aborted) return;
 	await sleep(ms, signal, false);
@@ -24946,14 +25074,21 @@ async function runDriverWithRetry(run) {
 		const deadline = run.budget().deadlineMs;
 		if (!Number.isFinite(deadline) || deadline <= 0) throw new ValidationError$1("runDriverWithRetry: until-complete requires a finite positive deadline");
 	}
+	const maxBarren = Math.max(1, run.reprompt?.maxBarren ?? 2);
 	const attempts = [];
 	let consecutiveBarren = 0;
+	let barrenReentries = 0;
 	let failures = 0;
 	let reprompts = 0;
 	let reentry;
 	const emit = async (record) => {
-		attempts.push(record);
-		await run.onAttempt?.(record);
+		const entered = reentry === void 0 ? {} : { reentry: reentry.reason };
+		const stamped = {
+			...record,
+			...entered
+		};
+		attempts.push(stamped);
+		await run.onAttempt?.(stamped);
 	};
 	/**
 	* Decide what a completed-but-undelivered drive does next. Every bound the FAILURE path applies
@@ -24962,6 +25097,7 @@ async function runDriverWithRetry(run) {
 	*/
 	const decideReprompt = async (attempt, after) => {
 		if (maxReprompts !== "until-complete" && reprompts >= maxReprompts) return { refusedBy: "reprompts-exhausted" };
+		if (barrenReentries >= maxBarren) return { refusedBy: "no-progress" };
 		if (run.signal.aborted) return { refusedBy: "aborted" };
 		const byBudget = budgetStop(run.budget(), now());
 		if (byBudget === "deadline" || byBudget === "budget-exhausted") return { refusedBy: byBudget };
@@ -24971,7 +25107,8 @@ async function runDriverWithRetry(run) {
 			maxReprompts,
 			progress: after,
 			budget: run.budget(),
-			...run.reprompt?.describe === void 0 ? {} : { describe: run.reprompt.describe }
+			...run.reprompt?.describe === void 0 ? {} : { describe: run.reprompt.describe },
+			barrenReentries
 		};
 		const decision = await run.reprompt?.onUnmetContract?.(context) ?? { steer: defaultUnmetContractSteer(context) };
 		if (decision === "stop") return { refusedBy: "caller-stop" };
@@ -25007,6 +25144,7 @@ async function runDriverWithRetry(run) {
 				if (progressed) return void 0;
 				return consecutiveBarren + 1 >= maxConsecutive ? "no-progress" : void 0;
 			})();
+			if (progressed) barrenReentries = 0;
 			if (stop !== void 0) {
 				await emit({
 					attempt,
@@ -25019,7 +25157,6 @@ async function runDriverWithRetry(run) {
 				throw new DriverAttemptsExhaustedError(error, attempts, stop);
 			}
 			consecutiveBarren = progressed ? 0 : consecutiveBarren + 1;
-			reentry = void 0;
 			const backoff = Math.min(maxBackoff, initialBackoff * 2 ** Math.max(0, consecutiveBarren - 1));
 			await emit({
 				attempt,
@@ -25029,6 +25166,11 @@ async function runDriverWithRetry(run) {
 				madeProgress: progressed,
 				retryInMs: backoff
 			});
+			reentry = {
+				reason: "driver-failure",
+				failure: errMessage(error),
+				retry: failures
+			};
 			await sleep(backoff, run.signal);
 			if (run.signal.aborted) throw new DriverAttemptsExhaustedError(error, attempts, "aborted");
 			const afterWait = budgetStop(run.budget(), now());
@@ -25041,15 +25183,12 @@ async function runDriverWithRetry(run) {
 		const progressed = madeProgress(before, after);
 		const contract = contractOf(after);
 		const contractField = contract === "none" ? {} : { contract };
+		if (progressed) barrenReentries = 0;
+		else if (reentry !== void 0 && contract === "unmet") barrenReentries += 1;
 		if (contract === "unmet" && (maxReprompts === "until-complete" || maxReprompts > 0)) {
 			const decision = await decideReprompt(attempt, after);
 			if ("steer" in decision) {
 				reprompts += 1;
-				reentry = {
-					reason: "unmet-contract",
-					steer: decision.steer,
-					reprompt: reprompts
-				};
 				await emit({
 					attempt,
 					durationMs,
@@ -25058,6 +25197,11 @@ async function runDriverWithRetry(run) {
 					reprompted: true,
 					retryInMs: 0
 				});
+				reentry = {
+					reason: "unmet-contract",
+					steer: decision.steer,
+					reprompt: reprompts
+				};
 				continue;
 			}
 			await emit({
@@ -26105,6 +26249,6 @@ function isNonEmptySpend(s) {
 	return s.iterations > 0 || s.tokens.input > 0 || s.tokens.output > 0 || s.usd > 0 || s.ms > 0 || s.tokensKnown === false || s.usdKnown === false || Object.values(s.resources ?? {}).some((resource) => resource.amount > 0 || !resource.known);
 }
 //#endregion
-export { recoverRetainedInteractiveRun as $, zeroSpend as $i, harnessTranscriptArtifact as $n, parseCommittedJsonLines as $r, isPeerMailEnvelope as $t, timerAt as A, createSandboxUsageLedger as Ai, providerAsSandboxClient as An, LOCAL_HARNESSES as Ar, workerTraceAnalysisStore as At, scopeRetainedOwnerResult as B, chargedTokens as Bi, startRetainedRun as Bn, fullProfileMaterialization as Br, workerTraceEnv as Bt, recordScopeOwnerMaterialization as C, detachedFrozen as Ci, routerBrain as Cn, sanitizeRuntimeStreamEvent as Cr, materializeTreeView as Ct, createWaitProbes as D, assertSandboxServedModel as Di, DEFAULT_SANDBOX_IDLE_TIMEOUT_SECONDS as Dn, createWorktree as Dr, captureWorkerTraceEvidence as Dt, settledToIteration as E, readSandboxOutcome as Ei, observedModelMatchesDeclared as En, captureWorktreeDiff as Er, WORKER_TOOL_TRACE_SCHEMA_VERSION as Et, consumeScopeRetainedOwnerResult as F, notifySandboxEventObserver as Fi, sandboxSessionTraceSource as Fn, terminateProcessTreeAndConfirm as Fr, newUsageTotals as Ft, interactiveAdmissionSeamKey as G, promptCacheTokenClasses as Gi, RunCancellationReason as Gn, promptResourceProfileMaterialization as Gr, createActivityLog as Gt, environmentReader as H, deleteBoxSafe as Hi, retainedCreateMaterial as Hn, promptControlProfileMaterialization as Hr, workerTraceSeamKey as Ht, prepareScopeRetainedOwnerTask as I, sandboxEventServedBackend as Ii, registerRetainedExecutorPreparation as In, AGENT_PROFILE_MATERIALIZATION_AXES as Ir, spendFromUsageEvents as It, attachWorker as J, stringifySafe as Ji, runAbortable as Jn, sandboxActProfileMaterialization as Jr, AUTHORITY_MARKERS as Jt, readWorkerInteractiveAdmissions as K, randomSuffix as Ki, abortError as Kn, renderProfileMaterializationIssues as Kr, readWorkerProgress as Kt, scopeRetainedOwnerContext as L, sandboxProgressEvents as Li, retainedExecutorSeamKey as Ln, assertProfileMaterialization as Lr, spendFromUsageTotals as Lt, waitUntil as M, isSandboxTerminalEvent as Mi, sandboxClientAsProvider as Mn, localHarnessExecutable as Mr, assertValidBudget as Mt, bindScopeRetainedOwnerEnvironmentId as N, mapSandboxEvent as Ni, createPushTraceSource as Nn, parseCodexTokenUsage as Nr, createBudgetPool as Nt, isWaitOutcome as O, canonicalStreamEventFromSandboxEvent as Oi, createAgentEnvironmentProviderRegistry as On, removeWorktree as Or, isTraceAnalysisStore as Ot, bindScopeRetainedOwnerProvider as P, mapSandboxToolEvent as Pi, decodeToolPart as Pn, CodexExecutionDiagnosticError as Pr, meterUsageEvent as Pt, reconnectRetainedInteractiveRun as Q, withTimeout as Qi, captureHarnessTranscript as Qn, isNoEntError as Qr, createPeerMailbox as Qt, scopeRetainedOwnerPriorSpend as R, sumSandboxUsage as Ri, reconnectRetainedRun as Rn, controlProfileMaterialization as Rr, WORKER_TRACE_PROPAGATION as Rt, meterRuntimeOwnedProviderAttempt as S, executableAgentSpecSnapshot as Si, readPromptOptions as Sn, sanitizeKnowledgeReadinessReport as Sr, loadSpawnForest as St, scopeOwnerExecutorNodeContext as T, projectSandboxOutcome as Ti, canonicalObservedModelParts as Tn, runWorktreeHarness as Tr, replaySpawnTree as Tt, hostDirectoryReader as U, hasCompleteCacheBreakdown as Ui, destroyInteractiveEnvironment as Un, promptModelProfileMaterialization as Ur, taskToPrompt as Ut, SPAWN_RESOURCE_PATH_MAX_BYTES as V, cloneSpend as Vi, startRetainedRunInEnvironment as Vn, profileMaterializationAxes$1 as Vr, workerTraceHeaders as Vt, resolveSpawnResourcePaths as W, isAbortError$2 as Wi, environmentGone as Wn, promptOnlyProfileMaterialization as Wr, DEFAULT_STALL_AFTER_MS as Wt, workerInteractiveBindingFile as X, throwIfAborted as Xi, defaultRedactorIdentityMaterial as Xn, validateProfileMaterialization as Xr, PEER_MAIL_WIRE_KEY as Xt, readWorkerInteractiveBinding as Y, throwAbort as Yi, defaultRedactor as Yn, unsupportedProfileDimensions as Yr, DEFAULT_PEER_MAIL_LIMITS as Yt, workerInteractiveBindingsDir as Z, unmeteredSpend as Zi, resolveRedactor as Zn, worktreeCliProfileMaterialization as Zr, claimsAuthority as Zt, assertRecursiveReservationPolicy as _, runtimeOwnedPendingExecutorMaterialization as _i, runAgentRounds as _n, padTraceId as _r, FileResultBlobStore as _t, pickBestDelivered as a, awaitAbortable$1 as aa, authoredProfileDigest as ai, bridgeAdmissionRefusal as an, traceContextToEnv as ar, rollingDispatch as at, deriveNodeExecutionIdentity as b, unknownMaterializationReceipt as bi, acquireSandbox as bn, createRuntimeStreamEventCollector as br, InMemorySpawnJournal as bt, DriverAttemptsExhaustedError as c, teardownExecutor as ca, knownExecutionBindingReceipt as ci, createCodexRolloutStoreReader as cn, buildLoopSpanNodes as cr, cliInPlaceExecutor as ct, defaultUnmetContractSteer as d, promptOptionsFromAgentTurnInput as da, providerAttemptEvidence as di, bridgeRuntimeAttachmentsKey as dn, createOtelExporter as dr, createExecutorRegistry as dt, addResourceSpend as ea, prepareJsonlAppend as ei, peerMailTools as en, persistHarnessTranscript as er, startRetainedInteractiveRun as et, runDriverWithRetry as f, providerMessageText as fa, recordRuntimeOwnedDriveHarnessProviderEvidence as fi, bridgeStopSignalKey as fn, exportEvalRuns as fr, snapshotExecutorConfig as ft, withDriverExecutor as g, runtimeOwnedExecutorProviderEvidence as gi, isTerminalDecision as gn, padSpanId as gr, createInPlaceCliExecutor as gt, isDriverSpec as h, runtimeOwnedExecutorMaterialization as hi, defaultSelectWinner as hn, loopEventToOtelSpan as hr, createSteerableSandboxSession as ht, collectDelivered as i, abortError$2 as ia, attestRuntimeOwnedScopeOwner as ii, executorFailure as in, readTraceContextFromEnv as ir, queueOf as it, validateWaitSpec as j, extractLlmCallEvent as ji, resolveAgentEnvironmentProvider as jn, harnessSupportsReasoningEffort as jr, BudgetReconcileFault as jt, pollFor as k, createSandboxToolPartState as ki, providerAsExecutor as kn, DEFAULT_LOCAL_HARNESS as kr, parseWorkerToolTraceArtifact as kt, HarnessTurnFailedError as l, teardownSurfaces as la, knownMaterializationReceipt as li, harnessUsageIsEmpty as ln, buildRuntimeEventOtelSpans as lr, cliWorktreeExecutor as lt, driverExecutorFactory as m, runtimeOwnedExecutorExecutionBinding as mi, createSandboxForSpec as mn, generateSpanId as mr, DEFAULT_SANDBOX_STEERING_MAX_TURNS as mt, createSupervisor as n, withBudgetResources as na, writeAllBytes as ni, isLiveNodeStatus as nn, createPropagatingTraceEmitter as nr, effectiveConcurrency as nt, runFinalizer as o, DEFAULT_SUCCESSFUL_SHUTDOWN_MS as oa, finalizeRuntimeOwnedPendingExecutor as oi, bridgeModelRouteRefusal as on, INTELLIGENCE_WIRE_VERSION as or, bindReusableExecutorExecutionId as ot, driverChild as p, runtimeOwnedDriveHarnessProviderEvidence as pi, TERMINAL_DECISIONS as pn, flatOtelSpan as pr, createWorktreeCliExecutor as pt, workerInteractiveAdmissionFile as q, sleep as qi, linkAbort as qn, renderUnsupported as qr, createInbox as qt, bestDelivered as r, decodeHarnessUsage as ra, attestRuntimeOwnedPendingExecutor as ri, isTerminalNodeStatus as rn, mergeTraceEnv as rr, freeSlots as rt, runTree as s, armDeadlineTimer as sa, inheritRuntimeOwnedExecutorAttestation as si, addHarnessUsage as sn, buildLoopOtelSpans as sr, captureReusableExecutorConfig as st, createRootHandle as t, resourceTelemetry as ta, readCommittedJsonLines as ti, peerMailVerbNames as tn, contentAddress as tr, errMessage as tt, classifyDriverFailure as u, promptFromAgentTurnInput as ua, newExecutionAttemptId as ui, readCodexRolloutSession as un, createOpenInferenceFileExporter as ur, createExecutor as ut, beginScopeOwnerAttempt as v, runtimeOwnedScopeOwnerRuntime as vi, createSandboxLineage as vn, toOtelAttributes as vr, FileSpawnJournal as vt, restoreScopeOwnerAcceptedExecution as w, detachedSnapshot as wi, runBrainLoop as wn, runSettledCommand as wr, pendingWaits as wt, meterRuntimeOwnedAccounting as x, executableAgentProfileSnapshot as xi, assertBoxlessPromptOptions as xn, sanitizeAgentRuntimeEvent as xr, insideCursorNamespace as xt, createScope as y, unknownExecutionBindingReceipt as yi, probeSandboxCapabilities as yn, createRuntimeEventCollector as yr, InMemoryResultBlobStore as yt, scopeRetainedOwnerResourceReader as z, addSpend as zi, recoverRetainedRun as zn, defineProfileMaterializationContract as zr, readWorkerTraceContext as zt };
+export { workerInteractiveBindingFile as $, throwIfAborted as $i, defaultRedactorIdentityMaterial as $n, validateProfileMaterialization as $r, PEER_MAIL_WIRE_KEY as $t, isWaitOutcome as A, assertSandboxServedModel as Ai, DEFAULT_SANDBOX_IDLE_TIMEOUT_SECONDS as An, createWorktree as Ar, captureWorkerTraceEvidence as At, scopeRetainedOwnerContext as B, sandboxProgressEvents as Bi, retainedExecutorSeamKey as Bn, assertProfileMaterialization as Br, spendFromUsageTotals as Bt, meterRuntimeOwnedAccounting as C, unknownMaterializationReceipt as Ci, acquireSandbox as Cn, createRuntimeStreamEventCollector as Cr, InMemorySpawnJournal as Ct, scopeOwnerExecutorNodeContext as D, detachedSnapshot as Di, runBrainLoop as Dn, runSettledCommand as Dr, pendingWaits as Dt, restoreScopeOwnerAcceptedExecution as E, detachedFrozen as Ei, routerBrain as En, sanitizeRuntimeStreamEvent as Er, materializeTreeView as Et, bindScopeRetainedOwnerEnvironmentId as F, isSandboxTerminalEvent as Fi, sandboxClientAsProvider as Fn, localHarnessExecutable as Fr, assertValidBudget as Ft, environmentReader as G, deleteBoxSafe as Gi, retainedCreateMaterial as Gn, promptControlProfileMaterialization as Gr, workerTraceSeamKey as Gt, scopeRetainedOwnerResourceReader as H, addSpend as Hi, recoverRetainedRun as Hn, defineProfileMaterializationContract as Hr, readWorkerTraceContext as Ht, bindScopeRetainedOwnerProvider as I, mapSandboxEvent as Ii, createPushTraceSource as In, parseCodexTokenUsage as Ir, createBudgetPool as It, interactiveAdmissionSeamKey as J, promptCacheTokenClasses as Ji, RunCancellationReason as Jn, promptResourceProfileMaterialization as Jr, createActivityLog as Jt, hostDirectoryReader as K, hasCompleteCacheBreakdown as Ki, destroyInteractiveEnvironment as Kn, promptModelProfileMaterialization as Kr, taskToPrompt as Kt, consumeScopeRetainedOwnerResult as L, mapSandboxToolEvent as Li, decodeToolPart as Ln, CodexExecutionDiagnosticError as Lr, meterUsageEvent as Lt, timerAt as M, createSandboxToolPartState as Mi, providerAsExecutor as Mn, DEFAULT_LOCAL_HARNESS as Mr, parseWorkerToolTraceArtifact as Mt, validateWaitSpec as N, createSandboxUsageLedger as Ni, providerAsSandboxClient as Nn, LOCAL_HARNESSES as Nr, workerTraceAnalysisStore as Nt, settledToIteration as O, projectSandboxOutcome as Oi, canonicalObservedModelParts as On, runWorktreeHarness as Or, replaySpawnTree as Ot, waitUntil as P, extractLlmCallEvent as Pi, resolveAgentEnvironmentProvider as Pn, harnessSupportsReasoningEffort as Pr, BudgetReconcileFault as Pt, readWorkerInteractiveBinding as Q, throwAbort as Qi, defaultRedactor as Qn, unsupportedProfileDimensions as Qr, DEFAULT_PEER_MAIL_LIMITS as Qt, prepareScopeRetainedOwnerTask as R, notifySandboxEventObserver as Ri, sandboxSessionTraceSource as Rn, terminateProcessTreeAndConfirm as Rr, newUsageTotals as Rt, deriveNodeExecutionIdentity as S, unknownExecutionBindingReceipt as Si, probeSandboxCapabilities as Sn, createRuntimeEventCollector as Sr, InMemoryResultBlobStore as St, recordScopeOwnerMaterialization as T, executableAgentSpecSnapshot as Ti, readPromptOptions as Tn, sanitizeKnowledgeReadinessReport as Tr, loadSpawnForest as Tt, scopeRetainedOwnerResult as U, chargedTokens as Ui, startRetainedRun as Un, fullProfileMaterialization as Ur, workerTraceEnv as Ut, scopeRetainedOwnerPriorSpend as V, sumSandboxUsage as Vi, reconnectRetainedRun as Vn, controlProfileMaterialization as Vr, WORKER_TRACE_PROPAGATION as Vt, SPAWN_RESOURCE_PATH_MAX_BYTES as W, cloneSpend as Wi, startRetainedRunInEnvironment as Wn, profileMaterializationAxes$1 as Wr, workerTraceHeaders as Wt, workerInteractiveAdmissionFile as X, sleep as Xi, linkAbort as Xn, renderUnsupported as Xr, createInbox as Xt, readWorkerInteractiveAdmissions as Y, randomSuffix as Yi, abortError as Yn, renderProfileMaterializationIssues as Yr, readWorkerProgress as Yt, attachWorker as Z, stringifySafe as Zi, runAbortable as Zn, sandboxActProfileMaterialization as Zr, AUTHORITY_MARKERS as Zt, isDriverSpec as _, runtimeOwnedExecutorExecutionBinding as _i, createSandboxForSpec as _n, generateSpanId as _r, DEFAULT_SANDBOX_STEERING_MAX_TURNS as _t, pickBestDelivered as a, withBudgetResources as aa, writeAllBytes as ai, isLiveNodeStatus as an, createPropagatingTraceEmitter as ar, effectiveConcurrency as at, beginScopeOwnerAttempt as b, runtimeOwnedPendingExecutorMaterialization as bi, runAgentRounds as bn, padTraceId as br, FileResultBlobStore as bt, DEFAULT_MAX_BARREN_REPROMPTS as c, awaitAbortable$1 as ca, authoredProfileDigest as ci, bridgeAdmissionRefusal as cn, traceContextToEnv as cr, rollingDispatch as ct, classifyDriverFailure as d, teardownExecutor as da, knownExecutionBindingReceipt as di, createCodexRolloutStoreReader as dn, buildLoopSpanNodes as dr, cliInPlaceExecutor as dt, unmeteredSpend as ea, worktreeCliProfileMaterialization as ei, claimsAuthority as en, resolveRedactor as er, workerInteractiveBindingsDir as et, defaultUnmetContractSteer as f, teardownSurfaces as fa, knownMaterializationReceipt as fi, harnessUsageIsEmpty as fn, buildRuntimeEventOtelSpans as fr, cliWorktreeExecutor as ft, driverExecutorFactory as g, runtimeOwnedDriveHarnessProviderEvidence as gi, TERMINAL_DECISIONS as gn, flatOtelSpan as gr, createWorktreeCliExecutor as gt, driverChild as h, providerMessageText as ha, recordRuntimeOwnedDriveHarnessProviderEvidence as hi, bridgeStopSignalKey as hn, exportEvalRuns as hr, snapshotExecutorConfig as ht, collectDelivered as i, resourceTelemetry as ia, readCommittedJsonLines as ii, peerMailVerbNames as in, contentAddress as ir, errMessage as it, pollFor as j, canonicalStreamEventFromSandboxEvent as ji, createAgentEnvironmentProviderRegistry as jn, removeWorktree as jr, isTraceAnalysisStore as jt, createWaitProbes as k, readSandboxOutcome as ki, observedModelMatchesDeclared as kn, captureWorktreeDiff as kr, WORKER_TOOL_TRACE_SCHEMA_VERSION as kt, DriverAttemptsExhaustedError as l, DEFAULT_SUCCESSFUL_SHUTDOWN_MS as la, finalizeRuntimeOwnedPendingExecutor as li, bridgeModelRouteRefusal as ln, INTELLIGENCE_WIRE_VERSION as lr, bindReusableExecutorExecutionId as lt, summarizeDriverAttempts as m, promptOptionsFromAgentTurnInput as ma, providerAttemptEvidence as mi, bridgeRuntimeAttachmentsKey as mn, createOtelExporter as mr, createExecutorRegistry as mt, createSupervisor as n, zeroSpend as na, parseCommittedJsonLines as ni, isPeerMailEnvelope as nn, harnessTranscriptArtifact as nr, recoverRetainedInteractiveRun as nt, runFinalizer as o, decodeHarnessUsage as oa, attestRuntimeOwnedPendingExecutor as oi, isTerminalNodeStatus as on, mergeTraceEnv as or, freeSlots as ot, runDriverWithRetry as p, promptFromAgentTurnInput as pa, newExecutionAttemptId as pi, readCodexRolloutSession as pn, createOpenInferenceFileExporter as pr, createExecutor as pt, resolveSpawnResourcePaths as q, isAbortError$2 as qi, environmentGone as qn, promptOnlyProfileMaterialization as qr, DEFAULT_STALL_AFTER_MS as qt, bestDelivered as r, addResourceSpend as ra, prepareJsonlAppend as ri, peerMailTools as rn, persistHarnessTranscript as rr, startRetainedInteractiveRun as rt, runTree as s, abortError$2 as sa, attestRuntimeOwnedScopeOwner as si, executorFailure as sn, readTraceContextFromEnv as sr, queueOf as st, createRootHandle as t, withTimeout as ta, isNoEntError as ti, createPeerMailbox as tn, captureHarnessTranscript as tr, reconnectRetainedInteractiveRun as tt, HarnessTurnFailedError as u, armDeadlineTimer as ua, inheritRuntimeOwnedExecutorAttestation as ui, addHarnessUsage as un, buildLoopOtelSpans as ur, captureReusableExecutorConfig as ut, withDriverExecutor as v, runtimeOwnedExecutorMaterialization as vi, defaultSelectWinner as vn, loopEventToOtelSpan as vr, createSteerableSandboxSession as vt, meterRuntimeOwnedProviderAttempt as w, executableAgentProfileSnapshot as wi, assertBoxlessPromptOptions as wn, sanitizeAgentRuntimeEvent as wr, insideCursorNamespace as wt, createScope as x, runtimeOwnedScopeOwnerRuntime as xi, createSandboxLineage as xn, toOtelAttributes as xr, FileSpawnJournal as xt, assertRecursiveReservationPolicy as y, runtimeOwnedExecutorProviderEvidence as yi, isTerminalDecision as yn, padSpanId as yr, createInPlaceCliExecutor as yt, reconcileScopeRetainedOwnerEnvironment as z, sandboxEventServedBackend as zi, registerRetainedExecutorPreparation as zn, AGENT_PROFILE_MATERIALIZATION_AXES as zr, spendFromUsageEvents as zt };
 
-//# sourceMappingURL=supervisor-yavsoQQo.js.map
+//# sourceMappingURL=supervisor-BGGvnXvV.js.map