@tangle-network/agent-runtime 0.342.2 → 0.343.2

package/dist/{supervisor-C_03z693.js → supervisor-gDn4C1o5.js}

@@ -1,15 +1,13 @@
-import { i as publishExclusiveDurableFile, n as assertNoSymlinkDescendant } from "./durable-file-gNI9ILAn.js";
+import { i as publishExclusiveDurableFile, n as assertNoSymlinkDescendant, s as sha256 } from "./durable-file-CA0kr1Pi.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 { n as recordValue, t as isRecord } from "./record-value-B6bwJxLa.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-FN2kab2-.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";
 import { _ as agentHarness, a as concreteProfileModel, c as profileModelExecutionSettings, d as assertRouterAutoDeclaration, f as assertRouterAutoResponse, g as observedModelMatchesDeclared, h as observedModelHasSnapshot, l as profileProviderModel, m as mergeObservedModelIdentity, o as enforceTokenLimits, s as profileBridgeWireModel, t as assertExecutableAgentProfile, u as resolveRouterRetryPolicy } from "./model-policy-CyCUwHed.js";
-import { t as sha256 } from "./content-digest-sBTLujlK.js";
 import { i as notifyRuntimeHookEvent } from "./runtime-hooks-tXpAarhW.js";
-import { a as readCommittedJsonLines, n as isNoEntError, t as appendCommittedJsonLine } from "./jsonl-file-C9Kde_0Z.js";
 import { AGENT_PROFILE_MATERIALIZATION_AXES, AgentEnvironmentCapabilitiesSchema, AgentExactRunControlRefSchema, AgentInteractiveSessionControlClaimAcknowledgementSchema, AgentInteractiveSessionControlClaimSchema, AgentInteractiveSessionPromptAcknowledgementSchema, AgentInteractiveSessionRefSchema, AgentInteractiveSessionStatusSchema, AgentInteractiveSessionStopAcknowledgementSchema, AgentNativeContextContinuationResultSchema, AgentRunCancellationAcknowledgementSchema, AgentRunCancellationRequestSchema, AgentTurnInputSchema, AgentTurnResultSchema, CanonicalStreamEventSchema, ContextTransferReceiptSchema, ContextTransferRequestSchema, InteractionAcknowledgementSchema, InteractionResponseCommandSchema, NativeContextBoundaryProofSchema, NativeContextContinuationRequestSchema, REASONING_EFFORTS, RuntimeEventEnvelopeSchema, TerminalReplayWindowSchema, TerminalSessionRefSchema, agentCandidateArtifactRefSchema, agentCandidateWorkspaceManifestMaterialSchema, agentCandidateWorkspaceSnapshotEvidenceSchema, agentInteractiveSessionControlClaimAcknowledgementMatchesRequest, agentInteractiveSessionControlClaimMatchesRef, agentInteractiveSessionPromptAcknowledgementMatchesCommand, agentInteractiveSessionRefMatchesStart, agentInteractiveSessionRunRef, agentInteractiveSessionStatusMatchesRef, agentInteractiveSessionStopAcknowledgementMatchesCommand, agentNativeContextContinuationResultMatchesRequest, agentProfileSchema, agentRunCancellationAcknowledgementMatchesRequest, agentRunCancellationRequestDigest, agentWorkspaceSnapshotRefDigest, canonicalAgentProfileDigest, canonicalCandidateDigest, canonicalWorkspaceCwd, contextTransferReceiptMatches, exactAgentInteractiveSessionStart, harnessTypeSchema, nativeContextContinuationTurnDigest, nativeReasoningControl, profileMaterializationAxes, profileMaterializationAxes as profileMaterializationAxes$1, renderInputPartsAsText, sha256DigestSchema, workspaceCheckpointRequestDigest, workspaceCheckpointResultMatchesRequest, workspaceCleanupAcknowledgementMatches, workspaceCleanupRequestDigest, workspaceForkRequestDigest, workspaceForkResultMatchesRequest } from "@tangle-network/agent-interface";
 import { isToolSpan, toolSpansToTraceAnalysisStore } from "@tangle-network/agent-eval";
 import { createAgentRunOutcomeTracker } from "@tangle-network/sandbox/runtime";
+import { SDKError, generateIdempotencyKey, isRecord, withRetry } from "@tangle-network/agent-core";
 import { collectAgentFinalMessageText, collectAgentResponseText } from "@tangle-network/sandbox";
 import { REDACTION_VERSION as REDACTION_VERSION$1, redact } from "@tangle-network/agent-eval/traces";
 import { z } from "zod";
@@ -27,7 +25,6 @@ import { request as request$1 } from "node:https";
 import { Readable } from "node:stream";
 import { ATTR, deriveHexId, isW3CSpanId, isW3CTraceId } from "@tangle-network/agent-trace-contract";
 import { clearImmediate, setImmediate as setImmediate$1 } from "node:timers";
-import { SDKError, generateIdempotencyKey, withRetry } from "@tangle-network/agent-core";
 //#region src/runtime/turn-input.ts
 /**
 * Copy only fields that describe a new provider turn.
@@ -315,6 +312,11 @@ function delay(ms, signal) {
 	});
 }
 //#endregion
+//#region src/record-value.ts
+function recordValue(value) {
+	return isRecord(value) ? value : void 0;
+}
+//#endregion
 //#region src/runtime/harness-usage.ts
 /**
 * Read and validate one codex `turn.completed` usage record.
@@ -330,7 +332,7 @@ function delay(ms, signal) {
 */
 function parseCodexUsageRecord(usage, label) {
 	const record = recordValue(usage);
-	if (record === void 0) throw new ValidationError$1(`${label}: usage must be an object, received ${describe(usage)}`);
+	if (record === void 0) throw new ValidationError$1(`${label}: usage must be an object, received ${describe$1(usage)}`);
 	const inputTokens = naturalNumber$1(record.input_tokens, "input_tokens", label);
 	const cachedInputTokens = naturalNumber$1(record.cached_input_tokens, "cached_input_tokens", label);
 	const outputTokens = naturalNumber$1(record.output_tokens, "output_tokens", label);
@@ -433,10 +435,10 @@ function decodeHarnessUsage(event, harness) {
 	}
 }
 function naturalNumber$1(value, field, label) {
-	if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) throw new ValidationError$1(`${label}: usage.${field} must be a non-negative safe integer, received ${describe(value)}`);
+	if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) throw new ValidationError$1(`${label}: usage.${field} must be a non-negative safe integer, received ${describe$1(value)}`);
 	return value;
 }
-function describe(value) {
+function describe$1(value) {
 	if (value === null) return "null";
 	if (typeof value === "number" || typeof value === "boolean") return String(value);
 	if (typeof value === "string") return JSON.stringify(value);
@@ -6135,10 +6137,12 @@ async function resolveBridgeModelCredential(credential, context) {
 var RunCancellationReason = class extends Error {
 	source;
 	operationId;
-	constructor(source, reason, operationId) {
+	operator;
+	constructor(source, reason, operationId, operator) {
 		super(reason);
 		this.source = source;
 		this.operationId = operationId;
+		this.operator = operator;
 		this.name = "RunCancellationReason";
 	}
 	toString() {
@@ -9604,7 +9608,7 @@ const USAGE_LIMIT_CODES = /* @__PURE__ */ new Set([
 /** Normalize a native harness refusal into a typed limit. A plain HTTP 429 is insufficient. */
 function subscriptionUsageLimitSignal(failure) {
 	if (failure.errorCode && USAGE_LIMIT_CODES.has(failure.errorCode.toLowerCase())) return "subscription-usage-limit";
-	if (/\bYou've hit your (?:usage|weekly|session) limit\b/iu.test(failure.error)) return "subscription-usage-limit";
+	if (/\bYou've hit your (?:usage|weekly|session|monthly spend) limit\b/iu.test(failure.error)) return "subscription-usage-limit";
 	if (/\bUsage limit reached for \d+ hours?\b/iu.test(failure.error)) return "subscription-usage-limit";
 }
 /** An ineligible or misconfigured account must never turn an authored stage into another model. */
@@ -9778,15 +9782,20 @@ function isUpstreamUnavailable(error) {
 * consumers may branch on it: a 5xx/408 is the upstream having a bad moment, a 429/503/529 is the
 * upstream out of capacity, and a 401/404/422 is a request that will fail identically forever. The
 * bridge's own never-retry classes are terminal whether or not a status rides with them.
+*
+* An `AbortError` is the run's own only when `signal` (the run) or `stopSignal` (the manager's own
+* stop: an accepted result, `stop`, a stop rule) has fired. Any other is a lost stream and is
+* retried: on magnetar-rust-20261019b a 4.0 h root turn ended "bridgeExecutor: turn aborted" and,
+* classed terminal, settled the run after one attempt.
 */
-function classifyDriverFailure(error, signal) {
+function classifyDriverFailure(error, signal, stopSignal) {
 	if (signal?.aborted) return "terminal";
 	if (error instanceof RetainedExecutionPendingError && error.pendingCause === "provider-contract") return "terminal";
 	if (undispatchedCredentialExit(error) !== void 0) return "unavailable";
 	const admission = retainedAdmissionCause(error);
 	if (admission !== void 0 && isDispatchNotAdmitted(admission)) return "terminal";
-	if (admission !== void 0) return classifyDriverFailure(admission, signal);
-	if (error instanceof Error && errorProperty(error, "name") === "AbortError") return "terminal";
+	if (admission !== void 0) return classifyDriverFailure(admission, signal, stopSignal);
+	if (error instanceof Error && errorProperty(error, "name") === "AbortError") return stopSignal?.aborted === true ? "terminal" : "transient";
 	if (error instanceof Error && isProviderSchemaRejection(error)) return "terminal";
 	if (isCredentialRefusal(error)) return "terminal";
 	if (causeChain(error).some(isProvisioningRefusal)) return "terminal";
@@ -9889,11 +9898,13 @@ function summarizeDriverAttempts(records) {
 	for (const record of records) if (record.madeProgress) barren = 0;
 	else if (record.beforeModelEvent !== true && record.error === void 0 && record.reentry !== void 0 && record.reentry !== "wake" && record.contract === "unmet") barren += 1;
 	const last = records.at(-1);
-	const refused = records.filter((record) => record.classification === "unavailable");
+	const stopPauses = records.filter((record) => record.replacesStop !== void 0);
+	const refused = records.filter((record) => record.classification === "unavailable" && record.replacesStop === void 0);
 	return {
-		attempts: records.length,
+		attempts: new Set(records.map((record) => record.attempt)).size,
 		reprompts: records.filter((record) => record.reprompted === true).length,
-		failureRetries: records.filter((record) => record.error !== void 0 && record.retryInMs !== void 0 && record.classification !== "unavailable").length,
+		failureRetries: records.filter((record) => record.error !== void 0 && record.retryInMs !== void 0 && record.classification !== "unavailable" && record.replacesStop === void 0).length,
+		stopPauses: stopPauses.length,
 		unavailablePauses: refused.filter((record) => record.retryInMs !== void 0).length,
 		unavailableMs: refused.reduce((sum, record) => sum + (record.madeProgress ? 0 : record.durationMs) + (record.retryInMs ?? 0), 0),
 		barrenReentries: barren,
@@ -19192,6 +19203,7 @@ function withRouterRequestTimeout(callerSignal, timeoutMs) {
 }
 //#endregion
 //#region src/runtime/router-request-body.ts
+/** Canonical provider request lowering for buffered and streamed completions. */
 /** The OpenAI-shape request body both plain-chat transports send. One builder so the streamed
 *  completion cannot drift from the buffered one on model, ceilings, seed, or reasoning effort. */
 function chatCompletionBody(cfg, messages, opts) {
@@ -23786,6 +23798,7 @@ const outsideKinds = /* @__PURE__ */ new Set([
 	"seat-paused",
 	"root-segment",
 	"root-reentered",
+	"reopened",
 	"paused",
 	"barren-pause",
 	"driver-attempt",
@@ -23802,6 +23815,209 @@ function insideCursorNamespace(ev) {
 	return !outsideKinds.has(ev.kind);
 }
 //#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;
+* corruption, short reads, and other I/O errors remain failures. Closing the iterator closes the fd. */
+async function* readCommittedJsonLines(path, options = {}) {
+	const fs = await import("node:fs/promises");
+	let handle;
+	try {
+		handle = await fs.open(path, "r");
+	} catch (error) {
+		if (options.allowMissing && isNoEntError(error)) return;
+		throw error;
+	}
+	try {
+		const { size } = await handle.stat();
+		if (size === 0) return;
+		const { StringDecoder } = await import("node:string_decoder");
+		const decoder = new StringDecoder("utf8");
+		const stream = handle.createReadStream({
+			autoClose: false,
+			end: size - 1
+		});
+		const fragments = [];
+		let lineNumber = 1;
+		try {
+			for await (const chunk of stream) {
+				options.onBytes?.(chunk);
+				const text = decoder.write(chunk);
+				let start = 0;
+				let end = text.indexOf("\n", start);
+				while (end !== -1) {
+					fragments.push(text.slice(start, end));
+					const record = parseRecord(fragments.join(""), path, lineNumber++, true, options.allowWhitespaceLines);
+					fragments.length = 0;
+					if (record !== void 0) yield record.value;
+					start = end + 1;
+					end = text.indexOf("\n", start);
+				}
+				if (start < text.length) fragments.push(text.slice(start));
+			}
+			if (stream.bytesRead !== size) throw new Error(`${path}: journal changed while reading its committed prefix`);
+			fragments.push(decoder.end());
+			const record = parseRecord(fragments.join(""), path, lineNumber, false, options.allowWhitespaceLines);
+			if (record !== void 0) yield record.value;
+		} finally {
+			stream.destroy();
+		}
+	} finally {
+		await handle.close();
+	}
+}
+/** An invalid unterminated tail may be a torn write; other parse failures are not evidence of one. */
+function parseRecord(line, source, lineNumber, terminated, allowWhitespaceLines = false) {
+	if (line.length === 0 || allowWhitespaceLines && line.trim().length === 0) return void 0;
+	try {
+		return { value: JSON.parse(line) };
+	} catch (cause) {
+		if (!(cause instanceof SyntaxError)) throw cause;
+		if (!terminated) return void 0;
+		throw new Error(`${source}: malformed JSONL record at line ${lineNumber}`, { cause });
+	}
+}
+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();
+	}
+}
+/** 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,
+* including its first write, so two directory aliases cannot acquire different write heads.
+* @internal
+*/
+async function withJsonlFileLock(path, operation) {
+	const fs = await import("node:fs/promises");
+	const { dirname } = await import("node:path");
+	const { tryAcquireAtomicFileLock } = await import("@tangle-network/agent-eval/ledger-core");
+	await fs.mkdir(dirname(path), { recursive: true });
+	await (await fs.open(path, "a")).close();
+	const canonicalPath = await fs.realpath(path);
+	const deadline = Date.now() + 5e3;
+	for (;;) {
+		const acquisition = tryAcquireAtomicFileLock({ lockPath: `${canonicalPath}.lock` });
+		if (!acquisition.acquired) {
+			if (Date.now() >= deadline) throw new Error(`journal file lock unavailable after 5000ms: ${canonicalPath}`);
+			await new Promise((resolve) => setTimeout(resolve, 25));
+			continue;
+		}
+		try {
+			return await operation(canonicalPath);
+		} finally {
+			acquisition.lock.release();
+		}
+	}
+}
+/** Read one keyed registry snapshot without an extra whole-file text allocation.
+* Historical registry files allow whitespace-only separators; append journals remain strict.
+* @internal
+*/
+async function readCommittedJsonFile(path) {
+	const records = [];
+	for await (const record of readCommittedJsonLines(path, {
+		allowMissing: true,
+		allowWhitespaceLines: true
+	})) records.push(record);
+	return records;
+}
+/** Replace one keyed row and publish one durable snapshot. The caller holds the file lock.
+* Keep unrelated rows in order and put the replacement last. No revision archive is retained.
+* @internal
+*/
+async function upsertCommittedJsonLine(path, record, key) {
+	const encoded = JSON.stringify(record);
+	if (encoded === void 0) throw new Error("JSONL records must be JSON serializable");
+	const snapshot = JSON.parse(encoded);
+	const id = key(snapshot);
+	const updated = [];
+	for await (const prior of readCommittedJsonLines(path, {
+		allowMissing: true,
+		allowWhitespaceLines: true
+	})) if (key(prior) !== id) updated.push(prior);
+	updated.push(snapshot);
+	const { writeAtomicDurableFile } = await import("./durable-file-CA0kr1Pi.js").then((n) => n.r);
+	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. */
+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;
+	}
+}
+/** 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. */
+function isNoEntError(error) {
+	return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+//#endregion
 //#region src/durable/spawn-journal/result-blob-store.ts
 /**
 * FS `ResultBlobStore`. One JSON file per artifact under `dir`, named by a
@@ -25829,6 +26045,379 @@ function unsettledOwnerRuns(events, nodeId, environmentId) {
 	return [...runs.values()];
 }
 //#endregion
+//#region src/mcp/tools/spawn-resource-paths.ts
+/**
+* Inline resources a manager hands a child by PATH instead of by content.
+*
+* The canonical profile schema knows two resource kinds, `inline` (a content string) and `github`.
+* A manager that wants a child to receive a data file therefore had one way to do it: emit the
+* bytes inside its own `spawn` tool call. That is a transcription by a language model, and it does
+* not survive size. Measured 2026-09-12 (discovery-lab `mech-interp-foundations-glm2-b-20260912b`):
+* a 29,144-character base64 payload on the manager's disk reached three children as 15,928
+* characters with 11 substitutions, and a fourth child received the literal placeholder the
+* manager meant to replace. Seven blind-check attempts across two runs delivered no data.
+*
+* `{ kind: 'inline', name, path }` lets the coordination server be the transport: it reads the
+* file from the manager's workspace, fills `content`, and the profile that reaches the schema,
+* the journal, and the provider is an ordinary inline resource. Nothing downstream changes; the
+* model's output stops carrying the bytes.
+*
+* Where the bytes come from is a {@link SpawnResourceReader}, and there are two:
+*  - a HOST DIRECTORY, for a manager whose driver runs on this host (a loopback bridge with a
+*    `cwd`), read through the descriptor-identity checks below;
+*  - the manager's OWN EXECUTION ENVIRONMENT, for a manager inside a provider sandbox, read
+*    through the environment's `read()`. The coordination server cannot see a sandbox filesystem,
+*    but the provider that created the sandbox can, and it is already in hand.
+*
+* The second reader exists because the first one's absence was not a refusal a manager could
+* work around. Measured 2026-09-17 (discovery-lab `mech-interp-foundations-sandbox-a-20260917h`):
+* a sandbox-rooted director, refused by path, fell back to emitting its files as content and got
+* 5 characters wrong in 24,008, destroying 3 of 7 files including its instrument and both
+* drivers. At that rate 20 KB of mounts all arrive intact about 2% of the time, and gzip makes it
+* worse by turning one wrong character into total loss. Four consecutive runs in that lane lost
+* their research children to this. There is no encoding that fixes a transcription channel; the
+* only fix is a channel with no model in it.
+*
+* Fail-closed rules, each with the reason a manager needs to fix its call:
+*  - no reader available → refused (neither a host directory nor an environment with `read`)
+*  - absolute path or `..` escape → refused by both readers; a symlink that resolves outside the
+*    root → refused by the host reader (the environment reader delegates containment to the
+*    provider, which serves only the sandbox's own workspace)
+*  - not a regular file → refused
+*  - over {@link SPAWN_RESOURCE_PATH_MAX_BYTES} → refused naming the bound
+*  - bytes that are not valid UTF-8 → refused; `content` is a string, so binary data is encoded
+*    (base64) by the manager first, exactly as it would be for a content resource
+*/
+const SPAWN_RESOURCE_PATH_MAX_BYTES = 4 * 1024 * 1024;
+/** The host-directory reader: a manager whose workspace is a directory this process can open. */
+function hostDirectoryReader(root) {
+	return {
+		describe: `workspace root ${root}`,
+		read: (requested) => readUnderRoot(root, requested)
+	};
+}
+/**
+* The environment reader: a manager running inside a provider environment whose `read()` serves
+* its own workspace. The provider owns containment — it will not serve a path outside the box —
+* but the relative-path and `..` rules are enforced here too, so the refusal names the rule the
+* manager broke rather than whatever the provider says about an escape it declined.
+*
+* `read()` returns a string, so an environment cannot hand back bytes that are not UTF-8; the
+* provider has already decoded. The size bound is checked on what arrives.
+*/
+function environmentReader(environment) {
+	return {
+		describe: `environment ${environment.id}`,
+		async read(requested) {
+			if (requested.length === 0) return {
+				ok: false,
+				reason: "path is empty"
+			};
+			if (isAbsolute(requested)) return {
+				ok: false,
+				reason: `path must be relative to the manager's workspace, not absolute (${requested})`
+			};
+			if (requested.split(/[\\/]/u).includes("..")) return {
+				ok: false,
+				reason: `path ${requested} leaves the manager's workspace`
+			};
+			let content;
+			try {
+				content = await environment.read(requested);
+			} catch (error) {
+				return {
+					ok: false,
+					reason: `path ${requested}: ${describe(error)} (read from environment ${environment.id})`
+				};
+			}
+			const bytes = Buffer.from(content, "utf8");
+			if (bytes.length > 4194304) return {
+				ok: false,
+				reason: `path ${requested} is ${bytes.length} bytes; an inline resource is at most ${SPAWN_RESOURCE_PATH_MAX_BYTES} bytes`
+			};
+			return {
+				ok: true,
+				content,
+				byteLength: bytes.length,
+				sha256: createHash("sha256").update(bytes).digest("hex")
+			};
+		}
+	};
+}
+/** An inline ref that names a path and carries no content. Anything else is left untouched so the
+*  canonical schema keeps its verdict on it. */
+function pathInlineRef(value) {
+	if (!isRecord(value)) return void 0;
+	if (value.kind !== "inline" || value.content !== void 0) return void 0;
+	if (typeof value.path !== "string" || typeof value.name !== "string") return void 0;
+	return {
+		kind: "inline",
+		name: value.name,
+		path: value.path
+	};
+}
+async function readUnderRoot(root, requested) {
+	if (requested.length === 0) return {
+		ok: false,
+		reason: "path is empty"
+	};
+	if (isAbsolute(requested)) return {
+		ok: false,
+		reason: `path must be relative to the workspace root, not absolute (${requested})`
+	};
+	const rootReal = await realpath(root).catch(() => void 0);
+	if (rootReal === void 0) return {
+		ok: false,
+		reason: `workspace root ${root} does not exist`
+	};
+	const candidate = resolve(rootReal, requested);
+	if (!inside(rootReal, candidate)) return {
+		ok: false,
+		reason: `path ${requested} leaves the workspace root`
+	};
+	let handle;
+	try {
+		handle = await open(candidate, "r");
+	} catch (error) {
+		return {
+			ok: false,
+			reason: `path ${requested}: ${describe(error)}`
+		};
+	}
+	try {
+		const info = await handle.stat();
+		if (!info.isFile()) return {
+			ok: false,
+			reason: `path ${requested} is not a regular file`
+		};
+		const real = await realpath(candidate).catch(() => void 0);
+		if (real === void 0 || !inside(rootReal, real)) return {
+			ok: false,
+			reason: `path ${requested} resolves outside the workspace root`
+		};
+		const named = await stat(real).catch(() => void 0);
+		if (named === void 0 || named.dev !== info.dev || named.ino !== info.ino) return {
+			ok: false,
+			reason: `path ${requested} changed while it was being read; retry the spawn`
+		};
+		if (info.size > 4194304) return {
+			ok: false,
+			reason: `path ${requested} is ${info.size} bytes; an inline resource is at most ${SPAWN_RESOURCE_PATH_MAX_BYTES} bytes`
+		};
+		const bytes = await handle.readFile();
+		if (bytes.length > 4194304) return {
+			ok: false,
+			reason: `path ${requested} is ${bytes.length} bytes; an inline resource is at most ${SPAWN_RESOURCE_PATH_MAX_BYTES} bytes`
+		};
+		const content = bytes.toString("utf8");
+		if (!Buffer.from(content, "utf8").equals(bytes)) return {
+			ok: false,
+			reason: `path ${requested} is not valid UTF-8; encode binary data (base64) before handing it to a child`
+		};
+		return {
+			ok: true,
+			content,
+			byteLength: bytes.length,
+			sha256: createHash("sha256").update(bytes).digest("hex")
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			reason: `path ${requested}: ${describe(error)}`
+		};
+	} finally {
+		await handle.close().catch(() => void 0);
+	}
+}
+/** `target` is `rootReal` itself or strictly below it; both must already be absolute. */
+function inside(rootReal, target) {
+	const rel = relative(rootReal, target);
+	return rel !== "" && !rel.startsWith(`..${sep}`) && rel !== ".." && !isAbsolute(rel);
+}
+function describe(error) {
+	const code = error?.code;
+	if (code === "ENOENT") return "does not exist under the workspace root";
+	if (code === "EACCES" || code === "EPERM") return "is not readable by the runtime process";
+	if (code === "EISDIR") return "is not a regular file";
+	return error instanceof Error ? error.message : String(error);
+}
+/**
+* Replace every `{ kind: 'inline', name, path }` under `profile.resources` with the inline
+* resource its bytes make. Returns the profile unchanged (same reference) when nothing names a
+* path, so callers pay nothing on the common case.
+*
+* `source` is a host directory (a string, kept for the existing call sites), a
+* {@link SpawnResourceReader}, or `undefined` when the manager has neither — in which case a path
+* is refused with the reason and what to do instead.
+*/
+async function resolveSpawnResourcePaths(profile, source) {
+	if (!isRecord(profile) || !isRecord(profile.resources)) return {
+		ok: true,
+		profile,
+		resolved: []
+	};
+	const reader = typeof source === "string" ? hostDirectoryReader(source) : source;
+	const resources = profile.resources;
+	const resolved = [];
+	let touched = false;
+	const next = { ...resources };
+	const substitute = async (at, ref) => {
+		if (reader === void 0) return { error: "this manager has no workspace root the coordination server may read (no host directory and no environment with read), so a resource by path cannot be resolved; pass content, or a github resource" };
+		const read = await reader.read(ref.path);
+		if (!read.ok) return { error: read.reason };
+		resolved.push({
+			at,
+			path: ref.path,
+			byteLength: read.byteLength,
+			sha256: read.sha256
+		});
+		touched = true;
+		return {
+			kind: "inline",
+			name: ref.name,
+			content: read.content
+		};
+	};
+	for (const list of [
+		"tools",
+		"skills",
+		"agents"
+	]) {
+		const entries = resources[list];
+		if (!Array.isArray(entries)) continue;
+		const out = [];
+		for (const [index, entry] of entries.entries()) {
+			const ref = pathInlineRef(entry);
+			if (ref === void 0) {
+				out.push(entry);
+				continue;
+			}
+			const at = `${list}[${index}]`;
+			const replaced = await substitute(at, ref);
+			if ("error" in replaced) return {
+				ok: false,
+				at,
+				reason: replaced.error
+			};
+			out.push(replaced);
+		}
+		next[list] = out;
+	}
+	if (Array.isArray(resources.files)) {
+		const out = [];
+		for (const [index, mount] of resources.files.entries()) {
+			const ref = isRecord(mount) ? pathInlineRef(mount.resource) : void 0;
+			if (ref === void 0 || !isRecord(mount)) {
+				out.push(mount);
+				continue;
+			}
+			const at = `files[${index}].resource`;
+			const replaced = await substitute(at, ref);
+			if ("error" in replaced) return {
+				ok: false,
+				at,
+				reason: replaced.error
+			};
+			out.push({
+				...mount,
+				resource: replaced
+			});
+		}
+		next.files = out;
+	}
+	const instructions = pathInlineRef(resources.instructions);
+	if (instructions !== void 0) {
+		const replaced = await substitute("instructions", instructions);
+		if ("error" in replaced) return {
+			ok: false,
+			at: "instructions",
+			reason: replaced.error
+		};
+		next.instructions = replaced;
+	}
+	if (!touched) return {
+		ok: true,
+		profile,
+		resolved: []
+	};
+	return {
+		ok: true,
+		profile: {
+			...profile,
+			resources: next
+		},
+		resolved
+	};
+}
+//#endregion
+//#region src/runtime/supervise/retained-owner-resource-reader.ts
+/**
+* The owner's environment as a source of by-path spawn resources.
+*
+* Built once per scope, before the environment exists: the coordination tools are created ahead
+* of the owner's first turn, and the environment is admitted during it. So the reader resolves
+* its target on every read — the latest environment admission on this node, reconstructed through
+* the bound provider the same way cleanup reconstructs it, with the same identity check. A manager
+* that has not yet been admitted, or whose provider was never bound, gets a refusal that names the
+* missing piece rather than a read from nowhere.
+*
+* The environment's `read()` serves the sandbox's own workspace; containment against that
+* workspace is the provider's. The relative-path and `..` rules are the reader's, in
+* `environmentReader`, so a manager is refused for the rule it broke.
+*/
+function scopeRetainedOwnerResourceReader(scope) {
+	const state = owners.get(scope);
+	if (state === void 0) return void 0;
+	const latestEnvironmentId = () => state.liveEnvironmentId?.() ?? [...state.admissions].reverse().flatMap((admission) => admission.phase === "environment" ? [admission.environmentId] : [])[0];
+	return {
+		get describe() {
+			return `environment ${latestEnvironmentId() ?? "<not yet admitted>"}`;
+		},
+		async read(path) {
+			const provider = state.provider;
+			if (provider === void 0) return {
+				ok: false,
+				reason: "the manager’s environment provider is not bound yet"
+			};
+			const environmentId = latestEnvironmentId();
+			if (environmentId === void 0) return {
+				ok: false,
+				reason: "the manager’s environment has not been admitted yet"
+			};
+			if (!provider.get) return {
+				ok: false,
+				reason: `provider ${provider.name} cannot reconstruct the manager’s environment`
+			};
+			let environment;
+			try {
+				environment = await provider.get(environmentId);
+			} catch (error) {
+				return {
+					ok: false,
+					reason: `environment ${environmentId}: ${error instanceof Error ? error.message : String(error)}`
+				};
+			}
+			if (environment === null) return {
+				ok: false,
+				reason: `environment ${environmentId} is gone`
+			};
+			if (environment.id !== environmentId || environment.provider !== provider.name) return {
+				ok: false,
+				reason: `provider returned another environment for ${environmentId}`
+			};
+			if (typeof environment.read !== "function") return {
+				ok: false,
+				reason: `environment ${environmentId} does not expose read; its provider cannot serve a resource by path`
+			};
+			const read = environment.read.bind(environment);
+			return environmentReader({
+				id: environment.id,
+				read
+			}).read(path);
+		}
+	};
+}
+//#endregion
 //#region src/runtime/supervise/retained-owner-seat-switch.ts
 /** A committed turn is the seat boundary. Keep its native home for a same-harness provider
 * continuation; only a provider/harness change needs a new environment. */
@@ -31997,14 +32586,10 @@ function deadlinePassed(pool, opts) {
 }
 //#endregion
 //#region src/runtime/supervise/supervisor-root-contract.ts
-/** A resumed process may continue only the exact root contract first recorded for this run id. */
+/** A resumed process may continue only the exact root contract first recorded for this run id. Its
+*  budget is the root's, or the one the run's last budget-carrying `reopened` row recorded. */
 function assertResumeContract(events, opts) {
-	const roots = events.filter((event) => event.kind === "spawned" && event.parent === void 0);
-	if (roots.length !== 1 || roots[0]?.id !== opts.runId) throw new RuntimeRunStateError(`supervisor: resumed run '${opts.runId}' must contain exactly one root identity event; found ${roots.length}`);
-	const recorded = roots[0];
-	if (contentAddress(recorded.budget) !== contentAddress(opts.budget)) throw new RuntimeRunStateError(`supervisor: resume budget mismatch for run '${opts.runId}'; use a new runId to change limits`);
-	const expectedAdmission = opts.reservationPolicy ? { policy: opts.reservationPolicy } : void 0;
-	if (contentAddress(recorded.recursiveAdmission ?? null) !== contentAddress(expectedAdmission ?? null)) throw new RuntimeRunStateError(`supervisor: resume reservation policy mismatch for run '${opts.runId}'; use a new runId`);
+	const recorded = assertResumeLimits(events, opts);
 	if (!sameOptionalIdentity(recorded.identity, opts.rootIdentity)) throw new RuntimeRunStateError(`supervisor: resume identity mismatch for run '${opts.runId}'; ${describeIdentityMismatch(recorded.identity, opts.rootIdentity)}`);
 	const receipts = events.filter((event) => event.kind === "materialized" && event.id === opts.runId);
 	const expectedReceipt = rootMaterializationReceipt(opts);
@@ -32013,6 +32598,20 @@ function assertResumeContract(events, opts) {
 	} else if (receipts.length !== 1 || contentAddress(receipts[0]?.receipt) !== contentAddress(expectedReceipt)) throw new RuntimeRunStateError(`supervisor: resume materialization mismatch for run '${opts.runId}'; backend, model, execution identity, and plan must match`);
 	return recorded;
 }
+/**
+* The limits half of the resume contract: one root identity event, the recorded budget and the
+* reservation policy. A reopen checks them before it archives anything (`durable/run-reopen.ts`);
+* `reopenBudget` is the budget that reopen is about to record, which then replaces the recorded one.
+*/
+function assertResumeLimits(events, opts, reopenBudget) {
+	const roots = events.filter((event) => event.kind === "spawned" && event.parent === void 0);
+	if (roots.length !== 1 || roots[0]?.id !== opts.runId) throw new RuntimeRunStateError(`supervisor: resumed run '${opts.runId}' must contain exactly one root identity event; found ${roots.length}`);
+	const recorded = roots[0];
+	if (contentAddress(reopenBudget ?? events.filter((event) => event.kind === "reopened" && event.id === opts.runId && event.budget !== void 0).at(-1)?.budget ?? recorded.budget) !== contentAddress(opts.budget)) throw new RuntimeRunStateError(`supervisor: resume budget mismatch for run '${opts.runId}'; use a new runId to change limits`);
+	const expectedAdmission = opts.reservationPolicy ? { policy: opts.reservationPolicy } : void 0;
+	if (contentAddress(recorded.recursiveAdmission ?? null) !== contentAddress(expectedAdmission ?? null)) throw new RuntimeRunStateError(`supervisor: resume reservation policy mismatch for run '${opts.runId}'; use a new runId`);
+	return recorded;
+}
 /** Mint root evidence at the trusted composition boundary. A generic in-process Agent root has no
 * executor declaration and remains explicitly unknown rather than inheriting fabricated details. */
 function rootMaterializationReceipt(opts) {
@@ -32696,7 +33295,8 @@ async function noWinner(settled, rejection) {
 			reason: "cancelled",
 			source: cancellation.source,
 			cancellationReason: cancellation.message,
-			...cancellation.operationId === void 0 ? {} : { operationId: cancellation.operationId }
+			...cancellation.operationId === void 0 ? {} : { operationId: cancellation.operationId },
+			...cancellation.operator === void 0 ? {} : { operator: cancellation.operator }
 		};
 	}
 	if (lifecycle !== void 0) return {
@@ -32718,6 +33318,6 @@ async function noWinner(settled, rejection) {
 	};
 }
 //#endregion
-export { noteScopeRetainedOwnerCoordination as $, CONTINUATIONS_DIR as $n, runtimeOwnedExecutorProviderEvidence as $r, createWorktreeCliExecutor as $t, providerVisibleProfile as A, assertValidBudget as Ai, taskToPrompt$1 as An, fullProfileMaterialization as Ar, toolResultText as At, recordScopeOwnerBarrenPause as B, createSandboxUsageLedger as Bi, classifyDriverFailure as Bn, attestRuntimeOwnedScopeOwner as Br, startRetainedRun as Bt, beginScopeOwnerAttempt as C, executorFailure as Ci, DEFAULT_PEER_MAIL_LIMITS as Cn, LOCAL_HARNESSES as Cr, acquireSandbox as Ct, scopeOwnerExecutorNodeContext as D, newUsageTotals as Di, isPeerMailEnvelope as Dn, assertProfileMaterializes as Dr, codeModeModelOutput as Dt, restoreScopeOwnerAcceptedExecution as E, meterUsageEvent as Ei, createPeerMailbox as En, assertProfileMaterialization as Er, codeModeArguments as Et, freeSlots as F, mapSandboxEvent as Fi, isTerminalNodeStatus as Fn, sandboxActProfileMaterialization as Fr, providerAsExecutor as Ft, consumeScopeRetainedOwnerResult as G, awaitAbortable$1 as Gi, SeatChainExhaustedError as Gn, knownExecutionBindingReceipt as Gr, captureHarnessTranscript as Gt, recordScopeOwnerPause as H, notifySandboxEventObserver as Hi, undispatchedCredentialExit as Hn, authoredProfileDigest as Hr, retainedCreateMaterial as Ht, queueOf as I, mapSandboxToolEvent as Ii, DriverAttemptsExhaustedError as In, sandboxProfileMaterialization as Ir, LEAF_CONTINUATION_TASK as It, scopeRetainedOwnerResult as J, providerMessageText as Ji, subscriptionUsageLimitSignal as Jn, providerAttemptEvidence as Jr, readHarnessTranscript as Jt, prepareScopeRetainedOwnerTask as K, promptFromAgentTurnInput as Ki, authoredSeatStages as Kn, knownMaterializationReceipt as Kr, harnessTranscriptArtifact as Kt, rollingDispatch as L, terminalTextFromSandboxEvent as Li, HarnessTurnFailedError as Ln, unsupportedProfileDimensions as Lr, providerAsSandboxClient as Lt, settledToIteration as M, defaultRedactorIdentityMaterial as Mi, createActivityLog as Mn, promptControlProfileMaterialization as Mr, routerBrain as Mt, assertRecursiveReservationPolicy as N, resolveRedactor as Ni, readWorkerProgress as Nn, promptModelProfileMaterialization as Nr, createAgentEnvironmentProviderRegistry as Nt, coordinationMcpAlias as O, spendFromUsageEvents as Oi, peerMailTools as On, controlProfileMaterialization as Or, createCodeModeTools as Ot, deriveNodeExecutionIdentity as P, createSandboxToolPartState as Pi, isLiveNodeStatus as Pn, renderUnsupported as Pr, resolveAgentEnvironmentProvider as Pt, scopeRetainedOwnerRestorePoint as Q, verdictFromJudgeScore as Qn, runtimeOwnedExecutorMaterialization as Qr, openSlotGroup as Qt, meterRuntimeOwnedAccounting as R, canonicalStreamEventFromSandboxEvent as Ri, abandonablePending as Rn, worktreeCliProfileMaterialization as Rr, reconnectRetainedRun as Rt, FileSpawnJournal as S, contentAddress as Si, AUTHORITY_MARKERS as Sn, runWorktreeHarness as Sr, createSandboxLineage as St, recordScopeOwnerMaterialization as T, createBudgetPool as Ti, claimsAuthority as Tn, terminateProcessTreeAndConfirm as Tr, defaultSelectWinner as Tt, prepareScopeRetainedOwnerSeatSwitch as U, sumSandboxUsage as Ui, upstreamUnavailableSignal as Un, finalizeRuntimeOwnedPendingExecutor as Ur, destroyInteractiveEnvironment as Ut, recordScopeOwnerDriverAttempt as V, extractLlmCallEvent as Vi, summarizeDriverAttempts as Vn, authoredAgentIdentity as Vr, startRetainedRunInEnvironment as Vt, abandonScopeRetainedOwnerInvocation as W, decodeHarnessUsage as Wi, SeatChain as Wn, inheritRuntimeOwnedExecutorAttestation as Wr, environmentGone as Wt, scopeRetainedOwnerTurnEnded as X, gateOnDeliverable as Xn, runtimeOwnedDriveHarnessProviderEvidence as Xr, retainHarnessTranscript as Xt, beginScopeRetainedOwnerDrive as Y, CheckUnavailableError as Yn, recordRuntimeOwnedDriveHarnessProviderEvidence as Yr, resolveHarnessTranscriptCapture as Yt, reconcileScopeRetainedOwnerEnvironment as Z, mapExecutorResult as Zn, runtimeOwnedExecutorExecutionBinding as Zr, createWorkerSlots as Zt, attachWorker as _, unavailableSignalOfFailure as _i, sanitizeKnowledgeReadinessReport as _n, runAbortable as _r, createSteerableSandboxSession as _t, runTree as a, executableAgentSpecSnapshot as ai, buildLoopSpanNodes as an, isFiniteNumber as ar, loadSpawnForest as at, recoverRetainedInteractiveRun as b, detachedFrozen as bi, createInbox as bn, bridgeStopSignalKey as br, readPromptOptions as bt, driverExecutorFactory as c, runtimeFailureCause as ci, createOtelExporter as cn, priceTokens as cr, InMemorySpawnJournal as ct, createScope as d, registerRetainedExecutorPreparation as di, loopEventToOtelSpan as dn, createCodexRolloutStoreReader as dr, createExecutorRegistry as dt, runtimeOwnedPendingExecutorMaterialization as ei, createInPlaceCliExecutor as en, admitContinuationPolicy as er, bindScopeRetainedOwnerEnvironmentId as et, replaySpawnTree as f, retainedExecutorSeamKey as fi, padSpanId as fn, harnessUsageIsEmpty as fr, bindReusableExecutorExecutionId as ft, interactiveAdmissionSeamKey as g, unavailableResumeAt as gi, createRuntimeStreamEventCollector as gn, linkAbort as gr, DEFAULT_SANDBOX_STEERING_MAX_TURNS as gt, workerTraceAnalysisStore as h, unavailablePauseMs as hi, createRuntimeEventCollector as hn, RunCancellationReason as hr, snapshotExecutorConfig as ht, runFinalizer as i, executableAgentProfileSnapshot as ii, buildLoopOtelSpans as in, failedItems as ir, scopeRetainedOwnerJournalRoot as it, runtimeGraphMetadataKey as j, defaultRedactor as ji, DEFAULT_STALL_AFTER_MS as jn, profileMaterializationAxes$1 as jr, createRouterTranscript as jt, coordinationProfileToolPrefix as k, spendFromUsageTotals as ki, peerMailVerbNames as kn, defineProfileMaterializationContract as kr, runCodeMode as kt, isDriverSpec as l, settlementFailureCause as li, flatOtelSpan as ln, ROUTER_PRICE_SOURCE as lr, FileResultBlobStore as lt, parseWorkerToolTraceArtifact as m, jitteredMs as mi, toOtelAttributes as mn, createPushTraceSource as mr, createExecutor as mt, createSupervisor as n, unknownExecutionBindingReceipt as ni, createPropagatingTraceEmitter as nn, checkVerdictOf as nr, owners as nt, createRootHandle as o, projectSandboxOutcome as oi, buildRuntimeEventOtelSpans as on, bridgeAdmissionRefusal as or, materializeTreeView as ot, isTraceAnalysisStore as p, cappedDoublingMs as pi, padTraceId as pn, readCodexRolloutSession as pr, captureReusableExecutorConfig as pt, scopeRetainedOwnerPriorSpend as q, promptOptionsFromAgentTurnInput as qi, seatExecutionProfile as qn, newExecutionAttemptId as qr, persistHarnessTranscript as qt, bestDelivered as r, unknownMaterializationReceipt as ri, readTraceContextFromEnv as rn, createContinuationKeeper as rr, scopeRetainedOwnerContext as rt, driverChild as s, readSandboxOutcome as si, createOpenInferenceFileExporter as sn, bridgeModelRouteRefusal as sr, InMemoryResultBlobStore as st, DEFAULT_MAX_DEPTH as t, runtimeOwnedScopeOwnerRuntime as ti, WORKER_TRACE_PROPAGATION as tn, bestComposite as tr, bindScopeRetainedOwnerProvider as tt, withDriverExecutor as u, RetainedExecutionPendingError as ui, generateSpanId as un, addHarnessUsage as ur, insideCursorNamespace as ut, readWorkerInteractiveBinding as v, TRACE_ROOT_SCHEMA as vi, sanitizeRuntimeStreamEvent as vn, signalAbortError as vr, runAgentRounds as vt, noteScopeOwnerPlannedExecution as w, errMessage as wi, PEER_MAIL_WIRE_KEY as wn, harnessInvocation as wr, TERMINAL_DECISIONS as wt, startRetainedInteractiveRun as x, detachedSnapshot as xi, failPendingAfter as xn, runSettledCommand as xr, createSandboxForSpec as xt, reconnectRetainedInteractiveRun as y, TRACE_SUMMARY_SCHEMA as yi, INBOX_RECEIPT_KEY as yn, bridgeRuntimeAttachmentsKey as yr, assertBoxlessPromptOptions as yt, meterRuntimeOwnedProviderAttempt as z, createSandboxTurnEventCollector as zi, causedByPartialFailure as zn, attestRuntimeOwnedPendingExecutor as zr, recoverRetainedRun as zt };
+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 };
 
-//# sourceMappingURL=supervisor-C_03z693.js.map
+//# sourceMappingURL=supervisor-gDn4C1o5.js.map