@tangle-network/agent-runtime 0.121.0 → 0.123.1

package/dist/{supervisor-CpT9yAxL.js → supervisor-DpjO0Gmy.js}

@@ -1,8 +1,8 @@
-import { c as RuntimeRunStateError, u as ValidationError } from "./errors-DEAvWQPy.js";
-import { S as detachedSnapshot, _ as captureWorkerTraceEvidence, c as replaySpawnTree, f as attestNestedDriverTreeOwner, h as runtimeOwnedNestedDriverTreeRoot, m as nestedDriverTreeRoot, o as materializeTreeView, p as driverRuntime, s as pendingWaits, x as contentAddress } from "./spawn-journal-IeXpidO2.js";
+import { c as RuntimeRunStateError, i as ConfigError, u as ValidationError } from "./errors-DEAvWQPy.js";
+import { S as detachedSnapshot, _ as captureWorkerTraceEvidence, c as replaySpawnTree, f as attestNestedDriverTreeOwner, h as runtimeOwnedNestedDriverTreeRoot, m as nestedDriverTreeRoot, o as materializeTreeView, p as driverRuntime, s as pendingWaits, x as contentAddress } from "./spawn-journal-DsZKDqeh.js";
 import { f as zeroTokenUsage, t as addTokenUsage } from "./util-MVgdwuIS.js";
 import { i as notifyRuntimeHookEvent } from "./runtime-hooks-C7iJOWm3.js";
-import { estimateCost, isModelPriced } from "@tangle-network/agent-eval";
+import { HARNESS_NATIVE_MODEL, estimateCost, isModelPriced } from "@tangle-network/agent-eval";
 import { AGENT_PROFILE_MATERIALIZATION_AXES, agentProfileSchema, canonicalCandidateDigest, profileMaterializationAxes, sha256DigestSchema } from "@tangle-network/agent-interface";
 import { createHash, randomUUID } from "node:crypto";
 import { applyWorkspacePlan, hashWorkspacePlan, materializeProfile, resolveAgentProfileResources } from "@tangle-network/agent-profile-materialize";
@@ -12,6 +12,67 @@ import { basename, delimiter, dirname, isAbsolute, join, resolve, sep, win32 } f
 import { spawn } from "node:child_process";
 import { homedir, tmpdir } from "node:os";
 import { stripVTControlCharacters } from "node:util";
+import { deriveHexId, isW3CSpanId, isW3CTraceId } from "@tangle-network/agent-trace-contract";
+//#region src/runtime/supervise/model-policy.ts
+/**
+* `assertModelAllowed` — a fail-loud guard that restricts a run to a chosen subset of
+* models. The two front doors (`supervise()` / `improve()`) call it once per configured
+* model at resolve time, so a run that names a model outside the allowed set throws before
+* any compute is spent — never silently swapped or silently allowed.
+*/
+/**
+* Return the model id an executor may send to a provider.
+*
+* Eval stamps {@link HARNESS_NATIVE_MODEL} into a profile when model selection is deliberately
+* delegated to the configured runtime. That marker belongs in experiment identity and cost
+* admission; it is not a provider model id.
+*/
+function concreteModelId(model) {
+	if (model === void 0) return void 0;
+	const id = model.trim();
+	return id.length > 0 && !isHarnessNativeModel(id) ? id : void 0;
+}
+/** Whether a model value delegates selection to the chosen execution system. */
+function isHarnessNativeModel(model) {
+	return model?.trim() === HARNESS_NATIVE_MODEL;
+}
+/** Return a profile's explicitly selected provider model, if it has one. */
+function concreteProfileModel(profile) {
+	return concreteModelId(profile.model?.default);
+}
+/**
+* Remove only Eval's runtime-selected model marker before a profile crosses an execution boundary.
+* Every other model hint remains intact, including provider, reasoning effort, and small-model
+* preferences. The input profile is never mutated.
+*/
+function profileForExecution(profile) {
+	const model = profile.model;
+	if (!isHarnessNativeModel(model?.default) || model === void 0) return profile;
+	const { default: _runtimeSelected, ...remainingModel } = model;
+	const { model: _model, ...remainingProfile } = profile;
+	return Object.keys(remainingModel).length > 0 ? {
+		...remainingProfile,
+		model: remainingModel
+	} : remainingProfile;
+}
+/**
+* Throw a `ConfigError` when `allowed` is set, `model` is defined, and `model` is not a
+* member of `allowed`. No-op when `allowed` is unset (the unrestricted default) or when
+* `model` is undefined (nothing was configured to check).
+*/
+function assertModelAllowed(model, allowed) {
+	if (!allowed || model === void 0) return;
+	if (!allowed.includes(model)) throw new ConfigError(`model ${JSON.stringify(model)} is not in the allowed set ${JSON.stringify([...allowed])}`);
+}
+/** Check every canonical model-bearing field in a complete profile, including the models a
+* backend may select for cheap work, named subagents, or modes. */
+function assertProfileModelsAllowed(profile, allowed) {
+	assertModelAllowed(profile.model?.default, allowed);
+	assertModelAllowed(profile.model?.small, allowed);
+	for (const subagent of Object.values(profile.subagents ?? {})) assertModelAllowed(subagent.model, allowed);
+	for (const mode of Object.values(profile.modes ?? {})) assertModelAllowed(mode.model, allowed);
+}
+//#endregion
 //#region src/mcp/codex-diagnostics.ts
 /** Thrown when reproducible Codex exits without one valid terminal usage event. */
 var CodexExecutionDiagnosticError = class extends Error {
@@ -289,8 +350,7 @@ function harnessInvocation(harness, profile, taskPrompt, options = {}) {
 	const invocation = HARNESS_INVOCATIONS[harness];
 	if (!invocation) throw new Error(`harnessInvocation: unknown harness ${String(harness)}`);
 	if (options.codexReproducible) {
-		const model = profile.model?.default;
-		if (typeof model !== "string" || model.trim().length === 0) throw new Error("harnessInvocation: codexReproducible requires profile.model.default");
+		if (!concreteProfileModel(profile)) throw new Error("harnessInvocation: codexReproducible requires profile.model.default");
 		if (profile.model?.reasoningEffort === void 0) throw new Error("harnessInvocation: codexReproducible requires profile.model.reasoningEffort");
 	}
 	const systemPrompt = profile.prompt?.systemPrompt;
@@ -302,8 +362,8 @@ function harnessInvocation(harness, profile, taskPrompt, options = {}) {
 		taskPrompt
 	].join("\n\n");
 	const args = buildHarnessArgs(harness, composedPrompt, options);
-	const model = profile.model?.default;
-	if (typeof model === "string" && model.length > 0) args.push(...invocation.modelArgs(model));
+	const model = concreteProfileModel(profile);
+	if (model) args.push(...invocation.modelArgs(model));
 	const reasoningEffort = profile.model?.reasoningEffort;
 	if (reasoningEffort !== void 0) args.push(...harnessReasoningArgs(harness, reasoningEffort));
 	return {
@@ -4391,11 +4451,30 @@ function toOtelAttributes(record) {
 function msToNs(ms) {
 	return (BigInt(Math.floor(Number.isFinite(ms) ? ms : Date.now())) * 1000000n).toString();
 }
+/**
+* Map a caller-supplied span id onto the 16-hex OTLP encoding. An id that is already a valid W3C
+* span id passes through UNCHANGED — that is what lets an inherited `PARENT_SPAN_ID`/`TRACEPARENT`
+* id keep parenting the same trace. A DASHED hex id (a UUID-form id) passes through dash-stripped:
+* that is the exact wire id every earlier release exported for it, so cross-version joins survive
+* the strict-W3C upgrade. Anything else (a human run id) is DERIVED via the zero-dep contract's
+* `deriveHexId`, the one legal derivation: the old slice-and-pad produced ids that embedded the
+* raw input in the wire id and were not even valid hex (the contract's own `non-hex-id` validator
+* rejected what this module exported). Exported as the ONE wire-id normalization every writer
+* shares — `traceContextToEnv` builds the child's `TRACEPARENT` through these same functions, so
+* a parent's exported spans and the context it hands its children always name the same trace.
+*/
 function padSpanId(id) {
-	return id.replace(/-/g, "").slice(0, 16).padEnd(16, "0");
+	if (isW3CSpanId(id)) return id;
+	const dashless = id.replace(/-/g, "");
+	return isW3CSpanId(dashless) ? dashless : deriveHexId(id, 8);
 }
+/** Trace-id counterpart of {@link padSpanId}: valid W3C trace ids pass through (dash-stripped when
+*  UUID-form, preserving the pre-strict-W3C wire id), everything else is derived with
+*  `deriveHexId(id, 16)` so every process derives the SAME wire id for the same run. */
 function padTraceId(id) {
-	return id.replace(/-/g, "").slice(0, 32).padEnd(32, "0");
+	if (isW3CTraceId(id)) return id;
+	const dashless = id.replace(/-/g, "");
+	return isW3CTraceId(dashless) ? dashless : deriveHexId(id, 16);
 }
 /** Mint a fresh 16-hex-character OTLP span id. Exported so a producer that must know a span's id
 *  BEFORE the span closes (a node opened at spawn and parented by its children) uses this one
@@ -4452,18 +4531,63 @@ async function exportEvalRuns(events, config) {
 //#endregion
 //#region src/mcp/trace-propagation.ts
 /**
-* Read trace context from the process environment.
-* Returns a context with inherited ids or a freshly generated root.
+*
+* Trace context propagation across process-spawn boundaries.
+*
+* CANONICAL WIRE: the W3C `TRACEPARENT` environment variable
+* (`00-<32 hex trace id>-<16 hex span id>-<2 hex flags>`), the convention the wider ecosystem —
+* OTel SDKs, collectors, the Claude Code harness binary — already reads at spawn. The bespoke
+* `TRACE_ID` / `PARENT_SPAN_ID` pair this package shipped first is the FORK, not the standard:
+* it is still read as a fallback and still written alongside `TRACEPARENT` for one release, so
+* a child running either version of this package joins the same trace. The legacy pair is
+* scheduled for removal in the next major.
+*
+*   read:  TRACEPARENT first, then TRACE_ID / PARENT_SPAN_ID, else a fresh root.
+*   write: BOTH — TRACEPARENT (+ TRACESTATE untouched) and TRACE_ID / PARENT_SPAN_ID.
+*
+* A fresh root minted because NO context reached this process is a severed hop, not a normal
+* start: it is marked `unpropagated: true` and every span tree it emits carries
+* `tangle.trace.unpropagated=true`, so a disconnected trace is a queryable fact instead of a
+* silent stranger.
+*
+* @experimental
 */
-function readTraceContextFromEnv() {
+/** `00-<traceId>-<spanId>-<flags>`, any version prefix, case-insensitive per the W3C grammar. */
+const TRACEPARENT_PATTERN = /^[0-9a-f]{2}-([0-9a-f]{32})-([0-9a-f]{16})-[0-9a-f]{2}$/i;
+/** Parse a W3C `traceparent` header/env value, or `undefined` when malformed. Fails closed: a
+*  half-formed value yields no context rather than an unjoinable id. */
+function parseTraceparent(value) {
+	if (typeof value !== "string") return void 0;
+	const match = TRACEPARENT_PATTERN.exec(value.trim());
+	if (!match) return void 0;
+	const traceId = match[1].toLowerCase();
+	const parentSpanId = match[2].toLowerCase();
+	if (!isW3CTraceId(traceId) || !isW3CSpanId(parentSpanId)) return void 0;
 	return {
-		traceId: process.env.TRACE_ID || generateTraceId(),
-		parentSpanId: process.env.PARENT_SPAN_ID || void 0
+		traceId,
+		parentSpanId
+	};
+}
+/**
+* Read trace context from a process environment (defaults to `process.env`).
+* `TRACEPARENT` wins; the legacy `TRACE_ID` / `PARENT_SPAN_ID` pair is the fallback; with
+* neither present a fresh root is generated AND marked `unpropagated` — see {@link TraceContext}.
+*/
+function readTraceContextFromEnv(env = process.env) {
+	const fromTraceparent = parseTraceparent(env.TRACEPARENT);
+	if (fromTraceparent) return fromTraceparent;
+	if (env.TRACE_ID) return {
+		traceId: env.TRACE_ID,
+		...env.PARENT_SPAN_ID ? { parentSpanId: env.PARENT_SPAN_ID } : {}
+	};
+	return {
+		traceId: generateTraceId(),
+		unpropagated: true
 	};
 }
 /**
 * Create a LoopTraceEmitter that:
-*   1. Parents all spans under the inherited PARENT_SPAN_ID.
+*   1. Parents all spans under the inherited parent span id.
 *   2. Exports spans to OTEL when OTEL_EXPORTER_OTLP_ENDPOINT is set.
 *
 * Returns both the emitter and the optional exporter handle for shutdown.
@@ -4480,7 +4604,13 @@ function createPropagatingTraceEmitter(ctx) {
 			if (event.kind === "loop.ended") {
 				const events = buffers.get(event.runId) ?? [event];
 				buffers.delete(event.runId);
-				for (const span of buildLoopOtelSpans(events, ctx.traceId, ctx.parentSpanId)) exporter.exportSpan(span);
+				for (const span of buildLoopOtelSpans(events, ctx.traceId, ctx.parentSpanId)) exporter.exportSpan(ctx.unpropagated === true ? {
+					...span,
+					attributes: [...span.attributes ?? [], {
+						key: "tangle.trace.unpropagated",
+						value: { boolValue: true }
+					}]
+				} : span);
 			}
 		} },
 		exporter,
@@ -4488,14 +4618,49 @@ function createPropagatingTraceEmitter(ctx) {
 	};
 }
 /**
-* Build env vars to pass to a child MCP subprocess so it inherits the
-* current trace context.
+* Build env vars to pass to a child subprocess so it inherits the current trace context.
+*
+* Writes BOTH conventions (see the module doc): `TRACEPARENT` carries the W3C-hex ids — mapped
+* through the exporter's own `padTraceId`/`padSpanId` (dashed hex passes through dash-stripped, a
+* human id is derived through the contract's `deriveHexId`), the SAME normalization every emitted
+* span uses, so both spellings and the parent's own spans all name ONE trace — and the legacy
+* pair carries the caller's ids verbatim. `TRACEPARENT` needs a parent span id by grammar; when
+* the context has none, the legacy pair still propagates the trace id alone.
 */
 function traceContextToEnv(ctx) {
 	const env = { TRACE_ID: ctx.traceId };
 	if (ctx.parentSpanId) env.PARENT_SPAN_ID = ctx.parentSpanId;
+	if (ctx.parentSpanId) env.TRACEPARENT = `00-${padTraceId(ctx.traceId)}-${padSpanId(ctx.parentSpanId)}-01`;
 	return env;
 }
+/**
+* Merge a spawned child's environment from lowest to highest precedence — ambient env, the
+* recorder's stamped trace env, the caller's own overrides — while keeping the ONE cross-key
+* invariant a plain spread cannot: `TRACEPARENT` and the legacy pair must name the SAME trace.
+* A caller override that declares `TRACE_ID` / `PARENT_SPAN_ID` without its own `TRACEPARENT`
+* would otherwise keep the recorder's W3C wire — the child would join the caller's trace on the
+* legacy pair and the RECORDER's on the standard one. The dual-write is performed on the
+* caller's behalf: the merged `TRACEPARENT` is rebuilt from the merged legacy pair through the
+* same {@link traceContextToEnv} derivation (`deriveHexId` for human ids), or dropped when no
+* parent span id survives the merge (the W3C grammar requires one).
+*/
+function mergeTraceEnv(ambient, traceEnv, overrides) {
+	const merged = {
+		...ambient,
+		...traceEnv,
+		...overrides ?? {}
+	};
+	if (!(overrides !== void 0 && overrides.TRACEPARENT === void 0 && (overrides.TRACE_ID !== void 0 || overrides.PARENT_SPAN_ID !== void 0))) return merged;
+	delete merged.TRACEPARENT;
+	if (merged.TRACE_ID !== void 0) {
+		const rewritten = traceContextToEnv({
+			traceId: merged.TRACE_ID,
+			...merged.PARENT_SPAN_ID !== void 0 ? { parentSpanId: merged.PARENT_SPAN_ID } : {}
+		});
+		if (rewritten.TRACEPARENT !== void 0) merged.TRACEPARENT = rewritten.TRACEPARENT;
+	}
+	return merged;
+}
 function generateTraceId() {
 	const bytes = /* @__PURE__ */ new Uint8Array(16);
 	if (typeof globalThis.crypto?.getRandomValues === "function") globalThis.crypto.getRandomValues(bytes);
@@ -4513,11 +4678,13 @@ function generateTraceId() {
 * parent's trace id and the spawning node's span id emits spans that JOIN the parent's trace, and
 * the viewer assembles the whole cross-machine tree with no viewer change.
 *
-* NO NEW FORMAT. The wire is the env-var convention this package already ships and already reads:
-* `TRACE_ID` / `PARENT_SPAN_ID`, written by {@link traceContextToEnv} and read back by
-* `readTraceContextFromEnv()` (`src/mcp/trace-propagation.ts`). Nothing here invents a second
-* encoding; W3C `traceparent` would be the standard alternative, but adopting it alongside this one
-* would fork the contract, and the reader for THIS one is already in the package.
+* THE WIRE IS W3C `TRACEPARENT`, dual-written with the legacy pair. `traceContextToEnv`
+* (`src/mcp/trace-propagation.ts`) writes `TRACEPARENT` (the convention the ecosystem — OTel SDKs,
+* collectors, the Claude Code harness binary — reads at spawn) ALONGSIDE the bespoke
+* `TRACE_ID` / `PARENT_SPAN_ID` pair this package shipped first, and `readTraceContextFromEnv()`
+* reads `TRACEPARENT` first with the legacy pair as fallback. The bespoke pair is the fork, not
+* the standard; it is kept for one release so children on the previous package version still join,
+* then removed in the next major.
 *
 * WHICH SPAN. The stamped `PARENT_SPAN_ID` is the span of the node that DID the spawning — the
 * scope's own `parentId` — not the span of the worker's own node. At depth 0 that is the run's root
@@ -4545,7 +4712,10 @@ function generateTraceId() {
 *   2. the trace context stamped here,
 *   3. the caller's own seam env (`CliSeam.env`).
 * A caller who sets `TRACE_ID` / `PARENT_SPAN_ID` on a seam wins — theirs is a deliberate
-* declaration about the worker. Ambient `process.env` does NOT win: when the supervisor process was
+* declaration about the worker — and the W3C wire follows: a seam that overrides the legacy pair
+* without its own `TRACEPARENT` gets `TRACEPARENT` rebuilt from ITS ids (`mergeTraceEnv` performs
+* the dual-write on the caller's behalf), never left as the recorder's, so both spellings always
+* name the same trace. Ambient `process.env` does NOT win: when the supervisor process was
 * itself launched as someone's worker, its inherited ids describe the SUPERVISOR's place in an
 * outer trace, and reusing them for a child would file the child's spans under the wrong parent.
 * The supported way to join that outer trace is `SupervisorSpanOptions.traceId` / `parentSpanId`
@@ -4566,6 +4736,23 @@ function generateTraceId() {
 *   - `provider`      NO — `AgentEnvironmentProvider` has no environment field on its port.
 */
 /**
+* The census above, as a value the compiler checks. `satisfies` against every `ExecutorConfig`
+* discriminant means an EIGHTH backend arm cannot be added without classifying it here — the prose
+* alone could go stale silently, which is the failure this table exists to prevent.
+*
+* `true` = the arm has a real environment channel to the worker and stamps the context.
+* `false` = it has none today; it is honestly unpropagated rather than silently dropping.
+*/
+const WORKER_TRACE_PROPAGATION = {
+	cli: true,
+	sandbox: true,
+	router: false,
+	"router-tools": false,
+	bridge: false,
+	"cli-worktree": false,
+	provider: false
+};
+/**
 * Seam key the `Scope` seeds a {@link TraceContext} under on each child's `ExecutorContext.seams`.
 * Single-sourced here so the scope and every backend agree on it without a circular import — the
 * same arrangement `nestedScopeSeamKey` uses.
@@ -4587,7 +4774,8 @@ function readWorkerTraceContext(ctx) {
 	};
 }
 /**
-* The `TRACE_ID` / `PARENT_SPAN_ID` pair to merge into a worker's environment — EMPTY when the run
+* The trace env to merge into a worker's environment — `TRACEPARENT` plus the legacy
+* `TRACE_ID` / `PARENT_SPAN_ID` pair (dual-written for one release) — EMPTY when the run
 * records no spans, which is what keeps the untraced path byte-identical. Merge it BELOW the
 * caller's own seam env so a deliberately-set id wins (see the precedence note above).
 */
@@ -4657,6 +4845,7 @@ function makeNestedScopeSeam(args, liveWorkerCapacity, childNodeId, childBudget,
 				...args.now ? { now: args.now } : {},
 				...args.hooks ? { hooks: args.hooks } : {},
 				...args.workerTrace ? { workerTrace: args.workerTrace } : {},
+				...args.workerTraceUnpropagated ? { workerTraceUnpropagated: args.workerTraceUnpropagated } : {},
 				...deferredOwner.ownerMaterialization === void 0 ? {} : { ownerMaterialization: deferredOwner.ownerMaterialization }
 			});
 		}
@@ -4917,6 +5106,17 @@ function createScope(args) {
 				...identity ? { identity } : {},
 				seq: ordinal,
 				at: new Date(now()).toISOString()
+			}).then(async () => {
+				if (args.workerTraceUnpropagated === void 0 || workerTrace === void 0) return;
+				await args.journal.appendEvent(args.root, {
+					kind: "trace-unpropagated",
+					id,
+					expectedTraceId: workerTrace.traceId,
+					backend: args.workerTraceUnpropagated.backend,
+					reason: args.workerTraceUnpropagated.reason,
+					seq: ordinal,
+					at: new Date(now()).toISOString()
+				});
 			}).then(async () => {
 				const profileDigest = identity?.profileDigest ?? authoredProfileDigest(spec.profile);
 				let receipt;
@@ -6659,7 +6859,7 @@ function describeRejection(error) {
 function createSupervisor() {
 	let attached;
 	async function run(root, task, opts) {
-		const { budget, rootIdentity, rootMaterialization, runId, journal: journalStore, blobs: blobStore, executors: executorRegistry, probes, maxDepth, maxLiveWorkers, maxRestarts, withinMs, resume, now: suppliedNow, signal, hooks, workerTrace } = opts;
+		const { budget, rootIdentity, rootMaterialization, runId, journal: journalStore, blobs: blobStore, executors: executorRegistry, probes, maxDepth, maxLiveWorkers, maxRestarts, withinMs, resume, now: suppliedNow, signal, hooks, workerTrace, workerTraceUnpropagated } = opts;
 		const input = detachedSnapshot({
 			task,
 			options: {
@@ -6683,7 +6883,8 @@ function createSupervisor() {
 			...suppliedNow === void 0 ? {} : { now: suppliedNow },
 			...signal === void 0 ? {} : { signal },
 			...hooks === void 0 ? {} : { hooks },
-			...workerTrace === void 0 ? {} : { workerTrace }
+			...workerTrace === void 0 ? {} : { workerTrace },
+			...workerTraceUnpropagated === void 0 ? {} : { workerTraceUnpropagated }
 		});
 		task = input.task;
 		const rootAct = root.act.bind(root);
@@ -6790,6 +6991,7 @@ function createSupervisor() {
 				} } : {},
 				...opts.probes ? { probes: opts.probes } : {},
 				...opts.workerTrace ? { workerTrace: opts.workerTrace } : {},
+				...opts.workerTraceUnpropagated ? { workerTraceUnpropagated: opts.workerTraceUnpropagated } : {},
 				...resumeFrom ? { resumeFrom } : {}
 			});
 			const openScope = scope;
@@ -7186,6 +7388,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 { WORKER_TOKEN_FLOOR as $, loopEventToOtelSpan as A, promptControlProfileMaterialization as At, timerAt as B, harnessInvocation as Bt, buildLoopSpanNodes as C, removeWorktree as Ct, exportEvalRuns as D, defineProfileMaterializationContract as Dt, createOtelExporter as E, controlProfileMaterialization as Et, sanitizeKnowledgeReadinessReport as F, sandboxActProfileMaterialization as Ft, describeToolArgs as G, CodexExecutionDiagnosticError as Gt, waitUntil as H, localHarnessExecutable as Ht, sanitizeRuntimeStreamEvent as I, validateProfileMaterialization as It, freeSlots as J, readWorkerProgress as K, createWaitProbes as L, worktreeCliProfileMaterialization as Lt, createRuntimeEventCollector as M, promptOnlyProfileMaterialization as Mt, createRuntimeStreamEventCollector as N, promptResourceProfileMaterialization as Nt, flatOtelSpan as O, fullProfileMaterialization as Ot, sanitizeAgentRuntimeEvent as P, renderProfileMaterializationIssues as Pt, teardownExecutor as Q, isWaitOutcome as R, DEFAULT_LOCAL_HARNESS as Rt, buildLoopOtelSpans as S, createWorktree as St, createOpenInferenceFileExporter as T, assertProfileMaterialization as Tt, DEFAULT_STALL_AFTER_MS as U, parseCodexTokenUsage as Ut, validateWaitSpec as V, harnessSupportsReasoningEffort as Vt, createActivityLog as W, runLocalHarness as Wt, rollingDispatch as X, queueOf as Y, DEFAULT_SUCCESSFUL_SHUTDOWN_MS as Z, workerTraceSeamKey as _, runSettledCommand as _t, pickBestDelivered as a, attestRuntimeOwnedScopeOwner as at, traceContextToEnv as b, worktreeProfileExecutionPlan as bt, driverChild as c, runtimeOwnedExecutorExecutionBinding as ct, deriveNodeExecutionIdentity as d, routerBrain as dt, workerTokenFloor as et, recordScopeOwnerMaterialization as f, routerChatWithTools as ft, workerTraceEnv as g, runBrainLoop as gt, readWorkerTraceContext as h, streamRouterChatWithTools as ht, collectDelivered as i, attestRuntimeOwnedExecutor as it, toOtelAttributes as j, promptModelProfileMaterialization as jt, generateSpanId as k, profileMaterializationAxes as kt, withDriverExecutor as l, runtimeOwnedExecutorMaterialization as lt, settledToIteration as m, routerToolLoop as mt, createSupervisor as n, createBudgetPool as nt, runFinalizer as o, inheritRuntimeOwnedExecutorAttestation as ot, scopeOwnerExecutorNodeContext as p, routerChatWithUsage as pt, effectiveConcurrency as q, bestDelivered as r, spendFromUsageEvents as rt, runTree as s, newExecutionAttemptId as st, createRootHandle as t, assertValidBudget as tt, createScope as u, runtimeOwnedScopeOwnerRuntime as ut, createPropagatingTraceEmitter as v, runWorktreeChecks as vt, buildRuntimeEventOtelSpans as w, AGENT_PROFILE_MATERIALIZATION_AXES as wt, INTELLIGENCE_WIRE_VERSION as x, captureWorktreeDiff as xt, readTraceContextFromEnv as y, runWorktreeHarness as yt, pollFor as z, LOCAL_HARNESSES as zt };
+export { queueOf as $, concreteProfileModel as $t, flatOtelSpan as A, controlProfileMaterialization as At, sanitizeRuntimeStreamEvent as B, validateProfileMaterialization as Bt, INTELLIGENCE_WIRE_VERSION as C, runWorktreeHarness as Ct, createOpenInferenceFileExporter as D, removeWorktree as Dt, buildRuntimeEventOtelSpans as E, createWorktree as Et, toOtelAttributes as F, promptModelProfileMaterialization as Ft, validateWaitSpec as G, harnessSupportsReasoningEffort as Gt, isWaitOutcome as H, DEFAULT_LOCAL_HARNESS as Ht, createRuntimeEventCollector as I, promptOnlyProfileMaterialization as It, createActivityLog as J, runLocalHarness as Jt, waitUntil as K, localHarnessExecutable as Kt, createRuntimeStreamEventCollector as L, promptResourceProfileMaterialization as Lt, loopEventToOtelSpan as M, fullProfileMaterialization as Mt, padSpanId as N, profileMaterializationAxes as Nt, createOtelExporter as O, AGENT_PROFILE_MATERIALIZATION_AXES as Ot, padTraceId as P, promptControlProfileMaterialization as Pt, freeSlots as Q, concreteModelId as Qt, sanitizeAgentRuntimeEvent as R, renderProfileMaterializationIssues as Rt, traceContextToEnv as S, runWorktreeChecks as St, buildLoopSpanNodes as T, captureWorktreeDiff as Tt, pollFor as U, LOCAL_HARNESSES as Ut, createWaitProbes as V, worktreeCliProfileMaterialization as Vt, timerAt as W, harnessInvocation as Wt, readWorkerProgress as X, assertModelAllowed as Xt, describeToolArgs as Y, CodexExecutionDiagnosticError as Yt, effectiveConcurrency as Z, assertProfileModelsAllowed as Zt, workerTraceEnv as _, routerChatWithUsage as _t, pickBestDelivered as a, assertValidBudget as at, mergeTraceEnv as b, runBrainLoop as bt, driverChild as c, attestRuntimeOwnedExecutor as ct, deriveNodeExecutionIdentity as d, newExecutionAttemptId as dt, isHarnessNativeModel as en, rollingDispatch as et, recordScopeOwnerMaterialization as f, runtimeOwnedExecutorExecutionBinding as ft, readWorkerTraceContext as g, routerChatWithTools as gt, WORKER_TRACE_PROPAGATION as h, routerBrain as ht, collectDelivered as i, workerTokenFloor as it, generateSpanId as j, defineProfileMaterializationContract as jt, exportEvalRuns as k, assertProfileMaterialization as kt, withDriverExecutor as l, attestRuntimeOwnedScopeOwner as lt, settledToIteration as m, runtimeOwnedScopeOwnerRuntime as mt, createSupervisor as n, teardownExecutor as nt, runFinalizer as o, createBudgetPool as ot, scopeOwnerExecutorNodeContext as p, runtimeOwnedExecutorMaterialization as pt, DEFAULT_STALL_AFTER_MS as q, parseCodexTokenUsage as qt, bestDelivered as r, WORKER_TOKEN_FLOOR as rt, runTree as s, spendFromUsageEvents as st, createRootHandle as t, profileForExecution as tn, DEFAULT_SUCCESSFUL_SHUTDOWN_MS as tt, createScope as u, inheritRuntimeOwnedExecutorAttestation as ut, workerTraceSeamKey as v, routerToolLoop as vt, buildLoopOtelSpans as w, worktreeProfileExecutionPlan as wt, readTraceContextFromEnv as x, runSettledCommand as xt, createPropagatingTraceEmitter as y, streamRouterChatWithTools as yt, sanitizeKnowledgeReadinessReport as z, sandboxActProfileMaterialization as zt };
 
-//# sourceMappingURL=supervisor-CpT9yAxL.js.map
+//# sourceMappingURL=supervisor-DpjO0Gmy.js.map