@tangle-network/agent-runtime 0.220.0 → 0.220.1

package/dist/{supervisor-WRrw0nlk.js → supervisor-n8DDNGli.js}

@@ -1,4 +1,4 @@
-import { c as RetainedInteractiveAdmissionError, d as RetainedRunDispatchBindingError, f as RuntimeRunStateError, l as RetainedInteractiveBindingError, m as ValidationError$1, r as BackendTransportError, u as RetainedRunAdmissionError } from "./errors-DodWX-cb.js";
+import { c as RetainedInteractiveAdmissionError, d as RetainedRunDispatchBindingError, f as RuntimeRunStateError, i as ConfigError, l as RetainedInteractiveBindingError, m as ValidationError$1, r as BackendTransportError, t as AgentEvalError$1, u as RetainedRunAdmissionError } from "./errors-DodWX-cb.js";
 import { a as concreteProfileModel, c as profileModelExecutionSettings, d as agentHarness, l as profileProviderModel, o as enforceTokenLimits, s as profileBridgeWireModel, t as assertExecutableAgentProfile, u as resolveRouterRetryPolicy } from "./model-policy-DKDyr-fc.js";
 import { i as notifyRuntimeHookEvent } from "./runtime-hooks-tXpAarhW.js";
 import { n as assertNoSymlinkDescendant, r as publishExclusiveDurableFile } from "./durable-file-D24y9zg7.js";
@@ -18213,6 +18213,64 @@ function queueOf(units, budget) {
 	};
 }
 //#endregion
+//#region src/runtime/supervise/error-message.ts
+const maxCauseDepth = 4;
+const maxMessageLength = 32768;
+const maxPartLength = 2048;
+/** A persisted failure must explain its wrappers without exporting credentials or unbounded data. */
+function errorText(value) {
+	let text;
+	try {
+		text = typeof value === "string" ? value : JSON.stringify(value) ?? String(value);
+	} catch {
+		text = "[unprintable rejection]";
+	}
+	return String(defaultRedactor(text)).slice(0, maxMessageLength);
+}
+function errorProperty(error, field) {
+	try {
+		const value = error[field];
+		return value === void 0 ? void 0 : errorText(value).slice(0, field === "name" ? 256 : maxMessageLength);
+	} catch {
+		return `[unreadable error ${field}]`;
+	}
+}
+function errorHttpStatus(error) {
+	try {
+		const status = Reflect.get(error, "status");
+		return typeof status === "number" && Number.isInteger(status) && status >= 100 && status <= 599 ? status : void 0;
+	} catch {
+		return;
+	}
+}
+/** Shared by child settlements, driver attempts, and the final no-winner result. */
+function errMessage(error) {
+	const parts = [];
+	const seen = /* @__PURE__ */ new Set();
+	let current = error;
+	for (let depth = 0; depth <= maxCauseDepth; depth += 1) try {
+		if (!(current instanceof Error)) {
+			parts.push(errorText(current).slice(0, maxPartLength));
+			break;
+		}
+		if (seen.has(current)) {
+			parts.push("[circular]");
+			break;
+		}
+		seen.add(current);
+		const status = errorHttpStatus(current);
+		const message = (status === void 0 ? "" : `HTTP ${status}: `) + (errorProperty(current, "message") ?? "");
+		parts.push((depth === 0 ? message : `${errorProperty(current, "name")}: ${message}`).slice(0, maxPartLength));
+		current = current.cause;
+		if (current === void 0 || current === null) break;
+		if (depth === maxCauseDepth) parts.push("[cause chain truncated]");
+	} catch {
+		parts.push("[unreadable error cause]");
+		break;
+	}
+	return parts.join(": caused by ").slice(0, maxMessageLength);
+}
+//#endregion
 //#region src/runtime/retained-interactive-handle.ts
 function createRetainedInteractiveRunHandle(environment, inputRef, capabilities, requestedStart) {
 	const ref = freezeInteractiveRef(inputRef);
@@ -19585,7 +19643,7 @@ function assertWaitWithinDeadline(spec, deadlineMs) {
 */
 async function runWait(args) {
 	const { spec, label, armedAt, resumed, signal, now } = args;
-	const sleep = args.sleep ?? defaultSleep;
+	const sleep = args.sleep ?? defaultSleep$1;
 	if (signal.aborted) return {
 		kind: "cancelled",
 		reason: "aborted before arming"
@@ -19646,7 +19704,7 @@ function outcome(kind, settled, label, untilMs, armedAt, wokenAt, polls, probeEr
 }
 /** `setTimeout` that resolves early (and clears) when the scope aborts, so a cancelled wait
 *  releases the event loop immediately instead of holding the process to its deadline. */
-function defaultSleep(ms, signal) {
+function defaultSleep$1(ms, signal) {
 	if (ms <= 0 || signal.aborted) return Promise.resolve();
 	return new Promise((resolve) => {
 		const timer = setTimeout(() => {
@@ -21722,21 +21780,6 @@ function isAbortError(err) {
 function isInfraError(err) {
 	return err instanceof ValidationError$1;
 }
-/** The message a settle record carries for a thrown executor, with its cause chain. A wrapper such
-*  as `RetainedExecutionPendingError` has one fixed message, so without the chain a run record says
-*  a child went down and nothing else; across 16 pursuits on 2026-09-11, 143 of 199 children
-*  settled that way and none was diagnosable from the record (#1182). Bounded, because a cause
-*  chain can be cyclic or long and a reason is a line, not a dump. */
-function errMessage(err) {
-	if (!(err instanceof Error)) return String(err);
-	const parts = [err.message];
-	let cause = err.cause;
-	for (let depth = 0; depth < 4 && cause !== void 0 && cause !== null; depth += 1) {
-		parts.push(cause instanceof Error ? `${cause.name}: ${cause.message}` : String(cause));
-		cause = cause instanceof Error ? cause.cause : void 0;
-	}
-	return parts.join(": caused by ");
-}
 //#endregion
 //#region src/runtime/supervise/driver-executor.ts
 /**
@@ -22089,6 +22132,303 @@ function unreportedSpend(total, prior) {
 	};
 }
 //#endregion
+//#region src/runtime/supervise/driver-retry.ts
+/**
+* Root-driver retry — the root gets the same second chance a worker's transport already has.
+*
+* A spawned child that dies is typed into a `down` settlement and the driver may re-spawn it. The
+* ROOT had no such path: one dropped connection, one SIGKILLed harness process, one upstream 5xx
+* ended a run of arbitrary length with `reason: 'driver-failed'`, and every live child was torn
+* down with it (#741). The driver's budget and deadline were usually almost untouched.
+*
+* This module supplies the missing arm: run the driver again, on the SAME scope, the SAME
+* coordination server and the SAME live children, until the budget or the deadline says stop.
+* Nothing here restarts children or replays work — it re-enters the driver, and the bridge backend
+* reattaches the harness session because the execution id is bound durably per node.
+*
+* Two classifications decide everything, and both are conservative:
+*
+*  - TERMINAL failures are Runtime's own refusals: a `ValidationError`/`ConfigError` guard, an
+*    exhausted budget, an abort, a client-side transport status (401/404/422). Runtime meant them,
+*    so retrying re-runs a decision rather than recovering from an accident. They fail immediately.
+*  - TRANSIENT failures are everything foreign: a harness process that exited without a reason, a
+*    stream that cut mid-turn, a 5xx, a socket reset. Those are accidents, and they are exactly
+*    what a retry exists for.
+*
+* The one loop the budget alone cannot bound is a driver that dies INSTANTLY and repeatedly — a
+* dead-on-arrival credential, a harness that refuses to start. Spending nothing, it would retry
+* until the deadline hours later. So progress is measured between attempts, and a run of attempts
+* that changes nothing stops at `maxConsecutiveFailures`. A failure that made progress resets that
+* counter: a long run may be rescued many times, a hopeless one gives up in seconds.
+*
+* WHAT COUNTS AS PROGRESS is the part this module got wrong first, and the correction is measured.
+* The original mark read metered spend, settled children, and an accepted submission — the
+* filesystem and the meter, never the goal. Across 1,422 settled discovery-lab runs (2026-09-01)
+* that reading retried the runs that had produced NOTHING 629 of 827 times (76.1%) while retrying
+* the runs that HAD left an artifact 21 of 399 times (5.3%): the loop spent its second chances on
+* the hopeless runs and measured persistence by burn rate. So when the caller declares a completion
+* check, spend and settlements alone are NOT progress while that check is unmet; only a delivery —
+* an accepted submission, a child that passed the check, or the contract turning met — resets the
+* barren counter. A caller that declares no check reports `contract: 'none'` and keeps the exact
+* historical reading.
+*
+* THE SECOND HALF of the same defect: `budgetStop` used to be consulted only after a failure, and a
+* 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, abort, and attempt bounds a retry crosses.
+*/
+/**
+* The instruction a completed-but-undelivered drive is re-entered with when the caller supplies no
+* `onUnmetContract`. It states the verdict, names what is owed, reports the ledger, and gives the
+* three steps — the same shape `depthStrategy` re-prompts a resumed session with, said in the
+* driver's own terms.
+*/
+function defaultUnmetContractSteer(context) {
+	const owed = context.describe?.trim();
+	return [
+		"The completion check has not passed. This run has delivered nothing yet.",
+		owed === void 0 || owed.length === 0 ? "The deliverable this run owes is still missing." : `The deliverable this run owes: ${owed}`,
+		`Workers settled: ${context.progress.settledCount}. Workers that passed the check: ${context.progress.deliveredCount ?? 0}.`,
+		"Do the unfinished work with the tools.",
+		"Verify that the check passes.",
+		"Then submit the result.",
+		"Do not restate work you already did."
+	].join("\n");
+}
+const DEFAULT_MAX_CONSECUTIVE_FAILURES = 3;
+const DEFAULT_MAX_ATTEMPTS = 8;
+const DEFAULT_INITIAL_BACKOFF_MS = 2e3;
+const DEFAULT_MAX_BACKOFF_MS = 3e4;
+/**
+* Bridge error classes the bridge itself never retries: a request that fails identically on
+* every attempt, mapped below 5xx on its HTTP path (`parse_error` 400, the other two 501). On the
+* stream path the same failure arrives with no status at all — a profile that cannot materialize
+* is a `parse_error` — and the status split alone read it as a bad moment and re-drove it to the
+* attempt ceiling.
+*/
+const DETERMINISTIC_BRIDGE_CODES = /* @__PURE__ */ new Set([
+	"parse_error",
+	"not_configured",
+	"capability_denied"
+]);
+/**
+* Classify one driver failure. Runtime's own typed refusals are decisions and stay terminal;
+* anything foreign is an accident and is retryable. A `BackendTransportError` is split by status
+* because the taxonomy already promises consumers may branch on it: a 5xx/429/408 is the upstream
+* having a bad moment, while a 401/404/422 is a request that will fail identically forever. The
+* bridge's own never-retry classes are terminal whether or not a status rides with them.
+*/
+function classifyDriverFailure(error, signal) {
+	if (signal?.aborted) return "terminal";
+	if (error instanceof Error && errorProperty(error, "name") === "AbortError") return "terminal";
+	if (error instanceof BackendTransportError) {
+		if (error.upstreamCode !== void 0 && DETERMINISTIC_BRIDGE_CODES.has(error.upstreamCode)) return "terminal";
+		const status = error.status;
+		if (status === void 0) return "transient";
+		if (status === 408 || status === 429 || status >= 500) return "transient";
+		return "terminal";
+	}
+	if (error instanceof ValidationError$1 || error instanceof ConfigError || error instanceof RuntimeRunStateError) return "terminal";
+	if (error instanceof AgentEvalError$1) return "terminal";
+	return "transient";
+}
+/** The budget's own verdict on whether another attempt may run at all. */
+function budgetStop(budget, atMs) {
+	if (budget.deadlineMs > 0 && atMs >= budget.deadlineMs) return "deadline";
+	if (budget.tokensLeft <= 0 || budget.iterationsLeft <= 0) return "budget-exhausted";
+	if (budget.usdCapped && budget.usdLeft <= 0) return "budget-exhausted";
+	if (budget.usdCapped && budget.usdKnown === false) return "budget-exhausted";
+	if (Object.values(budget.resources ?? {}).some((resource) => !resource.known || resource.remaining <= 0)) return "budget-exhausted";
+}
+function contractOf(mark) {
+	return mark.contract ?? "none";
+}
+/**
+* Did this attempt move the run toward its DELIVERABLE?
+*
+* A delivery always counts: an accepted submission, one more child that passed the check, or the
+* contract turning met. Spend and settlements count only while no declared check is outstanding —
+* with a check unmet they are the burn-rate reading this module's header measures and rejects.
+*/
+function madeProgress(before, after) {
+	if (after.submitted && !before.submitted) return true;
+	if ((after.deliveredCount ?? 0) > (before.deliveredCount ?? 0)) return true;
+	if (contractOf(before) !== "met" && contractOf(after) === "met") return true;
+	if (contractOf(after) === "unmet") return false;
+	return after.poolTokensSpent > before.poolTokensSpent || after.settledCount > before.settledCount;
+}
+/** The error a give-up throws: the original cause, re-described with the attempt history so
+*  `driver-failed` carries a diagnosable message instead of one backend's last words. */
+var DriverAttemptsExhaustedError = class extends RuntimeRunStateError {
+	attempts;
+	stop;
+	constructor(cause, attempts, stop) {
+		const last = attempts[attempts.length - 1];
+		const causeText = cause instanceof Error ? `${errorProperty(cause, "name")}: ${errMessage(cause)}` : errMessage(cause);
+		const firstFailure = attempts.find((attempt) => attempt.error !== void 0)?.error;
+		super(`supervisor driver failed after ${attempts.length} attempt(s) — stopped by ${stop}; ` + (firstFailure !== void 0 && firstFailure !== last?.error ? `first failure: ${errorText(firstFailure)}; ` : "") + `last cause: ${causeText}` + (last?.classification ? ` (classified ${last.classification})` : ""), { cause });
+		this.attempts = Object.freeze([...attempts]);
+		this.stop = stop;
+	}
+};
+async function defaultSleep(ms, signal) {
+	if (ms <= 0 || signal.aborted) return;
+	await new Promise((resolve) => {
+		const done = () => {
+			clearTimeout(timer);
+			signal.removeEventListener("abort", done);
+			resolve();
+		};
+		const timer = setTimeout(done, ms);
+		if (typeof timer === "object" && timer !== null && "unref" in timer) timer.unref();
+		signal.addEventListener("abort", done, { once: true });
+	});
+}
+/**
+* Run the driver until it completes WITH ITS CONTRACT MET, or until the budget, the deadline, an
+* abort, a terminal error, or a ceiling stops it. Transient failures are retried. A drive that
+* returns with its completion check unmet is re-entered on the same live session with the unmet
+* items, up to `reprompt.maxReprompts`. Throws `DriverAttemptsExhaustedError` (cause = the last
+* real failure) when a FAILURE ends the loop; a completed drive returns, met contract or not,
+* because deciding what an undelivered run is worth belongs to the finalizer, not to this loop.
+*/
+async function runDriverWithRetry(run) {
+	const now = run.now ?? Date.now;
+	const sleep = run.sleep ?? defaultSleep;
+	const policy = run.policy ?? {};
+	const retryEnabled = policy.enabled !== false;
+	const maxConsecutive = Math.max(0, policy.maxConsecutiveFailures ?? DEFAULT_MAX_CONSECUTIVE_FAILURES);
+	const maxAttempts = Math.max(1, policy.maxAttempts ?? DEFAULT_MAX_ATTEMPTS);
+	const initialBackoff = Math.max(0, policy.initialBackoffMs ?? DEFAULT_INITIAL_BACKOFF_MS);
+	const maxBackoff = Math.max(initialBackoff, policy.maxBackoffMs ?? DEFAULT_MAX_BACKOFF_MS);
+	const maxReprompts = Math.max(0, run.reprompt?.maxReprompts ?? 0);
+	const attempts = [];
+	let consecutiveBarren = 0;
+	let reprompts = 0;
+	let reentry;
+	const emit = async (record) => {
+		attempts.push(record);
+		await run.onAttempt?.(record);
+	};
+	/**
+	* Decide what a completed-but-undelivered drive does next. Every bound the FAILURE path applies
+	* is applied here too — that is the fix for `budgetStop` having lived only in the catch arm — and
+	* the caller's hook is consulted last, so no hook can talk the loop past a deadline.
+	*/
+	const decideReprompt = async (attempt, after) => {
+		if (reprompts >= maxReprompts) return { refusedBy: "reprompts-exhausted" };
+		if (run.signal.aborted) return { refusedBy: "aborted" };
+		const byBudget = budgetStop(run.budget(), now());
+		if (byBudget === "deadline" || byBudget === "budget-exhausted") return { refusedBy: byBudget };
+		if (attempt >= maxAttempts) return { refusedBy: "max-attempts" };
+		const context = {
+			attempt,
+			reprompts,
+			maxReprompts,
+			progress: after,
+			budget: run.budget(),
+			...run.reprompt?.describe === void 0 ? {} : { describe: run.reprompt.describe }
+		};
+		const decision = await run.reprompt?.onUnmetContract?.(context) ?? { steer: defaultUnmetContractSteer(context) };
+		if (decision === "stop") return { refusedBy: "caller-stop" };
+		const steer = typeof decision.steer === "string" ? decision.steer.trim() : "";
+		if (steer.length === 0) throw new ValidationError$1("runDriverWithRetry: onUnmetContract returned an empty steer — return a non-empty instruction or 'stop'");
+		return { steer };
+	};
+	for (let attempt = 1;; attempt += 1) {
+		const before = run.progress();
+		const startedAt = now();
+		try {
+			await run.drive(attempt, reentry);
+		} catch (error) {
+			const durationMs = now() - startedAt;
+			const classification = classifyDriverFailure(error, run.signal);
+			const progressed = madeProgress(before, run.progress());
+			const stop = (() => {
+				if (classification === "terminal") return "terminal-error";
+				if (!retryEnabled) return "retry-disabled";
+				if (run.signal.aborted) return "aborted";
+				const byBudget = budgetStop(run.budget(), now());
+				if (byBudget) return byBudget;
+				if (attempt >= maxAttempts) return "max-attempts";
+				if (progressed) return void 0;
+				return consecutiveBarren + 1 >= maxConsecutive ? "no-progress" : void 0;
+			})();
+			if (stop !== void 0) {
+				await emit({
+					attempt,
+					durationMs,
+					error: errMessage(error),
+					classification,
+					madeProgress: progressed,
+					stop
+				});
+				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,
+				durationMs,
+				error: errMessage(error),
+				classification,
+				madeProgress: progressed,
+				retryInMs: backoff
+			});
+			await sleep(backoff, run.signal);
+			if (run.signal.aborted) throw new DriverAttemptsExhaustedError(error, attempts, "aborted");
+			const afterWait = budgetStop(run.budget(), now());
+			if (afterWait) throw new DriverAttemptsExhaustedError(error, attempts, afterWait);
+			continue;
+		}
+		const durationMs = now() - startedAt;
+		const after = run.progress();
+		const progressed = madeProgress(before, after);
+		const contract = contractOf(after);
+		const contractField = contract === "none" ? {} : { contract };
+		if (contract === "unmet" && 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,
+					madeProgress: progressed,
+					...contractField,
+					reprompted: true,
+					retryInMs: 0
+				});
+				continue;
+			}
+			await emit({
+				attempt,
+				durationMs,
+				madeProgress: progressed,
+				...contractField,
+				repromptRefusedBy: decision.refusedBy,
+				stop: "completed"
+			});
+			return;
+		}
+		await emit({
+			attempt,
+			durationMs,
+			madeProgress: progressed,
+			...contractField,
+			stop: "completed"
+		});
+		return;
+	}
+}
+//#endregion
 //#region src/runtime/supervise/finalizer.ts
 /**
 * `SupervisorFinalizer` — the pluggable last step of a driver run: how the settled-worker ledger
@@ -22339,20 +22679,17 @@ const defaultMaxDepth = 4;
 * a stringification that itself throws (circular, hostile `toString`) falls back to the tag.
 */
 function describeRejection(error) {
-	if (error instanceof Error) return {
-		name: error.name,
-		message: error.message,
-		...error.stack !== void 0 ? { stack: error.stack } : {}
-	};
-	let message;
-	try {
-		message = typeof error === "string" ? error : JSON.stringify(error) ?? String(error);
-	} catch {
-		message = Object.prototype.toString.call(error);
+	if (error instanceof Error) {
+		const stack = errorProperty(error, "stack");
+		return {
+			name: errorProperty(error, "name") ?? "Error",
+			message: error instanceof DriverAttemptsExhaustedError ? errorProperty(error, "message") ?? "" : errMessage(error),
+			...stack !== void 0 ? { stack } : {}
+		};
 	}
 	return {
 		name: "NonError",
-		message
+		message: errMessage(error)
 	};
 }
 /** Create a supervisor that owns one recursive agent execution tree. */
@@ -22945,6 +23282,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 { createExecutor as $, createPropagatingTraceEmitter as $n, attestRuntimeOwnedScopeOwner as $r, createSandboxForSpec as $t, scopeRetainedOwnerPriorSpend as A, notifySandboxEventObserver as Ai, unmeteredSpend as An, parseCodexTokenUsage as Ar, DEFAULT_STALL_AFTER_MS as At, recoverRetainedInteractiveRun as B, retainedExecutorSeamKey as Bn, promptOnlyProfileMaterialization as Br, peerMailTools as Bt, pollFor as C, canonicalStreamEventFromSandboxEvent as Ci, isAbortError$2 as Cn, captureWorktreeDiff as Cr, spendFromUsageEvents as Ct, consumeScopeRetainedOwnerResult as D, isSandboxTerminalEvent as Di, stringifySafe as Dn, LOCAL_HARNESSES as Dr, workerTraceHeaders as Dt, waitUntil as E, extractLlmCallEvent as Ei, sleep as En, DEFAULT_LOCAL_HARNESS as Er, workerTraceEnv as Et, attachWorker as F, abortError$2 as Fi, withBudgetResources as Fn, defineProfileMaterializationContract as Fr, DEFAULT_PEER_MAIL_LIMITS as Ft, queueOf as G, reconnectRetainedRun as Gn, unsupportedProfileDimensions as Gr, bridgeModelRouteRefusal as Gt, destroyInteractiveEnvironment as H, abortError$1 as Hn, renderProfileMaterializationIssues as Hr, isLiveNodeStatus as Ht, readWorkerInteractiveBinding as I, awaitAbortable$1 as Ii, createPushTraceSource as In, fullProfileMaterialization as Ir, PEER_MAIL_WIRE_KEY as It, teardownExecutor as J, startRetainedRunInEnvironment as Jn, isNoEntError as Jr, harnessUsageIsEmpty as Jt, rollingDispatch as K, recoverRetainedRun as Kn, validateProfileMaterialization as Kr, addHarnessUsage as Kt, workerInteractiveBindingFile as L, promptFromAgentTurnInput as Li, decodeToolPart as Ln, profileMaterializationAxes$1 as Lr, claimsAuthority as Lt, interactiveAdmissionSeamKey as M, sandboxProgressEvents as Mi, zeroSpend as Mn, AGENT_PROFILE_MATERIALIZATION_AXES as Mr, readWorkerProgress as Mt, readWorkerInteractiveAdmissions as N, sumSandboxUsage as Ni, addResourceSpend as Nn, assertProfileMaterialization as Nr, createInbox as Nt, prepareScopeRetainedOwnerTask as O, mapSandboxEvent as Oi, throwAbort as On, harnessSupportsReasoningEffort as Or, workerTraceSeamKey as Ot, workerInteractiveAdmissionFile as P, decodeHarnessUsage as Pi, resourceTelemetry as Pn, controlProfileMaterialization as Pr, AUTHORITY_MARKERS as Pt, cliWorktreeExecutor as Q, resolveRedactor as Qn, attestRuntimeOwnedPendingExecutor as Qr, TERMINAL_DECISIONS as Qt, workerInteractiveBindingsDir as R, promptOptionsFromAgentTurnInput as Ri, sandboxSessionTraceSource as Rn, promptControlProfileMaterialization as Rr, createPeerMailbox as Rt, isWaitOutcome as S, assertSandboxServedModel as Si, hasCompleteCacheBreakdown as Sn, runWorktreeHarness as Sr, createBudgetPool as St, validateWaitSpec as T, createSandboxUsageLedger as Ti, randomSuffix as Tn, removeWorktree as Tr, readWorkerTraceContext as Tt, effectiveConcurrency as U, linkAbort as Un, renderUnsupported as Ur, isTerminalNodeStatus as Ut, startRetainedInteractiveRun as V, RunCancellationReason as Vn, promptResourceProfileMaterialization as Vr, peerMailVerbNames as Vt, freeSlots as W, runAbortable as Wn, sandboxActProfileMaterialization as Wr, bridgeAdmissionRefusal as Wt, captureReusableExecutorConfig as X, defaultRedactor as Xn, prepareJsonlAppend as Xr, bridgeRuntimeAttachmentsKey as Xt, bindReusableExecutorExecutionId as Y, retainedCreateMaterial as Yn, parseCommittedJsonLines as Yr, readCodexRolloutSession as Yt, cliInPlaceExecutor as Z, defaultRedactorIdentityMaterial as Zn, writeAllBytes as Zr, bridgeStopSignalKey as Zt, recordScopeOwnerMaterialization as _, executableAgentSpecSnapshot as _i, sandboxClientAsProvider as _n, createRuntimeStreamEventCollector as _r, isTraceAnalysisStore as _t, pickBestDelivered as a, newExecutionAttemptId as ai, acquireSandbox as an, buildLoopSpanNodes as ar, createInPlaceCliExecutor as at, settledToIteration as b, projectSandboxOutcome as bi, cloneSpend as bn, sanitizeRuntimeStreamEvent as br, contentAddress as bt, driverChild as c, runtimeOwnedDriveHarnessProviderEvidence as ci, routerBrain as cn, createOtelExporter as cr, InMemoryResultBlobStore as ct, withDriverExecutor as d, runtimeOwnedExecutorProviderEvidence as di, observedModelMatchesDeclared as dn, generateSpanId as dr, loadSpawnForest as dt, authoredProfileDigest as ei, defaultSelectWinner as en, mergeTraceEnv as er, createExecutorRegistry as et, beginScopeOwnerAttempt as f, runtimeOwnedPendingExecutorMaterialization as fi, DEFAULT_SANDBOX_IDLE_TIMEOUT_SECONDS as fn, loopEventToOtelSpan as fr, materializeTreeView as ft, meterRuntimeOwnedProviderAttempt as g, executableAgentProfileSnapshot as gi, resolveAgentEnvironmentProvider as gn, createRuntimeEventCollector as gr, captureWorkerTraceEvidence as gt, meterRuntimeOwnedAccounting as h, unknownMaterializationReceipt as hi, providerAsSandboxClient as hn, toOtelAttributes as hr, WORKER_TOOL_TRACE_SCHEMA_VERSION as ht, collectDelivered as i, knownMaterializationReceipt as ii, probeSandboxCapabilities as in, buildLoopOtelSpans as ir, createSteerableSandboxSession as it, scopeRetainedOwnerResult as j, sandboxEventServedBackend as ji, withTimeout as jn, CodexExecutionDiagnosticError as jr, createActivityLog as jt, scopeRetainedOwnerContext as k, mapSandboxToolEvent as ki, throwIfAborted as kn, localHarnessExecutable as kr, taskToPrompt as kt, driverExecutorFactory as l, runtimeOwnedExecutorExecutionBinding as li, runBrainLoop as ln, exportEvalRuns as lr, InMemorySpawnJournal as lt, deriveNodeExecutionIdentity as m, unknownExecutionBindingReceipt as mi, providerAsExecutor as mn, padTraceId as mr, replaySpawnTree as mt, createSupervisor as n, inheritRuntimeOwnedExecutorAttestation as ni, runAgentRounds as nn, traceContextToEnv as nr, createWorktreeCliExecutor as nt, runFinalizer as o, providerAttemptEvidence as oi, assertBoxlessPromptOptions as on, buildRuntimeEventOtelSpans as or, FileResultBlobStore as ot, createScope as p, runtimeOwnedScopeOwnerRuntime as pi, createAgentEnvironmentProviderRegistry as pn, padSpanId as pr, pendingWaits as pt, DEFAULT_SUCCESSFUL_SHUTDOWN_MS as q, startRetainedRun as qn, worktreeCliProfileMaterialization as qr, createCodexRolloutStoreReader as qt, bestDelivered as r, knownExecutionBindingReceipt as ri, createSandboxLineage as rn, INTELLIGENCE_WIRE_VERSION as rr, DEFAULT_SANDBOX_STEERING_MAX_TURNS as rt, runTree as s, recordRuntimeOwnedDriveHarnessProviderEvidence as si, readPromptOptions as sn, createOpenInferenceFileExporter as sr, FileSpawnJournal as st, createRootHandle as t, finalizeRuntimeOwnedPendingExecutor as ti, isTerminalDecision as tn, readTraceContextFromEnv as tr, snapshotExecutorConfig as tt, isDriverSpec as u, runtimeOwnedExecutorMaterialization as ui, canonicalObservedModelParts as un, flatOtelSpan as ur, insideCursorNamespace as ut, restoreScopeOwnerAcceptedExecution as v, detachedFrozen as vi, addSpend as vn, sanitizeAgentRuntimeEvent as vr, parseWorkerToolTraceArtifact as vt, timerAt as w, createSandboxToolPartState as wi, promptCacheTokenClasses as wn, createWorktree as wr, WORKER_TRACE_PROPAGATION as wt, createWaitProbes as x, readSandboxOutcome as xi, deleteBoxSafe as xn, runSettledCommand as xr, assertValidBudget as xt, scopeOwnerExecutorNodeContext as y, detachedSnapshot as yi, chargedTokens as yn, sanitizeKnowledgeReadinessReport as yr, workerTraceAnalysisStore as yt, reconnectRetainedInteractiveRun as z, providerMessageText as zi, registerRetainedExecutorPreparation as zn, promptModelProfileMaterialization as zr, isPeerMailEnvelope as zt };
+export { bindReusableExecutorExecutionId as $, retainedCreateMaterial as $n, parseCommittedJsonLines as $r, readCodexRolloutSession as $t, waitUntil as A, extractLlmCallEvent as Ai, sleep as An, DEFAULT_LOCAL_HARNESS as Ar, workerTraceEnv as At, readWorkerInteractiveBinding as B, awaitAbortable$1 as Bi, createPushTraceSource as Bn, fullProfileMaterialization as Br, PEER_MAIL_WIRE_KEY as Bt, scopeOwnerExecutorNodeContext as C, detachedSnapshot as Ci, chargedTokens as Cn, sanitizeKnowledgeReadinessReport as Cr, workerTraceAnalysisStore as Ct, pollFor as D, canonicalStreamEventFromSandboxEvent as Di, isAbortError$2 as Dn, captureWorktreeDiff as Dr, spendFromUsageEvents as Dt, isWaitOutcome as E, assertSandboxServedModel as Ei, hasCompleteCacheBreakdown as En, runWorktreeHarness as Er, createBudgetPool as Et, scopeRetainedOwnerResult as F, sandboxEventServedBackend as Fi, withTimeout as Fn, CodexExecutionDiagnosticError as Fr, createActivityLog as Ft, startRetainedInteractiveRun as G, RunCancellationReason as Gn, promptResourceProfileMaterialization as Gr, peerMailVerbNames as Gt, workerInteractiveBindingsDir as H, promptOptionsFromAgentTurnInput as Hi, sandboxSessionTraceSource as Hn, promptControlProfileMaterialization as Hr, createPeerMailbox as Ht, interactiveAdmissionSeamKey as I, sandboxProgressEvents as Ii, zeroSpend as In, AGENT_PROFILE_MATERIALIZATION_AXES as Ir, readWorkerProgress as It, freeSlots as J, runAbortable as Jn, sandboxActProfileMaterialization as Jr, bridgeAdmissionRefusal as Jt, destroyInteractiveEnvironment as K, abortError$1 as Kn, renderProfileMaterializationIssues as Kr, isLiveNodeStatus as Kt, readWorkerInteractiveAdmissions as L, sumSandboxUsage as Li, addResourceSpend as Ln, assertProfileMaterialization as Lr, createInbox as Lt, prepareScopeRetainedOwnerTask as M, mapSandboxEvent as Mi, throwAbort as Mn, harnessSupportsReasoningEffort as Mr, workerTraceSeamKey as Mt, scopeRetainedOwnerContext as N, mapSandboxToolEvent as Ni, throwIfAborted as Nn, localHarnessExecutable as Nr, taskToPrompt as Nt, timerAt as O, createSandboxToolPartState as Oi, promptCacheTokenClasses as On, createWorktree as Or, WORKER_TRACE_PROPAGATION as Ot, scopeRetainedOwnerPriorSpend as P, notifySandboxEventObserver as Pi, unmeteredSpend as Pn, parseCodexTokenUsage as Pr, DEFAULT_STALL_AFTER_MS as Pt, teardownExecutor as Q, startRetainedRunInEnvironment as Qn, isNoEntError as Qr, harnessUsageIsEmpty as Qt, workerInteractiveAdmissionFile as R, decodeHarnessUsage as Ri, resourceTelemetry as Rn, controlProfileMaterialization as Rr, AUTHORITY_MARKERS as Rt, restoreScopeOwnerAcceptedExecution as S, detachedFrozen as Si, addSpend as Sn, sanitizeAgentRuntimeEvent as Sr, parseWorkerToolTraceArtifact as St, createWaitProbes as T, readSandboxOutcome as Ti, deleteBoxSafe as Tn, runSettledCommand as Tr, assertValidBudget as Tt, reconnectRetainedInteractiveRun as U, providerMessageText as Ui, registerRetainedExecutorPreparation as Un, promptModelProfileMaterialization as Ur, isPeerMailEnvelope as Ut, workerInteractiveBindingFile as V, promptFromAgentTurnInput as Vi, decodeToolPart as Vn, profileMaterializationAxes$1 as Vr, claimsAuthority as Vt, recoverRetainedInteractiveRun as W, retainedExecutorSeamKey as Wn, promptOnlyProfileMaterialization as Wr, peerMailTools as Wt, rollingDispatch as X, recoverRetainedRun as Xn, validateProfileMaterialization as Xr, addHarnessUsage as Xt, queueOf as Y, reconnectRetainedRun as Yn, unsupportedProfileDimensions as Yr, bridgeModelRouteRefusal as Yt, DEFAULT_SUCCESSFUL_SHUTDOWN_MS as Z, startRetainedRun as Zn, worktreeCliProfileMaterialization as Zr, createCodexRolloutStoreReader as Zt, createScope as _, runtimeOwnedScopeOwnerRuntime as _i, createAgentEnvironmentProviderRegistry as _n, padSpanId as _r, pendingWaits as _t, pickBestDelivered as a, finalizeRuntimeOwnedPendingExecutor as ai, isTerminalDecision as an, readTraceContextFromEnv as ar, snapshotExecutorConfig as at, meterRuntimeOwnedProviderAttempt as b, executableAgentProfileSnapshot as bi, resolveAgentEnvironmentProvider as bn, createRuntimeEventCollector as br, captureWorkerTraceEvidence as bt, DriverAttemptsExhaustedError as c, knownMaterializationReceipt as ci, probeSandboxCapabilities as cn, buildLoopOtelSpans as cr, createSteerableSandboxSession as ct, runDriverWithRetry as d, recordRuntimeOwnedDriveHarnessProviderEvidence as di, readPromptOptions as dn, createOpenInferenceFileExporter as dr, FileSpawnJournal as dt, prepareJsonlAppend as ei, bridgeRuntimeAttachmentsKey as en, defaultRedactor as er, captureReusableExecutorConfig as et, driverChild as f, runtimeOwnedDriveHarnessProviderEvidence as fi, routerBrain as fn, createOtelExporter as fr, InMemoryResultBlobStore as ft, beginScopeOwnerAttempt as g, runtimeOwnedPendingExecutorMaterialization as gi, DEFAULT_SANDBOX_IDLE_TIMEOUT_SECONDS as gn, loopEventToOtelSpan as gr, materializeTreeView as gt, withDriverExecutor as h, runtimeOwnedExecutorProviderEvidence as hi, observedModelMatchesDeclared as hn, generateSpanId as hr, loadSpawnForest as ht, collectDelivered as i, authoredProfileDigest as ii, defaultSelectWinner as in, mergeTraceEnv as ir, createExecutorRegistry as it, consumeScopeRetainedOwnerResult as j, isSandboxTerminalEvent as ji, stringifySafe as jn, LOCAL_HARNESSES as jr, workerTraceHeaders as jt, validateWaitSpec as k, createSandboxUsageLedger as ki, randomSuffix as kn, removeWorktree as kr, readWorkerTraceContext as kt, classifyDriverFailure as l, newExecutionAttemptId as li, acquireSandbox as ln, buildLoopSpanNodes as lr, createInPlaceCliExecutor as lt, isDriverSpec as m, runtimeOwnedExecutorMaterialization as mi, canonicalObservedModelParts as mn, flatOtelSpan as mr, insideCursorNamespace as mt, createSupervisor as n, attestRuntimeOwnedPendingExecutor as ni, TERMINAL_DECISIONS as nn, resolveRedactor as nr, cliWorktreeExecutor as nt, runFinalizer as o, inheritRuntimeOwnedExecutorAttestation as oi, runAgentRounds as on, traceContextToEnv as or, createWorktreeCliExecutor as ot, driverExecutorFactory as p, runtimeOwnedExecutorExecutionBinding as pi, runBrainLoop as pn, exportEvalRuns as pr, InMemorySpawnJournal as pt, effectiveConcurrency as q, linkAbort as qn, renderUnsupported as qr, isTerminalNodeStatus as qt, bestDelivered as r, attestRuntimeOwnedScopeOwner as ri, createSandboxForSpec as rn, createPropagatingTraceEmitter as rr, createExecutor as rt, runTree as s, knownExecutionBindingReceipt as si, createSandboxLineage as sn, INTELLIGENCE_WIRE_VERSION as sr, DEFAULT_SANDBOX_STEERING_MAX_TURNS as st, createRootHandle as t, writeAllBytes as ti, bridgeStopSignalKey as tn, defaultRedactorIdentityMaterial as tr, cliInPlaceExecutor as tt, defaultUnmetContractSteer as u, providerAttemptEvidence as ui, assertBoxlessPromptOptions as un, buildRuntimeEventOtelSpans as ur, FileResultBlobStore as ut, deriveNodeExecutionIdentity as v, unknownExecutionBindingReceipt as vi, providerAsExecutor as vn, padTraceId as vr, replaySpawnTree as vt, settledToIteration as w, projectSandboxOutcome as wi, cloneSpend as wn, sanitizeRuntimeStreamEvent as wr, contentAddress as wt, recordScopeOwnerMaterialization as x, executableAgentSpecSnapshot as xi, sandboxClientAsProvider as xn, createRuntimeStreamEventCollector as xr, isTraceAnalysisStore as xt, meterRuntimeOwnedAccounting as y, unknownMaterializationReceipt as yi, providerAsSandboxClient as yn, toOtelAttributes as yr, WORKER_TOOL_TRACE_SCHEMA_VERSION as yt, attachWorker as z, abortError$2 as zi, withBudgetResources as zn, defineProfileMaterializationContract as zr, DEFAULT_PEER_MAIL_LIMITS as zt };
 
-//# sourceMappingURL=supervisor-WRrw0nlk.js.map
+//# sourceMappingURL=supervisor-n8DDNGli.js.map