@tangle-network/agent-runtime 0.114.0 → 0.115.1

package/dist/{supervise-tdxMJYem.js → supervise-B7TIJR3D.js}

@@ -1,11 +1,11 @@
 import { c as RuntimeRunStateError, i as ConfigError, o as NotFoundError, t as AgentEvalError$1, u as ValidationError } from "./errors-DEAvWQPy.js";
 import { a as mapWithConcurrency, c as sleep, d as throwIfAborted, f as withTimeout, l as stringifySafe, n as addTokenUsage, o as randomSuffix, p as zeroTokenUsage, r as deleteBoxSafe, s as randomUuid, t as abortError, u as throwAbort } from "./util-Cc9g9Y-o.js";
 import { a as contentAddress, i as InMemorySpawnJournal, n as FileSpawnJournal, r as InMemoryResultBlobStore, t as FileResultBlobStore } from "./spawn-journal-DCPbicXB.js";
-import { A as captureWorktreeDiff, C as routerChatWithUsage, E as runBrainLoop, M as removeWorktree, O as runWorktreeChecks, a as runFinalizer, i as pickBestDelivered, j as createWorktree, k as runWorktreeHarness, l as withDriverExecutor, n as bestDelivered, o as runTree, t as createSupervisor, x as routerBrain, y as createActivityLog } from "./supervisor-DKqolBGI.js";
-import { i as notifyRuntimeHookEvent } from "./runtime-hooks-C7iJOWm3.js";
+import { A as captureWorktreeDiff, C as routerChatWithUsage, E as runBrainLoop, M as removeWorktree, O as runWorktreeChecks, a as runFinalizer, i as pickBestDelivered, j as createWorktree, k as runWorktreeHarness, l as withDriverExecutor, n as bestDelivered, o as runTree, t as createSupervisor, x as routerBrain, y as createActivityLog } from "./supervisor-DzQu5Ydu.js";
+import { i as notifyRuntimeHookEvent, t as composeRuntimeHooks } from "./runtime-hooks-C7iJOWm3.js";
 import { a as notifySandboxEventObserver, n as extractLlmCallEvent } from "./sandbox-events-DeI5xX8P.js";
+import { a as createOtelExporter, c as generateSpanId, r as buildLoopSpanNodes, u as toOtelAttributes } from "./otel-export-CPZTSADj.js";
 import { i as resolveAgentEnvironmentProvider, n as providerAsExecutor, s as buildBackendOptions } from "./environment-provider-CCaEhA-l.js";
-import { r as buildLoopSpanNodes } from "./otel-export-D34IQW1C.js";
 import { t as createStdioToolServer } from "./tool-server-RcWgLIsL.js";
 import { n as UI_LENSES } from "./substrate-B0TYNrXn.js";
 import { argHash, computeFindingId, errorStreakDetector, estimateCost, isModelPriced, makeFinding, observeAll, repeatedActionDetector } from "@tangle-network/agent-eval";
@@ -94,6 +94,308 @@ function assertModelAllowed(model, allowed) {
 	if (!allowed.includes(model)) throw new ConfigError(`model ${JSON.stringify(model)} is not in the allowed set ${JSON.stringify([...allowed])}`);
 }
 //#endregion
+//#region src/runtime/supervise/otel-spans.ts
+/**
+* Supervisor tree → OTLP spans. OPT-IN, off by default.
+*
+* WHY. A supervised tree is legible today only by parsing this package's own spawn journal, so
+* every other multi-agent shape on the machine (a coding-CLI's subagents, a pi fanout, ad-hoc tool
+* parallelism) needs its own bespoke reader. A span carrying `parent_span_id` IS a tree, and any
+* system can emit one — so emitting spans makes the supervisor readable by the same viewer as
+* everything else, with no per-system reader.
+*
+* WHAT IT IS NOT. This is telemetry, never the record of truth. The spawn journal remains the sole
+* durable ledger for replay/resume and for cost; nothing here is read back, and a run whose export
+* fails is unaffected in every observable way. The two data models are deliberately separate.
+*
+* HOW IT ATTACHES. This is a pure `RuntimeHooks` observer over the lifecycle events `Scope` ALREADY
+* emits — `agent.spawn` (a node opened), `agent.child` (a node settled), `agent.turn` (a driver
+* inference turn was metered). It adds no event, mutates no journal, and changes no result. Because
+* `Scope` re-seeds the same hooks into every nested scope (`makeNestedScopeSeam`), one observer sees
+* the WHOLE recursion at arbitrary depth.
+*
+* SPAN SHAPE. One span per supervised node, opened at spawn and closed at settle, parented to its
+* parent node's span; the run root is the trace. Driver inference rides as an `LLM` child span under
+* the node that metered it. Attributes reuse the vocabulary the rest of the stack already reads
+* (`openinference.span.kind`, `agent.name`, `llm.token_count.*`, `llm.cost_usd`, `tangle.cost.usd`)
+* — see `@tangle-network/agent-eval`'s `src/trace/attribute-vocabulary.ts`, which is the consumer.
+*
+* UNKNOWN IS NEVER ZERO. `Spend.tokensKnown === false` / `usdKnown === false` mark work that
+* HAPPENED with an unreported count. Those spans OMIT the token/cost attribute entirely and set
+* `tangle.supervise.tokens_known` / `tangle.supervise.cost_known` to `false`, so a reader can never
+* mistake an unmeasured turn for a free one.
+*/
+/** OTEL status codes (`UNSET` / `OK` / `ERROR`) — the numeric wire values `OtelSpan.status` carries. */
+const STATUS_UNSET = 0;
+const STATUS_OK = 1;
+const STATUS_ERROR = 2;
+/** Longest string attribute value written from free-form detail, so an oversized turn payload
+*  cannot inflate a span. Identity/label attributes we control are never truncated. */
+const MAX_DETAIL_CHARS = 256;
+/**
+* Build the span recorder for one supervised run, or `undefined` when no exporter resolves — the
+* off-by-default path. A run that passes no `exporter` and no `exportConfig` never reaches this
+* function at all; one that passes an `exportConfig` with no endpoint (and no env endpoint) gets
+* `undefined` here, so "configured but unreachable" also costs nothing.
+*/
+function createSupervisorSpanRecorder(opts) {
+	const exporter = opts.exporter ?? createOtelExporter(opts.exportConfig);
+	if (!exporter) return void 0;
+	const ownsExporter = opts.exporter === void 0;
+	const now = opts.now ?? Date.now;
+	const traceId = normalizeTraceId(opts.traceId, opts.runId);
+	const rootSpanId = generateSpanId();
+	const rootStartMs = now();
+	const base = {
+		"tangle.run.id": opts.runId,
+		"tangle.sessionId": opts.runId,
+		...opts.attributes ?? {}
+	};
+	/** Node id → its open span. Seeded with the run id ⇒ the root span, because a depth-0 spawn's
+	*  `parentId` is the run id itself and every deeper spawn's is a real node id. */
+	const open = /* @__PURE__ */ new Map();
+	const spanIdOf = /* @__PURE__ */ new Map([[opts.runId, rootSpanId]]);
+	let finished = false;
+	/** Every export is best-effort: a throwing exporter must never reach the run. */
+	const emit = (span) => {
+		try {
+			exporter.exportSpan(span);
+		} catch {}
+	};
+	const span = (spanId, parentSpanId, name, startMs, endMs, attrs, status, message) => ({
+		traceId,
+		spanId,
+		...parentSpanId ? { parentSpanId } : {},
+		name,
+		kind: 1,
+		startTimeUnixNano: msToNano(startMs),
+		endTimeUnixNano: msToNano(Math.max(startMs, endMs)),
+		attributes: toOtelAttributes(attrs),
+		status: {
+			code: status,
+			...message ? { message } : {}
+		}
+	});
+	function onSpawn(event) {
+		const p = record(event.payload);
+		const childId = str$1(p.childId);
+		if (!childId) return;
+		const label = str$1(p.label) ?? "node";
+		const runtime = str$1(p.runtime);
+		const isWait = runtime === "wait";
+		const attrs = {
+			...base,
+			"openinference.span.kind": isWait ? "CHAIN" : "AGENT",
+			"agent.name": label,
+			"tangle.supervise.node.id": childId,
+			"tangle.supervise.node.label": label,
+			"tangle.supervise.node.kind": isWait ? "wait" : "agent",
+			"tangle.supervise.tree.root": event.runId
+		};
+		if (event.parentId) attrs["tangle.supervise.node.parent_id"] = event.parentId;
+		if (runtime) attrs["tangle.supervise.node.runtime"] = runtime;
+		if (typeof p.depth === "number") attrs["tangle.supervise.node.depth"] = p.depth;
+		if (typeof event.stepIndex === "number") attrs["tangle.supervise.node.ordinal"] = event.stepIndex;
+		if (p.resumed === true) attrs["tangle.supervise.node.resumed"] = true;
+		assignBudget(attrs, p.budget);
+		const spanId = generateSpanId();
+		spanIdOf.set(childId, spanId);
+		open.set(childId, {
+			spanId,
+			parentSpanId: event.parentId && spanIdOf.get(event.parentId) || rootSpanId,
+			name: label,
+			startMs: event.timestamp,
+			attrs
+		});
+	}
+	function onSettled(event) {
+		const p = record(event.payload);
+		const childId = str$1(p.childId);
+		if (!childId) return;
+		const node = open.get(childId);
+		if (!node) return;
+		open.delete(childId);
+		const status = str$1(p.status);
+		const down = status === "down";
+		const attrs = {
+			...node.attrs,
+			"tangle.supervise.node.status": status ?? "done"
+		};
+		if (typeof event.stepIndex === "number") attrs["tangle.supervise.node.seq"] = event.stepIndex;
+		if (typeof p.outRef === "string") attrs["tangle.supervise.node.out_ref"] = p.outRef;
+		if (typeof p.valid === "boolean") attrs["tangle.supervise.verdict.valid"] = p.valid;
+		if (typeof p.score === "number") attrs["tangle.supervise.verdict.score"] = p.score;
+		if (down) {
+			attrs["error.type"] = p.infra === true ? "infra" : "child-down";
+			const reason = str$1(p.reason);
+			if (reason) attrs["error.message"] = truncate(reason);
+			if (typeof p.infra === "boolean") attrs["tangle.supervise.node.infra"] = p.infra;
+		}
+		const wokeBy = str$1(record(p.wait).settled);
+		if (wokeBy) attrs["tangle.supervise.wait.settled"] = wokeBy;
+		assignSpend(attrs, p.spent);
+		emit(span(node.spanId, node.parentSpanId, node.name, node.startMs, event.timestamp, attrs, down ? STATUS_ERROR : STATUS_OK, down ? str$1(p.reason) ?? "child down" : void 0));
+	}
+	function onTurn(event) {
+		const p = record(event.payload);
+		const parentId = event.parentId;
+		const parentSpanId = parentId && spanIdOf.get(parentId) || rootSpanId;
+		const attrs = {
+			...base,
+			"openinference.span.kind": "LLM",
+			"inference.observation_kind": "LLM",
+			"tangle.supervise.node.kind": "inference"
+		};
+		if (parentId) attrs["tangle.supervise.node.id"] = parentId;
+		for (const [key, value] of Object.entries(p)) {
+			if (key === "spend") continue;
+			if (key === "driver" && typeof value === "string") {
+				attrs["agent.name"] = value;
+				attrs["inference.agent_name"] = value;
+				continue;
+			}
+			if (key === "model" && typeof value === "string") {
+				attrs["llm.model_name"] = value;
+				continue;
+			}
+			if (Array.isArray(value)) {
+				const scalars = value.filter((v) => typeof v === "string" || typeof v === "number");
+				if (scalars.length > 0) attrs[`tangle.supervise.turn.${key}`] = truncate(scalars.join(","));
+				continue;
+			}
+			if (typeof value === "string") attrs[`tangle.supervise.turn.${key}`] = truncate(value);
+			else if (typeof value === "number" || typeof value === "boolean") attrs[`tangle.supervise.turn.${key}`] = value;
+		}
+		const spend = assignSpend(attrs, p.spend);
+		const endMs = event.timestamp + (spend?.ms ?? 0);
+		emit(span(generateSpanId(), parentSpanId, "gen_ai.client.inference", event.timestamp, endMs, attrs, STATUS_OK));
+	}
+	return {
+		hooks: { onEvent(event) {
+			if (finished) return;
+			try {
+				if (event.phase !== "after") return;
+				if (event.target === "agent.spawn") onSpawn(event);
+				else if (event.target === "agent.child") onSettled(event);
+				else if (event.target === "agent.turn") onTurn(event);
+			} catch {}
+		} },
+		traceId,
+		rootSpanId,
+		async finish(outcome) {
+			if (finished) return;
+			finished = true;
+			const endMs = now();
+			try {
+				for (const [nodeId, node] of open) emit(span(node.spanId, node.parentSpanId, node.name, node.startMs, endMs, {
+					...node.attrs,
+					"tangle.supervise.node.status": "unsettled",
+					"tangle.supervise.node.settled": false,
+					"tangle.supervise.node.id": nodeId
+				}, STATUS_UNSET));
+				open.clear();
+				emit(span(rootSpanId, opts.parentSpanId, "supervisor.run", rootStartMs, endMs, rootAttrs(base, opts.agentName ?? "supervisor", outcome), rootStatus(outcome), rootMessage(outcome)));
+				await exporter.flush();
+				if (ownsExporter) await exporter.shutdown();
+			} catch {}
+		}
+	};
+}
+function rootAttrs(base, agentName, outcome) {
+	const attrs = {
+		...base,
+		"openinference.span.kind": "AGENT",
+		"inference.observation_kind": "AGENT",
+		"agent.name": agentName,
+		"inference.agent_name": agentName,
+		"tangle.supervise.node.kind": "root"
+	};
+	const result = outcome?.result;
+	if (result) {
+		attrs["tangle.supervise.result"] = result.kind;
+		if (result.kind === "no-winner") {
+			attrs["tangle.supervise.reason"] = result.reason;
+			attrs["tangle.supervise.down_count"] = result.downCount;
+			if (result.reason === "driver-failed") {
+				attrs["error.type"] = result.error.name;
+				attrs["error.message"] = truncate(result.error.message);
+			}
+		}
+		assignSpend(attrs, result.spentTotal);
+	}
+	if (outcome?.error !== void 0) {
+		attrs["tangle.supervise.result"] = "error";
+		const err = outcome.error;
+		attrs["error.type"] = err instanceof Error ? err.name : typeof err;
+		attrs["error.message"] = truncate(err instanceof Error ? err.message : String(err));
+	}
+	return attrs;
+}
+function rootStatus(outcome) {
+	if (outcome?.error !== void 0) return STATUS_ERROR;
+	if (!outcome?.result) return STATUS_UNSET;
+	return outcome.result.kind === "winner" ? STATUS_OK : STATUS_ERROR;
+}
+function rootMessage(outcome) {
+	if (outcome?.error !== void 0) return truncate(outcome.error instanceof Error ? outcome.error.message : String(outcome.error));
+	const result = outcome?.result;
+	return result && result.kind === "no-winner" ? result.reason : void 0;
+}
+/**
+* Write a `Spend` onto a span, honouring the "a missing measurement is never zero" invariant: a
+* channel marked NOT known contributes no number at all and instead flags itself, so nothing
+* downstream can sum an unmeasured turn as free. Returns the spend it read (for the duration).
+*/
+function assignSpend(attrs, value) {
+	if (!isRecord(value)) return void 0;
+	const spend = value;
+	const tokens = isRecord(spend.tokens) ? spend.tokens : void 0;
+	if (spend.tokensKnown === false) attrs["tangle.supervise.tokens_known"] = false;
+	else if (tokens) {
+		if (typeof tokens.input === "number") attrs["llm.token_count.prompt"] = tokens.input;
+		if (typeof tokens.output === "number") attrs["llm.token_count.completion"] = tokens.output;
+	}
+	if (spend.usdKnown === false) attrs["tangle.supervise.cost_known"] = false;
+	else if (typeof spend.usd === "number" && Number.isFinite(spend.usd)) {
+		attrs["llm.cost_usd"] = spend.usd;
+		attrs["tangle.cost.usd"] = spend.usd;
+	}
+	if (typeof spend.iterations === "number") attrs["tangle.supervise.iterations"] = spend.iterations;
+	if (typeof spend.ms === "number" && spend.ms > 0) attrs["tangle.supervise.duration_ms"] = spend.ms;
+	return spend;
+}
+function assignBudget(attrs, value) {
+	if (!isRecord(value)) return;
+	const budget = value;
+	if (typeof budget.maxTokens === "number") attrs["tangle.supervise.budget.max_tokens"] = budget.maxTokens;
+	if (typeof budget.maxIterations === "number") attrs["tangle.supervise.budget.max_iterations"] = budget.maxIterations;
+	if (typeof budget.maxUsd === "number") attrs["tangle.supervise.budget.max_usd"] = budget.maxUsd;
+}
+/**
+* A trace id must be 32 hex characters. A caller-supplied one is used verbatim when it already is;
+* anything else (and the default) is DERIVED from the run id by content address — deterministic, so
+* a resumed run rejoins the trace its first process opened rather than forking a new one.
+*/
+function normalizeTraceId(traceId, runId) {
+	if (traceId && /^[0-9a-f]{32}$/i.test(traceId)) return traceId.toLowerCase();
+	return contentAddress(traceId ?? runId).slice(7, 39);
+}
+function msToNano(ms) {
+	return (BigInt(Number.isFinite(ms) ? Math.floor(ms) : 0) * 1000000n).toString();
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function record(value) {
+	return isRecord(value) ? value : {};
+}
+function str$1(value) {
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function truncate(value) {
+	return value.length > MAX_DETAIL_CHARS ? `${value.slice(0, MAX_DETAIL_CHARS)}…` : value;
+}
+//#endregion
 //#region src/runtime/supervise/coordination-log.ts
 /** Should this bus event be persisted? Questions and findings ARE the prior context a resumed
 *  driver needs; answers fold their status; everything else has a better ledger or none. */
@@ -1405,6 +1707,13 @@ function publicConfigString(value, where) {
 /**
 * Build the canonical `{ mcpServers }` body the adapter reads, from `AgentProfile.mcp`.
 *
+* Every server is written with `directTools: true` (`pi-mcp-adapter` types.ts:351), which
+* registers its tools as NATIVE pi tools instead of hiding them behind the generic `mcp` tool.
+* Without it an agent must discover its own verbs before it can use them — connect to the server,
+* then describe each tool — and a measured run spent 58 turns and 639,632 input tokens doing that
+* before it could delegate once. A profile that declares an MCP server is asking for its tools,
+* not for a directory it has to browse.
+*
 * This is cli-bridge's `buildCanonicalMcpServers`
 * (`/home/drew/code/cli-bridge/src/backends/profile-support.ts:253`) reproduced field for field and
 * in the same key order — same drop of `enabled:false`, same stdio-versus-remote decision
@@ -1450,7 +1759,8 @@ function buildPiMcpServers(mcp) {
 				command,
 				...args.length > 0 ? { args } : {},
 				...Object.keys(env).length > 0 ? { env } : {},
-				...typeof raw.cwd === "string" && raw.cwd.length > 0 ? { cwd: raw.cwd } : {}
+				...typeof raw.cwd === "string" && raw.cwd.length > 0 ? { cwd: raw.cwd } : {},
+				directTools: true
 			};
 			continue;
 		}
@@ -1459,7 +1769,8 @@ function buildPiMcpServers(mcp) {
 			out[name] = {
 				type: transport === "sse" ? "sse" : "http",
 				url,
-				...Object.keys(headers).length > 0 ? { headers } : {}
+				...Object.keys(headers).length > 0 ? { headers } : {},
+				directTools: true
 			};
 		}
 	}
@@ -8357,7 +8668,13 @@ function supervise(profile, task, opts) {
 			...opts.maxTurns !== void 0 ? { maxTurns: opts.maxTurns } : {},
 			...opts.compaction ? { compaction: opts.compaction } : {}
 		});
-		return createSupervisor().run(agent, task, {
+		const spans = opts.otel ? createSupervisorSpanRecorder({
+			runId,
+			...opts.otel,
+			now
+		}) : void 0;
+		const hooks = spans ? composeRuntimeHooks(opts.hooks, spans.hooks) : opts.hooks;
+		const run = createSupervisor().run(agent, task, {
 			budget: opts.budget,
 			runId,
 			journal: opts.journal ?? ctx.journal,
@@ -8366,12 +8683,22 @@ function supervise(profile, task, opts) {
 			maxDepth: opts.maxDepth ?? 8,
 			...probes ? { probes } : {},
 			...ctx.resume === true ? { resume: true } : {},
-			...opts.now ? { now: opts.now } : {}
+			...opts.now ? { now: opts.now } : {},
+			...hooks ? { hooks } : {}
 		});
+		if (!spans) return run;
+		try {
+			const result = await run;
+			await spans.finish({ result });
+			return result;
+		} catch (error) {
+			await spans.finish({ error });
+			throw error;
+		}
 	};
 	return start();
 }
 //#endregion
-export { InMemoryDelegationStore as $, FileCoordinationLog as $t, DELEGATE_INPUT_SCHEMA as A, createWorktreeCliExecutor as At, profileRichnessFinding as B, PI_MCP_ADAPTER_ENV as Bt, validateDelegateUiAuditArgs as C, defaultToolDetectors as Ct, createDelegateFeedbackHandler as D, cliWorktreeExecutor as Dt, DELEGATE_FEEDBACK_TOOL_NAME as E, createInMemoryRunContext as Et, delegate as F, piSeamKey as Ft, DELEGATION_TRACE_MAX_SPANS as G, createInbox as Gt, DelegationTaskQueue as H, buildPiMcpServers as Ht, asAuthoredProfile as I, createPushTraceSource as It, composeLoopTraceEmitters as J, runAgentRounds as Jt, buildDelegationTraceSpans as K, createSandboxForSpec as Kt, assessAuthoredProfile as L, decodeToolPart as Lt, createDelegateHandler as M, createSteerableSandboxSession as Mt, validateDelegateArgs as N, PI_RUNTIME as Nt, validateDelegateFeedbackArgs as O, createExecutor as Ot, defaultDelegateBudget as P, piExecutor as Pt, FileDelegationStore as Q, acquireSandbox as Qt, authoredWorker as R, sandboxSessionTraceSource as Rt, createDelegateUiAuditHandler as S, rollingDispatch as St, DELEGATE_FEEDBACK_INPUT_SCHEMA as T, createFileRunContext as Tt, hashIdempotencyInput as U, piMcpAdapterAvailable as Ut, supervisorInstructions as V, PI_MCP_CONFIG_FLAG as Vt, DELEGATION_TRACE_MAX_BYTES as W, preparePiMcp as Wt, DelegationPersistenceError as X, createSandboxLineage as Xt, createDelegationTraceCollector as Y, runLoop as Yt, DelegationStateCorruptError as Z, probeSandboxCapabilities as Zt, createDelegationHistoryHandler as _, createCoordinationTools as _t, supervisorAgent as a, allWorkersStalled as at, DELEGATE_UI_AUDIT_INPUT_SCHEMA as b, freeSlots as bt, createMcpServer as c, noProgressFor as ct, DELEGATION_STATUS_TOOL_NAME as d, anytimeReport as dt, assertModelAllowed as en, InMemoryFeedbackStore as et, createDelegationStatusHandler as f, areaUnderCurve as ft, DELEGATION_HISTORY_TOOL_NAME as g, DEFAULT_AWAIT_EVENT_TIMEOUT_MS as gt, DELEGATION_HISTORY_INPUT_SCHEMA as h, renderAnytimeTable as ht, resolveSupervisorProfile as i, allOf as it, DELEGATE_TOOL_NAME as j, DEFAULT_SANDBOX_STEERING_MAX_TURNS as jt, DELEGATE_DESCRIPTION as k, createExecutorRegistry as kt, DELEGATION_STATUS_DESCRIPTION as l, plateau as lt, DELEGATION_HISTORY_DESCRIPTION as m, plateauLength as mt, workerFromBackend as n, driverAgent as nt, serveCoordinationMcp as o, anyOf as ot, validateDelegationStatusArgs as p, bestSoFar as pt, capDelegationTrace as q, defaultSelectWinner as qt, assertCoordinationBinding as r, finalizeBestDelivered as rt, createInProcessTransport as s, createProgressTracker as st, supervise as t, gateOnDeliverable as tn, eventToSnapshot as tt, DELEGATION_STATUS_INPUT_SCHEMA as u, sampleFromSettled as ut, validateDelegationHistoryArgs as v, createEventBus as vt, DELEGATE_FEEDBACK_DESCRIPTION as w, watchTrace as wt, DELEGATE_UI_AUDIT_TOOL_NAME as x, queueOf as xt, DELEGATE_UI_AUDIT_DESCRIPTION as y, effectiveConcurrency as yt, defaultProfileRichnessThresholds as z, PI_MCP_ADAPTER as zt };
+export { InMemoryDelegationStore as $, FileCoordinationLog as $t, DELEGATE_INPUT_SCHEMA as A, createWorktreeCliExecutor as At, profileRichnessFinding as B, PI_MCP_ADAPTER_ENV as Bt, validateDelegateUiAuditArgs as C, defaultToolDetectors as Ct, createDelegateFeedbackHandler as D, cliWorktreeExecutor as Dt, DELEGATE_FEEDBACK_TOOL_NAME as E, createInMemoryRunContext as Et, delegate as F, piSeamKey as Ft, DELEGATION_TRACE_MAX_SPANS as G, createInbox as Gt, DelegationTaskQueue as H, buildPiMcpServers as Ht, asAuthoredProfile as I, createPushTraceSource as It, composeLoopTraceEmitters as J, runAgentRounds as Jt, buildDelegationTraceSpans as K, createSandboxForSpec as Kt, assessAuthoredProfile as L, decodeToolPart as Lt, createDelegateHandler as M, createSteerableSandboxSession as Mt, validateDelegateArgs as N, PI_RUNTIME as Nt, validateDelegateFeedbackArgs as O, createExecutor as Ot, defaultDelegateBudget as P, piExecutor as Pt, FileDelegationStore as Q, acquireSandbox as Qt, authoredWorker as R, sandboxSessionTraceSource as Rt, createDelegateUiAuditHandler as S, rollingDispatch as St, DELEGATE_FEEDBACK_INPUT_SCHEMA as T, createFileRunContext as Tt, hashIdempotencyInput as U, piMcpAdapterAvailable as Ut, supervisorInstructions as V, PI_MCP_CONFIG_FLAG as Vt, DELEGATION_TRACE_MAX_BYTES as W, preparePiMcp as Wt, DelegationPersistenceError as X, createSandboxLineage as Xt, createDelegationTraceCollector as Y, runLoop as Yt, DelegationStateCorruptError as Z, probeSandboxCapabilities as Zt, createDelegationHistoryHandler as _, createCoordinationTools as _t, supervisorAgent as a, allWorkersStalled as at, DELEGATE_UI_AUDIT_INPUT_SCHEMA as b, freeSlots as bt, createMcpServer as c, noProgressFor as ct, DELEGATION_STATUS_TOOL_NAME as d, anytimeReport as dt, createSupervisorSpanRecorder as en, InMemoryFeedbackStore as et, createDelegationStatusHandler as f, areaUnderCurve as ft, DELEGATION_HISTORY_TOOL_NAME as g, DEFAULT_AWAIT_EVENT_TIMEOUT_MS as gt, DELEGATION_HISTORY_INPUT_SCHEMA as h, renderAnytimeTable as ht, resolveSupervisorProfile as i, allOf as it, DELEGATE_TOOL_NAME as j, DEFAULT_SANDBOX_STEERING_MAX_TURNS as jt, DELEGATE_DESCRIPTION as k, createExecutorRegistry as kt, DELEGATION_STATUS_DESCRIPTION as l, plateau as lt, DELEGATION_HISTORY_DESCRIPTION as m, plateauLength as mt, workerFromBackend as n, gateOnDeliverable as nn, driverAgent as nt, serveCoordinationMcp as o, anyOf as ot, validateDelegationStatusArgs as p, bestSoFar as pt, capDelegationTrace as q, defaultSelectWinner as qt, assertCoordinationBinding as r, finalizeBestDelivered as rt, createInProcessTransport as s, createProgressTracker as st, supervise as t, assertModelAllowed as tn, eventToSnapshot as tt, DELEGATION_STATUS_INPUT_SCHEMA as u, sampleFromSettled as ut, validateDelegationHistoryArgs as v, createEventBus as vt, DELEGATE_FEEDBACK_DESCRIPTION as w, watchTrace as wt, DELEGATE_UI_AUDIT_TOOL_NAME as x, queueOf as xt, DELEGATE_UI_AUDIT_DESCRIPTION as y, effectiveConcurrency as yt, defaultProfileRichnessThresholds as z, PI_MCP_ADAPTER as zt };
 
-//# sourceMappingURL=supervise-tdxMJYem.js.map
+//# sourceMappingURL=supervise-B7TIJR3D.js.map