@tangle-network/agent-runtime 0.343.4 → 0.348.1

package/dist/{supervisor-D3M9ab1v.js → supervisor-DDy0aEtR.js}

@@ -1,4 +1,4 @@
-import { i as publishExclusiveDurableFile, n as assertNoSymlinkDescendant, s as sha256 } from "./durable-file-DLcrzrjL.js";
+import { a as publishExclusiveDurableFile, c as captureRunWriteContext, l as fenceRunWrite, p as sha256, r as assertNoSymlinkDescendant, s as writeAtomicDurableFile, t as spawnJournalRecordEvents } from "./record-events-D93DkpAx.js";
 import { c as RetainedInteractiveAdmissionError, d as RetainedRunDispatchBindingError, f as RuntimeRunStateError, i as ConfigError, l as RetainedInteractiveBindingError, m as ValidationError$1, r as BackendTransportError, t as AgentEvalError$1, u as RetainedRunAdmissionError } from "./errors-DodWX-cb.js";
 import { $ as isAbortError$1, B as sha256Bytes$1, Ct as armDeadlineTimer, Dt as singleFlightTeardown, Et as isDeadlineAbortReason, G as addTokenUsage, H as hasControlCharacter, I as deepFreezeCandidate, J as cloneTokenUsage, K as chargedTokens, M as verifyWorkspaceSnapshotArtifacts, Ot as teardownExecutor, Q as hasCompleteCacheBreakdown, St as ROOT_DEADLINE_REASON, Tt as checkInIdleMs, U as abortError, W as addSpend, X as errorMessage, Y as deleteBoxSafe, Z as fnv1a32Hex, _t as withBudgetResources, at as roundBoxMinutes, c as verifyAgentCandidateWorkspaceTree, ct as throwAbort, dt as withTimeout, et as isAsyncIterable, ft as zeroSpend, g as verifiedArtifactChunks, gt as resourceTelemetry, ht as assertResources, it as randomUuid, kt as teardownSurfaces, lt as throwIfAborted, mt as addResourceSpend, nt as promptCacheTokenClasses, o as readAgentCandidateWorkspaceArtifactFiles, ot as sleep, pt as zeroTokenUsage, q as cloneSpend, rt as randomSuffix, s as verifyAgentCandidateWorkspaceArtifacts, st as stringifySafe, t as assertSandboxProfileCompatibility, tt as mapWithConcurrency, ut as unmeteredSpend, v as verifyAgentCandidateWorkspaceArchive, vt as ACCEPTED_RESULT_GRACE_MS, wt as boundedChildDeadlineAt, yt as CHILD_DEADLINE_REASON } from "./sandbox-profile-compat-_fEtHPCj.js";
 import { runTaskQueue } from "./task-queue.js";
@@ -13,7 +13,7 @@ import { REDACTION_VERSION as REDACTION_VERSION$1, redact } from "@tangle-networ
 import { z } from "zod";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
 import { LedgerCanonicalizationError, canonicalString, jsonDocument, merkleLeafHash, merkleRoot, merkleSalt } from "@tangle-network/agent-eval/ledger-core";
-import { appendFileSync, closeSync, constants, createReadStream, existsSync, mkdirSync, openSync, readFileSync } from "node:fs";
+import { appendFileSync, closeSync, constants, createReadStream, existsSync, fstatSync, fsyncSync, ftruncateSync, mkdirSync, openSync, readFileSync, readSync, statSync, writeSync } from "node:fs";
 import { basename, delimiter, dirname, isAbsolute, join, relative, resolve, sep, win32 } from "node:path";
 import { spawn } from "node:child_process";
 import { access, chmod, copyFile, mkdir, mkdtemp, open, readFile, readdir, realpath, rm, rmdir, stat, symlink, writeFile } from "node:fs/promises";
@@ -23,6 +23,7 @@ import { homedir, hostname, tmpdir } from "node:os";
 import { request } from "node:http";
 import { request as request$1 } from "node:https";
 import { Readable } from "node:stream";
+import { AsyncLocalStorage } from "node:async_hooks";
 import { ATTR, deriveHexId, isW3CSpanId, isW3CTraceId } from "@tangle-network/agent-trace-contract";
 import { clearImmediate, setImmediate as setImmediate$1 } from "node:timers";
 //#region src/runtime/turn-input.ts
@@ -3164,7 +3165,7 @@ function leafContinuationExecutionId(nodeId, inputSeq) {
 	return `${nodeId}:input:${inputSeq}`;
 }
 const retainedPreparations = /* @__PURE__ */ new WeakMap();
-/** Reconstruct an admitted manager through its original composition boundary. @internal */
+/** Reconstruct an admitted worker through its original composition boundary. @internal */
 function registerRetainedExecutorPreparation(factory, prepare) {
 	retainedPreparations.set(factory, prepare);
 	return factory;
@@ -4235,8 +4236,8 @@ const CODEX_PERMISSION_PROFILE = "agent_runtime_reproducible";
 * Default per-harness command + arg shape. `buildArgs` takes ONLY the task prompt and
 * emits the prompt-only invocation (no model, no system prompt) — the safe default shape
 * the in-process executor's `streamPrompt` drives. `modelArgs` maps a resolved model to
-* the harness's selector flag, which each harness spells for itself: codex and opencode
-* take `-m <model>`, claude-code and pi take `--model <model>`. The §1.5
+* the harness's selector flag, which each harness spells for itself: codex, kimi-code and
+* opencode take `-m <model>`, claude-code and pi take `--model <model>`. The §1.5
 * profile-aware mapper `harnessInvocation` composes these to thread the full
 * supervisor-authored profile (systemPrompt + model) into argv.
 *
@@ -4259,7 +4260,8 @@ const HARNESS_INVOCATIONS = {
 			},
 			args: (level) => ["--effort", level]
 		},
-		permissionBypassArgs: () => ["--dangerously-skip-permissions"]
+		permissionBypassArgs: () => ["--dangerously-skip-permissions"],
+		profileMcp: true
 	},
 	codex: {
 		command: "codex",
@@ -4283,7 +4285,8 @@ const HARNESS_INVOCATIONS = {
 			"-c",
 			"approval_policy=\"never\""
 		],
-		fullAccessArgs: () => ["--dangerously-bypass-approvals-and-sandbox"]
+		fullAccessArgs: () => ["--dangerously-bypass-approvals-and-sandbox"],
+		profileMcp: true
 	},
 	opencode: {
 		command: "opencode",
@@ -4300,7 +4303,8 @@ const HARNESS_INVOCATIONS = {
 			},
 			args: (level) => ["--variant", level]
 		},
-		permissionBypassArgs: () => ["--auto"]
+		permissionBypassArgs: () => ["--auto"],
+		profileMcp: true
 	},
 	pi: {
 		command: "pi",
@@ -4317,7 +4321,14 @@ const HARNESS_INVOCATIONS = {
 			},
 			args: (level) => ["--thinking", level]
 		},
-		permissionBypassArgs: () => ["--approve"]
+		permissionBypassArgs: () => ["--approve"],
+		profileMcp: true
+	},
+	"kimi-code": {
+		command: "kimi",
+		buildArgs: (taskPrompt) => ["-p", taskPrompt],
+		modelArgs: (model) => ["-m", model],
+		profileMcp: true
 	}
 };
 /** Every local harness, in table order — the one list `AGENT_RUNTIME_LOCAL_HARNESSES` and any
@@ -4331,6 +4342,15 @@ const LOCAL_HARNESSES = Object.keys(HARNESS_INVOCATIONS);
 function harnessSupportsReasoningEffort(harness, reasoningEffort) {
 	return HARNESS_INVOCATIONS[harness].reasoning?.levels[reasoningEffort] !== void 0;
 }
+/**
+* Whether a profile's MCP servers reach this harness on the local-harness path — the row's
+* `profileMcp` claim that the shared materializer's plan names a config surface the installed
+* CLI reads. Admission checks read this so a profile the spawn would silently disarm is
+* rejected BEFORE any workspace state is created, against the same table that emits the argv.
+*/
+function harnessMaterializesProfileMcp(harness) {
+	return HARNESS_INVOCATIONS[harness].profileMcp === true;
+}
 function harnessReasoningArgs(harness, reasoningEffort) {
 	const reasoning = HARNESS_INVOCATIONS[harness].reasoning;
 	const level = reasoning?.levels[reasoningEffort];
@@ -4399,6 +4419,7 @@ function harnessProfileModel(harness, profile) {
 	const provider = profile.model?.provider?.trim();
 	if (!provider) return model;
 	if (harness === "opencode") return model.includes("/") ? model : `${provider}/${model}`;
+	if (harness === "kimi-code") return model;
 	const nativeProvider = harness === "codex" ? "openai" : "anthropic";
 	if (provider !== nativeProvider) throw new Error(`harnessInvocation: ${harness} cannot materialize model provider ${JSON.stringify(provider)}; expected ${nativeProvider}`);
 	return model;
@@ -5377,7 +5398,7 @@ async function runLocalHarness(options) {
 *
 * Git worktree helpers for the in-process delegation executor. Each
 * delegation runs in its own worktree so multiple parallel harness
-* subprocesses (claude / codex / opencode in a 3-way fanout) don't clobber
+* subprocesses (claude / codex / opencode / pi / kimi-code in an N-way fanout) don't clobber
 * each other's edits on the shared workspace.
 *
 * Worktrees live under `<repoRoot>/.agent-worktrees/<runId>/`. After the
@@ -5534,7 +5555,7 @@ async function removeWorktree(options) {
 /**
 *
 * The ONE worktree-harness execution core. The physical act — run a supervisor-authored
-* `AgentProfile` on a local coding-harness CLI (claude / codex / opencode) against a fresh git
+* `AgentProfile` on a local coding-harness CLI (claude / codex / opencode / pi / kimi-code) against a fresh git
 * worktree off `repoRoot`, capture the diff, derive the test/typecheck PASS signals, then clean
 * up — lives here ONCE. Two executors adapt it to two ports without re-implementing it:
 *   - `createWorktreeCliExecutor` — the `Scope`/`Supervisor` leaf `Executor`.
@@ -5871,6 +5892,7 @@ function assertSupportedWorktreeProfile(profile, harness) {
 	const unsupportedAxes = [];
 	const reasoningEffort = profile.model?.reasoningEffort;
 	if (reasoningEffort !== void 0 && !harnessSupportsReasoningEffort(harness, reasoningEffort)) unsupportedAxes.push("model.reasoningEffort");
+	if (hasEnabledProfileMcpServer(profile) && !harnessMaterializesProfileMcp(harness)) unsupportedAxes.push("mcp");
 	if (unsupportedAxes.length > 0) throw new Error(`runWorktreeHarness: profile requests unsupported worktree behavior: ${unsupportedAxes.join(", ")}`);
 }
 function assertSafeMaterializedPaths(plan) {
@@ -5883,6 +5905,9 @@ function isGitMetadataSegment(segment) {
 	const windowsCanonical = segment.replace(/[ .]+$/u, "").toLowerCase();
 	return windowsCanonical === ".git" || windowsCanonical.startsWith(".git:");
 }
+function hasEnabledProfileMcpServer(profile) {
+	return Object.values(profile.mcp ?? {}).some((server) => server.enabled !== false);
+}
 function profileMaterializationReceipt(applied, resourceInstructions) {
 	return {
 		workspacePlanDigest: applied.workspacePlanDigest,
@@ -9037,9 +9062,9 @@ const CONTINUATIONS_DIR = "continuations";
 async function writeContinuationFiles(dir, continuation, files) {
 	const at = join(dir, String(continuation));
 	await mkdir(at, { recursive: true });
-	await writeFile(join(at, "note.md"), `${files.note}\n`, "utf8");
-	await writeFile(join(at, "verdict.json"), `${JSON.stringify(files.verdict ?? null, null, 2)}\n`, "utf8");
-	if (files.panel !== void 0) await writeFile(join(at, "panel.jsonl"), files.panel.map((line) => JSON.stringify(line)).join("\n") + (files.panel.length ? "\n" : ""), "utf8");
+	writeAtomicDurableFile(join(at, "note.md"), `${files.note}\n`);
+	writeAtomicDurableFile(join(at, "verdict.json"), `${JSON.stringify(files.verdict ?? null, null, 2)}\n`);
+	if (files.panel !== void 0) writeAtomicDurableFile(join(at, "panel.jsonl"), files.panel.map((line) => JSON.stringify(line)).join("\n") + (files.panel.length ? "\n" : ""));
 }
 /** The best composite across `reads`, or `undefined` when no read scored. */
 function bestComposite(reads) {
@@ -9249,19 +9274,53 @@ function createContinuationKeeper(input) {
 * executor has produced its output. The inner `score` is preserved; only `valid` is gated.
 */
 function gateOnDeliverable(inner, deliverable) {
-	let gated;
-	const check = async (out, baseScore) => {
-		let delivered;
-		try {
-			delivered = checkVerdictOf(await deliverable.check(out)).pass;
-		} catch {
-			delivered = false;
-		}
-		return {
-			valid: delivered,
-			score: baseScore ?? (delivered ? 1 : 0)
+	return wrapCompletionGate(inner, (result) => checkDeliverable(deliverable, result));
+}
+/** Build a worker with the same check on durable acceptance and normal completion. @internal */
+function gateFactoryOnDeliverable(factory, deliverable) {
+	return (spec, ctx) => {
+		const retention = retainedExecutorContext(ctx);
+		if (retention === void 0) return gateOnDeliverable(factory(spec, ctx), deliverable);
+		const verdicts = /* @__PURE__ */ new WeakMap();
+		const check = (result) => {
+			let verdict = verdicts.get(result);
+			if (verdict === void 0) {
+				verdict = checkDeliverable(deliverable, result);
+				verdicts.set(result, verdict);
+			}
+			return verdict;
 		};
+		const checkedRetention = (source) => ({
+			...source,
+			onResult: async (result) => source.onResult({
+				...result,
+				verdict: await check(result)
+			}),
+			...source.continueInvocation === void 0 ? {} : { continueInvocation: async (task) => checkedRetention(await source.continueInvocation(task)) }
+		});
+		return wrapCompletionGate(factory(spec, {
+			...ctx,
+			seams: {
+				...ctx.seams,
+				[retainedExecutorSeamKey]: checkedRetention(retention)
+			}
+		}), check);
+	};
+}
+async function checkDeliverable(deliverable, result) {
+	let delivered;
+	try {
+		delivered = checkVerdictOf(await deliverable.check(result.out)).pass;
+	} catch {
+		delivered = false;
+	}
+	return {
+		valid: delivered,
+		score: result.verdict?.score ?? (delivered ? 1 : 0)
 	};
+}
+function wrapCompletionGate(inner, check) {
+	let gated;
 	/**
 	* Ask the delivery question once, from whatever the inner executor managed to produce.
 	*
@@ -9275,7 +9334,7 @@ function gateOnDeliverable(inner, deliverable) {
 		} catch {
 			return;
 		}
-		gated = await check(art.out, art.verdict?.score);
+		gated = await check(art);
 	};
 	const gateExecution = (r) => {
 		if (isAsyncIterable(r)) return (async function* () {
@@ -9293,7 +9352,7 @@ function gateOnDeliverable(inner, deliverable) {
 				await settleVerdict();
 				throw error;
 			}
-			gated = await check(res.out, res.verdict?.score);
+			gated = await check(res);
 			return {
 				...res,
 				verdict: gated
@@ -9308,6 +9367,7 @@ function gateOnDeliverable(inner, deliverable) {
 		...inner.traceSource ? { traceSource: () => inner.traceSource?.() } : {},
 		...inner.metered ? { metered: () => inner.metered?.() } : {},
 		...inner.accounting ? { accounting: () => inner.accounting?.() } : {},
+		...inner.resultAccepted ? { resultAccepted: () => inner.resultAccepted?.() === true } : {},
 		...inner.harnessTranscript ? { harnessTranscript: () => inner.harnessTranscript?.() } : {},
 		...inner.harnessTranscriptSettled ? { harnessTranscriptSettled: () => inner.harnessTranscriptSettled?.() ?? Promise.resolve() } : {},
 		execute: (task, signal) => gateExecution(inner.execute(task, signal)),
@@ -11078,13 +11138,15 @@ function recordLaunch(env, ids, options) {
 			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);
-		}
+		fenceRunWrite(() => {
+			const fd = openSync(join(dir, `${host}.jsonl`), "a", 384);
+			try {
+				appendFileSync(fd, node);
+				appendFileSync(fd, edge);
+			} finally {
+				closeSync(fd);
+			}
+		});
 	} catch {}
 }
 //#endregion
@@ -12925,7 +12987,7 @@ function bridgeOutputText(out) {
 }
 /**
 * The leaf `createWorktreeCliExecutor` as a backend-as-data factory: a supervisor-authored
-* `AgentProfile` driving claude / codex / opencode on its own worktree. `budgetExempt` like
+* `AgentProfile` driving claude / codex / opencode / pi / kimi-code on its own worktree. `budgetExempt` like
 * the other CLI leaves; the authored systemPrompt + model reach the harness via §1.5.
 */
 //#endregion
@@ -13085,7 +13147,7 @@ const routerToolsSeamKey = "router-tools";
 /**
 *
 * The worktree-CLI leaf executor — a supervisor-authored `AgentProfile` driving a local
-* coding-harness CLI (claude / codex / opencode) on its OWN git worktree, surfaced as the open
+* coding-harness CLI (claude / codex / opencode / pi / kimi-code) on its OWN git worktree, surfaced as the open
 * `Executor<Out>` port (`./types`). It is a LEAF executor: it plugs straight into the
 * `Scope`/`Supervisor` recursion and `gateOnDeliverable`, so it IS the canonical recursive path
 * (no `runAgentRounds`/virtual-SandboxInstance shim in between).
@@ -23649,7 +23711,7 @@ var SpawnEventIndex = class {
 		}
 		if (!outsideCursorNamespace(event) && this.cursors.has(event.seq)) throw new Error(`spawn journal corrupted: duplicate cursor seq ${event.seq} in tree '${this.root}'; the cursor order replay relies on is not unique`);
 	}
-	/** Called only after validation and, for the file writer, a successful durable append. */
+	/** Called after validation; a file writer discards staged state if grouped publication fails. */
 	add(event) {
 		if (!outsideCursorNamespace(event)) this.cursors.add(event.seq);
 		if (event.kind !== "spawned" && event.kind !== "materialized" && event.kind !== "seat-materialized" && event.kind !== "execution-bound" && event.kind !== "execution-input" && event.kind !== "execution-admitted" && event.kind !== "execution-result" && event.kind !== "execution-abandoned" && event.kind !== "environment-teardown" && event.kind !== "environment-terminal" && !closesCursorSlot(event)) return;
@@ -23796,6 +23858,7 @@ const outsideKinds = /* @__PURE__ */ new Set([
 	"seat-segment",
 	"seat-materialized",
 	"seat-paused",
+	"run-parked",
 	"root-segment",
 	"root-reentered",
 	"reopened",
@@ -23815,6 +23878,81 @@ function insideCursorNamespace(ev) {
 	return !outsideKinds.has(ev.kind);
 }
 //#endregion
+//#region src/durable/jsonl-append.ts
+/** Commit JSONL bytes and validate their descriptor under one generation fence. @internal */
+function commitJsonLine(path, record, acknowledge) {
+	const encoded = JSON.stringify(record);
+	if (encoded === void 0) throw new TypeError("JSONL records must be JSON serializable");
+	return fenceRunWrite(() => {
+		const separator = prepareJsonlTail(path);
+		const fd = openSync(path, "a");
+		try {
+			const bytes = Buffer.from(`${separator ? "\n" : ""}${encoded}\n`);
+			let offset = 0;
+			while (offset < bytes.length) {
+				const written = writeSync(fd, bytes, offset, bytes.length - offset);
+				if (written <= 0) throw new Error(`append-only file write made no progress at byte ${offset}`);
+				offset += written;
+			}
+			fsyncSync(fd);
+			return acknowledge?.(fd);
+		} finally {
+			closeSync(fd);
+		}
+	});
+}
+/** Recover only an uncommitted tail. Caller holds the generation fence. @internal */
+function prepareJsonlTail(path) {
+	let fd;
+	try {
+		fd = openSync(path, "r+");
+	} catch (error) {
+		if (error.code === "ENOENT") return false;
+		throw error;
+	}
+	try {
+		const size = fstatSync(fd).size;
+		if (size === 0) return false;
+		const last = Buffer.allocUnsafe(1);
+		readAt(fd, last, size - 1);
+		if (last[0] === 10) return false;
+		const chunks = [];
+		let end = size;
+		let tailStart = 0;
+		while (end > 0) {
+			const start = Math.max(0, end - 65536);
+			const chunk = Buffer.allocUnsafe(end - start);
+			readAt(fd, chunk, start);
+			const newline = chunk.lastIndexOf(10);
+			chunks.push(chunk.subarray(newline + 1));
+			if (newline >= 0) {
+				tailStart = start + newline + 1;
+				break;
+			}
+			end = start;
+		}
+		try {
+			JSON.parse(Buffer.concat(chunks.reverse()).toString("utf8"));
+			return true;
+		} catch (error) {
+			if (!(error instanceof SyntaxError)) throw error;
+			ftruncateSync(fd, tailStart);
+			fsyncSync(fd);
+			return false;
+		}
+	} finally {
+		closeSync(fd);
+	}
+}
+function readAt(fd, buffer, position) {
+	let offset = 0;
+	while (offset < buffer.length) {
+		const read = readSync(fd, buffer, offset, buffer.length - offset, position + offset);
+		if (read === 0) throw new Error("journal changed while preparing its append tail");
+		offset += read;
+	}
+}
+//#endregion
 //#region src/durable/jsonl-file.ts
 /** Read a fixed file prefix one record at a time, never allocating the whole journal as a string.
 * A reader cannot chase concurrent appends forever. Missing files are empty only when requested;
@@ -23878,16 +24016,7 @@ function parseRecord(line, source, lineNumber, terminated, allowWhitespaceLines
 	}
 }
 async function appendCommittedJsonLine(path, record, acknowledge) {
-	const fs = await import("node:fs/promises");
-	const needsSeparator = await prepareJsonlAppend(path);
-	const handle = await fs.open(path, "a");
-	try {
-		await writeAllBytes(handle, `${needsSeparator ? "\n" : ""}${JSON.stringify(record)}\n`);
-		await handle.sync();
-		return await acknowledge?.(handle);
-	} finally {
-		await handle.close();
-	}
+	return commitJsonLine(path, record, acknowledge);
 }
 /** Serialize JSONL file updates across processes and aliases using Eval's existing file lock.
 * The caller owns validation and the record format. The lock path names the canonical file,
@@ -23943,74 +24072,12 @@ async function upsertCommittedJsonLine(path, record, key) {
 		allowWhitespaceLines: true
 	})) if (key(prior) !== id) updated.push(prior);
 	updated.push(snapshot);
-	const { writeAtomicDurableFile } = await import("./durable-file-DLcrzrjL.js").then((n) => n.r);
+	const { writeAtomicDurableFile } = await import("./record-events-D93DkpAx.js").then((n) => n.i);
 	writeAtomicDurableFile(path, `${updated.map((row) => JSON.stringify(row)).join("\n")}\n`, { preserveMode: true });
 }
-/** FileHandle.write may legally make a short write. Loop until every byte is appended. */
-async function writeAllBytes(handle, value) {
-	const bytes = typeof value === "string" ? Buffer.from(value) : Buffer.from(value);
-	let offset = 0;
-	while (offset < bytes.byteLength) {
-		const { bytesWritten } = await handle.write(bytes, offset, bytes.byteLength - offset, null);
-		if (bytesWritten <= 0) throw new Error(`append-only file write made no progress at byte ${offset}`);
-		offset += bytesWritten;
-	}
-}
-/** Prepare the tail under the journal owner's existing single-writer discipline.
-* Healthy appends read one byte, regardless of history size. Only recovery scans backward,
-* retaining a valid unterminated value or truncating an uncommitted torn tail. */
+/** Recover a torn tail under the same generation fence as durable publications. @internal */
 async function prepareJsonlAppend(path) {
-	const fs = await import("node:fs/promises");
-	let handle;
-	try {
-		handle = await fs.open(path, "r+");
-	} catch (error) {
-		if (isNoEntError(error)) return false;
-		throw error;
-	}
-	try {
-		const size = (await handle.stat()).size;
-		if (size === 0) return false;
-		const lastByte = Buffer.allocUnsafe(1);
-		await readAt(handle, lastByte, size - 1);
-		if (lastByte[0] === 10) return false;
-		const chunks = [];
-		let end = size;
-		let tailStart = 0;
-		while (end > 0) {
-			const start = Math.max(0, end - 65536);
-			const chunk = Buffer.allocUnsafe(end - start);
-			await readAt(handle, chunk, start);
-			const newline = chunk.lastIndexOf(10);
-			chunks.push(chunk.subarray(newline + 1));
-			if (newline >= 0) {
-				tailStart = start + newline + 1;
-				break;
-			}
-			end = start;
-		}
-		const tail = Buffer.concat(chunks.reverse()).toString("utf8");
-		try {
-			JSON.parse(tail);
-			return true;
-		} catch (error) {
-			if (!(error instanceof SyntaxError)) throw error;
-			await handle.truncate(tailStart);
-			await handle.sync();
-			return false;
-		}
-	} finally {
-		await handle.close();
-	}
-}
-/** A short read is legal; an unexpected EOF means the owner's snapshot changed. */
-async function readAt(handle, buffer, position) {
-	let offset = 0;
-	while (offset < buffer.length) {
-		const { bytesRead } = await handle.read(buffer, offset, buffer.length - offset, position + offset);
-		if (bytesRead === 0) throw new Error("journal changed while preparing its append tail");
-		offset += bytesRead;
-	}
+	return fenceRunWrite(() => prepareJsonlTail(path));
 }
 /** True for a filesystem error meaning "the file is not there yet" — the one condition an
 *  append-only reader treats as an empty log rather than a fault. */
@@ -24028,16 +24095,19 @@ function isNoEntError(error) {
 */
 var FileResultBlobStore = class {
 	dir;
+	writeContext = captureRunWriteContext();
 	constructor(dir) {
 		this.dir = dir;
 	}
 	async put(outRef, artifact) {
-		const { text } = encodeResultBlob(outRef, artifact);
-		const filePath = this.blobPath(outRef);
-		assertNoSymlinkDescendant(this.dir, filePath, "result blob");
-		await (await import("node:fs/promises")).mkdir(this.dir, { recursive: true });
-		assertNoSymlinkDescendant(this.dir, filePath, "result blob");
-		if (!publishExclusiveDurableFile(filePath, text, { mode: 384 })) assertContentAddress(outRef, await this.get(outRef));
+		return this.writeContext(async () => {
+			const { text } = encodeResultBlob(outRef, artifact);
+			const filePath = this.blobPath(outRef);
+			assertNoSymlinkDescendant(this.dir, filePath, "result blob");
+			await (await import("node:fs/promises")).mkdir(this.dir, { recursive: true });
+			assertNoSymlinkDescendant(this.dir, filePath, "result blob");
+			if (!publishExclusiveDurableFile(filePath, text, { mode: 384 })) assertContentAddress(outRef, await this.get(outRef));
+		});
 	}
 	async get(outRef) {
 		const filePath = this.blobPath(outRef);
@@ -24833,6 +24903,10 @@ function noteScopeRetainedOwnerCoordination(scope) {
 		delete state.checkpointing;
 	});
 }
+/** @internal The checkpoint in progress for this owner, for a test or a release to wait on. */
+function scopeRetainedOwnerCheckpointing(scope) {
+	return owners.get(scope)?.checkpointing;
+}
 async function checkpointOwnerWorkspace(scope, state) {
 	const { provider, args } = state;
 	if (provider === void 0) return;
@@ -25677,10 +25751,11 @@ const ABANDON_STOP_TIMEOUT_MS = 3e4;
 * Abandon the owner's in-flight invocation, which the driver retry loop asks for when the same
 * reconciliation keeps failing the same way (`DriverRetryRun.resolvePending`).
 *
-* Runtime stops the invocation at the provider when it had dispatched, then journals what the
-* provider confirmed. The journal refuses every later admission or result of the invocation, so
-* only the replacement the next {@link prepareScopeRetainedOwnerTask} starts can commit a result.
-* Answers `false`, journaling nothing, when this owner has no unfinished invocation to abandon.
+* Runtime abandons only after the provider confirms the dispatched execution stopped or is no
+* longer live. An intent without a dispatch reference, or an unconfirmed stop, keeps the original
+* invocation recoverable under the same identity. The journal refuses every later admission or
+* result of an abandoned invocation, so only its replacement can commit a result. Answers `false`,
+* journaling nothing, when there is no unfinished invocation or its native stop is unconfirmed.
 */
 async function abandonScopeRetainedOwnerInvocation(scope, failure, failures) {
 	const state = owners.get(scope);
@@ -25699,7 +25774,7 @@ async function abandonScopeRetainedOwnerInvocation(scope, failure, failures) {
 		now: args.now
 	});
 	scope.signal.throwIfAborted();
-	const stopped = stop?.effect === "cancelled" || stop?.effect === "not_live";
+	if (!(stop?.effect === "cancelled" || stop?.effect === "not_live")) return false;
 	await args.journal.appendEvent(args.rootId, {
 		kind: "execution-abandoned",
 		id: args.nodeId,
@@ -25707,7 +25782,7 @@ async function abandonScopeRetainedOwnerInvocation(scope, failure, failures) {
 		pendingCause: failure.pendingCause,
 		failures,
 		detail: errorText(errMessage(failure)).slice(0, 2048),
-		outcome: stopped ? "stopped" : "uncertain",
+		outcome: "stopped",
 		...stop === void 0 ? {} : { stop: {
 			executionId: stop.executionId,
 			effect: stop.effect,
@@ -25740,8 +25815,8 @@ async function prepareScopeRetainedOwnerTask(scope, task, session = "native") {
 	}
 	if (state.taskRef !== void 0 && state.acceptedRef === void 0) await abandonInputAdmittedIntoDebt(state, await reconcileOwnerWorkspaceBeforeReuse(state, scope.signal));
 	const unusable = unusableEnvironmentIds(owned);
-	const inFlight = continuedEnvironment(owned);
-	if (inFlight?.inFlight && unusable.has(inFlight.admission.environmentId)) {
+	const currentEnvironment = state.admissions.find((admission) => admission.phase === "environment");
+	if (state.acceptedRef === void 0 && currentEnvironment?.phase === "environment" && unusable.has(currentEnvironment.environmentId)) {
 		delete state.inputSequence;
 		delete state.taskRef;
 		state.admissions.length = 0;
@@ -28216,7 +28291,7 @@ async function appendSpawnEvents(journal, root, events) {
 }
 /**
 * JSONL on disk. One line per record: the first record is `begin`, subsequent records
-* are `event` envelopes wrapping a `SpawnEvent`. `loadTree` replays the whole file,
+* are `event` or atomic `events` envelopes. `loadTree` replays the whole file,
 * filtering by `root`, and applies the same begin-precedes-events + unique-seq
 * corruption guards as the in-memory impl. Each append fsyncs so a crash between
 * writes never loses an acknowledged event.
@@ -28225,6 +28300,7 @@ async function appendSpawnEvents(journal, root, events) {
 */
 var FileSpawnJournal = class {
 	path;
+	writeContext = captureRunWriteContext();
 	appendTail = Promise.resolve();
 	appendIndex;
 	constructor(path) {
@@ -28239,9 +28315,11 @@ var FileSpawnJournal = class {
 			if (record.kind === "begin") begun = true;
 			else {
 				if (!begun) throw new Error(`spawn journal corrupted: event for tree '${root}' precedes its begin record`);
-				index.assert(record.event);
-				index.add(record.event);
-				events.push(record.event);
+				for (const event of spawnJournalRecordEvents(record)) {
+					index.assert(event);
+					index.add(event);
+					events.push(event);
+				}
 			}
 		}
 		return begun ? events : void 0;
@@ -28280,6 +28358,28 @@ var FileSpawnJournal = class {
 			tree.index.add(event);
 		});
 	}
+	async appendEvents(root, events) {
+		const captured = detachedSnapshot(events, "spawn events");
+		return this.serializeAppend(async () => {
+			const state = await this.validationIndex();
+			const tree = state.trees.get(root);
+			if (tree === void 0) throw new Error(`appendEvents called for unknown spawn tree '${root}'; call beginTree first`);
+			try {
+				for (const event of captured) {
+					tree.index.assert(event);
+					tree.index.add(event);
+				}
+				state.stamp = await this.writeRecord({
+					kind: "events",
+					root,
+					events: captured
+				});
+			} catch (error) {
+				this.appendIndex = void 0;
+				throw error;
+			}
+		});
+	}
 	async validationIndex() {
 		const stamp = await this.fileStamp();
 		if (this.appendIndex && this.appendIndex.stamp === stamp) return this.appendIndex;
@@ -28293,8 +28393,10 @@ var FileSpawnJournal = class {
 		} else {
 			const tree = trees.get(record.root);
 			if (!tree) throw new Error(`spawn journal corrupted: event for tree '${record.root}' precedes its begin record`);
-			tree.index.assert(record.event);
-			tree.index.add(record.event);
+			for (const event of spawnJournalRecordEvents(record)) {
+				tree.index.assert(event);
+				tree.index.add(event);
+			}
 		}
 		if (await this.fileStamp() !== stamp) throw new Error("spawn journal changed while rebuilding its append index");
 		this.appendIndex = {
@@ -28313,7 +28415,7 @@ var FileSpawnJournal = class {
 		}
 	}
 	async serializeAppend(operation) {
-		const append = this.appendTail.then(operation);
+		const append = this.appendTail.then(() => this.writeContext(operation));
 		this.appendTail = append.catch(() => void 0);
 		return append;
 	}
@@ -28322,9 +28424,9 @@ var FileSpawnJournal = class {
 		const { dirname } = await import("node:path");
 		try {
 			await fs.mkdir(dirname(this.path), { recursive: true });
-			return await appendCommittedJsonLine(this.path, record, async (handle) => {
-				const stamp = journalFileStamp(await handle.stat({ bigint: true }));
-				if (await this.fileStamp() !== stamp) throw new Error("spawn journal changed while acknowledging its append");
+			return await appendCommittedJsonLine(this.path, record, (fd) => {
+				const stamp = journalFileStamp(fstatSync(fd, { bigint: true }));
+				if (journalFileStamp(statSync(this.path, { bigint: true })) !== stamp) throw new Error("spawn journal changed while acknowledging its append");
 				return stamp;
 			});
 		} catch (error) {
@@ -28860,10 +28962,11 @@ function workerLifecycle(eventDir, workerId) {
 		const text = line.trim();
 		if (!text) continue;
 		try {
-			const record = JSON.parse(text);
-			if (record.kind !== "event" || record.event?.id !== workerId) continue;
-			if (record.event.kind === "spawned") spawned = true;
-			if (record.event.kind === "settled" || record.event.kind === "cancelled") terminal = true;
+			for (const event of spawnJournalRecordEvents(JSON.parse(text))) {
+				if (event?.id !== workerId) continue;
+				if (event.kind === "spawned") spawned = true;
+				if (event.kind === "settled" || event.kind === "cancelled") terminal = true;
+			}
 		} catch {}
 	}
 	return {
@@ -29966,19 +30069,18 @@ async function prepareInterruptedExecutors(opts, events, signal, now, parentId =
 		const profile = shareParsedStrings(agentProfileSchema.parse(await opts.blobs.get(node.profileRef)), parsedStrings);
 		const task = shareParsedStrings(await opts.blobs.get(taskRef), parsedStrings);
 		if (canonicalAgentProfileDigest(profile) !== node.identity.profileDigest || canonicalCandidateDigest(task) !== node.identity.taskDigest) throw new RuntimeRunStateError(`recovery inputs for '${node.id}' do not match its admitted identity`);
-		let prepared;
 		if (node.ownedTreeRoot !== void 0) {
 			if (node.ownedTreeRoot !== nestedDriverTreeRoot(opts.runId, node.id)) throw new RuntimeRunStateError(`retained manager '${node.id}' changed its owned tree`);
 			const nested = await opts.journal.loadTree(node.ownedTreeRoot);
 			const roots = nested?.filter((event) => event.kind === "spawned" && event.parent === void 0) ?? [];
 			if (nested?.length && (roots.length !== 1 || contentAddress(roots[0]) !== contentAddress(ownedTreeRootSpawn(node)))) throw new RuntimeRunStateError(`retained manager '${node.id}' has conflicting subtree ownership`);
-			prepared = prepareRetainedExecutor(opts.recoverExecutor, {
-				spawned: node,
-				profile,
-				task
-			});
-			if (!prepared) continue;
 		}
+		const prepared = prepareRetainedExecutor(opts.recoverExecutor, {
+			spawned: node,
+			profile,
+			task
+		});
+		if (node.ownedTreeRoot !== void 0 && !prepared) continue;
 		const priorMaterialization = [...owned].reverse().find((event) => event.kind === "materialized" || event.kind === "seat-materialized")?.receipt;
 		const continuation = latestInput !== void 0 && inputs.length > 1 && node.ownedTreeRoot === void 0 ? await leafContinuation(node, owned, latestInput, opts) : latestInput !== void 0 && node.continues !== void 0 && admissions.length === 0 && node.ownedTreeRoot === void 0 ? heldContinuation(node, events, latestInput) : void 0;
 		recoveries.push({
@@ -31683,7 +31785,8 @@ const driverExecutorFactory = (rawSpec, ctx) => {
 				accounting = partial?.accounting;
 				const events = await journal.loadTree(nestedRoot).catch(() => void 0);
 				const settledIds = new Set(events?.filter((event) => event.kind === "settled" || event.kind === "cancelled").map((event) => event.id));
-				if (events?.some((event) => event.kind === "execution-admitted" && event.id === seam.nodeId || event.kind === "spawned" && event.parent !== void 0 && event.runtime !== "inline" && !settledIds.has(event.id))) throw new RetainedExecutionPendingError(err, "nested-recovery");
+				const terminalAdmissionRefusal = isTerminalAdmissionRefusal(err);
+				if (driver.resultAccepted?.() === true || spec.acceptedSubmission?.() === true || events?.some((event) => event.kind === "execution-admitted" && (event.admission.phase === "dispatched" || event.id === seam.nodeId && (event.admission.phase !== "intent" || !terminalAdmissionRefusal)) || event.kind === "execution-result" || event.kind === "spawned" && event.parent !== void 0 && !settledIds.has(event.id))) throw new RetainedExecutionPendingError(err, "nested-recovery");
 				if (cleanupError !== void 0) throw cleanupError;
 				throw err;
 			} finally {
@@ -31750,6 +31853,11 @@ function withDriverExecutor(base) {
 		}
 	};
 }
+/** Positive pre-dispatch refusal evidence; a missing dispatch record proves nothing by itself. */
+function isTerminalAdmissionRefusal(error) {
+	const failure = error instanceof DriverAttemptsExhaustedError && error.stop === "terminal-error" ? error.cause : error;
+	return (isCredentialRefusal(failure) || failure instanceof RetainedExecutionPendingError && failure.phase === "admission" && failure.pendingCause === "request-rejected") && classifyDriverFailure(failure) === "terminal";
+}
 async function closeNestedScope(scope, controller, reason) {
 	if (!controller.signal.aborted) controller.abort(reason);
 	for (;;) if (await scope.next() === null) break;
@@ -32046,6 +32154,156 @@ async function runFinalizer(finalizer, args) {
 	return await accepted(candidate) ? candidate : void 0;
 }
 //#endregion
+//#region src/runtime/supervise/run-parking.ts
+/** Read the journal's bounded parking projection. Undefined means no current parking handoff. */
+async function readRunParking(runDir) {
+	let raw;
+	try {
+		raw = await readFile(resolve(runDir, "parking.json"), "utf8");
+	} catch (error) {
+		if (error.code === "ENOENT") return void 0;
+		throw error;
+	}
+	const record = JSON.parse(raw);
+	if (record === null || typeof record !== "object") throw new Error("invalid run parking record");
+	const data = record;
+	if (data.status === "resuming") return void 0;
+	if (data.status !== "parked" || typeof data.runId !== "string" || ![
+		"seat-wait",
+		"paused-root",
+		"deadline"
+	].includes(String(data.reason)) || typeof data.since !== "string" || !Number.isFinite(Date.parse(data.since)) || typeof data.wakeAt !== "string" || !Number.isFinite(Date.parse(data.wakeAt))) throw new Error("invalid run parking record");
+	return Object.freeze({
+		runId: data.runId,
+		reason: data.reason,
+		since: data.since,
+		wakeAt: data.wakeAt
+	});
+}
+/** A resumable wait, with no terminal result or failure. Catch it and let the coordinator exit. */
+var RunParkedError = class extends Error {
+	runId;
+	parking;
+	constructor(runId, parking) {
+		super(`run '${runId}' parked (${parking.reason}) until ${parking.wakeAt}`);
+		this.runId = runId;
+		this.parking = parking;
+		this.name = "RunParkedError";
+	}
+};
+const DEFAULT_PARK_AFTER_MS = 6e4;
+const parkingContext = new AsyncLocalStorage();
+const parkingDrains = /* @__PURE__ */ new WeakMap();
+/** Drain committed child work through the existing manager ledger before testing root idleness. */
+function bindScopeParkingDrain(scope, drain, idle) {
+	parkingDrains.set(scope, {
+		drain,
+		idle
+	});
+}
+/** Validate at intake, before any execution or ownership acquisition. */
+function assertRunParking(policy, durable) {
+	if (policy === void 0) return;
+	if (!durable) throw new ValidationError$1("supervise: parking requires runDir");
+	if (policy === null || typeof policy !== "object" || policy.afterMs !== void 0 && (!Number.isFinite(policy.afterMs) || policy.afterMs < 0)) throw new ValidationError$1("supervise: parking.afterMs must be a nonnegative finite number");
+}
+/** Scope the handoff to one execution, preserving the original wake time on an early re-entry. */
+async function withRunParking(policy, runDir, runId, journal, now, signal, run) {
+	if (policy === void 0 || runDir === void 0) return run();
+	const events = await journal.loadTree(runId) ?? [];
+	const previous = [...events].reverse().find((event) => event.kind === "run-parked");
+	const transition = [...events].reverse().find((event) => event.id === runId && (event.kind === "run-parked" || event.kind === "root-reentered" || event.kind === "reopened"));
+	const current = transition?.kind === "run-parked" ? transition : void 0;
+	if (current !== void 0 && Date.parse(current.wakeAt) > now() && !signal?.aborted) {
+		await writeParkingProjection(runDir, runId, current);
+		throw new RunParkedError(runId, parkingRecordOf(current));
+	}
+	if (previous !== void 0) await writeAtomicDurableFile(resolve(runDir, "parking.json"), JSON.stringify({
+		status: "resuming",
+		runId,
+		...parkingRecordOf(previous),
+		resumedAt: new Date(now()).toISOString()
+	}));
+	return parkingContext.run({
+		runDir,
+		runId,
+		journal,
+		now,
+		afterMs: policy.afterMs ?? DEFAULT_PARK_AFTER_MS
+	}, run);
+}
+/**
+* Sleep through the existing wait path. A root with no live descendants may hand off after its
+* idle threshold; children and roots with active work keep their normal wait. No timer survives
+* the handoff, and no provider work is cancelled or terminal settlement written for parking.
+*/
+async function sleepScopeWait(scope, ms, signal, reason) {
+	if (ms <= 0 || signal.aborted) return;
+	const context = parkingContext.getStore();
+	const onlyRootWait = () => context !== void 0 && scope.view.root === context.runId && parkingDrains.get(scope)?.idle() !== false && scope.workerCapacity.unconfirmed.length === 0 && !(scope.observeTree?.() ?? scope.view).nodes.some((node) => node.id !== context.runId && isLiveNodeStatus(node.status));
+	if (context === void 0 || scope.view.root !== context.runId || ms <= context.afterMs) return sleep(ms, signal, false);
+	const since = context.now();
+	const deadline = scope.budget.deadlineMs;
+	const wakeAt = Math.min(since + ms, deadline > 0 ? deadline : Number.POSITIVE_INFINITY);
+	if (wakeAt - since <= context.afterMs) return sleep(ms, signal, false);
+	let idleSince = onlyRootWait() ? since : void 0;
+	for (;;) {
+		const remaining = Math.max(0, wakeAt - context.now());
+		if (remaining <= context.afterMs) return sleep(remaining, signal, false);
+		const checkMs = context.afterMs || (idleSince === void 0 ? DEFAULT_PARK_AFTER_MS : 0);
+		await sleep(Math.min(checkMs, remaining), signal, false);
+		if (signal.aborted) return;
+		await parkingDrains.get(scope)?.drain();
+		if (!onlyRootWait()) {
+			idleSince = void 0;
+			continue;
+		}
+		if (idleSince === void 0) {
+			idleSince = context.now();
+			continue;
+		}
+		if (context.now() - idleSince < context.afterMs) continue;
+		const events = await context.journal.loadTree(context.runId) ?? [];
+		if (signal.aborted) return;
+		const ownerEvents = events.filter((event) => event.id === context.runId);
+		const input = [...ownerEvents].reverse().find((event) => event.kind === "execution-input");
+		const invocation = input === void 0 ? [] : ownerEvents.slice(ownerEvents.indexOf(input));
+		if (invocation.some((event) => event.kind === "execution-admitted") && !invocation.some((event) => event.kind === "execution-result" || event.kind === "execution-abandoned" && event.outcome === "stopped") || !onlyRootWait()) {
+			idleSince = void 0;
+			continue;
+		}
+		const parking = {
+			reason: deadline > 0 && wakeAt === deadline ? "deadline" : reason,
+			since: new Date(idleSince).toISOString(),
+			wakeAt: new Date(wakeAt).toISOString()
+		};
+		closeScopeAdmission(scope);
+		await context.journal.appendEvent(context.runId, {
+			kind: "run-parked",
+			id: context.runId,
+			...parking,
+			seq: events.filter((event) => event.kind === "run-parked").length,
+			at: new Date(context.now()).toISOString()
+		});
+		await writeParkingProjection(context.runDir, context.runId, parking);
+		throw new RunParkedError(context.runId, parking);
+	}
+}
+async function writeParkingProjection(runDir, runId, parking) {
+	await writeAtomicDurableFile(resolve(runDir, "parking.json"), JSON.stringify({
+		status: "parked",
+		runId,
+		...parkingRecordOf(parking)
+	}));
+}
+function parkingRecordOf(record) {
+	return {
+		reason: record.reason,
+		since: record.since,
+		wakeAt: record.wakeAt
+	};
+}
+//#endregion
 //#region src/durable/spawn-journal/provider-model-evidence.ts
 /**
 * Aggregate provider-served model evidence across one recursively owned journal forest.
@@ -33192,6 +33450,7 @@ async function executeRoot(root) {
 	};
 	let executionAborted = controller.signal.aborted;
 	let allChildrenDownAtSettle = false;
+	let parked = false;
 	try {
 		await startScopeRecoveries(scope);
 		actOutcome = {
@@ -33199,6 +33458,10 @@ async function executeRoot(root) {
 			out: await runAbortable(root.run, controller.signal, "supervisor aborted")
 		};
 	} catch (error) {
+		if (error instanceof RunParkedError && error.runId === opts.runId) {
+			parked = true;
+			throw error;
+		}
 		actOutcome = {
 			ok: false,
 			error
@@ -33209,26 +33472,31 @@ async function executeRoot(root) {
 		allChildrenDownAtSettle = allSpawnedChildrenDown(runTree(scope));
 		if (!controller.signal.aborted && deadline.atMs > 0 && now() >= deadline.atMs) deadline.exceeded = true;
 		deadline.clear();
-		const settleGraceMs = !controller.signal.aborted ? boundedSettleGrace(opts.childSettleGraceMs, deadline.atMs, now) : 0;
-		try {
-			await joinRunChildren(join, settleGraceMs);
-		} catch (error) {
-			if (actOutcome?.ok !== false) actOutcome = {
-				ok: false,
-				error
-			};
-		}
-		if (!persistence.failed) try {
-			await finalizeScopeOwnerMaterialization(scope);
-		} catch (error) {
-			if (actOutcome?.ok !== false) actOutcome = {
-				ok: false,
-				error
-			};
-		}
-		if (persistence.failed) {
-			await waitForScopeChildren(scope);
-			await persistence.drain();
+		if (!parked) {
+			const settleGraceMs = !controller.signal.aborted ? boundedSettleGrace(opts.childSettleGraceMs, deadline.atMs, now) : 0;
+			try {
+				await joinRunChildren(join, settleGraceMs);
+			} catch (error) {
+				if (actOutcome?.ok !== false) actOutcome = {
+					ok: false,
+					error
+				};
+			}
+			if (!persistence.failed) try {
+				await finalizeScopeOwnerMaterialization(scope);
+			} catch (error) {
+				if (actOutcome?.ok !== false) actOutcome = {
+					ok: false,
+					error
+				};
+			}
+			if (persistence.failed) {
+				await waitForScopeChildren(scope);
+				await persistence.drain();
+			}
+		} else {
+			await scopeRetainedOwnerCheckpointing(scope);
+			await scopeRetainedOwnerSettled(scope);
 		}
 		executionAborted ||= cascade.aborted();
 		cascade.detach();
@@ -33318,6 +33586,6 @@ async function noWinner(settled, rejection) {
 	};
 }
 //#endregion
-export { beginScopeRetainedOwnerDrive as $, sumSandboxUsage as $i, upstreamUnavailableSignal as $n, finalizeRuntimeOwnedPendingExecutor as $r, destroyInteractiveEnvironment as $t, coordinationProfileToolPrefix as A, detachedFrozen as Ai, createInbox as An, bridgeStopSignalKey as Ar, readPromptOptions as At, meterRuntimeOwnedProviderAttempt as B, assertValidBudget as Bi, taskToPrompt$1 as Bn, fullProfileMaterialization as Br, toolResultText as Bt, FileSpawnJournal as C, cappedDoublingMs as Ci, padTraceId as Cn, readCodexRolloutSession as Cr, captureReusableExecutorConfig as Ct, restoreScopeOwnerAcceptedExecution as D, unavailableSignalOfFailure as Di, sanitizeKnowledgeReadinessReport as Dn, runAbortable as Dr, createSteerableSandboxSession as Dt, recordScopeOwnerMaterialization as E, unavailableResumeAt as Ei, createRuntimeStreamEventCollector as En, linkAbort as Er, DEFAULT_SANDBOX_STEERING_MAX_TURNS as Et, deriveNodeExecutionIdentity as F, createBudgetPool as Fi, claimsAuthority as Fn, terminateProcessTreeAndConfirm as Fr, defaultSelectWinner as Ft, scopeRetainedOwnerResourceReader as G, mapSandboxEvent as Gi, isTerminalNodeStatus as Gn, sandboxActProfileMaterialization as Gr, providerAsExecutor as Gt, recordScopeOwnerDriverAttempt as H, defaultRedactorIdentityMaterial as Hi, createActivityLog as Hn, promptControlProfileMaterialization as Hr, routerBrain as Ht, freeSlots as I, meterUsageEvent as Ii, createPeerMailbox as In, assertProfileMaterialization as Ir, codeModeArguments as It, abandonScopeRetainedOwnerInvocation as J, canonicalStreamEventFromSandboxEvent as Ji, abandonablePending as Jn, worktreeCliProfileMaterialization as Jr, reconnectRetainedRun as Jt, environmentReader as K, mapSandboxToolEvent as Ki, DriverAttemptsExhaustedError as Kn, sandboxProfileMaterialization as Kr, LEAF_CONTINUATION_TASK as Kt, queueOf as L, newUsageTotals as Li, isPeerMailEnvelope as Ln, assertProfileMaterializes as Lr, codeModeModelOutput as Lt, runtimeGraphMetadataKey as M, contentAddress as Mi, AUTHORITY_MARKERS as Mn, runWorktreeHarness as Mr, createSandboxLineage as Mt, settledToIteration as N, executorFailure as Ni, DEFAULT_PEER_MAIL_LIMITS as Nn, LOCAL_HARNESSES as Nr, acquireSandbox as Nt, scopeOwnerExecutorNodeContext as O, TRACE_ROOT_SCHEMA as Oi, sanitizeRuntimeStreamEvent as On, signalAbortError as Or, runAgentRounds as Ot, assertRecursiveReservationPolicy as P, errMessage as Pi, PEER_MAIL_WIRE_KEY as Pn, harnessInvocation as Pr, TERMINAL_DECISIONS as Pt, scopeRetainedOwnerResult as Q, notifySandboxEventObserver as Qi, undispatchedCredentialExit as Qn, authoredProfileDigest as Qr, retainedCreateMaterial as Qt, rollingDispatch as R, spendFromUsageEvents as Ri, peerMailTools as Rn, controlProfileMaterialization as Rr, createCodeModeTools as Rt, startRetainedInteractiveRun as S, retainedExecutorSeamKey as Si, padSpanId as Sn, harnessUsageIsEmpty as Sr, bindReusableExecutorExecutionId as St, noteScopeOwnerPlannedExecution as T, unavailablePauseMs as Ti, createRuntimeEventCollector as Tn, RunCancellationReason as Tr, snapshotExecutorConfig as Tt, recordScopeOwnerPause as U, resolveRedactor as Ui, readWorkerProgress as Un, promptModelProfileMaterialization as Ur, createAgentEnvironmentProviderRegistry as Ut, recordScopeOwnerBarrenPause as V, defaultRedactor as Vi, DEFAULT_STALL_AFTER_MS as Vn, profileMaterializationAxes$1 as Vr, createRouterTranscript as Vt, prepareScopeRetainedOwnerSeatSwitch as W, createSandboxToolPartState as Wi, isLiveNodeStatus as Wn, renderUnsupported as Wr, resolveAgentEnvironmentProvider as Wt, prepareScopeRetainedOwnerTask as X, createSandboxUsageLedger as Xi, classifyDriverFailure as Xn, attestRuntimeOwnedScopeOwner as Xr, startRetainedRun as Xt, consumeScopeRetainedOwnerResult as Y, createSandboxTurnEventCollector as Yi, causedByPartialFailure as Yn, attestRuntimeOwnedPendingExecutor as Yr, recoverRetainedRun as Yt, scopeRetainedOwnerPriorSpend as Z, extractLlmCallEvent as Zi, summarizeDriverAttempts as Zn, authoredAgentIdentity as Zr, startRetainedRunInEnvironment as Zt, interactiveAdmissionSeamKey as _, readSandboxOutcome as _i, createOpenInferenceFileExporter as _n, bridgeModelRouteRefusal as _r, readCommittedJsonLines as _t, runFinalizer as a, recordRuntimeOwnedDriveHarnessProviderEvidence as ai, resolveHarnessTranscriptCapture as an, CheckUnavailableError as ar, bindScopeRetainedOwnerProvider as at, reconnectRetainedInteractiveRun as b, RetainedExecutionPendingError as bi, generateSpanId as bn, addHarnessUsage as br, insideCursorNamespace as bt, driverChild as c, runtimeOwnedExecutorMaterialization as ci, openSlotGroup as cn, verdictFromJudgeScore as cr, loadSpawnForest as ct, withDriverExecutor as d, runtimeOwnedScopeOwnerRuntime as di, WORKER_TRACE_PROPAGATION as dn, bestComposite as dr, InMemorySpawnJournal as dt, decodeHarnessUsage as ea, inheritRuntimeOwnedExecutorAttestation as ei, environmentGone as en, SeatChain as er, scopeRetainedOwnerTurnEnded as et, createScope as f, unknownExecutionBindingReceipt as fi, createPropagatingTraceEmitter as fn, checkVerdictOf as fr, FileResultBlobStore as ft, workerTraceAnalysisStore as g, projectSandboxOutcome as gi, buildRuntimeEventOtelSpans as gn, bridgeAdmissionRefusal as gr, readCommittedJsonFile as gt, parseWorkerToolTraceArtifact as h, executableAgentSpecSnapshot as hi, buildLoopSpanNodes as hn, isFiniteNumber as hr, prepareJsonlAppend as ht, bestDelivered as i, providerMessageText as ia, providerAttemptEvidence as ii, readHarnessTranscript as in, subscriptionUsageLimitSignal as ir, bindScopeRetainedOwnerEnvironmentId as it, providerVisibleProfile as j, detachedSnapshot as ji, failPendingAfter as jn, runSettledCommand as jr, createSandboxForSpec as jt, coordinationMcpAlias as k, TRACE_SUMMARY_SCHEMA as ki, INBOX_RECEIPT_KEY as kn, bridgeRuntimeAttachmentsKey as kr, assertBoxlessPromptOptions as kt, driverExecutorFactory as l, runtimeOwnedExecutorProviderEvidence as li, createWorktreeCliExecutor as ln, CONTINUATIONS_DIR as lr, materializeTreeView as lt, isTraceAnalysisStore as m, executableAgentProfileSnapshot as mi, buildLoopOtelSpans as mn, failedItems as mr, isNoEntError as mt, createSupervisor as n, promptFromAgentTurnInput as na, knownMaterializationReceipt as ni, harnessTranscriptArtifact as nn, authoredSeatStages as nr, scopeRetainedOwnerRestorePoint as nt, runTree as o, runtimeOwnedDriveHarnessProviderEvidence as oi, retainHarnessTranscript as on, gateOnDeliverable as or, scopeRetainedOwnerContext as ot, replaySpawnTree as p, unknownMaterializationReceipt as pi, readTraceContextFromEnv as pn, createContinuationKeeper as pr, appendCommittedJsonLine as pt, resolveSpawnResourcePaths as q, terminalTextFromSandboxEvent as qi, HarnessTurnFailedError as qn, unsupportedProfileDimensions as qr, providerAsSandboxClient as qt, assertResumeLimits as r, promptOptionsFromAgentTurnInput as ra, newExecutionAttemptId as ri, persistHarnessTranscript as rn, seatExecutionProfile as rr, noteScopeRetainedOwnerCoordination as rt, createRootHandle as s, runtimeOwnedExecutorExecutionBinding as si, createWorkerSlots as sn, mapExecutorResult as sr, scopeRetainedOwnerJournalRoot as st, DEFAULT_MAX_DEPTH as t, awaitAbortable$1 as ta, knownExecutionBindingReceipt as ti, captureHarnessTranscript as tn, SeatChainExhaustedError as tr, reconcileScopeRetainedOwnerEnvironment as tt, isDriverSpec as u, runtimeOwnedPendingExecutorMaterialization as ui, createInPlaceCliExecutor as un, admitContinuationPolicy as ur, InMemoryResultBlobStore as ut, attachWorker as v, runtimeFailureCause as vi, createOtelExporter as vn, priceTokens as vr, upsertCommittedJsonLine as vt, beginScopeOwnerAttempt as w, jitteredMs as wi, toOtelAttributes as wn, createPushTraceSource as wr, createExecutor as wt, recoverRetainedInteractiveRun as x, registerRetainedExecutorPreparation as xi, loopEventToOtelSpan as xn, createCodexRolloutStoreReader as xr, createExecutorRegistry as xt, readWorkerInteractiveBinding as y, settlementFailureCause as yi, flatOtelSpan as yn, ROUTER_PRICE_SOURCE as yr, withJsonlFileLock as yt, meterRuntimeOwnedAccounting as z, spendFromUsageTotals as zi, peerMailVerbNames as zn, defineProfileMaterializationContract as zr, runCodeMode as zt };
+export { resolveSpawnResourcePaths as $, mapSandboxToolEvent as $i, HarnessTurnFailedError as $n, sandboxProfileMaterialization as $r, providerAsSandboxClient as $t, beginScopeOwnerAttempt as A, cappedDoublingMs as Ai, toOtelAttributes as An, readCodexRolloutSession as Ar, createExecutor as At, assertRecursiveReservationPolicy as B, executorFailure as Bi, PEER_MAIL_WIRE_KEY as Bn, LOCAL_HARNESSES as Br, TERMINAL_DECISIONS as Bt, interactiveAdmissionSeamKey as C, projectSandboxOutcome as Ci, createOpenInferenceFileExporter as Cn, bridgeAdmissionRefusal as Cr, readCommittedJsonLines as Ct, recoverRetainedInteractiveRun as D, RetainedExecutionPendingError as Di, loopEventToOtelSpan as Dn, addHarnessUsage as Dr, createExecutorRegistry as Dt, reconnectRetainedInteractiveRun as E, settlementFailureCause as Ei, generateSpanId as En, ROUTER_PRICE_SOURCE as Er, insideCursorNamespace as Et, coordinationMcpAlias as F, TRACE_ROOT_SCHEMA as Fi, INBOX_RECEIPT_KEY as Fn, signalAbortError as Fr, assertBoxlessPromptOptions as Ft, meterRuntimeOwnedAccounting as G, spendFromUsageEvents as Gi, peerMailVerbNames as Gn, controlProfileMaterialization as Gr, runCodeMode as Gt, freeSlots as H, createBudgetPool as Hi, createPeerMailbox as Hn, terminateProcessTreeAndConfirm as Hr, codeModeArguments as Ht, coordinationProfileToolPrefix as I, TRACE_SUMMARY_SCHEMA as Ii, createInbox as In, bridgeRuntimeAttachmentsKey as Ir, readPromptOptions as It, recordScopeOwnerDriverAttempt as J, defaultRedactor as Ji, createActivityLog as Jn, profileMaterializationAxes$1 as Jr, routerBrain as Jt, meterRuntimeOwnedProviderAttempt as K, spendFromUsageTotals as Ki, taskToPrompt$1 as Kn, defineProfileMaterializationContract as Kr, toolResultText as Kt, providerVisibleProfile as L, detachedFrozen as Li, failPendingAfter as Ln, bridgeStopSignalKey as Lr, createSandboxForSpec as Lt, recordScopeOwnerMaterialization as M, unavailablePauseMs as Mi, createRuntimeStreamEventCollector as Mn, RunCancellationReason as Mr, DEFAULT_SANDBOX_STEERING_MAX_TURNS as Mt, restoreScopeOwnerAcceptedExecution as N, unavailableResumeAt as Ni, sanitizeKnowledgeReadinessReport as Nn, linkAbort as Nr, createSteerableSandboxSession as Nt, startRetainedInteractiveRun as O, registerRetainedExecutorPreparation as Oi, padSpanId as On, createCodexRolloutStoreReader as Or, bindReusableExecutorExecutionId as Ot, scopeOwnerExecutorNodeContext as P, unavailableSignalOfFailure as Pi, sanitizeRuntimeStreamEvent as Pn, runAbortable as Pr, runAgentRounds as Pt, environmentReader as Q, mapSandboxEvent as Qi, DriverAttemptsExhaustedError as Qn, sandboxActProfileMaterialization as Qr, LEAF_CONTINUATION_TASK as Qt, runtimeGraphMetadataKey as R, detachedSnapshot as Ri, AUTHORITY_MARKERS as Rn, runSettledCommand as Rr, createSandboxLineage as Rt, workerTraceAnalysisStore as S, executableAgentSpecSnapshot as Si, buildRuntimeEventOtelSpans as Sn, isFiniteNumber as Sr, readCommittedJsonFile as St, readWorkerInteractiveBinding as T, runtimeFailureCause as Ti, flatOtelSpan as Tn, priceTokens as Tr, withJsonlFileLock as Tt, queueOf as U, meterUsageEvent as Ui, isPeerMailEnvelope as Un, assertProfileMaterialization as Ur, codeModeModelOutput as Ut, deriveNodeExecutionIdentity as V, errMessage as Vi, claimsAuthority as Vn, harnessInvocation as Vr, defaultSelectWinner as Vt, rollingDispatch as W, newUsageTotals as Wi, peerMailTools as Wn, assertProfileMaterializes as Wr, createCodeModeTools as Wt, prepareScopeRetainedOwnerSeatSwitch as X, resolveRedactor as Xi, isLiveNodeStatus as Xn, promptModelProfileMaterialization as Xr, resolveAgentEnvironmentProvider as Xt, recordScopeOwnerPause as Y, defaultRedactorIdentityMaterial as Yi, readWorkerProgress as Yn, promptControlProfileMaterialization as Yr, createAgentEnvironmentProviderRegistry as Yt, scopeRetainedOwnerResourceReader as Z, createSandboxToolPartState as Zi, isTerminalNodeStatus as Zn, renderUnsupported as Zr, providerAsExecutor as Zt, withDriverExecutor as _, runtimeOwnedPendingExecutorMaterialization as _i, WORKER_TRACE_PROPAGATION as _n, admitContinuationPolicy as _r, InMemorySpawnJournal as _t, assertRunParking as a, notifySandboxEventObserver as aa, authoredProfileDigest as ai, destroyInteractiveEnvironment as an, upstreamUnavailableSignal as ar, beginScopeRetainedOwnerDrive as at, isTraceAnalysisStore as b, unknownMaterializationReceipt as bi, buildLoopOtelSpans as bn, createContinuationKeeper as br, isNoEntError as bt, sleepScopeWait as c, awaitAbortable$1 as ca, knownExecutionBindingReceipt as ci, harnessTranscriptArtifact as cn, authoredSeatStages as cr, scopeRetainedOwnerRestorePoint as ct, runFinalizer as d, providerMessageText as da, providerAttemptEvidence as di, resolveHarnessTranscriptCapture as dn, CheckUnavailableError as dr, bindScopeRetainedOwnerProvider as dt, terminalTextFromSandboxEvent as ea, unsupportedProfileDimensions as ei, reconnectRetainedRun as en, abandonablePending as er, abandonScopeRetainedOwnerInvocation as et, runTree as f, recordRuntimeOwnedDriveHarnessProviderEvidence as fi, retainHarnessTranscript as fn, gateFactoryOnDeliverable as fr, scopeRetainedOwnerContext as ft, isDriverSpec as g, runtimeOwnedExecutorProviderEvidence as gi, createInPlaceCliExecutor as gn, CONTINUATIONS_DIR as gr, InMemoryResultBlobStore as gt, driverExecutorFactory as h, runtimeOwnedExecutorMaterialization as hi, createWorktreeCliExecutor as hn, verdictFromJudgeScore as hr, materializeTreeView as ht, RunParkedError as i, extractLlmCallEvent as ia, authoredAgentIdentity as ii, retainedCreateMaterial as in, undispatchedCredentialExit as ir, scopeRetainedOwnerResult as it, noteScopeOwnerPlannedExecution as j, jitteredMs as ji, createRuntimeEventCollector as jn, createPushTraceSource as jr, snapshotExecutorConfig as jt, FileSpawnJournal as k, retainedExecutorSeamKey as ki, padTraceId as kn, harnessUsageIsEmpty as kr, captureReusableExecutorConfig as kt, withRunParking as l, promptFromAgentTurnInput as la, knownMaterializationReceipt as li, persistHarnessTranscript as ln, seatExecutionProfile as lr, noteScopeRetainedOwnerCoordination as lt, driverChild as m, runtimeOwnedExecutorExecutionBinding as mi, openSlotGroup as mn, mapExecutorResult as mr, loadSpawnForest as mt, createSupervisor as n, createSandboxTurnEventCollector as na, attestRuntimeOwnedPendingExecutor as ni, startRetainedRun as nn, classifyDriverFailure as nr, prepareScopeRetainedOwnerTask as nt, bindScopeParkingDrain as o, sumSandboxUsage as oa, finalizeRuntimeOwnedPendingExecutor as oi, environmentGone as on, SeatChain as or, scopeRetainedOwnerTurnEnded as ot, createRootHandle as p, runtimeOwnedDriveHarnessProviderEvidence as pi, createWorkerSlots as pn, gateOnDeliverable as pr, scopeRetainedOwnerJournalRoot as pt, recordScopeOwnerBarrenPause as q, assertValidBudget as qi, DEFAULT_STALL_AFTER_MS as qn, fullProfileMaterialization as qr, createRouterTranscript as qt, assertResumeLimits as r, createSandboxUsageLedger as ra, attestRuntimeOwnedScopeOwner as ri, startRetainedRunInEnvironment as rn, summarizeDriverAttempts as rr, scopeRetainedOwnerPriorSpend as rt, readRunParking as s, decodeHarnessUsage as sa, inheritRuntimeOwnedExecutorAttestation as si, captureHarnessTranscript as sn, SeatChainExhaustedError as sr, reconcileScopeRetainedOwnerEnvironment as st, DEFAULT_MAX_DEPTH as t, canonicalStreamEventFromSandboxEvent as ta, worktreeCliProfileMaterialization as ti, recoverRetainedRun as tn, causedByPartialFailure as tr, consumeScopeRetainedOwnerResult as tt, bestDelivered as u, promptOptionsFromAgentTurnInput as ua, newExecutionAttemptId as ui, readHarnessTranscript as un, subscriptionUsageLimitSignal as ur, bindScopeRetainedOwnerEnvironmentId as ut, createScope as v, runtimeOwnedScopeOwnerRuntime as vi, createPropagatingTraceEmitter as vn, bestComposite as vr, FileResultBlobStore as vt, attachWorker as w, readSandboxOutcome as wi, createOtelExporter as wn, bridgeModelRouteRefusal as wr, upsertCommittedJsonLine as wt, parseWorkerToolTraceArtifact as x, executableAgentProfileSnapshot as xi, buildLoopSpanNodes as xn, failedItems as xr, prepareJsonlAppend as xt, replaySpawnTree as y, unknownExecutionBindingReceipt as yi, readTraceContextFromEnv as yn, checkVerdictOf as yr, appendCommittedJsonLine as yt, settledToIteration as z, contentAddress as zi, DEFAULT_PEER_MAIL_LIMITS as zn, runWorktreeHarness as zr, acquireSandbox as zt };
 
-//# sourceMappingURL=supervisor-D3M9ab1v.js.map
+//# sourceMappingURL=supervisor-DDy0aEtR.js.map