@tangle-network/agent-runtime 0.163.0 → 0.165.0

package/dist/{supervisor-DmWq4vkU.js → supervisor-DpIKMlPJ.js}

@@ -1,7 +1,7 @@
 import { C as runtimeOwnedScopeOwnerRuntime, S as runtimeOwnedPendingExecutorMaterialization, T as unknownMaterializationReceipt, _ as runtimeOwnedDeferredExecutorRuntime, a as authoredProfileDigest, b as runtimeOwnedExecutorMaterialization, c as knownExecutionBindingReceipt, g as recordRuntimeOwnedProviderModel, h as recordRuntimeOwnedProviderIdentityConflict, l as knownMaterializationReceipt, m as recordRuntimeOwnedProviderDispatchNotStarted, n as attestRuntimeOwnedExecutor, o as finalizeRuntimeOwnedPendingExecutor, p as recordRuntimeOwnedProviderAttemptStart, r as attestRuntimeOwnedPendingExecutor, s as inheritRuntimeOwnedExecutorAttestation, t as attestRuntimeOwnedDeferredExecutor, u as newExecutionAttemptId, w as unknownExecutionBindingReceipt, x as runtimeOwnedExecutorProviderEvidence, y as runtimeOwnedExecutorExecutionBinding } from "./materialization-Ct3I4wu3.js";
 import { f as RuntimeRunStateError, m as ValidationError, r as BackendTransportError } from "./errors-CDZ8XsVj.js";
 import { n as detachedSnapshot } from "./snapshot-CTAf4uuA.js";
-import { _ as captureWorkerTraceEvidence, a as aggregateProviderModelEvidence, c as loadSpawnForest, d as replaySpawnTree, f as attestNestedDriverTreeOwner, h as runtimeOwnedNestedDriverTreeRoot, l as materializeTreeView, m as nestedDriverTreeRoot, o as closesCursorSlot, p as driverRuntime, u as pendingWaits, x as contentAddress } from "./spawn-journal-oewq1g2h.js";
+import { _ as captureWorkerTraceEvidence, a as aggregateProviderModelEvidence, c as loadSpawnForest, d as replaySpawnTree, f as attestNestedDriverTreeOwner, h as runtimeOwnedNestedDriverTreeRoot, l as materializeTreeView, m as nestedDriverTreeRoot, o as closesCursorSlot, p as driverRuntime, u as pendingWaits, x as contentAddress } from "./spawn-journal-Tgvp5VS5.js";
 import { _ as unmeteredSpend, a as cloneTokenUsage, b as zeroTokenUsage, d as randomSuffix, f as randomUuid, g as throwIfAborted, h as throwAbort, l as mapWithConcurrency, m as stringifySafe, n as addTokenUsage, o as deleteBoxSafe, p as sleep, r as chargedTokens, s as hasCompleteCacheBreakdown, t as addSpend, u as promptCacheTokenClasses, v as withTimeout, y as zeroSpend } from "./util-D6ZEuBMi.js";
 import { c as notifySandboxEventObserver, i as extractLlmCallEvent, l as sandboxEventServedBackend, r as createSandboxToolPartState, s as mapSandboxToolEvent, t as assertSandboxServedModel, u as sandboxProgressEvents } from "./sandbox-events-BVjstFgb.js";
 import { n as executableAgentSpecSnapshot, r as projectSandboxOutcome, t as executableAgentProfileSnapshot } from "./executable-spec-CkGvdPds.js";
@@ -513,7 +513,25 @@ const HARNESS_INVOCATIONS = {
 				ultracode: "max"
 			},
 			args: (level) => ["--variant", level]
-		}
+		},
+		permissionBypassArgs: () => ["--auto"]
+	},
+	pi: {
+		command: "pi",
+		buildArgs: (taskPrompt) => ["--print", taskPrompt],
+		modelArgs: (model) => ["--model", model],
+		reasoning: {
+			levels: {
+				minimal: "minimal",
+				low: "low",
+				medium: "medium",
+				high: "high",
+				xhigh: "xhigh",
+				ultracode: "max"
+			},
+			args: (level) => ["--thinking", level]
+		},
+		permissionBypassArgs: () => ["--approve"]
 	}
 };
 /** Every local harness, in table order — the one list `AGENT_RUNTIME_LOCAL_HARNESSES` and any
@@ -691,7 +709,7 @@ var RollingByteCapture = class {
 async function runLocalHarness(options) {
 	const { harness, cwd, taskPrompt } = options;
 	if (options.codexReproducible && harness !== "codex") throw new Error("runLocalHarness: codexReproducible requires the Codex harness");
-	if (options.codexReproducible && process.platform !== "linux") throw new Error("runLocalHarness: codexReproducible currently requires Linux");
+	if (options.codexReproducible && !isSupportedCodexPlatform()) throw new Error(`runLocalHarness: codexReproducible does not support ${process.platform}/${process.arch}; supported: linux and darwin on x64 or arm64`);
 	if (options.codexReadDeniedPaths !== void 0 && !options.codexReproducible) throw new Error("runLocalHarness: codexReadDeniedPaths requires codexReproducible");
 	const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
 	const maxOutputBytes = options.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
@@ -1194,7 +1212,7 @@ async function isolateCodexHome(opts) {
 		const stagedPath = join(candidateRoot, ".agent-runtime-bin");
 		if (readDeniedPaths.some((path) => isSameOrDescendant(candidateRoot, path) || isSameOrDescendant(stagedPath, path) || isSameOrDescendant(path, stagedPath))) throw new Error("runLocalHarness: codexReadDeniedPaths cannot contain the candidate root or staged executable");
 		const nativeExecutable = await opts.resolveExecutable(opts.command, opts.baseEnv);
-		if (!await isStaticElfExecutable(nativeExecutable)) throw new Error("runLocalHarness: reproducible Codex mode requires a statically linked Linux Codex ELF");
+		if (!await isVendoredCodexExecutable(nativeExecutable)) throw new Error("runLocalHarness: reproducible Codex mode requires the vendored native Codex build (a static musl ELF on linux, a Mach-O executable on darwin), not a PATH wrapper");
 		const sourceExecutableSha256 = await sha256File(nativeExecutable);
 		stagedExecutableDir = stagedPath;
 		try {
@@ -1207,7 +1225,7 @@ async function isolateCodexHome(opts) {
 		await copyFile(nativeExecutable, stagedExecutable, constants.COPYFILE_FICLONE);
 		await chmod(stagedExecutable, 320);
 		const executableSha256 = await sha256File(stagedExecutable);
-		if (executableSha256 !== sourceExecutableSha256 || !await isStaticElfExecutable(stagedExecutable)) throw new Error("runLocalHarness: staged Codex executable digest mismatch");
+		if (executableSha256 !== sourceExecutableSha256 || !await isVendoredCodexExecutable(stagedExecutable)) throw new Error("runLocalHarness: staged Codex executable digest mismatch");
 		await chmod(stagedExecutableDir, 320);
 		workspaceTemp = await mkdtemp(join(candidateRoot, ".agent-runtime-tmp-"));
 		await chmod(workspaceTemp, 448);
@@ -1357,7 +1375,7 @@ async function resolveCodexNativeExecutable(command, env) {
 		}
 		if (seen.has(resolved)) continue;
 		seen.add(resolved);
-		if (await isStaticElfExecutable(resolved)) return resolved;
+		if (await isVendoredCodexExecutable(resolved)) return resolved;
 		const packageRoot = await findCodexPackageRoot(resolved);
 		if (!packageRoot) continue;
 		const bundled = await findBundledCodexExecutable(packageRoot);
@@ -1377,51 +1395,103 @@ async function findCodexPackageRoot(file) {
 	}
 }
 async function findBundledCodexExecutable(packageRoot) {
-	const target = linuxCodexTarget();
+	const target = codexTarget();
 	const candidates = [join(packageRoot, "node_modules", "@openai", target.packageName, "vendor", target.triple, "bin", "codex"), join(packageRoot, "vendor", target.triple, "bin", "codex")];
-	for (const executable of candidates) if (await isStaticElfExecutable(executable)) return executable;
+	for (const executable of candidates) if (await isVendoredCodexExecutable(executable)) return executable;
 }
-function linuxCodexTarget() {
-	if (process.platform !== "linux") throw new Error("runLocalHarness: reproducible Codex mode requires Linux");
-	if (process.arch === "x64") return {
-		packageName: "codex-linux-x64",
-		triple: "x86_64-unknown-linux-musl"
-	};
-	if (process.arch === "arm64") return {
-		packageName: "codex-linux-arm64",
-		triple: "aarch64-unknown-linux-musl"
-	};
-	throw new Error(`runLocalHarness: unsupported Linux architecture ${process.arch}`);
+/**
+* The vendored Codex build for this host.
+*
+* `@openai/codex` ships a per-platform binary for linux, darwin and win32 on x64 and arm64.
+* Reproducible mode needs the vendored native executable rather than a PATH wrapper, so the
+* table maps host to package name plus Rust target triple. Linux vendors static musl builds;
+* darwin vendors Mach-O against the system libc, which is why the executable check below is
+* per-format rather than ELF-only.
+*/
+function codexTarget() {
+	const target = {
+		"linux-x64": {
+			packageName: "codex-linux-x64",
+			triple: "x86_64-unknown-linux-musl"
+		},
+		"linux-arm64": {
+			packageName: "codex-linux-arm64",
+			triple: "aarch64-unknown-linux-musl"
+		},
+		"darwin-x64": {
+			packageName: "codex-darwin-x64",
+			triple: "x86_64-apple-darwin"
+		},
+		"darwin-arm64": {
+			packageName: "codex-darwin-arm64",
+			triple: "aarch64-apple-darwin"
+		}
+	}[`${process.platform}-${process.arch}`];
+	if (!target) throw new Error(`runLocalHarness: reproducible Codex mode does not support ${process.platform}/${process.arch}`);
+	return target;
+}
+/** Hosts with a vendored Codex build reproducible mode can verify and run. */
+function isSupportedCodexPlatform() {
+	return (process.platform === "linux" || process.platform === "darwin") && (process.arch === "x64" || process.arch === "arm64");
 }
-async function isStaticElfExecutable(path) {
+/**
+* Is this the vendored native Codex build for this host?
+*
+* Reproducible mode must run the vendored binary, never a shell wrapper that could re-enter
+* a different toolchain, so the check reads the file's own header rather than trusting its
+* path. The two vendor formats differ: linux ships a STATIC musl ELF (an interpreter segment
+* would mean a dynamic build, which is rejected), darwin ships Mach-O linked against the
+* system libc, where dynamic linkage is normal and not a signal of the wrong artifact.
+*/
+async function isVendoredCodexExecutable(path) {
 	let handle;
 	try {
 		await access(path, constants.X_OK);
 		handle = await open(path, "r");
 		const header = Buffer.alloc(64);
 		const { bytesRead } = await handle.read(header, 0, header.length, 0);
-		if (bytesRead !== header.length || !header.subarray(0, 4).equals(Buffer.from([
-			127,
-			69,
-			76,
-			70
-		])) || header[4] !== 2 || header[5] !== 1) return false;
-		const programHeaderOffset = Number(header.readBigUInt64LE(32));
-		const programHeaderSize = header.readUInt16LE(54);
-		const programHeaderCount = header.readUInt16LE(56);
-		const expectedMachine = process.arch === "x64" ? 62 : process.arch === "arm64" ? 183 : -1;
-		if (![2, 3].includes(header.readUInt16LE(16)) || header.readUInt16LE(18) !== expectedMachine || !Number.isSafeInteger(programHeaderOffset) || programHeaderOffset < 64 || programHeaderSize < 56 || programHeaderSize > 1024 || programHeaderCount === 0 || programHeaderCount > 1024) return false;
-		const tableSize = programHeaderSize * programHeaderCount;
-		const table = Buffer.alloc(tableSize);
-		if ((await handle.read(table, 0, tableSize, programHeaderOffset)).bytesRead !== tableSize) return false;
-		for (let index = 0; index < programHeaderCount; index += 1) if (table.readUInt32LE(index * programHeaderSize) === 3) return false;
-		return true;
+		if (bytesRead !== header.length) return false;
+		if (process.platform === "darwin") return isMachOExecutable(header);
+		return await isStaticElf(header, handle);
 	} catch {
 		return false;
 	} finally {
 		await handle?.close();
 	}
 }
+/**
+* A 64-bit Mach-O executable for this architecture, or a universal binary containing one.
+*
+* Magics: 0xfeedfacf is a little-endian 64-bit Mach-O; 0xcafebabe/0xbebafeca is a fat header,
+* whose slices are checked by the loader at exec time rather than here.
+*/
+function isMachOExecutable(header) {
+	const magic = header.readUInt32LE(0);
+	const MH_MAGIC_64 = 4277009103;
+	const MH_CIGAM_64 = 3489328638;
+	if (magic === 3199925962 || magic === 3405691582) return true;
+	if (magic !== MH_MAGIC_64 && magic !== MH_CIGAM_64) return false;
+	return (magic === MH_MAGIC_64 ? header.readUInt32LE(4) : header.readUInt32BE(4)) === (process.arch === "x64" ? 16777223 : 16777228);
+}
+/** A statically linked ELF for this architecture: no PT_INTERP segment (type 3). */
+async function isStaticElf(header, handle) {
+	if (!header.subarray(0, 4).equals(Buffer.from([
+		127,
+		69,
+		76,
+		70
+	])) || header[4] !== 2 || header[5] !== 1) return false;
+	const programHeaderOffset = Number(header.readBigUInt64LE(32));
+	const programHeaderSize = header.readUInt16LE(54);
+	const programHeaderCount = header.readUInt16LE(56);
+	const expectedMachine = process.arch === "x64" ? 62 : process.arch === "arm64" ? 183 : -1;
+	if (![2, 3].includes(header.readUInt16LE(16)) || header.readUInt16LE(18) !== expectedMachine || !Number.isSafeInteger(programHeaderOffset) || programHeaderOffset < 64 || programHeaderSize < 56 || programHeaderSize > 1024 || programHeaderCount === 0 || programHeaderCount > 1024) return false;
+	const tableSize = programHeaderSize * programHeaderCount;
+	const table = Buffer.alloc(tableSize);
+	if ((await handle.read(table, 0, tableSize, programHeaderOffset)).bytesRead !== tableSize) return false;
+	for (let index = 0; index < programHeaderCount; index += 1) if (table.readUInt32LE(index * programHeaderSize) === 3) return false;
+	return true;
+}
 function sha256File(path) {
 	return new Promise((resolveDigest, reject) => {
 		const hash = createHash("sha256");
@@ -10508,13 +10578,16 @@ function createWaitProbes(entries) {
 function isWaitOutcome(value) {
 	return typeof value === "object" && value !== null && value.waitOutcome === true;
 }
-/** The absolute instant a spec is bounded by, or `undefined` for an unbounded poll. */
+/** The absolute instant a spec is bounded by, or `undefined` for an unbounded wait. */
 function waitUntil(spec) {
-	return spec.kind === "timer" ? spec.untilMs : spec.timeoutAtMs;
+	if (spec.kind === "timer") return spec.untilMs;
+	if (spec.kind === "token") return spec.expiresAtMs;
+	return spec.timeoutAtMs;
 }
 /** Structural validation, independent of the run. Returns null when the spec is usable. */
 function validateWaitSpec(spec) {
 	if (spec.kind === "timer") return Number.isFinite(spec.untilMs) ? null : "timer.untilMs must be a finite epoch-ms instant";
+	if (spec.kind === "token") return "token waits are graph-engine-owned; deliver them through engine resume/expire";
 	if (typeof spec.probe !== "string" || spec.probe.length === 0) return "poll.probe must be a non-empty probe name";
 	if (!Number.isFinite(spec.intervalMs) || spec.intervalMs <= 0) return "poll.intervalMs must be > 0";
 	if (spec.timeoutAtMs !== void 0 && !Number.isFinite(spec.timeoutAtMs)) return "poll.timeoutAtMs must be a finite epoch-ms instant";
@@ -10557,6 +10630,7 @@ async function runWait(args) {
 			outcome: outcome("timer", "fired", label, spec.untilMs, armedAt, now(), 0, 0, resumed)
 		};
 	}
+	if (spec.kind === "token") throw new ValidationError(`wait '${label}': token waits are graph-engine-owned; deliver them through engine resume/expire`);
 	const probe = args.probes?.resolve(spec.probe);
 	if (!probe) throw new ValidationError(`wait '${label}': poll probe '${spec.probe}' is not registered in this run's WaitProbeRegistry`);
 	let polls = 0;
@@ -13317,6 +13391,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;
 }
 //#endregion
-export { DEFAULT_STALL_AFTER_MS as $, LOCAL_HARNESSES as $t, createBudgetPool as A, buildLoopOtelSpans as At, createExecutorRegistry as B, padTraceId as Bt, effectiveConcurrency as C, canonicalObservedModel as Ct, DEFAULT_SUCCESSFUL_SHUTDOWN_MS as D, readTraceContextFromEnv as Dt, rollingDispatch as E, mergeTraceEnv as Et, bridgeRuntimeAttachmentsKey as F, exportEvalRuns as Ft, workerTraceEnv as G, sanitizeKnowledgeReadinessReport as Gt, createWorktreeCliExecutor as H, createRuntimeEventCollector as Ht, bridgeStopSignalKey as I, flatOtelSpan as It, DEFAULT_SANDBOX_STEERING_MAX_TURNS as J, runWorktreeHarness as Jt, workerTraceHeaders as K, sanitizeRuntimeStreamEvent as Kt, captureReusableExecutorConfig as L, generateSpanId as Lt, bindReusableExecutorExecutionId as M, buildRuntimeEventOtelSpans as Mt, bridgeAdmissionRead as N, createOpenInferenceFileExporter as Nt, teardownExecutor as O, traceContextToEnv as Ot, bridgeModelRouteRefusal as P, createOtelExporter as Pt, sandboxSessionTraceSource as Q, DEFAULT_LOCAL_HARNESS as Qt, cliWorktreeExecutor as R, loopEventToOtelSpan as Rt, waitUntil as S, runBrainLoop as St, queueOf as T, createPropagatingTraceEmitter as Tt, WORKER_TRACE_PROPAGATION as U, createRuntimeStreamEventCollector as Ut, snapshotExecutorConfig as V, toOtelAttributes as Vt, readWorkerTraceContext as W, sanitizeAgentRuntimeEvent as Wt, createPushTraceSource as X, createWorktree as Xt, createSteerableSandboxSession as Y, captureWorktreeDiff as Yt, decodeToolPart as Z, removeWorktree as Zt, createWaitProbes as _, unsupportedProfileDimensions as _n, runAgentRounds as _t, pickBestDelivered as a, assertProfileMaterialization as an, PEER_MAIL_WIRE_KEY as at, timerAt as b, acquireSandbox as bt, driverChild as c, fullProfileMaterialization as cn, isPeerMailEnvelope as ct, deriveNodeExecutionIdentity as d, promptModelProfileMaterialization as dn, isLiveNodeStatus as dt, harnessSupportsReasoningEffort as en, createActivityLog as et, meterRuntimeOwnedAccounting as f, promptOnlyProfileMaterialization as fn, isTerminalNodeStatus as ft, settledToIteration as g, sandboxActProfileMaterialization as gn, isTerminalDecision as gt, scopeOwnerExecutorNodeContext as h, renderUnsupported as hn, defaultSelectWinner as ht, collectDelivered as i, AGENT_PROFILE_MATERIALIZATION_AXES as in, DEFAULT_PEER_MAIL_LIMITS as it, spendFromUsageEvents as j, buildLoopSpanNodes as jt, assertValidBudget as k, INTELLIGENCE_WIRE_VERSION as kt, withDriverExecutor as l, profileMaterializationAxes$1 as ln, peerMailTools as lt, recordScopeOwnerMaterialization as m, renderProfileMaterializationIssues as mn, createSandboxForSpec as mt, createSupervisor as n, parseCodexTokenUsage as nn, createInbox as nt, runFinalizer as o, controlProfileMaterialization as on, claimsAuthority as ot, meterRuntimeOwnedProviderAttempt as p, promptResourceProfileMaterialization as pn, TERMINAL_DECISIONS as pt, workerTraceSeamKey as q, runSettledCommand as qt, bestDelivered as r, CodexExecutionDiagnosticError as rn, AUTHORITY_MARKERS as rt, runTree as s, defineProfileMaterializationContract as sn, createPeerMailbox as st, createRootHandle as t, localHarnessExecutable as tn, readWorkerProgress as tt, createScope as u, promptControlProfileMaterialization as un, peerMailVerbNames as ut, isWaitOutcome as v, validateProfileMaterialization as vn, createSandboxLineage as vt, freeSlots as w, observedModelMatchesDeclared as wt, validateWaitSpec as x, routerBrain as xt, pollFor as y, worktreeCliProfileMaterialization as yn, probeSandboxCapabilities as yt, createExecutor as z, padSpanId as zt };
+export { createPushTraceSource as $, createWorktree as $t, DEFAULT_SUCCESSFUL_SHUTDOWN_MS as A, readTraceContextFromEnv as At, captureReusableExecutorConfig as B, generateSpanId as Bt, timerAt as C, acquireSandbox as Ct, freeSlots as D, observedModelMatchesDeclared as Dt, effectiveConcurrency as E, canonicalObservedModel as Et, bindReusableExecutorExecutionId as F, buildRuntimeEventOtelSpans as Ft, createWorktreeCliExecutor as G, createRuntimeEventCollector as Gt, createExecutor as H, padSpanId as Ht, bridgeAdmissionRead as I, createOpenInferenceFileExporter as It, workerTraceEnv as J, sanitizeKnowledgeReadinessReport as Jt, WORKER_TRACE_PROPAGATION as K, createRuntimeStreamEventCollector as Kt, bridgeModelRouteRefusal as L, createOtelExporter as Lt, assertValidBudget as M, INTELLIGENCE_WIRE_VERSION as Mt, createBudgetPool as N, buildLoopOtelSpans as Nt, queueOf as O, createPropagatingTraceEmitter as Ot, spendFromUsageEvents as P, buildLoopSpanNodes as Pt, createSteerableSandboxSession as Q, captureWorktreeDiff as Qt, bridgeRuntimeAttachmentsKey as R, exportEvalRuns as Rt, pollFor as S, worktreeCliProfileMaterialization as Sn, probeSandboxCapabilities as St, waitUntil as T, runBrainLoop as Tt, createExecutorRegistry as U, padTraceId as Ut, cliWorktreeExecutor as V, loopEventToOtelSpan as Vt, snapshotExecutorConfig as W, toOtelAttributes as Wt, workerTraceSeamKey as X, runSettledCommand as Xt, workerTraceHeaders as Y, sanitizeRuntimeStreamEvent as Yt, DEFAULT_SANDBOX_STEERING_MAX_TURNS as Z, runWorktreeHarness as Zt, recordScopeOwnerMaterialization as _, renderProfileMaterializationIssues as _n, createSandboxForSpec as _t, uncertainSpawnBudgets as a, parseCodexTokenUsage as an, createInbox as at, createWaitProbes as b, unsupportedProfileDimensions as bn, runAgentRounds as bt, pickBestDelivered as c, assertProfileMaterialization as cn, PEER_MAIL_WIRE_KEY as ct, driverChild as d, fullProfileMaterialization as dn, isPeerMailEnvelope as dt, removeWorktree as en, decodeToolPart as et, withDriverExecutor as f, profileMaterializationAxes$1 as fn, peerMailTools as ft, meterRuntimeOwnedProviderAttempt as g, promptResourceProfileMaterialization as gn, TERMINAL_DECISIONS as gt, meterRuntimeOwnedAccounting as h, promptOnlyProfileMaterialization as hn, isTerminalNodeStatus as ht, sumMeasuredSpendFromEvents as i, localHarnessExecutable as in, readWorkerProgress as it, teardownExecutor as j, traceContextToEnv as jt, rollingDispatch as k, mergeTraceEnv as kt, runFinalizer as l, controlProfileMaterialization as ln, claimsAuthority as lt, deriveNodeExecutionIdentity as m, promptModelProfileMaterialization as mn, isLiveNodeStatus as mt, createSupervisor as n, LOCAL_HARNESSES as nn, DEFAULT_STALL_AFTER_MS as nt, bestDelivered as o, CodexExecutionDiagnosticError as on, AUTHORITY_MARKERS as ot, createScope as p, promptControlProfileMaterialization as pn, peerMailVerbNames as pt, readWorkerTraceContext as q, sanitizeAgentRuntimeEvent as qt, maxSeqOf as r, harnessSupportsReasoningEffort as rn, createActivityLog as rt, collectDelivered as s, AGENT_PROFILE_MATERIALIZATION_AXES as sn, DEFAULT_PEER_MAIL_LIMITS as st, createRootHandle as t, DEFAULT_LOCAL_HARNESS as tn, sandboxSessionTraceSource as tt, runTree as u, defineProfileMaterializationContract as un, createPeerMailbox as ut, scopeOwnerExecutorNodeContext as v, renderUnsupported as vn, defaultSelectWinner as vt, validateWaitSpec as w, routerBrain as wt, isWaitOutcome as x, validateProfileMaterialization as xn, createSandboxLineage as xt, settledToIteration as y, sandboxActProfileMaterialization as yn, isTerminalDecision as yt, bridgeStopSignalKey as z, flatOtelSpan as zt };
 
-//# sourceMappingURL=supervisor-DmWq4vkU.js.map
+//# sourceMappingURL=supervisor-DpIKMlPJ.js.map