@tangle-network/agent-runtime 0.266.0 → 0.271.0

package/dist/{runtime-hOLlAc1i.js → runtime-DVjIH1eo.js}

@@ -1,16 +1,16 @@
-import { $i as cloneSpend, An as routerBrain, Bn as sandboxClientAsProvider, Dt as insideCursorNamespace, En as probeSandboxCapabilities, Et as InMemorySpawnJournal, Fi as detachedFrozen, Fn as LEAF_CONTINUATION_TASK, Hn as unavailableSignalOfFailure, Hr as harnessInvocation, M as settledToIteration, Mn as canonicalObservedModelParts, Ni as executableAgentProfileSnapshot, On as assertBoxlessPromptOptions, Pi as executableAgentSpecSnapshot, Pt as isTraceAnalysisStore, Qi as chargedTokens, Sn as defaultSelectWinner, Tn as createSandboxLineage, Tt as InMemoryResultBlobStore, Un as createPushTraceSource, Vn as unavailablePauseMs, Zi as addSpend, _t as createExecutorRegistry, aa as sleep, b as withDriverExecutor, da as zeroSpend, dt as rollingDispatch, fi as prepareJsonlAppend, fr as contentAddress, gt as createExecutor, ia as randomSuffix, jn as runBrainLoop, kn as readPromptOptions, mi as writeAllBytes, na as isAbortError, oa as stringifySafe, pi as readCommittedJsonLines, qi as notifySandboxEventObserver, r as createSupervisor, ta as hasCompleteCacheBreakdown, wn as runAgentRounds, ya as armDeadlineTimer, yt as createWorktreeCliExecutor } from "./supervisor-B8UMAXya.js";
+import { At as insideCursorNamespace, Dn as runAgentRounds, Dt as SpawnEventIndex, Et as InMemorySpawnJournal, Fn as canonicalObservedModelParts, Gn as unavailableSignalOfFailure, Gr as harnessInvocation, Ii as executableAgentProfileSnapshot, Kn as createPushTraceSource, Li as executableAgentSpecSnapshot, Lt as isTraceAnalysisStore, M as settledToIteration, Mn as readPromptOptions, Nn as routerBrain, On as createSandboxLineage, Ot as assertContentAddress, Pn as runBrainLoop, Ri as detachedFrozen, Rn as LEAF_CONTINUATION_TASK, Sa as armDeadlineTimer, Tn as defaultSelectWinner, Tt as InMemoryResultBlobStore, Un as sandboxClientAsProvider, Wn as unavailablePauseMs, Xi as notifySandboxEventObserver, _i as writeAllBytes, _t as createExecutorRegistry, aa as isAbortError, b as withDriverExecutor, ca as sleep, dt as rollingDispatch, ea as addSpend, gi as readCommittedJsonLines, gt as createExecutor, hi as prepareJsonlAppend, hr as contentAddress, ia as hasCompleteCacheBreakdown, jn as assertBoxlessPromptOptions, kn as probeSandboxCapabilities, kt as encodeResultBlob, la as stringifySafe, ma as zeroSpend, na as cloneSpend, r as createSupervisor, sa as randomSuffix, ta as chargedTokens, yt as createWorktreeCliExecutor, zi as detachedSnapshot } from "./supervisor-Cvd5mf7x.js";
 import { m as ValidationError, n as AnalystError, s as PlannerError } from "./errors-DodWX-cb.js";
-import { E as profileChatClient, S as ObservationError, T as renderReport, b as sample, k as strategyAuthorMethod, v as refine, w as observe, x as sampleThenRefine, y as runAgentic } from "./structural-rollout-DV9YoQF6.js";
+import { E as profileChatClient, S as ObservationError, T as renderReport, b as sample, k as strategyAuthorMethod, v as refine, w as observe, x as sampleThenRefine, y as runAgentic } from "./structural-rollout-I92sIfNl.js";
 import { a as concreteProfileModel, c as profileModelExecutionSettings, i as concreteModelId, l as profileProviderModel, o as enforceTokenLimits, t as assertExecutableAgentProfile } from "./model-policy-BbSCSak0.js";
 import { C as canonicalCandidateDigest$1, D as immutableCandidateValue, k as sha256Bytes$1, m as captureMaterializedWorkspace } from "./workspace-archive-C9lgf77y.js";
 import { i as notifyRuntimeHookEvent } from "./runtime-hooks-tXpAarhW.js";
 import { i as redactProtectedValue, r as redactProtectedReason } from "./protected-redaction--F3v1oo8.js";
-import "./coordination-driver-DdZ-nh_4.js";
-import { C as gateOnDeliverable, r as supervise, w as mapExecutorResult } from "./supervise--njTtSL3.js";
+import "./coordination-driver-iBGMKDvB.js";
+import { C as gateOnDeliverable, r as supervise, w as mapExecutorResult } from "./supervise-DJ_1i9vj.js";
 import "./run-layout-vwd4SwX_.js";
-import "./provision-supervisor-Bf_bPaCv.js";
-import "./delegate-Ajx_PVyu.js";
-import "./graph-CK50N9vG.js";
+import "./provision-supervisor-Cy8pqE95.js";
+import "./delegate-DOqUvaIz.js";
+import "./graph-DnMcepkN.js";
 import { agentProfileSchema, canonicalAgentProfileDigest, canonicalCandidateDigest, 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";
@@ -848,6 +848,173 @@ async function materializeLocalMcp(profile, opts = {}) {
 	};
 }
 //#endregion
+//#region src/durable/spawn-journal-sql.ts
+/**
+* SQL-backed durable stores for supervised runs — `SqlSpawnJournal` and `SqlResultBlobStore`
+* over the same minimal statement seam `SqlConversationJournal` uses (D1, postgres, sqlite,
+* libSQL; positional `?` placeholders). This closes the orchestration-durability gap recorded in
+* `conformance/durability/STATUS.md`: until now the spawn layer was file-only.
+*
+* Parity with the JSONL file stores, by construction:
+*   • same corruption guards — `beginTree` precedes events (enforced by the schema: an event row
+*     names a tree row), duplicate cursor seqs and duplicate materialization receipts are refused
+*     by the same `SpawnEventIndex` the file journal replays through, on both append and load;
+*   • same content-address law for blobs — a `put` whose ref does not hash to the artifact is
+*     refused, a re-put of the same ref asserts the identical bytes;
+*   • load order is insertion order (`INTEGER PRIMARY KEY AUTOINCREMENT`), the SQL analogue of
+*     the JSONL append-only spine.
+*
+* Durability note: this suite and its process-kill test run against `node:sqlite`, whose
+* autocommit commits survive SIGKILL (process death, not OS crash). A deployment that must
+* survive power loss sets its driver's synchronous mode (`PRAGMA synchronous=FULL` + WAL) at the
+* adapter; agent-runtime takes no opinion.
+*
+* @experimental — draft: cross-process ownership is single-writer by convention (the same
+* limitation `createFileRunContext` documents); a machine-visible ownership lease is follow-up.
+*/
+const TREES_DDL = (table) => `
+  CREATE TABLE IF NOT EXISTS ${table}_trees (
+    root TEXT PRIMARY KEY,
+    begun_at TEXT NOT NULL
+  )
+`;
+const EVENTS_DDL = (table) => `
+  CREATE TABLE IF NOT EXISTS ${table}_events (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    root TEXT NOT NULL REFERENCES ${table}_trees (root),
+    body TEXT NOT NULL
+  )
+`;
+const BLOBS_DDL = (table) => `
+  CREATE TABLE IF NOT EXISTS ${table}_blobs (
+    ref TEXT PRIMARY KEY,
+    body TEXT NOT NULL
+  )
+`;
+/** SQL-backed `SpawnJournal`. One row per event; insertion order is replay order. */
+var SqlSpawnJournal = class {
+	db;
+	table;
+	cache = /* @__PURE__ */ new Map();
+	appendTail = Promise.resolve();
+	constructor(db, table = "runtime_spawn_journal") {
+		this.db = db;
+		this.table = table;
+	}
+	/** Create the journal's tables if absent. Idempotent. */
+	async migrate() {
+		await this.db.exec(TREES_DDL(this.table));
+		await this.db.exec(EVENTS_DDL(this.table));
+	}
+	async loadTree(root) {
+		if ((await this.db.query(`SELECT begun_at FROM ${this.table}_trees WHERE root = ?`, [root])).length === 0) return void 0;
+		const rows = await this.db.query(`SELECT id, body FROM ${this.table}_events WHERE root = ? ORDER BY id`, [root]);
+		const index = new SpawnEventIndex(root);
+		const events = [];
+		for (const row of rows) {
+			const event = JSON.parse(row.body);
+			index.assert(event);
+			index.add(event);
+			events.push(event);
+		}
+		return events;
+	}
+	async beginTree(root, at) {
+		return this.serializeAppend(async () => {
+			await this.ensureMigrated();
+			const existing = await this.db.query(`SELECT begun_at FROM ${this.table}_trees WHERE root = ?`, [root]);
+			if (existing.length > 0) {
+				const begunAt = existing[0]?.begun_at;
+				if (begunAt !== at) throw new Error(`spawn tree '${root}' already begun in SQL at ${begunAt}; refusing to overwrite with ${at}`);
+				return;
+			}
+			await this.db.exec(`INSERT INTO ${this.table}_trees (root, begun_at) VALUES (?, ?)`, [root, at]);
+			this.cache.set(root, {
+				maxId: 0,
+				index: new SpawnEventIndex(root)
+			});
+		});
+	}
+	async appendEvent(root, ev) {
+		const event = detachedSnapshot(ev, "spawn event");
+		return this.serializeAppend(async () => {
+			await this.ensureMigrated();
+			const state = await this.validationIndex(root);
+			state.index.assert(event);
+			if ((await this.db.exec(`INSERT INTO ${this.table}_events (root, body) VALUES (?, ?)`, [root, JSON.stringify(event)])).rowsAffected !== 1) throw new Error(`spawn journal SQL: append of an event for tree '${root}' affected no rows`);
+			state.index.add(event);
+			state.maxId = await this.maxEventId(root);
+		});
+	}
+	async validationIndex(root) {
+		if ((await this.db.query(`SELECT begun_at FROM ${this.table}_trees WHERE root = ?`, [root])).length === 0) throw new Error(`appendEvent called for unknown spawn tree '${root}'; call beginTree first`);
+		const max = await this.maxEventId(root);
+		const cached = this.cache.get(root);
+		if (cached && cached.maxId === max) return cached;
+		const index = new SpawnEventIndex(root);
+		if (max > 0) {
+			const rows = await this.db.query(`SELECT body FROM ${this.table}_events WHERE root = ? ORDER BY id`, [root]);
+			for (const row of rows) {
+				const event = JSON.parse(row.body);
+				index.assert(event);
+				index.add(event);
+			}
+		}
+		const state = {
+			maxId: max,
+			index
+		};
+		this.cache.set(root, state);
+		return state;
+	}
+	async maxEventId(root) {
+		return (await this.db.query(`SELECT MAX(id) AS max FROM ${this.table}_events WHERE root = ?`, [root]))[0]?.max ?? 0;
+	}
+	migrated = false;
+	async ensureMigrated() {
+		if (this.migrated) return;
+		await this.migrate();
+		this.migrated = true;
+	}
+	serializeAppend(operation) {
+		const append = this.appendTail.then(operation);
+		this.appendTail = append.catch(() => void 0);
+		return append;
+	}
+};
+/** SQL-backed `ResultBlobStore`. One content-addressed row per settled result. */
+var SqlResultBlobStore = class {
+	db;
+	table;
+	migrated = false;
+	constructor(db, table = "runtime_result_blobs") {
+		this.db = db;
+		this.table = table;
+	}
+	async migrate() {
+		await this.db.exec(BLOBS_DDL(this.table));
+	}
+	async put(outRef, artifact) {
+		await this.ensureMigrated();
+		const { text } = encodeResultBlob(outRef, artifact);
+		if ((await this.db.exec(`INSERT OR IGNORE INTO ${this.table}_blobs (ref, body) VALUES (?, ?)`, [outRef, text])).rowsAffected === 1) return;
+		assertContentAddress(outRef, await this.get(outRef));
+	}
+	async get(outRef) {
+		await this.ensureMigrated();
+		const rows = await this.db.query(`SELECT body FROM ${this.table}_blobs WHERE ref = ?`, [outRef]);
+		if (rows.length === 0) return void 0;
+		const artifact = JSON.parse(rows[0]?.body ?? "null");
+		assertContentAddress(outRef, artifact);
+		return artifact;
+	}
+	async ensureMigrated() {
+		if (this.migrated) return;
+		await this.migrate();
+		this.migrated = true;
+	}
+};
+//#endregion
 //#region src/runtime/audit-intent.ts
 /** Default system instruction for intent-auditor agents: diagnose diverged/drifting trajectories. */
 const defaultAuditorInstruction = "You audit whether an AI agent is on the RIGHT ROUTE — not whether it works hard, but whether its actions serve the stated intents. Infer the REVEALED intent from the action pattern (what the trajectory is actually optimizing). Compare against the declared task intent, the user intent when given, and the meta-intent when given. Flawless execution down the wrong route is DIVERGED. Busy-work that neither advances nor harms is DRIFTING. Judge only from the trajectory — be specific about which actions ground your verdict. Recommend abort only when continuing cannot serve the intent.";
@@ -5438,6 +5605,7 @@ async function createWorker(lease, root, createProfile, placement) {
 		const timeoutMs = options?.timeoutMs ?? 0;
 		const turnDeadline = timeoutMs > 0 ? Date.now() + timeoutMs : void 0;
 		let sessionId;
+		const subagents = /* @__PURE__ */ new Set();
 		let refusalsInARow = 0;
 		let prompt = message;
 		for (let invocation = 1;; invocation += 1) {
@@ -5465,12 +5633,14 @@ async function createWorker(lease, root, createProfile, placement) {
 				running = void 0;
 			}
 			sessionId = parsed.sessionId() ?? sessionId;
+			for (const child of parsed.subagentSessionIds()) subagents.add(child);
 			const failure = parsed.failure(exitCode, errorText);
 			const refusal = failure === void 0 || unavailablePause === false || signal?.aborted ? void 0 : unavailableSignalOfFailure({ error: failure });
 			refusalsInARow = parsed.madeProgress() ? 1 : refusalsInARow + 1;
 			const pauseMs = refusal === void 0 || unavailablePause === false ? 0 : unavailablePauseMs(refusalsInARow, unavailablePause);
 			if (refusal === void 0 || turnDeadline !== void 0 && Date.now() + pauseMs >= turnDeadline) {
 				if (sessionId !== void 0) await exportSession(run, collect, paths, sessionId);
+				for (const child of subagents) if (child !== sessionId) await exportSession(run, collect, paths, child);
 				signal?.throwIfAborted();
 				yield* parsed.finish(exitCode, errorText, invocation);
 				return;
@@ -5494,7 +5664,7 @@ async function createWorker(lease, root, createProfile, placement) {
 			if (released) throw new ValidationError("sharedBoxPlacement: this worker was released");
 			if (turnActive) throw new ValidationError("sharedBoxPlacement: a worker runs one turn at a time");
 			const turnProfile = options?.backend?.profile === void 0 ? createProfile : agentProfileSchema.parse(options.backend.profile);
-			if (canonicalCandidateDigest(turnProfile) !== canonicalCandidateDigest(createProfile) && sharedBoxRefusal(turnProfile) !== void 0) throw new ValidationError(`sharedBoxPlacement: ${sharedBoxRefusal(turnProfile)}`);
+			if (canonicalAgentProfileDigest(turnProfile) !== canonicalAgentProfileDigest(createProfile) && sharedBoxRefusal(turnProfile) !== void 0) throw new ValidationError(`sharedBoxPlacement: ${sharedBoxRefusal(turnProfile)}`);
 			if (options?.backend?.type !== void 0 && options.backend.type !== HARNESS) throw new ValidationError(`sharedBoxPlacement: backend ${options.backend.type} is not ${HARNESS}`);
 			turnActive = true;
 			try {
@@ -5688,7 +5858,7 @@ async function materializeWorker(box, paths, profile, task, turnModel, clientNam
 * `opencode export` writes the same session as JSON.
 */
 async function exportSession(run, collect, paths, sessionId) {
-	if (!/^[A-Za-z0-9_-]+$/u.test(sessionId)) return;
+	if (!SESSION_ID.test(sessionId)) return;
 	await collect(await run([
 		"/bin/sh",
 		"-c",
@@ -5698,6 +5868,29 @@ async function exportSession(run, collect, paths, sessionId) {
 		`${paths.home}/.local/share/opencode/export/${sessionId}.json`
 	], DEFAULT_EXEC_TIMEOUT_MS));
 }
+const SESSION_ID = /^[A-Za-z0-9_-]+$/u;
+/** A subagent's session id in a `task` result (`<task id="ses_…">`) or failure (`task_id: ses_…`). */
+const TASK_SESSION = /(?:<task id="|task_id: )(ses_[A-Za-z0-9]+)/u;
+/**
+* The session a harness subagent ran in, named by its parent's `task` tool part.
+*
+* opencode starts each subagent in a child session and refuses a nested one unless the
+* configuration raises `subagent_depth` above 1, so under the default the parent's parts name
+* every subagent session. A running part carries the id in `state.metadata.sessionId`; a finished
+* one also carries it in its output, and a failed one in its error.
+*/
+function subagentSessionOf(part) {
+	if (part.type !== "tool" || part.tool !== "task") return void 0;
+	const state = part.state;
+	if (state === void 0 || state === null || typeof state !== "object") return void 0;
+	const { metadata, output, error } = state;
+	const named = metadata !== null && typeof metadata === "object" ? metadata.sessionId : void 0;
+	if (typeof named === "string" && SESSION_ID.test(named)) return named;
+	for (const text of [output, error]) {
+		const match = typeof text === "string" ? TASK_SESSION.exec(text) : null;
+		if (match !== null) return match[1];
+	}
+}
 /**
 * Translate opencode's JSON event lines into the Sandbox event wire the provider executor reads.
 *
@@ -5711,6 +5904,7 @@ function createOpencodeEventParser(model) {
 	let sessionId;
 	let finalMessageId;
 	const textByMessage = /* @__PURE__ */ new Map();
+	const subagentSessions = /* @__PURE__ */ new Set();
 	const errors = [];
 	let malformed = 0;
 	let spentTokens = false;
@@ -5723,6 +5917,7 @@ function createOpencodeEventParser(model) {
 	};
 	return {
 		sessionId: () => sessionId,
+		subagentSessionIds: () => [...subagentSessions],
 		/** Why this run failed, or `undefined` when it answered. */
 		failure: failureOf,
 		/** Whether this run spent any model tokens before it ended. */
@@ -5747,6 +5942,8 @@ function createOpencodeEventParser(model) {
 			}
 			const part = event.part;
 			if (part === void 0 || part === null || typeof part !== "object") return;
+			const subagent = subagentSessionOf(part);
+			if (subagent !== void 0) subagentSessions.add(subagent);
 			yield {
 				type: "message.part.updated",
 				data: { part }
@@ -7001,6 +7198,31 @@ function signalPass(value, required) {
 	return !required;
 }
 //#endregion
+//#region src/runtime/supervise/run-context-sql.ts
+/**
+*
+* `createSqlRunContext` — the SQL-backed durable bundle a `createSupervisor().run` (or a
+* `runGraph`/`supervise` call that accepts injected stores) needs: a `SqlSpawnJournal`, a
+* `SqlResultBlobStore` (both over one `SqlStatements` seam — the same adapter shape
+* `SqlConversationJournal` takes), and a fresh `createExecutorRegistry()`, with `resume: true`
+* so spreading the context makes the run loadTree-first.
+*
+* The SQL analogue of `createFileRunContext`: where that bundle owns a directory, this one owns
+* tables in a database the caller already operates. The durable coordination side-log and
+* cancellation observers remain file-based behind `runDir`; a SQL coordination log is follow-up.
+*
+* @experimental
+*/
+/** Build a durable run context over one SQL statement seam. Tables are created on first use. */
+function createSqlRunContext(db) {
+	return {
+		journal: new SqlSpawnJournal(db),
+		blobs: new SqlResultBlobStore(db),
+		executors: createExecutorRegistry(),
+		resume: true
+	};
+}
+//#endregion
 //#region src/runtime/supervise/trajectory-recorder.ts
 /**
 *
@@ -8284,6 +8506,6 @@ function tail(s) {
 	return s.slice(-400);
 }
 //#endregion
-export { definePersona as $, createTangleSandboxExactProcessProvider as $t, chatWorkerSeam as A, superviseDispatch as At, DEFAULT_SHARED_BOX_RESOURCES as B, renderPairwiseMarkdown as Bt, withUntrackedArtifacts as C, harvestCorpus as Ct, codeModeSupervisorTools as D, inlineSandboxClient as Dt, runCoderChecks as E, localSandboxClient as Et, selectChampion as F, leaderboard as Ft, sharedWorkerClientName as G, materializeLocalMcp as Gt, ROUTER_CLIENT_HEADER as H, defaultAuditorInstruction as Ht, assertStrategyContract as I, pairwiseSignificance as It, printBenchmarkReport as J, envKeyProvider as Jt, SandboxRunAbortError as K, createMcpEnvironment as Kt, authorStrategy as L, renderLeaderboardHtml as Lt, discriminatingMeans as M, deterministicCompletion as Mt, pickChampion as N, sentinelCompletion as Nt, unsafeInProcessRunner as O, loopCampaignDispatch as Ot, runStrategyEvolution as P, stopSentinel as Pt, trajectoryReport as Q, secretEnvOfMcpServer as Qt, strategyAuthorContract as R, renderLeaderboardMarkdown as Rt, copyUntrackedIntoClone as S, HarvestError as St, patchDelivered as T, resolveSandboxClient as Tt, sharedBoxPlacement as U, McpSpawnFault as Ut, DEFAULT_SHARED_BOX_WORKERS as V, auditIntent as Vt, sharedBoxRefusal as W, connectStdioMcp as Wt, promotionGate as X, resolveMcpServerLaunch as Xt, runBenchmark as Y, mcpSecretEnvMetadataKey as Yt, equalKOnCost as Z, resolveSecretEnv as Zt, NOTE_MAX_CHARS as _, createScopeAnalyst as _t, localShell as a, InMemoryCorpus as at, composeWorkerEvidence as b, runIsolatedCheck as bt, createVerifierEnvironment as c, flatWidenGate as ct, harvestSurfaceDiffs as d, pipeline as dt, runPersonified as et, analystsFromRegistry as f, selectValidWinner as ft, EVIDENCE_MAX_CHARS as g, buildSteerContext as gt, worktreeFanout as h, assertTraceDerivedFindings as ht, jjWorkspace as i, FileCorpus as it, createChatSessionStore as j, completionAuthorizes as jt, chatTransportExecutor as k, loopDispatch as kt, boxSurfaceReader as l, loopUntil as lt, superviseSurface as m, widen as mt, makeFinding$1 as n, createShapeRegistry as nt, runInWorkspace as o, renderCorpusToInstructions as ot, failuresAnalyst as p, verify as pt, openSandboxRun as q, sanitizeMcpToolSchema as qt, gitWorkspace as r, registerShape as rt, createWaterfallCollector as s, fanout as st, computeFindingId$1 as t, builtinShapes as tt, fsSurfaceReader as u, panel as ut, VERIFY_TAIL_CHARS as v, registryScopeAnalyst as vt, analyzeTrace as w, defineLeaderboard as wt, settledWorkerOut as x, inProcessSandboxClient as xt, closingWorkerNote as y, observationFromRegistry as yt, strategyAuthorSystemPrompt as z, renderLeaderboardSvg as zt };
+export { trajectoryReport as $, resolveMcpServerLaunch as $t, chatTransportExecutor as A, loopDispatch as At, strategyAuthorSystemPrompt as B, renderLeaderboardSvg as Bt, withUntrackedArtifacts as C, HarvestError as Ct, runCoderChecks as D, localSandboxClient as Dt, patchDelivered as E, resolveSandboxClient as Et, runStrategyEvolution as F, stopSentinel as Ft, sharedBoxRefusal as G, SqlSpawnJournal as Gt, DEFAULT_SHARED_BOX_WORKERS as H, auditIntent as Ht, selectChampion as I, leaderboard as It, openSandboxRun as J, materializeLocalMcp as Jt, sharedWorkerClientName as K, McpSpawnFault as Kt, assertStrategyContract as L, pairwiseSignificance as Lt, createChatSessionStore as M, completionAuthorizes as Mt, discriminatingMeans as N, deterministicCompletion as Nt, codeModeSupervisorTools as O, inlineSandboxClient as Ot, pickChampion as P, sentinelCompletion as Pt, equalKOnCost as Q, mcpSecretEnvMetadataKey as Qt, authorStrategy as R, renderLeaderboardHtml as Rt, copyUntrackedIntoClone as S, inProcessSandboxClient as St, createSqlRunContext as T, defineLeaderboard as Tt, ROUTER_CLIENT_HEADER as U, defaultAuditorInstruction as Ut, DEFAULT_SHARED_BOX_RESOURCES as V, renderPairwiseMarkdown as Vt, sharedBoxPlacement as W, SqlResultBlobStore as Wt, runBenchmark as X, sanitizeMcpToolSchema as Xt, printBenchmarkReport as Y, createMcpEnvironment as Yt, promotionGate as Z, envKeyProvider as Zt, NOTE_MAX_CHARS as _, buildSteerContext as _t, localShell as a, FileCorpus as at, composeWorkerEvidence as b, observationFromRegistry as bt, createVerifierEnvironment as c, fanout as ct, harvestSurfaceDiffs as d, panel as dt, resolveSecretEnv as en, definePersona as et, analystsFromRegistry as f, pipeline as ft, EVIDENCE_MAX_CHARS as g, assertTraceDerivedFindings as gt, worktreeFanout as h, widen as ht, jjWorkspace as i, registerShape as it, chatWorkerSeam as j, superviseDispatch as jt, unsafeInProcessRunner as k, loopCampaignDispatch as kt, boxSurfaceReader as l, flatWidenGate as lt, superviseSurface as m, verify as mt, makeFinding$1 as n, createTangleSandboxExactProcessProvider as nn, builtinShapes as nt, runInWorkspace as o, InMemoryCorpus as ot, failuresAnalyst as p, selectValidWinner as pt, SandboxRunAbortError as q, connectStdioMcp as qt, gitWorkspace as r, createShapeRegistry as rt, createWaterfallCollector as s, renderCorpusToInstructions as st, computeFindingId$1 as t, secretEnvOfMcpServer as tn, runPersonified as tt, fsSurfaceReader as u, loopUntil as ut, VERIFY_TAIL_CHARS as v, createScopeAnalyst as vt, analyzeTrace as w, harvestCorpus as wt, settledWorkerOut as x, runIsolatedCheck as xt, closingWorkerNote as y, registryScopeAnalyst as yt, strategyAuthorContract as z, renderLeaderboardMarkdown as zt };
 
-//# sourceMappingURL=runtime-hOLlAc1i.js.map
+//# sourceMappingURL=runtime-DVjIH1eo.js.map