@tangle-network/agent-runtime 0.237.0 → 0.239.0

package/dist/{supervisor-B5wyKVRd.js → supervisor-De0lytFU.js}

@@ -287,9 +287,9 @@ async function exactSessionResult(session) {
 	return session.result();
 }
 function assertEventBinding(source, controlRef) {
-	const transport = isRecord$2(source) ? source : void 0;
-	const payload = isRecord$2(source.data) ? source.data : void 0;
-	const providerEvent = isRecord$2(source.providerEvent) ? source.providerEvent : void 0;
+	const transport = isRecord$3(source) ? source : void 0;
+	const payload = isRecord$3(source.data) ? source.data : void 0;
+	const providerEvent = isRecord$3(source.providerEvent) ? source.providerEvent : void 0;
 	const bindings = [
 		{
 			value: transport,
@@ -317,7 +317,7 @@ function assertCanonicalEventBinding(controlRef, event) {
 	const binding = event.request.binding;
 	if (binding.runId !== controlRef.runId || binding.provider !== controlRef.provider || binding.environmentId !== controlRef.environmentId || binding.sessionId !== controlRef.sessionId || binding.executionId !== controlRef.executionId || binding.interactionId !== event.request.id) throw new Error("provider returned an interaction for another retained execution");
 }
-function isRecord$2(value) {
+function isRecord$3(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function assertStableText(value, label) {
@@ -391,7 +391,7 @@ function delay(ms, signal) {
 */
 function parseCodexUsageRecord(usage, label) {
 	const record = plainRecord$2(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);
@@ -471,10 +471,10 @@ function plainRecord$2(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
 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);
@@ -518,7 +518,7 @@ function assertRuntimeTimestamp(value, label) {
 const harnessNativePayloadType = "raw";
 /** Parse canonical payload fields without treating transport identity as event data. */
 function parseCanonicalTransportEvent(type, data, normalized, source) {
-	if (!isRecord$1(data)) throw new Error(`${source} emitted a canonical event without an object payload`);
+	if (!isRecord$2(data)) throw new Error(`${source} emitted a canonical event without an object payload`);
 	const outerType = String(type ?? "");
 	const harnessNative = outerType === harnessNativePayloadType;
 	if (normalized !== void 0) {
@@ -540,10 +540,10 @@ function parseCanonicalTransportEvent(type, data, normalized, source) {
 }
 /** Extract shared event identity without privileging one provider wire shape. */
 function extractTransportEventIdentity(event) {
-	const record = isRecord$1(event) ? event : {};
-	const data = isRecord$1(record.data) ? record.data : {};
-	const providerEvent = isRecord$1(record.providerEvent) ? record.providerEvent : {};
-	const providerData = isRecord$1(providerEvent.data) ? providerEvent.data : {};
+	const record = isRecord$2(event) ? event : {};
+	const data = isRecord$2(record.data) ? record.data : {};
+	const providerEvent = isRecord$2(record.providerEvent) ? record.providerEvent : {};
+	const providerData = isRecord$2(providerEvent.data) ? providerEvent.data : {};
 	const eventId = canonicalEventId(record, data, providerEvent, providerData);
 	const cursor = stableString(record.cursor ?? data.cursor ?? providerEvent.cursor ?? providerData.cursor);
 	const sequence = optionalSequence(record.sequence ?? data.sequence ?? providerEvent.sequence ?? providerData.sequence);
@@ -591,7 +591,7 @@ function optionalTimestamp(value) {
 	assertRuntimeTimestamp(value, "occurredAt");
 	return value;
 }
-function isRecord$1(value) {
+function isRecord$2(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 //#endregion
@@ -2365,22 +2365,66 @@ function providerAttemptEvidence(model) {
 }
 //#endregion
 //#region src/durable/jsonl-file.ts
-/** Parse an append-only JSONL file without treating a torn final write as committed data.
-* A malformed newline-terminated or non-final record is corruption and fails loud. */
-function parseCommittedJsonLines(text, source) {
-	const lines = text.split("\n");
-	const finalIndex = lines.length - 1;
-	const records = [];
-	for (const [index, line] of lines.entries()) {
-		if (line.length === 0) continue;
+/** 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 {
-			records.push(JSON.parse(line));
-		} catch (cause) {
-			if (index === finalIndex && !text.endsWith("\n")) break;
-			throw new Error(`${source}: malformed JSONL record at line ${index + 1}`, { cause });
+			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);
+					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);
+			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) {
+	if (line.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 });
 	}
-	return records;
 }
 /** FileHandle.write may legally make a short write. Loop until every byte is appended. */
 async function writeAllBytes(handle, value) {
@@ -3599,13 +3643,13 @@ function normalizeCodexDebugPromptNewlines(value) {
 function jsonTextContains(value, needle) {
 	if (typeof value === "string") return value.includes(needle);
 	if (Array.isArray(value)) return value.some((item) => jsonTextContains(item, needle));
-	if (isRecord(value)) return Object.values(value).some((item) => jsonTextContains(item, needle));
+	if (isRecord$1(value)) return Object.values(value).some((item) => jsonTextContains(item, needle));
 	return false;
 }
 function redactJsonText(value, text) {
 	if (typeof value === "string") return value.replaceAll(text, "");
 	if (Array.isArray(value)) return value.map((item) => redactJsonText(item, text));
-	if (isRecord(value)) return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, redactJsonText(item, text)]));
+	if (isRecord$1(value)) return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, redactJsonText(item, text)]));
 	return value;
 }
 const CODEX_AUTH_ENV = [
@@ -3997,11 +4041,11 @@ function parseCodexTokenUsage(stdout) {
 		} catch {
 			throw new ValidationError$1(`runLocalHarness: Codex JSONL line ${index + 1} is not valid JSON`);
 		}
-		if (isRecord(event) && event.type === "turn.completed") completed.push(event);
+		if (isRecord$1(event) && event.type === "turn.completed") completed.push(event);
 	}
 	if (completed.length !== 1) throw new ValidationError$1(`runLocalHarness: expected exactly one Codex turn.completed usage event, received ${completed.length}`);
 	const event = completed[0];
-	if (!isRecord(event) || !isRecord(event.usage)) throw new ValidationError$1("runLocalHarness: Codex turn.completed event is missing usage");
+	if (!isRecord$1(event) || !isRecord$1(event.usage)) throw new ValidationError$1("runLocalHarness: Codex turn.completed event is missing usage");
 	const record = parseCodexUsageRecord(event.usage, "runLocalHarness: Codex");
 	return {
 		inputTokens: record.inputTokens,
@@ -4011,7 +4055,7 @@ function parseCodexTokenUsage(stdout) {
 		...record.cacheWriteInputTokens === void 0 ? {} : { cacheWriteInputTokens: record.cacheWriteInputTokens }
 	};
 }
-function isRecord(value) {
+function isRecord$1(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 //#endregion
@@ -8083,7 +8127,8 @@ async function* streamProviderExecutor(args) {
 		settled = {
 			...result.outcome?.status === "failed" ? { outcome: {
 				success: false,
-				...result.outcome.error ? { error: result.outcome.error } : {}
+				...result.outcome.error ? { error: result.outcome.error } : {},
+				...result.outcome.errorCode ? { errorCode: result.outcome.errorCode } : {}
 			} } : {},
 			outRef: contentRef$1(`provider:${args.provider.name}`, result),
 			out: result,
@@ -13292,12 +13337,20 @@ function priceUnreceiptedWork(work) {
 const outcomeSchema = AgentTurnResultSchema.pick({
 	success: true,
 	error: true
-}).strict();
+}).extend({ errorCode: AgentTurnResultSchema.shape.error }).strict();
 /** Read only the executor envelope; application output and grades are not execution status. */
-function executorFailureReason(result) {
+function executorFailure(result) {
 	if (result.outcome === void 0) return void 0;
 	const outcome = outcomeSchema.parse(result.outcome);
-	return outcome.success ? void 0 : outcome.error ?? "Agent execution failed";
+	if (outcome.success) return void 0;
+	return {
+		error: outcome.error ?? "Agent execution failed",
+		...outcome.errorCode === void 0 ? {} : { errorCode: outcome.errorCode }
+	};
+}
+/** The failure text alone, for callers that record a settlement reason. */
+function executorFailureReason(result) {
+	return executorFailure(result)?.error;
 }
 /** Preserve deterministic result pointers across built-in executors and replay.
 * FNV-1a is an identity convention here, not a cryptographic integrity check. */
@@ -15572,18 +15625,10 @@ var FileSpawnJournal = class {
 		this.path = path;
 	}
 	async loadTree(root) {
-		const fs = await import("node:fs/promises");
-		let text;
-		try {
-			text = await fs.readFile(this.path, "utf8");
-		} catch (err) {
-			if (isNoEntError(err)) return void 0;
-			throw err;
-		}
 		let begun = false;
 		const events = [];
 		const index = new SpawnEventIndex(root);
-		for (const record of parseCommittedJsonLines(text, this.path)) {
+		for await (const record of readCommittedJsonLines(this.path, { allowMissing: true })) {
 			if (record.root !== root) continue;
 			if (record.kind === "begin") begun = true;
 			else {
@@ -15630,26 +15675,22 @@ var FileSpawnJournal = class {
 		});
 	}
 	async validationIndex() {
-		const fs = await import("node:fs/promises");
 		const stamp = await this.fileStamp();
 		if (this.appendIndex && this.appendIndex.stamp === stamp) return this.appendIndex;
 		this.appendIndex = void 0;
 		const trees = /* @__PURE__ */ new Map();
-		if (stamp !== void 0) {
-			const text = await fs.readFile(this.path, "utf8");
-			if (await this.fileStamp() !== stamp) throw new Error("spawn journal changed while rebuilding its append index");
-			for (const record of parseCommittedJsonLines(text, this.path)) if (record.kind === "begin") {
-				if (!trees.has(record.root)) trees.set(record.root, {
-					begunAt: record.at,
-					index: new SpawnEventIndex(record.root)
-				});
-			} else {
-				const tree = trees.get(record.root);
-				if (!tree) throw new Error(`spawn journal corrupted: event for tree '${record.root}' precedes its begin record`);
-				tree.index.assert(record.event);
-				tree.index.add(record.event);
-			}
+		if (stamp !== void 0) for await (const record of readCommittedJsonLines(this.path)) if (record.kind === "begin") {
+			if (!trees.has(record.root)) trees.set(record.root, {
+				begunAt: record.at,
+				index: new SpawnEventIndex(record.root)
+			});
+		} else {
+			const tree = trees.get(record.root);
+			if (!tree) throw new Error(`spawn journal corrupted: event for tree '${record.root}' precedes its begin record`);
+			tree.index.assert(record.event);
+			tree.index.add(record.event);
 		}
+		if (await this.fileStamp() !== stamp) throw new Error("spawn journal changed while rebuilding its append index");
 		this.appendIndex = {
 			stamp,
 			trees
@@ -19058,6 +19099,9 @@ function errorProperty(error, field) {
 		return `[unreadable error ${field}]`;
 	}
 }
+/** An HTTP status carried on a thrown error, read without trusting its getter. Provider SDKs put
+*  one on their own error classes, so this is how a refusal is recognised outside the transport
+*  taxonomy — for the persisted message here, and for the driver's retry verdict. */
 function errorHttpStatus(error) {
 	try {
 		const status = Reflect.get(error, "status");
@@ -20397,6 +20441,314 @@ async function prepareScopeResume(opts, events, signal, now, parentId = opts.run
 	};
 }
 //#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")
+			};
+		}
+	};
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** 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-scope-owner.ts
 const owners = /* @__PURE__ */ new WeakMap();
 /** The scope owns these writers; provider adapters receive only the restricted context. */
@@ -20484,6 +20836,84 @@ function bindScopeRetainedOwnerProvider(scope, provider) {
 	const state = owners.get(scope);
 	if (state) state.provider = provider;
 }
+/**
+* Bind where the owner's CURRENT environment id can be read from. The drive harness supplies a
+* resolver over its active executor's materialization receipt, which every provider path
+* publishes once the environment exists. The `environment` admission is written only on the
+* retained path, and the production tangle provider declares no `retainedControl`, so a reader
+* that scanned admissions alone would refuse every read on a real sandbox root while looking
+* correct in every test that uses the retained fixture.
+*/
+function bindScopeRetainedOwnerEnvironmentId(scope, liveEnvironmentId) {
+	const state = owners.get(scope);
+	if (state) state.liveEnvironmentId = liveEnvironmentId;
+}
+/**
+* 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);
+		}
+	};
+}
 /** The existing scope settlement barrier releases the owner's environment after all its turns. */
 async function releaseScopeRetainedOwnerEnvironment(scope) {
 	const state = owners.get(scope);
@@ -23369,7 +23799,9 @@ function unreportedSpend(total, prior) {
 *    so retrying re-runs a decision rather than recovering from an accident. They fail immediately.
 *  - TRANSIENT failures are everything foreign: a harness process that exited without a reason, a
 *    stream that cut mid-turn, a 5xx, a socket reset. Those are accidents, and they are exactly
-*    what a retry exists for.
+*    what a retry exists for. A harness turn that RETURNED a failed outcome is the same accident
+*    reported as a value rather than thrown, so the drive raises {@link HarnessTurnFailedError}
+*    and it is classified here like any other failure.
 *
 * The one loop the budget alone cannot bound is a driver that dies INSTANTLY and repeatedly — a
 * dead-on-arrival credential, a harness that refuses to start. Spending nothing, it would retry
@@ -23431,6 +23863,28 @@ const DETERMINISTIC_BRIDGE_CODES = /* @__PURE__ */ new Set([
 	"capability_denied"
 ]);
 /**
+* A driver's harness turn ran to its terminal result, and that result reported failure.
+*
+* A provider executor reports a failed turn as a returned outcome, not a thrown error, so without
+* this error a failed turn reads as a completed drive and never reaches the retry decision.
+* Measured 2026-09-17 on a Discovery director placed on tangle-sandbox with the opencode harness:
+* a 53-minute turn ended `status code 524`, and another ended `Invalid API key` after a platform
+* key expired mid-turn. A new turn succeeds in both cases.
+*
+* `errorCode` is the provider's machine code when it reported one. The classifier reads the code
+* and never the text, because the text is written for people and changes without notice.
+*/
+var HarnessTurnFailedError = class extends Error {
+	runtime;
+	errorCode;
+	constructor(runtime, failure) {
+		super(`${runtime} harness turn ended with a failed outcome` + (failure.errorCode === void 0 ? "" : ` (${failure.errorCode})`) + `: ${failure.error}`);
+		this.name = "HarnessTurnFailedError";
+		this.runtime = runtime;
+		if (failure.errorCode !== void 0) this.errorCode = failure.errorCode;
+	}
+};
+/**
 * Classify one driver failure. Runtime's own typed refusals are decisions and stay terminal;
 * anything foreign is an accident and is retryable. A `BackendTransportError` is split by status
 * because the taxonomy already promises consumers may branch on it: a 5xx/429/408 is the upstream
@@ -23440,6 +23894,7 @@ const DETERMINISTIC_BRIDGE_CODES = /* @__PURE__ */ new Set([
 function classifyDriverFailure(error, signal) {
 	if (signal?.aborted) return "terminal";
 	if (error instanceof Error && errorProperty(error, "name") === "AbortError") return "terminal";
+	if (error instanceof HarnessTurnFailedError) return error.errorCode !== void 0 && DETERMINISTIC_BRIDGE_CODES.has(error.errorCode) ? "terminal" : "transient";
 	if (error instanceof BackendTransportError) {
 		if (error.upstreamCode !== void 0 && DETERMINISTIC_BRIDGE_CODES.has(error.upstreamCode)) return "terminal";
 		const status = error.status;
@@ -23449,7 +23904,28 @@ function classifyDriverFailure(error, signal) {
 	}
 	if (error instanceof ValidationError$1 || error instanceof ConfigError || error instanceof RuntimeRunStateError) return "terminal";
 	if (error instanceof AgentEvalError$1) return "terminal";
-	return "transient";
+	return foreignHttpStatusVerdict(error) ?? "transient";
+}
+/**
+* A foreign error that still carries an HTTP status is a refusal we can read.
+*
+* A provider SDK throws its own error classes, so an environment `create` that the platform
+* refused arrives here as neither a `BackendTransportError` nor an `AgentEvalError`, and the
+* default sends it to `transient`. Measured 2026-09-16: a Tangle Sandbox create refused
+* `HTTP 400 {"code":"CONFIG_ERROR"}` for a key whose budget was fully reserved retried 14-22
+* times per node while the run showed a durable intent and no other event, so eleven of twelve
+* roots sat for 25 minutes with nothing to diagnose. The status was on the error the whole time.
+*
+* Reading it applies the same rule the transport branch already promises consumers: 408, 429 and
+* 5xx are the upstream having a bad moment, and any other 4xx is a request that will fail
+* identically forever. Anything without a plain numeric status keeps the historical default.
+*/
+function foreignHttpStatusVerdict(error) {
+	if (!(error instanceof Error)) return void 0;
+	const status = errorHttpStatus(error);
+	if (status === void 0 || status < 400) return void 0;
+	if (status === 408 || status === 429 || status >= 500) return "transient";
+	return "terminal";
 }
 /** The budget's own verdict on whether another attempt may run at all. */
 function budgetStop(budget, atMs) {
@@ -24570,6 +25046,6 @@ function isNonEmptySpend(s) {
 	return s.iterations > 0 || s.tokens.input > 0 || s.tokens.output > 0 || s.usd > 0 || s.ms > 0 || s.tokensKnown === false || s.usdKnown === false || Object.values(s.resources ?? {}).some((resource) => resource.amount > 0 || !resource.known);
 }
 //#endregion
-export { bindReusableExecutorExecutionId as $, providerMessageText as $i, buildRuntimeEventOtelSpans as $n, providerAttemptEvidence as $r, addHarnessUsage as $t, waitUntil as A, deleteBoxSafe as Ai, RunCancellationReason as An, profileMaterializationAxes$1 as Ar, spendFromUsageTotals as At, attachWorker as B, withTimeout as Bi, defaultRedactorIdentityMaterial as Bn, worktreeCliProfileMaterialization as Br, createInbox as Bt, scopeOwnerExecutorNodeContext as C, notifySandboxEventObserver as Ci, resolveAgentEnvironmentProvider as Cn, parseCodexTokenUsage as Cr, workerTraceAnalysisStore as Ct, pollFor as D, addSpend as Di, sandboxSessionTraceSource as Dn, controlProfileMaterialization as Dr, meterUsageEvent as Dt, isWaitOutcome as E, sumSandboxUsage as Ei, decodeToolPart as En, assertProfileMaterialization as Er, createBudgetPool as Et, scopeRetainedOwnerPriorSpend as F, sleep as Fi, recoverRetainedRun as Fn, renderProfileMaterializationIssues as Fr, workerTraceSeamKey as Ft, recoverRetainedInteractiveRun as G, decodeHarnessUsage as Gi, contentAddress as Gn, attestRuntimeOwnedPendingExecutor as Gr, createPeerMailbox as Gt, workerInteractiveBindingFile as H, addResourceSpend as Hi, captureHarnessTranscript as Hn, parseCommittedJsonLines as Hr, DEFAULT_PEER_MAIL_LIMITS as Ht, scopeRetainedOwnerResult as I, stringifySafe as Ii, startRetainedRun as In, renderUnsupported as Ir, taskToPrompt as It, errMessage as J, DEFAULT_SUCCESSFUL_SHUTDOWN_MS as Ji, readTraceContextFromEnv as Jn, finalizeRuntimeOwnedPendingExecutor as Jr, peerMailVerbNames as Jt, startRetainedInteractiveRun as K, abortError$2 as Ki, createPropagatingTraceEmitter as Kn, attestRuntimeOwnedScopeOwner as Kr, isPeerMailEnvelope as Kt, interactiveAdmissionSeamKey as L, throwAbort as Li, startRetainedRunInEnvironment as Ln, sandboxActProfileMaterialization as Lr, DEFAULT_STALL_AFTER_MS as Lt, consumeScopeRetainedOwnerResult as M, isAbortError$2 as Mi, linkAbort as Mn, promptModelProfileMaterialization as Mr, readWorkerTraceContext as Mt, prepareScopeRetainedOwnerTask as N, promptCacheTokenClasses as Ni, runAbortable as Nn, promptOnlyProfileMaterialization as Nr, workerTraceEnv as Nt, timerAt as O, chargedTokens as Oi, registerRetainedExecutorPreparation as On, defineProfileMaterializationContract as Or, newUsageTotals as Ot, scopeRetainedOwnerContext as P, randomSuffix as Pi, reconnectRetainedRun as Pn, promptResourceProfileMaterialization as Pr, workerTraceHeaders as Pt, rollingDispatch as Q, promptOptionsFromAgentTurnInput as Qi, buildLoopSpanNodes as Qn, newExecutionAttemptId as Qr, bridgeModelRouteRefusal as Qt, readWorkerInteractiveAdmissions as R, throwIfAborted as Ri, retainedCreateMaterial as Rn, unsupportedProfileDimensions as Rr, createActivityLog as Rt, restoreScopeOwnerAcceptedExecution as S, mapSandboxToolEvent as Si, providerAsSandboxClient as Sn, localHarnessExecutable as Sr, parseWorkerToolTraceArtifact as St, createWaitProbes as T, sandboxProgressEvents as Ti, createPushTraceSource as Tn, AGENT_PROFILE_MATERIALIZATION_AXES as Tr, assertValidBudget as Tt, workerInteractiveBindingsDir as U, resourceTelemetry as Ui, harnessTranscriptArtifact as Un, prepareJsonlAppend as Ur, PEER_MAIL_WIRE_KEY as Ut, readWorkerInteractiveBinding as V, zeroSpend as Vi, resolveRedactor as Vn, isNoEntError as Vr, AUTHORITY_MARKERS as Vt, reconnectRetainedInteractiveRun as W, withBudgetResources as Wi, persistHarnessTranscript as Wn, writeAllBytes as Wr, claimsAuthority as Wt, freeSlots as X, teardownExecutor as Xi, INTELLIGENCE_WIRE_VERSION as Xn, knownExecutionBindingReceipt as Xr, isTerminalNodeStatus as Xt, effectiveConcurrency as Y, armDeadlineTimer as Yi, traceContextToEnv as Yn, inheritRuntimeOwnedExecutorAttestation as Yr, isLiveNodeStatus as Yt, queueOf as Z, promptFromAgentTurnInput as Zi, buildLoopOtelSpans as Zn, knownMaterializationReceipt as Zr, bridgeAdmissionRefusal as Zt, createScope as _, createSandboxToolPartState as _i, canonicalObservedModelParts as _n, createWorktree as _r, pendingWaits as _t, pickBestDelivered as a, runtimeOwnedPendingExecutorMaterialization as ai, TERMINAL_DECISIONS as an, loopEventToOtelSpan as ar, snapshotExecutorConfig as at, meterRuntimeOwnedProviderAttempt as b, isSandboxTerminalEvent as bi, createAgentEnvironmentProviderRegistry as bn, LOCAL_HARNESSES as br, captureWorkerTraceEvidence as bt, DriverAttemptsExhaustedError as c, unknownMaterializationReceipt as ci, isTerminalDecision as cn, toOtelAttributes as cr, createSteerableSandboxSession as ct, runDriverWithRetry as d, detachedFrozen as di, probeSandboxCapabilities as dn, sanitizeAgentRuntimeEvent as dr, FileSpawnJournal as dt, recordRuntimeOwnedDriveHarnessProviderEvidence as ei, createCodexRolloutStoreReader as en, createOpenInferenceFileExporter as er, captureReusableExecutorConfig as et, driverChild as f, detachedSnapshot as fi, acquireSandbox as fn, sanitizeKnowledgeReadinessReport as fr, InMemoryResultBlobStore as ft, beginScopeOwnerAttempt as g, canonicalStreamEventFromSandboxEvent as gi, runBrainLoop as gn, captureWorktreeDiff as gr, materializeTreeView as gt, withDriverExecutor as h, assertSandboxServedModel as hi, routerBrain as hn, runWorktreeHarness as hr, loadSpawnForest as ht, collectDelivered as i, runtimeOwnedExecutorProviderEvidence as ii, bridgeStopSignalKey as in, generateSpanId as ir, createExecutorRegistry as it, bindScopeRetainedOwnerProvider as j, hasCompleteCacheBreakdown as ji, abortError as jn, promptControlProfileMaterialization as jr, WORKER_TRACE_PROPAGATION as jt, validateWaitSpec as k, cloneSpend as ki, retainedExecutorSeamKey as kn, fullProfileMaterialization as kr, spendFromUsageEvents as kt, classifyDriverFailure as l, executableAgentProfileSnapshot as li, runAgentRounds as ln, createRuntimeEventCollector as lr, createInPlaceCliExecutor as lt, isDriverSpec as m, readSandboxOutcome as mi, readPromptOptions as mn, runSettledCommand as mr, insideCursorNamespace as mt, createSupervisor as n, runtimeOwnedExecutorExecutionBinding as ni, readCodexRolloutSession as nn, exportEvalRuns as nr, cliWorktreeExecutor as nt, runFinalizer as o, runtimeOwnedScopeOwnerRuntime as oi, createSandboxForSpec as on, padSpanId as or, createWorktreeCliExecutor as ot, driverExecutorFactory as p, projectSandboxOutcome as pi, assertBoxlessPromptOptions as pn, sanitizeRuntimeStreamEvent as pr, InMemorySpawnJournal as pt, destroyInteractiveEnvironment as q, awaitAbortable$1 as qi, mergeTraceEnv as qn, authoredProfileDigest as qr, peerMailTools as qt, bestDelivered as r, runtimeOwnedExecutorMaterialization as ri, bridgeRuntimeAttachmentsKey as rn, flatOtelSpan as rr, createExecutor as rt, runTree as s, unknownExecutionBindingReceipt as si, defaultSelectWinner as sn, padTraceId as sr, DEFAULT_SANDBOX_STEERING_MAX_TURNS as st, createRootHandle as t, runtimeOwnedDriveHarnessProviderEvidence as ti, harnessUsageIsEmpty as tn, createOtelExporter as tr, cliInPlaceExecutor as tt, defaultUnmetContractSteer as u, executableAgentSpecSnapshot as ui, createSandboxLineage as un, createRuntimeStreamEventCollector as ur, FileResultBlobStore as ut, deriveNodeExecutionIdentity as v, createSandboxUsageLedger as vi, observedModelMatchesDeclared as vn, removeWorktree as vr, replaySpawnTree as vt, settledToIteration as w, sandboxEventServedBackend as wi, sandboxClientAsProvider as wn, CodexExecutionDiagnosticError as wr, BudgetReconcileFault as wt, recordScopeOwnerMaterialization as x, mapSandboxEvent as xi, providerAsExecutor as xn, harnessSupportsReasoningEffort as xr, isTraceAnalysisStore as xt, meterRuntimeOwnedAccounting as y, extractLlmCallEvent as yi, DEFAULT_SANDBOX_IDLE_TIMEOUT_SECONDS as yn, DEFAULT_LOCAL_HARNESS as yr, WORKER_TOOL_TRACE_SCHEMA_VERSION as yt, workerInteractiveAdmissionFile as z, unmeteredSpend as zi, defaultRedactor as zn, validateProfileMaterialization as zr, readWorkerProgress as zt };
+export { startRetainedInteractiveRun as $, decodeHarnessUsage as $i, contentAddress as $n, attestRuntimeOwnedPendingExecutor as $r, isPeerMailEnvelope as $t, validateWaitSpec as A, mapSandboxToolEvent as Ai, providerAsSandboxClient as An, localHarnessExecutable as Ar, workerTraceAnalysisStore as At, SPAWN_RESOURCE_PATH_MAX_BYTES as B, isAbortError$2 as Bi, linkAbort as Bn, promptModelProfileMaterialization as Br, workerTraceEnv as Bt, restoreScopeOwnerAcceptedExecution as C, assertSandboxServedModel as Ci, routerBrain as Cn, runWorktreeHarness as Cr, materializeTreeView as Ct, isWaitOutcome as D, extractLlmCallEvent as Di, DEFAULT_SANDBOX_IDLE_TIMEOUT_SECONDS as Dn, DEFAULT_LOCAL_HARNESS as Dr, captureWorkerTraceEvidence as Dt, createWaitProbes as E, createSandboxUsageLedger as Ei, observedModelMatchesDeclared as En, removeWorktree as Er, WORKER_TOOL_TRACE_SCHEMA_VERSION as Et, prepareScopeRetainedOwnerTask as F, addSpend as Fi, sandboxSessionTraceSource as Fn, controlProfileMaterialization as Fr, newUsageTotals as Ft, readWorkerInteractiveAdmissions as G, throwAbort as Gi, startRetainedRunInEnvironment as Gn, sandboxActProfileMaterialization as Gr, createActivityLog as Gt, hostDirectoryReader as H, randomSuffix as Hi, reconnectRetainedRun as Hn, promptResourceProfileMaterialization as Hr, workerTraceSeamKey as Ht, scopeRetainedOwnerContext as I, chargedTokens as Ii, registerRetainedExecutorPreparation as In, defineProfileMaterializationContract as Ir, spendFromUsageEvents as It, readWorkerInteractiveBinding as J, withTimeout as Ji, defaultRedactorIdentityMaterial as Jn, worktreeCliProfileMaterialization as Jr, AUTHORITY_MARKERS as Jt, workerInteractiveAdmissionFile as K, throwIfAborted as Ki, retainedCreateMaterial as Kn, unsupportedProfileDimensions as Kr, readWorkerProgress as Kt, scopeRetainedOwnerPriorSpend as L, cloneSpend as Li, retainedExecutorSeamKey as Ln, fullProfileMaterialization as Lr, spendFromUsageTotals as Lt, bindScopeRetainedOwnerEnvironmentId as M, sandboxEventServedBackend as Mi, sandboxClientAsProvider as Mn, CodexExecutionDiagnosticError as Mr, assertValidBudget as Mt, bindScopeRetainedOwnerProvider as N, sandboxProgressEvents as Ni, createPushTraceSource as Nn, AGENT_PROFILE_MATERIALIZATION_AXES as Nr, createBudgetPool as Nt, pollFor as O, isSandboxTerminalEvent as Oi, createAgentEnvironmentProviderRegistry as On, LOCAL_HARNESSES as Or, isTraceAnalysisStore as Ot, consumeScopeRetainedOwnerResult as P, sumSandboxUsage as Pi, decodeToolPart as Pn, assertProfileMaterialization as Pr, meterUsageEvent as Pt, recoverRetainedInteractiveRun as Q, withBudgetResources as Qi, persistHarnessTranscript as Qn, writeAllBytes as Qr, createPeerMailbox as Qt, scopeRetainedOwnerResourceReader as R, deleteBoxSafe as Ri, RunCancellationReason as Rn, profileMaterializationAxes$1 as Rr, WORKER_TRACE_PROPAGATION as Rt, recordScopeOwnerMaterialization as S, readSandboxOutcome as Si, readPromptOptions as Sn, runSettledCommand as Sr, loadSpawnForest as St, settledToIteration as T, createSandboxToolPartState as Ti, canonicalObservedModelParts as Tn, createWorktree as Tr, replaySpawnTree as Tt, resolveSpawnResourcePaths as U, sleep as Ui, recoverRetainedRun as Un, renderProfileMaterializationIssues as Ur, taskToPrompt as Ut, environmentReader as V, promptCacheTokenClasses as Vi, runAbortable as Vn, promptOnlyProfileMaterialization as Vr, workerTraceHeaders as Vt, interactiveAdmissionSeamKey as W, stringifySafe as Wi, startRetainedRun as Wn, renderUnsupported as Wr, DEFAULT_STALL_AFTER_MS as Wt, workerInteractiveBindingsDir as X, addResourceSpend as Xi, captureHarnessTranscript as Xn, prepareJsonlAppend as Xr, PEER_MAIL_WIRE_KEY as Xt, workerInteractiveBindingFile as Y, zeroSpend as Yi, resolveRedactor as Yn, isNoEntError as Yr, DEFAULT_PEER_MAIL_LIMITS as Yt, reconnectRetainedInteractiveRun as Z, resourceTelemetry as Zi, harnessTranscriptArtifact as Zn, readCommittedJsonLines as Zr, claimsAuthority as Zt, beginScopeOwnerAttempt as _, executableAgentProfileSnapshot as _i, runAgentRounds as _n, createRuntimeEventCollector as _r, FileResultBlobStore as _t, pickBestDelivered as a, promptFromAgentTurnInput as aa, knownMaterializationReceipt as ai, bridgeAdmissionRefusal as an, buildLoopOtelSpans as ar, rollingDispatch as at, meterRuntimeOwnedAccounting as b, detachedSnapshot as bi, acquireSandbox as bn, sanitizeKnowledgeReadinessReport as br, InMemorySpawnJournal as bt, DriverAttemptsExhaustedError as c, recordRuntimeOwnedDriveHarnessProviderEvidence as ci, createCodexRolloutStoreReader as cn, createOpenInferenceFileExporter as cr, cliInPlaceExecutor as ct, defaultUnmetContractSteer as d, runtimeOwnedExecutorMaterialization as di, bridgeRuntimeAttachmentsKey as dn, flatOtelSpan as dr, createExecutorRegistry as dt, abortError$2 as ea, attestRuntimeOwnedScopeOwner as ei, peerMailTools as en, createPropagatingTraceEmitter as er, destroyInteractiveEnvironment as et, runDriverWithRetry as f, runtimeOwnedExecutorProviderEvidence as fi, bridgeStopSignalKey as fn, generateSpanId as fr, snapshotExecutorConfig as ft, withDriverExecutor as g, unknownMaterializationReceipt as gi, isTerminalDecision as gn, toOtelAttributes as gr, createInPlaceCliExecutor as gt, isDriverSpec as h, unknownExecutionBindingReceipt as hi, defaultSelectWinner as hn, padTraceId as hr, createSteerableSandboxSession as ht, collectDelivered as i, teardownExecutor as ia, knownExecutionBindingReceipt as ii, executorFailure as in, INTELLIGENCE_WIRE_VERSION as ir, queueOf as it, waitUntil as j, notifySandboxEventObserver as ji, resolveAgentEnvironmentProvider as jn, parseCodexTokenUsage as jr, BudgetReconcileFault as jt, timerAt as k, mapSandboxEvent as ki, providerAsExecutor as kn, harnessSupportsReasoningEffort as kr, parseWorkerToolTraceArtifact as kt, HarnessTurnFailedError as l, runtimeOwnedDriveHarnessProviderEvidence as li, harnessUsageIsEmpty as ln, createOtelExporter as lr, cliWorktreeExecutor as lt, driverExecutorFactory as m, runtimeOwnedScopeOwnerRuntime as mi, createSandboxForSpec as mn, padSpanId as mr, DEFAULT_SANDBOX_STEERING_MAX_TURNS as mt, createSupervisor as n, DEFAULT_SUCCESSFUL_SHUTDOWN_MS as na, finalizeRuntimeOwnedPendingExecutor as ni, isLiveNodeStatus as nn, readTraceContextFromEnv as nr, effectiveConcurrency as nt, runFinalizer as o, promptOptionsFromAgentTurnInput as oa, newExecutionAttemptId as oi, bridgeModelRouteRefusal as on, buildLoopSpanNodes as or, bindReusableExecutorExecutionId as ot, driverChild as p, runtimeOwnedPendingExecutorMaterialization as pi, TERMINAL_DECISIONS as pn, loopEventToOtelSpan as pr, createWorktreeCliExecutor as pt, attachWorker as q, unmeteredSpend as qi, defaultRedactor as qn, validateProfileMaterialization as qr, createInbox as qt, bestDelivered as r, armDeadlineTimer as ra, inheritRuntimeOwnedExecutorAttestation as ri, isTerminalNodeStatus as rn, traceContextToEnv as rr, freeSlots as rt, runTree as s, providerMessageText as sa, providerAttemptEvidence as si, addHarnessUsage as sn, buildRuntimeEventOtelSpans as sr, captureReusableExecutorConfig as st, createRootHandle as t, awaitAbortable$1 as ta, authoredProfileDigest as ti, peerMailVerbNames as tn, mergeTraceEnv as tr, errMessage as tt, classifyDriverFailure as u, runtimeOwnedExecutorExecutionBinding as ui, readCodexRolloutSession as un, exportEvalRuns as ur, createExecutor as ut, createScope as v, executableAgentSpecSnapshot as vi, createSandboxLineage as vn, createRuntimeStreamEventCollector as vr, FileSpawnJournal as vt, scopeOwnerExecutorNodeContext as w, canonicalStreamEventFromSandboxEvent as wi, runBrainLoop as wn, captureWorktreeDiff as wr, pendingWaits as wt, meterRuntimeOwnedProviderAttempt as x, projectSandboxOutcome as xi, assertBoxlessPromptOptions as xn, sanitizeRuntimeStreamEvent as xr, insideCursorNamespace as xt, deriveNodeExecutionIdentity as y, detachedFrozen as yi, probeSandboxCapabilities as yn, sanitizeAgentRuntimeEvent as yr, InMemoryResultBlobStore as yt, scopeRetainedOwnerResult as z, hasCompleteCacheBreakdown as zi, abortError as zn, promptControlProfileMaterialization as zr, readWorkerTraceContext as zt };
 
-//# sourceMappingURL=supervisor-B5wyKVRd.js.map
+//# sourceMappingURL=supervisor-De0lytFU.js.map