@tangle-network/agent-runtime 0.228.0 → 0.231.1

package/dist/{supervisor-DBnQuTyJ.js → supervisor-DFsXULnE.js}

@@ -5754,6 +5754,165 @@ function generateTraceId() {
 	return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
 }
 //#endregion
+//#region src/runtime/native-session-evidence.ts
+/**
+* Read a sandbox child's own harness transcript out of its environment before the
+* environment is destroyed, and persist it beside the tool-span `trace` receipt.
+*
+* Why this exists: Runtime destroys a child's environment at teardown and nothing read
+* those files first, so a child's Claude Code / Codex / OpenCode session never reached a
+* run record. The settled `trace` receipt covers the supervisor's own tool spans only —
+* `toolName`, `args`, `status`, `callId`, with `startedAt === endedAt` — so it carries no
+* assistant text, no reasoning, and no tool results, and `status: 'available'` never meant
+* the transcript survived. See tangle-network/agent-runtime#1214.
+*
+* The port already has what this needs: `AgentEnvironment.read?(path, { signal })`
+* returns a file's content as a string. Two constraints shape the design:
+*
+*   - `read` is OPTIONAL and, on the Tangle provider, gated behind
+*     `capabilities.workspace.read && box.read`. An environment without it is reported as
+*     `unsupported` rather than silently producing an empty artifact — the whole point of
+*     #1214 is that a receipt must not claim coverage it does not have.
+*   - `read` takes one path and gives no directory listing, so enumeration goes through
+*     `exec`. An environment with `read` but no `exec` cannot be enumerated and is also
+*     reported, not guessed at.
+*
+* Storage is NOT this module's business. The executor returns the artifact inside the result
+* it already settles with, and supervise puts that under the child's `outRef` in its own
+* `ResultBlobStore`. No destroy site learns about storage, and replay rehydrates it for free.
+*
+* Credentials are excluded by construction: enumeration lists only the transcript globs
+* for the harness, and any path matching DENY is dropped even if a producer moved a
+* credential file inside a session directory. The helper never reads `auth.json`,
+* `.credentials.json`, `credentials`, or a dotenv file.
+*/
+/** Where each harness keeps the session files that hold the conversation. */
+const HARNESS_ROOTS = Object.freeze({
+	"claude-code": Object.freeze([
+		".claude/projects",
+		".claude/history.jsonl",
+		".claude/todos"
+	]),
+	codex: Object.freeze([".codex/sessions", ".codex/history.jsonl"]),
+	opencode: Object.freeze([".local/share/opencode/storage", ".local/share/opencode/log"]),
+	pi: Object.freeze([".pi/agent/sessions"])
+});
+/**
+* Never read, whatever a producer put inside a session tree.
+*
+* Case-insensitive and broader than the obvious names: `.netrc`, `*.key`, `*.p12`/`*.pfx`
+* and an uppercase `ID_RSA` all slipped an earlier lowercase-only pattern.
+*/
+const DENY = /(^|\/)(auth\.json|\.credentials\.json|credentials|\.netrc|\.env(\..*)?|secrets?(\.|$)|.*\.(pem|key|p12|pfx)|id_[a-z0-9_]+)$/iu;
+/**
+* Bounds per file and in total. These are deliberately modest: the artifact rides inside the
+* settled result that supervise blobs under one `outRef`, so an unbounded transcript would
+* bloat every replay of that child, not just the capture.
+*/
+const MAX_FILE_BYTES = 2 * 1024 * 1024;
+const MAX_TOTAL_BYTES = 16 * 1024 * 1024;
+const MAX_FILES = 1e3;
+function unavailable$2(reason) {
+	return Object.freeze({
+		status: "unavailable",
+		reason
+	});
+}
+/**
+* Enumerate candidate transcript paths inside the environment.
+*
+* `find` is given the roots and prints one path per line. A missing root is not an error:
+* a child that never used a harness has no directory for it.
+*/
+async function enumerate(environment, roots, signal) {
+	if (!environment.exec) return void 0;
+	const command = `find ${roots.map((r) => `"$HOME/${r}"`).join(" ")} -type f -size -${Math.floor(MAX_FILE_BYTES / 1024)}k 2>/dev/null | head -${MAX_FILES}`;
+	try {
+		return ((await environment.exec(command, signal ? { signal } : void 0)).stdout ?? "").split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
+	} catch {
+		return;
+	}
+}
+/**
+* Read the harness transcript out of one LIVE environment.
+*
+* Call this before the environment is destroyed — on the settled path that means before the
+* result is built, since the `finally` that destroys runs after. It never throws: a teardown
+* must not fail because evidence could not be collected, and every failure mode is a named
+* `reason` the settled receipt carries instead of an empty artifact that reads as coverage.
+*/
+async function captureNativeSessionEvidence(environment, harness, signal) {
+	if (!environment?.read) return unavailable$2("unsupported-environment");
+	if (harness === void 0) return unavailable$2("unknown-harness");
+	const roots = HARNESS_ROOTS[harness];
+	if (!roots) return unavailable$2("unknown-harness");
+	const paths = await enumerate(environment, roots, signal);
+	if (paths === void 0) return unavailable$2("enumeration-failed");
+	if (paths.length === 0) return unavailable$2("no-transcript");
+	const files = [];
+	const skipped = [];
+	let total = 0;
+	for (const path of paths) {
+		if (signal?.aborted) {
+			skipped.push({
+				path,
+				reason: "aborted"
+			});
+			continue;
+		}
+		if (DENY.test(path)) {
+			skipped.push({
+				path,
+				reason: "denied-credential-shaped-path"
+			});
+			continue;
+		}
+		if (total >= MAX_TOTAL_BYTES) {
+			skipped.push({
+				path,
+				reason: "total-byte-budget-exhausted"
+			});
+			continue;
+		}
+		try {
+			const content = await environment.read(path, signal ? { signal } : void 0);
+			const bytes = Buffer.byteLength(content, "utf8");
+			if (bytes > MAX_FILE_BYTES) {
+				skipped.push({
+					path,
+					reason: "file-exceeds-byte-bound"
+				});
+				continue;
+			}
+			files.push(Object.freeze({
+				path,
+				bytes,
+				content
+			}));
+			total += bytes;
+		} catch {
+			skipped.push({
+				path,
+				reason: "read-failed"
+			});
+		}
+	}
+	if (files.length === 0) return unavailable$2("no-transcript");
+	const artifact = Object.freeze({
+		schemaVersion: 1,
+		harness,
+		files: Object.freeze(files),
+		skipped: Object.freeze(skipped)
+	});
+	return Object.freeze({
+		status: "available",
+		artifact,
+		fileCount: files.length,
+		totalBytes: total,
+		skippedCount: skipped.length
+	});
+}
+//#endregion
 //#region src/runtime/provider-placement.ts
 const placementMetadataKey = "runtimeProviderPlacement";
 /** Select exactly one declaration before any provider effects. Shared defaults carry infrastructure only. */
@@ -6459,7 +6618,14 @@ async function startRetainedRun(options) {
 	assertRequestedInteractionCapabilities(options.provider.name, options.turn.interactions, providerCapabilities);
 	options.environment.signal?.throwIfAborted();
 	options.turn.signal?.throwIfAborted();
-	const environment = await options.provider.create({
+	let environment;
+	if (options.existingEnvironmentId !== void 0) {
+		assertStableText(options.existingEnvironmentId, "retained environment id");
+		const existing = await options.provider.get(options.existingEnvironmentId);
+		if (!existing || existing.id !== options.existingEnvironmentId || existing.provider !== options.provider.name) throw new Error("retained provider environment is unavailable or has another identity");
+		await assertRetainedEnvironmentOwnership(options.provider, existing.id, options.environment.idempotencyKey);
+		environment = existing;
+	} else environment = await options.provider.create({
 		...options.environment,
 		metadata: retainedEnvironmentMetadata(options.environment.metadata, options.environment.idempotencyKey)
 	});
@@ -6468,6 +6634,7 @@ async function startRetainedRun(options) {
 		capabilities = retainedCapabilitiesForEnvironment(options.provider.name, providerCapabilities, environment);
 		assertRequestedInteractionCapabilities(options.provider.name, options.turn.interactions, capabilities);
 	} catch (error) {
+		if (options.existingEnvironmentId !== void 0) throw error;
 		try {
 			await environment.destroy?.();
 		} catch (cleanupError) {
@@ -6476,6 +6643,7 @@ async function startRetainedRun(options) {
 		throw error;
 	}
 	if (!environment.dispatch || !environment.session) {
+		if (options.existingEnvironmentId !== void 0) throw new Error(`provider "${options.provider.name}" does not expose detached session control`);
 		try {
 			await environment.destroy?.();
 		} catch (cleanupError) {
@@ -6493,7 +6661,8 @@ async function startRetainedRun(options) {
 		identity,
 		onAdmission: options.onAdmission,
 		capabilities,
-		now: options.now
+		now: options.now,
+		preserveEnvironment: options.existingEnvironmentId !== void 0
 	});
 }
 /**
@@ -6534,7 +6703,8 @@ async function startRetainedRunInEnvironment(options) {
 		identity,
 		onAdmission: options.onAdmission,
 		capabilities,
-		now: options.now
+		now: options.now,
+		preserveEnvironment: true
 	});
 }
 async function assertRetainedEnvironmentOwnership(provider, environmentId, idempotencyKey) {
@@ -6555,7 +6725,7 @@ async function dispatchRetainedRun(options) {
 		executionId: identity.executionId
 	});
 	const destroyIfCreated = async (cause) => {
-		if (environment.creation !== "created") throw cause;
+		if (options.preserveEnvironment || environment.creation !== "created") throw cause;
 		try {
 			await environment.destroy?.();
 		} catch (cleanupError) {
@@ -6692,6 +6862,7 @@ function retainedRunIntent(options, identity, contextTransfer) {
 		kind: "retained-run-intent.v1",
 		provider: options.provider.name,
 		idempotencyKey: options.environment.idempotencyKey,
+		...options.existingEnvironmentId === void 0 ? {} : { existingEnvironmentId: options.existingEnvironmentId },
 		turnId: options.turn.turnId,
 		sessionId: identity.sessionId,
 		executionId: identity.executionId,
@@ -7386,7 +7557,8 @@ function providerAsExecutor(provider, options = {}) {
 	};
 }
 function createProviderExecutor(provider, profile, ctx, options, placement) {
-	const controller = linkAbort(ctx.signal);
+	const controller = new AbortController();
+	const node = ctx.node === void 0 ? void 0 : detachedSnapshot(ctx.node, "provider executor node");
 	let environment;
 	let artifact;
 	let retained;
@@ -7396,8 +7568,8 @@ function createProviderExecutor(provider, profile, ctx, options, placement) {
 	const runtime = options.runtime ?? provider.name;
 	const createProfile = options.profileForCreate?.(profile) ?? profile;
 	if (placement && canonicalAgentProfileDigest(createProfile) !== canonicalAgentProfileDigest(profile)) throw new ValidationError("provider placement: profileForCreate cannot change the selected profile");
-	const executionId = retention?.executionId ?? ctx.node?.nodeId ?? `provider-run-${randomUUID()}`;
-	const attemptId = ctx.node?.attemptId ?? newExecutionAttemptId(executionId);
+	const executionId = retention?.executionId ?? node?.nodeId ?? `provider-run-${randomUUID()}`;
+	const attemptId = node?.attemptId ?? newExecutionAttemptId(executionId);
 	const trace = createPushTraceSource({ runId: executionId });
 	const providerModel = concreteProfileModel(createProfile);
 	const tokenLimits = enforceTokenLimits(profileModelExecutionSettings(createProfile, `providerAsExecutor(${provider.name})`).tokenLimits, "provider", `providerAsExecutor(${provider.name})`);
@@ -7419,7 +7591,7 @@ function createProviderExecutor(provider, profile, ctx, options, placement) {
 		plan: {
 			kind: "agent-environment",
 			provider: provider.name,
-			destroyOnSettle: options.destroyOnSettle ?? true,
+			destroyOnSettle: retention?.preserveEnvironment ? false : options.destroyOnSettle ?? true,
 			requireTerminalEvent: options.requireTerminalEvent ?? true,
 			tokenLimits,
 			...placement ? { placement } : {}
@@ -7444,42 +7616,47 @@ function createProviderExecutor(provider, profile, ctx, options, placement) {
 		}
 	};
 	let executor;
-	const run = (task, signal, recovering = false) => {
-		return streamProviderExecutor({
-			provider,
-			profile,
-			createProfile,
-			task,
-			signal,
-			controller,
-			options,
-			retention,
-			executionId,
-			trace,
-			recovering,
-			onRetained: (handle) => {
-				retained = handle;
-			},
-			onPending: (value) => {
-				pending = value;
-			},
-			onEnvironment: (env) => {
-				environment = env;
-				finalizeRuntimeOwnedPendingExecutor(executor, {
-					...plannedDeclaration,
-					execution: {
-						kind: "environment",
-						id: env.id
-					}
-				}, plannedBinding);
-			},
-			onArtifact: (next) => {
-				artifact = next;
-			},
-			onDestroyed: () => {
-				destroyed = true;
-			}
-		});
+	const run = async function* (task, signal, recovering = false) {
+		const linked = linkAbort(ctx.signal, signal, controller.signal);
+		try {
+			yield* streamProviderExecutor({
+				provider,
+				profile,
+				createProfile,
+				task,
+				signal: linked.signal,
+				...node === void 0 ? {} : { node },
+				options,
+				retention,
+				executionId,
+				trace,
+				recovering,
+				onRetained: (handle) => {
+					retained = handle;
+				},
+				onPending: (value) => {
+					pending = value;
+				},
+				onEnvironment: (env) => {
+					environment = env;
+					finalizeRuntimeOwnedPendingExecutor(executor, {
+						...plannedDeclaration,
+						execution: {
+							kind: "environment",
+							id: env.id
+						}
+					}, plannedBinding);
+				},
+				onArtifact: (next) => {
+					artifact = next;
+				},
+				onDestroyed: () => {
+					destroyed = true;
+				}
+			});
+		} finally {
+			linked.release();
+		}
 	};
 	executor = {
 		runtime,
@@ -7571,7 +7748,7 @@ function admittedEnvironmentId(retention) {
 }
 async function* streamProviderExecutor(args) {
 	const started = Date.now();
-	const linked = linkAbort(args.signal, args.controller.signal).signal;
+	const linked = args.signal;
 	const defaultTurn = taskToTurnInput(args.task, linked);
 	let turn = providerTurnWithDefaults(providerTurnDefaults(args.options.promptOptions, `providerAsExecutor(${args.provider.name})`), args.options.taskToTurn?.(args.task, args.profile, defaultTurn) ?? defaultTurn, linked);
 	if (args.options.defaults?.metadata?.runtimeProviderPlacement !== void 0) {
@@ -7655,8 +7832,10 @@ async function* streamProviderExecutor(args) {
 		}
 		if ((args.options.requireTerminalEvent ?? true) && !terminal) throw new ValidationError(`providerAsExecutor(${args.provider.name}): stream ended without a terminal result/done/status event`);
 		yield { kind: "iteration" };
+		const nativeSession = await captureNativeSessionEvidence(environment, args.profile.harness, linked);
 		const result = {
 			...resultFromEvents(archive.events(), text),
+			nativeSession,
 			...archive.superseded > 0 ? { supersededPartUpdates: archive.superseded } : {},
 			...explicitFailure ? { outcome: outcomeTracker.finish() } : {}
 		};
@@ -7671,6 +7850,7 @@ async function* streamProviderExecutor(args) {
 		};
 		const verdict = await args.options.validator?.validate(result, {
 			iteration: 0,
+			...args.node === void 0 ? {} : { node: args.node },
 			box: environmentAsSandboxInstance(environment, { requireTerminalEvent: args.options.requireTerminalEvent ?? true }),
 			signal: linked
 		});
@@ -7691,7 +7871,7 @@ async function* streamProviderExecutor(args) {
 		failure = source.retained ? new RetainedExecutionPendingError(error) : error;
 		failed = true;
 	} finally {
-		if ((!source.retained || settled !== void 0 && !failed) && (args.options.destroyOnSettle ?? true)) try {
+		if ((!source.retained || settled !== void 0 && !failed) && !(source.retained && args.retention?.preserveEnvironment) && (args.options.destroyOnSettle ?? true)) try {
 			await environment.destroy?.();
 			args.onDestroyed();
 		} catch (error) {
@@ -7782,16 +7962,26 @@ async function providerExecutionSource(args, turn, signal) {
 		admitted = true;
 		args.onPending(true);
 	};
+	const priorSession = retention.priorSession;
+	const environmentKey = priorSession?.idempotencyKey ?? `runtime:${args.executionId}`;
+	const turnId = `${args.executionId}:turn:0`;
 	const material = {
 		environment: {
 			...args.options.defaults,
 			profile: args.createProfile,
-			idempotencyKey: `runtime:${args.executionId}`,
+			idempotencyKey: environmentKey,
 			signal
 		},
 		turn: {
 			...turn,
-			turnId: `${args.executionId}:turn:0`
+			turnId
+		},
+		...priorSession === void 0 ? {} : {
+			existingEnvironmentId: priorSession.environmentId,
+			identity: {
+				sessionId: priorSession.sessionId,
+				executionId: mintRetainedIdentity(environmentKey, turnId).executionId
+			}
 		}
 	};
 	try {
@@ -7812,7 +8002,12 @@ async function providerExecutionSource(args, turn, signal) {
 			if (!reconnected) throw new Error("retained provider environment is unavailable");
 			handle = reconnected;
 		} else if (args.recovering && environmentAdmission?.phase === "environment") {
-			let recovered = await recoverRetainedRun({
+			let recovered = material.existingEnvironmentId !== void 0 && intent?.phase === "intent" ? await recoverRetainedRun({
+				provider: args.provider,
+				admission: intent,
+				replay: material,
+				onAdmission
+			}) : await recoverRetainedRun({
 				provider: args.provider,
 				environmentId: environmentAdmission.environmentId,
 				sessionId: environmentAdmission.sessionId,
@@ -7855,34 +8050,53 @@ async function providerExecutionSource(args, turn, signal) {
 		if (!environment) throw new Error("retained provider environment is unavailable");
 		const session = exactSession(environment, handle.controlRef).session;
 		async function* events() {
-			let iterator;
 			let observationFailure;
-			try {
-				iterator = session.events({
-					executionId: handle.controlRef.executionId,
-					signal
-				})[Symbol.asyncIterator]();
-			} catch (error) {
-				if (signal.aborted) throw error;
-				observationFailure = { error };
-			}
-			try {
-				while (iterator !== void 0) {
-					let next;
-					try {
-						next = await awaitAbortable$1(Promise.resolve().then(() => iterator.next()), signal);
-					} catch (error) {
-						if (signal.aborted) throw error;
-						observationFailure = { error };
-						break;
+			let lastReplayPosition;
+			let sawTerminal = false;
+			const drain = async function* (open) {
+				let iterator;
+				let failed = false;
+				try {
+					iterator = open()[Symbol.asyncIterator]();
+				} catch (error) {
+					if (signal.aborted) throw error;
+					observationFailure = { error };
+					return false;
+				}
+				try {
+					while (true) {
+						let next;
+						try {
+							next = await awaitAbortable$1(Promise.resolve().then(() => iterator.next()), signal);
+						} catch (error) {
+							if (signal.aborted) throw error;
+							observationFailure = { error };
+							failed = true;
+							break;
+						}
+						if (next.done) break;
+						assertEventBinding(next.value, handle.controlRef);
+						if (next.value.id !== void 0) lastReplayPosition = next.value.id;
+						if (isTerminalEnvironmentEvent(next.value)) sawTerminal = true;
+						yield next.value;
 					}
-					if (next.done) break;
-					assertEventBinding(next.value, handle.controlRef);
-					yield next.value;
+				} finally {
+					if (signal.aborted || failed) Promise.resolve().then(() => iterator?.return?.()).catch(() => void 0);
+					else await iterator?.return?.();
 				}
-			} finally {
-				if (signal.aborted || observationFailure !== void 0) Promise.resolve().then(() => iterator?.return?.()).catch(() => void 0);
-				else await iterator?.return?.();
+				return !failed;
+			};
+			if (!(yield* drain(() => session.events({
+				executionId: handle.controlRef.executionId,
+				signal
+			}))) && !sawTerminal && lastReplayPosition !== void 0) {
+				const firstFailure = observationFailure;
+				observationFailure = void 0;
+				if (!(yield* drain(() => session.events({
+					executionId: handle.controlRef.executionId,
+					since: lastReplayPosition,
+					signal
+				})))) observationFailure = firstFailure;
 			}
 			let result;
 			try {
@@ -19713,8 +19927,13 @@ function registerScopeRetainedOwner(scope, args) {
 	const taskEvent = [...events].reverse().find((event) => event.kind === "execution-input");
 	const start = taskEvent === void 0 ? 0 : events.indexOf(taskEvent);
 	const attempt = events.slice(start);
+	const beforeInput = taskEvent === void 0 ? [] : events.slice(0, start);
+	const priorInput = [...beforeInput].reverse().find((event) => event.kind === "execution-input");
+	const priorAttempt = priorInput === void 0 ? [] : beforeInput.slice(beforeInput.indexOf(priorInput));
 	const admissions = attempt.flatMap((event) => event.kind === "execution-admitted" ? [event.admission] : []);
 	const acceptedRef = [...attempt].reverse().find((event) => event.kind === "execution-result");
+	const priorResult = [...priorAttempt].reverse().find((event) => event.kind === "execution-result");
+	const priorSession = priorResult?.kind === "execution-result" ? priorAttempt.slice(0, priorAttempt.indexOf(priorResult)).reverse().flatMap((event) => event.kind === "execution-admitted" && event.admission.phase === "environment" ? [event.admission] : [])[0] : void 0;
 	let sequence = Math.max(0, ...events.map((event) => "seq" in event ? event.seq : 0));
 	const state = {
 		args,
@@ -19725,11 +19944,16 @@ function registerScopeRetainedOwner(scope, args) {
 			inputSequence: taskEvent.seq
 		} : {},
 		...acceptedRef?.kind === "execution-result" ? { acceptedRef } : {},
+		...priorSession ? { priorSession } : {},
 		context: {
 			get executionId() {
 				if (state.inputSequence === void 0) throw new ValidationError$1("retained owner input was not committed");
 				return `${args.nodeId}:input:${state.inputSequence}`;
 			},
+			get priorSession() {
+				return state.priorSession;
+			},
+			preserveEnvironment: true,
 			admissions,
 			onAdmission: async (admission) => {
 				scope.signal.throwIfAborted();
@@ -19777,6 +20001,56 @@ function registerScopeRetainedOwner(scope, args) {
 function scopeRetainedOwnerContext(scope) {
 	return owners.get(scope)?.context;
 }
+/** Bind cleanup before replay can return an already accepted owner result. */
+function bindScopeRetainedOwnerProvider(scope, provider) {
+	const state = owners.get(scope);
+	if (state) state.provider = provider;
+}
+/** The existing scope settlement barrier releases the owner's environment after all its turns. */
+async function releaseScopeRetainedOwnerEnvironment(scope) {
+	const state = owners.get(scope);
+	if (!state?.provider) return [];
+	const { provider, args } = state;
+	const events = await args.journal.loadTree(args.rootId) ?? [];
+	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] : []));
+	let unconfirmed = false;
+	for (const environmentId of environments) {
+		if (released.has(environmentId)) continue;
+		let destroyed = false;
+		let detail;
+		try {
+			await runAbortable(async () => {
+				if (!provider.get) throw new Error("provider cannot reconstruct the retained environment");
+				const environment = await provider.get(environmentId);
+				if (environment === null) return;
+				if (environment.id !== environmentId || environment.provider !== provider.name) throw new Error("provider returned another retained environment");
+				if (!environment.destroy) throw new Error("provider cannot destroy the retained environment");
+				await environment.destroy();
+			}, AbortSignal.timeout(3e4), "retained owner cleanup timed out");
+			destroyed = true;
+		} catch {
+			detail = "retained owner environment cleanup was not confirmed";
+			unconfirmed = true;
+		}
+		await args.journal.appendEvent(args.rootId, {
+			kind: "environment-teardown",
+			id: args.nodeId,
+			provider: provider.name,
+			environmentId,
+			destroyed,
+			...detail === void 0 ? {} : { detail },
+			seq: state.nextSequence(),
+			at: new Date(args.now()).toISOString()
+		});
+	}
+	return unconfirmed ? [{
+		id: args.nodeId,
+		label: "scope owner",
+		runtime: provider.name,
+		status: "done"
+	}] : [];
+}
 /** Resume the original backend prompt; rebuilt coordination observations cannot replace it. */
 async function prepareScopeRetainedOwnerTask(scope, task) {
 	const state = owners.get(scope);
@@ -19794,6 +20068,8 @@ async function prepareScopeRetainedOwnerTask(scope, task) {
 		if (accepted?.kind === "execution-result") state.acceptedRef = accepted;
 	}
 	if (state.prepared && state.acceptedRef && state.acceptedConsumed) {
+		const currentEnvironment = [...state.admissions].reverse().find((admission) => admission.phase === "environment");
+		if (currentEnvironment?.phase === "environment") state.priorSession = currentEnvironment;
 		delete state.inputSequence;
 		delete state.taskRef;
 		delete state.acceptedRef;
@@ -20085,6 +20361,8 @@ async function startScopeRecoveries(scope) {
 async function releaseRetainedEnvironments(scope) {
 	const release = retainedReleasers.get(scope);
 	if (release) await release();
+	const ownerUnconfirmed = await releaseScopeRetainedOwnerEnvironment(scope);
+	return [...scope.workerCapacity.unconfirmed, ...ownerUnconfirmed];
 }
 /**
 * @internal Close this scope to NEW children. Idempotent, synchronous, and irreversible.
@@ -20388,6 +20666,7 @@ function createScope(args) {
 					rootId: args.root,
 					parentId: args.parentId,
 					nodeId: id,
+					depth: args.depth + 1,
 					attemptId,
 					...identity ? { identity } : {}
 				},
@@ -21060,6 +21339,7 @@ function createScope(args) {
 			journal: args.journal,
 			root: args.ownerMaterialization.journalRoot ?? args.root,
 			nodeId: args.ownerMaterialization.nodeId ?? args.parentId,
+			depth: args.depth,
 			runtime: args.ownerMaterialization.runtime,
 			attemptId: args.ownerMaterialization.attemptId,
 			...authoredProfile === void 0 ? {} : { authoredProfile },
@@ -21245,6 +21525,7 @@ function scopeOwnerExecutorNodeContext(scope) {
 		rootId: state.root,
 		parentId: state.nodeId,
 		nodeId: state.nodeId,
+		depth: state.depth,
 		attemptId: state.attemptId
 	});
 }
@@ -22373,8 +22654,7 @@ const driverExecutorFactory = (rawSpec, ctx) => {
 		},
 		async releaseRetained() {
 			if (nestedScopeHeld === void 0) return [];
-			await releaseRetainedEnvironments(nestedScopeHeld);
-			unconfirmedDescendants = nestedScopeHeld.workerCapacity.unconfirmed.map((node) => node.id);
+			unconfirmedDescendants = (await releaseRetainedEnvironments(nestedScopeHeld)).map((node) => node.id);
 			return [];
 		},
 		resultArtifact() {
@@ -22914,29 +23194,49 @@ const collectDelivered = (ctx) => {
 * Run a finalizer over a settled-worker ledger under the delivered-only invariant: filter the
 * ledger to structurally delivered children, materialize their outputs, and hand the finalizer a
 * blob reader that throws on any ref outside that set. This is the one call site both driver arms
-* (the in-process tool-loop and the MCP-mounted harness) finalize through.
+* (the in-process tool-loop and the MCP-mounted harness) finalize through. When a parent declares
+* a deliverable, its candidate must also pass that check: children may have narrower assignments.
+* The default selects the highest-scoring child that passes the parent's check; custom finalizers
+* assemble their candidate before the check. A rejection leaves the parent incomplete; a thrown
+* oracle surfaces a validation error. Neither changes child validity.
 */
 async function runFinalizer(finalizer, args) {
 	const deliveredRows = args.settled.filter((w) => w.status === "done" && w.valid === true);
 	const deliveredRefs = /* @__PURE__ */ new Set();
 	for (const w of deliveredRows) if (w.outRef !== void 0) deliveredRefs.add(w.outRef);
-	return finalizer({
-		delivered: await Promise.all(deliveredRows.map(async (w) => ({
-			id: w.id,
-			...w.score !== void 0 ? { score: w.score } : {},
-			...w.outRef !== void 0 ? {
-				outRef: w.outRef,
-				out: await args.blobs.get(w.outRef)
-			} : {}
-		}))),
+	const delivered = await Promise.all(deliveredRows.map(async (w) => ({
+		id: w.id,
+		...w.score !== void 0 ? { score: w.score } : {},
+		...w.outRef !== void 0 ? {
+			outRef: w.outRef,
+			out: await args.blobs.get(w.outRef)
+		} : {}
+	})));
+	const guardedBlobs = { get: (outRef) => {
+		if (!deliveredRefs.has(outRef)) throw new ValidationError$1(`finalizer: outRef '${outRef}' is not a DELIVERED child's result — a finalizer may only operate on outputs that settled done and passed their completion oracle`);
+		return args.blobs.get(outRef);
+	} };
+	const accepted = async (candidate) => {
+		if (candidate === void 0) return false;
+		if (args.deliverable === void 0) return true;
+		try {
+			return await args.deliverable.check(candidate) === true;
+		} catch (error) {
+			throw new ValidationError$1(`finalizer: parent completion check threw: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	};
+	if (finalizer === bestDelivered && args.deliverable !== void 0) {
+		for (const output of [...delivered].sort((a, b) => (b.score ?? 0) - (a.score ?? 0))) if (await accepted(output.out)) return output.out;
+		return;
+	}
+	const candidate = await finalizer({
+		delivered,
 		allSettled: args.settled,
 		tree: args.tree,
-		blobs: { get: (outRef) => {
-			if (!deliveredRefs.has(outRef)) throw new ValidationError$1(`finalizer: outRef '${outRef}' is not a DELIVERED child's result — a finalizer may only operate on outputs that settled done and passed their completion oracle`);
-			return args.blobs.get(outRef);
-		} },
+		blobs: guardedBlobs,
 		budget: args.budget
 	});
+	return await accepted(candidate) ? candidate : void 0;
 }
 //#endregion
 //#region src/runtime/supervise/supervisor.ts
@@ -23294,10 +23594,7 @@ function createSupervisor() {
 				const settleGraceMs = !controller.signal.aborted ? boundedSettleGrace(opts.childSettleGraceMs, rootDeadlineAtMs, now) : 0;
 				try {
 					teardownUnconfirmed = await drainLiveChildren(openScope, controller, settleGraceMs);
-					if (retainedAtSettlement === "release") {
-						await releaseRetainedEnvironments(openScope);
-						teardownUnconfirmed = openScope.workerCapacity.unconfirmed;
-					}
+					if (retainedAtSettlement === "release") teardownUnconfirmed = await releaseRetainedEnvironments(openScope);
 					for (const node of teardownUnconfirmed) await opts.journal.appendEvent(opts.runId, {
 						kind: "teardown-unconfirmed",
 						id: node.id,
@@ -23689,6 +23986,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 { cliInPlaceExecutor as $, generateSpanId as $n, runtimeOwnedExecutorProviderEvidence as $r, createCodexRolloutStoreReader as $t, waitUntil as A, sleep as Ai, abortError as An, renderProfileMaterializationIssues as Ar, WORKER_TRACE_PROPAGATION as At, readWorkerInteractiveBinding as B, decodeHarnessUsage as Bi, resolveRedactor as Bn, attestRuntimeOwnedPendingExecutor as Br, AUTHORITY_MARKERS as Bt, scopeOwnerExecutorNodeContext as C, chargedTokens as Ci, sandboxClientAsProvider as Cn, defineProfileMaterializationContract as Cr, BudgetReconcileFault as Ct, pollFor as D, isAbortError$2 as Di, registerRetainedExecutorPreparation as Dn, promptModelProfileMaterialization as Dr, newUsageTotals as Dt, isWaitOutcome as E, hasCompleteCacheBreakdown as Ei, sandboxSessionTraceSource as En, promptControlProfileMaterialization as Er, meterUsageEvent as Et, scopeRetainedOwnerResult as F, withTimeout as Fi, startRetainedRun as Fn, worktreeCliProfileMaterialization as Fr, taskToPrompt as Ft, startRetainedInteractiveRun as G, teardownExecutor as Gi, INTELLIGENCE_WIRE_VERSION as Gn, knownExecutionBindingReceipt as Gr, isPeerMailEnvelope as Gt, workerInteractiveBindingsDir as H, awaitAbortable$1 as Hi, mergeTraceEnv as Hn, authoredProfileDigest as Hr, PEER_MAIL_WIRE_KEY as Ht, interactiveAdmissionSeamKey as I, zeroSpend as Ii, startRetainedRunInEnvironment as In, isNoEntError as Ir, DEFAULT_STALL_AFTER_MS as It, freeSlots as J, providerMessageText as Ji, buildRuntimeEventOtelSpans as Jn, providerAttemptEvidence as Jr, isLiveNodeStatus as Jt, destroyInteractiveEnvironment as K, promptFromAgentTurnInput as Ki, buildLoopOtelSpans as Kn, knownMaterializationReceipt as Kr, peerMailTools as Kt, readWorkerInteractiveAdmissions as L, addResourceSpend as Li, retainedCreateMaterial as Ln, parseCommittedJsonLines as Lr, createActivityLog as Lt, prepareScopeRetainedOwnerTask as M, throwAbort as Mi, runAbortable as Mn, sandboxActProfileMaterialization as Mr, workerTraceEnv as Mt, scopeRetainedOwnerContext as N, throwIfAborted as Ni, reconnectRetainedRun as Nn, unsupportedProfileDimensions as Nr, workerTraceHeaders as Nt, timerAt as O, promptCacheTokenClasses as Oi, retainedExecutorSeamKey as On, promptOnlyProfileMaterialization as Or, spendFromUsageEvents as Ot, scopeRetainedOwnerPriorSpend as P, unmeteredSpend as Pi, recoverRetainedRun as Pn, validateProfileMaterialization as Pr, workerTraceSeamKey as Pt, captureReusableExecutorConfig as Q, flatOtelSpan as Qn, runtimeOwnedExecutorMaterialization as Qr, addHarnessUsage as Qt, workerInteractiveAdmissionFile as R, resourceTelemetry as Ri, defaultRedactor as Rn, prepareJsonlAppend as Rr, readWorkerProgress as Rt, restoreScopeOwnerAcceptedExecution as S, addSpend as Si, resolveAgentEnvironmentProvider as Sn, controlProfileMaterialization as Sr, contentAddress as St, createWaitProbes as T, deleteBoxSafe as Ti, decodeToolPart as Tn, profileMaterializationAxes$1 as Tr, createBudgetPool as Tt, reconnectRetainedInteractiveRun as U, DEFAULT_SUCCESSFUL_SHUTDOWN_MS as Ui, readTraceContextFromEnv as Un, finalizeRuntimeOwnedPendingExecutor as Ur, claimsAuthority as Ut, workerInteractiveBindingFile as V, abortError$2 as Vi, createPropagatingTraceEmitter as Vn, attestRuntimeOwnedScopeOwner as Vr, DEFAULT_PEER_MAIL_LIMITS as Vt, recoverRetainedInteractiveRun as W, armDeadlineTimer as Wi, traceContextToEnv as Wn, inheritRuntimeOwnedExecutorAttestation as Wr, createPeerMailbox as Wt, rollingDispatch as X, createOtelExporter as Xn, runtimeOwnedDriveHarnessProviderEvidence as Xr, bridgeAdmissionRefusal as Xt, queueOf as Y, createOpenInferenceFileExporter as Yn, recordRuntimeOwnedDriveHarnessProviderEvidence as Yr, isTerminalNodeStatus as Yt, bindReusableExecutorExecutionId as Z, exportEvalRuns as Zn, runtimeOwnedExecutorExecutionBinding as Zr, bridgeModelRouteRefusal as Zt, createScope as _, mapSandboxToolEvent as _i, observedModelMatchesDeclared as _n, localHarnessExecutable as _r, WORKER_TOOL_TRACE_SCHEMA_VERSION as _t, pickBestDelivered as a, executableAgentSpecSnapshot as ai, createSandboxForSpec as an, createRuntimeStreamEventCollector as ar, DEFAULT_SANDBOX_STEERING_MAX_TURNS as at, meterRuntimeOwnedProviderAttempt as b, sandboxProgressEvents as bi, providerAsExecutor as bn, AGENT_PROFILE_MATERIALIZATION_AXES as br, parseWorkerToolTraceArtifact as bt, DriverAttemptsExhaustedError as c, projectSandboxOutcome as ci, runAgentRounds as cn, sanitizeRuntimeStreamEvent as cr, FileResultBlobStore as ct, runDriverWithRetry as d, canonicalStreamEventFromSandboxEvent as di, acquireSandbox as dn, captureWorktreeDiff as dr, InMemorySpawnJournal as dt, runtimeOwnedPendingExecutorMaterialization as ei, harnessUsageIsEmpty as en, loopEventToOtelSpan as er, cliWorktreeExecutor as et, driverChild as f, createSandboxToolPartState as fi, assertBoxlessPromptOptions as fn, createWorktree as fr, insideCursorNamespace as ft, beginScopeOwnerAttempt as g, mapSandboxEvent as gi, canonicalObservedModelParts as gn, harnessSupportsReasoningEffort as gr, replaySpawnTree as gt, withDriverExecutor as h, isSandboxTerminalEvent as hi, runBrainLoop as hn, LOCAL_HARNESSES as hr, pendingWaits as ht, collectDelivered as i, executableAgentProfileSnapshot as ii, TERMINAL_DECISIONS as in, createRuntimeEventCollector as ir, createWorktreeCliExecutor as it, consumeScopeRetainedOwnerResult as j, stringifySafe as ji, linkAbort as jn, renderUnsupported as jr, readWorkerTraceContext as jt, validateWaitSpec as k, randomSuffix as ki, RunCancellationReason as kn, promptResourceProfileMaterialization as kr, spendFromUsageTotals as kt, classifyDriverFailure as l, readSandboxOutcome as li, createSandboxLineage as ln, runSettledCommand as lr, FileSpawnJournal as lt, isDriverSpec as m, extractLlmCallEvent as mi, routerBrain as mn, DEFAULT_LOCAL_HARNESS as mr, materializeTreeView as mt, createSupervisor as n, unknownExecutionBindingReceipt as ni, bridgeRuntimeAttachmentsKey as nn, padTraceId as nr, createExecutorRegistry as nt, runFinalizer as o, detachedFrozen as oi, defaultSelectWinner as on, sanitizeAgentRuntimeEvent as or, createSteerableSandboxSession as ot, driverExecutorFactory as p, createSandboxUsageLedger as pi, readPromptOptions as pn, removeWorktree as pr, loadSpawnForest as pt, effectiveConcurrency as q, promptOptionsFromAgentTurnInput as qi, buildLoopSpanNodes as qn, newExecutionAttemptId as qr, peerMailVerbNames as qt, bestDelivered as r, unknownMaterializationReceipt as ri, bridgeStopSignalKey as rn, toOtelAttributes as rr, snapshotExecutorConfig as rt, runTree as s, detachedSnapshot as si, isTerminalDecision as sn, sanitizeKnowledgeReadinessReport as sr, createInPlaceCliExecutor as st, createRootHandle as t, runtimeOwnedScopeOwnerRuntime as ti, readCodexRolloutSession as tn, padSpanId as tr, createExecutor as tt, defaultUnmetContractSteer as u, assertSandboxServedModel as ui, probeSandboxCapabilities as un, runWorktreeHarness as ur, InMemoryResultBlobStore as ut, deriveNodeExecutionIdentity as v, notifySandboxEventObserver as vi, DEFAULT_SANDBOX_IDLE_TIMEOUT_SECONDS as vn, parseCodexTokenUsage as vr, captureWorkerTraceEvidence as vt, settledToIteration as w, cloneSpend as wi, createPushTraceSource as wn, fullProfileMaterialization as wr, assertValidBudget as wt, recordScopeOwnerMaterialization as x, sumSandboxUsage as xi, providerAsSandboxClient as xn, assertProfileMaterialization as xr, workerTraceAnalysisStore as xt, meterRuntimeOwnedAccounting as y, sandboxEventServedBackend as yi, createAgentEnvironmentProviderRegistry as yn, CodexExecutionDiagnosticError as yr, isTraceAnalysisStore as yt, attachWorker as z, withBudgetResources as zi, defaultRedactorIdentityMaterial as zn, writeAllBytes as zr, createInbox as zt };
+export { captureReusableExecutorConfig as $, flatOtelSpan as $n, runtimeOwnedExecutorMaterialization as $r, addHarnessUsage as $t, waitUntil as A, randomSuffix as Ai, RunCancellationReason as An, promptResourceProfileMaterialization as Ar, spendFromUsageTotals as At, attachWorker as B, withBudgetResources as Bi, defaultRedactorIdentityMaterial as Bn, writeAllBytes as Br, createInbox as Bt, scopeOwnerExecutorNodeContext as C, addSpend as Ci, resolveAgentEnvironmentProvider as Cn, controlProfileMaterialization as Cr, contentAddress as Ct, pollFor as D, hasCompleteCacheBreakdown as Di, sandboxSessionTraceSource as Dn, promptControlProfileMaterialization as Dr, meterUsageEvent as Dt, isWaitOutcome as E, deleteBoxSafe as Ei, decodeToolPart as En, profileMaterializationAxes$1 as Er, createBudgetPool as Et, scopeRetainedOwnerPriorSpend as F, unmeteredSpend as Fi, recoverRetainedRun as Fn, validateProfileMaterialization as Fr, workerTraceSeamKey as Ft, recoverRetainedInteractiveRun as G, armDeadlineTimer as Gi, traceContextToEnv as Gn, inheritRuntimeOwnedExecutorAttestation as Gr, createPeerMailbox as Gt, workerInteractiveBindingFile as H, abortError$2 as Hi, createPropagatingTraceEmitter as Hn, attestRuntimeOwnedScopeOwner as Hr, DEFAULT_PEER_MAIL_LIMITS as Ht, scopeRetainedOwnerResult as I, withTimeout as Ii, startRetainedRun as In, worktreeCliProfileMaterialization as Ir, taskToPrompt as It, effectiveConcurrency as J, promptOptionsFromAgentTurnInput as Ji, buildLoopSpanNodes as Jn, newExecutionAttemptId as Jr, peerMailVerbNames as Jt, startRetainedInteractiveRun as K, teardownExecutor as Ki, INTELLIGENCE_WIRE_VERSION as Kn, knownExecutionBindingReceipt as Kr, isPeerMailEnvelope as Kt, interactiveAdmissionSeamKey as L, zeroSpend as Li, startRetainedRunInEnvironment as Ln, isNoEntError as Lr, DEFAULT_STALL_AFTER_MS as Lt, consumeScopeRetainedOwnerResult as M, stringifySafe as Mi, linkAbort as Mn, renderUnsupported as Mr, readWorkerTraceContext as Mt, prepareScopeRetainedOwnerTask as N, throwAbort as Ni, runAbortable as Nn, sandboxActProfileMaterialization as Nr, workerTraceEnv as Nt, timerAt as O, isAbortError$2 as Oi, registerRetainedExecutorPreparation as On, promptModelProfileMaterialization as Or, newUsageTotals as Ot, scopeRetainedOwnerContext as P, throwIfAborted as Pi, reconnectRetainedRun as Pn, unsupportedProfileDimensions as Pr, workerTraceHeaders as Pt, bindReusableExecutorExecutionId as Q, exportEvalRuns as Qn, runtimeOwnedExecutorExecutionBinding as Qr, bridgeModelRouteRefusal as Qt, readWorkerInteractiveAdmissions as R, addResourceSpend as Ri, retainedCreateMaterial as Rn, parseCommittedJsonLines as Rr, createActivityLog as Rt, restoreScopeOwnerAcceptedExecution as S, sumSandboxUsage as Si, providerAsSandboxClient as Sn, assertProfileMaterialization as Sr, workerTraceAnalysisStore as St, createWaitProbes as T, cloneSpend as Ti, createPushTraceSource as Tn, fullProfileMaterialization as Tr, assertValidBudget as Tt, workerInteractiveBindingsDir as U, awaitAbortable$1 as Ui, mergeTraceEnv as Un, authoredProfileDigest as Ur, PEER_MAIL_WIRE_KEY as Ut, readWorkerInteractiveBinding as V, decodeHarnessUsage as Vi, resolveRedactor as Vn, attestRuntimeOwnedPendingExecutor as Vr, AUTHORITY_MARKERS as Vt, reconnectRetainedInteractiveRun as W, DEFAULT_SUCCESSFUL_SHUTDOWN_MS as Wi, readTraceContextFromEnv as Wn, finalizeRuntimeOwnedPendingExecutor as Wr, claimsAuthority as Wt, queueOf as X, createOpenInferenceFileExporter as Xn, recordRuntimeOwnedDriveHarnessProviderEvidence as Xr, isTerminalNodeStatus as Xt, freeSlots as Y, providerMessageText as Yi, buildRuntimeEventOtelSpans as Yn, providerAttemptEvidence as Yr, isLiveNodeStatus as Yt, rollingDispatch as Z, createOtelExporter as Zn, runtimeOwnedDriveHarnessProviderEvidence as Zr, bridgeAdmissionRefusal as Zt, createScope as _, mapSandboxEvent as _i, canonicalObservedModelParts as _n, harnessSupportsReasoningEffort as _r, replaySpawnTree as _t, pickBestDelivered as a, executableAgentProfileSnapshot as ai, TERMINAL_DECISIONS as an, createRuntimeEventCollector as ar, createWorktreeCliExecutor as at, meterRuntimeOwnedProviderAttempt as b, sandboxEventServedBackend as bi, createAgentEnvironmentProviderRegistry as bn, CodexExecutionDiagnosticError as br, isTraceAnalysisStore as bt, DriverAttemptsExhaustedError as c, detachedSnapshot as ci, isTerminalDecision as cn, sanitizeKnowledgeReadinessReport as cr, createInPlaceCliExecutor as ct, runDriverWithRetry as d, assertSandboxServedModel as di, probeSandboxCapabilities as dn, runWorktreeHarness as dr, InMemoryResultBlobStore as dt, runtimeOwnedExecutorProviderEvidence as ei, createCodexRolloutStoreReader as en, generateSpanId as er, cliInPlaceExecutor as et, driverChild as f, canonicalStreamEventFromSandboxEvent as fi, acquireSandbox as fn, captureWorktreeDiff as fr, InMemorySpawnJournal as ft, beginScopeOwnerAttempt as g, isSandboxTerminalEvent as gi, runBrainLoop as gn, LOCAL_HARNESSES as gr, pendingWaits as gt, withDriverExecutor as h, extractLlmCallEvent as hi, routerBrain as hn, DEFAULT_LOCAL_HARNESS as hr, materializeTreeView as ht, collectDelivered as i, unknownMaterializationReceipt as ii, bridgeStopSignalKey as in, toOtelAttributes as ir, snapshotExecutorConfig as it, bindScopeRetainedOwnerProvider as j, sleep as ji, abortError as jn, renderProfileMaterializationIssues as jr, WORKER_TRACE_PROPAGATION as jt, validateWaitSpec as k, promptCacheTokenClasses as ki, retainedExecutorSeamKey as kn, promptOnlyProfileMaterialization as kr, spendFromUsageEvents as kt, classifyDriverFailure as l, projectSandboxOutcome as li, runAgentRounds as ln, sanitizeRuntimeStreamEvent as lr, FileResultBlobStore as lt, isDriverSpec as m, createSandboxUsageLedger as mi, readPromptOptions as mn, removeWorktree as mr, loadSpawnForest as mt, createSupervisor as n, runtimeOwnedScopeOwnerRuntime as ni, readCodexRolloutSession as nn, padSpanId as nr, createExecutor as nt, runFinalizer as o, executableAgentSpecSnapshot as oi, createSandboxForSpec as on, createRuntimeStreamEventCollector as or, DEFAULT_SANDBOX_STEERING_MAX_TURNS as ot, driverExecutorFactory as p, createSandboxToolPartState as pi, assertBoxlessPromptOptions as pn, createWorktree as pr, insideCursorNamespace as pt, destroyInteractiveEnvironment as q, promptFromAgentTurnInput as qi, buildLoopOtelSpans as qn, knownMaterializationReceipt as qr, peerMailTools as qt, bestDelivered as r, unknownExecutionBindingReceipt as ri, bridgeRuntimeAttachmentsKey as rn, padTraceId as rr, createExecutorRegistry as rt, runTree as s, detachedFrozen as si, defaultSelectWinner as sn, sanitizeAgentRuntimeEvent as sr, createSteerableSandboxSession as st, createRootHandle as t, runtimeOwnedPendingExecutorMaterialization as ti, harnessUsageIsEmpty as tn, loopEventToOtelSpan as tr, cliWorktreeExecutor as tt, defaultUnmetContractSteer as u, readSandboxOutcome as ui, createSandboxLineage as un, runSettledCommand as ur, FileSpawnJournal as ut, deriveNodeExecutionIdentity as v, mapSandboxToolEvent as vi, observedModelMatchesDeclared as vn, localHarnessExecutable as vr, WORKER_TOOL_TRACE_SCHEMA_VERSION as vt, settledToIteration as w, chargedTokens as wi, sandboxClientAsProvider as wn, defineProfileMaterializationContract as wr, BudgetReconcileFault as wt, recordScopeOwnerMaterialization as x, sandboxProgressEvents as xi, providerAsExecutor as xn, AGENT_PROFILE_MATERIALIZATION_AXES as xr, parseWorkerToolTraceArtifact as xt, meterRuntimeOwnedAccounting as y, notifySandboxEventObserver as yi, DEFAULT_SANDBOX_IDLE_TIMEOUT_SECONDS as yn, parseCodexTokenUsage as yr, captureWorkerTraceEvidence as yt, workerInteractiveAdmissionFile as z, resourceTelemetry as zi, defaultRedactor as zn, prepareJsonlAppend as zr, readWorkerProgress as zt };
 
-//# sourceMappingURL=supervisor-DBnQuTyJ.js.map
+//# sourceMappingURL=supervisor-DFsXULnE.js.map