@tangle-network/agent-runtime 0.300.0 → 0.301.0

package/dist/{supervisor-CQSu5XGl.js → supervisor-DA_nvF-h.js}

@@ -109,6 +109,13 @@ const DEFAULT_SUCCESSFUL_SHUTDOWN_MS = 5e3;
 const CHILD_DEADLINE_REASON = "child deadline exceeded";
 /** The abort reason the root's budget deadline cascades to every node. */
 const ROOT_DEADLINE_REASON = "root budget deadline exceeded";
+/**
+* How long an abort waits for a manager whose result was already accepted to end the turn that
+* submitted it. Acceptance asks the turn's harness to stop; what remains is the turn's final
+* session copy (a bounded native capture), metering its usage and committing its result. Its
+* workspace capture is not part of it: the manager's owner runs that after the result.
+*/
+const ACCEPTED_RESULT_GRACE_MS = 5 * 6e4;
 /** Whether an abort reason is a deadline: the child's own or the root budget's. */
 function isDeadlineAbortReason(reason) {
 	return reason === "child deadline exceeded" || reason === "root budget deadline exceeded";
@@ -1809,6 +1816,7 @@ function mapSandboxToolEvent(event, state) {
 		if (String(part.type ?? "") !== "tool") return [];
 		return projectToolPart(part, state, typeof event.id === "string" ? event.id : void 0);
 	}
+	if (CANONICAL_STREAM_EVENT_TYPES.has(type)) return [];
 	if (type.includes("tool")) {
 		const callId = pickString(data, [
 			"toolCallId",
@@ -7335,6 +7343,7 @@ function nativeSlots(port) {
 	}
 	return key;
 }
+const capturesInFlight = /* @__PURE__ */ new WeakMap();
 async function withCaptureSlot(port, signal, capture) {
 	if (port.maxConcurrentCaptures === void 0) return capture();
 	let group = captureGroups.get(port);
@@ -7351,13 +7360,56 @@ async function withCaptureSlot(port, signal, capture) {
 		permit.release();
 	}
 }
+/** Count one capture of `port` in flight until `work` settles, and say how many were ahead. */
+function trackCapture(port, work) {
+	const ahead = capturesInFlight.get(port) ?? 0;
+	capturesInFlight.set(port, ahead + 1);
+	return work(ahead).finally(() => {
+		capturesInFlight.set(port, Math.max(0, (capturesInFlight.get(port) ?? 1) - 1));
+	});
+}
 /**
 * Capture, require durable refs, and verify every returned manifest/archive byte.
 * `native` calls {@link ProviderWorkspaceRetentionPort.captureNative} under its own queue and
-* bound, and judges coverage by the sessions alone.
+* bound, and judges coverage by the sessions alone. `onTiming` receives the queue wait and the
+* capture time of a workspace capture once it settles, whether it succeeded or failed.
 */
-async function captureProviderWorkspaceSnapshot(port, context, scope = "environment") {
+async function captureProviderWorkspaceSnapshot(port, context, scope = "environment", onTiming) {
 	assertProviderWorkspaceRetentionPort(port, "provider workspace retention");
+	if (scope === "native" || onTiming === void 0) return await captureWithinSlot(port, context, scope);
+	return await trackCapture(port, async (ahead) => {
+		const requestedAt = Date.now();
+		let grantedAt;
+		const report = (timing) => {
+			const settledAt = Date.now();
+			try {
+				onTiming({
+					ahead,
+					queuedMs: (grantedAt ?? settledAt) - requestedAt,
+					...grantedAt === void 0 ? {} : { captureMs: settledAt - grantedAt },
+					...timing
+				});
+			} catch {}
+		};
+		try {
+			const captured = await captureWithinSlot(port, context, scope, () => {
+				grantedAt = Date.now();
+			});
+			report({
+				outcome: "captured",
+				archiveBytes: captured.snapshot.archive.byteLength
+			});
+			return captured;
+		} catch (error) {
+			report({
+				outcome: "failed",
+				error: (error instanceof Error ? error.message : String(error)).slice(0, 1e3)
+			});
+			throw error;
+		}
+	});
+}
+async function captureWithinSlot(port, context, scope, onGranted) {
 	const native = scope === "native";
 	if (native && port.captureNative === void 0) throw new ValidationError$1("provider workspace retention: the port has no captureNative");
 	const timeoutMs = native ? port.nativeTimeoutMs ?? 12e4 : port.timeoutMs;
@@ -7367,6 +7419,7 @@ async function captureProviderWorkspaceSnapshot(port, context, scope = "environm
 	const clearDeadline = armDeadlineTimer(timeoutMs, () => controller.abort(/* @__PURE__ */ new Error(`provider workspace retention timed out after ${timeoutMs}ms`)), true);
 	try {
 		return await runAbortable(() => withCaptureSlot(native ? nativeSlots(port) : port, controller.signal, async () => {
+			onGranted?.();
 			const input = {
 				...context,
 				...controlRef === void 0 ? {} : { controlRef: Object.freeze({ ...controlRef }) },
@@ -8652,6 +8705,119 @@ function describeRetainedNativeStops(stops) {
 	}).join("; ");
 }
 //#endregion
+//#region src/runtime/supervise/executor-seams.ts
+function assertExactConfigKeys(value, allowed, context) {
+	const unknown = Object.keys(value).filter((key) => !allowed.has(key));
+	if (unknown.length > 0) throw new ValidationError$1(`${context}: unknown fields ${unknown.sort().join(", ")}; execution behavior belongs in AgentProfile`);
+}
+/** Narrow a named seam off the `ExecutorContext`, failing loud when absent — no
+*  silent default for a required external-boundary seam. */
+function readSeam(ctx, key, who) {
+	const seam = ctx.seams[key];
+	if (seam === void 0 || seam === null) throw new ValidationError$1(`${who} executor: missing required seam "${key}" on ExecutorContext`);
+	return seam;
+}
+function readOptionalAbortSignal(ctx, key, who) {
+	const value = ctx.seams[key];
+	if (value === void 0) return void 0;
+	if (value === null || typeof value !== "object" || typeof value.aborted !== "boolean" || typeof value.addEventListener !== "function") throw new ValidationError$1(`${who} executor: seam "${key}" must be an AbortSignal`);
+	return value;
+}
+/** Narrow the Runtime-owned MCP attachment seam. Absent means the run mounts nothing; a present
+*  value must be a named map of MCP servers, never an empty one that would silently mount nothing. */
+function readOptionalMcpAttachments(ctx, key, who) {
+	const value = ctx.seams[key];
+	if (value === void 0) return void 0;
+	const entries = value !== null && typeof value === "object" && !Array.isArray(value) ? Object.entries(value) : void 0;
+	if (entries === void 0 || entries.length === 0 || entries.some(([, server]) => server === null || typeof server !== "object")) throw new ValidationError$1(`${who} executor: seam ${JSON.stringify(key)} must be a non-empty map of MCP servers`);
+	return value;
+}
+//#endregion
+//#region src/runtime/supervise/bridge-config.ts
+const bridgeSeamKey = "bridge";
+/** Internal control seam used by Runtime-owned external supervisors. A completion request stops
+* the next bridge turn; it must not abort the paid request that is already streaming. */
+const bridgeStopSignalKey = "__bridge_stop_signal";
+/** Internal attachment seam used by Runtime-owned external supervisors. The named MCP servers ride
+* beside the AgentProfile as `runtime_attachments`, so the bridge mounts them for the run and keeps
+* them out of its session profile binding. A rebound coordination port therefore cannot move the
+* authored profile digest that binds a durable session. */
+const bridgeRuntimeAttachmentsKey = "__bridge_runtime_attachments";
+const maxBridgeTimeoutMs = 2147483647;
+function isLoopbackBridgeHost(hostname) {
+	const host = hostname.trim().toLowerCase().replace(/^\[/, "").replace(/\]$/, "");
+	if (host === "localhost" || host === "::1" || host === "0:0:0:0:0:0:0:1") return true;
+	if (host === "::ffff:127.0.0.1") return true;
+	return /^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/u.test(host);
+}
+function isLoopbackBridgeUrl(value) {
+	try {
+		const target = new URL(value);
+		return (target.protocol === "http:" || target.protocol === "https:") && isLoopbackBridgeHost(target.hostname);
+	} catch {
+		return false;
+	}
+}
+/** Validate and capture the non-serialisable credential service without reading its value. */
+function captureBridgeModelCredential(value, context) {
+	if (value === null || typeof value !== "object") throw new ValidationError$1(`${context}: modelCredential must be an object`);
+	assertExactConfigKeys(value, /* @__PURE__ */ new Set([
+		"baseUrlKey",
+		"key",
+		"provider"
+	]), `${context} modelCredential`);
+	if (typeof value.key !== "string" || value.key.trim().length === 0) throw new ValidationError$1(`${context}: modelCredential.key must be a non-empty string`);
+	if (typeof value.baseUrlKey !== "string" || value.baseUrlKey.trim().length === 0) throw new ValidationError$1(`${context}: modelCredential.baseUrlKey must be a non-empty string`);
+	if (value.baseUrlKey === value.key) throw new ValidationError$1(`${context}: modelCredential.baseUrlKey must differ from key`);
+	if (!value.provider || typeof value.provider.get !== "function") throw new ValidationError$1(`${context}: modelCredential.provider must implement get(name)`);
+	const captured = {
+		key: value.key,
+		baseUrlKey: value.baseUrlKey
+	};
+	Object.defineProperty(captured, "provider", {
+		configurable: false,
+		enumerable: false,
+		value: value.provider,
+		writable: false
+	});
+	return Object.freeze(captured);
+}
+function validateBridgeModelCredential(value, bridgeUrl, context) {
+	if (value === void 0) return void 0;
+	if (!isLoopbackBridgeUrl(bridgeUrl)) throw new ValidationError$1(`${context}: modelCredential is allowed only for a loopback bridge URL`);
+	return captureBridgeModelCredential(value, context);
+}
+function resolveProtectedModelBaseUrl(value, context) {
+	let target;
+	try {
+		target = new URL(value);
+	} catch {
+		throw new ValidationError$1(`${context}: modelCredential.baseUrl must be an absolute HTTPS URL`);
+	}
+	if (target.protocol !== "https:" || target.username || target.password || target.search || target.hash) throw new ValidationError$1(`${context}: modelCredential.baseUrl must be an HTTPS URL without credentials, query, or fragment`);
+	return target.toString().replace(/\/$/u, "");
+}
+/** Resolve only at the outbound boundary. Provider errors are redacted because they may contain
+*  the protected value; diagnostics identify key names, never values or provider errors. */
+async function resolveBridgeModelCredential(credential, context) {
+	if (credential === void 0) return void 0;
+	const resolveValue = async (key) => {
+		let value;
+		try {
+			value = await credential.provider.get(key);
+		} catch {
+			throw new ValidationError$1(`${context}: modelCredential provider failed for '${key}'`);
+		}
+		if (typeof value !== "string" || value.length === 0 || /[\r\n\0]/u.test(value)) throw new ValidationError$1(`${context}: modelCredential provider has no usable value for '${key}'`);
+		return value;
+	};
+	const [token, baseUrl] = await Promise.all([resolveValue(credential.key), resolveValue(credential.baseUrlKey)]);
+	return {
+		token,
+		baseUrl: resolveProtectedModelBaseUrl(baseUrl, context)
+	};
+}
+//#endregion
 //#region src/runtime/supervise/cost-estimate.ts
 /**
 * Pricing for work that arrived without a provider receipt.
@@ -10204,6 +10370,7 @@ const outsideKinds = /* @__PURE__ */ new Set([
 	"workspace-checkpoint",
 	"workspace-checkpoint-cleanup",
 	"workspace-restored",
+	"workspace-capture",
 	"trace-unpropagated",
 	"paused",
 	"driver-attempt",
@@ -10280,6 +10447,7 @@ async function replaySpawnTree(journal, blobs, root) {
 		if (ev.kind === "workspace-checkpoint") continue;
 		if (ev.kind === "workspace-checkpoint-cleanup") continue;
 		if (ev.kind === "workspace-restored") continue;
+		if (ev.kind === "workspace-capture") continue;
 		if (ev.kind === "trace-unpropagated") continue;
 		if (ev.kind === "paused") continue;
 		if (ev.kind === "driver-attempt") continue;
@@ -10622,6 +10790,18 @@ function executorEvidenceWriter(args) {
 		});
 	};
 }
+/** @internal The journal writer for `onWorkspaceCapture`; `nextSequence` is the node's own. */
+function workspaceCaptureWriter(args) {
+	return async (capture) => {
+		await args.journal.appendEvent(args.rootId, {
+			kind: "workspace-capture",
+			id: args.nodeId,
+			...detachedSnapshot(capture, "workspace capture timing"),
+			seq: args.nextSequence(),
+			at: new Date(args.now()).toISOString()
+		});
+	};
+}
 function retainedExecutorContext(ctx) {
 	return ctx.seams[retainedExecutorSeamKey];
 }
@@ -11286,6 +11466,18 @@ function createProviderExecutor(provider, profile, ctx, options, placement) {
 	let pending = false;
 	let harnessTranscript = harnessTranscriptUnavailable("execution-never-started");
 	const retention = retainedExecutorContext(ctx);
+	const managerStop = readOptionalAbortSignal(ctx, bridgeStopSignalKey, "provider");
+	const cancelRetainedOnManagerStop = (handle) => {
+		if (managerStop === void 0) return;
+		const cancel = () => {
+			handle.cancel({
+				operationId: `manager-stop:${randomUUID()}`,
+				reason: String(managerStop.reason ?? "the manager stopped")
+			}).catch(() => void 0);
+		};
+		if (managerStop.aborted) cancel();
+		else managerStop.addEventListener("abort", cancel, { once: true });
+	};
 	let destroyed = false;
 	let workspaceEnvironmentId;
 	let workspaceSnapshot;
@@ -11378,7 +11570,19 @@ function createProviderExecutor(provider, profile, ctx, options, placement) {
 				profile: createProfile,
 				...outcome === void 0 ? {} : { outcome }
 			};
-			workspaceCapturePromise = (nativeInFlight ?? Promise.resolve()).then(() => captureProviderWorkspaceSnapshot(workspaceRetention, captureContext)).then(({ snapshot, provenance, coverageComplete, incompleteReason }) => {
+			const reportTiming = retention?.onWorkspaceCapture;
+			let timing;
+			const capturedExecutionId = workspaceExecutionId;
+			workspaceCapturePromise = (nativeInFlight ?? Promise.resolve()).then(() => captureProviderWorkspaceSnapshot(workspaceRetention, captureContext, "environment", reportTiming === void 0 ? void 0 : (measured) => {
+				timing = measured;
+			})).finally(async () => {
+				if (timing === void 0 || reportTiming === void 0) return;
+				await reportTiming({
+					executionId: capturedExecutionId,
+					environmentId: next.id,
+					...timing
+				}).catch(() => void 0);
+			}).then(({ snapshot, provenance, coverageComplete, incompleteReason }) => {
 				workspaceSnapshot = snapshot;
 				workspaceProvenance = provenance;
 				workspaceCoverageComplete = coverageComplete ?? false;
@@ -11695,10 +11899,12 @@ function createProviderExecutor(provider, profile, ctx, options, placement) {
 					...carried === void 0 ? {} : { carried },
 					executionStartedAt,
 					mayContinue: options.unavailablePause !== false && invocation.retention?.continueInvocation !== void 0,
+					managerStopped: () => managerStop?.aborted === true,
 					onRetained: (handle) => {
 						retained = handle;
 						workspaceControlRef = freezeControlRef(handle.controlRef);
 						providerSessionId = workspaceControlRef.sessionId;
+						cancelRetainedOnManagerStop(handle);
 					},
 					onPending: (value) => {
 						pending = value;
@@ -11978,6 +12184,19 @@ async function* streamProviderExecutor(args) {
 	let failure;
 	let failed = false;
 	let unavailable;
+	let finalCopyTaken = false;
+	const ownerTakesCapture = () => args.options.workspaceRetention?.captureNative !== void 0 && args.createProfile.harness !== void 0 && source.retained && args.retention?.preserveEnvironment === true && args.retention.onEndOfTurnWork !== void 0;
+	const handCaptureToOwner = (reported, captureOutcome, publish) => {
+		args.retention?.onEndOfTurnWork?.(args.captureWorkspace(environment, captureOutcome).then(async (snapshot) => {
+			if (publish) args.onPublishedSnapshot(snapshot);
+			if (snapshot === void 0) return;
+			await args.retention?.onEvidence?.({
+				...reported,
+				workspaceSnapshot: snapshot,
+				workspaceCapture: providerWorkspaceCaptureReceipt(args, environment, snapshot, turn.sessionId ?? null)
+			});
+		}, () => void 0));
+	};
 	let harnessStop;
 	const stopEndedHarness = () => {
 		if (settled !== void 0 || !linked.aborted) return Promise.resolve();
@@ -12058,14 +12277,17 @@ async function* streamProviderExecutor(args) {
 			box: environmentAsSandboxInstance(environment, { requireTerminalEvent: args.options.requireTerminalEvent ?? true }),
 			signal: linked
 		});
+		const deferCapture = ownerTakesCapture() && args.managerStopped();
 		let retainedWorkspace;
 		let workspaceCaptureFailure;
-		try {
-			retainedWorkspace = await args.captureWorkspace(environment, outcome);
-		} catch (error) {
-			workspaceCaptureFailure = `${errorText(error instanceof Error ? error.message : error)}; source environment preserved`;
+		if (!deferCapture) {
+			try {
+				retainedWorkspace = await args.captureWorkspace(environment, outcome);
+			} catch (error) {
+				workspaceCaptureFailure = `${errorText(error instanceof Error ? error.message : error)}; source environment preserved`;
+			}
+			args.onPublishedSnapshot(retainedWorkspace);
 		}
-		args.onPublishedSnapshot(retainedWorkspace);
 		const settledResult = {
 			...result,
 			...workspaceCaptureFailure === void 0 ? {} : { workspaceCaptureFailure },
@@ -12099,6 +12321,11 @@ async function* streamProviderExecutor(args) {
 		else if (retainedWorkspace !== void 0) await args.retention?.onEvidence?.(settledResult);
 		args.onPending(false);
 		args.onArtifact(settled);
+		if (deferCapture) {
+			await args.finishNativeMirror(environment, "settled");
+			finalCopyTaken = true;
+			handCaptureToOwner(settledResult, outcome, true);
+		}
 	} catch (error) {
 		failure = source.retained ? new RetainedExecutionPendingError(error) : error;
 		failed = true;
@@ -12112,7 +12339,14 @@ async function* streamProviderExecutor(args) {
 		await stopEndedHarness();
 		if (linked.aborted) await args.finishNativeMirror(environment, "failed");
 		args.onTranscriptSettled();
-		try {
+		if (ownerTakesCapture()) {
+			if (!linked.aborted) await args.finishNativeMirror(environment, "failed");
+			finalCopyTaken = true;
+			handCaptureToOwner({
+				...resultFromEvents(archive.events(), text),
+				outcome: failureOutcome
+			}, failureOutcome, false);
+		} else try {
 			const retainedWorkspace = await args.captureWorkspace(environment, failureOutcome);
 			if (retainedWorkspace !== void 0 && args.retention?.onEvidence !== void 0) await args.retention.onEvidence({
 				...resultFromEvents(archive.events(), text),
@@ -12127,7 +12361,7 @@ async function* streamProviderExecutor(args) {
 		if (args.options.workspaceRetention === void 0) args.onHarnessTranscript(await captureHarnessTranscript(environment, args.profile.harness, linked));
 	} finally {
 		await stopEndedHarness();
-		await args.finishNativeMirror(environment, failed ? "failed" : settled !== void 0 ? "settled" : "interrupted");
+		if (!finalCopyTaken) await args.finishNativeMirror(environment, failed ? "failed" : settled !== void 0 ? "settled" : "interrupted");
 		if ((!source.retained || settled !== void 0 && !failed) && !(source.retained && args.retention?.preserveEnvironment) && !(unavailable !== void 0 && !failed) && (args.options.destroyOnSettle ?? true)) {
 			const cleanup = await args.destroyEnvironment();
 			if (!cleanup.destroyed) {
@@ -13277,6 +13511,14 @@ async function runBrainLoop(opts) {
 				role: "assistant",
 				content: r.content
 			});
+			const next = maxTurns === 0 || turn < maxTurns ? await opts.hooks?.afterFinal?.(turn) : void 0;
+			if (next !== void 0) {
+				messages.push({
+					role: "user",
+					content: next
+				});
+				continue;
+			}
 			return {
 				final: lastText,
 				turns: turn,
@@ -15617,119 +15859,6 @@ function sandboxToolCalls(events) {
 	}] : []));
 }
 //#endregion
-//#region src/runtime/supervise/executor-seams.ts
-function assertExactConfigKeys(value, allowed, context) {
-	const unknown = Object.keys(value).filter((key) => !allowed.has(key));
-	if (unknown.length > 0) throw new ValidationError$1(`${context}: unknown fields ${unknown.sort().join(", ")}; execution behavior belongs in AgentProfile`);
-}
-/** Narrow a named seam off the `ExecutorContext`, failing loud when absent — no
-*  silent default for a required external-boundary seam. */
-function readSeam(ctx, key, who) {
-	const seam = ctx.seams[key];
-	if (seam === void 0 || seam === null) throw new ValidationError$1(`${who} executor: missing required seam "${key}" on ExecutorContext`);
-	return seam;
-}
-function readOptionalAbortSignal(ctx, key, who) {
-	const value = ctx.seams[key];
-	if (value === void 0) return void 0;
-	if (value === null || typeof value !== "object" || typeof value.aborted !== "boolean" || typeof value.addEventListener !== "function") throw new ValidationError$1(`${who} executor: seam "${key}" must be an AbortSignal`);
-	return value;
-}
-/** Narrow the Runtime-owned MCP attachment seam. Absent means the run mounts nothing; a present
-*  value must be a named map of MCP servers, never an empty one that would silently mount nothing. */
-function readOptionalMcpAttachments(ctx, key, who) {
-	const value = ctx.seams[key];
-	if (value === void 0) return void 0;
-	const entries = value !== null && typeof value === "object" && !Array.isArray(value) ? Object.entries(value) : void 0;
-	if (entries === void 0 || entries.length === 0 || entries.some(([, server]) => server === null || typeof server !== "object")) throw new ValidationError$1(`${who} executor: seam ${JSON.stringify(key)} must be a non-empty map of MCP servers`);
-	return value;
-}
-//#endregion
-//#region src/runtime/supervise/bridge-config.ts
-const bridgeSeamKey = "bridge";
-/** Internal control seam used by Runtime-owned external supervisors. A completion request stops
-* the next bridge turn; it must not abort the paid request that is already streaming. */
-const bridgeStopSignalKey = "__bridge_stop_signal";
-/** Internal attachment seam used by Runtime-owned external supervisors. The named MCP servers ride
-* beside the AgentProfile as `runtime_attachments`, so the bridge mounts them for the run and keeps
-* them out of its session profile binding. A rebound coordination port therefore cannot move the
-* authored profile digest that binds a durable session. */
-const bridgeRuntimeAttachmentsKey = "__bridge_runtime_attachments";
-const maxBridgeTimeoutMs = 2147483647;
-function isLoopbackBridgeHost(hostname) {
-	const host = hostname.trim().toLowerCase().replace(/^\[/, "").replace(/\]$/, "");
-	if (host === "localhost" || host === "::1" || host === "0:0:0:0:0:0:0:1") return true;
-	if (host === "::ffff:127.0.0.1") return true;
-	return /^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/u.test(host);
-}
-function isLoopbackBridgeUrl(value) {
-	try {
-		const target = new URL(value);
-		return (target.protocol === "http:" || target.protocol === "https:") && isLoopbackBridgeHost(target.hostname);
-	} catch {
-		return false;
-	}
-}
-/** Validate and capture the non-serialisable credential service without reading its value. */
-function captureBridgeModelCredential(value, context) {
-	if (value === null || typeof value !== "object") throw new ValidationError$1(`${context}: modelCredential must be an object`);
-	assertExactConfigKeys(value, /* @__PURE__ */ new Set([
-		"baseUrlKey",
-		"key",
-		"provider"
-	]), `${context} modelCredential`);
-	if (typeof value.key !== "string" || value.key.trim().length === 0) throw new ValidationError$1(`${context}: modelCredential.key must be a non-empty string`);
-	if (typeof value.baseUrlKey !== "string" || value.baseUrlKey.trim().length === 0) throw new ValidationError$1(`${context}: modelCredential.baseUrlKey must be a non-empty string`);
-	if (value.baseUrlKey === value.key) throw new ValidationError$1(`${context}: modelCredential.baseUrlKey must differ from key`);
-	if (!value.provider || typeof value.provider.get !== "function") throw new ValidationError$1(`${context}: modelCredential.provider must implement get(name)`);
-	const captured = {
-		key: value.key,
-		baseUrlKey: value.baseUrlKey
-	};
-	Object.defineProperty(captured, "provider", {
-		configurable: false,
-		enumerable: false,
-		value: value.provider,
-		writable: false
-	});
-	return Object.freeze(captured);
-}
-function validateBridgeModelCredential(value, bridgeUrl, context) {
-	if (value === void 0) return void 0;
-	if (!isLoopbackBridgeUrl(bridgeUrl)) throw new ValidationError$1(`${context}: modelCredential is allowed only for a loopback bridge URL`);
-	return captureBridgeModelCredential(value, context);
-}
-function resolveProtectedModelBaseUrl(value, context) {
-	let target;
-	try {
-		target = new URL(value);
-	} catch {
-		throw new ValidationError$1(`${context}: modelCredential.baseUrl must be an absolute HTTPS URL`);
-	}
-	if (target.protocol !== "https:" || target.username || target.password || target.search || target.hash) throw new ValidationError$1(`${context}: modelCredential.baseUrl must be an HTTPS URL without credentials, query, or fragment`);
-	return target.toString().replace(/\/$/u, "");
-}
-/** Resolve only at the outbound boundary. Provider errors are redacted because they may contain
-*  the protected value; diagnostics identify key names, never values or provider errors. */
-async function resolveBridgeModelCredential(credential, context) {
-	if (credential === void 0) return void 0;
-	const resolveValue = async (key) => {
-		let value;
-		try {
-			value = await credential.provider.get(key);
-		} catch {
-			throw new ValidationError$1(`${context}: modelCredential provider failed for '${key}'`);
-		}
-		if (typeof value !== "string" || value.length === 0 || /[\r\n\0]/u.test(value)) throw new ValidationError$1(`${context}: modelCredential provider has no usable value for '${key}'`);
-		return value;
-	};
-	const [token, baseUrl] = await Promise.all([resolveValue(credential.key), resolveValue(credential.baseUrlKey)]);
-	return {
-		token,
-		baseUrl: resolveProtectedModelBaseUrl(baseUrl, context)
-	};
-}
-//#endregion
 //#region src/runtime/codex-rollout-store.ts
 const zeroCounters = {
 	input: 0,
@@ -17613,11 +17742,20 @@ function renderPeerMail(message, nonce) {
 function createInbox() {
 	const pending = [];
 	let live = null;
+	let waiters = [];
 	return {
+		nextDelivery() {
+			return new Promise((resolve) => {
+				waiters.push(resolve);
+			});
+		},
 		deliver(msg) {
 			const m = parseDown(msg);
 			if (!m) return false;
 			pending.push(m);
+			const woken = waiters;
+			waiters = [];
+			for (const wake of woken) wake();
 			if (m.interrupt && live && !live.signal.aborted) live.abort();
 			return true;
 		},
@@ -23245,6 +23383,18 @@ function registerScopeRetainedOwner(scope, args) {
 				nextSequence: () => state.nextSequence(),
 				now: args.now
 			}),
+			onWorkspaceCapture: workspaceCaptureWriter({
+				journal: args.journal,
+				rootId: args.rootId,
+				nodeId: args.nodeId,
+				nextSequence: () => state.nextSequence(),
+				now: args.now
+			}),
+			onEndOfTurnWork: (work) => {
+				const prior = state.turnEnd;
+				const settled = work.catch(() => void 0);
+				state.turnEnd = prior === void 0 ? settled : Promise.all([prior, settled]).then(() => {});
+			},
 			onResult: async (result) => {
 				scope.signal.throwIfAborted();
 				assertValidSpend(result.spent, "retained owner result");
@@ -23475,7 +23625,14 @@ async function checkpointHandle(state, sourceEnvironmentId, signal) {
 		return;
 	}
 }
-/** An aborted observation cannot prove that the provider never created a snapshot. */
+/**
+* An aborted observation cannot prove that the provider never created a snapshot, so a request
+* whose lookup does not find it keeps its source alive for a later lookup, with one exception: a
+* provider that answers `not_found` for a request older than {@link WORKSPACE_CHECKPOINT_ABSENT_AFTER_MS}
+* never created it. No operation that request started can still be in flight, and keeping the
+* source then holds a sandbox for nothing: on Discovery Lab runs terraform-economics-20261005e and
+* f, each root was kept after its run settled over requests made hours earlier.
+*/
 async function reconcileCheckpointRequests(state, events) {
 	const operationKey = (operation) => JSON.stringify([operation.idempotencyKey, operation.requestDigest]);
 	const resolved = new Set(events.flatMap((event) => event.kind === "workspace-checkpoint" && event.id === state.args.nodeId && event.provider === state.provider?.name ? [operationKey(event.checkpoint)] : []));
@@ -23490,7 +23647,29 @@ async function reconcileCheckpointRequests(state, events) {
 				idempotencyKey: event.request.idempotencyKey,
 				requestDigest: event.request.requestDigest
 			}, { signal }), signal, "retained owner checkpoint lookup timed out");
-			if (result.status !== "found" || !workspaceCheckpointResultMatchesRequest(event.request, result)) throw new Error("checkpoint operation outcome is unresolved");
+			if (result.status === "not_found") {
+				const requestedAt = Date.parse(event.at);
+				if (Number.isFinite(requestedAt) && state.args.now() - requestedAt >= 12e5) continue;
+				unconfirmed.push({
+					event,
+					reason: "lookup not_found while the request may be in flight"
+				});
+				continue;
+			}
+			if (result.status !== "found") {
+				unconfirmed.push({
+					event,
+					reason: `lookup ${result.status}${"message" in result && result.message ? `: ${result.message}` : ""}`
+				});
+				continue;
+			}
+			if (!workspaceCheckpointResultMatchesRequest(event.request, result)) {
+				unconfirmed.push({
+					event,
+					reason: "lookup found a checkpoint for another request"
+				});
+				continue;
+			}
 			const recovered = {
 				kind: "workspace-checkpoint",
 				id: event.id,
@@ -23503,8 +23682,11 @@ async function reconcileCheckpointRequests(state, events) {
 			};
 			await state.args.journal.appendEvent(state.args.rootId, recovered);
 			events.push(recovered);
-		} catch {
-			unconfirmed.push(event);
+		} catch (error) {
+			unconfirmed.push({
+				event,
+				reason: `lookup failed: ${errorText(error instanceof Error ? error.message : error)}`
+			});
 		}
 	}
 	return unconfirmed;
@@ -23582,16 +23764,94 @@ async function scopeRetainedOwnerRestorePoint(scope) {
 function retainedOwnerReleaseRetriable(scope) {
 	return owners.get(scope)?.releaseRetriable ?? false;
 }
-/** The existing scope settlement barrier releases the owner's environment after all its turns. */
-async function releaseScopeRetainedOwnerEnvironment(scope) {
+/**
+* Mark one drive of the owner in progress until the returned function is called. An abort settles
+* the node while the drive is still ending its turn: stopping the harness, copying its session and
+* handing its workspace capture over. A release that ran then would find no receipt for the turn
+* and keep the source alive, as on terraform-economics-20261005f, where the root's last attempt was
+* recorded two minutes after its environment's release.
+*/
+function beginScopeRetainedOwnerDrive(scope) {
 	const state = owners.get(scope);
-	if (!state?.provider) return [];
-	const { provider, args } = state;
+	if (state === void 0) return () => {};
+	let end;
+	const drive = new Promise((resolve) => {
+		end = resolve;
+	});
+	state.drive = drive;
+	return () => {
+		end();
+		if (state.drive === drive) delete state.drive;
+	};
+}
+/** Wait, bounded like a turn's own ending, for the owner's drive in progress to end. */
+async function ownerDriveEnded(state) {
+	const drive = state.drive;
+	if (drive === void 0) return;
+	let timer;
+	try {
+		await Promise.race([drive, new Promise((resolve) => {
+			timer = setTimeout(resolve, HARNESS_TRANSCRIPT_SETTLE_TIMEOUT_MS);
+		})]);
+	} finally {
+		if (timer !== void 0) clearTimeout(timer);
+	}
+}
+/**
+* Wait for the end-of-turn work the owner's last turn handed over: its workspace capture and the
+* evidence record of its receipt. A turn hands it over so that its node settles without it; the
+* owner's next turn and its environment's release wait for it here.
+*/
+async function scopeRetainedOwnerTurnEnded(scope) {
+	const state = owners.get(scope);
+	if (state === void 0) return;
+	for (;;) {
+		const pending = state.turnEnd;
+		if (pending === void 0) return;
+		await pending;
+		if (state.turnEnd === pending) {
+			delete state.turnEnd;
+			return;
+		}
+	}
+}
+/** @internal Wait for everything this owner still has in flight: the drive ending its turn, the
+*  work that turn handed over, and a release. */
+async function scopeRetainedOwnerSettled(scope) {
+	const state = owners.get(scope);
+	if (state === void 0) return;
+	await ownerDriveEnded(state);
+	await scopeRetainedOwnerTurnEnded(scope);
+	await state.releasing?.catch(() => void 0);
+}
+/**
+* Release the owner's environment once no turn of it will run again: at the run's final
+* settlement for the root, and when a nested manager's own scope has finished. A second call while
+* one is in flight joins it. The release first waits for the end-of-turn capture of the owner's
+* last turn, so the capture always precedes the destroy.
+*/
+function releaseScopeRetainedOwnerEnvironment(scope) {
+	const state = owners.get(scope);
+	const provider = state?.provider;
+	if (state === void 0 || provider === void 0) return Promise.resolve([]);
+	if (state.releasing !== void 0) return state.releasing;
+	const tracked = (async () => {
+		await ownerDriveEnded(state);
+		await scopeRetainedOwnerTurnEnded(scope);
+		return await releaseOwnerEnvironment(state, provider);
+	})().finally(() => {
+		if (state.releasing === tracked) delete state.releasing;
+	});
+	state.releasing = tracked;
+	return tracked;
+}
+async function releaseOwnerEnvironment(state, provider) {
+	const { args } = state;
 	state.checkpointsUnavailable ??= "released";
 	await state.checkpointing?.catch(() => void 0);
 	const events = [...await args.journal.loadTree(args.rootId) ?? []];
 	const requestFailures = await reconcileCheckpointRequests(state, events);
-	const pendingSources = new Set(requestFailures.map((event) => event.environmentId));
+	const pendingSources = new Set(requestFailures.map(({ event }) => event.environmentId));
 	const released = new Set(events.flatMap((event) => event.kind === "environment-teardown" && event.id === args.nodeId && event.provider === provider.name && event.destroyed ? [event.environmentId] : []));
 	const environments = new Set(events.flatMap((event) => event.id === args.nodeId && event.kind === "execution-admitted" && event.admission.phase === "environment" ? [event.admission.environmentId] : []));
 	const retentionFailures = state.workspaceRetention || events.some((event) => event.kind === "execution-input" && event.id === args.nodeId && event.workspaceRetention === true) ? await ownerWorkspaceRetentionFailures(events, args.nodeId, args.blobs) : /* @__PURE__ */ new Set();
@@ -23674,12 +23934,12 @@ async function releaseScopeRetainedOwnerEnvironment(scope) {
 		runtime: provider.name,
 		status: "done",
 		detail: `checkpoint cleanup unconfirmed: ${event.checkpoint.checkpointId} from ${event.environmentId}`
-	})), ...requestFailures.map((event) => ({
+	})), ...requestFailures.map(({ event, reason }) => ({
 		id: args.nodeId,
 		label: "scope owner checkpoint request",
 		runtime: provider.name,
 		status: "done",
-		detail: `checkpoint request unresolved: ${event.request.idempotencyKey} from ${event.environmentId}`
+		detail: `checkpoint request unresolved: ${event.request.idempotencyKey} from ${event.environmentId} (${reason})`
 	}))];
 	return unconfirmed.length > 0 || preserved.length > 0 ? [{
 		id: args.nodeId,
@@ -23718,7 +23978,15 @@ function unsettledOwnerRuns(events, nodeId, environmentId) {
 	close();
 	return [...runs.values()];
 }
-/** Group owner admissions by input and require a verified workspace receipt before deletion. */
+/**
+* Group owner admissions by input and require a verified workspace receipt before deletion.
+*
+* The receipt is the attempt's committed result, or an evidence record of the same attempt: a
+* turn its manager stopped commits its result first and journals its capture as evidence after
+* it, and a turn that failed journals the capture it took of the stopped session. This runs only
+* at a release no process will resume, so a complete, verified capture of the exact execution is
+* the whole of what keeping the source would preserve.
+*/
 async function ownerWorkspaceRetentionFailures(events, nodeId, blobs) {
 	const attempts = [];
 	let current;
@@ -23726,30 +23994,26 @@ async function ownerWorkspaceRetentionFailures(events, nodeId, blobs) {
 		if (current !== void 0) attempts.push(current);
 		current = void 0;
 	};
+	const fresh = (executionId) => ({
+		...executionId === void 0 ? {} : { executionId },
+		environmentIds: /* @__PURE__ */ new Set(),
+		controlByEnvironment: /* @__PURE__ */ new Map(),
+		evidence: []
+	});
 	for (const event of events) {
 		if (!("id" in event) || event.id !== nodeId) continue;
 		if (event.kind === "execution-input") {
 			flush();
-			current = {
-				executionId: `${nodeId}:input:${event.seq}`,
-				environmentIds: /* @__PURE__ */ new Set(),
-				controlByEnvironment: /* @__PURE__ */ new Map()
-			};
+			current = fresh(`${nodeId}:input:${event.seq}`);
 		} else if (event.kind === "execution-admitted" && event.admission.phase === "environment") {
 			if (current?.result !== void 0) flush();
-			current ??= {
-				environmentIds: /* @__PURE__ */ new Set(),
-				controlByEnvironment: /* @__PURE__ */ new Map()
-			};
+			current ??= fresh();
 			current.environmentIds.add(event.admission.environmentId);
 		} else if (event.kind === "execution-admitted" && event.admission.phase === "dispatched") current?.controlByEnvironment.set(event.admission.controlRef.environmentId, event.admission.controlRef);
 		else if (event.kind === "execution-result") {
-			current ??= {
-				environmentIds: /* @__PURE__ */ new Set(),
-				controlByEnvironment: /* @__PURE__ */ new Map()
-			};
+			current ??= fresh();
 			current.result = event;
-		}
+		} else if (event.kind === "execution-evidence") current?.evidence.push(event);
 	}
 	flush();
 	const failures = /* @__PURE__ */ new Set();
@@ -23759,25 +24023,30 @@ async function ownerWorkspaceRetentionFailures(events, nodeId, blobs) {
 			for (const environmentId of attempt.environmentIds) failures.add(environmentId);
 			continue;
 		}
-		const result = attempt.result;
-		if (result === void 0) {
-			for (const environmentId of attempt.environmentIds) failures.add(environmentId);
-			continue;
-		}
-		let output;
-		try {
-			output = await blobs.get(result.outRef);
-			if (output === void 0 || contentAddress(output) !== result.outRef) throw new Error();
-		} catch {
-			output = void 0;
-		}
-		const snapshot = output !== null && typeof output === "object" ? output.workspaceSnapshot : void 0;
 		const environmentId = [...attempt.environmentIds][0];
 		const controlRef = attempt.controlByEnvironment.get(environmentId);
-		if (!hasDurableWorkspaceCapture(output, snapshot, environmentId, attempt.executionId, controlRef)) failures.add(environmentId);
+		const receipts = [...attempt.result === void 0 ? [] : [attempt.result.outRef], ...attempt.evidence.map((event) => event.outRef)];
+		let verified = false;
+		for (const outRef of receipts) {
+			const output = await storedOutput(blobs, outRef);
+			if (hasDurableWorkspaceCapture(output, output !== null && typeof output === "object" ? output.workspaceSnapshot : void 0, environmentId, attempt.executionId, controlRef)) {
+				verified = true;
+				break;
+			}
+		}
+		if (!verified) failures.add(environmentId);
 	}
 	return failures;
 }
+/** A stored output whose bytes match its content reference, or undefined. */
+async function storedOutput(blobs, outRef) {
+	try {
+		const output = await blobs.get(outRef);
+		return output === void 0 || contentAddress(output) !== outRef ? void 0 : output;
+	} catch {
+		return;
+	}
+}
 /** A stored result authorizes cleanup only for the exact source and complete capture. */
 function hasDurableWorkspaceCapture(output, snapshot, environmentId, executionId, controlRef) {
 	const parsed = agentCandidateWorkspaceSnapshotEvidenceSchema.safeParse(snapshot);
@@ -23993,13 +24262,12 @@ function consumeScopeRetainedOwnerResult(scope) {
 *               absolute `timeoutAtMs` passes (CI status, file existence, an HTTP probe, an
 *               inbox message).
 *
-* ── How this differs from `await_event`'s 45s poll fence (`DEFAULT_AWAIT_EVENT_TIMEOUT_MS`) ──
+* ── How this differs from a manager's wake (`./wake`) ──
 *
-* They look similar and are not the same mechanism. `await_event` is an IN-RUN RENDEZVOUS: the
-* driver blocks on the coordination bus for the next event from a live worker, and the 45s fence
-* exists only so a remote MCP request does not exceed the client's timeout — the caller re-polls.
-* Every re-poll is another driver inference turn (real tokens) against a process that must stay
-* up, and nothing about that wait is recorded: kill the process and the wait is simply gone.
+* They look similar and are not the same mechanism. A wake is an IN-RUN RENDEZVOUS: a manager
+* that ends its turn with work open is resumed when the coordination bus delivers its next event.
+* It costs no model turn, but it lives in a process that must stay up, and nothing about that
+* wait is recorded: kill the process and the wait is simply gone.
 *
 * A wait-state is a NODE, not a call. It has a node id in the tree, a journal record carrying its
 * ABSOLUTE deadline, and it settles through the same `Scope.next()` cursor as any worker. Nobody
@@ -24191,6 +24459,10 @@ const teardownRetriable = /* @__PURE__ */ new WeakMap();
 const ownerUnconfirmedByScope = /* @__PURE__ */ new WeakMap();
 /** The scope a recursive executor owns, so the settlement retry reaches its descendants. */
 const nestedTeardownScopes = /* @__PURE__ */ new WeakMap();
+/** Each scope's reader of the manager scopes its children own, read live. */
+const nestedManagerScopeReaders = /* @__PURE__ */ new WeakMap();
+/** A manager scope's release of its own environment, started once and joined by later callers. */
+const managerEnvironmentReleases = /* @__PURE__ */ new WeakMap();
 /** Scopes whose settlement released retained environments: none of their retained children is
 *  kept for a resume any longer. */
 const releasingScopes = /* @__PURE__ */ new WeakSet();
@@ -24268,9 +24540,47 @@ async function releaseRetainedEnvironments(scope) {
 	releasingScopes.add(scope);
 	const release = retainedReleasers.get(scope);
 	if (release) await release();
+	await releaseNestedManagerEnvironments(scope);
 	ownerUnconfirmedByScope.set(scope, await releaseScopeRetainedOwnerEnvironment(scope));
 	return unconfirmedTeardowns(scope);
 }
+/** The manager scopes this scope's children own, read live. */
+function nestedManagerScopes(scope) {
+	return nestedManagerScopeReaders.get(scope)?.() ?? [];
+}
+async function releaseNestedManagerEnvironments(scope) {
+	await Promise.all(nestedManagerScopes(scope).map(async (nested) => {
+		await releaseNestedManagerEnvironments(nested);
+		if (!ownerUnconfirmedByScope.has(nested)) await releaseManagerEnvironment(nested);
+	}));
+}
+/**
+* @internal Release the environment a manager kept between its turns, once its own scope has
+* finished and no turn of it will run again. The release first waits for the manager's last
+* end-of-turn capture, so it runs in the background of the manager's settlement; a later call,
+* including the run's settlement sweep, joins it. Its receipt is journaled in the manager's own
+* tree. It is the manager's own resource, not one of its descendants, so it never changes the
+* teardown answer its executor gives the parent.
+*/
+function releaseManagerEnvironment(scope) {
+	let release = managerEnvironmentReleases.get(scope);
+	if (release === void 0) {
+		release = releaseScopeRetainedOwnerEnvironment(scope).then(() => void 0);
+		managerEnvironmentReleases.set(scope, release);
+	}
+	return release;
+}
+/**
+* @internal Wait for the work every manager in this scope's tree still has in flight after its
+* node settled: the end-of-turn capture its last turn handed over, and the release of its
+* environment. The run's settlement awaits it under either retention policy, so nothing writes to
+* the run's journal after the run settles and no capture is cut short by the process exiting.
+*/
+async function settleManagerWork(scope) {
+	await Promise.all(nestedManagerScopes(scope).map((nested) => settleManagerWork(nested)));
+	await scopeRetainedOwnerSettled(scope);
+	await managerEnvironmentReleases.get(scope)?.catch(() => void 0);
+}
 /**
 * @internal Close the cursor slot of every retained child this scope and its nested scopes still
 * hold open, once the settlement is final and the release and its retries are done.
@@ -24694,6 +25004,14 @@ function createScope(args) {
 				}, "accepted retained child result");
 				live.recoveryPending = false;
 			});
+			let captureSeq = 0;
+			const onWorkspaceCapture = workspaceCaptureWriter({
+				journal: args.journal,
+				rootId: args.root,
+				nodeId: id,
+				nextSequence: () => captureSeq++,
+				now
+			});
 			const onPause = (pause) => retainedWrite(async () => {
 				await args.journal.appendEvent(args.root, {
 					kind: "paused",
@@ -24722,6 +25040,7 @@ function createScope(args) {
 					now
 				}),
 				onPause,
+				onWorkspaceCapture,
 				continueInvocation: async (nextTask) => {
 					controller.signal.throwIfAborted();
 					if (live.acceptedResult === void 0) throw new ValidationError$1("scope: a retained child continues only after its invocation committed a result");
@@ -24838,7 +25157,7 @@ function createScope(args) {
 				abortChild: (reason) => controller.abort(reason)
 			};
 			const recordCancellation = () => {
-				if (!live.executorDone && live.acceptedResult === void 0 && controller.signal.reason instanceof RunCancellationReason) live.cancellationReason = controller.signal.reason;
+				if (!live.executorDone && live.acceptedResult === void 0 && executor.resultAccepted?.() !== true && controller.signal.reason instanceof RunCancellationReason) live.cancellationReason = controller.signal.reason;
 			};
 			if (controller.signal.aborted) recordCancellation();
 			else controller.signal.addEventListener("abort", recordCancellation, { once: true });
@@ -25498,6 +25817,10 @@ function createScope(args) {
 		return child.ownedTreeRoot === void 0 || nested === void 0 || hasRetriableTeardowns(nested, true);
 	});
 	teardownRetriable.set(scope, (release) => retriableTeardowns().length > 0 || release && (releasable().length > 0 || retainedOwnerReleaseRetriable(scope)));
+	nestedManagerScopeReaders.set(scope, () => [...children.values()].flatMap((child) => {
+		const nested = child.readNestedScope?.();
+		return nested === void 0 ? [] : [nested];
+	}));
 	teardownRetriers.set(scope, async () => {
 		await Promise.all(retriableTeardowns().map((child) => {
 			child.teardownRetry ??= (async () => {
@@ -26261,7 +26584,7 @@ async function runChild(live, executor, childAbort, task, opts, pool, ticket, bl
 			const reconcileError = reconcileOnce(accounting?.reservation ?? terminalSpend);
 			if (reconcileError !== void 0) throw reconcileError;
 		} else {
-			const terminal = await retainOutput(await awaitAbortable(Promise.resolve(ran), childAbort.signal));
+			const terminal = await retainOutput(await awaitUnlessAccepted(Promise.resolve(ran), childAbort.signal, executor));
 			await executionEvidence.complete();
 			const accounting = executor.accounting?.();
 			live.spent = accounting?.reported ?? terminal.spent;
@@ -26275,7 +26598,7 @@ async function runChild(live, executor, childAbort, task, opts, pool, ticket, bl
 		const ownMetered = executor.metered?.();
 		const trace = await captureTraceOnce();
 		const childHarnessTranscript = await persistTranscriptOnce();
-		if (childAbort.signal.aborted && live.acceptedResult === void 0) {
+		if (childAbort.signal.aborted && live.acceptedResult === void 0 && executor.resultAccepted?.() !== true) {
 			await teardownOnce(opts.shutdown ?? "brutalKill");
 			return downRecord("aborted before settle", true, trace, ownMetered, runtimeOwnedExecutorProviderEvidence(executor), retainedOutputRef, childHarnessTranscript);
 		}
@@ -26667,6 +26990,19 @@ function preserveUnknownTelemetry(streamed, terminal) {
 		...(streamed.tokensProvenance ?? terminal.tokensProvenance) === void 0 ? {} : { tokensProvenance: streamed.tokensProvenance ?? terminal.tokensProvenance }
 	};
 }
+/**
+* Await a one-shot executor's terminal result unless an abort wins first, except for an execution
+* whose result was accepted before the abort arrived: it is ending the turn that submitted that
+* result, so it is awaited rather than discarded, and the executor bounds that wait itself.
+*/
+async function awaitUnlessAccepted(work, signal, executor) {
+	try {
+		return await awaitAbortable(work, signal);
+	} catch (error) {
+		if (signal.aborted && executor.resultAccepted?.() === true) return await work;
+		throw error;
+	}
+}
 async function awaitAbortable(work, signal) {
 	if (signal.aborted) {
 		work.catch(() => void 0);
@@ -26879,6 +27215,7 @@ const driverExecutorFactory = (rawSpec, ctx) => {
 		...spec.progress ? { progress: spec.progress } : {},
 		...spec.harnessTranscript ? { harnessTranscript: spec.harnessTranscript } : {},
 		...spec.harnessTranscriptSettled ? { harnessTranscriptSettled: spec.harnessTranscriptSettled } : {},
+		resultAccepted: () => driver.resultAccepted?.() === true,
 		...deliver ? { deliver(message) {
 			return deliver(message) !== false;
 		} } : {},
@@ -26901,8 +27238,15 @@ const driverExecutorFactory = (rawSpec, ctx) => {
 			if (recovering && (!spec.recoverExecutor || !seam.restore)) throw new RetainedExecutionPendingError(new ValidationError$1("driverExecutor: nested recovery has no original executor reconstruction"), "nested-recovery");
 			signal.throwIfAborted();
 			const controller = new AbortController();
-			const onParentAbort = () => controller.abort(signal.reason);
-			if (signal.aborted) controller.abort(signal.reason);
+			let clearAcceptedGrace;
+			const onParentAbort = () => {
+				if (driver.resultAccepted?.() === true) {
+					clearAcceptedGrace ??= armDeadlineTimer(ACCEPTED_RESULT_GRACE_MS, () => controller.abort(signal.reason));
+					return;
+				}
+				controller.abort(signal.reason);
+			};
+			if (signal.aborted) onParentAbort();
 			else signal.addEventListener("abort", onParentAbort, { once: true });
 			let nestedScope;
 			try {
@@ -26925,6 +27269,7 @@ const driverExecutorFactory = (rawSpec, ctx) => {
 				const out = await runAbortable(() => driver.act(task, nestedScope), controller.signal, "driver aborted");
 				await finalizeScopeOwnerMaterialization(nestedScope);
 				await closeActive("driver completed");
+				releaseManagerEnvironment(nestedScope).catch(() => void 0);
 				const events = await loadTreeEvents(journal, nestedRoot);
 				const childWork = sumSpend(events.filter(isSettled));
 				const totalMetered = sumMetered(events);
@@ -26955,6 +27300,7 @@ const driverExecutorFactory = (rawSpec, ctx) => {
 				throw err;
 			} finally {
 				signal.removeEventListener("abort", onParentAbort);
+				clearAcceptedGrace?.();
 				active = void 0;
 			}
 		},
@@ -27953,7 +28299,7 @@ var DriverAttemptsExhaustedError = class extends RuntimeRunStateError {
 function summarizeDriverAttempts(records) {
 	let barren = 0;
 	for (const record of records) if (record.madeProgress) barren = 0;
-	else if (record.error === void 0 && record.reentry !== void 0 && record.contract === "unmet") barren += 1;
+	else if (record.error === void 0 && record.reentry !== void 0 && record.reentry !== "wake" && record.contract === "unmet") barren += 1;
 	const last = records.at(-1);
 	const refused = records.filter((record) => record.classification === "unavailable");
 	return {
@@ -27963,6 +28309,8 @@ function summarizeDriverAttempts(records) {
 		unavailablePauses: refused.filter((record) => record.retryInMs !== void 0).length,
 		unavailableMs: refused.reduce((sum, record) => sum + (record.madeProgress ? 0 : record.durationMs) + (record.retryInMs ?? 0), 0),
 		barrenReentries: barren,
+		wakes: records.filter((record) => record.reentry === "wake").length,
+		waitedMs: records.reduce((sum, record) => sum + (record.waitedMs ?? 0), 0),
 		ended: last?.stop ?? "unrecorded",
 		...last?.repromptRefusedBy === void 0 ? {} : { repromptRefusedBy: last.repromptRefusedBy }
 	};
@@ -28005,6 +28353,7 @@ async function runDriverWithRetry(run) {
 	let consecutivePauses = 0;
 	let pauses = 0;
 	let continuations = 0;
+	let wakes = 0;
 	let reentry;
 	const emit = async (record) => {
 		const entered = reentry === void 0 ? {} : { reentry: reentry.reason };
@@ -28164,7 +28513,28 @@ async function runDriverWithRetry(run) {
 		const contract = contractOf(after);
 		const contractField = contract === "none" ? {} : { contract };
 		if (progressed) barrenReentries = 0;
-		else if (reentry !== void 0 && contract === "unmet") barrenReentries += 1;
+		else if (reentry !== void 0 && reentry.reason !== "wake" && contract === "unmet") barrenReentries += 1;
+		const wait = run.wait;
+		if (wait !== void 0 && contract !== "met" && !(continuation?.closed() ?? false) && !run.signal.aborted && budgetStop(run.budget(), now()) === void 0 && wait.open()) {
+			const woken = await wait.wake(attempt + 1);
+			if (woken !== void 0 && !run.signal.aborted) {
+				wakes += 1;
+				await emit({
+					attempt,
+					durationMs,
+					madeProgress: progressed,
+					...contractField,
+					waitedMs: woken.idleMs,
+					retryInMs: 0
+				});
+				reentry = {
+					reason: "wake",
+					input: woken.input,
+					wake: wakes
+				};
+				continue;
+			}
+		}
 		if (contract === "unmet" && continuation !== void 0) {
 			const decision = await decideContinuation(continuation, attempt, after);
 			if ("steer" in decision) {
@@ -28590,6 +28960,7 @@ function createSupervisor() {
 		task = input.task;
 		const rootAct = root.act.bind(root);
 		const rootDeliver = root.deliver?.bind(root);
+		const rootResultAccepted = root.resultAccepted?.bind(root);
 		const now = opts.now ?? Date.now;
 		assertRootIdentity(opts);
 		const rootLease = attached?.acquire();
@@ -28711,10 +29082,19 @@ function createSupervisor() {
 			});
 			let deadlineExceeded = false;
 			const rootDeadlineAtMs = pool.readout().deadlineMs;
-			if (rootDeadlineAtMs > 0 && now() >= rootDeadlineAtMs) deadlineExceeded = cascadeAbort(ROOT_DEADLINE_REASON);
-			const clearRootDeadline = opts.budget.deadlineMs === void 0 ? void 0 : armDeadlineTimer(Math.max(0, rootDeadlineAtMs - now()), () => {
+			let clearAcceptedGrace;
+			const reachRootDeadline = () => {
+				if (clearAcceptedGrace !== void 0) return;
+				if (rootResultAccepted?.() === true) {
+					clearAcceptedGrace = armDeadlineTimer(ACCEPTED_RESULT_GRACE_MS, () => {
+						deadlineExceeded = cascadeAbort(ROOT_DEADLINE_REASON);
+					});
+					return;
+				}
 				deadlineExceeded = cascadeAbort(ROOT_DEADLINE_REASON);
-			});
+			};
+			if (rootDeadlineAtMs > 0 && now() >= rootDeadlineAtMs) reachRootDeadline();
+			const clearRootDeadline = opts.budget.deadlineMs === void 0 ? void 0 : armDeadlineTimer(Math.max(0, rootDeadlineAtMs - now()), reachRootDeadline);
 			let actOutcome = {
 				ok: false,
 				error: new RuntimeRunStateError("supervisor: root execution did not start")
@@ -28741,9 +29121,11 @@ function createSupervisor() {
 				allChildrenDownAtSettle = allSpawnedChildrenDown(runTree(openScope));
 				if (!controller.signal.aborted && rootDeadlineAtMs > 0 && now() >= rootDeadlineAtMs) deadlineExceeded = true;
 				clearRootDeadline?.();
+				clearAcceptedGrace?.();
 				const settleGraceMs = !controller.signal.aborted ? boundedSettleGrace(opts.childSettleGraceMs, rootDeadlineAtMs, now) : 0;
 				try {
 					teardownUnconfirmed = await drainLiveChildren(openScope, controller, settleGraceMs);
+					await settleManagerWork(openScope);
 					if (!persistence.failed && retainedAtSettlement === "release") teardownUnconfirmed = await releaseRetainedEnvironments(openScope);
 					const confirmWindowMs = opts.teardownConfirmMs ?? DEFAULT_TEARDOWN_CONFIRM_MS;
 					const releasing = !persistence.failed && retainedAtSettlement === "release";
@@ -29315,6 +29697,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 { bindScopeRetainedOwnerProvider as $, detachedFrozen as $i, parseWorkerToolTraceArtifact as $n, sanitizeRuntimeStreamEvent as $r, isPeerMailEnvelope as $t, driverExecutorFactory as A, addResourceSpend as Aa, prepareJsonlAppend as Ai, resolveAgentEnvironmentProvider as An, contentAddress as Ar, createExecutor as At, recordScopeOwnerDriverAttempt as B, promptFromAgentTurnInput as Ba, newExecutionAttemptId as Bi, InMemoryResultBlobStore as Bn, buildRuntimeEventOtelSpans as Br, workerTraceEnv as Bt, createContinuationKeeper as C, sleep as Ca, renderProfileMaterializationIssues as Ci, readPromptOptions as Cn, runAbortable as Cr, freeSlots as Ct, passedItems as D, unmeteredSpend as Da, validateProfileMaterialization as Di, createAgentEnvironmentProviderRegistry as Dn, readHarnessTranscript as Dr, captureReusableExecutorConfig as Dt, failedItems as E, throwIfAborted as Ea, unsupportedProfileDimensions as Ei, LEAF_CONTINUATION_TASK as En, persistHarnessTranscript as Er, bindReusableExecutorExecutionId as Et, beginScopeOwnerAttempt as F, awaitAbortable$1 as Fa, authoredProfileDigest as Fi, sandboxSessionTraceSource as Fn, defaultRedactor as Fr, createSteerableSandboxSession as Ft, settledToIteration as G, runtimeOwnedExecutorMaterialization as Gi, insideCursorNamespace as Gn, loopEventToOtelSpan as Gr, createActivityLog as Gt, recordScopeOwnerPause as H, providerMessageText as Ha, recordRuntimeOwnedDriveHarnessProviderEvidence as Hi, SpawnEventIndex as Hn, createOtelExporter as Hr, workerTraceSeamKey as Ht, createScope as I, DEFAULT_SUCCESSFUL_SHUTDOWN_MS as Ia, finalizeRuntimeOwnedPendingExecutor as Ii, registerRetainedExecutorPreparation as In, defaultRedactorIdentityMaterial as Ir, createRouterTranscript as It, pollFor as J, runtimeOwnedScopeOwnerRuntime as Ji, pendingWaits as Jn, toOtelAttributes as Jr, AUTHORITY_MARKERS as Jt, createWaitProbes as K, runtimeOwnedExecutorProviderEvidence as Ki, loadSpawnForest as Kn, padSpanId as Kr, readWorkerProgress as Kt, deriveNodeExecutionIdentity as L, armDeadlineTimer as La, inheritRuntimeOwnedExecutorAttestation as Li, retainedExecutorSeamKey as Ln, resolveRedactor as Lr, createInPlaceCliExecutor as Lt, withDriverExecutor as M, withBudgetResources as Ma, writeAllBytes as Mi, unavailableSignalOfFailure as Mn, mergeTraceEnv as Mr, snapshotExecutorConfig as Mt, SUBTREE_RESULT_LIMIT as N, decodeHarnessUsage as Na, attestRuntimeOwnedPendingExecutor as Ni, createPushTraceSource as Nn, readTraceContextFromEnv as Nr, createWorktreeCliExecutor as Nt, verdictFromJudgeScore as O, withTimeout as Oa, worktreeCliProfileMaterialization as Oi, providerAsExecutor as On, resolveHarnessTranscriptCapture as Or, cliInPlaceExecutor as Ot, assertRecursiveReservationPolicy as P, abortError$2 as Pa, attestRuntimeOwnedScopeOwner as Pi, decodeToolPart as Pn, traceContextToEnv as Pr, DEFAULT_SANDBOX_STEERING_MAX_TURNS as Pt, bindScopeRetainedOwnerEnvironmentId as Q, executableAgentSpecSnapshot as Qi, isTraceAnalysisStore as Qn, sanitizeKnowledgeReadinessReport as Qr, createPeerMailbox as Qt, meterRuntimeOwnedAccounting as R, teardownExecutor as Ra, knownExecutionBindingReceipt as Ri, FileResultBlobStore as Rn, buildLoopOtelSpans as Rr, WORKER_TRACE_PROPAGATION as Rt, composeContinuationNote as S, randomSuffix as Sa, promptResourceProfileMaterialization as Si, assertBoxlessPromptOptions as Sn, linkAbort as Sr, startRetainedInteractiveRun as St, expandQuestions as T, throwAbort as Ta, sandboxActProfileMaterialization as Ti, runBrainLoop as Tn, harnessTranscriptArtifact as Tr, rollingDispatch as Tt, restoreScopeOwnerAcceptedExecution as U, runtimeOwnedDriveHarnessProviderEvidence as Ui, assertContentAddress as Un, flatOtelSpan as Ur, taskToPrompt as Ut, recordScopeOwnerMaterialization as V, promptOptionsFromAgentTurnInput as Va, providerAttemptEvidence as Vi, InMemorySpawnJournal as Vn, createOpenInferenceFileExporter as Vr, workerTraceHeaders as Vt, scopeOwnerExecutorNodeContext as W, runtimeOwnedExecutorExecutionBinding as Wi, encodeResultBlob as Wn, generateSpanId as Wr, DEFAULT_STALL_AFTER_MS as Wt, validateWaitSpec as X, unknownMaterializationReceipt as Xi, WORKER_TOOL_TRACE_SCHEMA_VERSION as Xn, createRuntimeStreamEventCollector as Xr, PEER_MAIL_WIRE_KEY as Xt, timerAt as Y, unknownExecutionBindingReceipt as Yi, replaySpawnTree as Yn, createRuntimeEventCollector as Yr, DEFAULT_PEER_MAIL_LIMITS as Yt, waitUntil as Z, executableAgentProfileSnapshot as Zi, captureWorkerTraceEvidence as Zn, sanitizeAgentRuntimeEvent as Zr, claimsAuthority as Zt, CheckUnavailableError as _, cloneSpend as _a, fullProfileMaterialization as _i, createSandboxLineage as _n, environmentGone as _r, readWorkerInteractiveBinding as _t, collectDelivered as a, createSandboxToolPartState as aa, DEFAULT_LOCAL_HARNESS as ai, bridgeModelRouteRefusal as an, createBudgetPool as ar, scopeRetainedOwnerPriorSpend as at, bestComposite as b, isAbortError$2 as ba, promptModelProfileMaterialization as bi, SandboxEvidenceRetentionError as bn, RunCancellationReason as br, reconnectRetainedInteractiveRun as bt, runTree as c, isSandboxTerminalEvent as ca, harnessSupportsReasoningEffort as ci, harnessUsageIsEmpty as cn, spendFromUsageEvents as cr, scopeRetainedOwnerResult as ct, classifyDriverFailure as d, notifySandboxEventObserver as da, CodexExecutionDiagnosticError as di, bridgeStopSignalKey as dn, reconnectRetainedRun as dr, hostDirectoryReader as dt, detachedSnapshot as ea, runSettledCommand as ei, peerMailTools as en, workerTraceAnalysisStore as er, consumeScopeRetainedOwnerResult as et, runDriverWithRetry as f, sandboxEventServedBackend as fa, terminateProcessTreeAndConfirm as fi, TERMINAL_DECISIONS as fn, recoverRetainedRun as fr, resolveSpawnResourcePaths as ft, CONTINUATION_FACTS as g, chargedTokens as ga, defineProfileMaterializationContract as gi, runAgentRounds as gn, destroyInteractiveEnvironment as gr, attachWorker as gt, CONTINUATIONS_DIR as h, addSpend as ha, controlProfileMaterialization as hi, isTerminalDecision as hn, retainedCreateMaterial as hr, workerInteractiveAdmissionFile as ht, bestDelivered as i, canonicalStreamEventFromSandboxEvent as ia, removeWorktree as ii, bridgeAdmissionRefusal as in, assertValidBudget as ir, scopeRetainedOwnerContext as it, isDriverSpec as j, resourceTelemetry as ja, readCommittedJsonLines as ji, unavailablePauseMs as jn, createPropagatingTraceEmitter as jr, createExecutorRegistry as jt, driverChild as k, zeroSpend as ka, isNoEntError as ki, providerAsSandboxClient as kn, retainHarnessTranscript as kr, cliWorktreeExecutor as kt, DriverAttemptsExhaustedError as l, mapSandboxEvent as la, localHarnessExecutable as li, readCodexRolloutSession as ln, spendFromUsageTotals as lr, SPAWN_RESOURCE_PATH_MAX_BYTES as lt, upstreamUnavailableSignal as m, sumSandboxUsage as ma, assertProfileMaterialization as mi, defaultSelectWinner as mn, startRetainedRunInEnvironment as mr, readWorkerInteractiveAdmissions as mt, createRootHandle as n, readSandboxOutcome as na, captureWorktreeDiff as ni, isLiveNodeStatus as nn, BudgetReconcileFault as nr, prepareScopeRetainedOwnerTask as nt, pickBestDelivered as o, createSandboxUsageLedger as oa, LOCAL_HARNESSES as oi, addHarnessUsage as on, meterUsageEvent as or, scopeRetainedOwnerResourceReader as ot, summarizeDriverAttempts as p, sandboxProgressEvents as pa, AGENT_PROFILE_MATERIALIZATION_AXES as pi, createSandboxForSpec as pn, startRetainedRun as pr, interactiveAdmissionSeamKey as pt, isWaitOutcome as q, runtimeOwnedPendingExecutorMaterialization as qi, materializeTreeView as qn, padTraceId as qr, createInbox as qt, createSupervisor as r, assertSandboxServedModel as ra, createWorktree as ri, isTerminalNodeStatus as rn, ReservationWaitRefused as rr, reconcileScopeRetainedOwnerEnvironment as rt, runFinalizer as s, extractLlmCallEvent as sa, harnessInvocation as si, createCodexRolloutStoreReader as sn, newUsageTotals as sr, scopeRetainedOwnerRestorePoint as st, DEFAULT_MAX_DEPTH as t, projectSandboxOutcome as ta, runWorktreeHarness as ti, peerMailVerbNames as tn, executorFailure as tr, noteScopeRetainedOwnerCoordination as tt, HarnessTurnFailedError as u, mapSandboxToolEvent as ua, parseCodexTokenUsage as ui, bridgeRuntimeAttachmentsKey as un, errMessage as ur, environmentReader as ut, admitContinuationPolicy as v, deleteBoxSafe as va, profileMaterializationAxes$1 as vi, probeSandboxCapabilities as vn, createWorkerSlots as vr, workerInteractiveBindingFile as vt, distillFindings as w, stringifySafe as wa, renderUnsupported as wi, routerBrain as wn, captureHarnessTranscript as wr, queueOf as wt, checkVerdictOf as x, promptCacheTokenClasses as xa, promptOnlyProfileMaterialization as xi, captureBeforeDestroy as xn, abortError as xr, recoverRetainedInteractiveRun as xt, admitFinding as y, hasCompleteCacheBreakdown as ya, promptControlProfileMaterialization as yi, acquireSandbox as yn, openSlotGroup as yr, workerInteractiveBindingsDir as yt, meterRuntimeOwnedProviderAttempt as z, teardownSurfaces as za, knownMaterializationReceipt as zi, FileSpawnJournal as zn, buildLoopSpanNodes as zr, readWorkerTraceContext as zt };
+export { bindScopeRetainedOwnerEnvironmentId as $, executableAgentProfileSnapshot as $i, parseWorkerToolTraceArtifact as $n, sanitizeAgentRuntimeEvent as $r, claimsAuthority as $t, driverExecutorFactory as A, withTimeout as Aa, worktreeCliProfileMaterialization as Ai, resolveAgentEnvironmentProvider as An, resolveHarnessTranscriptCapture as Ar, cliInPlaceExecutor as At, recordScopeOwnerDriverAttempt as B, teardownExecutor as Ba, knownExecutionBindingReceipt as Bi, InMemoryResultBlobStore as Bn, buildLoopOtelSpans as Br, WORKER_TRACE_PROPAGATION as Bt, createContinuationKeeper as C, promptCacheTokenClasses as Ca, promptOnlyProfileMaterialization as Ci, readPromptOptions as Cn, abortError as Cr, recoverRetainedInteractiveRun as Ct, passedItems as D, throwAbort as Da, sandboxActProfileMaterialization as Di, createAgentEnvironmentProviderRegistry as Dn, harnessTranscriptArtifact as Dr, rollingDispatch as Dt, failedItems as E, stringifySafe as Ea, renderUnsupported as Ei, LEAF_CONTINUATION_TASK as En, captureHarnessTranscript as Er, queueOf as Et, beginScopeOwnerAttempt as F, decodeHarnessUsage as Fa, attestRuntimeOwnedPendingExecutor as Fi, sandboxSessionTraceSource as Fn, readTraceContextFromEnv as Fr, createWorktreeCliExecutor as Ft, settledToIteration as G, runtimeOwnedDriveHarnessProviderEvidence as Gi, insideCursorNamespace as Gn, flatOtelSpan as Gr, taskToPrompt as Gt, recordScopeOwnerPause as H, promptFromAgentTurnInput as Ha, newExecutionAttemptId as Hi, SpawnEventIndex as Hn, buildRuntimeEventOtelSpans as Hr, workerTraceEnv as Ht, createScope as I, abortError$2 as Ia, attestRuntimeOwnedScopeOwner as Ii, registerRetainedExecutorPreparation as In, traceContextToEnv as Ir, DEFAULT_SANDBOX_STEERING_MAX_TURNS as It, pollFor as J, runtimeOwnedExecutorProviderEvidence as Ji, pendingWaits as Jn, padSpanId as Jr, readWorkerProgress as Jt, createWaitProbes as K, runtimeOwnedExecutorExecutionBinding as Ki, loadSpawnForest as Kn, generateSpanId as Kr, DEFAULT_STALL_AFTER_MS as Kt, deriveNodeExecutionIdentity as L, awaitAbortable$1 as La, authoredProfileDigest as Li, retainedExecutorSeamKey as Ln, defaultRedactor as Lr, createSteerableSandboxSession as Lt, withDriverExecutor as M, addResourceSpend as Ma, prepareJsonlAppend as Mi, unavailableSignalOfFailure as Mn, contentAddress as Mr, createExecutor as Mt, SUBTREE_RESULT_LIMIT as N, resourceTelemetry as Na, readCommittedJsonLines as Ni, createPushTraceSource as Nn, createPropagatingTraceEmitter as Nr, createExecutorRegistry as Nt, verdictFromJudgeScore as O, throwIfAborted as Oa, unsupportedProfileDimensions as Oi, providerAsExecutor as On, persistHarnessTranscript as Or, bindReusableExecutorExecutionId as Ot, assertRecursiveReservationPolicy as P, withBudgetResources as Pa, writeAllBytes as Pi, decodeToolPart as Pn, mergeTraceEnv as Pr, snapshotExecutorConfig as Pt, beginScopeRetainedOwnerDrive as Q, unknownMaterializationReceipt as Qi, isTraceAnalysisStore as Qn, createRuntimeStreamEventCollector as Qr, PEER_MAIL_WIRE_KEY as Qt, meterRuntimeOwnedAccounting as R, DEFAULT_SUCCESSFUL_SHUTDOWN_MS as Ra, finalizeRuntimeOwnedPendingExecutor as Ri, FileResultBlobStore as Rn, defaultRedactorIdentityMaterial as Rr, createRouterTranscript as Rt, composeContinuationNote as S, isAbortError$2 as Sa, promptModelProfileMaterialization as Si, assertBoxlessPromptOptions as Sn, RunCancellationReason as Sr, reconnectRetainedInteractiveRun as St, expandQuestions as T, sleep as Ta, renderProfileMaterializationIssues as Ti, runBrainLoop as Tn, runAbortable as Tr, freeSlots as Tt, restoreScopeOwnerAcceptedExecution as U, promptOptionsFromAgentTurnInput as Ua, providerAttemptEvidence as Ui, assertContentAddress as Un, createOpenInferenceFileExporter as Ur, workerTraceHeaders as Ut, recordScopeOwnerMaterialization as V, teardownSurfaces as Va, knownMaterializationReceipt as Vi, InMemorySpawnJournal as Vn, buildLoopSpanNodes as Vr, readWorkerTraceContext as Vt, scopeOwnerExecutorNodeContext as W, providerMessageText as Wa, recordRuntimeOwnedDriveHarnessProviderEvidence as Wi, encodeResultBlob as Wn, createOtelExporter as Wr, workerTraceSeamKey as Wt, validateWaitSpec as X, runtimeOwnedScopeOwnerRuntime as Xi, WORKER_TOOL_TRACE_SCHEMA_VERSION as Xn, toOtelAttributes as Xr, AUTHORITY_MARKERS as Xt, timerAt as Y, runtimeOwnedPendingExecutorMaterialization as Yi, replaySpawnTree as Yn, padTraceId as Yr, createInbox as Yt, waitUntil as Z, unknownExecutionBindingReceipt as Zi, captureWorkerTraceEvidence as Zn, createRuntimeEventCollector as Zr, DEFAULT_PEER_MAIL_LIMITS as Zt, CheckUnavailableError as _, addSpend as _a, controlProfileMaterialization as _i, createSandboxLineage as _n, retainedCreateMaterial as _r, workerInteractiveAdmissionFile as _t, collectDelivered as a, assertSandboxServedModel as aa, createWorktree as ai, isTerminalNodeStatus as an, createBudgetPool as ar, scopeRetainedOwnerContext as at, bestComposite as b, deleteBoxSafe as ba, profileMaterializationAxes$1 as bi, SandboxEvidenceRetentionError as bn, createWorkerSlots as br, workerInteractiveBindingFile as bt, runTree as c, createSandboxUsageLedger as ca, LOCAL_HARNESSES as ci, addHarnessUsage as cn, spendFromUsageEvents as cr, scopeRetainedOwnerRestorePoint as ct, classifyDriverFailure as d, mapSandboxEvent as da, localHarnessExecutable as di, readCodexRolloutSession as dn, bridgeStopSignalKey as dr, SPAWN_RESOURCE_PATH_MAX_BYTES as dt, executableAgentSpecSnapshot as ea, sanitizeKnowledgeReadinessReport as ei, createPeerMailbox as en, workerTraceAnalysisStore as er, bindScopeRetainedOwnerProvider as et, runDriverWithRetry as f, mapSandboxToolEvent as fa, parseCodexTokenUsage as fi, TERMINAL_DECISIONS as fn, errMessage as fr, environmentReader as ft, CONTINUATION_FACTS as g, sumSandboxUsage as ga, assertProfileMaterialization as gi, runAgentRounds as gn, startRetainedRunInEnvironment as gr, readWorkerInteractiveAdmissions as gt, CONTINUATIONS_DIR as h, sandboxProgressEvents as ha, AGENT_PROFILE_MATERIALIZATION_AXES as hi, isTerminalDecision as hn, startRetainedRun as hr, interactiveAdmissionSeamKey as ht, bestDelivered as i, readSandboxOutcome as ia, captureWorktreeDiff as ii, isLiveNodeStatus as in, assertValidBudget as ir, reconcileScopeRetainedOwnerEnvironment as it, isDriverSpec as j, zeroSpend as ja, isNoEntError as ji, unavailablePauseMs as jn, retainHarnessTranscript as jr, cliWorktreeExecutor as jt, driverChild as k, unmeteredSpend as ka, validateProfileMaterialization as ki, providerAsSandboxClient as kn, readHarnessTranscript as kr, captureReusableExecutorConfig as kt, DriverAttemptsExhaustedError as l, extractLlmCallEvent as la, harnessInvocation as li, createCodexRolloutStoreReader as ln, spendFromUsageTotals as lr, scopeRetainedOwnerResult as lt, upstreamUnavailableSignal as m, sandboxEventServedBackend as ma, terminateProcessTreeAndConfirm as mi, defaultSelectWinner as mn, recoverRetainedRun as mr, resolveSpawnResourcePaths as mt, createRootHandle as n, detachedSnapshot as na, runSettledCommand as ni, peerMailTools as nn, BudgetReconcileFault as nr, noteScopeRetainedOwnerCoordination as nt, pickBestDelivered as o, canonicalStreamEventFromSandboxEvent as oa, removeWorktree as oi, bridgeAdmissionRefusal as on, meterUsageEvent as or, scopeRetainedOwnerPriorSpend as ot, summarizeDriverAttempts as p, notifySandboxEventObserver as pa, CodexExecutionDiagnosticError as pi, createSandboxForSpec as pn, reconnectRetainedRun as pr, hostDirectoryReader as pt, isWaitOutcome as q, runtimeOwnedExecutorMaterialization as qi, materializeTreeView as qn, loopEventToOtelSpan as qr, createActivityLog as qt, createSupervisor as r, projectSandboxOutcome as ra, runWorktreeHarness as ri, peerMailVerbNames as rn, ReservationWaitRefused as rr, prepareScopeRetainedOwnerTask as rt, runFinalizer as s, createSandboxToolPartState as sa, DEFAULT_LOCAL_HARNESS as si, bridgeModelRouteRefusal as sn, newUsageTotals as sr, scopeRetainedOwnerResourceReader as st, DEFAULT_MAX_DEPTH as t, detachedFrozen as ta, sanitizeRuntimeStreamEvent as ti, isPeerMailEnvelope as tn, executorFailure as tr, consumeScopeRetainedOwnerResult as tt, HarnessTurnFailedError as u, isSandboxTerminalEvent as ua, harnessSupportsReasoningEffort as ui, harnessUsageIsEmpty as un, bridgeRuntimeAttachmentsKey as ur, scopeRetainedOwnerTurnEnded as ut, admitContinuationPolicy as v, chargedTokens as va, defineProfileMaterializationContract as vi, probeSandboxCapabilities as vn, destroyInteractiveEnvironment as vr, attachWorker as vt, distillFindings as w, randomSuffix as wa, promptResourceProfileMaterialization as wi, routerBrain as wn, linkAbort as wr, startRetainedInteractiveRun as wt, checkVerdictOf as x, hasCompleteCacheBreakdown as xa, promptControlProfileMaterialization as xi, captureBeforeDestroy as xn, openSlotGroup as xr, workerInteractiveBindingsDir as xt, admitFinding as y, cloneSpend as ya, fullProfileMaterialization as yi, acquireSandbox as yn, environmentGone as yr, readWorkerInteractiveBinding as yt, meterRuntimeOwnedProviderAttempt as z, armDeadlineTimer as za, inheritRuntimeOwnedExecutorAttestation as zi, FileSpawnJournal as zn, resolveRedactor as zr, createInPlaceCliExecutor as zt };
 
-//# sourceMappingURL=supervisor-CQSu5XGl.js.map
+//# sourceMappingURL=supervisor-DA_nvF-h.js.map