@tangle-network/agent-runtime 0.238.0 → 0.240.0

package/dist/{supervisor-BN3oMv_v.js → supervisor-CFSPj8rx.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
@@ -3643,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 = [
@@ -4041,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,
@@ -4055,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
@@ -20441,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. */
@@ -20528,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);
@@ -22762,6 +23148,7 @@ function makeTreeView(root, children) {
 		...c.materialization ? { materialization: c.materialization } : {},
 		...c.executionBindings.length > 0 ? { executionBindings: Object.freeze([...c.executionBindings]) } : {},
 		spent: c.spent,
+		...c.resolved !== void 0 && !c.delivered ? { settlementPending: { kind: c.resolved.kind } } : {},
 		...c.settledAt === void 0 ? {} : { settledAt: c.settledAt },
 		...c.outRef ? { outRef: c.outRef } : {},
 		...c.trace ? { trace: c.trace } : {},
@@ -24660,6 +25047,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 { rollingDispatch as $, promptFromAgentTurnInput as $i, buildLoopOtelSpans as $n, knownMaterializationReceipt as $r, bridgeAdmissionRefusal as $t, validateWaitSpec as A, chargedTokens as Ai, registerRetainedExecutorPreparation as An, defineProfileMaterializationContract as Ar, spendFromUsageEvents as At, workerInteractiveAdmissionFile as B, throwIfAborted as Bi, retainedCreateMaterial as Bn, unsupportedProfileDimensions as Br, readWorkerProgress as Bt, restoreScopeOwnerAcceptedExecution as C, mapSandboxEvent as Ci, providerAsExecutor as Cn, harnessSupportsReasoningEffort as Cr, parseWorkerToolTraceArtifact as Ct, isWaitOutcome as D, sandboxProgressEvents as Di, createPushTraceSource as Dn, AGENT_PROFILE_MATERIALIZATION_AXES as Dr, createBudgetPool as Dt, createWaitProbes as E, sandboxEventServedBackend as Ei, sandboxClientAsProvider as En, CodexExecutionDiagnosticError as Er, assertValidBudget as Et, scopeRetainedOwnerContext as F, promptCacheTokenClasses as Fi, runAbortable as Fn, promptOnlyProfileMaterialization as Fr, workerTraceHeaders as Ft, reconnectRetainedInteractiveRun as G, resourceTelemetry as Gi, harnessTranscriptArtifact as Gn, readCommittedJsonLines as Gr, claimsAuthority as Gt, readWorkerInteractiveBinding as H, withTimeout as Hi, defaultRedactorIdentityMaterial as Hn, worktreeCliProfileMaterialization as Hr, AUTHORITY_MARKERS as Ht, scopeRetainedOwnerPriorSpend as I, randomSuffix as Ii, reconnectRetainedRun as In, promptResourceProfileMaterialization as Ir, workerTraceSeamKey as It, destroyInteractiveEnvironment as J, abortError$2 as Ji, createPropagatingTraceEmitter as Jn, attestRuntimeOwnedScopeOwner as Jr, peerMailTools as Jt, recoverRetainedInteractiveRun as K, withBudgetResources as Ki, persistHarnessTranscript as Kn, writeAllBytes as Kr, createPeerMailbox as Kt, scopeRetainedOwnerResult as L, sleep as Li, recoverRetainedRun as Ln, renderProfileMaterializationIssues as Lr, taskToPrompt as Lt, bindScopeRetainedOwnerProvider as M, deleteBoxSafe as Mi, RunCancellationReason as Mn, profileMaterializationAxes$1 as Mr, WORKER_TRACE_PROPAGATION as Mt, consumeScopeRetainedOwnerResult as N, hasCompleteCacheBreakdown as Ni, abortError as Nn, promptControlProfileMaterialization as Nr, readWorkerTraceContext as Nt, pollFor as O, sumSandboxUsage as Oi, decodeToolPart as On, assertProfileMaterialization as Or, meterUsageEvent as Ot, prepareScopeRetainedOwnerTask as P, isAbortError$2 as Pi, linkAbort as Pn, promptModelProfileMaterialization as Pr, workerTraceEnv as Pt, queueOf as Q, teardownExecutor as Qi, INTELLIGENCE_WIRE_VERSION as Qn, knownExecutionBindingReceipt as Qr, executorFailure as Qt, interactiveAdmissionSeamKey as R, stringifySafe as Ri, startRetainedRun as Rn, renderUnsupported as Rr, DEFAULT_STALL_AFTER_MS as Rt, recordScopeOwnerMaterialization as S, isSandboxTerminalEvent as Si, createAgentEnvironmentProviderRegistry as Sn, LOCAL_HARNESSES as Sr, isTraceAnalysisStore as St, settledToIteration as T, notifySandboxEventObserver as Ti, resolveAgentEnvironmentProvider as Tn, parseCodexTokenUsage as Tr, BudgetReconcileFault as Tt, workerInteractiveBindingFile as U, zeroSpend as Ui, resolveRedactor as Un, isNoEntError as Ur, DEFAULT_PEER_MAIL_LIMITS as Ut, attachWorker as V, unmeteredSpend as Vi, defaultRedactor as Vn, validateProfileMaterialization as Vr, createInbox as Vt, workerInteractiveBindingsDir as W, addResourceSpend as Wi, captureHarnessTranscript as Wn, prepareJsonlAppend as Wr, PEER_MAIL_WIRE_KEY as Wt, effectiveConcurrency as X, DEFAULT_SUCCESSFUL_SHUTDOWN_MS as Xi, readTraceContextFromEnv as Xn, finalizeRuntimeOwnedPendingExecutor as Xr, isLiveNodeStatus as Xt, errMessage as Y, awaitAbortable$1 as Yi, mergeTraceEnv as Yn, authoredProfileDigest as Yr, peerMailVerbNames as Yt, freeSlots as Z, armDeadlineTimer as Zi, traceContextToEnv as Zn, inheritRuntimeOwnedExecutorAttestation as Zr, isTerminalNodeStatus as Zt, beginScopeOwnerAttempt as _, assertSandboxServedModel as _i, routerBrain as _n, runWorktreeHarness as _r, materializeTreeView as _t, pickBestDelivered as a, runtimeOwnedExecutorMaterialization as ai, bridgeRuntimeAttachmentsKey as an, flatOtelSpan as ar, createExecutorRegistry as at, meterRuntimeOwnedAccounting as b, createSandboxUsageLedger as bi, observedModelMatchesDeclared as bn, removeWorktree as br, WORKER_TOOL_TRACE_SCHEMA_VERSION as bt, DriverAttemptsExhaustedError as c, runtimeOwnedScopeOwnerRuntime as ci, createSandboxForSpec as cn, padSpanId as cr, DEFAULT_SANDBOX_STEERING_MAX_TURNS as ct, defaultUnmetContractSteer as d, executableAgentProfileSnapshot as di, runAgentRounds as dn, createRuntimeEventCollector as dr, FileResultBlobStore as dt, promptOptionsFromAgentTurnInput as ea, newExecutionAttemptId as ei, bridgeModelRouteRefusal as en, buildLoopSpanNodes as er, bindReusableExecutorExecutionId as et, runDriverWithRetry as f, executableAgentSpecSnapshot as fi, createSandboxLineage as fn, createRuntimeStreamEventCollector as fr, FileSpawnJournal as ft, withDriverExecutor as g, readSandboxOutcome as gi, readPromptOptions as gn, runSettledCommand as gr, loadSpawnForest as gt, isDriverSpec as h, projectSandboxOutcome as hi, assertBoxlessPromptOptions as hn, sanitizeRuntimeStreamEvent as hr, insideCursorNamespace as ht, collectDelivered as i, runtimeOwnedExecutorExecutionBinding as ii, readCodexRolloutSession as in, exportEvalRuns as ir, createExecutor as it, waitUntil as j, cloneSpend as ji, retainedExecutorSeamKey as jn, fullProfileMaterialization as jr, spendFromUsageTotals as jt, timerAt as k, addSpend as ki, sandboxSessionTraceSource as kn, controlProfileMaterialization as kr, newUsageTotals as kt, HarnessTurnFailedError as l, unknownExecutionBindingReceipt as li, defaultSelectWinner as ln, padTraceId as lr, createSteerableSandboxSession as lt, driverExecutorFactory as m, detachedSnapshot as mi, acquireSandbox as mn, sanitizeKnowledgeReadinessReport as mr, InMemorySpawnJournal as mt, createSupervisor as n, recordRuntimeOwnedDriveHarnessProviderEvidence as ni, createCodexRolloutStoreReader as nn, createOpenInferenceFileExporter as nr, cliInPlaceExecutor as nt, runFinalizer as o, runtimeOwnedExecutorProviderEvidence as oi, bridgeStopSignalKey as on, generateSpanId as or, snapshotExecutorConfig as ot, driverChild as p, detachedFrozen as pi, probeSandboxCapabilities as pn, sanitizeAgentRuntimeEvent as pr, InMemoryResultBlobStore as pt, startRetainedInteractiveRun as q, decodeHarnessUsage as qi, contentAddress as qn, attestRuntimeOwnedPendingExecutor as qr, isPeerMailEnvelope as qt, bestDelivered as r, runtimeOwnedDriveHarnessProviderEvidence as ri, harnessUsageIsEmpty as rn, createOtelExporter as rr, cliWorktreeExecutor as rt, runTree as s, runtimeOwnedPendingExecutorMaterialization as si, TERMINAL_DECISIONS as sn, loopEventToOtelSpan as sr, createWorktreeCliExecutor as st, createRootHandle as t, providerMessageText as ta, providerAttemptEvidence as ti, addHarnessUsage as tn, buildRuntimeEventOtelSpans as tr, captureReusableExecutorConfig as tt, classifyDriverFailure as u, unknownMaterializationReceipt as ui, isTerminalDecision as un, toOtelAttributes as ur, createInPlaceCliExecutor as ut, createScope as v, canonicalStreamEventFromSandboxEvent as vi, runBrainLoop as vn, captureWorktreeDiff as vr, pendingWaits as vt, scopeOwnerExecutorNodeContext as w, mapSandboxToolEvent as wi, providerAsSandboxClient as wn, localHarnessExecutable as wr, workerTraceAnalysisStore as wt, meterRuntimeOwnedProviderAttempt as x, extractLlmCallEvent as xi, DEFAULT_SANDBOX_IDLE_TIMEOUT_SECONDS as xn, DEFAULT_LOCAL_HARNESS as xr, captureWorkerTraceEvidence as xt, deriveNodeExecutionIdentity as y, createSandboxToolPartState as yi, canonicalObservedModelParts as yn, createWorktree as yr, replaySpawnTree as yt, readWorkerInteractiveAdmissions as z, throwAbort as zi, startRetainedRunInEnvironment as zn, sandboxActProfileMaterialization as zr, createActivityLog 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-BN3oMv_v.js.map
+//# sourceMappingURL=supervisor-CFSPj8rx.js.map