@tangle-network/agent-runtime 0.319.8 → 0.320.1

package/dist/{supervisor-CRod4ISR.js → supervisor-CCtmmmOz.js}

@@ -7428,6 +7428,42 @@ async function captureProviderLiveWorkspace(port, context, parent) {
 		clearDeadline();
 	}
 }
+/** @internal Construct the same exact receipt for a live capture and evidence-only recovery. */
+function workspaceCaptureReceipt(context, captured) {
+	const { snapshot, provenance, coverageComplete = false, incompleteReason } = captured;
+	return {
+		executionId: context.executionId,
+		...context.controlRef === void 0 ? {} : { controlRef: context.controlRef },
+		...context.node === void 0 ? {} : { node: context.node },
+		environmentId: context.environment.id,
+		profileDigest: canonicalAgentProfileDigest(context.profile),
+		...capturedSessionIdentity(provenance, coverageComplete, context.executionId, context.providerSessionId ?? null),
+		snapshot,
+		provenance,
+		coverageComplete,
+		...incompleteReason === void 0 ? {} : { incompleteReason }
+	};
+}
+/** Only a verified, single-session capture may supply a scalar session identity. */
+function capturedSessionIdentity(provenance, coverageComplete, executionId, providerSessionId) {
+	const unknown = {
+		providerSessionId,
+		nativeSessionId: null
+	};
+	if (!coverageComplete || provenance?.status !== "reported" || provenance.executionId !== executionId || provenance.sessions?.length !== 1) return unknown;
+	const session = provenance.sessions[0];
+	if (session.executionId !== executionId || providerSessionId !== null && session.id !== providerSessionId) return unknown;
+	const ids = new Set((provenance.attempts ?? []).filter((attempt) => session.executionIds?.includes(attempt.executionId)).flatMap((attempt) => attempt.nativeSessionIds));
+	const nativeSessionId = ids.size === 1 ? [...ids][0] : null;
+	if (session.nativeSessionId != null && nativeSessionId !== session.nativeSessionId) return {
+		providerSessionId,
+		nativeSessionId: null
+	};
+	return {
+		providerSessionId,
+		nativeSessionId
+	};
+}
 /** Validate the executable retention port at the create boundary. */
 function assertProviderWorkspaceRetentionPort(port, context) {
 	if (!Number.isSafeInteger(port.timeoutMs) || port.timeoutMs <= 0) throw new ValidationError$1(`${context}: workspaceRetention.timeoutMs must be a positive safe integer`);
@@ -11272,6 +11308,13 @@ function classifyRetainedPendingCause(cause, phase = "execution") {
 	}
 	return "unobservable";
 }
+/** @internal Evidence recovery failed; the accepted turn stands and a root pursuit stays open. */
+var RetainedWorkspaceCapturePendingError = class extends Error {
+	constructor(executionId, cause) {
+		super(`retained workspace capture pending for ${executionId}; source environment preserved: ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
+		this.name = "RetainedWorkspaceCapturePendingError";
+	}
+};
 /**
 * Local observation stopped; the retained provider execution has no accepted terminal result.
 *
@@ -11670,26 +11713,6 @@ function providerAsSandboxClient(provider, options = {}) {
 		});
 	} };
 }
-/** Only a verified, single-session capture may supply a scalar session identity. */
-function capturedSessionIdentity(provenance, coverageComplete, executionId, providerSessionId) {
-	const unknown = {
-		providerSessionId,
-		nativeSessionId: null
-	};
-	if (!coverageComplete || provenance?.status !== "reported" || provenance.executionId !== executionId || provenance.sessions?.length !== 1) return unknown;
-	const session = provenance.sessions[0];
-	if (session.executionId !== executionId || providerSessionId !== null && session.id !== providerSessionId) return unknown;
-	const ids = new Set((provenance.attempts ?? []).filter((attempt) => session.executionIds?.includes(attempt.executionId)).flatMap((attempt) => attempt.nativeSessionIds));
-	const nativeSessionId = ids.size === 1 ? [...ids][0] : null;
-	if (session.nativeSessionId != null && nativeSessionId !== session.nativeSessionId) return {
-		providerSessionId,
-		nativeSessionId: null
-	};
-	return {
-		providerSessionId,
-		nativeSessionId
-	};
-}
 /**
 * Lower the seam's prompt options onto turn fields, through the one mapper this module already
 * uses to raise a sandbox prompt into a provider turn. Reusing it is what keeps the two directions
@@ -12497,24 +12520,24 @@ function admittedEnvironmentId(retention) {
 	}
 }
 function providerWorkspaceCaptureReceipt(args, environment, snapshot, fallbackSessionId) {
-	const provenance = args.workspaceProvenance();
 	const coverage = args.workspaceCoverage();
 	const controlRef = args.workspaceControlRef();
-	return {
+	return workspaceCaptureReceipt({
 		executionId: args.executionId,
 		...controlRef === void 0 ? {} : { controlRef },
 		...args.node === void 0 ? {} : { node: args.node },
-		environmentId: environment.id,
-		profileDigest: canonicalAgentProfileDigest(args.profile),
-		...capturedSessionIdentity(provenance, coverage.complete, args.executionId, controlRef?.sessionId ?? fallbackSessionId),
+		environment,
+		profile: args.profile,
+		providerSessionId: controlRef?.sessionId ?? fallbackSessionId
+	}, {
 		snapshot,
-		provenance: provenance ?? {
+		provenance: args.workspaceProvenance() ?? {
 			status: "unavailable",
 			missing: ["Capture coverage metadata was not retained"]
 		},
 		coverageComplete: coverage.complete,
 		...coverage.incompleteReason === void 0 ? {} : { incompleteReason: coverage.incompleteReason }
-	};
+	});
 }
 async function* streamProviderExecutor(args) {
 	const started = Date.now();
@@ -13332,18 +13355,14 @@ function environmentAsSandboxInstance(environment, options) {
 					providerSessionId,
 					nativeSessionId: null,
 					profile: identity.profile
-				}).then(({ snapshot, provenance, coverageComplete, incompleteReason }) => ({
+				}).then((captured) => workspaceCaptureReceipt({
+					environment,
 					executionId: identity.executionId,
 					...controlRef === void 0 ? {} : { controlRef },
 					...identity.node === void 0 ? {} : { node: identity.node },
-					environmentId: environment.id,
-					profileDigest: canonicalAgentProfileDigest(identity.profile),
-					...capturedSessionIdentity(provenance, coverageComplete === true, identity.executionId, providerSessionId),
-					snapshot,
-					provenance,
-					coverageComplete: coverageComplete ?? false,
-					...incompleteReason === void 0 ? {} : { incompleteReason }
-				}));
+					profile: identity.profile,
+					providerSessionId
+				}, captured));
 				const receipt = await capture;
 				publication ??= Promise.resolve().then(async () => {
 					await options.onWorkspaceCaptured?.(receipt);
@@ -24890,6 +24909,7 @@ async function prepareScopeRetainedOwnerSeatSwitch(scope, mode) {
 	if (!state?.acceptedRef || !state.acceptedConsumed) throw new ValidationError$1("seat switch requires a committed owner turn");
 	const accepted = state.acceptedRef;
 	await scopeRetainedOwnerTurnEnded(scope);
+	await reconcileOwnerWorkspaceBeforeReuse(state, scope.signal);
 	await state.checkpointing;
 	await checkpointOwnerWorkspace(scope, state);
 	const owned = (await state.args.journal.loadTree(state.args.rootId) ?? []).filter((event) => event.id === state.args.nodeId);
@@ -25490,7 +25510,7 @@ async function releaseOwnerEnvironment(state, provider, capturesMs) {
 	const pendingSources = new Set(requestFailures.map(({ event }) => event.environmentId));
 	const released = new Set(events.flatMap((event) => event.kind === "environment-teardown" && event.id === args.nodeId && event.provider === provider.name && event.destroyed ? [event.environmentId] : []));
 	const environments = new Set(events.flatMap((event) => event.id === args.nodeId && event.kind === "execution-admitted" && event.admission.phase === "environment" ? [event.admission.environmentId] : []));
-	const retentionFailures = state.workspaceRetention || events.some((event) => event.kind === "execution-input" && event.id === args.nodeId && event.workspaceRetention === true) ? await ownerWorkspaceRetentionFailures(events, args.nodeId, args.blobs) : /* @__PURE__ */ new Set();
+	const retentionFailures = state.workspaceRetention || events.some((event) => event.kind === "execution-input" && event.id === args.nodeId && event.workspaceRetention === true) ? await ownerWorkspaceRetentionFailures(events, args) : /* @__PURE__ */ new Set();
 	const unconfirmed = [];
 	const preserved = [];
 	let lastDetail;
@@ -25641,23 +25661,17 @@ function unsettledOwnerRuns(events, nodeId, environmentId) {
 	close();
 	return [...runs.values()];
 }
-/**
-* Group owner admissions by input and require a verified workspace receipt before deletion.
-*
-* The receipt is the attempt's committed result, or an evidence record of the same attempt: a
-* turn its manager stopped commits its result first and journals its capture as evidence after
-* it, and a turn that failed journals the capture it took of the stopped session. This runs only
-* at a release no process will resume, so a complete, verified capture of the exact execution is
-* the whole of what keeping the source would preserve.
-*/
-async function ownerWorkspaceRetentionFailures(events, nodeId, blobs) {
+/** One grouping for release and the evidence gate before another owner invocation. */
+function ownerWorkspaceAttempts(events, nodeId) {
 	const attempts = [];
 	let current;
 	const flush = () => {
 		if (current !== void 0) attempts.push(current);
 		current = void 0;
 	};
-	const fresh = (executionId) => ({
+	const fresh = (executionId, workspaceRetention) => ({
+		workspaceRetention,
+		admissions: [],
 		...executionId === void 0 ? {} : { executionId },
 		environmentIds: /* @__PURE__ */ new Set(),
 		controlByEnvironment: /* @__PURE__ */ new Map(),
@@ -25667,18 +25681,37 @@ async function ownerWorkspaceRetentionFailures(events, nodeId, blobs) {
 		if (!("id" in event) || event.id !== nodeId) continue;
 		if (event.kind === "execution-input") {
 			flush();
-			current = fresh(`${nodeId}:input:${event.seq}`);
+			current = fresh(`${nodeId}:input:${event.seq}`, event.workspaceRetention);
 		} else if (event.kind === "execution-admitted" && event.admission.phase === "environment") {
 			if (current?.result !== void 0) flush();
 			current ??= fresh();
 			current.environmentIds.add(event.admission.environmentId);
-		} else if (event.kind === "execution-admitted" && event.admission.phase === "dispatched") current?.controlByEnvironment.set(event.admission.controlRef.environmentId, event.admission.controlRef);
-		else if (event.kind === "execution-result") {
+			current.admissions.push(event.admission);
+		} else if (event.kind === "execution-admitted" && event.admission.phase === "dispatched") {
+			current?.admissions.push(event.admission);
+			current?.controlByEnvironment.set(event.admission.controlRef.environmentId, event.admission.controlRef);
+		} else if (event.kind === "execution-admitted") current?.admissions.push(event.admission);
+		else if (event.kind === "execution-bound") {
+			if (current !== void 0 && current.result === void 0) current.binding = event.binding;
+		} else if (event.kind === "execution-result") {
 			current ??= fresh();
 			current.result = event;
 		} else if (event.kind === "execution-evidence") current?.evidence.push(event);
 	}
 	flush();
+	return attempts;
+}
+/**
+* Group owner admissions by input and require a verified workspace receipt before deletion.
+*
+* The receipt is the attempt's committed result, or an evidence record of the same attempt: a
+* turn its manager stopped commits its result first and journals its capture as evidence after
+* it, and a turn that failed journals the capture it took of the stopped session. A root capture
+* failure can enter this cleanup barrier and still be resumed, so any receipt refused before
+* reuse must also preserve its source here.
+*/
+async function ownerWorkspaceRetentionFailures(events, owner) {
+	const attempts = ownerWorkspaceAttempts(events, owner.nodeId);
 	const failures = /* @__PURE__ */ new Set();
 	for (const attempt of attempts) {
 		if (attempt.environmentIds.size === 0) continue;
@@ -25687,19 +25720,87 @@ async function ownerWorkspaceRetentionFailures(events, nodeId, blobs) {
 			continue;
 		}
 		const environmentId = [...attempt.environmentIds][0];
-		const controlRef = attempt.controlByEnvironment.get(environmentId);
-		const receipts = [...attempt.result === void 0 ? [] : [attempt.result.outRef], ...attempt.evidence.map((event) => event.outRef)];
-		let verified = false;
-		for (const outRef of receipts) {
-			const output = await storedOutput(blobs, outRef);
-			if (hasDurableWorkspaceCapture(output, output !== null && typeof output === "object" ? output.workspaceSnapshot : void 0, environmentId, attempt.executionId, controlRef)) {
-				verified = true;
-				break;
+		if (!await ownerAttemptHasCapture(attempt, environmentId, owner.blobs, attempt.workspaceRetention === true ? owner : void 0)) failures.add(environmentId);
+	}
+	return failures;
+}
+async function ownerAttemptHasCapture(attempt, environmentId, blobs, owner) {
+	const controlRef = attempt.controlByEnvironment.get(environmentId);
+	const receipts = [...attempt.result === void 0 ? [] : [attempt.result.outRef], ...attempt.evidence.map((event) => event.outRef)];
+	let verified = false;
+	for (const outRef of receipts) {
+		const output = await storedOutput(blobs, outRef);
+		if (hasDurableWorkspaceCapture(output, output !== null && typeof output === "object" ? output.workspaceSnapshot : void 0, environmentId, attempt.executionId, controlRef, owner === void 0 ? void 0 : ownerCaptureIdentity(attempt, owner))) {
+			verified = true;
+			break;
+		}
+	}
+	return verified;
+}
+function ownerCaptureIdentity(attempt, owner) {
+	const intent = attempt.admissions.find((admission) => admission.phase === "intent");
+	const node = attempt.binding === void 0 ? void 0 : {
+		rootId: owner.executionRootId ?? owner.rootId,
+		parentId: owner.nodeId,
+		nodeId: owner.nodeId,
+		...owner.depth === void 0 ? {} : { depth: owner.depth },
+		attemptId: attempt.binding.attemptId
+	};
+	return {
+		profileDigest: intent?.requestedProfileDigest,
+		node
+	};
+}
+/** Recover evidence only, before a later turn or checkpoint can change the accepted workspace. */
+async function reconcileOwnerWorkspaceBeforeReuse(state, signal) {
+	const { args } = state;
+	const events = await args.journal.loadTree(args.rootId) ?? [];
+	const attempts = ownerWorkspaceAttempts(events, args.nodeId);
+	const latest = attempts.at(-1);
+	const unusable = unusableEnvironmentIds(events.filter((event) => event.id === args.nodeId));
+	if (latest === void 0) return;
+	const reusing = new Set(latest.environmentIds);
+	if (latest.result === void 0 && state.priorSession !== void 0) reusing.add(state.priorSession.environmentId);
+	for (const [index, attempt] of attempts.entries()) {
+		if (attempt.workspaceRetention !== true || attempt.result === void 0) continue;
+		for (const environmentId of attempt.environmentIds) {
+			if (!reusing.has(environmentId) || unusable.has(environmentId)) continue;
+			if (await ownerAttemptHasCapture(attempt, environmentId, args.blobs, args)) continue;
+			try {
+				if (attempt.environmentIds.size !== 1 || attempt.executionId === void 0) throw new Error("accepted workspace has ambiguous admission identity");
+				if (index < attempts.length - 1) throw new Error("a later invocation already admitted this environment; historical workspace cannot be recaptured");
+				const capture = state.checkpointCapture;
+				const provider = state.provider;
+				const intent = attempt.admissions.find((admission) => admission.phase === "intent");
+				const admission = attempt.admissions.find((admission) => admission.phase === "environment");
+				const dispatched = attempt.admissions.find((admission) => admission.phase === "dispatched");
+				if (capture === void 0 || provider?.get === void 0 || intent?.phase !== "intent" || admission?.phase !== "environment" || dispatched?.phase !== "dispatched") throw new Error("accepted workspace recovery requires its retention port and exact admissions");
+				const controlRef = dispatched.controlRef;
+				if (provider.name !== intent.provider || admission.provider !== intent.provider || controlRef.provider !== intent.provider || admission.environmentId !== controlRef.environmentId || admission.sessionId !== controlRef.sessionId || admission.executionId !== controlRef.executionId || admission.idempotencyKey !== intent.idempotencyKey || dispatched.idempotencyKey !== intent.idempotencyKey || admission.sessionId !== intent.sessionId || admission.executionId !== intent.executionId || admission.turnId !== intent.turnId || dispatched.turnId !== intent.turnId || canonicalAgentProfileDigest(capture.profile) !== intent.requestedProfileDigest) throw new Error("accepted workspace recovery does not match its original profile or admission");
+				const environment = await runAbortable(() => provider.get(environmentId), AbortSignal.any([signal, AbortSignal.timeout(Math.min(3e4, capture.port.timeoutMs))]), "accepted workspace source lookup timed out");
+				if (environment === null || environment.id !== environmentId || environment.provider !== provider.name) throw new Error("accepted workspace source is unavailable");
+				const identity = ownerCaptureIdentity(attempt, args);
+				const context = {
+					environment,
+					executionId: attempt.executionId,
+					controlRef,
+					providerSessionId: controlRef.sessionId,
+					nativeSessionId: null,
+					profile: capture.profile,
+					...identity.node === void 0 ? {} : { node: identity.node }
+				};
+				const captured = await runAbortable(() => captureProviderWorkspaceSnapshot(capture.port, context), signal, "accepted workspace capture aborted");
+				const output = {
+					workspaceSnapshot: captured.snapshot,
+					workspaceCapture: workspaceCaptureReceipt(context, captured)
+				};
+				if (!hasDurableWorkspaceCapture(output, captured.snapshot, environmentId, attempt.executionId, controlRef, identity)) throw new Error(captured.incompleteReason ?? "accepted workspace capture is incomplete");
+				await state.context.onEvidence(output);
+			} catch (cause) {
+				throw new RetainedWorkspaceCapturePendingError(attempt.executionId ?? args.nodeId, cause);
 			}
 		}
-		if (!verified) failures.add(environmentId);
 	}
-	return failures;
 }
 /** A stored output whose bytes match its content reference, or undefined. */
 async function storedOutput(blobs, outRef) {
@@ -25711,13 +25812,14 @@ async function storedOutput(blobs, outRef) {
 	}
 }
 /** A stored result authorizes cleanup only for the exact source and complete capture. */
-function hasDurableWorkspaceCapture(output, snapshot, environmentId, executionId, controlRef) {
+function hasDurableWorkspaceCapture(output, snapshot, environmentId, executionId, controlRef, identity) {
 	const parsed = agentCandidateWorkspaceSnapshotEvidenceSchema.safeParse(snapshot);
 	if (!parsed.success || !("locator" in parsed.data.manifest) || !("locator" in parsed.data.archive)) return false;
 	if (output === null || typeof output !== "object") return false;
 	const capture = output.workspaceCapture;
 	if (capture === null || typeof capture !== "object") return false;
 	const receipt = capture;
+	if (identity !== void 0 && (identity.profileDigest === void 0 || receipt.profileDigest !== identity.profileDigest || (identity.node === void 0 ? receipt.node !== void 0 : receipt.node === void 0 || contentAddress(receipt.node) !== contentAddress(identity.node)))) return false;
 	const capturedControl = AgentExactRunControlRefSchema.safeParse(receipt.controlRef);
 	if (executionId === void 0 || controlRef === void 0 || !capturedControl.success || !sameControlCoordinates(capturedControl.data, controlRef) || receipt.environmentId !== environmentId || receipt.executionId !== executionId || receipt.coverageComplete !== true) return false;
 	const linked = agentCandidateWorkspaceSnapshotEvidenceSchema.safeParse(receipt.snapshot);
@@ -25838,6 +25940,7 @@ async function prepareScopeRetainedOwnerTask(scope, task) {
 		const accepted = [...attempt].reverse().find((event) => event.kind === "execution-result");
 		if (accepted?.kind === "execution-result") state.acceptedRef = accepted;
 	}
+	if (state.taskRef !== void 0 && state.acceptedRef === void 0) await reconcileOwnerWorkspaceBeforeReuse(state, scope.signal);
 	const unusable = unusableEnvironmentIds(owned);
 	const inFlight = continuedEnvironment(owned);
 	if (inFlight?.inFlight && unusable.has(inFlight.admission.environmentId)) {
@@ -25852,6 +25955,7 @@ async function prepareScopeRetainedOwnerTask(scope, task) {
 		state.admissions.length = 0;
 	}
 	if (state.prepared && state.acceptedRef && state.acceptedConsumed) {
+		await reconcileOwnerWorkspaceBeforeReuse(state, scope.signal);
 		const currentEnvironment = [...state.admissions].reverse().find((admission) => admission.phase === "environment");
 		if (currentEnvironment?.phase === "environment") state.priorSession = currentEnvironment;
 		delete state.inputSequence;
@@ -27539,7 +27643,9 @@ function createScope(args) {
 	});
 	registerScopeRetainedOwner(scope, {
 		rootId: args.root,
+		executionRootId: args.ownerMaterialization?.journalRoot ?? args.root,
 		nodeId: args.parentId,
+		depth: args.depth,
 		journal: args.journal,
 		blobs: args.blobs,
 		priorEvents: args.resumeFrom?.events ?? [],
@@ -29557,6 +29663,7 @@ async function runDriverWithRetry(run) {
 		try {
 			await run.drive(attempt, reentry);
 		} catch (error) {
+			if (error instanceof RetainedWorkspaceCapturePendingError) throw error;
 			const durationMs = now() - startedAt;
 			const classification = classifyDriverFailure(error, run.signal);
 			const after = run.progress();
@@ -30414,6 +30521,7 @@ function createSupervisor() {
 			const tree = runTree(scope);
 			const leakedReservations = pool.openReservations();
 			if (controller.signal.reason instanceof RunCancellationReason) return noWinner();
+			if (!actOutcome.ok && actOutcome.error instanceof RetainedWorkspaceCapturePendingError) throw actOutcome.error;
 			if (actOutcome.ok) {
 				if (executionAborted) return noWinner();
 				const out = actOutcome.out;
@@ -30903,4 +31011,4 @@ function isNonEmptySpend(s) {
 //#endregion
 export { environmentReader as $, runtimeOwnedScopeOwnerRuntime as $i, parseWorkerToolTraceArtifact as $n, loopEventToOtelSpan as $r, PEER_MAIL_WIRE_KEY as $t, scopeOwnerExecutorNodeContext as A, promptOnlyProfileMaterialization as Ai, resolveAgentEnvironmentProvider as An, resolveHarnessTranscriptCapture as Ar, captureReusableExecutorConfig as At, consumeScopeRetainedOwnerResult as B, authoredProfileDigest as Bi, InMemoryResultBlobStore as Bn, mergeTraceEnv as Br, createInPlaceCliExecutor as Bt, deriveNodeExecutionIdentity as C, promptFromAgentTurnInput as Ca, assertProfileMaterializes as Ci, readPromptOptions as Cn, abortError as Cr, createContinuationKeeper as Ct, recordScopeOwnerMaterialization as D, profileMaterializationAxes$1 as Di, createAgentEnvironmentProviderRegistry as Dn, harnessTranscriptArtifact as Dr, passedItems as Dt, recordScopeOwnerDriverAttempt as E, fullProfileMaterialization as Ei, LEAF_CONTINUATION_TASK as En, captureHarnessTranscript as Er, failedItems as Et, seatExecutionProfile as F, unsupportedProfileDimensions as Fi, retainedExecutorSeamKey as Fn, runCodeMode as Fr, snapshotExecutorConfig as Ft, scopeRetainedOwnerContext as G, newExecutionAttemptId as Gi, replaySpawnTree as Gn, resolveRedactor as Gr, workerTraceSeamKey as Gt, prepareScopeRetainedOwnerSeatSwitch as H, inheritRuntimeOwnedExecutorAttestation as Hi, insideCursorNamespace as Hn, traceContextToEnv as Hr, readWorkerTraceContext as Ht, abandonScopeRetainedOwnerInvocation as I, validateProfileMaterialization as Ii, unavailablePauseMs as In, priceTokens as Ir, createWorktreeCliExecutor as It, scopeRetainedOwnerResourceReader as J, runtimeOwnedDriveHarnessProviderEvidence as Ji, readCommittedJsonLines as Jn, buildRuntimeEventOtelSpans as Jr, createActivityLog as Jt, scopeRetainedOwnerJournalRoot as K, providerAttemptEvidence as Ki, isNoEntError as Kn, buildLoopOtelSpans as Kr, taskToPrompt as Kt, beginScopeRetainedOwnerDrive as L, worktreeCliProfileMaterialization as Li, unavailableSignalOfFailure as Ln, routerTokenPrice as Lr, DEFAULT_SANDBOX_STEERING_MAX_TURNS as Lt, SeatChain as M, renderProfileMaterializationIssues as Mi, decodeToolPart as Mn, contentAddress as Mr, cliWorktreeExecutor as Mt, SeatChainExhaustedError as N, renderUnsupported as Ni, sandboxSessionTraceSource as Nn, createCodeModeTools as Nr, createExecutor as Nt, recordScopeOwnerPause as O, promptControlProfileMaterialization as Oi, providerAsExecutor as On, persistHarnessTranscript as Or, verdictFromJudgeScore as Ot, authoredSeatStages as P, sandboxActProfileMaterialization as Pi, registerRetainedExecutorPreparation as Pn, describeCodeModeTools as Pr, createExecutorRegistry as Pt, SPAWN_RESOURCE_PATH_MAX_BYTES as Q, runtimeOwnedPendingExecutorMaterialization as Qi, isTraceAnalysisStore as Qn, generateSpanId as Qr, DEFAULT_PEER_MAIL_LIMITS as Qt, bindScopeRetainedOwnerEnvironmentId as R, attestRuntimeOwnedPendingExecutor as Ri, FileResultBlobStore as Rn, ROUTER_PRICE_SOURCE as Rr, createSteerableSandboxSession as Rt, createScope as S, awaitAbortable$1 as Sa, assertProfileMaterialization as Si, assertBoxlessPromptOptions as Sn, RunCancellationReason as Sr, checkVerdictOf as St, meterRuntimeOwnedProviderAttempt as T, providerMessageText as Ta, defineProfileMaterializationContract as Ti, runBrainLoop as Tn, runAbortable as Tr, expandQuestions as Tt, prepareScopeRetainedOwnerTask as U, knownExecutionBindingReceipt as Ui, loadSpawnForest as Un, defaultRedactor as Ur, workerTraceEnv as Ut, noteScopeRetainedOwnerCoordination as V, finalizeRuntimeOwnedPendingExecutor as Vi, InMemorySpawnJournal as Vn, readTraceContextFromEnv as Vr, WORKER_TRACE_PROPAGATION as Vt, reconcileScopeRetainedOwnerEnvironment as W, knownMaterializationReceipt as Wi, materializeTreeView as Wn, defaultRedactorIdentityMaterial as Wr, workerTraceHeaders as Wt, scopeRetainedOwnerResult as X, runtimeOwnedExecutorMaterialization as Xi, WORKER_TOOL_TRACE_SCHEMA_VERSION as Xn, createOtelExporter as Xr, createInbox as Xt, scopeRetainedOwnerRestorePoint as Y, runtimeOwnedExecutorExecutionBinding as Yi, writeAllBytes as Yn, createOpenInferenceFileExporter as Yr, readWorkerProgress as Yt, scopeRetainedOwnerTurnEnded as Z, runtimeOwnedExecutorProviderEvidence as Zi, captureWorkerTraceEvidence as Zn, flatOtelSpan as Zr, AUTHORITY_MARKERS as Zt, isDriverSpec as _, sandboxEventServedBackend as _a, localHarnessExecutable as _i, runAgentRounds as _n, retainedCreateMaterial as _r, CONTINUATION_FACTS as _t, collectDelivered as a, detachedSnapshot as aa, sanitizeAgentRuntimeEvent as ai, isLiveNodeStatus as an, createBudgetPool as ar, interactiveAdmissionSeamKey as at, assertRecursiveReservationPolicy as b, decodeHarnessUsage as ba, terminateProcessTreeAndConfirm as bi, SandboxEvidenceRetentionError as bn, createWorkerSlots as br, admitFinding as bt, runTree as c, assertSandboxServedModel as ca, runSettledCommand as ci, bridgeModelRouteRefusal as cn, spendFromUsageEvents as cr, reconnectRetainedInteractiveRun as ct, classifyDriverFailure as d, createSandboxUsageLedger as da, createWorktree as di, harnessUsageIsEmpty as dn, bridgeStopSignalKey as dr, freeSlots as dt, unknownExecutionBindingReceipt as ea, padSpanId as ei, claimsAuthority as en, workerTraceAnalysisStore as er, hostDirectoryReader as et, runDriverWithRetry as f, extractLlmCallEvent as fa, removeWorktree as fi, readCodexRolloutSession as fn, errMessage as fr, queueOf as ft, driverExecutorFactory as g, notifySandboxEventObserver as ga, harnessSupportsReasoningEffort as gi, isTerminalDecision as gn, startRetainedRunInEnvironment as gr, CONTINUATIONS_DIR as gt, driverChild as h, mapSandboxToolEvent as ha, harnessInvocation as hi, defaultSelectWinner as hn, startRetainedRun as hr, mapExecutorResult as ht, bestDelivered as i, detachedFrozen as ia, createRuntimeStreamEventCollector as ii, peerMailVerbNames as in, assertValidBudget as ir, providerVisibleProfile as it, settledToIteration as j, promptResourceProfileMaterialization as ji, createPushTraceSource as jn, retainHarnessTranscript as jr, cliInPlaceExecutor as jt, restoreScopeOwnerAcceptedExecution as k, promptModelProfileMaterialization as ki, providerAsSandboxClient as kn, readHarnessTranscript as kr, bindReusableExecutorExecutionId as kt, DriverAttemptsExhaustedError as l, canonicalStreamEventFromSandboxEvent as la, runWorktreeHarness as li, addHarnessUsage as ln, spendFromUsageTotals as lr, recoverRetainedInteractiveRun as lt, upstreamUnavailableSignal as m, mapSandboxEvent as ma, LOCAL_HARNESSES as mi, createSandboxForSpec as mn, recoverRetainedRun as mr, gateOnDeliverable as mt, createRootHandle as n, executableAgentProfileSnapshot as na, toOtelAttributes as ni, isPeerMailEnvelope as nn, BudgetReconcileFault as nr, coordinationMcpAlias as nt, pickBestDelivered as o, projectSandboxOutcome as oa, sanitizeKnowledgeReadinessReport as oi, isTerminalNodeStatus as on, meterUsageEvent as or, attachWorker as ot, summarizeDriverAttempts as p, isSandboxTerminalEvent as pa, DEFAULT_LOCAL_HARNESS as pi, TERMINAL_DECISIONS as pn, reconnectRetainedRun as pr, rollingDispatch as pt, scopeRetainedOwnerPriorSpend as q, recordRuntimeOwnedDriveHarnessProviderEvidence as qi, prepareJsonlAppend as qn, buildLoopSpanNodes as qr, DEFAULT_STALL_AFTER_MS as qt, createSupervisor as r, executableAgentSpecSnapshot as ra, createRuntimeEventCollector as ri, peerMailTools as rn, ReservationWaitRefused as rr, coordinationProfileToolPrefix as rt, runFinalizer as s, readSandboxOutcome as sa, sanitizeRuntimeStreamEvent as si, bridgeAdmissionRefusal as sn, newUsageTotals as sr, readWorkerInteractiveBinding as st, DEFAULT_MAX_DEPTH as t, unknownMaterializationReceipt as ta, padTraceId as ti, createPeerMailbox as tn, executorFailure as tr, resolveSpawnResourcePaths as tt, HarnessTurnFailedError as u, createSandboxToolPartState as ua, captureWorktreeDiff as ui, createCodexRolloutStoreReader as un, bridgeRuntimeAttachmentsKey as ur, startRetainedInteractiveRun as ut, withDriverExecutor as v, sandboxProgressEvents as va, parseCodexTokenUsage as vi, createSandboxLineage as vn, destroyInteractiveEnvironment as vr, CheckUnavailableError as vt, meterRuntimeOwnedAccounting as w, promptOptionsFromAgentTurnInput as wa, controlProfileMaterialization as wi, routerBrain as wn, linkAbort as wr, distillFindings as wt, beginScopeOwnerAttempt as x, abortError$1 as xa, AGENT_PROFILE_MATERIALIZATION_AXES as xi, captureBeforeDestroy as xn, openSlotGroup as xr, bestComposite as xt, SUBTREE_RESULT_LIMIT as y, sumSandboxUsage as ya, CodexExecutionDiagnosticError as yi, acquireSandbox as yn, environmentGone as yr, admitContinuationPolicy as yt, bindScopeRetainedOwnerProvider as z, attestRuntimeOwnedScopeOwner as zi, FileSpawnJournal as zn, createPropagatingTraceEmitter as zr, createRouterTranscript as zt };
 
-//# sourceMappingURL=supervisor-CRod4ISR.js.map
+//# sourceMappingURL=supervisor-CCtmmmOz.js.map