@tangle-network/agent-runtime 0.318.0 → 0.319.3

package/dist/{runtime-UG5tV_yf.js → runtime-6qzuLTJ7.js}

@@ -1,16 +1,17 @@
-import { Bn as InMemoryResultBlobStore, Cn as readPromptOptions, Hn as insideCursorNamespace, It as createWorktreeCliExecutor, Jn as readCommittedJsonLines, Mr as contentAddress, Nt as createExecutor, Ot as verdictFromJudgeScore, Pt as createExecutorRegistry, Qn as isTraceAnalysisStore, Sn as assertBoxlessPromptOptions, Tn as runBrainLoop, Vn as InMemorySpawnJournal, Yn as writeAllBytes, _n as runAgentRounds, ha as notifySandboxEventObserver, hn as defaultSelectWinner, ht as mapExecutorResult, ia as detachedSnapshot, j as settledToIteration, mt as gateOnDeliverable, na as executableAgentSpecSnapshot, pt as rollingDispatch, qn as prepareJsonlAppend, r as createSupervisor, ra as detachedFrozen, ta as executableAgentProfileSnapshot, v as withDriverExecutor, vn as createSandboxLineage, vt as CheckUnavailableError, wn as routerBrain } from "./supervisor-BXEL_Fxe.js";
+import { a as graphRunsFor, d as recordGraphRun, i as graphRegistry, l as lookupGraph, p as taskShapeDigest, r as graphFromStored, t as digestOfGraph } from "./graph-registry-BuJbzTzF.js";
+import { Bn as InMemoryResultBlobStore, Cn as readPromptOptions, Hn as insideCursorNamespace, It as createWorktreeCliExecutor, Jn as readCommittedJsonLines, Mr as contentAddress, Nt as createExecutor, Ot as verdictFromJudgeScore, Pt as createExecutorRegistry, Qn as isTraceAnalysisStore, Sn as assertBoxlessPromptOptions, Tn as runBrainLoop, Vn as InMemorySpawnJournal, Yn as writeAllBytes, _n as runAgentRounds, aa as detachedSnapshot, ga as notifySandboxEventObserver, hn as defaultSelectWinner, ht as mapExecutorResult, ia as detachedFrozen, j as settledToIteration, mt as gateOnDeliverable, na as executableAgentProfileSnapshot, pt as rollingDispatch, qn as prepareJsonlAppend, r as createSupervisor, ra as executableAgentSpecSnapshot, v as withDriverExecutor, vn as createSandboxLineage, vt as CheckUnavailableError, wn as routerBrain } from "./supervisor-Cqhu3xH-.js";
 import { i as ConfigError, m as ValidationError, n as AnalystError, s as PlannerError } from "./errors-DodWX-cb.js";
-import { B as runAgentic, G as observe, K as renderReport, U as ObservationError, V as sample, X as strategyAuthorMethod, a as reconcileInterruptedSearchCalls, c as searchExecutor, q as profileChatClient, r as dedicatedLane, x as runtimeShipDecision, z as refine } from "./search-executor-DMX6tCY4.js";
-import { $ as randomSuffix, B as addSpend, H as chargedTokens, I as immutableCandidateValue, J as hasCompleteCacheBreakdown, K as errorMessage, M as canonicalCandidateDigest$1, R as sha256Bytes$1, U as cloneSpend, X as isAsyncIterable, Y as isAbortError, bt as armDeadlineTimer, ct as zeroSpend, k as markPutStreamVerified, nt as sleep, q as fnv1a32Hex, rt as stringifySafe, v as WorkspaceScanLimitError, x as captureMaterializedWorkspace } from "./workspace-streams-DkijayqX.js";
-import { c as profileModelExecutionSettings, i as concreteModelId, l as profileProviderModel, o as enforceTokenLimits, p as canonicalObservedModelParts, t as assertExecutableAgentProfile } from "./model-policy-B-rOb8Nj.js";
+import { B as runAgentic, G as observe, K as renderReport, U as ObservationError, V as sample, X as strategyAuthorMethod, a as reconcileInterruptedSearchCalls, c as searchExecutor, q as profileChatClient, r as dedicatedLane, x as runtimeShipDecision, z as refine } from "./search-executor-DlaLafvy.js";
+import { A as markPutStreamVerified, J as fnv1a32Hex, L as immutableCandidateValue, N as canonicalCandidateDigest$1, S as captureMaterializedWorkspace, U as chargedTokens, V as addSpend, W as cloneSpend, X as isAbortError, Y as hasCompleteCacheBreakdown, Z as isAsyncIterable, et as randomSuffix, it as stringifySafe, lt as zeroSpend, q as errorMessage, rt as sleep, xt as armDeadlineTimer, y as WorkspaceScanLimitError, z as sha256Bytes$1 } from "./workspace-streams-DFAhW7hF.js";
+import { c as profileModelExecutionSettings, i as concreteModelId, l as profileProviderModel, o as enforceTokenLimits, p as canonicalObservedModelParts, t as assertExecutableAgentProfile } from "./model-policy-CNe257pB.js";
 import { i as notifyRuntimeHookEvent } from "./runtime-hooks-tXpAarhW.js";
 import { i as redactProtectedValue, r as redactProtectedReason } from "./protected-redaction-DylCC_ot.js";
-import { C as createInMemoryRunContext, E as foldCoordinationRecords } from "./coordination-driver-DK3pI_HB.js";
-import { r as supervise } from "./supervise-C41ywfFd.js";
+import { C as createInMemoryRunContext, E as foldCoordinationRecords } from "./coordination-driver-Culvomn2.js";
+import { r as supervise } from "./supervise-D4CnC-cl.js";
 import "./run-layout-DSCWdbX2.js";
-import "./provision-supervisor-CunKnayY.js";
-import "./delegate-Co9vJIgE.js";
-import "./graph-DYBCYZjg.js";
+import "./provision-supervisor-DiZTjzdp.js";
+import "./delegate-CpMbpiIR.js";
+import "./graph-DnfSGUM8.js";
 import { agentProfileSchema, canonicalAgentProfileDigest, canonicalCandidateDigest, sha256Bytes, validateAgentProfileSecurity } from "@tangle-network/agent-interface";
 import { CODING_HARNESSES, DEFAULT_TRACE_ANALYST_KINDS, InMemoryTraceStore, OUTPUT_VALUE, benjaminiHochberg, buildTrajectory, computeFindingId as computeFindingId$1, confidenceInterval, createTraceAnalyst, expandProfileAxes, makeFinding as makeFinding$1, pairedBootstrap, paretoFrontier, wilcoxonSignedRank, wilson } from "@tangle-network/agent-eval";
 import { createAgentRunOutcomeTracker } from "@tangle-network/sandbox/runtime";
@@ -562,12 +563,23 @@ function envKeyProvider(env = process.env) {
 }
 /** The `AgentProfileMcpServer.metadata` key the declarative secret-env map
 *  rides under: `{ ENV_VAR_NAME: 'PROVIDER_KEY_NAME' }`. Names only — values
-*  are resolved at materialize time and never stored. */
+*  are resolved at materialize time and never stored.
+*
+*  DEPRECATED (2026-10-12): this is the interface <0.40 channel. Author
+*  `profile.mcp[key].env.ENV_VAR_NAME = { kind: 'secret-ref', key }` instead —
+*  the canonical form since 0.40. The legacy map keeps resolving (profiles
+*  are data in the wild and must not break at boot) but every use now warns
+*  once per server; removal lands at the next interface major. */
 const mcpSecretEnvMetadataKey = "secretEnv";
+const warnedSecretEnv = /* @__PURE__ */ new Set();
 /** Read (and validate) a server entry's declared secret-env map, if any.
 *  Malformed metadata throws — a half-declared secret must never half-boot. */
-function secretEnvOfMcpServer(server) {
+function secretEnvOfMcpServer(server, label = "profile.mcp server") {
 	const raw = server.metadata?.[mcpSecretEnvMetadataKey];
+	if (raw !== void 0 && !warnedSecretEnv.has(label)) {
+		warnedSecretEnv.add(label);
+		console.warn(`${label}: metadata.${mcpSecretEnvMetadataKey} is deprecated — author env secret-refs (profile.mcp[key].env.ENV = { kind: 'secret-ref', key }) instead; support is removed at the next interface major`);
+	}
 	if (raw === void 0 || raw === null) return void 0;
 	if (typeof raw !== "object" || Array.isArray(raw)) throw new ValidationError(`secretEnvOfMcpServer: metadata.${mcpSecretEnvMetadataKey} must be an object mapping env var name -> key name`);
 	const entries = Object.entries(raw);
@@ -7116,6 +7128,185 @@ function chatWorkerSeam(opts) {
 	};
 }
 //#endregion
+//#region src/runtime/supervise/designer-tools.ts
+/**
+* `graphDesignerExtraTools` — the designer's toolset on the existing
+* `RunGraphOptions.extraTools` seam.
+*
+* A meta-graph designer is an ordinary supervisor ROOT whose ONLY tools are
+* these three: look up what this task shape has run, run a graph (authored or
+* replayed — every run recorded, terminal accounting included), and read the
+* history. The agent authors graphs as DATA (nodes, edges, budget, deliverable
+* description); execution is ENVIRONMENT-OWNED — the caller closes over how
+* graphs run (backend/brain/leaf seam) and how the deliverable's check is
+* re-bound, because oracles are environment, never agent-supplied.
+*
+* This is the `measure_rung` pattern from the graph contract generalized: the
+* root's profile declares the tools; the graph options supply them; nothing
+* new exists below this line but the registry calls themselves.
+*/
+const taskShapeSchema = {
+	type: "object",
+	description: "Stable descriptor of this class of work (kind, source, constraints) — the lookup key. Not the payload.",
+	additionalProperties: true
+};
+const graphDataSchema = {
+	type: "object",
+	description: "A graph as data: { nodes: [{id, profile}], edges: [{kind, from, to, directive, ...}], budget, deliverable: {describe} }. No check function — the environment binds it.",
+	additionalProperties: true
+};
+function asRecord(value, context) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new ValidationError(`${context}: expected an object`);
+	return value;
+}
+/** The designer's three tools over one registry. Record-every-run is enforced
+*  by construction: running IS recording. */
+function graphDesignerExtraTools(env) {
+	const registry = graphRegistry(env.registryDir);
+	let runCounter = 0;
+	const runId = env.nextRunId ?? (() => `designer-${++runCounter}`);
+	const runAndRecord = async (taskShape, graph, mode) => {
+		const digest = digestOfGraph(graph);
+		const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+		const result = await env.runGraph(graph);
+		const winner = result.result.kind === "winner";
+		const spent = winner ? result.result.spentTotal : void 0;
+		await recordGraphRun(registry, graph, {
+			graphDigest: digest,
+			taskDigest: taskShapeDigest(taskShape),
+			startedAt,
+			finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			outcome: winner ? { kind: "delivered" } : {
+				kind: "no-winner",
+				reason: `mode=${mode} result=${result.result.kind}`
+			},
+			cost: {
+				...spent?.iterations !== void 0 ? { iterations: spent.iterations } : {},
+				...spent?.tokens && typeof spent.tokens === "object" && "input" in spent.tokens ? { tokens: (spent.tokens.input ?? 0) + (spent.tokens.output ?? 0) } : {},
+				...spent?.usd !== void 0 ? { usd: spent.usd } : {}
+			},
+			traversals: result.ledger.length,
+			...result.exhaustedEdges.length > 0 ? { exhaustedEdges: result.exhaustedEdges } : {}
+		});
+		return {
+			runId: runId(),
+			outcome: winner ? "delivered" : `no-winner (${result.result.kind})`,
+			graphDigest: digest,
+			traversals: result.ledger.length,
+			...spent?.iterations !== void 0 ? { iterations: spent.iterations } : {},
+			...spent?.tokens && typeof spent.tokens === "object" && "input" in spent.tokens ? { tokens: (spent.tokens.input ?? 0) + (spent.tokens.output ?? 0) } : {}
+		};
+	};
+	const summarize = (row) => ({
+		graphDigest: row.graphDigest.slice(0, 12),
+		outcome: row.outcome.kind,
+		cost: row.cost,
+		finishedAt: row.finishedAt
+	});
+	return {
+		extraTools: [
+			{
+				name: "designer_lookup_graph",
+				description: "Look up what this task shape has run before. Returns replay (a known-good graph — run it verbatim with designer_run_graph, near-zero inference) or author (with the reason), plus the recent history for context.",
+				parameters: {
+					type: "object",
+					properties: { taskShape: taskShapeSchema },
+					required: ["taskShape"],
+					additionalProperties: false
+				}
+			},
+			{
+				name: "designer_run_graph",
+				description: "Run a graph and record it. REPLAY mode: pass the graphDigest from lookup — the stored graph runs verbatim, check re-bound by the environment. AUTHOR mode: pass the graph as data (no check). Every run is recorded with its terminal accounting; the registry is the memory.",
+				parameters: {
+					type: "object",
+					properties: {
+						taskShape: taskShapeSchema,
+						mode: {
+							type: "string",
+							enum: ["replay", "authored"]
+						},
+						graphDigest: {
+							type: "string",
+							description: "Replay mode: the digest lookup returned."
+						},
+						graph: graphDataSchema,
+						mutationNote: {
+							type: "string",
+							description: "Author mode after a failed replay lineage: what the prior record says went wrong and the ONE axis this graph changes."
+						}
+					},
+					required: ["taskShape", "mode"],
+					additionalProperties: false
+				}
+			},
+			{
+				name: "designer_history",
+				description: "Every recorded run for a task shape (or all shapes): graph digest, outcome, cost, finish time. The evidence for improvement decisions.",
+				parameters: {
+					type: "object",
+					properties: { taskShape: taskShapeSchema },
+					additionalProperties: false
+				}
+			}
+		],
+		executeExtraTool: (name, raw) => {
+			if (name === "designer_lookup_graph") return (async () => {
+				return lookupGraphSyncish(asRecord(asRecord(raw, "designer_lookup_graph").taskShape, "designer_lookup_graph.taskShape"));
+			})();
+			if (name === "designer_history") return (async () => {
+				const args = asRecord(raw ?? {}, "designer_history");
+				const { listGraphRuns } = await import("./graph-registry-BuJbzTzF.js").then((n) => n.o);
+				const all = await listGraphRuns(registry);
+				return { runs: (args.taskShape === void 0 ? all : all.filter((row) => row.taskDigest === taskShapeDigest(asRecord(args.taskShape, "designer_history.taskShape")))).map(summarize) };
+			})();
+			if (name === "designer_run_graph") return (async () => {
+				const args = asRecord(raw, "designer_run_graph");
+				const taskShape = asRecord(args.taskShape, "designer_run_graph.taskShape");
+				const mode = args.mode;
+				if (mode === "replay") {
+					const digest = args.graphDigest;
+					if (typeof digest !== "string" || digest.length === 0) throw new ValidationError("designer_run_graph: replay mode requires graphDigest from lookup");
+					const { loadGraph } = await import("./graph-registry-BuJbzTzF.js").then((n) => n.o);
+					const stored = await loadGraph(registry, digest);
+					if (!stored) throw new ValidationError(`designer_run_graph: no stored graph ${digest.slice(0, 12)} — re-lookup`);
+					const graph = env.bindCheck(graphFromStored(stored, () => {
+						throw new Error("designer: environment did not bind the deliverable check");
+					}));
+					return runAndRecord(taskShape, graph, "replay");
+				}
+				if (mode === "authored") {
+					const graph = asRecord(args.graph, "designer_run_graph.graph");
+					for (const axis of [
+						"nodes",
+						"edges",
+						"budget",
+						"deliverable"
+					]) if (graph[axis] === void 0) throw new ValidationError(`designer_run_graph.graph: ${axis} is required`);
+					return runAndRecord(taskShape, env.bindCheck(graph), "authored");
+				}
+				throw new ValidationError("designer_run_graph: mode must be 'replay' | 'authored'");
+			})();
+			return null;
+		}
+	};
+	async function lookupGraphSyncish(taskShape) {
+		const selection = await lookupGraph(registry, taskShapeDigest(taskShape));
+		const history = (await graphRunsFor(registry, taskShapeDigest(taskShape))).map(summarize);
+		if (selection.kind === "replay") return {
+			decision: "replay",
+			reason: `a delivered graph exists (${selection.record.cost.iterations ?? "?"} iterations, ${selection.record.cost.tokens ?? "?"} tokens)`,
+			graphDigest: selection.graph.digest,
+			history
+		};
+		return {
+			decision: "author",
+			reason: selection.reason,
+			history
+		};
+	}
+}
+//#endregion
 //#region src/runtime/supervise/patch-checks.ts
 const DEFAULT_MAX_DIFF_LINES = 400;
 /**
@@ -7245,6 +7436,109 @@ function signalPass(value, required) {
 	return !required;
 }
 //#endregion
+//#region src/runtime/supervise/profile-registry.ts
+/**
+* `profile-registry` — named AgentProfiles with run receipts: the missing
+* bottom layer of the designer's memory.
+*
+* The graph registry (#1719) answers "which GRAPH won for this task shape?"
+* but a profile is reused ACROSS graphs and across products — the same
+* summarizer, the same referee, the same driver — and "did the v2 prompt
+* actually improve?" was answerable only per-graph. This module gives named
+* profiles their own receipt loop in the exact same shape as the graph
+* registry: profiles content-addressed by the interface's canonical digest,
+* one JSONL record per run, pickBest by the same documented heuristic.
+*
+* A profile record answers the question a prompt change has to answer before
+* it deserves to exist: same name, new digest — what did each version cost,
+* and did it deliver? Versions never overwrite (immutability), so old-vs-new
+* is always a controlled diff, and a product mounting the registry can refuse
+* a profile revision with no runs behind it.
+*/
+const RECORDS_FILE = "profile-records.jsonl";
+const PROFILES_DIR = "profiles";
+function assertRecord(record) {
+	if (typeof record.name !== "string" || record.name.trim().length === 0) throw new ValidationError("profile-registry: record.name is required");
+	if (typeof record.profileDigest !== "string" || record.profileDigest.length === 0) throw new ValidationError("profile-registry: record.profileDigest is required");
+	if (record.outcome.kind !== "delivered" && record.outcome.kind !== "failed") throw new ValidationError("profile-registry: record.outcome.kind must be 'delivered' | 'failed'");
+}
+/** Open (or lazily create) a profile registry rooted at a workspace directory. */
+function profileRegistry(root) {
+	if (!root || root.trim().length === 0) throw new ValidationError("profileRegistry: root directory is required");
+	return { root };
+}
+async function ensureLayout(reg) {
+	await mkdir(join(reg.root, PROFILES_DIR), { recursive: true });
+}
+async function readRecords(reg) {
+	try {
+		return (await readFile(join(reg.root, RECORDS_FILE), "utf8")).split("\n").filter((line) => line.trim().length > 0).map((line) => JSON.parse(line));
+	} catch {
+		return [];
+	}
+}
+/** Record one run and persist the exact profile revision beside it. The
+*  record's digest must match the supplied profile — a record always names
+*  the revision that actually ran. The revision file is write-once: a
+*  different profile under the same digest is refused. */
+async function recordProfileRun(reg, profile, record) {
+	assertRecord(record);
+	if (typeof profile?.name !== "string" || profile.name !== record.name) throw new ValidationError(`profile-registry: the supplied profile's name must equal record.name ('${record.name}')`);
+	const digest = canonicalAgentProfileDigest(profile);
+	if (digest !== record.profileDigest) throw new ValidationError(`profile-registry: record.profileDigest ${record.profileDigest.slice(0, 12)} does not match the supplied profile (${digest.slice(0, 12)}) — record the revision that actually ran`);
+	await ensureLayout(reg);
+	const file = join(reg.root, PROFILES_DIR, `${digest}.json`);
+	try {
+		if (canonicalAgentProfileDigest(JSON.parse(await readFile(file, "utf8"))) !== digest) throw new ValidationError(`profile-registry: revision ${digest.slice(0, 12)} is immutable but its stored copy differs — refusing to overwrite`);
+	} catch (error) {
+		if (!(error instanceof ValidationError)) await writeFile(file, JSON.stringify(profile), "utf8");
+		else throw error;
+	}
+	const deduped = (await readRecords(reg)).filter((row) => !(row.name === record.name && row.profileDigest === record.profileDigest && row.startedAt === record.startedAt));
+	deduped.push(record);
+	await writeFile(join(reg.root, RECORDS_FILE), deduped.map((row) => JSON.stringify(row)).join("\n") + "\n", "utf8");
+}
+/** All records for one name, newest last. */
+async function profileRunsForName(reg, name) {
+	return (await readRecords(reg)).filter((row) => row.name === name);
+}
+/** The best revision of a name by the same documented heuristic as the graph
+*  registry: delivered beats failed, then cheaper (tokens, then iterations),
+*  then most recent. This is the answer to "which prompt revision is winning?"
+*  — and every alternative is a controlled diff away (versions never overwrite). */
+function pickBestProfile(records) {
+	const delivered = records.filter((row) => row.outcome.kind === "delivered");
+	if (delivered.length === 0) return void 0;
+	const better = (a, b) => {
+		const aTokens = a.cost.tokens ?? Number.POSITIVE_INFINITY;
+		const bTokens = b.cost.tokens ?? Number.POSITIVE_INFINITY;
+		if (aTokens !== bTokens) return aTokens < bTokens ? a : b;
+		const aIter = a.cost.iterations ?? Number.POSITIVE_INFINITY;
+		const bIter = b.cost.iterations ?? Number.POSITIVE_INFINITY;
+		if (aIter !== bIter) return aIter < bIter ? a : b;
+		return a.finishedAt >= b.finishedAt ? a : b;
+	};
+	return delivered.reduce((best, row) => better(best, row) === best ? best : row);
+}
+/** Load a stored profile revision by digest (for replaying the winning revision). */
+async function loadProfile(reg, digest) {
+	try {
+		return JSON.parse(await readFile(join(reg.root, PROFILES_DIR, `${digest}.json`), "utf8"));
+	} catch {
+		return;
+	}
+}
+/** The winning revision of a name, ready to mount. */
+async function bestProfileFor(reg, name) {
+	const best = pickBestProfile(await profileRunsForName(reg, name));
+	if (!best) return void 0;
+	const profile = await loadProfile(reg, best.profileDigest);
+	return profile ? {
+		profile,
+		record: best
+	} : void 0;
+}
+//#endregion
 //#region src/runtime/supervise/sql-run-context.ts
 /**
 * A cross-machine run context on the existing autocommit SqlAdapter. Reuse the same database,
@@ -8530,6 +8824,6 @@ function tail(s) {
 	return s.slice(-400);
 }
 //#endregion
-export { flatWidenGate as $, runStrategyEvolution as A, sentinelCompletion as At, runBenchmark as B, McpSpawnFault as Bt, analyzeTrace as C, declaredCheckDeliverable as Ct, chatTransportExecutor as D, runIsolatedCheck as Dt, runCoderChecks as E, readDeclaredCheck as Et, strategyAuthorSystemPrompt as F, renderLeaderboardMarkdown as Ft, runPersonified as G, envKeyProvider as Gt, equalKOnCost as H, materializeLocalMcp as Ht, SandboxRunAbortError as I, renderLeaderboardSvg as It, registerShape as J, resolveSecretEnv as Jt, builtinShapes as K, mcpSecretEnvMetadataKey as Kt, openSandboxRun as L, renderPairwiseMarkdown as Lt, assertStrategyContract as M, leaderboard as Mt, authorStrategy as N, pairwiseSignificance as Nt, chatWorkerSeam as O, completionAuthorizes as Ot, strategyAuthorContract as P, renderLeaderboardHtml as Pt, fanout as Q, createS3PrivateCasStore as R, SqlRunOwnershipError as Rt, withUntrackedArtifacts as S, checkProgramDigest as St, patchDelivered as T, declaredCheckJudge as Tt, trajectoryReport as U, createMcpEnvironment as Ut, createPrivateCasArtifactPort as V, connectStdioMcp as Vt, definePersona as W, sanitizeMcpToolSchema as Wt, InMemoryCorpus as X, createTangleSandboxExactProcessProvider as Xt, FileCorpus as Y, secretEnvOfMcpServer as Yt, renderCorpusToInstructions as Z, VERIFY_TAIL_CHARS as _, inlineSandboxClient as _t, localShell as a, widen as at, settledWorkerOut as b, superviseDispatch as bt, createVerifierEnvironment as c, createScopeAnalyst as ct, harvestSurfaceDiffs as d, inProcessSandboxClient as dt, loopUntil as et, analystsFromRegistry as f, HarvestError as ft, NOTE_MAX_CHARS as g, localSandboxClient as gt, EVIDENCE_MAX_CHARS as h, resolveSandboxClient as ht, jjWorkspace as i, verify as it, strategyTournament as j, stopSentinel as jt, createChatSessionStore as k, deterministicCompletion as kt, boxSurfaceReader as l, registryScopeAnalyst as lt, worktreeFanout as m, defineLeaderboard as mt, makeFinding$1 as n, pipeline as nt, runInWorkspace as o, assertTraceDerivedFindings as ot, failuresAnalyst as p, harvestCorpus as pt, createShapeRegistry as q, resolveMcpServerLaunch as qt, gitWorkspace as r, selectValidWinner as rt, createWaterfallCollector as s, buildSteerContext as st, computeFindingId$1 as t, panel as tt, fsSurfaceReader as u, observationFromRegistry as ut, closingWorkerNote as v, loopCampaignDispatch as vt, createFencedSqlRunContext as w, declaredCheckDigest as wt, copyUntrackedIntoClone as x, assertDeclaredCheck as xt, composeWorkerEvidence as y, loopDispatch as yt, printBenchmarkReport as z, openSqlRunStore as zt };
+export { builtinShapes as $, mcpSecretEnvMetadataKey as $t, recordProfileRun as A, declaredCheckDeliverable as At, authorStrategy as B, pairwiseSignificance as Bt, analyzeTrace as C, localSandboxClient as Ct, pickBestProfile as D, superviseDispatch as Dt, loadProfile as E, loopDispatch as Et, chatWorkerSeam as F, completionAuthorizes as Ft, createS3PrivateCasStore as G, SqlRunOwnershipError as Gt, strategyAuthorSystemPrompt as H, renderLeaderboardMarkdown as Ht, createChatSessionStore as I, deterministicCompletion as It, createPrivateCasArtifactPort as J, connectStdioMcp as Jt, printBenchmarkReport as K, openSqlRunStore as Kt, runStrategyEvolution as L, sentinelCompletion as Lt, runCoderChecks as M, declaredCheckJudge as Mt, graphDesignerExtraTools as N, readDeclaredCheck as Nt, profileRegistry as O, assertDeclaredCheck as Ot, chatTransportExecutor as P, runIsolatedCheck as Pt, runPersonified as Q, envKeyProvider as Qt, strategyTournament as R, stopSentinel as Rt, withUntrackedArtifacts as S, resolveSandboxClient as St, bestProfileFor as T, loopCampaignDispatch as Tt, SandboxRunAbortError as U, renderLeaderboardSvg as Ut, strategyAuthorContract as V, renderLeaderboardHtml as Vt, openSandboxRun as W, renderPairwiseMarkdown as Wt, trajectoryReport as X, createMcpEnvironment as Xt, equalKOnCost as Y, materializeLocalMcp as Yt, definePersona as Z, sanitizeMcpToolSchema as Zt, VERIFY_TAIL_CHARS as _, observationFromRegistry as _t, localShell as a, fanout as at, settledWorkerOut as b, harvestCorpus as bt, createVerifierEnvironment as c, panel as ct, harvestSurfaceDiffs as d, verify as dt, resolveMcpServerLaunch as en, createShapeRegistry as et, analystsFromRegistry as f, widen as ft, NOTE_MAX_CHARS as g, registryScopeAnalyst as gt, EVIDENCE_MAX_CHARS as h, createScopeAnalyst as ht, jjWorkspace as i, renderCorpusToInstructions as it, patchDelivered as j, declaredCheckDigest as jt, profileRunsForName as k, checkProgramDigest as kt, boxSurfaceReader as l, pipeline as lt, worktreeFanout as m, buildSteerContext as mt, makeFinding$1 as n, secretEnvOfMcpServer as nn, FileCorpus as nt, runInWorkspace as o, flatWidenGate as ot, failuresAnalyst as p, assertTraceDerivedFindings as pt, runBenchmark as q, McpSpawnFault as qt, gitWorkspace as r, createTangleSandboxExactProcessProvider as rn, InMemoryCorpus as rt, createWaterfallCollector as s, loopUntil as st, computeFindingId$1 as t, resolveSecretEnv as tn, registerShape as tt, fsSurfaceReader as u, selectValidWinner as ut, closingWorkerNote as v, inProcessSandboxClient as vt, createFencedSqlRunContext as w, inlineSandboxClient as wt, copyUntrackedIntoClone as x, defineLeaderboard as xt, composeWorkerEvidence as y, HarvestError as yt, assertStrategyContract as z, leaderboard as zt };
 
-//# sourceMappingURL=runtime-UG5tV_yf.js.map
+//# sourceMappingURL=runtime-6qzuLTJ7.js.map