@tangle-network/agent-runtime 0.132.13 → 0.133.1

package/dist/{runtime-DDg4OVlX.js → runtime-CmTSbexZ.js}

@@ -1,19 +1,19 @@
-import { n as AnalystError, s as PlannerError, u as ValidationError } from "./errors-DEAvWQPy.js";
-import "./stream-agent-turn-Bo5ZSAUR.js";
-import { i as InMemorySpawnJournal, r as InMemoryResultBlobStore, v as isTraceAnalysisStore, x as contentAddress } from "./spawn-journal-Cd5L-Ie9.js";
+import { c as RetainedRunAdmissionError, f as ValidationError, l as RetainedRunDispatchBindingError, n as AnalystError, s as PlannerError } from "./errors-DRoXIc7E.js";
+import "./stream-agent-turn-D8YHY0oO.js";
+import { S as contentAddress, i as InMemorySpawnJournal, r as InMemoryResultBlobStore, y as isTraceAnalysisStore } from "./spawn-journal-BX3-4WDm.js";
 import { a as isAbortError, i as hasCompleteCacheBreakdown, l as sleep, m as zeroTokenUsage, n as cloneTokenUsage, s as randomSuffix, t as addTokenUsage, u as stringifySafe } from "./util-Dr--8wAL.js";
 import { i as redactProtectedValue, r as redactProtectedReason } from "./protected-redaction--F3v1oo8.js";
 import { a as notifySandboxEventObserver, c as parseCanonicalTransportEvent, s as extractTransportEventIdentity } from "./sandbox-events-vIwmuPdl.js";
-import { c as profileProviderModel, i as concreteModelId, s as profileModelExecutionSettings, t as assertExecutableAgentProfile } from "./model-policy-mWSoToiQ.js";
-import { b as executableAgentProfileSnapshot, x as executableAgentSpecSnapshot } from "./materialization-JR_nN_oT.js";
-import { $ as runAgentRounds, I as createWorktreeCliExecutor, N as createExecutor, P as createExecutorRegistry, Q as defaultSelectWinner, W as createPushTraceSource, at as observedModelMatchesDeclared, et as createSandboxLineage, it as runBrainLoop, l as withDriverExecutor, m as settledToIteration, n as createSupervisor, rt as routerBrain, tt as probeSandboxCapabilities, w as rollingDispatch } from "./supervisor-DnA7FWmf.js";
+import { c as profileProviderModel, i as concreteModelId, s as profileModelExecutionSettings, t as assertExecutableAgentProfile } from "./model-policy-Bv1DU2fw.js";
+import { T as executableAgentSpecSnapshot, w as executableAgentProfileSnapshot } from "./materialization-D2bdTfkK.js";
+import { $ as defaultSelectWinner, F as createExecutorRegistry, G as createPushTraceSource, L as createWorktreeCliExecutor, P as createExecutor, T as rollingDispatch, at as runBrainLoop, et as runAgentRounds, h as settledToIteration, it as routerBrain, l as withDriverExecutor, n as createSupervisor, nt as probeSandboxCapabilities, ot as canonicalObservedModel, tt as createSandboxLineage } from "./supervisor-BpIcKHy7.js";
 import "./environment-provider-mDsjfGjY.js";
 import { i as notifyRuntimeHookEvent } from "./runtime-hooks-C7iJOWm3.js";
-import { C as observe, O as strategyAuthorMethod, T as profileChatClient, b as sample, v as refine, x as sampleThenRefine, y as runAgentic } from "./structural-rollout-CwK_V7eP.js";
-import { It as gateOnDeliverable, Lt as mapExecutorResult, n as supervise } from "./supervise-B8BYfxEw.js";
-import "./authoring-D8uh1TYA.js";
-import "./graph-BJy5vrLu.js";
-import { CODING_HARNESSES, InMemoryTraceStore, OUTPUT_VALUE, benjaminiHochberg, buildTrajectory, computeFindingId as computeFindingId$1, confidenceInterval, expandProfileAxes, makeFinding as makeFinding$1, modelHasSnapshot, pairedBootstrap, paretoFrontier, wilcoxonSignedRank, wilson } from "@tangle-network/agent-eval";
+import { C as observe, O as strategyAuthorMethod, T as profileChatClient, b as sample, v as refine, x as sampleThenRefine, y as runAgentic } from "./structural-rollout-Cy0l0bbT.js";
+import { It as gateOnDeliverable, Lt as mapExecutorResult, n as supervise } from "./supervise-DZxpJGK_.js";
+import "./authoring-CoJWo0Ju.js";
+import "./graph-B2xqnhnF.js";
+import { CODING_HARNESSES, InMemoryTraceStore, OUTPUT_VALUE, benjaminiHochberg, buildTrajectory, computeFindingId as computeFindingId$1, confidenceInterval, expandProfileAxes, makeFinding as makeFinding$1, pairedBootstrap, paretoFrontier, wilcoxonSignedRank, wilson } from "@tangle-network/agent-eval";
 import { heldoutSignificance, runProfileMatrix } from "@tangle-network/agent-eval/campaign";
 import { AgentEnvironmentCapabilitiesSchema, AgentExactRunControlRefSchema, AgentNativeContextContinuationResultSchema, AgentRunCancellationAcknowledgementSchema, AgentRunCancellationRequestSchema, AgentTurnResultSchema, InteractionAcknowledgementSchema, InteractionResponseCommandSchema, NativeContextBoundaryProofSchema, NativeContextContinuationRequestSchema, RuntimeEventEnvelopeSchema, agentNativeContextContinuationResultMatchesRequest, agentProfileSchema, agentRunCancellationAcknowledgementMatchesRequest, agentRunCancellationRequestDigest, canonicalAgentProfileDigest, canonicalCandidateDigest, nativeContextContinuationTurnDigest, validateAgentProfileSecurity } from "@tangle-network/agent-interface";
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
@@ -995,38 +995,6 @@ function deterministicCompletion(check) {
 }
 //#endregion
 //#region src/runtime/loop-dispatch.ts
-/**
-* `loopDispatch` — turn `runAgentRounds` into an agent-eval campaign dispatch.
-*
-* Without this adapter a consumer wiring `runAgentRounds` into `runProfileMatrix` /
-* `runCampaign` has to, by hand, every time: (a) build an `ExecCtx` with a
-* sandbox client, (b) adapt the campaign `DispatchContext.trace` into a
-* `LoopTraceEmitter` (or lose all loop trace correlation), and (c) remember to
-* forward the loop's cost + tokens via `ctx.cost` (forgetting it yields a
-* `{0,0}` cell the backend-integrity guard reads as a stub). Three foot-guns,
-* the third silent. The fleet's products skipped (c) and fell back to a
-* `workerRecords[]` side-channel — the exact anti-pattern the substrate exists
-* to kill.
-*
-* `loopDispatch` collapses all three into one typed call:
-*
-*   const dispatch = loopDispatch({
-*     sandboxClient,
-*     toLoopOptions: (scenario, profile) => ({ driver, agentRun, output, validator, task }),
-*   })
-*   await runProfileMatrix({ profiles, scenarios, dispatch, judges, commitSha })
-*
-* The complete Runtime cell starts inside `ctx.cost.runPaidCall` before any
-* sandbox work begins. Its provider-reported usage becomes the paid-call
-* receipt before Eval settles the call. A completed `LoopResult` cannot be
-* attached afterward because it cannot prove pre-execution admission.
-* Trace events are forwarded automatically and the Runtime context is built
-* automatically.
-*
-* Typed structurally against the campaign `DispatchContext` (imported type-only
-* from `@tangle-network/agent-eval/campaign`) — a downward dependency, never an
-* inversion.
-*/
 /** Bridge a campaign `DispatchContext.trace` to a `LoopTraceEmitter` so every
 *  `loop.*` event lands as a span under the cell's scoped trace. */
 function campaignTraceToLoopEmitter(trace) {
@@ -1095,43 +1063,84 @@ function costReceiptFromUsage(usage, model, cost) {
 		...cost.estimatedCostUsd !== void 0 ? { estimatedCostUsd: cost.estimatedCostUsd } : {}
 	};
 }
-/**
-* Eval has one pre-admitted paid call for this dispatch. A tree can only settle that one call when
-* Runtime can prove every visible leaf used the same model. Child identities come from Runtime's
-* materialization receipts. The root identity comes only from Runtime's settled provider receipt;
-* the authored profile remains a matching constraint, never a fallback. A nested tree is not
-* flattened in this result view, so it remains unknown rather than being relabelled from its
-* parent. A caller-supplied override would be false.
-*/
-function supervisedTreeModel(result, rootProfile) {
-	const models = /* @__PURE__ */ new Set();
-	const rootEvidence = result.rootProviderModel;
-	if (rootEvidence?.status !== "known" || rootEvidence.models.length === 0) return { kind: "unknown" };
-	for (const model of rootEvidence.models) {
-		if (!modelHasSnapshot(model) || !observedModelMatchesDeclared(model, rootProfile.model?.default ?? "")) return { kind: "unknown" };
-		models.add(model);
+/** Eval has one pre-admitted paid call for this dispatch. A tree can settle that call only when
+* Runtime has provider-served identity for every inference attempt that actually started. Plan
+* materialization is deliberately ignored: it describes what Runtime requested, not what the
+* provider served. Every visible terminal child must carry provider attempt evidence; a missing
+* evidence record stays unknown, including zero-valued or incomplete spend.
+* @internal Testable identity projection used by superviseDispatch. */
+function supervisedTreeModelForDispatch(result, rootProfile) {
+	const canonicalModels = /* @__PURE__ */ new Set();
+	const observedModels = [];
+	const wholeTreeEvidence = result.providerModel;
+	if (wholeTreeEvidence === void 0 || wholeTreeEvidence.status !== "known" && wholeTreeEvidence.reason !== "provider-model-conflict" || wholeTreeEvidence.attempts.length === 0) return { kind: "unknown" };
+	const wholeTreeIdentity = collectProviderModels(wholeTreeEvidence, () => true);
+	if (wholeTreeIdentity.kind !== "known") return wholeTreeIdentity;
+	for (const model of wholeTreeIdentity.observed) {
+		observedModels.push(model.raw);
+		canonicalModels.add(model.canonical);
 	}
-	let unknown = false;
-	for (const node of result.tree.nodes) {
-		if (node.ownedTreeRoot !== void 0) {
-			unknown = true;
-			continue;
-		}
-		const materialization = node.materialization;
-		if (materialization?.status !== "known" || materialization.model.status !== "known") {
-			unknown = true;
-			continue;
-		}
-		models.add(materialization.model.id);
-	}
-	if (unknown || models.size === 0) return { kind: "unknown" };
-	if (models.size !== 1) return {
+	if (canonicalModels.size === 0) return { kind: "unknown" };
+	if (canonicalModels.size !== 1) return {
 		kind: "mixed",
-		models: [...models].sort()
+		models: [...canonicalModels].sort()
 	};
 	return {
 		kind: "known",
-		model: [...models][0]
+		model: observedModels[0]
+	};
+}
+function collectProviderModels(evidence, validate) {
+	if (evidence.status !== "known" && evidence.reason !== "provider-model-conflict" || !Array.isArray(evidence.attempts) || evidence.attempts.length === 0 || !Array.isArray(evidence.models)) return { kind: "unknown" };
+	const observed = [];
+	const canonical = /* @__PURE__ */ new Set();
+	const observedRaw = /* @__PURE__ */ new Set();
+	for (const attempt of evidence.attempts) {
+		if (attempt === null || typeof attempt !== "object" || !Array.isArray(attempt.observations) || attempt.observations.length === 0 || attempt.identityConflict === true) return { kind: "unknown" };
+		let attemptBase;
+		let attemptSnapshot;
+		let representative;
+		for (const model of attempt.observations) {
+			if (typeof model !== "string" || !validate(model)) return { kind: "unknown" };
+			const identity = canonicalObservedModel(model);
+			if (identity === void 0) return { kind: "unknown" };
+			const at = identity.lastIndexOf("@");
+			const base = at < 0 ? identity : identity.slice(0, at);
+			const snapshot = at < 0 ? void 0 : identity.slice(at + 1);
+			if (attemptBase !== void 0 && attemptBase !== base) return {
+				kind: "mixed",
+				models: [.../* @__PURE__ */ new Set([...attemptBase ? [attemptBase] : [], identity])]
+			};
+			if (attemptSnapshot !== void 0 && snapshot !== void 0 && attemptSnapshot !== snapshot) return {
+				kind: "mixed",
+				models: [`${attemptBase}@${attemptSnapshot}`, `${base}@${snapshot}`]
+			};
+			attemptBase = base;
+			attemptSnapshot ??= snapshot;
+			if (snapshot !== void 0) representative = model;
+			observedRaw.add(model);
+		}
+		if (attemptBase === void 0 || attemptSnapshot === void 0 || representative === void 0) return { kind: "unknown" };
+		const attemptIdentity = `${attemptBase}@${attemptSnapshot}`;
+		observed.push({
+			raw: representative,
+			canonical: attemptIdentity
+		});
+		canonical.add(attemptIdentity);
+	}
+	if (observed.length === 0) return { kind: "unknown" };
+	const declaredRaw = /* @__PURE__ */ new Set();
+	for (const model of evidence.models) {
+		if (typeof model !== "string") return { kind: "unknown" };
+		declaredRaw.add(model);
+	}
+	if (declaredRaw.size !== observedRaw.size || [...declaredRaw].some((model) => !observedRaw.has(model))) return { kind: "unknown" };
+	return canonical.size > 1 ? {
+		kind: "mixed",
+		models: [...canonical].sort()
+	} : {
+		kind: "known",
+		observed
 	};
 }
 /** The Eval receipt surface has no pre-admitted per-model recursive-tree receipt bundle yet. */
@@ -1168,12 +1177,12 @@ function superviseDispatch(opts) {
 					...superviseOptions,
 					signal: executionSignal
 				});
-				const identity = supervisedTreeModel(result, profile);
+				const identity = supervisedTreeModelForDispatch(result, profile);
 				if (identity.kind !== "known") throw new SupervisedTreeModelIdentityError(identity);
 				return result;
 			},
 			receipt: (result) => {
-				const identity = supervisedTreeModel(result, profile);
+				const identity = supervisedTreeModelForDispatch(result, profile);
 				if (identity.kind !== "known") throw new SupervisedTreeModelIdentityError(identity);
 				return costReceiptFromUsage(result.spentTotal.tokens, identity.model, {
 					usageUnknown: result.spentTotal.tokensKnown === false,
@@ -3854,8 +3863,33 @@ function freshTurnInput(input, runtime) {
 //#endregion
 //#region src/runtime/retained-run-start.ts
 /**
+* Mint deterministic dispatch coordinates from the two caller-supplied keys.
+* The same `(idempotencyKey, turnId)` pair yields the same coordinates in
+* every process, so a pre-dispatch admission record always names the exact
+* session and execution the dispatch will request. Format is readable, not
+* hashed, following `deriveExecutionId`: components are URL-encoded so
+* delimiters inside caller keys cannot collapse distinct pairs, and the
+* result stays inside the 256-byte identifier bound.
+*/
+function mintRetainedIdentity(idempotencyKey, turnId) {
+	const base = `${encodeURIComponent(idempotencyKey)}:${encodeURIComponent(turnId)}`;
+	const sessionId = `retained-session:${base}`;
+	const executionId = `retained-execution:${base}`;
+	if (executionId.length > 256) throw new RangeError("minted retained identity must not exceed 256 bytes");
+	return {
+		sessionId,
+		executionId
+	};
+}
+/**
 * Dispatch one detached, replayable run and return only after exact durable
-* coordinates are confirmed by the provider.
+* coordinates are confirmed by the provider and persisted by the caller.
+*
+* The required `onAdmission` hook is awaited twice: with the recovery
+* coordinates after environment creation, and with the verified exact control
+* reference after dispatch. The returned promise resolves only after the
+* dispatched admission is durable, so no caller can observe a successful start
+* whose exact reference a crash would lose.
 *
 * @stable
 */
@@ -3866,9 +3900,19 @@ async function startRetainedRun(options) {
 		assertStableText(options.identity.sessionId, "retained session id");
 		assertStableText(options.identity.executionId, "retained execution id");
 	}
+	if (typeof options.onAdmission !== "function") throw new Error("startRetainedRun requires an awaited onAdmission durability hook");
+	const identity = options.identity ?? mintRetainedIdentity(options.environment.idempotencyKey, options.turn.turnId);
 	const capabilities = await assertRetainedCapabilities(options.provider);
 	if (!options.provider.get) throw new Error(`provider "${options.provider.name}" cannot reconstruct an environment by id`);
-	const environment = await options.provider.create(options.environment);
+	const environment = await options.provider.create({
+		...options.environment,
+		metadata: {
+			...options.environment.metadata,
+			retainedIdempotencyKey: options.environment.idempotencyKey,
+			sessionId: identity.sessionId,
+			executionId: identity.executionId
+		}
+	});
 	if (!environment.dispatch || !environment.session) {
 		try {
 			await environment.destroy?.();
@@ -3877,19 +3921,115 @@ async function startRetainedRun(options) {
 		}
 		throw new Error(`provider "${options.provider.name}" does not expose detached session control`);
 	}
+	await admitDurably(options.onAdmission, {
+		phase: "environment",
+		provider: options.provider.name,
+		environmentId: environment.id,
+		idempotencyKey: options.environment.idempotencyKey,
+		turnId: options.turn.turnId,
+		sessionId: identity.sessionId,
+		executionId: identity.executionId
+	});
 	const reference = await environment.dispatch(freshTurnInput(options.turn, {
 		turnId: options.turn.turnId,
 		detach: true,
-		...options.identity === void 0 ? {} : options.identity
-	}));
-	if (reference.provider !== void 0 && reference.provider !== options.provider.name) throw new Error("provider dispatch returned a session reference for another provider");
-	const exact = exactSession(environment, exactControlRef(reference.controlRef, {
-		provider: options.provider.name,
-		environmentId: environment.id,
-		sessionId: reference.id
+		...identity
 	}));
+	let exact;
+	try {
+		if (reference.provider !== void 0 && reference.provider !== options.provider.name) throw new Error("provider dispatch returned a session reference for another provider");
+		if (reference.id !== identity.sessionId) throw new Error("provider dispatched into another session than the requested identity");
+		const controlRef = exactControlRef(reference.controlRef, {
+			provider: options.provider.name,
+			environmentId: environment.id,
+			sessionId: identity.sessionId
+		});
+		if (controlRef.executionId !== identity.executionId) throw new Error("provider bound another execution than the requested identity");
+		exact = exactSession(environment, controlRef);
+	} catch (error) {
+		throw new RetainedRunDispatchBindingError({
+			provider: options.provider.name,
+			environmentId: environment.id,
+			sessionId: identity.sessionId,
+			executionId: identity.executionId
+		}, {
+			...reference.id === void 0 ? {} : { id: reference.id },
+			...reference.provider === void 0 ? {} : { provider: reference.provider },
+			...reference.controlRef === void 0 ? {} : { controlRef: reference.controlRef }
+		}, { cause: error });
+	}
+	await admitDurably(options.onAdmission, {
+		phase: "dispatched",
+		controlRef: freezeControlRef(exact.controlRef),
+		idempotencyKey: options.environment.idempotencyKey,
+		turnId: options.turn.turnId
+	});
 	return createRetainedRunHandle(environment, exact.session, exact.controlRef, capabilities, options.now);
 }
+/**
+* Await one admission record through the caller's durability hook. A rejection
+* keeps the environment alive — the provider state plus any partial admission
+* record is the recovery path — and surfaces as `RetainedRunAdmissionError` so
+* callers can distinguish a persistence failure from a provider failure.
+*/
+async function admitDurably(onAdmission, admission) {
+	try {
+		await onAdmission(Object.freeze(admission));
+	} catch (error) {
+		throw new RetainedRunAdmissionError(admission, { cause: error });
+	}
+}
+/**
+* Rebuild the exact run named by pre-dispatch admission coordinates, or
+* report why the provider cannot prove it.
+*
+* `not_found`: the provider no longer holds the environment, so nothing
+* remains to destroy. `recovered`: the provider self-identified the session
+* with a strict exact reference matching the recorded coordinates.
+* `unverifiable`: the environment exists but the provider cannot
+* self-identify the session — no session accessor, an accessor that throws,
+* a lazy accessor with no stored reference, or a loose reference. That
+* outcome is never destroy-safe: keep the environment, retry
+* `reconnectRetainedRun` with a dispatched admission record, or inspect the
+* environment with provider-native tools. A session that self-identifies
+* with different coordinates throws: something live is not the recorded run.
+*
+* @stable
+*/
+async function recoverRetainedRun(options) {
+	assertStableText(options.environmentId, "retained environment id");
+	assertStableText(options.sessionId, "retained session id");
+	assertStableText(options.executionId, "retained execution id");
+	const capabilities = await assertRetainedCapabilities(options.provider);
+	if (!options.provider.get) throw new Error(`provider "${options.provider.name}" cannot reconstruct an environment by id`);
+	const environment = await options.provider.get(options.environmentId);
+	if (!environment) return { outcome: "not_found" };
+	if (!environment.session) return {
+		outcome: "unverifiable",
+		environment
+	};
+	let session;
+	try {
+		session = environment.session(options.sessionId);
+	} catch {
+		return {
+			outcome: "unverifiable",
+			environment
+		};
+	}
+	const parsed = AgentExactRunControlRefSchema.safeParse(session.controlRef);
+	if (!parsed.success) return {
+		outcome: "unverifiable",
+		environment
+	};
+	const controlRef = parsed.data;
+	if (controlRef.provider !== options.provider.name || controlRef.environmentId !== options.environmentId || controlRef.sessionId !== options.sessionId || controlRef.executionId !== options.executionId) throw new Error("provider session is bound to other retained run coordinates");
+	const exact = exactSession(environment, controlRef);
+	return {
+		outcome: "recovered",
+		handle: createRetainedRunHandle(environment, exact.session, exact.controlRef, capabilities, options.now)
+	};
+}
 /** Rebuild a retained-run client without retaining any object from the starter. @stable */
 async function reconnectRetainedRun(options) {
 	const controlRef = AgentExactRunControlRefSchema.parse(options.controlRef);
@@ -6211,6 +6351,6 @@ function tail(s) {
 	return s.slice(-400);
 }
 //#endregion
-export { loopUntil as $, assertStrategyContract as A, McpSpawnFault as At, promotionGate as B, chatTransportExecutor as C, pairwiseSignificance as Ct, pickChampion as D, renderPairwiseMarkdown as Dt, discriminatingMeans as E, renderLeaderboardSvg as Et, openSandboxRun as F, envKeyProvider as Ft, builtinShapes as G, trajectoryReport as H, printBenchmarkReport as I, mcpSecretEnvMetadataKey as It, FileCorpus as J, createShapeRegistry as K, runBenchmark as L, resolveMcpServerLaunch as Lt, strategyAuthorContract as M, materializeLocalMcp as Mt, strategyAuthorSystemPrompt as N, createMcpEnvironment as Nt, runStrategyEvolution as O, auditIntent as Ot, SandboxRunAbortError as P, sanitizeMcpToolSchema as Pt, flatWidenGate as Q, reconnectRetainedRun as R, resolveSecretEnv as Rt, runCoderChecks as S, leaderboard as St, createChatSessionStore as T, renderLeaderboardMarkdown as Tt, definePersona as U, equalKOnCost as V, runPersonified as W, renderCorpusToInstructions as X, InMemoryCorpus as Y, fanout as Z, settledWorkerOut as _, superviseDispatch as _t, localShell as a, assertTraceDerivedFindings as at, analyzeTrace as b, sentinelCompletion as bt, createVerifierEnvironment as c, registryScopeAnalyst as ct, worktreeFanout as d, defineLeaderboard as dt, panel as et, EVIDENCE_MAX_CHARS as f, resolveSandboxClient as ft, composeWorkerEvidence as g, loopDispatch as gt, closingWorkerNote as h, loopCampaignDispatch as ht, jjWorkspace as i, widen as it, authorStrategy as j, connectStdioMcp as jt, selectChampion as k, defaultAuditorInstruction as kt, failuresAnalyst as l, inProcessSandboxClient as lt, VERIFY_TAIL_CHARS as m, inlineSandboxClient as mt, makeFinding$1 as n, selectValidWinner as nt, runInWorkspace as o, buildSteerContext as ot, NOTE_MAX_CHARS as p, localSandboxClient as pt, registerShape as q, gitWorkspace as r, verify as rt, createWaterfallCollector as s, createScopeAnalyst as st, computeFindingId$1 as t, pipeline as tt, superviseSurface as u, harvestCorpus as ut, copyUntrackedIntoClone as v, completionAuthorizes as vt, chatWorkerSeam as w, renderLeaderboardHtml as wt, patchDelivered as x, stopSentinel as xt, withUntrackedArtifacts as y, deterministicCompletion as yt, startRetainedRun as z, secretEnvOfMcpServer as zt };
+export { flatWidenGate as $, assertStrategyContract as A, defaultAuditorInstruction as At, startRetainedRun as B, secretEnvOfMcpServer as Bt, chatTransportExecutor as C, leaderboard as Ct, pickChampion as D, renderLeaderboardSvg as Dt, discriminatingMeans as E, renderLeaderboardMarkdown as Et, openSandboxRun as F, sanitizeMcpToolSchema as Ft, runPersonified as G, equalKOnCost as H, printBenchmarkReport as I, envKeyProvider as It, registerShape as J, builtinShapes as K, runBenchmark as L, mcpSecretEnvMetadataKey as Lt, strategyAuthorContract as M, connectStdioMcp as Mt, strategyAuthorSystemPrompt as N, materializeLocalMcp as Nt, runStrategyEvolution as O, renderPairwiseMarkdown as Ot, SandboxRunAbortError as P, createMcpEnvironment as Pt, fanout as Q, reconnectRetainedRun as R, resolveMcpServerLaunch as Rt, runCoderChecks as S, stopSentinel as St, createChatSessionStore as T, renderLeaderboardHtml as Tt, trajectoryReport as U, promotionGate as V, definePersona as W, InMemoryCorpus as X, FileCorpus as Y, renderCorpusToInstructions as Z, settledWorkerOut as _, loopDispatch as _t, localShell as a, widen as at, analyzeTrace as b, deterministicCompletion as bt, createVerifierEnvironment as c, createScopeAnalyst as ct, worktreeFanout as d, harvestCorpus as dt, loopUntil as et, EVIDENCE_MAX_CHARS as f, defineLeaderboard as ft, composeWorkerEvidence as g, loopCampaignDispatch as gt, closingWorkerNote as h, inlineSandboxClient as ht, jjWorkspace as i, verify as it, authorStrategy as j, McpSpawnFault as jt, selectChampion as k, auditIntent as kt, failuresAnalyst as l, registryScopeAnalyst as lt, VERIFY_TAIL_CHARS as m, localSandboxClient as mt, makeFinding$1 as n, pipeline as nt, runInWorkspace as o, assertTraceDerivedFindings as ot, NOTE_MAX_CHARS as p, resolveSandboxClient as pt, createShapeRegistry as q, gitWorkspace as r, selectValidWinner as rt, createWaterfallCollector as s, buildSteerContext as st, computeFindingId$1 as t, panel as tt, superviseSurface as u, inProcessSandboxClient as ut, copyUntrackedIntoClone as v, superviseDispatch as vt, chatWorkerSeam as w, pairwiseSignificance as wt, patchDelivered as x, sentinelCompletion as xt, withUntrackedArtifacts as y, completionAuthorizes as yt, recoverRetainedRun as z, resolveSecretEnv as zt };
 
-//# sourceMappingURL=runtime-DDg4OVlX.js.map
+//# sourceMappingURL=runtime-CmTSbexZ.js.map