@tangle-network/agent-runtime 0.229.0 → 0.232.0

package/dist/{supervisor-DAHG98Rs.js → supervisor-BVAM5glY.js}

@@ -5754,7 +5754,18 @@ function generateTraceId() {
 	return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
 }
 //#endregion
-//#region src/runtime/native-session-evidence.ts
+//#region src/durable/content-address.ts
+/** Stable content address shared by result and trace artifacts. */
+function contentAddress(artifact) {
+	return `sha256:${createHash("sha256").update(stableStringify(artifact), "utf-8").digest("hex")}`;
+}
+function stableStringify(value) {
+	if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "null";
+	if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+	return `{${Object.entries(value).filter(([, v]) => v !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k, v]) => `${JSON.stringify(k)}:${stableStringify(v)}`).join(",")}}`;
+}
+//#endregion
+//#region src/runtime/harness-transcript.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.
@@ -5777,9 +5788,11 @@ function generateTraceId() {
 *     `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.
+* Storage is NOT the executor's business. The executor holds the in-memory capture and hands it
+* to the scope through `Executor.harnessTranscript()`; the scope persists it under its own
+* content ref with `persistHarnessTranscript` and settles the receipt. No provider or destroy
+* site learns about storage, the result blob never carries the files, and replay rehydrates a
+* pointer — the bytes are read only by `harnessTranscriptArtifact`, when someone opens them.
 *
 * 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
@@ -5805,9 +5818,15 @@ const HARNESS_ROOTS = Object.freeze({
 */
 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.
+* Bounds per file and in total, PER CHILD. They multiply by fleet width, and the next person
+* sizing a fleet must find that here: a 132-child pursuit (mech-interp-foundations-astra-20260911f,
+* the widest retained on one operator host) at the ceiling is 132 x 16 MiB = 2.1 GiB of transcript
+* for one run (#1248).
+*
+* That figure is a DISK number, not a replay number. The artifact is persisted under its own
+* content ref in the `ResultBlobStore` and the settlement carries only the receipt, so replay and
+* resume rehydrate a ref, never the files; nothing pays for a transcript until someone opens it.
+* The bound is enforced exactly, after each read, so a child settles at or under MAX_TOTAL_BYTES.
 */
 const MAX_FILE_BYTES = 2 * 1024 * 1024;
 const MAX_TOTAL_BYTES = 16 * 1024 * 1024;
@@ -5818,17 +5837,53 @@ function unavailable$2(reason) {
 		reason
 	});
 }
+/** The one place an absent transcript is spelled, so every settlement reads the same — the
+*  settle path needs it for the reasons only IT can know (an executor that offers no transcript,
+*  a child that never started), which the capture itself never sees. */
+function harnessTranscriptUnavailable(reason) {
+	return unavailable$2(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.
+* `find` is given the roots and prints one `size<TAB>path` line per file. A missing root is not
+* an error: a child that never used a harness has no directory for it. A line with no size (an
+* environment whose `find` lacks `-printf`) is read and bounded after the read, as before.
+*
+* Two omissions used to be silent, so `skippedCount` could read 0 on an incomplete capture: a
+* `-size` filter dropped oversized files before they were ever listed, and `head` cut the listing
+* at MAX_FILES with nothing saying so. Both are reported now: an oversized file is skipped by its
+* listed size WITHOUT being read, and a listing that overflows carries one
+* `enumeration-truncated` entry naming the bound.
 */
 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}`;
+	const command = `find ${roots.map((r) => `"$HOME/${r}"`).join(" ")} -type f -printf '%s\\t%p\\n' 2>/dev/null | head -1001`;
 	try {
-		return ((await environment.exec(command, signal ? { signal } : void 0)).stdout ?? "").split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
+		const lines = ((await environment.exec(command, signal ? { signal } : void 0)).stdout ?? "").split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
+		const omitted = [];
+		const paths = [];
+		for (const line of lines.slice(0, MAX_FILES)) {
+			const tab = line.indexOf("	");
+			const path = tab === -1 ? line : line.slice(tab + 1);
+			const size = tab === -1 ? void 0 : Number(line.slice(0, tab));
+			if (size !== void 0 && Number.isFinite(size) && size > MAX_FILE_BYTES) {
+				omitted.push({
+					path,
+					reason: "file-exceeds-byte-bound"
+				});
+				continue;
+			}
+			paths.push(path);
+		}
+		if (lines.length > MAX_FILES) omitted.push({
+			path: roots.join(" "),
+			reason: `enumeration-truncated-at-${MAX_FILES}`
+		});
+		return {
+			paths,
+			omitted
+		};
 	} catch {
 		return;
 	}
@@ -5841,16 +5896,17 @@ async function enumerate(environment, roots, signal) {
 * 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) {
+async function captureHarnessTranscript(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 enumerated = await enumerate(environment, roots, signal);
+	if (enumerated === void 0) return unavailable$2("enumeration-failed");
+	const { paths } = enumerated;
+	if (paths.length === 0 && enumerated.omitted.length === 0) return unavailable$2("no-transcript");
 	const files = [];
-	const skipped = [];
+	const skipped = [...enumerated.omitted];
 	let total = 0;
 	for (const path of paths) {
 		if (signal?.aborted) {
@@ -5884,6 +5940,13 @@ async function captureNativeSessionEvidence(environment, harness, signal) {
 				});
 				continue;
 			}
+			if (total + bytes > MAX_TOTAL_BYTES) {
+				skipped.push({
+					path,
+					reason: "total-byte-budget-exhausted"
+				});
+				continue;
+			}
 			files.push(Object.freeze({
 				path,
 				bytes,
@@ -5897,7 +5960,11 @@ async function captureNativeSessionEvidence(environment, harness, signal) {
 			});
 		}
 	}
-	if (files.length === 0) return unavailable$2("no-transcript");
+	if (files.length === 0) return Object.freeze({
+		status: "unavailable",
+		reason: "nothing-carried",
+		skipped: Object.freeze(skipped)
+	});
 	const artifact = Object.freeze({
 		schemaVersion: 1,
 		harness,
@@ -5905,13 +5972,54 @@ async function captureNativeSessionEvidence(environment, harness, signal) {
 		skipped: Object.freeze(skipped)
 	});
 	return Object.freeze({
-		status: "available",
+		status: "captured",
 		artifact,
 		fileCount: files.length,
 		totalBytes: total,
 		skippedCount: skipped.length
 	});
 }
+/**
+* Persist a capture under its own content ref and return the receipt a settlement carries.
+*
+* The scope calls this, not the executor: storage stays out of every provider and destroy site,
+* exactly as the tool-span trace is persisted by `captureWorkerTraceEvidence` and not by the
+* source that collected it. A capture that is already unavailable passes through untouched.
+*/
+async function persistHarnessTranscript(capture, blobs) {
+	if (capture.status !== "captured") return capture;
+	const transcriptRef = contentAddress(capture.artifact);
+	try {
+		await blobs.put(transcriptRef, capture.artifact);
+	} catch {
+		return unavailable$2("transcript-persistence-failed");
+	}
+	return Object.freeze({
+		status: "available",
+		transcriptRef,
+		harness: capture.artifact.harness,
+		fileCount: capture.fileCount,
+		totalBytes: capture.totalBytes,
+		skippedCount: capture.skippedCount
+	});
+}
+/**
+* Rehydrate the exact persisted transcript a receipt points at, or `undefined` when the receipt
+* says there is none. Throws only when the receipt claims a blob the store does not hold — that
+* is corruption, not absence, and must not read as "no transcript".
+*/
+async function harnessTranscriptArtifact(evidence, blobs) {
+	if (evidence.status !== "available") return void 0;
+	const raw = await blobs.get(evidence.transcriptRef);
+	if (!isHarnessTranscriptArtifact(raw)) throw new ValidationError$1(`harnessTranscriptArtifact: blob store has no transcript artifact for '${evidence.transcriptRef}'`);
+	return raw;
+}
+/** Every entry, not just the arrays: a blob with `files: [null]` is corruption, not a transcript. */
+function isHarnessTranscriptArtifact(value) {
+	if (value === null || typeof value !== "object") return false;
+	const artifact = value;
+	return artifact.schemaVersion === 1 && typeof artifact.harness === "string" && Array.isArray(artifact.files) && artifact.files.every((file) => file !== null && typeof file === "object" && typeof file.path === "string" && typeof file.content === "string" && Number.isSafeInteger(file.bytes) && file.bytes >= 0) && Array.isArray(artifact.skipped) && artifact.skipped.every((entry) => entry !== null && typeof entry === "object" && typeof entry.path === "string" && typeof entry.reason === "string");
+}
 //#endregion
 //#region src/runtime/provider-placement.ts
 const placementMetadataKey = "runtimeProviderPlacement";
@@ -6618,7 +6726,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)
 	});
@@ -6627,6 +6742,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) {
@@ -6635,6 +6751,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) {
@@ -6652,7 +6769,8 @@ async function startRetainedRun(options) {
 		identity,
 		onAdmission: options.onAdmission,
 		capabilities,
-		now: options.now
+		now: options.now,
+		preserveEnvironment: options.existingEnvironmentId !== void 0
 	});
 }
 /**
@@ -6693,7 +6811,8 @@ async function startRetainedRunInEnvironment(options) {
 		identity,
 		onAdmission: options.onAdmission,
 		capabilities,
-		now: options.now
+		now: options.now,
+		preserveEnvironment: true
 	});
 }
 async function assertRetainedEnvironmentOwnership(provider, environmentId, idempotencyKey) {
@@ -6714,7 +6833,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) {
@@ -6851,6 +6970,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,
@@ -7545,18 +7665,20 @@ 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;
 	let pending = false;
+	let harnessTranscript = harnessTranscriptUnavailable("execution-never-started");
 	const retention = retainedExecutorContext(ctx);
 	let destroyed = false;
 	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})`);
@@ -7578,7 +7700,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 } : {}
@@ -7603,42 +7725,51 @@ 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;
+					if (harnessTranscript.status === "unavailable" && harnessTranscript.reason === "execution-never-started") harnessTranscript = harnessTranscriptUnavailable("capture-did-not-run");
+					finalizeRuntimeOwnedPendingExecutor(executor, {
+						...plannedDeclaration,
+						execution: {
+							kind: "environment",
+							id: env.id
+						}
+					}, plannedBinding);
+				},
+				onArtifact: (next) => {
+					artifact = next;
+				},
+				onHarnessTranscript: (next) => {
+					harnessTranscript = next;
+				},
+				onDestroyed: () => {
+					destroyed = true;
+				}
+			});
+		} finally {
+			linked.release();
+		}
 	};
 	executor = {
 		runtime,
@@ -7717,7 +7848,8 @@ function createProviderExecutor(provider, profile, ctx, options, placement) {
 			if (!artifact) throw new ValidationError(`providerAsExecutor(${provider.name}): resultArtifact() read before stream drained`);
 			return artifact;
 		},
-		traceSource: () => trace.source
+		traceSource: () => trace.source,
+		harnessTranscript: () => harnessTranscript
 	};
 	return attestRuntimeOwnedPendingExecutor(executor, runtime, plannedDeclaration, plannedBinding);
 }
@@ -7730,7 +7862,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) {
@@ -7814,10 +7946,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 harnessTranscript = await captureHarnessTranscript(environment, args.profile.harness, linked);
+		args.onHarnessTranscript(harnessTranscript);
 		const result = {
 			...resultFromEvents(archive.events(), text),
-			nativeSession,
 			...archive.superseded > 0 ? { supersededPartUpdates: archive.superseded } : {},
 			...explicitFailure ? { outcome: outcomeTracker.finish() } : {}
 		};
@@ -7832,6 +7964,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
 		});
@@ -7851,8 +7984,9 @@ async function* streamProviderExecutor(args) {
 	} catch (error) {
 		failure = source.retained ? new RetainedExecutionPendingError(error) : error;
 		failed = true;
+		args.onHarnessTranscript(await captureHarnessTranscript(environment, args.profile.harness, linked));
 	} 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) {
@@ -7943,16 +8077,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 {
@@ -7973,7 +8117,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,
@@ -8016,34 +8165,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 {
@@ -15021,17 +15189,6 @@ function describeLeakedReservation(leak) {
 	return parts.join(", ");
 }
 //#endregion
-//#region src/durable/content-address.ts
-/** Stable content address shared by result and trace artifacts. */
-function contentAddress(artifact) {
-	return `sha256:${createHash("sha256").update(stableStringify(artifact), "utf-8").digest("hex")}`;
-}
-function stableStringify(value) {
-	if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "null";
-	if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
-	return `{${Object.entries(value).filter(([, v]) => v !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k, v]) => `${JSON.stringify(k)}:${stableStringify(v)}`).join(",")}}`;
-}
-//#endregion
 //#region src/runtime/supervise/trace-evidence.ts
 /**
 * Durable structured tool evidence for supervised workers.
@@ -15151,27 +15308,6 @@ function runtimeOwnedNestedDriverTreeRoot(owner, parentTreeRoot, driverNodeId) {
 //#endregion
 //#region src/durable/spawn-journal.ts
 /**
-*
-* Event-sourced spawn journal for the recursive execution atom (build steps 3 + 7).
-*
-* The supervision tree is journaled as an append-only event log: every `spawned`,
-* `settled`, and `cancelled` is recorded AFTER it is observed-committed (never
-* speculative), mirroring `ConversationJournal`'s begin/append/load shape. The log
-* holds only the THIN decision record — ids, parentage, budget, the spend a decision
-* consumed, and a content-addressed `outRef`. The payloads the driver branched on
-* (the `out` artifacts) live in a separate `ResultBlobStore`, keyed by `outRef`, so
-* the journal stays small (decisions) and replay rehydrates the exact `Settled` from
-* the blob store (evidence). This is the decision/payload split the replay argument
-* rests on (B1/B2).
-*
-* Replay determinism (B2): `seq` is the monotonic cursor order `scope.next()` yielded
-* each settlement — NOT wall-clock. `replaySpawnTree` sorts strictly by `seq` before
-* touching the blob store, so the order in which rehydration `get`s resolve can never
-* reorder the replayed `Settled[]`; the result is identical regardless of blob latency.
-*
-* @stable
-*/
-/**
 * Mint the content-addressed `outRef` for a result artifact: `sha256:<hex>` over a
 * stable JSON encoding. Producers call this to derive the `outRef` they journal and
 * `put`; the FS/in-mem stores re-derive it on `put` to verify the supplied ref
@@ -15284,14 +15420,17 @@ var InMemorySpawnJournal = class {
 		}
 		this.trees.set(root, {
 			begunAt: at,
-			events: []
+			events: [],
+			index: new SpawnEventIndex(root)
 		});
 	}
 	async appendEvent(root, ev) {
 		const tree = this.trees.get(root);
 		if (!tree) throw new Error(`appendEvent called for unknown spawn tree '${root}'; call beginTree first`);
-		assertSeqUnique(root, tree.events, ev);
-		tree.events.push(detachedSnapshot(ev, "spawn event"));
+		const event = detachedSnapshot(ev, "spawn event");
+		tree.index.assert(event);
+		tree.events.push(event);
+		tree.index.add(event);
 	}
 };
 /**
@@ -15306,6 +15445,7 @@ var InMemorySpawnJournal = class {
 var FileSpawnJournal = class {
 	path;
 	appendTail = Promise.resolve();
+	appendIndex;
 	constructor(path) {
 		this.path = path;
 	}
@@ -15320,12 +15460,14 @@ var FileSpawnJournal = class {
 		}
 		let begun = false;
 		const events = [];
+		const index = new SpawnEventIndex(root);
 		for (const record of parseCommittedJsonLines(text, this.path)) {
 			if (record.root !== root) continue;
 			if (record.kind === "begin") begun = true;
 			else {
 				if (!begun) throw new Error(`spawn journal corrupted: event for tree '${root}' precedes its begin record`);
-				assertSeqUnique(root, events, record.event);
+				index.assert(record.event);
+				index.add(record.event);
 				events.push(record.event);
 			}
 		}
@@ -15333,41 +15475,73 @@ var FileSpawnJournal = class {
 	}
 	async beginTree(root, at) {
 		return this.serializeAppend(async () => {
-			const existing = await this.loadTreeBegin(root);
+			const state = await this.validationIndex();
+			const existing = state.trees.get(root);
 			if (existing) {
-				if (existing !== at) throw new Error(`spawn tree '${root}' already begun in ${this.path} at ${existing}; refusing to overwrite with ${at}`);
+				if (existing.begunAt !== at) throw new Error(`spawn tree '${root}' already begun in ${this.path} at ${existing.begunAt}; refusing to overwrite with ${at}`);
 				return;
 			}
-			await this.writeRecord({
+			state.stamp = await this.writeRecord({
 				kind: "begin",
 				root,
 				at
 			});
+			state.trees.set(root, {
+				begunAt: at,
+				index: new SpawnEventIndex(root)
+			});
 		});
 	}
 	async appendEvent(root, ev) {
 		const event = detachedSnapshot(ev, "spawn event");
 		return this.serializeAppend(async () => {
-			const events = await this.loadTree(root);
-			if (events === void 0) throw new Error(`appendEvent called for unknown spawn tree '${root}'; call beginTree first`);
-			assertSeqUnique(root, events, event);
-			await this.writeRecord({
+			const state = await this.validationIndex();
+			const tree = state.trees.get(root);
+			if (tree === void 0) throw new Error(`appendEvent called for unknown spawn tree '${root}'; call beginTree first`);
+			tree.index.assert(event);
+			state.stamp = await this.writeRecord({
 				kind: "event",
 				root,
 				event
 			});
+			tree.index.add(event);
 		});
 	}
-	async loadTreeBegin(root) {
+	async validationIndex() {
+		const fs = await import("node:fs/promises");
+		const stamp = await this.fileStamp();
+		if (this.appendIndex && this.appendIndex.stamp === stamp) return this.appendIndex;
+		this.appendIndex = void 0;
+		const trees = /* @__PURE__ */ new Map();
+		if (stamp !== void 0) {
+			const text = await fs.readFile(this.path, "utf8");
+			if (await this.fileStamp() !== stamp) throw new Error("spawn journal changed while rebuilding its append index");
+			for (const record of parseCommittedJsonLines(text, this.path)) if (record.kind === "begin") {
+				if (!trees.has(record.root)) trees.set(record.root, {
+					begunAt: record.at,
+					index: new SpawnEventIndex(record.root)
+				});
+			} else {
+				const tree = trees.get(record.root);
+				if (!tree) throw new Error(`spawn journal corrupted: event for tree '${record.root}' precedes its begin record`);
+				tree.index.assert(record.event);
+				tree.index.add(record.event);
+			}
+		}
+		this.appendIndex = {
+			stamp,
+			trees
+		};
+		return this.appendIndex;
+	}
+	async fileStamp() {
 		const fs = await import("node:fs/promises");
-		let text;
 		try {
-			text = await fs.readFile(this.path, "utf8");
-		} catch (err) {
-			if (isNoEntError(err)) return void 0;
-			throw err;
+			return journalFileStamp(await fs.stat(this.path, { bigint: true }));
+		} catch (error) {
+			if (isNoEntError(error)) return void 0;
+			throw error;
 		}
-		for (const record of parseCommittedJsonLines(text, this.path)) if (record.root === root && record.kind === "begin") return record.at;
 	}
 	async serializeAppend(operation) {
 		const append = this.appendTail.then(operation);
@@ -15377,17 +15551,29 @@ var FileSpawnJournal = class {
 	async writeRecord(record) {
 		const fs = await import("node:fs/promises");
 		const path = await import("node:path");
-		await fs.mkdir(path.dirname(this.path), { recursive: true });
-		const needsSeparator = await prepareJsonlAppend(this.path);
-		const fh = await fs.open(this.path, "a");
 		try {
-			await writeAllBytes(fh, `${needsSeparator ? "\n" : ""}${JSON.stringify(record)}\n`);
-			await fh.sync();
-		} finally {
-			await fh.close();
+			await fs.mkdir(path.dirname(this.path), { recursive: true });
+			const needsSeparator = await prepareJsonlAppend(this.path);
+			const fh = await fs.open(this.path, "a");
+			try {
+				await writeAllBytes(fh, `${needsSeparator ? "\n" : ""}${JSON.stringify(record)}\n`);
+				await fh.sync();
+				const stamp = journalFileStamp(await fh.stat({ bigint: true }));
+				if (await this.fileStamp() !== stamp) throw new Error("spawn journal changed while acknowledging its append");
+				return stamp;
+			} finally {
+				await fh.close();
+			}
+		} catch (error) {
+			this.appendIndex = void 0;
+			throw error;
 		}
 	}
 };
+/** Detect replacement, truncation, and same-size edits; this is not a cross-process write lock. */
+function journalFileStamp(stat) {
+	return `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}`;
+}
 /**
 * Load every journal tree owned by one recursive supervision run and flatten its nodes/events.
 *
@@ -15654,79 +15840,104 @@ function servedIdentityParts(model) {
 		snapshot
 	};
 }
-/** Retained records form one ordered admission chain; older journals need no such chain. */
-function assertRetainedExecutionOrder(events, event) {
-	if (event.kind !== "execution-input" && event.kind !== "execution-admitted" && event.kind !== "execution-result") return;
-	const nodeEvents = events.filter((item) => item.id === event.id);
-	let inputIndex = -1;
-	for (let index = 0; index < nodeEvents.length; index++) if (nodeEvents[index].kind === "execution-input") inputIndex = index;
-	const prior = inputIndex < 0 ? nodeEvents : nodeEvents.slice(inputIndex);
-	function fail(reason) {
-		throw new Error(`spawn journal corrupted: retained execution '${event.id}' ${reason}`);
-	}
-	if (!nodeEvents.some((item) => item.kind === "spawned")) fail("precedes its spawn");
-	if (nodeEvents.some(closesCursorSlot)) fail("follows its terminal settlement");
-	if (event.kind === "execution-input") {
-		if (!/^sha256:[0-9a-f]{64}$/.test(event.taskRef)) fail("has an invalid task reference");
-		if (nodeEvents.some((item) => item.kind === "execution-input" && item.seq === event.seq)) fail("has duplicate input sequence");
-		if (inputIndex >= 0 && !prior.some((item) => item.kind === "execution-result")) fail("input replaces an unfinished invocation");
-		return;
-	}
-	const admissions = prior.flatMap((item) => item.kind === "execution-admitted" ? [item.admission] : []);
-	if (event.kind === "execution-result") {
-		if (prior.some((item) => item.kind === "execution-result")) fail("has duplicate result");
-		if (!admissions.some((item) => item.phase === "dispatched")) fail("result precedes dispatch");
-		if (!/^sha256:[0-9a-f]{64}$/.test(event.outRef)) fail("has an invalid result reference");
-		assertValidSpend(event.spent, "retained execution result");
-		executorFailureReason(event);
-		return;
-	}
-	const admission = event.admission;
-	if (!admission || ![
-		"intent",
-		"environment",
-		"dispatched"
-	].includes(admission.phase)) fail("has an invalid admission phase");
-	if (admissions.some((item) => item.phase === admission.phase)) fail("has duplicate admission phase");
-	if (prior.some((item) => item.kind === "execution-result")) fail("admission follows result");
-	if (!prior.some((item) => item.kind === "execution-input")) fail("admission precedes input");
-	if (admission.phase === "intent") {
-		if (admissions.length !== 0) fail("intent follows another admission");
-		return;
-	}
-	const intent = admissions.find((item) => item.phase === "intent");
-	if (intent?.phase !== "intent") fail("admission precedes intent");
-	if (admission.idempotencyKey !== intent.idempotencyKey || admission.turnId !== intent.turnId) fail("changes its admitted request identity");
-	if (admission.phase === "environment") {
-		if (admission.provider !== intent.provider || admission.sessionId !== intent.sessionId || admission.executionId !== intent.executionId) fail("changes its admitted execution identity");
-		return;
-	}
-	const environment = admissions.find((item) => item.phase === "environment");
-	if (environment?.phase !== "environment") fail("dispatch precedes environment");
-	const control = admission.controlRef;
-	if (!control || control.provider !== intent.provider || control.environmentId !== environment.environmentId || control.sessionId !== intent.sessionId || control.executionId !== intent.executionId) fail("dispatch changes its admitted execution identity");
-}
-/**
-* Two `seq` namespaces share the journal: a `spawned` event's `seq` is the spawn ordinal
-* (the order children were created), and a `settled`/`cancelled` event's `seq` is the
-* monotonic CURSOR order `scope.next()` yielded that settlement (B2). The uniqueness
-* replay rests on is the cursor namespace — two settlements cannot share the position
-* replay orders by — so the guard checks only settled/cancelled events. A `spawned`
-* ordinal legitimately equals a later `settled` cursor seq and is not a collision.
-*/
-function assertSeqUnique(root, events, ev) {
-	assertRetainedExecutionOrder(events, ev);
-	if (ev.kind === "materialized") {
-		if (events.some((event) => event.kind === "materialized" && event.id === ev.id)) throw new Error(`spawn journal corrupted: duplicate materialization receipt for node '${ev.id}' in tree '${root}'`);
-		if (!events.some((event) => event.kind === "spawned" && event.id === ev.id)) throw new Error(`spawn journal corrupted: materialization for node '${ev.id}' precedes its spawn in tree '${root}'`);
-	}
-	if (ev.kind === "execution-bound") {
-		if (events.some((event) => event.kind === "execution-bound" && event.id === ev.id && event.binding.attemptId === ev.binding.attemptId)) throw new Error(`spawn journal corrupted: duplicate execution binding for node '${ev.id}' attempt '${ev.binding.attemptId}' in tree '${root}'`);
-		if (!events.some((event) => event.kind === "materialized" && event.id === ev.id)) throw new Error(`spawn journal corrupted: execution binding for node '${ev.id}' precedes materialization in tree '${root}'`);
+/** One validation implementation for memory, durable append, and cold replay. */
+var SpawnEventIndex = class {
+	root;
+	nodes = /* @__PURE__ */ new Map();
+	cursors = /* @__PURE__ */ new Set();
+	constructor(root) {
+		this.root = root;
+	}
+	assert(event) {
+		const node = this.nodes.get(event.id);
+		this.assertRetained(node, event);
+		if (event.kind === "materialized") {
+			if (node?.materialized) throw new Error(`spawn journal corrupted: duplicate materialization receipt for node '${event.id}' in tree '${this.root}'`);
+			if (!node?.spawned) throw new Error(`spawn journal corrupted: materialization for node '${event.id}' precedes its spawn in tree '${this.root}'`);
+		}
+		if (event.kind === "execution-bound") {
+			if (node?.bindings.has(event.binding.attemptId)) throw new Error(`spawn journal corrupted: duplicate execution binding for node '${event.id}' attempt '${event.binding.attemptId}' in tree '${this.root}'`);
+			if (!node?.materialized) throw new Error(`spawn journal corrupted: execution binding for node '${event.id}' precedes materialization in tree '${this.root}'`);
+		}
+		if (!outsideCursorNamespace(event) && this.cursors.has(event.seq)) throw new Error(`spawn journal corrupted: duplicate cursor seq ${event.seq} in tree '${this.root}'; the cursor order replay relies on is not unique`);
+	}
+	/** Called only after validation and, for the file writer, a successful durable append. */
+	add(event) {
+		if (!outsideCursorNamespace(event)) this.cursors.add(event.seq);
+		if (event.kind !== "spawned" && event.kind !== "materialized" && event.kind !== "execution-bound" && event.kind !== "execution-input" && event.kind !== "execution-admitted" && event.kind !== "execution-result" && !closesCursorSlot(event)) return;
+		let node = this.nodes.get(event.id);
+		if (!node) {
+			node = {
+				spawned: false,
+				closed: false,
+				materialized: false,
+				bindings: /* @__PURE__ */ new Set(),
+				inputs: /* @__PURE__ */ new Set(),
+				input: false,
+				result: false,
+				admissions: /* @__PURE__ */ new Map()
+			};
+			this.nodes.set(event.id, node);
+		}
+		if (event.kind === "spawned") node.spawned = true;
+		else if (event.kind === "materialized") node.materialized = true;
+		else if (event.kind === "execution-bound") node.bindings.add(event.binding.attemptId);
+		else if (event.kind === "execution-input") {
+			node.inputs.add(event.seq);
+			node.input = true;
+			node.result = false;
+			node.admissions.clear();
+		} else if (event.kind === "execution-admitted") node.admissions.set(event.admission.phase, event.admission);
+		else if (event.kind === "execution-result") node.result = true;
+		if (closesCursorSlot(event)) node.closed = true;
+	}
+	assertRetained(node, event) {
+		if (event.kind !== "execution-input" && event.kind !== "execution-admitted" && event.kind !== "execution-result") return;
+		function fail(reason) {
+			throw new Error(`spawn journal corrupted: retained execution '${event.id}' ${reason}`);
+		}
+		if (!node?.spawned) fail("precedes its spawn");
+		if (node.closed) fail("follows its terminal settlement");
+		if (event.kind === "execution-input") {
+			if (!/^sha256:[0-9a-f]{64}$/.test(event.taskRef)) fail("has an invalid task reference");
+			if (node.inputs.has(event.seq)) fail("has duplicate input sequence");
+			if (node.input && !node.result) fail("input replaces an unfinished invocation");
+			return;
+		}
+		if (event.kind === "execution-result") {
+			if (node.result) fail("has duplicate result");
+			if (!node.admissions.has("dispatched")) fail("result precedes dispatch");
+			if (!/^sha256:[0-9a-f]{64}$/.test(event.outRef)) fail("has an invalid result reference");
+			assertValidSpend(event.spent, "retained execution result");
+			executorFailureReason(event);
+			return;
+		}
+		const admission = event.admission;
+		if (!admission || ![
+			"intent",
+			"environment",
+			"dispatched"
+		].includes(admission.phase)) fail("has an invalid admission phase");
+		if (node.admissions.has(admission.phase)) fail("has duplicate admission phase");
+		if (node.result) fail("admission follows result");
+		if (!node.input) fail("admission precedes input");
+		if (admission.phase === "intent") {
+			if (node.admissions.size !== 0) fail("intent follows another admission");
+			return;
+		}
+		const intent = node.admissions.get("intent");
+		if (intent?.phase !== "intent") fail("admission precedes intent");
+		if (admission.idempotencyKey !== intent.idempotencyKey || admission.turnId !== intent.turnId) fail("changes its admitted request identity");
+		if (admission.phase === "environment") {
+			if (admission.provider !== intent.provider || admission.sessionId !== intent.sessionId || admission.executionId !== intent.executionId) fail("changes its admitted execution identity");
+			return;
+		}
+		const environment = node.admissions.get("environment");
+		if (environment?.phase !== "environment") fail("dispatch precedes environment");
+		const control = admission.controlRef;
+		if (!control || control.provider !== intent.provider || control.environmentId !== environment.environmentId || control.sessionId !== intent.sessionId || control.executionId !== intent.executionId) fail("dispatch changes its admitted execution identity");
 	}
-	if (outsideCursorNamespace(ev)) return;
-	if (events.some((e) => !outsideCursorNamespace(e) && e.seq === ev.seq)) throw new Error(`spawn journal corrupted: duplicate cursor seq ${ev.seq} in tree '${root}'; the cursor order replay relies on is not unique`);
-}
+};
 /**
 * The records that CLOSE a node's cursor slot: a settlement, a cancellation, or a wait being
 * woken. The complement question to {@link outsideCursorNamespace}, and the one a resume needs —
@@ -15886,6 +16097,7 @@ async function replaySpawnTree(journal, blobs, root) {
 				...ev.providerModel === void 0 ? {} : { providerModel: copyProviderModelEvidence(ev.providerModel) },
 				...budgetViolationOf(ev),
 				trace,
+				...ev.harnessTranscript === void 0 ? {} : { harnessTranscript: ev.harnessTranscript },
 				...settlementTime(ev.at),
 				seq: ev.seq
 			});
@@ -15906,6 +16118,7 @@ async function replaySpawnTree(journal, blobs, root) {
 			...ev.providerModel === void 0 ? {} : { providerModel: copyProviderModelEvidence(ev.providerModel) },
 			...budgetViolationOf(ev),
 			trace,
+			...ev.harnessTranscript === void 0 ? {} : { harnessTranscript: ev.harnessTranscript },
 			...settlementTime(ev.at),
 			seq: ev.seq
 		});
@@ -19874,8 +20087,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,
@@ -19886,11 +20104,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();
@@ -19938,6 +20161,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);
@@ -19955,6 +20228,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;
@@ -20246,6 +20521,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.
@@ -20549,6 +20826,7 @@ function createScope(args) {
 					rootId: args.root,
 					parentId: args.parentId,
 					nodeId: id,
+					depth: args.depth + 1,
 					attemptId,
 					...identity ? { identity } : {}
 				},
@@ -20853,7 +21131,7 @@ function createScope(args) {
 				try {
 					await interactiveBindingCommitted;
 				} catch {
-					resolution = downRecord("interactive worker binding persistence failed", true, s.trace, s.metered, s.providerModel, s.outRef);
+					resolution = downRecord("interactive worker binding persistence failed", true, s.trace, s.metered, s.providerModel, s.outRef, s.harnessTranscript);
 				}
 				live.resolved = resolution;
 				return resolution;
@@ -21221,6 +21499,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 },
@@ -21406,6 +21685,7 @@ function scopeOwnerExecutorNodeContext(scope) {
 		rootId: state.root,
 		parentId: state.nodeId,
 		nodeId: state.nodeId,
+		depth: state.depth,
 		attemptId: state.attemptId
 	});
 }
@@ -21576,12 +21856,14 @@ async function appendSettlementMetering(journal, root, id, spend, at) {
 /** An open node's reconciled floor has the same per-child sequence discipline as its metering:
 *  outside the cursor namespace, monotonic per node, so a node reconciled once per process (a
 *  retained failure, a recovery, a second retained failure) keeps its records ordered. */
-async function appendReconciledFloor(journal, root, id, spent, at) {
+async function appendReconciledFloor(journal, root, id, spent, at, harnessTranscript) {
+	const seq = await nextPerNodeSeq(journal, root, "reconciled", id);
 	await appendAcknowledged(journal, root, {
 		kind: "reconciled",
 		id,
 		spent,
-		seq: await nextPerNodeSeq(journal, root, "reconciled", id),
+		...harnessTranscript ? { harnessTranscript } : {},
+		seq,
 		at
 	});
 }
@@ -21641,10 +21923,11 @@ async function finalizeSettlement(child, settlement, seq, args, now) {
 			...settlement.providerModel ? { providerModel: settlement.providerModel } : {},
 			...child.budgetViolation ? { budgetViolation: child.budgetViolation } : {},
 			trace: settlement.trace,
+			...settlement.harnessTranscript ? { harnessTranscript: settlement.harnessTranscript } : {},
 			seq,
 			at
 		});
-		else if (settlement.reconciled !== void 0) await appendReconciledFloor(args.journal, args.root, child.id, settlement.reconciled, at);
+		else if (settlement.reconciled !== void 0) await appendReconciledFloor(args.journal, args.root, child.id, settlement.reconciled, at, settlement.harnessTranscript);
 		notifyRuntimeHookEvent(args.hooks, {
 			id: `${child.id}:settled`,
 			runId: args.root,
@@ -21672,6 +21955,7 @@ async function finalizeSettlement(child, settlement, seq, args, now) {
 			...settlement.providerModel ? { providerModel: settlement.providerModel } : {},
 			...child.budgetViolation ? { budgetViolation: child.budgetViolation } : {},
 			trace: settlement.trace,
+			...settlement.harnessTranscript ? { harnessTranscript: settlement.harnessTranscript } : {},
 			settledAt,
 			seq
 		};
@@ -21691,6 +21975,7 @@ async function finalizeSettlement(child, settlement, seq, args, now) {
 		...settlement.providerModel ? { providerModel: settlement.providerModel } : {},
 		...child.budgetViolation ? { budgetViolation: child.budgetViolation } : {},
 		trace: settlement.trace,
+		...settlement.harnessTranscript ? { harnessTranscript: settlement.harnessTranscript } : {},
 		seq,
 		at
 	});
@@ -21722,6 +22007,7 @@ async function finalizeSettlement(child, settlement, seq, args, now) {
 		...settlement.providerModel ? { providerModel: settlement.providerModel } : {},
 		...child.budgetViolation ? { budgetViolation: child.budgetViolation } : {},
 		trace: settlement.trace,
+		...settlement.harnessTranscript ? { harnessTranscript: settlement.harnessTranscript } : {},
 		settledAt,
 		seq
 	};
@@ -21854,6 +22140,11 @@ async function runChild(live, executor, childAbort, task, opts, pool, ticket, bl
 		traceEvidence ??= await captureWorkerTraceEvidence(live.readTraceSource, blobs, started);
 		return traceEvidence;
 	};
+	let transcriptEvidence;
+	const persistTranscriptOnce = async () => {
+		transcriptEvidence ??= await persistHarnessTranscript(readHarnessTranscript(executor), blobs);
+		return transcriptEvidence;
+	};
 	const teardownOnce = async (grace) => {
 		if (teardownStarted) return;
 		teardownStarted = true;
@@ -21940,16 +22231,17 @@ async function runChild(live, executor, childAbort, task, opts, pool, ticket, bl
 		live.executorDone = true;
 		const ownMetered = executor.metered?.();
 		const trace = await captureTraceOnce();
+		const childHarnessTranscript = await persistTranscriptOnce();
 		if (childAbort.signal.aborted && live.acceptedResult === void 0) {
 			await teardownOnce(opts.shutdown ?? "brutalKill");
-			return downRecord("aborted before settle", true, trace, ownMetered, runtimeOwnedExecutorProviderEvidence(executor), retainedOutputRef);
+			return downRecord("aborted before settle", true, trace, ownMetered, runtimeOwnedExecutorProviderEvidence(executor), retainedOutputRef, childHarnessTranscript);
 		}
 		const outRef = artifact.outRef;
 		const failureReason = executorFailureReason(artifact);
 		if (failureReason !== void 0) {
 			await teardownOnce(opts.shutdown ?? 5e3).catch(() => void 0);
 			return {
-				...downRecord(failureReason, false, trace, ownMetered, runtimeOwnedExecutorProviderEvidence(executor)),
+				...downRecord(failureReason, false, trace, ownMetered, runtimeOwnedExecutorProviderEvidence(executor), void 0, childHarnessTranscript),
 				outRef
 			};
 		}
@@ -21961,6 +22253,7 @@ async function runChild(live, executor, childAbort, task, opts, pool, ticket, bl
 			...artifact.verdict ? { verdict: artifact.verdict } : {},
 			spent: live.spent,
 			trace,
+			harnessTranscript: childHarnessTranscript,
 			providerModel: runtimeOwnedExecutorProviderEvidence(executor),
 			...ownMetered ? { metered: ownMetered } : {}
 		};
@@ -21980,7 +22273,7 @@ async function runChild(live, executor, childAbort, task, opts, pool, ticket, bl
 				const metered = executor.metered?.();
 				const failureReason = executorFailureReason(accepted);
 				if (failureReason !== void 0) return {
-					...downRecord(failureReason, false, trace, metered, runtimeOwnedExecutorProviderEvidence(executor)),
+					...downRecord(failureReason, false, trace, metered, runtimeOwnedExecutorProviderEvidence(executor), void 0, await persistTranscriptOnce()),
 					outRef: accepted.outRef
 				};
 				return {
@@ -21990,6 +22283,7 @@ async function runChild(live, executor, childAbort, task, opts, pool, ticket, bl
 					...accepted.verdict ? { verdict: accepted.verdict } : {},
 					spent: live.spent,
 					trace,
+					harnessTranscript: await persistTranscriptOnce(),
 					providerModel: runtimeOwnedExecutorProviderEvidence(executor),
 					...metered ? { metered } : {}
 				};
@@ -22015,7 +22309,7 @@ async function runChild(live, executor, childAbort, task, opts, pool, ticket, bl
 			}
 			live.budgetViolation = void 0;
 			return {
-				...downRecord(errMessage(err), true, trace, executor.metered?.(), void 0, retainedOutputRef),
+				...downRecord(errMessage(err), true, trace, executor.metered?.(), void 0, retainedOutputRef, await persistTranscriptOnce()),
 				reconciled: live.spent
 			};
 		}
@@ -22039,7 +22333,7 @@ async function runChild(live, executor, childAbort, task, opts, pool, ticket, bl
 		const aborted = childAbort.signal.aborted || isAbortError(err);
 		if (started && !terminalTelemetryCaptured && accounting === void 0) live.spent = unknownFloor(live.spent);
 		const reconcileError = reconcileOnce(accounting?.reservation ?? live.spent);
-		return downRecord(errMessage(err), evidenceError !== void 0 || teardownError !== void 0 || reconcileError !== void 0 || aborted || isInfraError(err), trace, executor.metered?.(), providerModel, retainedOutputRef);
+		return downRecord(errMessage(err), evidenceError !== void 0 || teardownError !== void 0 || reconcileError !== void 0 || aborted || isInfraError(err), trace, executor.metered?.(), providerModel, retainedOutputRef, await persistTranscriptOnce());
 	} finally {
 		await closeRetainedWrites();
 	}
@@ -22277,17 +22571,47 @@ function unknownFloor(spend) {
 		}])) }
 	};
 }
-function downRecord(reason, infra, trace, metered, providerModel, outRef) {
+function downRecord(reason, infra, trace, metered, providerModel, outRef, harnessTranscript) {
 	return {
 		kind: "down",
 		reason,
 		infra,
 		trace,
+		...harnessTranscript ? { harnessTranscript } : {},
 		...providerModel ? { providerModel } : {},
 		...metered ? { metered } : {},
 		...outRef === void 0 ? {} : { outRef }
 	};
 }
+/**
+* Read one executor's harness-transcript receipt without letting a broken port escape.
+*
+* The three answers this has to keep apart, because #1214 and #1244 are both about an artifact
+* that reads as coverage without being coverage:
+*   - `available`                              the transcript survived;
+*   - a reason the CAPTURE produced            a box existed and could not be read;
+*   - `executor-exposes-no-transcript`     this runtime has no transcript to offer at all;
+*   - `execution-never-started`                no environment was ever created (the executor's
+*                                              own seed, set before `create`);
+*   - `capture-did-not-run`                    the port answered nothing, so the capture was
+*                                              skipped rather than attempted and failed.
+*
+* Mirrors `readInteractiveSession` above: an absence is always a named reason, never `undefined`.
+*/
+function readHarnessTranscript(executor) {
+	if (!executor.harnessTranscript) return harnessTranscriptUnavailable("executor-exposes-no-transcript");
+	let reported;
+	try {
+		reported = executor.harnessTranscript();
+	} catch {
+		return harnessTranscriptUnavailable("executor-exposes-no-transcript");
+	}
+	if (reported === void 0) return harnessTranscriptUnavailable("capture-did-not-run");
+	const capture = reported;
+	if (capture.status === "captured" && capture.artifact) return capture;
+	if (capture.status === "unavailable" && capture.reason) return capture;
+	return harnessTranscriptUnavailable("executor-exposes-no-transcript");
+}
 /** The one place an absent interactive process is spelled, so every refusal reads the same. */
 function noInteractiveSession(reason) {
 	return Object.freeze({
@@ -22534,8 +22858,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() {
@@ -22747,7 +23070,8 @@ function unreportedSpend(total, prior) {
 * 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.
+* crosses the same budget, deadline, and abort bounds. Successful continuations do not consume
+* the failure retry allowance.
 */
 /**
 * The instruction a completed-but-undelivered drive is re-entered with when the caller supplies no
@@ -22864,9 +23188,14 @@ async function runDriverWithRetry(run) {
 	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 maxReprompts = run.reprompt?.maxReprompts ?? 0;
+	if (maxReprompts === "until-complete") {
+		const deadline = run.budget().deadlineMs;
+		if (!Number.isFinite(deadline) || deadline <= 0) throw new ValidationError$1("runDriverWithRetry: until-complete requires a finite positive deadline");
+	}
 	const attempts = [];
 	let consecutiveBarren = 0;
+	let failures = 0;
 	let reprompts = 0;
 	let reentry;
 	const emit = async (record) => {
@@ -22879,11 +23208,10 @@ async function runDriverWithRetry(run) {
 	* 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 (maxReprompts !== "until-complete" && 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,
@@ -22912,6 +23240,7 @@ async function runDriverWithRetry(run) {
 		try {
 			await run.drive(attempt, reentry);
 		} catch (error) {
+			failures += 1;
 			const durationMs = now() - startedAt;
 			const classification = classifyDriverFailure(error, run.signal);
 			const progressed = madeProgress(before, run.progress());
@@ -22921,7 +23250,7 @@ async function runDriverWithRetry(run) {
 				if (run.signal.aborted) return "aborted";
 				const byBudget = budgetStop(run.budget(), now());
 				if (byBudget) return byBudget;
-				if (attempt >= maxAttempts) return "max-attempts";
+				if (failures >= maxAttempts) return "max-attempts";
 				if (progressed) return void 0;
 				return consecutiveBarren + 1 >= maxConsecutive ? "no-progress" : void 0;
 			})();
@@ -22953,12 +23282,13 @@ async function runDriverWithRetry(run) {
 			if (afterWait) throw new DriverAttemptsExhaustedError(error, attempts, afterWait);
 			continue;
 		}
+		consecutiveBarren = 0;
 		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) {
+		if (contract === "unmet" && (maxReprompts === "until-complete" || maxReprompts > 0)) {
 			const decision = await decideReprompt(attempt, after);
 			if ("steer" in decision) {
 				reprompts += 1;
@@ -23075,29 +23405,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
@@ -23455,10 +23805,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,
@@ -23850,6 +24197,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 { bindReusableExecutorExecutionId as $, providerMessageText as $i, buildRuntimeEventOtelSpans as $n, providerAttemptEvidence as $r, addHarnessUsage as $t, waitUntil as A, deleteBoxSafe as Ai, RunCancellationReason as An, profileMaterializationAxes$1 as Ar, spendFromUsageTotals as At, attachWorker as B, withTimeout as Bi, defaultRedactorIdentityMaterial as Bn, worktreeCliProfileMaterialization as Br, createInbox as Bt, scopeOwnerExecutorNodeContext as C, notifySandboxEventObserver as Ci, resolveAgentEnvironmentProvider as Cn, parseCodexTokenUsage as Cr, workerTraceAnalysisStore as Ct, pollFor as D, addSpend as Di, sandboxSessionTraceSource as Dn, controlProfileMaterialization as Dr, meterUsageEvent as Dt, isWaitOutcome as E, sumSandboxUsage as Ei, decodeToolPart as En, assertProfileMaterialization as Er, createBudgetPool as Et, scopeRetainedOwnerPriorSpend as F, sleep as Fi, recoverRetainedRun as Fn, renderProfileMaterializationIssues as Fr, workerTraceSeamKey as Ft, recoverRetainedInteractiveRun as G, decodeHarnessUsage as Gi, contentAddress as Gn, attestRuntimeOwnedPendingExecutor as Gr, createPeerMailbox as Gt, workerInteractiveBindingFile as H, addResourceSpend as Hi, captureHarnessTranscript as Hn, parseCommittedJsonLines as Hr, DEFAULT_PEER_MAIL_LIMITS as Ht, scopeRetainedOwnerResult as I, stringifySafe as Ii, startRetainedRun as In, renderUnsupported as Ir, taskToPrompt as It, errMessage as J, DEFAULT_SUCCESSFUL_SHUTDOWN_MS as Ji, readTraceContextFromEnv as Jn, finalizeRuntimeOwnedPendingExecutor as Jr, peerMailVerbNames as Jt, startRetainedInteractiveRun as K, abortError$2 as Ki, createPropagatingTraceEmitter as Kn, attestRuntimeOwnedScopeOwner as Kr, isPeerMailEnvelope as Kt, interactiveAdmissionSeamKey as L, throwAbort as Li, startRetainedRunInEnvironment as Ln, sandboxActProfileMaterialization as Lr, DEFAULT_STALL_AFTER_MS as Lt, consumeScopeRetainedOwnerResult as M, isAbortError$2 as Mi, linkAbort as Mn, promptModelProfileMaterialization as Mr, readWorkerTraceContext as Mt, prepareScopeRetainedOwnerTask as N, promptCacheTokenClasses as Ni, runAbortable as Nn, promptOnlyProfileMaterialization as Nr, workerTraceEnv as Nt, timerAt as O, chargedTokens as Oi, registerRetainedExecutorPreparation as On, defineProfileMaterializationContract as Or, newUsageTotals as Ot, scopeRetainedOwnerContext as P, randomSuffix as Pi, reconnectRetainedRun as Pn, promptResourceProfileMaterialization as Pr, workerTraceHeaders as Pt, rollingDispatch as Q, promptOptionsFromAgentTurnInput as Qi, buildLoopSpanNodes as Qn, newExecutionAttemptId as Qr, bridgeModelRouteRefusal as Qt, readWorkerInteractiveAdmissions as R, throwIfAborted as Ri, retainedCreateMaterial as Rn, unsupportedProfileDimensions as Rr, createActivityLog as Rt, restoreScopeOwnerAcceptedExecution as S, mapSandboxToolEvent as Si, providerAsSandboxClient as Sn, localHarnessExecutable as Sr, parseWorkerToolTraceArtifact as St, createWaitProbes as T, sandboxProgressEvents as Ti, createPushTraceSource as Tn, AGENT_PROFILE_MATERIALIZATION_AXES as Tr, assertValidBudget as Tt, workerInteractiveBindingsDir as U, resourceTelemetry as Ui, harnessTranscriptArtifact as Un, prepareJsonlAppend as Ur, PEER_MAIL_WIRE_KEY as Ut, readWorkerInteractiveBinding as V, zeroSpend as Vi, resolveRedactor as Vn, isNoEntError as Vr, AUTHORITY_MARKERS as Vt, reconnectRetainedInteractiveRun as W, withBudgetResources as Wi, persistHarnessTranscript as Wn, writeAllBytes as Wr, claimsAuthority as Wt, freeSlots as X, teardownExecutor as Xi, INTELLIGENCE_WIRE_VERSION as Xn, knownExecutionBindingReceipt as Xr, isTerminalNodeStatus as Xt, effectiveConcurrency as Y, armDeadlineTimer as Yi, traceContextToEnv as Yn, inheritRuntimeOwnedExecutorAttestation as Yr, isLiveNodeStatus as Yt, queueOf as Z, promptFromAgentTurnInput as Zi, buildLoopOtelSpans as Zn, knownMaterializationReceipt as Zr, bridgeAdmissionRefusal as Zt, createScope as _, createSandboxToolPartState as _i, canonicalObservedModelParts as _n, createWorktree as _r, pendingWaits as _t, pickBestDelivered as a, runtimeOwnedPendingExecutorMaterialization as ai, TERMINAL_DECISIONS as an, loopEventToOtelSpan as ar, snapshotExecutorConfig as at, meterRuntimeOwnedProviderAttempt as b, isSandboxTerminalEvent as bi, createAgentEnvironmentProviderRegistry as bn, LOCAL_HARNESSES as br, captureWorkerTraceEvidence as bt, DriverAttemptsExhaustedError as c, unknownMaterializationReceipt as ci, isTerminalDecision as cn, toOtelAttributes as cr, createSteerableSandboxSession as ct, runDriverWithRetry as d, detachedFrozen as di, probeSandboxCapabilities as dn, sanitizeAgentRuntimeEvent as dr, FileSpawnJournal as dt, recordRuntimeOwnedDriveHarnessProviderEvidence as ei, createCodexRolloutStoreReader as en, createOpenInferenceFileExporter as er, captureReusableExecutorConfig as et, driverChild as f, detachedSnapshot as fi, acquireSandbox as fn, sanitizeKnowledgeReadinessReport as fr, InMemoryResultBlobStore as ft, beginScopeOwnerAttempt as g, canonicalStreamEventFromSandboxEvent as gi, runBrainLoop as gn, captureWorktreeDiff as gr, materializeTreeView as gt, withDriverExecutor as h, assertSandboxServedModel as hi, routerBrain as hn, runWorktreeHarness as hr, loadSpawnForest as ht, collectDelivered as i, runtimeOwnedExecutorProviderEvidence as ii, bridgeStopSignalKey as in, generateSpanId as ir, createExecutorRegistry as it, bindScopeRetainedOwnerProvider as j, hasCompleteCacheBreakdown as ji, abortError as jn, promptControlProfileMaterialization as jr, WORKER_TRACE_PROPAGATION as jt, validateWaitSpec as k, cloneSpend as ki, retainedExecutorSeamKey as kn, fullProfileMaterialization as kr, spendFromUsageEvents as kt, classifyDriverFailure as l, executableAgentProfileSnapshot as li, runAgentRounds as ln, createRuntimeEventCollector as lr, createInPlaceCliExecutor as lt, isDriverSpec as m, readSandboxOutcome as mi, readPromptOptions as mn, runSettledCommand as mr, insideCursorNamespace as mt, createSupervisor as n, runtimeOwnedExecutorExecutionBinding as ni, readCodexRolloutSession as nn, exportEvalRuns as nr, cliWorktreeExecutor as nt, runFinalizer as o, runtimeOwnedScopeOwnerRuntime as oi, createSandboxForSpec as on, padSpanId as or, createWorktreeCliExecutor as ot, driverExecutorFactory as p, projectSandboxOutcome as pi, assertBoxlessPromptOptions as pn, sanitizeRuntimeStreamEvent as pr, InMemorySpawnJournal as pt, destroyInteractiveEnvironment as q, awaitAbortable$1 as qi, mergeTraceEnv as qn, authoredProfileDigest as qr, peerMailTools as qt, bestDelivered as r, runtimeOwnedExecutorMaterialization as ri, bridgeRuntimeAttachmentsKey as rn, flatOtelSpan as rr, createExecutor as rt, runTree as s, unknownExecutionBindingReceipt as si, defaultSelectWinner as sn, padTraceId as sr, DEFAULT_SANDBOX_STEERING_MAX_TURNS as st, createRootHandle as t, runtimeOwnedDriveHarnessProviderEvidence as ti, harnessUsageIsEmpty as tn, createOtelExporter as tr, cliInPlaceExecutor as tt, defaultUnmetContractSteer as u, executableAgentSpecSnapshot as ui, createSandboxLineage as un, createRuntimeStreamEventCollector as ur, FileResultBlobStore as ut, deriveNodeExecutionIdentity as v, createSandboxUsageLedger as vi, observedModelMatchesDeclared as vn, removeWorktree as vr, replaySpawnTree as vt, settledToIteration as w, sandboxEventServedBackend as wi, sandboxClientAsProvider as wn, CodexExecutionDiagnosticError as wr, BudgetReconcileFault as wt, recordScopeOwnerMaterialization as x, mapSandboxEvent as xi, providerAsExecutor as xn, harnessSupportsReasoningEffort as xr, isTraceAnalysisStore as xt, meterRuntimeOwnedAccounting as y, extractLlmCallEvent as yi, DEFAULT_SANDBOX_IDLE_TIMEOUT_SECONDS as yn, DEFAULT_LOCAL_HARNESS as yr, WORKER_TOOL_TRACE_SCHEMA_VERSION as yt, workerInteractiveAdmissionFile as z, unmeteredSpend as zi, defaultRedactor as zn, validateProfileMaterialization as zr, readWorkerProgress as zt };
 
-//# sourceMappingURL=supervisor-DAHG98Rs.js.map
+//# sourceMappingURL=supervisor-BVAM5glY.js.map