@tangle-network/agent-runtime 0.116.0 → 0.119.0

package/dist/{runtime-Ut1pkd2n.js → runtime-D4e3GP5K.js}

@@ -1,17 +1,16 @@
 import { n as AnalystError, r as BackendTransportError, s as PlannerError, u as ValidationError } from "./errors-DEAvWQPy.js";
 import { i as normalizeBackendStreamEvent, o as newRuntimeSession, s as nowIso } from "./backends-CiOCyRHb.js";
-import { c as sleep, i as isAbortError, l as stringifySafe, n as addTokenUsage, o as randomSuffix, p as zeroTokenUsage } from "./util-Cc9g9Y-o.js";
-import { i as InMemorySpawnJournal, r as InMemoryResultBlobStore } from "./spawn-journal-DCPbicXB.js";
+import { i as InMemorySpawnJournal, r as InMemoryResultBlobStore, v as isTraceAnalysisStore } from "./spawn-journal-IeXpidO2.js";
+import { a as randomSuffix, c as stringifySafe, f as zeroTokenUsage, r as isAbortError, s as sleep, t as addTokenUsage } from "./util-MVgdwuIS.js";
 import { i as redactProtectedValue, r as redactProtectedReason } from "./protected-redaction--F3v1oo8.js";
-import { H as routerBrain, W as routerChatWithUsage, d as settledToIteration, l as withDriverExecutor, q as runBrainLoop, t as createSupervisor } from "./supervisor-BBbPBXpe.js";
-import { C as observe, O as strategyAuthorMethod, b as sample, v as refine, x as sampleThenRefine, y as runAgentic } from "./structural-rollout-CVY_0hJp.js";
+import { X as rollingDispatch, dt as routerBrain, gt as runBrainLoop, l as withDriverExecutor, m as settledToIteration, n as createSupervisor, pt as routerChatWithUsage } from "./supervisor-CpT9yAxL.js";
+import { C as observe, O as strategyAuthorMethod, b as sample, v as refine, x as sampleThenRefine, y as runAgentic } from "./structural-rollout-DQHO3b2Y.js";
 import { i as notifyRuntimeHookEvent } from "./runtime-hooks-C7iJOWm3.js";
-import { a as notifySandboxEventObserver, i as mapSandboxToolEvent, r as mapSandboxEvent, t as createSandboxToolPartState } from "./sandbox-events-DeI5xX8P.js";
-import { At as createWorktreeCliExecutor, Jt as runAgentRounds, Ot as createExecutor, St as rollingDispatch, Xt as createSandboxLineage, Zt as probeSandboxCapabilities, kt as createExecutorRegistry, nn as gateOnDeliverable, qt as defaultSelectWinner, t as supervise } from "./supervise-BUR9ByF7.js";
-import { CODING_HARNESSES, InMemoryTraceStore, benjaminiHochberg, buildTrajectory, computeFindingId as computeFindingId$1, confidenceInterval, expandProfileAxes, harnessAxisOf, makeFinding as makeFinding$1, pairedBootstrap, paretoFrontier, scoreKnowledgeReadiness, wilcoxonSignedRank, wilson } from "@tangle-network/agent-eval";
+import { a as notifySandboxEventObserver, i as mapSandboxToolEvent, r as mapSandboxEvent, t as createSandboxToolPartState } from "./sandbox-events-Yhd1GYWl.js";
+import { At as runAgentRounds, Kt as gateOnDeliverable, Mt as createSandboxLineage, Nt as probeSandboxCapabilities, bt as createExecutorRegistry, kt as defaultSelectWinner, n as supervise, wt as createPushTraceSource, xt as createWorktreeCliExecutor, yt as createExecutor } from "./supervise-Cq50UT5-.js";
+import { CODING_HARNESSES, InMemoryTraceStore, OUTPUT_VALUE, benjaminiHochberg, buildTrajectory, computeFindingId as computeFindingId$1, confidenceInterval, expandProfileAxes, harnessAxisOf, makeFinding as makeFinding$1, pairedBootstrap, paretoFrontier, scoreKnowledgeReadiness, wilcoxonSignedRank, wilson } from "@tangle-network/agent-eval";
 import { heldoutSignificance, runProfileMatrix } from "@tangle-network/agent-eval/campaign";
 import { canonicalCandidateDigest, validateAgentProfileSecurity } from "@tangle-network/agent-interface";
-import { randomUUID } from "node:crypto";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { appendFileSync, chmodSync, constants, copyFileSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readlinkSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
@@ -2905,7 +2904,7 @@ async function trajectoryReport(journal, blobs, root, options = {}) {
 	const events = await journal.loadTree(root);
 	if (events === void 0) throw new Error(`trajectoryReport: no journaled tree for root '${root}'`);
 	const spawns = events.filter(isNodeCreation).sort(bySeq);
-	const closes = events.filter((ev) => ev.kind !== "spawned" && ev.kind !== "waiting" && ev.kind !== "metered").sort(bySeq);
+	const closes = events.filter((ev) => ev.kind !== "spawned" && ev.kind !== "waiting" && ev.kind !== "metered" && ev.kind !== "materialized" && ev.kind !== "execution-bound").sort(bySeq);
 	const nodes = /* @__PURE__ */ new Map();
 	for (const ev of spawns) nodes.set(ev.id, {
 		id: ev.id,
@@ -3068,6 +3067,7 @@ function addNodeSpend(a, b) {
 			input: a.tokens.input + b.tokens.input,
 			output: a.tokens.output + b.tokens.output
 		},
+		...a.tokensKnown === false || b.tokensKnown === false ? { tokensKnown: false } : {},
 		usd: a.usd + b.usd,
 		...a.tokensKnown === false || b.tokensKnown === false ? { tokensKnown: false } : {},
 		...a.usdKnown === false || b.usdKnown === false ? { usdKnown: false } : {},
@@ -3081,6 +3081,7 @@ function cloneSpend(spend) {
 			input: spend.tokens.input,
 			output: spend.tokens.output
 		},
+		...spend.tokensKnown === false ? { tokensKnown: false } : {},
 		usd: spend.usd,
 		...spend.tokensKnown === false ? { tokensKnown: false } : {},
 		...spend.usdKnown === false ? { usdKnown: false } : {},
@@ -3091,6 +3092,7 @@ function cloneSpend(spend) {
 function addSpend(acc, delta) {
 	acc.iterations += delta.iterations;
 	addTokenUsage(acc.tokens, delta.tokens);
+	if (delta.tokensKnown === false) acc.tokensKnown = false;
 	acc.usd += delta.usd;
 	if (delta.tokensKnown === false) acc.tokensKnown = false;
 	if (delta.usdKnown === false) acc.usdKnown = false;
@@ -4775,140 +4777,6 @@ function signalPass(value, required) {
 	return !required;
 }
 //#endregion
-//#region src/runtime/supervise/run-layout.ts
-/**
-* The on-disk supervisor-run layout: `<root>/.agent/supervisor/<id>`.
-*
-* This is the durable, cross-process face of a supervisor run — the counterpart to the in-process
-* `Inbox` seam in `./inbox`. A run persists its state under one directory so that any OTHER process
-* can find it after the fact: `@tangle-network/traces` reads exactly this layout via
-* `traces analyze --supervisor-run-dir`, a restarted host can rehydrate a run it no longer holds
-* handles to, and a human can steer a live worker by appending one NDJSON line. Until now the
-* layout was defined only in the unpublished `loops` repo (`src/supervisor-control.ts`) — a
-* published reader depending on an unpublished writer's convention — so the contract is promoted
-* here, names preserved.
-*
-* `.agent` is the one dot-dir for ALL agent-owned state (skills already write
-* `.agent/hypotheses/`, `.agent/skill-runs.jsonl`); supervisor runs live beside them rather than
-* under a product-branded dir. Runs written by older writers used `.loops/supervisor/<id>` —
-* readers that must see those keep a legacy fallback; this writer never creates `.loops` again.
-*
-* Layout, relative to `supervisorRunDir(root, id)`:
-*
-*   workers/<label>.inbox.ndjson   down-leg steer/answer requests for one worker (durable inbox);
-*                                  each line is a {@link WorkerSteerRequest}
-*   workers/<label>.ndjson         best-effort per-worker control-event log (delivery bookkeeping)
-*
-* Reads are tolerant by contract: a partial trailing line (a writer mid-append) or a corrupt line
-* never poisons the rest of the file — later valid lines still matter.
-*
-* Promoted from `loops/src/supervisor-control.ts`. The one deliberate difference: the loops version
-* resolved a worker id to its label through the run journal before writing a steer; that resolution
-* stays with the caller (it is journal-format-specific), so `writeWorkerSteer` here takes the worker
-* LABEL directly.
-*
-* @experimental
-*/
-/** The root every supervisor run of one workspace lives under. */
-function supervisorRunsRoot(rootDir) {
-	return join(resolve(rootDir), ".agent", "supervisor");
-}
-/** The run directory every artifact of one supervisor run lives under. */
-function supervisorRunDir(rootDir, id) {
-	return join(supervisorRunsRoot(rootDir), id);
-}
-/**
-* Where a pre-rename writer put the same run (`<root>/.loops/supervisor/<id>`). Readers that must
-* see historical runs check {@link supervisorRunDir} first and fall back to this; nothing writes
-* here anymore.
-*/
-function legacySupervisorRunDir(rootDir, id) {
-	return join(resolve(rootDir), ".loops", "supervisor", id);
-}
-/** A worker label reduced to a safe filename stem. Empty labels get a stable fallback. */
-function safeWorkerFile(label) {
-	const safe = label.replace(/[^A-Za-z0-9._-]/g, "_");
-	return safe.length > 0 ? safe : "worker";
-}
-/** The durable inbox file for one worker of one run. */
-function workerInboxFile(rootDir, supervisorId, worker) {
-	return workerInboxFileFromEventDir(supervisorRunDir(rootDir, supervisorId), worker);
-}
-/** Same, addressed from an already-known run directory (the reader's usual entry point). */
-function workerInboxFileFromEventDir(eventDir, worker) {
-	return join(eventDir, "workers", `${safeWorkerFile(worker)}.inbox.ndjson`);
-}
-/**
-* Durably append one steer request to a worker's inbox and log the delivery attempt.
-*
-* The inbox append is the durable act; the control-event log is best-effort bookkeeping and may
-* silently fail without voiding the steer.
-*/
-function writeWorkerSteer(rootDir, supervisorId, worker, message, source = "human") {
-	const trimmed = message.trim();
-	if (!trimmed) throw new Error("steer message is empty");
-	const dir = supervisorRunDir(rootDir, supervisorId);
-	mkdirSync(join(dir, "workers"), { recursive: true });
-	const request = {
-		id: randomUUID(),
-		at: (/* @__PURE__ */ new Date()).toISOString(),
-		source,
-		worker,
-		message: trimmed
-	};
-	const file = workerInboxFile(rootDir, supervisorId, worker);
-	appendFileSync(file, `${JSON.stringify(request)}\n`, "utf8");
-	appendWorkerControlEvent(dir, worker, {
-		kind: "message",
-		direction: "down",
-		source,
-		requestId: request.id,
-		message: trimmed,
-		queued: true,
-		delivered: false
-	});
-	return {
-		worker,
-		file,
-		request
-	};
-}
-/** Read every valid steer request in a worker's inbox. Corrupt or partial lines are skipped. */
-function readWorkerSteerRequests(eventDir, worker) {
-	const file = workerInboxFileFromEventDir(eventDir, worker);
-	if (!existsSync(file)) return [];
-	const out = [];
-	let raw = "";
-	try {
-		raw = readFileSync(file, "utf8");
-	} catch {
-		return out;
-	}
-	for (const line of raw.split("\n")) {
-		const trimmed = line.trim();
-		if (!trimmed) continue;
-		try {
-			const parsed = JSON.parse(trimmed);
-			if (isWorkerSteerRequest(parsed)) out.push(parsed);
-		} catch {}
-	}
-	return out;
-}
-function appendWorkerControlEvent(eventDir, label, event) {
-	try {
-		const workersDir = join(eventDir, "workers");
-		mkdirSync(workersDir, { recursive: true });
-		appendFileSync(join(workersDir, `${safeWorkerFile(label)}.ndjson`), `${JSON.stringify({
-			at: (/* @__PURE__ */ new Date()).toISOString(),
-			label,
-			...event
-		})}\n`, "utf8");
-	} catch {}
-}
-function isWorkerSteerRequest(value) {
-	return typeof value.id === "string" && typeof value.at === "string" && typeof value.source === "string" && typeof value.worker === "string" && typeof value.message === "string" && value.message.trim().length > 0;
-}
-//#endregion
 //#region src/runtime/supervise/trajectory-recorder.ts
 /**
 *
@@ -5213,24 +5081,31 @@ function worktreeFanout(options) {
 		...options.require !== void 0 ? { require: options.require } : {}
 	});
 	const itemSpec = (item) => {
-		const executor = gateOnDeliverable(createWorktreeCliExecutor({
-			repoRoot: options.repoRoot,
-			profile: item.profile,
-			harness: item.harness,
-			taskPrompt: options.taskPrompt,
-			...item.runId ? { runId: item.runId } : {},
-			...item.baseRef ? { baseRef: item.baseRef } : {},
-			...options.testCmd !== void 0 ? { testCmd: options.testCmd } : {},
-			...options.typecheckCmd !== void 0 ? { typecheckCmd: options.typecheckCmd } : {},
-			...options.harnessTimeoutMs !== void 0 ? { harnessTimeoutMs: options.harnessTimeoutMs } : {},
-			...options.runGit ? { runGit: options.runGit } : {},
-			...options.runHarness ? { runHarness: options.runHarness } : {},
-			...options.runCommand ? { runCommand: options.runCommand } : {}
-		}), deliverable);
+		const executorFactory = (_spec, ctx) => {
+			if (!ctx.node) throw new Error("worktreeFanout: supervised node context required");
+			return gateOnDeliverable(createWorktreeCliExecutor({
+				repoRoot: options.repoRoot,
+				profile: item.profile,
+				harness: item.harness,
+				taskPrompt: options.taskPrompt,
+				executionAttemptId: ctx.node.attemptId,
+				...item.budgetExempt !== void 0 ? { budgetExempt: item.budgetExempt } : {},
+				...item.codexReproducible !== void 0 ? { codexReproducible: item.codexReproducible } : {},
+				...item.codexReadDeniedPaths !== void 0 ? { codexReadDeniedPaths: item.codexReadDeniedPaths } : {},
+				...item.runId ? { runId: item.runId } : {},
+				...item.baseRef ? { baseRef: item.baseRef } : {},
+				...options.testCmd !== void 0 ? { testCmd: options.testCmd } : {},
+				...options.typecheckCmd !== void 0 ? { typecheckCmd: options.typecheckCmd } : {},
+				...options.harnessTimeoutMs !== void 0 ? { harnessTimeoutMs: options.harnessTimeoutMs } : {},
+				...options.runGit ? { runGit: options.runGit } : {},
+				...options.runHarness ? { runHarness: options.runHarness } : {},
+				...options.runCommand ? { runCommand: options.runCommand } : {}
+			}), deliverable);
+		};
 		return {
 			profile: item.profile,
 			harness: null,
-			executor
+			executorFactory
 		};
 	};
 	const selectWinner = selectValidWinner({
@@ -5246,29 +5121,63 @@ function worktreeFanout(options) {
 }
 //#endregion
 //#region src/runtime/supervise-surface.ts
-/** Remember the worker's LAST `run_tests` output so the analyst can name the still-failing tests — a
-*  transparent passthrough for every other surface call. Local to this module (no surface-zoo concept). */
-function captureFailures(base) {
+/**
+* superviseSurface — drive a team of agents to solve a graded `AgenticSurface` task. ONE capability that
+* replaces the worker-seam + "self-improving supervisor" wrapper pair: the driver (`profile`) spawns
+* workers that each run `runAgentic` over the surface (`refine` by default), settle on the surface's OWN
+* check (settled ⟺ resolved — a worker that ran but didn't pass settles invalid, so a keep-best driver
+* never counts it done), and feed the driver a self-improvement lens (the still-FAILING tests, by default)
+* so the next spawn targets the persistently-hard cases. Returns the deployable outcome + the full
+* conserved spend.
+*
+* WHY this lives here and not as a `supervise()` backend: `runAgentic` depends on the supervise core
+* (`strategy.ts` → `supervise/`), so a surface-solving worker cannot be a supervise built-in without an
+* import cycle. It is therefore a COMPOSITION of `supervise()` + `runAgentic` at the layer above both —
+* the right home for "supervise over a graded surface". The within-run self-improvement is the analyst
+* (authored content, swap `analysts`); the across-run kind wraps this call in `improve()`.
+*/
+/** Instrument every real surface call with the shared push trace source. The last test report remains
+*  available on `SurfaceWorkerOut` for compatibility, but analysts read only the persisted spans. */
+function traceSurfaceCalls(base) {
 	let lastReport = "";
-	const surface = {
-		name: base.name,
-		open: (t) => base.open(t),
-		tools: (t, h) => base.tools(t, h),
-		async call(h, name, args) {
-			const out = await base.call(h, name, args);
-			if (name === "run_tests") lastReport = out;
-			return out;
-		},
-		score: (t, h) => base.score(t, h),
-		close: (h) => base.close(h)
-	};
-	const failing = () => {
-		const body = /FAILING:\s*(.+)/i.exec(lastReport)?.[1];
-		return body ? body.split(",").map((s) => s.trim()).filter(Boolean) : [];
-	};
+	const trace = createPushTraceSource();
 	return {
-		surface,
-		failing
+		surface: {
+			name: base.name,
+			open: (t) => base.open(t),
+			tools: (t, h) => base.tools(t, h),
+			async call(h, name, args) {
+				const startedAt = Date.now();
+				const recordedArgs = structuredClone(args);
+				try {
+					const out = await base.call(h, name, args);
+					trace.record({
+						toolName: name,
+						args: recordedArgs,
+						result: out,
+						status: out.startsWith("ERROR:") ? "error" : "ok",
+						startedAt,
+						endedAt: Date.now()
+					});
+					if (name === "run_tests") lastReport = out;
+					return out;
+				} catch (error) {
+					trace.record({
+						toolName: name,
+						args: recordedArgs,
+						result: `ERROR: ${error instanceof Error ? error.message : String(error)}`,
+						status: "error",
+						startedAt,
+						endedAt: Date.now()
+					});
+					throw error;
+				}
+			},
+			score: (t, h) => base.score(t, h),
+			close: (h) => base.close(h)
+		},
+		failing: () => failingTestNames(lastReport),
+		traceSource: trace.source
 	};
 }
 /** The default self-improvement LENS — authored content, not a code path. On each settled worker it hands
@@ -5282,20 +5191,68 @@ function failuresAnalyst() {
 			area: "progress"
 		}],
 		run: async (_kindId, trace) => {
-			const w = trace ?? {};
-			if (!(typeof w === "object" && w !== null && "resolved" in w)) return { summary: `worker produced: ${JSON.stringify(trace).slice(0, 300)}` };
-			if (w.resolved) return { summary: "worker RESOLVED — every check passed; stop." };
-			const failing = w.failing ?? [];
-			const head = `worker did NOT resolve — score ${(100 * (w.score ?? 0)).toFixed(0)}%, ${w.shots ?? "?"} shot(s)`;
-			return { summary: failing.length ? `${head}. STILL FAILING (${failing.length}): ${failing.slice(0, 12).join(", ")}. Spawn the next worker to fix exactly these; if a test keeps failing across workers, give it concrete guidance about that case.` : `${head}. (no failing-test list available this round)` };
+			if (!isTraceAnalysisStore(trace)) return missingRunTestsEvidence();
+			const report = await latestRunTestsReport(trace);
+			if (report === void 0) return missingRunTestsEvidence();
+			const failing = failingTestNames(report);
+			return { summary: failing.length ? `Latest structured run_tests evidence reports STILL FAILING (${failing.length}): ${failing.join(", ")}. Spawn the next worker to fix exactly these; if a test keeps failing across workers, give it concrete guidance about that case.` : allTestsPassed(report) ? "Latest structured run_tests evidence reports every test passed; stop." : `Latest structured run_tests evidence contains no parseable failing-test names. Refusing to infer them from worker prose. run_tests output: ${report.slice(0, 300)}` };
 		}
 	};
 }
+async function latestRunTestsReport(store) {
+	const overview = await store.getOverview({ tool_names: ["run_tests"] });
+	const candidates = [];
+	let ordinal = 0;
+	for (const traceId of overview.sample_trace_ids) {
+		let spans = (await store.viewTrace({
+			trace_id: traceId,
+			per_attribute_byte_cap: 16384
+		})).spans;
+		if (spans === void 0) {
+			const matches = await store.searchTrace({
+				trace_id: traceId,
+				regex_pattern: "run_tests",
+				max_matches: 100
+			});
+			const spanIds = [...new Set(matches.hits.filter((hit) => hit.span_name === "run_tests").map((hit) => hit.span_id))];
+			spans = spanIds.length ? (await store.viewSpans({
+				trace_id: traceId,
+				span_ids: spanIds,
+				per_attribute_byte_cap: 16384
+			})).spans : [];
+		}
+		for (const span of spans) {
+			if (span.tool_name !== "run_tests") continue;
+			const output = span.attributes[OUTPUT_VALUE];
+			if (typeof output !== "string") continue;
+			candidates.push({
+				output,
+				endedAt: span.end_time,
+				ordinal: ordinal++
+			});
+		}
+	}
+	candidates.sort((left, right) => Date.parse(left.endedAt) - Date.parse(right.endedAt) || left.ordinal - right.ordinal);
+	return candidates.at(-1)?.output;
+}
+function failingTestNames(report) {
+	const body = /FAILING:\s*([^\n]+)/iu.exec(report)?.[1];
+	if (body === void 0) return [];
+	return body.replace(/\.\s+COLLECTION-BLOCKED:.*$/iu, "").replace(/\s*\(\+\d+\s+more\)\s*$/iu, "").split(",").map((name) => name.trim()).filter(Boolean);
+}
+function allTestsPassed(report) {
+	const fraction = /(\d+)\s*\/\s*(\d+)\s+tests?\s+passed/iu.exec(report);
+	return fraction !== null && Number(fraction[1]) === Number(fraction[2]);
+}
+function missingRunTestsEvidence() {
+	return { summary: "Missing structured run_tests span evidence. Refusing to infer failing-test names from worker prose." };
+}
 /** One spawned worker = one `runAgentic` attempt over the surface task. The driver's brief is threaded
 *  into the attempt (so a re-spawn can take a targeted angle, not an identical retry); `runAgentic` stamps
 *  real tokens/usd/ms, forwarded as `Spend`; the still-failing tests are captured for the analyst. */
 function surfaceWorkerExecutor(surface, task, worker, strategy) {
 	let artifact;
+	const traced = traceSurfaceCalls(surface);
 	return {
 		runtime: "surface-worker",
 		async execute(brief) {
@@ -5304,9 +5261,8 @@ function surfaceWorkerExecutor(surface, task, worker, strategy) {
 				...task,
 				systemPrompt: `${task.systemPrompt ?? ""}\n\n— Supervisor guidance for THIS attempt (incorporate it; do not just repeat a prior approach) —\n${guidance}`
 			} : task;
-			const cap = captureFailures(surface);
 			const r = await runAgentic({
-				surface: cap.surface,
+				surface: traced.surface,
 				task: attemptTask,
 				strategy,
 				budget: worker.budget ?? 1,
@@ -5321,7 +5277,7 @@ function surfaceWorkerExecutor(surface, task, worker, strategy) {
 				score: r.score,
 				shots: r.shots,
 				summary: `${strategy.name} ${r.shots} shot(s) → ${(100 * r.score).toFixed(0)}% (${r.resolved ? "resolved" : "unresolved"})`,
-				failing: r.resolved ? [] : cap.failing()
+				failing: r.resolved ? [] : traced.failing()
 			};
 			const spent = {
 				iterations: r.completions,
@@ -5340,6 +5296,7 @@ function surfaceWorkerExecutor(surface, task, worker, strategy) {
 			};
 			return artifact;
 		},
+		traceSource: () => traced.traceSource,
 		teardown: () => Promise.resolve({ destroyed: true }),
 		resultArtifact() {
 			if (!artifact) throw new Error("surfaceWorkerExecutor: resultArtifact before execute");
@@ -5820,6 +5777,6 @@ function tail(s) {
 	return s.slice(-400);
 }
 //#endregion
-export { InMemoryCorpus as $, runCoderChecks as A, renderLeaderboardMarkdown as At, SandboxRunAbortError as B, envKeyProvider as Bt, safeWorkerFile as C, completionAuthorizes as Ct, workerInboxFileFromEventDir as D, leaderboard as Dt, workerInboxFile as E, stopSentinel as Et, runStrategyEvolution as F, McpSpawnFault as Ft, equalKOnCost as G, printBenchmarkReport as H, resolveMcpServerLaunch as Ht, selectChampion as I, connectStdioMcp as It, runPersonified as J, trajectoryReport as K, assertStrategyContract as L, materializeLocalMcp as Lt, streamAgentTurn as M, renderPairwiseMarkdown as Mt, discriminatingMeans as N, auditIntent as Nt, writeWorkerSteer as O, pairwiseSignificance as Ot, pickChampion as P, defaultAuditorInstruction as Pt, FileCorpus as Q, authorStrategy as R, createMcpEnvironment as Rt, readWorkerSteerRequests as S, loopDispatch as St, supervisorRunsRoot as T, sentinelCompletion as Tt, runBenchmark as U, resolveSecretEnv as Ut, openSandboxRun as V, mcpSecretEnvMetadataKey as Vt, promotionGate as W, secretEnvOfMcpServer as Wt, createShapeRegistry as X, builtinShapes as Y, registerShape as Z, settledWorkerOut as _, naiveDriver as _t, localShell as a, pipeline as at, analyzeTrace as b, inlineSandboxClient as bt, createVerifierEnvironment as c, widen as ct, worktreeFanout as d, createScopeAnalyst as dt, renderCorpusToInstructions as et, EVIDENCE_MAX_CHARS as f, registryScopeAnalyst as ft, composeWorkerEvidence as g, dumbDriver as gt, closingWorkerNote as h, defineLeaderboard as ht, jjWorkspace as i, panel as it, collectAgentTurn as j, renderLeaderboardSvg as jt, patchDelivered as k, renderLeaderboardHtml as kt, failuresAnalyst as l, assertTraceDerivedFindings as lt, VERIFY_TAIL_CHARS as m, harvestCorpus as mt, makeFinding$1 as n, flatWidenGate as nt, runInWorkspace as o, selectValidWinner as ot, NOTE_MAX_CHARS as p, inProcessSandboxClient as pt, definePersona as q, gitWorkspace as r, loopUntil as rt, createWaterfallCollector as s, verify as st, computeFindingId$1 as t, fanout as tt, superviseSurface as u, buildSteerContext as ut, copyUntrackedIntoClone as v, resolveSandboxClient as vt, supervisorRunDir as w, deterministicCompletion as wt, legacySupervisorRunDir as x, loopCampaignDispatch as xt, withUntrackedArtifacts as y, localSandboxClient as yt, strategyAuthorContract as z, sanitizeMcpToolSchema as zt };
+export { verify as $, authorStrategy as A, createMcpEnvironment as At, runPersonified as B, collectAgentTurn as C, renderLeaderboardSvg as Ct, runStrategyEvolution as D, McpSpawnFault as Dt, pickChampion as E, defaultAuditorInstruction as Et, runBenchmark as F, resolveSecretEnv as Ft, InMemoryCorpus as G, createShapeRegistry as H, promotionGate as I, secretEnvOfMcpServer as It, flatWidenGate as J, renderCorpusToInstructions as K, equalKOnCost as L, SandboxRunAbortError as M, envKeyProvider as Mt, openSandboxRun as N, mcpSecretEnvMetadataKey as Nt, selectChampion as O, connectStdioMcp as Ot, printBenchmarkReport as P, resolveMcpServerLaunch as Pt, selectValidWinner as Q, trajectoryReport as R, runCoderChecks as S, renderLeaderboardMarkdown as St, discriminatingMeans as T, auditIntent as Tt, registerShape as U, builtinShapes as V, FileCorpus as W, panel as X, loopUntil as Y, pipeline as Z, settledWorkerOut as _, sentinelCompletion as _t, localShell as a, inProcessSandboxClient as at, analyzeTrace as b, pairwiseSignificance as bt, createVerifierEnvironment as c, dumbDriver as ct, worktreeFanout as d, localSandboxClient as dt, widen as et, EVIDENCE_MAX_CHARS as f, inlineSandboxClient as ft, composeWorkerEvidence as g, deterministicCompletion as gt, closingWorkerNote as h, completionAuthorizes as ht, jjWorkspace as i, registryScopeAnalyst as it, strategyAuthorContract as j, sanitizeMcpToolSchema as jt, assertStrategyContract as k, materializeLocalMcp as kt, failuresAnalyst as l, naiveDriver as lt, VERIFY_TAIL_CHARS as m, loopDispatch as mt, makeFinding$1 as n, buildSteerContext as nt, runInWorkspace as o, harvestCorpus as ot, NOTE_MAX_CHARS as p, loopCampaignDispatch as pt, fanout as q, gitWorkspace as r, createScopeAnalyst as rt, createWaterfallCollector as s, defineLeaderboard as st, computeFindingId$1 as t, assertTraceDerivedFindings as tt, superviseSurface as u, resolveSandboxClient as ut, copyUntrackedIntoClone as v, stopSentinel as vt, streamAgentTurn as w, renderPairwiseMarkdown as wt, patchDelivered as x, renderLeaderboardHtml as xt, withUntrackedArtifacts as y, leaderboard as yt, definePersona as z };
 
-//# sourceMappingURL=runtime-Ut1pkd2n.js.map
+//# sourceMappingURL=runtime-D4e3GP5K.js.map