@tangle-network/agent-runtime 0.252.1 → 0.254.1

package/dist/{supervisor-BlDW3u0y.js → supervisor-CJyzUjc7.js}

@@ -8,11 +8,11 @@ import { estimateCost, isModelPriced, isToolSpan, toolSpansToTraceAnalysisStore
 import { createAgentRunOutcomeTracker } from "@tangle-network/sandbox/runtime";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
 import { spawn } from "node:child_process";
-import { appendFileSync, constants, createReadStream, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { appendFileSync, closeSync, constants, createReadStream, existsSync, mkdirSync, openSync, readFileSync } from "node:fs";
 import { basename, delimiter, dirname, isAbsolute, join, relative, resolve, sep, win32 } from "node:path";
 import { access, chmod, copyFile, mkdir, mkdtemp, open, readFile, readdir, realpath, rm, rmdir, stat, symlink, writeFile } from "node:fs/promises";
 import { applyWorkspacePlan, hashWorkspacePlan, materializeProfile, resolveAgentProfileResources } from "@tangle-network/agent-profile-materialize";
-import { homedir, tmpdir } from "node:os";
+import { homedir, hostname, tmpdir } from "node:os";
 import { stripVTControlCharacters } from "node:util";
 import { deriveHexId, isW3CSpanId, isW3CTraceId } from "@tangle-network/agent-trace-contract";
 import { SDKError, generateIdempotencyKey, withRetry } from "@tangle-network/agent-core";
@@ -136,9 +136,10 @@ function boundedChildDeadlineAt(parentDeadlineAtMs, childDeadlineMs, nowMs) {
 /** Invoke teardown once and bound how long the runtime waits for its acknowledgement. A hard
 * execution deadline always wins; without one, numeric grace gets a short acknowledgement
 * allowance and a brutal kill gets only that allowance. Explicit `infinity` remains unbounded
-* only when no execution deadline exists. The losing promise stays observed. */
-async function teardownExecutor(executor, grace, deadlineAtMs, now) {
-	const work = Promise.resolve(executor.teardown(grace));
+* only when no execution deadline exists. The losing promise stays observed. `ask` issues the
+* request; a scope passes its per-child single-flight asker (see `singleFlightTeardown`). */
+async function teardownExecutor(executor, grace, deadlineAtMs, now, ask = (requested) => Promise.resolve(executor.teardown(requested))) {
+	const work = Promise.resolve(ask(grace));
 	const requestedWaitMs = grace === "infinity" ? void 0 : grace === "brutalKill" ? executor.teardownTimeoutMs ?? TEARDOWN_ACKNOWLEDGEMENT_MS : grace + TEARDOWN_ACKNOWLEDGEMENT_MS;
 	const deadlineWaitMs = deadlineAtMs === void 0 ? void 0 : Math.max(0, deadlineAtMs - now()) + TEARDOWN_ACKNOWLEDGEMENT_MS;
 	const waitMs = requestedWaitMs === void 0 ? deadlineWaitMs : deadlineWaitMs === void 0 ? requestedWaitMs : Math.min(requestedWaitMs, deadlineWaitMs);
@@ -160,6 +161,48 @@ async function teardownExecutor(executor, grace, deadlineAtMs, now) {
 	}
 	if (!receipt.destroyed) throw new ValidationError$1(`executor teardown reported destroyed=false${receipt.detail ? `: ${receipt.detail}` : ""}`);
 }
+/**
+* The optional teardown surfaces a wrapping executor forwards, so wrapping never changes how a
+* child is released: the acknowledgement window a remote teardown needs, the release of a
+* retained execution at root settlement, and the environments an unconfirmed teardown names for
+* a sweeper. A wrapper that dropped `releaseRetained` left every retained child it wrapped
+* running after settlement. Each surface is present only when the inner executor implements it.
+*/
+function teardownSurfaces(inner) {
+	return {
+		...inner.teardownTimeoutMs === void 0 ? {} : { teardownTimeoutMs: inner.teardownTimeoutMs },
+		...inner.releaseRetained === void 0 ? {} : { releaseRetained: (signal) => inner.releaseRetained(signal) },
+		...inner.heldEnvironments === void 0 ? {} : { heldEnvironments: () => inner.heldEnvironments() }
+	};
+}
+/**
+* An asker that sends an executor at most one teardown at a time. While a request is still
+* running, every later ask returns that same request instead of sending another beside it.
+*
+* A settlement's own teardown has a short acknowledgement window, and a request that misses it
+* keeps running. Without this, the first settlement retry sent a second teardown next to the
+* first. An executor that does not deduplicate internally, such as one that re-issues its
+* cancels, then ran two teardowns at once. `onRequest` runs once for each request actually sent.
+*/
+function singleFlightTeardown(executor, onRequest) {
+	let inFlight;
+	return (grace) => {
+		if (inFlight !== void 0) return inFlight;
+		onRequest();
+		let request;
+		try {
+			request = Promise.resolve(executor.teardown(grace));
+		} catch (error) {
+			request = Promise.reject(error);
+		}
+		inFlight = request;
+		const settle = () => {
+			if (inFlight === request) inFlight = void 0;
+		};
+		request.then(settle, settle);
+		return request;
+	};
+}
 //#endregion
 //#region src/runtime/retained-run-binding.ts
 function exactSession(environment, controlRef) {
@@ -6468,6 +6511,117 @@ function isDurableArtifact(artifact) {
 	return "locator" in artifact;
 }
 //#endregion
+//#region src/runtime/retained-interactive-lifecycle.ts
+const INTERACTIVE_CLEANUP_TIMEOUT_MS = 3e4;
+/** Bound on one lookup that asks the provider whether it still holds an environment. */
+const ENVIRONMENT_LOOKUP_TIMEOUT_MS = 3e4;
+/**
+* Whether the provider no longer holds `environmentId`, asked after a destroy failed.
+*
+* A delete that ran on the server but whose answer was lost, or that a cancel aborted in flight,
+* fails on every later delete with not-found: the Tangle SDK throws `NotFoundError` on a 404. A
+* retry that only re-sends the delete then never confirms, and names for a sweeper an environment
+* that no longer exists. The provider's lookup is the confirmation left: `get` answering `null`
+* means the environment is gone, the same rule a retained release applies. A lookup that fails,
+* times out or finds the environment confirms nothing.
+*/
+async function environmentGone(provider, environmentId, signal) {
+	if (provider.get === void 0) return false;
+	const bound = AbortSignal.timeout(ENVIRONMENT_LOOKUP_TIMEOUT_MS);
+	try {
+		return await awaitAbortable$1(Promise.resolve().then(() => provider.get(environmentId)), signal === void 0 ? bound : AbortSignal.any([signal, bound])) === null;
+	} catch {
+		return false;
+	}
+}
+/** Create one environment while retaining ownership if cancellation wins the race. */
+async function createInteractiveEnvironment(create, signal) {
+	if (signal?.aborted) throw abortError$2(signal.reason);
+	const creation = Promise.resolve().then(create);
+	if (signal === void 0) return creation;
+	return new Promise((resolve, reject) => {
+		let owner = "pending";
+		const removeAbortListener = () => signal.removeEventListener("abort", onAbort);
+		const onAbort = () => {
+			if (owner !== "pending") return;
+			owner = "runtime";
+			removeAbortListener();
+			disposeInteractiveEnvironment(creation, signal.reason);
+			reject(abortError$2(signal.reason));
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+		creation.then((environment) => {
+			if (owner !== "pending") return;
+			owner = "caller";
+			removeAbortListener();
+			resolve(environment);
+		}, (error) => {
+			if (owner !== "pending") return;
+			owner = "runtime";
+			removeAbortListener();
+			reject(error);
+		});
+	});
+}
+/** Start one process while destroying its unreturned environment on cancellation. */
+async function startInteractiveProcess(environment, start, signal) {
+	if (signal?.aborted) {
+		disposeInteractiveEnvironment(Promise.resolve(environment), signal.reason);
+		throw abortError$2(signal.reason);
+	}
+	const pending = Promise.resolve().then(start);
+	if (signal === void 0) return pending;
+	return new Promise((resolve, reject) => {
+		let owner = "pending";
+		const removeAbortListener = () => signal.removeEventListener("abort", onAbort);
+		const onAbort = () => {
+			if (owner !== "pending") return;
+			owner = "runtime";
+			removeAbortListener();
+			disposeInteractiveEnvironment(Promise.resolve(environment), signal.reason);
+			reject(abortError$2(signal.reason));
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+		pending.then((result) => {
+			if (owner !== "pending") return;
+			owner = "caller";
+			removeAbortListener();
+			resolve(result);
+		}, (error) => {
+			if (owner !== "pending") return;
+			owner = "runtime";
+			removeAbortListener();
+			reject(error);
+		});
+	});
+}
+/** Destroy an environment with fresh, bounded cleanup authority. */
+async function destroyInteractiveEnvironment(environment) {
+	if (!environment.destroy) throw new Error(`provider environment "${environment.id}" does not expose destroy()`);
+	const controller = new AbortController();
+	const timeout = /* @__PURE__ */ new Error("interactive environment cleanup timed out");
+	let timer;
+	const destruction = Promise.resolve().then(() => environment.destroy?.({ signal: controller.signal }));
+	destruction.catch(() => void 0);
+	try {
+		await Promise.race([destruction, new Promise((_resolve, reject) => {
+			timer = setTimeout(() => {
+				controller.abort(timeout);
+				reject(timeout);
+			}, INTERACTIVE_CLEANUP_TIMEOUT_MS);
+		})]);
+	} finally {
+		if (timer !== void 0) clearTimeout(timer);
+	}
+}
+function disposeInteractiveEnvironment(environment, abortReason) {
+	environment.then(destroyInteractiveEnvironment, () => void 0).catch((cleanupError) => {
+		const reason = abortReason instanceof Error ? abortReason : new Error(String(abortReason));
+		const failure = new AggregateError([reason, cleanupError], "cancelled interactive environment cleanup failed");
+		process.emitWarning(failure, { code: "AGENT_RUNTIME_INTERACTIVE_CLEANUP_FAILED" });
+	});
+}
+//#endregion
 //#region src/runtime/interaction-capabilities.ts
 /**
 * Check one turn's interaction request before the provider can dispatch it.
@@ -8018,7 +8172,8 @@ function createProviderExecutor(provider, profile, ctx, options, placement) {
 			if (target === void 0) return { destroyed: true };
 			if (workspacePreservationRequired) return {
 				destroyed: false,
-				detail: "provider workspace retention: source preserved because execution failed before a retrievable settled workspace receipt existed"
+				detail: "provider workspace retention: source preserved because execution failed before a retrievable settled workspace receipt existed",
+				permanent: true
 			};
 			if (options.workspaceRetention !== void 0) try {
 				const currentSnapshot = await captureWorkspace(target, workspaceOutcome);
@@ -8026,13 +8181,15 @@ function createProviderExecutor(provider, profile, ctx, options, placement) {
 					workspacePreservationRequired = true;
 					return {
 						destroyed: false,
-						detail: "provider workspace retention: live workspace changed after the published receipt; source preserved"
+						detail: "provider workspace retention: live workspace changed after the published receipt; source preserved",
+						permanent: true
 					};
 				}
 			} catch {
 				return {
 					destroyed: false,
-					detail: workspaceFailureDetail()
+					detail: workspaceFailureDetail(),
+					permanent: true
 				};
 			}
 			if (destroyed) return { destroyed: true };
@@ -8041,6 +8198,10 @@ function createProviderExecutor(provider, profile, ctx, options, placement) {
 				destroyed = true;
 				return { destroyed: true };
 			} catch (error) {
+				if (await environmentGone(provider, target.id, cleanupSignal)) {
+					destroyed = true;
+					return { destroyed: true };
+				}
 				return {
 					destroyed: false,
 					detail: `providerAsExecutor(${provider.name}): environment.destroy() failed — ${error instanceof Error ? error.message : String(error)}`
@@ -8200,39 +8361,52 @@ function createProviderExecutor(provider, profile, ctx, options, placement) {
 			};
 			if (pending) return {
 				destroyed: false,
-				detail: "retained execution requires reconciliation"
+				detail: "retained execution requires reconciliation",
+				permanent: true
 			};
 			return await destroyEnvironment();
 		},
+		heldEnvironments() {
+			if (destroyed) return [];
+			const environmentId = environment?.id ?? retained?.controlRef.environmentId ?? admittedEnvironmentId(retention);
+			if (environmentId === void 0) return [];
+			const preserved = workspacePreservationRequired || workspaceCaptureFailure !== void 0;
+			return [{
+				provider: provider.name,
+				environmentId,
+				...preserved ? { keptFor: "evidence" } : {}
+			}];
+		},
 		async releaseRetained(signal) {
 			controller.abort();
 			if (!pending) return [];
 			const environmentId = retained?.controlRef.environmentId ?? environment?.id ?? admittedEnvironmentId(retention);
 			if (environmentId === void 0) return [];
-			const receipt = (destroyed, detail) => ({
+			const receipt = (destroyed, detail, permanent) => ({
 				provider: provider.name,
 				environmentId,
 				destroyed,
-				...detail === void 0 ? {} : { detail }
+				...detail === void 0 ? {} : { detail },
+				...permanent === true ? { permanent } : {}
 			});
 			if (options.workspaceRetention !== void 0 && workspaceRunActive) return [receipt(false, "provider workspace retention: source preserved while execution is still active")];
 			if (retainedReleasePromise !== void 0) return await retainedReleasePromise;
 			const releasePromise = (async () => {
 				try {
 					const target = environment ?? (provider.get === void 0 ? void 0 : await awaitAbortable$1(provider.get(environmentId), signal));
-					if (target === void 0) return [receipt(false, `providerAsExecutor(${provider.name}): no environment handle and the provider exposes no get()`)];
+					if (target === void 0) return [receipt(false, `providerAsExecutor(${provider.name}): no environment handle and the provider exposes no get()`, true)];
 					if (target === null) {
 						pending = false;
 						destroyed = true;
 						return [receipt(true)];
 					}
-					if (target.destroy === void 0) return [receipt(false, `providerAsExecutor(${provider.name}): environment exposes no destroy()`)];
+					if (target.destroy === void 0) return [receipt(false, `providerAsExecutor(${provider.name}): environment exposes no destroy()`, true)];
 					if (environment === void 0) {
 						environment = target;
 						resetWorkspaceState(target);
 					}
 					const result = await destroyEnvironment(signal);
-					if (!result.destroyed) return [receipt(false, result.detail)];
+					if (!result.destroyed) return [receipt(false, result.detail, result.permanent)];
 					pending = false;
 					return [receipt(true)];
 				} catch (error) {
@@ -14327,6 +14501,181 @@ function taskToPrompt(task) {
 	return JSON.stringify(task);
 }
 //#endregion
+//#region src/runtime/supervise/worker-lineage.ts
+/**
+* Session lineage handed DOWN to a spawned worker: the `TANGLE_*` ids the operator's `lineage` tool
+* (tangle-tools `lineage/`) stamps at every launch, so a supervised tree shows up in the cross-box
+* session graph with each worker under the supervisor that spawned it.
+*
+* WHY NOT THE TRACE SEAM. `worker-trace.ts` joins a worker's SPANS to the supervisor's trace, and is
+* off unless the run exports spans. Lineage is a different question — which session started which —
+* and has to hold when tracing is off. It keys on the supervisor process's OWN lineage instead: the
+* ambient `TANGLE_RUN_ID` a launcher stamped on this process.
+*
+* OFF WHEN THE SUPERVISOR IS UNSTAMPED. No ambient `TANGLE_RUN_ID` ⇒ every function here returns an
+* empty record and writes nothing, so a runtime used outside a lineage-stamped launcher spawns
+* byte-identical environments to before this module existed.
+*
+* THE WIRE (contract v1, tangle-tools `lineage/README.md`):
+*   env      TANGLE_RUN_ID (fresh `run_<32 hex>` per worker), TANGLE_PARENT_RUN_ID (this process),
+*            TANGLE_ROOT_RUN_ID, TANGLE_EDGE_KIND=spawned, TANGLE_OPERATOR / TANGLE_PROJECT /
+*            TANGLE_ACCOUNT (inherited), TANGLE_HARNESS, TANGLE_HOST (local children only),
+*            OTEL_RESOURCE_ATTRIBUTES with the `tangle.*` keys replaced, and TANGLE_CLAUDE_SESSION
+*            cleared so a Claude Code worker takes the stamped run as its own.
+*   headers  `x-tangle-run-id` and siblings on the cli-bridge turn POST; the bridge stamps them into
+*            the harness child it spawns.
+*   event    one `node` line plus one `spawned` edge appended to
+*            `$LINEAGE_HOME/events/<host>.jsonl` (default `~/.local/state/lineage`), only when that
+*            directory already exists — the runtime never creates operator state on its own.
+*
+* Every failure to record is swallowed: lineage is observability and must never fail a spawn.
+*/
+/** Inherited from the supervisor process to every worker unchanged. */
+const INHERITED = [
+	"TANGLE_OPERATOR",
+	"TANGLE_PROJECT",
+	"TANGLE_ACCOUNT"
+];
+const OTEL_KEYS = {
+	TANGLE_RUN_ID: "tangle.run.id",
+	TANGLE_PARENT_RUN_ID: "tangle.parent_run.id",
+	TANGLE_ROOT_RUN_ID: "tangle.root_run.id",
+	TANGLE_EDGE_KIND: "tangle.edge.kind",
+	TANGLE_OPERATOR: "tangle.operator",
+	TANGLE_PROJECT: "tangle.project",
+	TANGLE_ACCOUNT: "tangle.account",
+	TANGLE_HARNESS: "tangle.harness",
+	TANGLE_HOST: "host.name"
+};
+/** Harness names the lineage contract accepts, from a backend type or a CLI binary name. */
+const HARNESS_ALIASES = {
+	claude: "claude-code",
+	"claude-code": "claude-code",
+	codex: "codex",
+	opencode: "opencode",
+	pi: "pi",
+	kimi: "kimi",
+	"kimi-code": "kimi"
+};
+const EMPTY = {
+	env: {},
+	headers: {}
+};
+function lineageHost(env = process.env) {
+	const name = (env.LINEAGE_HOST || hostname()).trim().toLowerCase();
+	return name.endsWith(".local") ? name.slice(0, -6) : name;
+}
+function lineageHarness(harness) {
+	if (!harness) return "agent-runtime";
+	const base = harness.split(/[\\/]/).pop() ?? harness;
+	return HARNESS_ALIASES[base] ?? HARNESS_ALIASES[harness] ?? "agent-runtime";
+}
+/** Merge lineage ids into an OTEL_RESOURCE_ATTRIBUTES value, replacing earlier lineage keys. */
+function lineageOtelAttributes(existing, ids) {
+	const ours = new Set(Object.values(OTEL_KEYS));
+	const kept = (existing ?? "").split(",").map((pair) => pair.trim()).filter((pair) => pair.length > 0 && !ours.has((pair.split("=", 1)[0] ?? "").trim()));
+	for (const [envKey, attr] of Object.entries(OTEL_KEYS)) {
+		const value = ids[envKey];
+		if (value) kept.push(`${attr}=${encodeURIComponent(value)}`);
+	}
+	return kept.join(",");
+}
+/**
+* Mint the lineage ids for one worker and record its launch. Empty when the supervisor process
+* carries no `TANGLE_RUN_ID`.
+*/
+function workerLineage(options) {
+	const env = options.env ?? process.env;
+	const parent = env.TANGLE_RUN_ID;
+	if (!parent) return EMPTY;
+	const run = `run_${randomBytes(16).toString("hex")}`;
+	const harness = lineageHarness(options.harness);
+	const ids = {
+		TANGLE_RUN_ID: run,
+		TANGLE_PARENT_RUN_ID: parent,
+		TANGLE_ROOT_RUN_ID: env.TANGLE_ROOT_RUN_ID || parent,
+		TANGLE_EDGE_KIND: "spawned",
+		TANGLE_HARNESS: harness
+	};
+	for (const key of INHERITED) {
+		const value = env[key];
+		if (value) ids[key] = value;
+	}
+	if (options.local) ids.TANGLE_HOST = lineageHost(env);
+	const workerEnv = {
+		...ids,
+		OTEL_RESOURCE_ATTRIBUTES: lineageOtelAttributes(env.OTEL_RESOURCE_ATTRIBUTES, ids),
+		TANGLE_CLAUDE_SESSION: ""
+	};
+	const headers = {};
+	for (const [key, value] of Object.entries(ids)) headers[`x-${key.toLowerCase().replace(/_/g, "-")}`] = value;
+	recordLaunch(env, ids, options);
+	return {
+		env: workerEnv,
+		headers
+	};
+}
+function eventLine(event) {
+	const body = sortKeys(event);
+	const id = createHash("sha256").update(JSON.stringify(body)).digest("hex").slice(0, 16);
+	return `${JSON.stringify(sortKeys({
+		...body,
+		id
+	}))}\n`;
+}
+function sortKeys(value) {
+	const out = {};
+	for (const key of Object.keys(value).sort()) {
+		const item = value[key];
+		if (item === void 0 || item === "") continue;
+		out[key] = item !== null && typeof item === "object" && !Array.isArray(item) ? sortKeys(item) : item;
+	}
+	return out;
+}
+function recordLaunch(env, ids, options) {
+	try {
+		const dir = join(env.LINEAGE_HOME || join(homedir(), ".local", "state", "lineage"), "events");
+		if (!existsSync(dir)) return;
+		const host = lineageHost(env);
+		const common = {
+			v: 1,
+			ts: (options.now?.() ?? /* @__PURE__ */ new Date()).toISOString(),
+			host,
+			source: "runtime"
+		};
+		const node = eventLine({
+			...common,
+			type: "node",
+			run: ids.TANGLE_RUN_ID,
+			parent: ids.TANGLE_PARENT_RUN_ID,
+			root: ids.TANGLE_ROOT_RUN_ID,
+			harness: ids.TANGLE_HARNESS,
+			project: ids.TANGLE_PROJECT,
+			operator: ids.TANGLE_OPERATOR,
+			account: ids.TANGLE_ACCOUNT,
+			native: options.nodeId ? `runtime:${options.nodeId}` : void 0,
+			label: options.label?.slice(0, 80),
+			cwd: process.cwd(),
+			attrs: options.local ? {} : { placement: "remote" }
+		});
+		const edge = eventLine({
+			...common,
+			type: "edge",
+			kind: "spawned",
+			src: ids.TANGLE_PARENT_RUN_ID,
+			dst: ids.TANGLE_RUN_ID,
+			attrs: {}
+		});
+		const fd = openSync(join(dir, `${host}.jsonl`), "a", 384);
+		try {
+			appendFileSync(fd, node);
+			appendFileSync(fd, edge);
+		} finally {
+			closeSync(fd);
+		}
+	} catch {}
+}
+//#endregion
 //#region src/runtime/supervise/worker-trace.ts
 /**
 * Trace context handed DOWN to a spawned worker, so one supervised tree spans machines.
@@ -14499,7 +14848,15 @@ const bridgeExecutor = (spec, ctx) => {
 	const maxReconnects = seam.maxReconnects ?? 3;
 	const sessionId = seam.sessionId ?? `bridge-${spec.profile.name ?? "worker"}-${randomUUID()}`;
 	const attemptId = ctx.node?.attemptId ?? newExecutionAttemptId(sessionId);
-	const traceHeaders = workerTraceHeaders(ctx);
+	const traceHeaders = {
+		...workerLineage({
+			harness: harness ?? null,
+			nodeId: ctx.node?.nodeId,
+			label: spec.profile.name,
+			local: false
+		}).headers,
+		...workerTraceHeaders(ctx)
+	};
 	const controller = linkAbort(ctx.signal);
 	const inbox = createInbox();
 	let artifact;
@@ -16502,6 +16859,8 @@ const outsideKinds = /* @__PURE__ */ new Set([
 	"reconciled",
 	"edge",
 	"teardown-unconfirmed",
+	"teardown-pending",
+	"teardown-confirmed",
 	"environment-teardown",
 	"trace-unpropagated",
 	"node-inputs-resolved",
@@ -16571,6 +16930,7 @@ async function replaySpawnTree(journal, blobs, root) {
 		if (ev.kind === "execution-input" || ev.kind === "execution-admitted" || ev.kind === "execution-result") continue;
 		if (ev.kind === "edge") continue;
 		if (ev.kind === "teardown-unconfirmed") continue;
+		if (ev.kind === "teardown-pending" || ev.kind === "teardown-confirmed") continue;
 		if (ev.kind === "environment-teardown") continue;
 		if (ev.kind === "trace-unpropagated") continue;
 		if (ev.kind === "node-inputs-resolved") continue;
@@ -18141,7 +18501,15 @@ const sandboxExecutor = (spec, ctx) => {
 	const maxIterations = seam.maxIterations ?? 1;
 	if (!Number.isFinite(maxIterations) || maxIterations <= 0) throw new ValidationError$1("sandboxExecutor: maxIterations must be > 0");
 	const sandboxTokenLimits = enforceTokenLimits(profileModelExecutionSettings(spec.profile, "sandboxExecutor").tokenLimits, "sandbox", "sandboxExecutor");
-	const traceEnv = workerTraceEnv(ctx);
+	const traceEnv = {
+		...workerLineage({
+			harness,
+			nodeId: ctx.node?.nodeId,
+			label: spec.profile.name,
+			local: false
+		}).env,
+		...workerTraceEnv(ctx)
+	};
 	const controller = linkAbort(ctx.signal);
 	let artifact;
 	const executionId = ctx.node?.nodeId ?? `sandbox-run-${randomUUID()}`;
@@ -18427,10 +18795,18 @@ function verdictForOutputMarker(marker) {
 * `0` is indistinguishable from one that measured zero, and every ceiling downstream then reads
 * as enforced while enforcing nothing.
 */
-const cliExecutor = (_spec, ctx) => {
+const cliExecutor = (spec, ctx) => {
 	const seam = readSeam(ctx, cliSeamKey, "cli");
 	if (!seam.bin) throw new ValidationError$1("cliExecutor: CliSeam.bin required");
-	const traceEnv = workerTraceEnv(ctx);
+	const traceEnv = {
+		...workerLineage({
+			harness: seam.bin,
+			nodeId: ctx.node?.nodeId,
+			label: spec.profile.name,
+			local: true
+		}).env,
+		...workerTraceEnv(ctx)
+	};
 	const controller = linkAbort(ctx.signal);
 	let proc;
 	let artifact;
@@ -18468,7 +18844,7 @@ const cliExecutor = (_spec, ctx) => {
 			return artifact;
 		}
 	}, {
-		effectiveProfile: _spec.profile,
+		effectiveProfile: spec.profile,
 		backend: "cli",
 		model: {
 			status: "unknown",
@@ -19590,96 +19966,6 @@ function sameInteractiveRef(left, right) {
 	return canonicalCandidateDigest(left) === canonicalCandidateDigest(right);
 }
 //#endregion
-//#region src/runtime/retained-interactive-lifecycle.ts
-const INTERACTIVE_CLEANUP_TIMEOUT_MS = 3e4;
-/** Create one environment while retaining ownership if cancellation wins the race. */
-async function createInteractiveEnvironment(create, signal) {
-	if (signal?.aborted) throw abortError$2(signal.reason);
-	const creation = Promise.resolve().then(create);
-	if (signal === void 0) return creation;
-	return new Promise((resolve, reject) => {
-		let owner = "pending";
-		const removeAbortListener = () => signal.removeEventListener("abort", onAbort);
-		const onAbort = () => {
-			if (owner !== "pending") return;
-			owner = "runtime";
-			removeAbortListener();
-			disposeInteractiveEnvironment(creation, signal.reason);
-			reject(abortError$2(signal.reason));
-		};
-		signal.addEventListener("abort", onAbort, { once: true });
-		creation.then((environment) => {
-			if (owner !== "pending") return;
-			owner = "caller";
-			removeAbortListener();
-			resolve(environment);
-		}, (error) => {
-			if (owner !== "pending") return;
-			owner = "runtime";
-			removeAbortListener();
-			reject(error);
-		});
-	});
-}
-/** Start one process while destroying its unreturned environment on cancellation. */
-async function startInteractiveProcess(environment, start, signal) {
-	if (signal?.aborted) {
-		disposeInteractiveEnvironment(Promise.resolve(environment), signal.reason);
-		throw abortError$2(signal.reason);
-	}
-	const pending = Promise.resolve().then(start);
-	if (signal === void 0) return pending;
-	return new Promise((resolve, reject) => {
-		let owner = "pending";
-		const removeAbortListener = () => signal.removeEventListener("abort", onAbort);
-		const onAbort = () => {
-			if (owner !== "pending") return;
-			owner = "runtime";
-			removeAbortListener();
-			disposeInteractiveEnvironment(Promise.resolve(environment), signal.reason);
-			reject(abortError$2(signal.reason));
-		};
-		signal.addEventListener("abort", onAbort, { once: true });
-		pending.then((result) => {
-			if (owner !== "pending") return;
-			owner = "caller";
-			removeAbortListener();
-			resolve(result);
-		}, (error) => {
-			if (owner !== "pending") return;
-			owner = "runtime";
-			removeAbortListener();
-			reject(error);
-		});
-	});
-}
-/** Destroy an environment with fresh, bounded cleanup authority. */
-async function destroyInteractiveEnvironment(environment) {
-	if (!environment.destroy) throw new Error(`provider environment "${environment.id}" does not expose destroy()`);
-	const controller = new AbortController();
-	const timeout = /* @__PURE__ */ new Error("interactive environment cleanup timed out");
-	let timer;
-	const destruction = Promise.resolve().then(() => environment.destroy?.({ signal: controller.signal }));
-	destruction.catch(() => void 0);
-	try {
-		await Promise.race([destruction, new Promise((_resolve, reject) => {
-			timer = setTimeout(() => {
-				controller.abort(timeout);
-				reject(timeout);
-			}, INTERACTIVE_CLEANUP_TIMEOUT_MS);
-		})]);
-	} finally {
-		if (timer !== void 0) clearTimeout(timer);
-	}
-}
-function disposeInteractiveEnvironment(environment, abortReason) {
-	environment.then(destroyInteractiveEnvironment, () => void 0).catch((cleanupError) => {
-		const reason = abortReason instanceof Error ? abortReason : new Error(String(abortReason));
-		const failure = new AggregateError([reason, cleanupError], "cancelled interactive environment cleanup failed");
-		process.emitWarning(failure, { code: "AGENT_RUNTIME_INTERACTIVE_CLEANUP_FAILED" });
-	});
-}
-//#endregion
 //#region src/runtime/retained-interactive.ts
 /**
 * Start one retry-safe native coding-agent TUI without dispatching a headless turn.
@@ -21303,6 +21589,10 @@ function scopeRetainedOwnerResourceReader(scope) {
 		}
 	};
 }
+/** @internal Whether another owner release could still destroy what the last one left. */
+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) {
 	const state = owners.get(scope);
@@ -21312,27 +21602,45 @@ async function releaseScopeRetainedOwnerEnvironment(scope) {
 	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();
-	let unconfirmed = false;
+	const unconfirmed = [];
+	const preserved = [];
+	let lastDetail;
+	let retriable = false;
 	for (const environmentId of environments) {
 		if (released.has(environmentId)) continue;
 		let destroyed = false;
 		let detail;
 		if (retentionFailures.has(environmentId)) {
 			detail = "provider workspace retention: source preserved because the owner execution has no verified workspace receipt";
-			unconfirmed = true;
-		} else 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;
+			preserved.push(environmentId);
+			lastDetail = detail;
+		} else {
+			let permanent = false;
+			try {
+				await runAbortable(async () => {
+					if (!provider.get) {
+						permanent = true;
+						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) {
+						permanent = true;
+						throw new Error("provider returned another retained environment");
+					}
+					if (!environment.destroy) {
+						permanent = true;
+						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.push(environmentId);
+				lastDetail = detail;
+				if (!permanent) retriable = true;
+			}
 		}
 		await args.journal.appendEvent(args.rootId, {
 			kind: "environment-teardown",
@@ -21345,11 +21653,22 @@ async function releaseScopeRetainedOwnerEnvironment(scope) {
 			at: new Date(args.now()).toISOString()
 		});
 	}
-	return unconfirmed ? [{
+	state.releaseRetriable = retriable;
+	return unconfirmed.length > 0 || preserved.length > 0 ? [{
 		id: args.nodeId,
 		label: "scope owner",
 		runtime: provider.name,
-		status: "done"
+		status: "done",
+		...unconfirmed.length === 0 ? {} : { environments: unconfirmed.map((environmentId) => ({
+			provider: provider.name,
+			environmentId
+		})) },
+		...preserved.length === 0 ? {} : { kept: preserved.map((environmentId) => ({
+			provider: provider.name,
+			environmentId,
+			keptFor: "evidence"
+		})) },
+		...lastDetail === void 0 ? {} : { detail: lastDetail }
 	}] : [];
 }
 /** Group owner admissions by input and require a verified workspace receipt before deletion. */
@@ -21689,9 +22008,55 @@ function defaultSleep$1(ms, signal) {
 const runtimeOwnedProviderMeters = /* @__PURE__ */ new WeakMap();
 const recoveryStarters = /* @__PURE__ */ new WeakMap();
 const retainedReleasers = /* @__PURE__ */ new WeakMap();
+const teardownRetriers = /* @__PURE__ */ new WeakMap();
+const teardownRetriable = /* @__PURE__ */ new WeakMap();
+/** The retained owner environments a scope's last release could not confirm destroyed. */
+const ownerUnconfirmedByScope = /* @__PURE__ */ new WeakMap();
+/** The scope a recursive executor owns, so the settlement retry reaches its descendants. */
+const nestedTeardownScopes = /* @__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();
 const admissionSeals = /* @__PURE__ */ new WeakMap();
 /** Per-child bound on a retained release: one remote destroy, answered or abandoned. */
 const RETAINED_RELEASE_TIMEOUT_MS = 3e4;
+/**
+* One unconfirmed child as the run names it: the node, the environments its executor still
+* reports holding, and what the last teardown attempt answered.
+*
+* Environments split by intent. Those kept on purpose go in `kept`, so a sweeper that deletes
+* `environments` never destroys work a resume would recover or evidence preserved on purpose.
+* The executor marks what it preserves as evidence. A retained-pending child is kept for a resume
+* until its scope releases retained environments at settlement: `releasing` says whether it has.
+* After a release, a retained environment still held is a leak like any other.
+*/
+function unconfirmedTeardownOf(child, releasing) {
+	const keptForResume = child.recoveryPending === true && !releasing;
+	const environments = [];
+	const kept = [];
+	try {
+		for (const environment of child.readHeldEnvironments?.() ?? []) {
+			const keptFor = environment.keptFor ?? (keptForResume ? "resume" : void 0);
+			const named = Object.freeze({
+				provider: environment.provider,
+				environmentId: environment.environmentId,
+				...keptFor === void 0 ? {} : { keptFor }
+			});
+			if (keptFor === void 0) environments.push(named);
+			else kept.push(named);
+		}
+	} catch {}
+	return Object.freeze({
+		id: child.id,
+		label: child.label,
+		runtime: child.runtime,
+		status: child.status,
+		...environments.length === 0 ? {} : { environments: Object.freeze(environments) },
+		...kept.length === 0 ? {} : { kept: Object.freeze(kept) },
+		...child.teardownAttempts > 0 ? { attempts: child.teardownAttempts } : {},
+		...child.teardownDetail === void 0 ? {} : { detail: child.teardownDetail }
+	});
+}
 /** @internal Admit original children before the parent acts; do not wait for their results. */
 async function startScopeRecoveries(scope) {
 	const start = recoveryStarters.get(scope);
@@ -21712,10 +22077,50 @@ async function startScopeRecoveries(scope) {
 * `Executor.releaseRetained`, and its nested scope journals theirs.
 */
 async function releaseRetainedEnvironments(scope) {
+	releasingScopes.add(scope);
 	const release = retainedReleasers.get(scope);
 	if (release) await release();
-	const ownerUnconfirmed = await releaseScopeRetainedOwnerEnvironment(scope);
-	return [...scope.workerCapacity.unconfirmed, ...ownerUnconfirmed];
+	ownerUnconfirmedByScope.set(scope, await releaseScopeRetainedOwnerEnvironment(scope));
+	return unconfirmedTeardowns(scope);
+}
+/**
+* @internal Everything this scope cannot prove destroyed: its settled children whose teardown is
+* unconfirmed and, after a release, the retained owner environment that release could not
+* confirm. Read live, so a later retry that confirms a node removes it.
+*/
+function unconfirmedTeardowns(scope) {
+	return [...scope.workerCapacity.unconfirmed, ...ownerUnconfirmedByScope.get(scope) ?? []];
+}
+/** @internal Let the settlement retry reach the scope a recursive executor owns. */
+function registerNestedTeardownScope(executor, read) {
+	nestedTeardownScopes.set(executor, read);
+}
+/**
+* @internal Ask each settled child whose teardown is still unconfirmed to tear down once more,
+* and resolve when every attempt has answered.
+*
+* A child's first teardown runs inside its settlement with a short acknowledgement window, and a
+* provider delete that fails once or answers late then leaves its sandbox running for good. This
+* is one retry pass; the supervisor paces passes with backoff inside a bounded window, and a
+* nested manager runs one pass over its own scope each time its teardown is asked again, so the
+* retry reaches every level of the tree.
+*
+* A retained-pending child is skipped: its executor answers `destroyed: false` by construction
+* while a resume may still reconcile it, and `releaseRetainedEnvironments` owns its release. An
+* attempt still in flight from an earlier pass is awaited, never duplicated. Never rejects.
+*/
+async function retryUnconfirmedTeardowns(scope) {
+	const retry = teardownRetriers.get(scope);
+	if (retry) await retry();
+}
+/**
+* @internal Whether another retry can still change this scope's unconfirmed set. With `release`
+* the run releases retained environments at settlement, so a retained child or owner whose
+* release failed can still be released again; without it those are kept for a resume, and only
+* an ordinary unconfirmed teardown counts.
+*/
+function hasRetriableTeardowns(scope, release) {
+	return teardownRetriable.get(scope)?.(release) ?? false;
 }
 /**
 * @internal Close this scope to NEW children. Idempotent, synchronous, and irreversible.
@@ -22100,6 +22505,9 @@ function createScope(args) {
 					controller.abort(new RunCancellationReason("worker-handle", reason ?? "worker cancelled"));
 				}
 			};
+			const askTeardown = singleFlightTeardown(executor, () => {
+				live.teardownAttempts += 1;
+			});
 			const live = {
 				id,
 				status: "acquiring",
@@ -22129,8 +22537,12 @@ function createScope(args) {
 				...executor.cancel ? { requestCancel: executor.cancel.bind(executor) } : {},
 				...executor.releaseRetained ? {
 					releaseRetained: executor.releaseRetained.bind(executor),
-					confirmTeardown: () => teardownExecutor(executor, "brutalKill", void 0, now)
+					confirmTeardown: () => teardownExecutor(executor, "brutalKill", void 0, now, askTeardown)
 				} : {},
+				askTeardown,
+				...executor.heldEnvironments ? { readHeldEnvironments: executor.heldEnvironments.bind(executor) } : {},
+				...nestedTeardownScopes.has(executor) ? { readNestedScope: nestedTeardownScopes.get(executor) } : {},
+				teardownAttempts: 0,
 				abortChild: (reason) => controller.abort(reason)
 			};
 			const recordCancellation = () => {
@@ -22461,6 +22873,7 @@ function createScope(args) {
 			delivered: false,
 			executorDone: false,
 			cleanupConfirmed: true,
+			teardownAttempts: 0,
 			executionBindings: [],
 			startedAt: armedAt,
 			lastActivityAt: now(),
@@ -22672,12 +23085,7 @@ function createScope(args) {
 			return {
 				live: liveWorkerCapacity.live,
 				freeSlots: freeSlots(liveWorkerCapacity.live, liveWorkerCapacity.max),
-				unconfirmed: Object.freeze([...children.values()].filter((child) => isTerminalNodeStatus(child.status) && !child.cleanupConfirmed).map((child) => Object.freeze({
-					id: child.id,
-					label: child.label,
-					runtime: child.runtime,
-					status: child.status
-				})))
+				unconfirmed: Object.freeze([...children.values()].filter((child) => isTerminalNodeStatus(child.status) && !child.cleanupConfirmed).map((child) => unconfirmedTeardownOf(child, releasingScopes.has(scope))))
 			};
 		}
 	};
@@ -22741,18 +23149,55 @@ function createScope(args) {
 			throw error;
 		}
 	});
+	const retainedHeld = () => [...children.values()].filter((child) => isTerminalNodeStatus(child.status) && !child.cleanupConfirmed && (child.recoveryPending === true || child.ownedTreeRoot !== void 0) && child.teardownPermanent !== true && child.releaseRetained !== void 0 && child.confirmTeardown !== void 0);
+	const retriableTeardowns = () => [...children.values()].filter((child) => {
+		if (!isTerminalNodeStatus(child.status) || child.cleanupConfirmed || child.recoveryPending === true || child.teardownPermanent === true || child.askTeardown === void 0) return false;
+		const nested = child.readNestedScope?.();
+		return nested === void 0 || unconfirmedTeardowns(nested).length === 0 || hasRetriableTeardowns(nested, false);
+	});
+	const releasable = () => retainedHeld().filter((child) => {
+		const nested = child.readNestedScope?.();
+		return child.ownedTreeRoot === void 0 || nested === void 0 || hasRetriableTeardowns(nested, true);
+	});
+	teardownRetriable.set(scope, (release) => retriableTeardowns().length > 0 || release && (releasable().length > 0 || retainedOwnerReleaseRetriable(scope)));
+	teardownRetriers.set(scope, async () => {
+		await Promise.all(retriableTeardowns().map((child) => {
+			child.teardownRetry ??= (async () => {
+				try {
+					const nested = child.readNestedScope?.();
+					if (nested !== void 0) await retryUnconfirmedTeardowns(nested);
+					const receipt = await child.askTeardown("brutalKill");
+					if (receipt.destroyed) {
+						child.cleanupConfirmed = true;
+						child.teardownDetail = void 0;
+					} else {
+						child.teardownDetail = `executor teardown reported destroyed=false${receipt.detail ? `: ${receipt.detail}` : ""}`;
+						if (receipt.permanent === true) child.teardownPermanent = true;
+					}
+				} catch (error) {
+					child.teardownDetail = errMessage(error);
+				} finally {
+					child.teardownRetry = void 0;
+				}
+			})();
+			return child.teardownRetry;
+		}));
+	});
 	retainedReleasers.set(scope, async () => {
-		const held = [...children.values()].filter((child) => isTerminalNodeStatus(child.status) && !child.cleanupConfirmed && (child.recoveryPending === true || child.ownedTreeRoot !== void 0) && child.releaseRetained !== void 0 && child.confirmTeardown !== void 0);
+		const held = retainedHeld();
 		const released = await Promise.all(held.map(async (child) => {
 			const bound = new AbortController();
 			const timer = setTimeout(() => bound.abort(new ValidationError$1(`retained release did not acknowledge within ${RETAINED_RELEASE_TIMEOUT_MS}ms`)), RETAINED_RELEASE_TIMEOUT_MS);
 			timer.unref?.();
 			try {
 				const receipts = await child.releaseRetained(bound.signal);
+				if (receipts.some((receipt) => !receipt.destroyed && receipt.permanent === true)) child.teardownPermanent = true;
 				if (receipts.every((receipt) => receipt.destroyed)) try {
 					await child.confirmTeardown();
 					child.cleanupConfirmed = true;
-				} catch {}
+				} catch {
+					if (receipts.length === 0 && child.ownedTreeRoot === void 0) child.teardownPermanent = true;
+				}
 				return {
 					child,
 					receipts
@@ -23344,10 +23789,11 @@ async function runChild(live, executor, childAbort, task, opts, pool, ticket, bl
 		if (teardownStarted) return;
 		teardownStarted = true;
 		try {
-			await teardownExecutor(executor, grace, deadlineAtMs, now);
+			await teardownExecutor(executor, grace, deadlineAtMs, now, live.askTeardown);
 			live.cleanupConfirmed = true;
 		} catch (error) {
 			teardownFailure = error;
+			live.teardownDetail = errMessage(error);
 			throw error;
 		}
 	};
@@ -23944,16 +24390,14 @@ const driverExecutorFactory = (rawSpec, ctx) => {
 	let recovering = false;
 	let previouslyMetered = zeroSpend();
 	let cleanupFailure;
-	let unconfirmedDescendants = [];
 	let active;
 	let nestedScopeHeld;
+	const unconfirmedDescendants = () => nestedScopeHeld === void 0 ? [] : unconfirmedTeardowns(nestedScopeHeld);
 	const closeActive = (reason) => {
 		if (active === void 0) return Promise.resolve();
 		if (!active.close) {
 			const { scope, controller } = active;
-			active.close = closeNestedScope(scope, controller, reason).then(() => {
-				unconfirmedDescendants = scope.workerCapacity.unconfirmed.map((node) => node.id);
-			}, (error) => {
+			active.close = closeNestedScope(scope, controller, reason).then(() => void 0, (error) => {
 				cleanupFailure = error;
 				throw error;
 			});
@@ -24051,14 +24495,18 @@ const driverExecutorFactory = (rawSpec, ctx) => {
 		async teardown() {
 			await closeActive("driver executor teardown");
 			if (cleanupFailure !== void 0) throw cleanupFailure;
-			return unconfirmedDescendants.length > 0 ? {
+			const unconfirmed = unconfirmedDescendants();
+			return unconfirmed.length > 0 ? {
 				destroyed: false,
-				detail: `Nested executor cleanup is unconfirmed: ${unconfirmedDescendants.join(", ")}`
+				detail: `Nested executor cleanup is unconfirmed: ${unconfirmed.map((node) => node.id).join(", ")}`
 			} : { destroyed: true };
 		},
+		heldEnvironments() {
+			return unconfirmedDescendants().flatMap((node) => [...node.environments ?? [], ...node.kept ?? []]);
+		},
 		async releaseRetained() {
 			if (nestedScopeHeld === void 0) return [];
-			unconfirmedDescendants = (await releaseRetainedEnvironments(nestedScopeHeld)).map((node) => node.id);
+			await releaseRetainedEnvironments(nestedScopeHeld);
 			return [];
 		},
 		resultArtifact() {
@@ -24066,6 +24514,7 @@ const driverExecutorFactory = (rawSpec, ctx) => {
 			return artifact;
 		}
 	};
+	registerNestedTeardownScope(executor, () => nestedScopeHeld);
 	const treeOwner = attestNestedDriverTreeOwner(executor);
 	const ownerRuntime = runtimeOwnedScopeOwnerRuntime(driver);
 	return ownerRuntime === void 0 ? treeOwner : attestRuntimeOwnedDeferredExecutor(treeOwner, ownerRuntime);
@@ -24711,8 +25160,10 @@ async function runFinalizer(finalizer, args) {
 *  - Join barrier: when `act()` settles (resolve OR reject), every still-live child is
 *    torn down before `run` returns — the generalization of the kernel's
 *    `finally{ Promise.allSettled(destroy) }` barrier (run-loop.ts) from boxes to the
-*    whole sub-tree. A teardown failure is `allSettled`'d and journaled per node as a
-*    `teardown-unconfirmed` event; it NEVER masks act()'s own outcome. act()'s rejection is the
+*    whole sub-tree. An unconfirmed teardown is retried with backoff for `teardownConfirmMs`.
+*    Each node pending when the window opens is journaled first as `teardown-pending`, then as
+*    `teardown-confirmed` or, still unconfirmed when the window closes, `teardown-unconfirmed`
+*    naming its provider environments; it NEVER masks act()'s own outcome. act()'s rejection is the
 *    PRIMARY error (the kernel's firstError precedence), so a teardown throw during the
 *    barrier can never overwrite the real failure.
 *  - Abort cascade: a root abort (caller signal, `RootHandle.abort`, a tripped breaker,
@@ -24861,7 +25312,7 @@ function describeRejection(error) {
 function createSupervisor() {
 	let attached;
 	async function run(root, task, opts) {
-		const { budget, rootIdentity, rootMaterialization, runId, journal: journalStore, blobs: blobStore, executors: executorRegistry, recoverExecutor, probes, maxDepth, maxLiveWorkers, maxRestarts, withinMs, childSettleGraceMs, resume, retainedAtSettlement: requestedRetainedAtSettlement, ownerWorkspaceRetention, now: suppliedNow, signal, hooks, workerTrace, workerTraceUnpropagated, interactiveBindingDir } = opts;
+		const { budget, rootIdentity, rootMaterialization, runId, journal: journalStore, blobs: blobStore, executors: executorRegistry, recoverExecutor, probes, maxDepth, maxLiveWorkers, maxRestarts, withinMs, childSettleGraceMs, teardownConfirmMs, resume, retainedAtSettlement: requestedRetainedAtSettlement, ownerWorkspaceRetention, now: suppliedNow, signal, hooks, workerTrace, workerTraceUnpropagated, interactiveBindingDir } = opts;
 		const input = detachedSnapshot({
 			task,
 			options: {
@@ -24874,12 +25325,14 @@ function createSupervisor() {
 				...maxRestarts === void 0 ? {} : { maxRestarts },
 				...withinMs === void 0 ? {} : { withinMs },
 				...childSettleGraceMs === void 0 ? {} : { childSettleGraceMs },
+				...teardownConfirmMs === void 0 ? {} : { teardownConfirmMs },
 				...resume === void 0 ? {} : { resume },
 				...requestedRetainedAtSettlement === void 0 ? {} : { retainedAtSettlement: requestedRetainedAtSettlement },
 				...ownerWorkspaceRetention === void 0 ? {} : { ownerWorkspaceRetention },
 				...interactiveBindingDir === void 0 ? {} : { interactiveBindingDir }
 			}
 		}, "supervisor.run");
+		if (teardownConfirmMs !== void 0 && (typeof teardownConfirmMs !== "number" || !Number.isFinite(teardownConfirmMs) || teardownConfirmMs < 0)) throw new ValidationError$1(`supervisor: teardownConfirmMs must be a nonnegative finite number of milliseconds, got ${JSON.stringify(teardownConfirmMs)}`);
 		if (requestedRetainedAtSettlement !== void 0 && requestedRetainedAtSettlement !== "release" && requestedRetainedAtSettlement !== "keep") throw new ValidationError$1(`supervisor: retainedAtSettlement must be 'release' or 'keep', got ${JSON.stringify(requestedRetainedAtSettlement)}`);
 		opts = Object.freeze({
 			...input.options,
@@ -25051,12 +25504,31 @@ function createSupervisor() {
 				try {
 					teardownUnconfirmed = await drainLiveChildren(openScope, controller, settleGraceMs);
 					if (retainedAtSettlement === "release") teardownUnconfirmed = await releaseRetainedEnvironments(openScope);
+					const confirmWindowMs = opts.teardownConfirmMs ?? DEFAULT_TEARDOWN_CONFIRM_MS;
+					const releasing = retainedAtSettlement === "release";
+					if (teardownUnconfirmed.length > 0 && confirmWindowMs > 0 && hasRetriableTeardowns(openScope, releasing)) {
+						const pending = teardownUnconfirmed;
+						for (const node of pending) await opts.journal.appendEvent(opts.runId, {
+							kind: "teardown-pending",
+							...unconfirmedRecord(node),
+							seq: teardownSeq++,
+							at: new Date(now()).toISOString()
+						});
+						teardownUnconfirmed = await confirmSettledTeardowns(openScope, confirmWindowMs, releasing);
+						const still = new Set(teardownUnconfirmed.map((node) => node.id));
+						for (const node of pending) {
+							if (still.has(node.id)) continue;
+							await opts.journal.appendEvent(opts.runId, {
+								kind: "teardown-confirmed",
+								id: node.id,
+								seq: teardownSeq++,
+								at: new Date(now()).toISOString()
+							});
+						}
+					}
 					for (const node of teardownUnconfirmed) await opts.journal.appendEvent(opts.runId, {
 						kind: "teardown-unconfirmed",
-						id: node.id,
-						label: node.label,
-						runtime: node.runtime,
-						status: node.status,
+						...unconfirmedRecord(node),
 						seq: teardownSeq++,
 						at: new Date(now()).toISOString()
 					});
@@ -25301,22 +25773,89 @@ async function drainLiveChildren(scope, controller, settleGraceMs = 0) {
 	if (after.inFlight > 0 || after.waiting > 0) throw new RuntimeRunStateError(`supervisor: cleanup ended with ${after.inFlight} running, ${after.waiting} waiting, and ` + describeUnconfirmed(scope));
 	return unconfirmedTeardowns(scope);
 }
-/**
-* The settled children whose executor teardown was never acknowledged.
-*
-* They still hold their capacity slot — the ledger stays poisoned, so replacement work can never
-* exceed the physical live count — but every one of them has already reached a terminal state and
-* journaled its work. That is evidence about an EXECUTOR, not a cause of run failure, so the
-* barrier NAMES them and lets the run reach its real terminal state. Live work after the drain is
-* a different fault and still fails loud.
-*/
-function unconfirmedTeardowns(scope) {
-	return scope.workerCapacity.unconfirmed;
+/** Five minutes: long enough to outlast a provider's transient delete failures and a slow
+*  acknowledgement, short enough that a cancelled run still settles promptly. */
+const DEFAULT_TEARDOWN_CONFIRM_MS = 3e5;
+/** The fields a `teardown-pending` or `teardown-unconfirmed` record carries for one node. */
+function unconfirmedRecord(node) {
+	return {
+		id: node.id,
+		label: node.label,
+		runtime: node.runtime,
+		status: node.status,
+		...node.environments === void 0 ? {} : { environments: node.environments },
+		...node.kept === void 0 ? {} : { kept: node.kept },
+		...node.attempts === void 0 ? {} : { attempts: node.attempts },
+		...node.detail === void 0 ? {} : { detail: node.detail }
+	};
+}
+/**
+* Retry every unconfirmed teardown in the settled tree until each executor confirms destruction
+* or `windowMs` passes, and return what is still unconfirmed.
+*
+* Settled children are evidence about an EXECUTOR, not a cause of run failure, so the barrier
+* never fails the run over them; it asks again and then NAMES what it could not confirm. Backoff
+* starts at 1/300 of the window and doubles up to 1/10 of it, so the default window gives about
+* fourteen attempts. A request still running is awaited by later passes and never sent twice,
+* including a settlement request that missed its acknowledgement window, and it never holds up
+* another child's retry. Under `release`, a retained environment whose release
+* failed is released again; otherwise it is kept for a resume and not retried. The window is wall
+* clock, like the timers that pace it, so an injected `now` cannot stall it.
+*/
+async function confirmSettledTeardowns(scope, windowMs, release) {
+	const closesAt = Date.now() + windowMs;
+	const maxDelayMs = windowMs / 10;
+	let delayMs = windowMs / 300;
+	let releasing;
+	let failure;
+	while (failure === void 0 && hasRetriableTeardowns(scope, release)) {
+		if (closesAt - Date.now() <= 0) break;
+		await pause(Math.min(delayMs, closesAt - Date.now()));
+		delayMs = Math.min(delayMs * 2, maxDelayMs);
+		if (release && releasing === void 0) releasing = releaseRetainedEnvironments(scope).finally(() => {
+			releasing = void 0;
+		});
+		const pass = Promise.all([releasing, retryUnconfirmedTeardowns(scope)]).catch((error) => {
+			failure ??= { error };
+		});
+		const answerWindow = pausable(Math.min(delayMs, Math.max(0, closesAt - Date.now())));
+		await Promise.race([pass, answerWindow.elapsed]);
+		answerWindow.cancel();
+	}
+	const inFlight = releasing;
+	if (inFlight !== void 0) await inFlight.catch((error) => {
+		failure ??= { error };
+	});
+	if (failure !== void 0) throw failure.error;
+	return unconfirmedTeardowns(scope);
+}
+/** A wall-clock wait that keeps the process alive until it ends. */
+function pause(ms) {
+	return pausable(ms).elapsed;
+}
+/** A wall-clock wait that can be cancelled, so a wait that lost a race holds no timer open. */
+function pausable(ms) {
+	if (ms <= 0) return {
+		elapsed: Promise.resolve(),
+		cancel: () => {}
+	};
+	let cancel = () => {};
+	return {
+		elapsed: new Promise((resolve) => {
+			cancel = armDeadlineTimer(ms, resolve, true);
+		}),
+		cancel
+	};
 }
 /** The unconfirmed set as one error clause: the count plus the node ids behind it. One integer is
 *  not actionable after a six-hour run. */
 function describeUnconfirmed(scope) {
-	const named = scope.workerCapacity.unconfirmed.map((node) => `${node.id} (${node.label}, ${node.runtime}, ${node.status})`).join(", ");
+	const named = scope.workerCapacity.unconfirmed.map((node) => `${node.id} (${[
+		node.label,
+		node.runtime,
+		node.status,
+		...(node.environments ?? []).map((environment) => `${environment.provider}:${environment.environmentId}`)
+	].join(", ")})`).join(", ");
 	return `${scope.workerCapacity.live} executor resource(s) not confirmed destroyed${named.length > 0 ? `: ${named}` : ""}`;
 }
 /** The settle window a driver's children actually get: the caller's grace, never past an explicit
@@ -25491,6 +26030,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 { startRetainedInteractiveRun as $, withBudgetResources as $i, contentAddress as $n, writeAllBytes as $r, isPeerMailEnvelope as $t, validateWaitSpec as A, mapSandboxEvent as Ai, providerAsSandboxClient as An, localHarnessExecutable as Ar, workerTraceAnalysisStore as At, SPAWN_RESOURCE_PATH_MAX_BYTES as B, hasCompleteCacheBreakdown as Bi, startRetainedRun as Bn, promptControlProfileMaterialization as Br, workerTraceEnv as Bt, restoreScopeOwnerAcceptedExecution as C, readSandboxOutcome as Ci, routerBrain as Cn, runWorktreeHarness as Cr, materializeTreeView as Ct, isWaitOutcome as D, createSandboxUsageLedger as Di, DEFAULT_SANDBOX_IDLE_TIMEOUT_SECONDS as Dn, DEFAULT_LOCAL_HARNESS as Dr, captureWorkerTraceEvidence as Dt, createWaitProbes as E, createSandboxToolPartState as Ei, observedModelMatchesDeclared as En, removeWorktree as Er, WORKER_TOOL_TRACE_SCHEMA_VERSION as Et, prepareScopeRetainedOwnerTask as F, sumSandboxUsage as Fi, sandboxSessionTraceSource as Fn, assertProfileMaterialization as Fr, newUsageTotals as Ft, readWorkerInteractiveAdmissions as G, stringifySafe as Gi, linkAbort as Gn, renderUnsupported as Gr, createActivityLog as Gt, hostDirectoryReader as H, promptCacheTokenClasses as Hi, retainedCreateMaterial as Hn, promptOnlyProfileMaterialization as Hr, workerTraceSeamKey as Ht, scopeRetainedOwnerContext as I, addSpend as Ii, registerRetainedExecutorPreparation as In, controlProfileMaterialization as Ir, spendFromUsageEvents as It, readWorkerInteractiveBinding as J, unmeteredSpend as Ji, defaultRedactorIdentityMaterial as Jn, validateProfileMaterialization as Jr, AUTHORITY_MARKERS as Jt, workerInteractiveAdmissionFile as K, throwAbort as Ki, runAbortable as Kn, sandboxActProfileMaterialization as Kr, readWorkerProgress as Kt, scopeRetainedOwnerPriorSpend as L, chargedTokens as Li, retainedExecutorSeamKey as Ln, defineProfileMaterializationContract as Lr, spendFromUsageTotals as Lt, bindScopeRetainedOwnerEnvironmentId as M, notifySandboxEventObserver as Mi, sandboxClientAsProvider as Mn, CodexExecutionDiagnosticError as Mr, assertValidBudget as Mt, bindScopeRetainedOwnerProvider as N, sandboxEventServedBackend as Ni, createPushTraceSource as Nn, terminateProcessTreeAndConfirm as Nr, createBudgetPool as Nt, pollFor as O, extractLlmCallEvent as Oi, createAgentEnvironmentProviderRegistry as On, LOCAL_HARNESSES as Or, isTraceAnalysisStore as Ot, consumeScopeRetainedOwnerResult as P, sandboxProgressEvents as Pi, decodeToolPart as Pn, AGENT_PROFILE_MATERIALIZATION_AXES as Pr, meterUsageEvent as Pt, recoverRetainedInteractiveRun as Q, resourceTelemetry as Qi, persistHarnessTranscript as Qn, readCommittedJsonLines as Qr, createPeerMailbox as Qt, scopeRetainedOwnerResourceReader as R, cloneSpend as Ri, reconnectRetainedRun as Rn, fullProfileMaterialization as Rr, WORKER_TRACE_PROPAGATION as Rt, recordScopeOwnerMaterialization as S, projectSandboxOutcome as Si, readPromptOptions as Sn, runSettledCommand as Sr, loadSpawnForest as St, settledToIteration as T, canonicalStreamEventFromSandboxEvent as Ti, canonicalObservedModelParts as Tn, createWorktree as Tr, replaySpawnTree as Tt, resolveSpawnResourcePaths as U, randomSuffix as Ui, RunCancellationReason as Un, promptResourceProfileMaterialization as Ur, taskToPrompt as Ut, environmentReader as V, isAbortError$2 as Vi, startRetainedRunInEnvironment as Vn, promptModelProfileMaterialization as Vr, workerTraceHeaders as Vt, interactiveAdmissionSeamKey as W, sleep as Wi, abortError as Wn, renderProfileMaterializationIssues as Wr, DEFAULT_STALL_AFTER_MS as Wt, workerInteractiveBindingsDir as X, zeroSpend as Xi, captureHarnessTranscript as Xn, isNoEntError as Xr, PEER_MAIL_WIRE_KEY as Xt, workerInteractiveBindingFile as Y, withTimeout as Yi, resolveRedactor as Yn, worktreeCliProfileMaterialization as Yr, DEFAULT_PEER_MAIL_LIMITS as Yt, reconnectRetainedInteractiveRun as Z, addResourceSpend as Zi, harnessTranscriptArtifact as Zn, prepareJsonlAppend as Zr, claimsAuthority as Zt, beginScopeOwnerAttempt as _, unknownMaterializationReceipt as _i, runAgentRounds as _n, createRuntimeEventCollector as _r, FileResultBlobStore as _t, pickBestDelivered as a, teardownExecutor as aa, knownExecutionBindingReceipt as ai, bridgeAdmissionRefusal as an, buildLoopOtelSpans as ar, rollingDispatch as at, meterRuntimeOwnedAccounting as b, detachedFrozen as bi, acquireSandbox as bn, sanitizeKnowledgeReadinessReport as br, InMemorySpawnJournal as bt, DriverAttemptsExhaustedError as c, providerMessageText as ca, providerAttemptEvidence as ci, createCodexRolloutStoreReader as cn, createOpenInferenceFileExporter as cr, cliInPlaceExecutor as ct, defaultUnmetContractSteer as d, runtimeOwnedExecutorExecutionBinding as di, bridgeRuntimeAttachmentsKey as dn, flatOtelSpan as dr, createExecutorRegistry as dt, decodeHarnessUsage as ea, attestRuntimeOwnedPendingExecutor as ei, peerMailTools as en, createPropagatingTraceEmitter as er, destroyInteractiveEnvironment as et, runDriverWithRetry as f, runtimeOwnedExecutorMaterialization as fi, bridgeStopSignalKey as fn, generateSpanId as fr, snapshotExecutorConfig as ft, withDriverExecutor as g, unknownExecutionBindingReceipt as gi, isTerminalDecision as gn, toOtelAttributes as gr, createInPlaceCliExecutor as gt, isDriverSpec as h, runtimeOwnedScopeOwnerRuntime as hi, defaultSelectWinner as hn, padTraceId as hr, createSteerableSandboxSession as ht, collectDelivered as i, armDeadlineTimer as ia, inheritRuntimeOwnedExecutorAttestation as ii, executorFailure as in, INTELLIGENCE_WIRE_VERSION as ir, queueOf as it, waitUntil as j, mapSandboxToolEvent as ji, resolveAgentEnvironmentProvider as jn, parseCodexTokenUsage as jr, BudgetReconcileFault as jt, timerAt as k, isSandboxTerminalEvent as ki, providerAsExecutor as kn, harnessSupportsReasoningEffort as kr, parseWorkerToolTraceArtifact as kt, HarnessTurnFailedError as l, recordRuntimeOwnedDriveHarnessProviderEvidence as li, harnessUsageIsEmpty as ln, createOtelExporter as lr, cliWorktreeExecutor as lt, driverExecutorFactory as m, runtimeOwnedPendingExecutorMaterialization as mi, createSandboxForSpec as mn, padSpanId as mr, DEFAULT_SANDBOX_STEERING_MAX_TURNS as mt, createSupervisor as n, awaitAbortable$1 as na, authoredProfileDigest as ni, isLiveNodeStatus as nn, readTraceContextFromEnv as nr, effectiveConcurrency as nt, runFinalizer as o, promptFromAgentTurnInput as oa, knownMaterializationReceipt as oi, bridgeModelRouteRefusal as on, buildLoopSpanNodes as or, bindReusableExecutorExecutionId as ot, driverChild as p, runtimeOwnedExecutorProviderEvidence as pi, TERMINAL_DECISIONS as pn, loopEventToOtelSpan as pr, createWorktreeCliExecutor as pt, attachWorker as q, throwIfAborted as qi, defaultRedactor as qn, unsupportedProfileDimensions as qr, createInbox as qt, bestDelivered as r, DEFAULT_SUCCESSFUL_SHUTDOWN_MS as ra, finalizeRuntimeOwnedPendingExecutor as ri, isTerminalNodeStatus as rn, traceContextToEnv as rr, freeSlots as rt, runTree as s, promptOptionsFromAgentTurnInput as sa, newExecutionAttemptId as si, addHarnessUsage as sn, buildRuntimeEventOtelSpans as sr, captureReusableExecutorConfig as st, createRootHandle as t, abortError$2 as ta, attestRuntimeOwnedScopeOwner as ti, peerMailVerbNames as tn, mergeTraceEnv as tr, errMessage as tt, classifyDriverFailure as u, runtimeOwnedDriveHarnessProviderEvidence as ui, readCodexRolloutSession as un, exportEvalRuns as ur, createExecutor as ut, createScope as v, executableAgentProfileSnapshot as vi, createSandboxLineage as vn, createRuntimeStreamEventCollector as vr, FileSpawnJournal as vt, scopeOwnerExecutorNodeContext as w, assertSandboxServedModel as wi, runBrainLoop as wn, captureWorktreeDiff as wr, pendingWaits as wt, meterRuntimeOwnedProviderAttempt as x, detachedSnapshot as xi, assertBoxlessPromptOptions as xn, sanitizeRuntimeStreamEvent as xr, insideCursorNamespace as xt, deriveNodeExecutionIdentity as y, executableAgentSpecSnapshot as yi, probeSandboxCapabilities as yn, sanitizeAgentRuntimeEvent as yr, InMemoryResultBlobStore as yt, scopeRetainedOwnerResult as z, deleteBoxSafe as zi, recoverRetainedRun as zn, profileMaterializationAxes$1 as zr, readWorkerTraceContext as zt };
+export { startRetainedInteractiveRun as $, resourceTelemetry as $i, persistHarnessTranscript as $n, readCommittedJsonLines as $r, peerMailTools as $t, validateWaitSpec as A, isSandboxTerminalEvent as Ai, resolveAgentEnvironmentProvider as An, harnessSupportsReasoningEffort as Ar, BudgetReconcileFault as At, SPAWN_RESOURCE_PATH_MAX_BYTES as B, deleteBoxSafe as Bi, startRetainedRunInEnvironment as Bn, profileMaterializationAxes$1 as Br, workerTraceHeaders as Bt, restoreScopeOwnerAcceptedExecution as C, projectSandboxOutcome as Ci, runBrainLoop as Cn, runSettledCommand as Cr, pendingWaits as Ct, isWaitOutcome as D, createSandboxToolPartState as Di, createAgentEnvironmentProviderRegistry as Dn, removeWorktree as Dr, isTraceAnalysisStore as Dt, createWaitProbes as E, canonicalStreamEventFromSandboxEvent as Ei, DEFAULT_SANDBOX_IDLE_TIMEOUT_SECONDS as En, createWorktree as Er, captureWorkerTraceEvidence as Et, prepareScopeRetainedOwnerTask as F, sandboxProgressEvents as Fi, registerRetainedExecutorPreparation as Fn, AGENT_PROFILE_MATERIALIZATION_AXES as Fr, spendFromUsageEvents as Ft, readWorkerInteractiveAdmissions as G, sleep as Gi, abortError as Gn, renderProfileMaterializationIssues as Gr, readWorkerProgress as Gt, hostDirectoryReader as H, isAbortError$2 as Hi, destroyInteractiveEnvironment as Hn, promptModelProfileMaterialization as Hr, taskToPrompt as Ht, scopeRetainedOwnerContext as I, sumSandboxUsage as Ii, retainedExecutorSeamKey as In, assertProfileMaterialization as Ir, spendFromUsageTotals as It, readWorkerInteractiveBinding as J, throwIfAborted as Ji, defaultRedactor as Jn, unsupportedProfileDimensions as Jr, DEFAULT_PEER_MAIL_LIMITS as Jt, workerInteractiveAdmissionFile as K, stringifySafe as Ki, linkAbort as Kn, renderUnsupported as Kr, createInbox as Kt, scopeRetainedOwnerPriorSpend as L, addSpend as Li, reconnectRetainedRun as Ln, controlProfileMaterialization as Lr, WORKER_TRACE_PROPAGATION as Lt, bindScopeRetainedOwnerEnvironmentId as M, mapSandboxToolEvent as Mi, createPushTraceSource as Mn, parseCodexTokenUsage as Mr, createBudgetPool as Mt, bindScopeRetainedOwnerProvider as N, notifySandboxEventObserver as Ni, decodeToolPart as Nn, CodexExecutionDiagnosticError as Nr, meterUsageEvent as Nt, pollFor as O, createSandboxUsageLedger as Oi, providerAsExecutor as On, DEFAULT_LOCAL_HARNESS as Or, parseWorkerToolTraceArtifact as Ot, consumeScopeRetainedOwnerResult as P, sandboxEventServedBackend as Pi, sandboxSessionTraceSource as Pn, terminateProcessTreeAndConfirm as Pr, newUsageTotals as Pt, recoverRetainedInteractiveRun as Q, addResourceSpend as Qi, harnessTranscriptArtifact as Qn, prepareJsonlAppend as Qr, isPeerMailEnvelope as Qt, scopeRetainedOwnerResourceReader as R, chargedTokens as Ri, recoverRetainedRun as Rn, defineProfileMaterializationContract as Rr, readWorkerTraceContext as Rt, recordScopeOwnerMaterialization as S, detachedSnapshot as Si, routerBrain as Sn, sanitizeRuntimeStreamEvent as Sr, materializeTreeView as St, settledToIteration as T, assertSandboxServedModel as Ti, observedModelMatchesDeclared as Tn, captureWorktreeDiff as Tr, WORKER_TOOL_TRACE_SCHEMA_VERSION as Tt, resolveSpawnResourcePaths as U, promptCacheTokenClasses as Ui, environmentGone as Un, promptOnlyProfileMaterialization as Ur, DEFAULT_STALL_AFTER_MS as Ut, environmentReader as V, hasCompleteCacheBreakdown as Vi, retainedCreateMaterial as Vn, promptControlProfileMaterialization as Vr, workerTraceSeamKey as Vt, interactiveAdmissionSeamKey as W, randomSuffix as Wi, RunCancellationReason as Wn, promptResourceProfileMaterialization as Wr, createActivityLog as Wt, workerInteractiveBindingsDir as X, withTimeout as Xi, resolveRedactor as Xn, worktreeCliProfileMaterialization as Xr, claimsAuthority as Xt, workerInteractiveBindingFile as Y, unmeteredSpend as Yi, defaultRedactorIdentityMaterial as Yn, validateProfileMaterialization as Yr, PEER_MAIL_WIRE_KEY as Yt, reconnectRetainedInteractiveRun as Z, zeroSpend as Zi, captureHarnessTranscript as Zn, isNoEntError as Zr, createPeerMailbox as Zt, beginScopeOwnerAttempt as _, unknownExecutionBindingReceipt as _i, createSandboxLineage as _n, toOtelAttributes as _r, FileSpawnJournal as _t, pickBestDelivered as a, armDeadlineTimer as aa, inheritRuntimeOwnedExecutorAttestation as ai, bridgeModelRouteRefusal as an, INTELLIGENCE_WIRE_VERSION as ar, bindReusableExecutorExecutionId as at, meterRuntimeOwnedAccounting as b, executableAgentSpecSnapshot as bi, assertBoxlessPromptOptions as bn, sanitizeAgentRuntimeEvent as br, insideCursorNamespace as bt, DriverAttemptsExhaustedError as c, promptFromAgentTurnInput as ca, newExecutionAttemptId as ci, harnessUsageIsEmpty as cn, buildRuntimeEventOtelSpans as cr, cliWorktreeExecutor as ct, defaultUnmetContractSteer as d, runtimeOwnedDriveHarnessProviderEvidence as di, bridgeStopSignalKey as dn, exportEvalRuns as dr, snapshotExecutorConfig as dt, withBudgetResources as ea, writeAllBytes as ei, peerMailVerbNames as en, contentAddress as er, errMessage as et, runDriverWithRetry as f, runtimeOwnedExecutorExecutionBinding as fi, TERMINAL_DECISIONS as fn, flatOtelSpan as fr, createWorktreeCliExecutor as ft, withDriverExecutor as g, runtimeOwnedScopeOwnerRuntime as gi, runAgentRounds as gn, padTraceId as gr, FileResultBlobStore as gt, isDriverSpec as h, runtimeOwnedPendingExecutorMaterialization as hi, isTerminalDecision as hn, padSpanId as hr, createInPlaceCliExecutor as ht, collectDelivered as i, DEFAULT_SUCCESSFUL_SHUTDOWN_MS as ia, finalizeRuntimeOwnedPendingExecutor as ii, bridgeAdmissionRefusal as in, traceContextToEnv as ir, rollingDispatch as it, waitUntil as j, mapSandboxEvent as ji, sandboxClientAsProvider as jn, localHarnessExecutable as jr, assertValidBudget as jt, timerAt as k, extractLlmCallEvent as ki, providerAsSandboxClient as kn, LOCAL_HARNESSES as kr, workerTraceAnalysisStore as kt, HarnessTurnFailedError as l, promptOptionsFromAgentTurnInput as la, providerAttemptEvidence as li, readCodexRolloutSession as ln, createOpenInferenceFileExporter as lr, createExecutor as lt, driverExecutorFactory as m, runtimeOwnedExecutorProviderEvidence as mi, defaultSelectWinner as mn, loopEventToOtelSpan as mr, createSteerableSandboxSession as mt, createSupervisor as n, abortError$2 as na, attestRuntimeOwnedScopeOwner as ni, isTerminalNodeStatus as nn, mergeTraceEnv as nr, freeSlots as nt, runFinalizer as o, teardownExecutor as oa, knownExecutionBindingReceipt as oi, addHarnessUsage as on, buildLoopOtelSpans as or, captureReusableExecutorConfig as ot, driverChild as p, runtimeOwnedExecutorMaterialization as pi, createSandboxForSpec as pn, generateSpanId as pr, DEFAULT_SANDBOX_STEERING_MAX_TURNS as pt, attachWorker as q, throwAbort as qi, runAbortable as qn, sandboxActProfileMaterialization as qr, AUTHORITY_MARKERS as qt, bestDelivered as r, awaitAbortable$1 as ra, authoredProfileDigest as ri, executorFailure as rn, readTraceContextFromEnv as rr, queueOf as rt, runTree as s, teardownSurfaces as sa, knownMaterializationReceipt as si, createCodexRolloutStoreReader as sn, buildLoopSpanNodes as sr, cliInPlaceExecutor as st, createRootHandle as t, decodeHarnessUsage as ta, attestRuntimeOwnedPendingExecutor as ti, isLiveNodeStatus as tn, createPropagatingTraceEmitter as tr, effectiveConcurrency as tt, classifyDriverFailure as u, providerMessageText as ua, recordRuntimeOwnedDriveHarnessProviderEvidence as ui, bridgeRuntimeAttachmentsKey as un, createOtelExporter as ur, createExecutorRegistry as ut, createScope as v, unknownMaterializationReceipt as vi, probeSandboxCapabilities as vn, createRuntimeEventCollector as vr, InMemoryResultBlobStore as vt, scopeOwnerExecutorNodeContext as w, readSandboxOutcome as wi, canonicalObservedModelParts as wn, runWorktreeHarness as wr, replaySpawnTree as wt, meterRuntimeOwnedProviderAttempt as x, detachedFrozen as xi, readPromptOptions as xn, sanitizeKnowledgeReadinessReport as xr, loadSpawnForest as xt, deriveNodeExecutionIdentity as y, executableAgentProfileSnapshot as yi, acquireSandbox as yn, createRuntimeStreamEventCollector as yr, InMemorySpawnJournal as yt, scopeRetainedOwnerResult as z, cloneSpend as zi, startRetainedRun as zn, fullProfileMaterialization as zr, workerTraceEnv as zt };
 
-//# sourceMappingURL=supervisor-BlDW3u0y.js.map
+//# sourceMappingURL=supervisor-CJyzUjc7.js.map