@tangle-network/agent-runtime 0.301.0 → 0.306.1

package/dist/{runtime-6VPSJVeg.js → runtime-B9eBIyws.js}

@@ -1,16 +1,16 @@
-import { $i as executableAgentProfileSnapshot, Bn as InMemoryResultBlobStore, Cn as readPromptOptions, Dt as rollingDispatch, Ea as stringifySafe, Ft as createWorktreeCliExecutor, G as settledToIteration, Gn as insideCursorNamespace, Hn as SpawnEventIndex, M as withDriverExecutor, Mi as prepareJsonlAppend, Mr as contentAddress, Mt as createExecutor, Ni as readCommittedJsonLines, Nn as createPushTraceSource, Nt as createExecutorRegistry, O as verdictFromJudgeScore, Pi as writeAllBytes, Qn as isTraceAnalysisStore, Sa as isAbortError, Sn as assertBoxlessPromptOptions, Ta as sleep, Tn as runBrainLoop, Un as assertContentAddress, Vn as InMemorySpawnJournal, Wn as encodeResultBlob, _ as CheckUnavailableError, _a as addSpend, _n as createSandboxLineage, ea as executableAgentSpecSnapshot, gn as runAgentRounds, ja as zeroSpend, mn as defaultSelectWinner, na as detachedSnapshot, pa as notifySandboxEventObserver, r as createSupervisor, ta as detachedFrozen, va as chargedTokens, vn as probeSandboxCapabilities, wa as randomSuffix, wn as routerBrain, xa as hasCompleteCacheBreakdown, ya as cloneSpend, za as armDeadlineTimer } from "./supervisor-DA_nvF-h.js";
+import { An as insideCursorNamespace, Bi as detachedSnapshot, Bn as isTraceAnalysisStore, D as verdictFromJudgeScore, Fn as prepareJsonlAppend, In as readCommittedJsonLines, Li as executableAgentProfileSnapshot, Ln as writeAllBytes, On as InMemoryResultBlobStore, Ri as executableAgentSpecSnapshot, St as createExecutorRegistry, W as settledToIteration, Zi as notifySandboxEventObserver, _ as CheckUnavailableError, an as runAgentRounds, br as contentAddress, dn as readPromptOptions, fn as routerBrain, gt as rollingDispatch, j as withDriverExecutor, kn as InMemorySpawnJournal, on as createSandboxLineage, pn as runBrainLoop, r as createSupervisor, rn as defaultSelectWinner, un as assertBoxlessPromptOptions, wt as createWorktreeCliExecutor, xt as createExecutor, zi as detachedFrozen } from "./supervisor-gCfG6K1-.js";
 import { i as ConfigError, m as ValidationError, n as AnalystError, s as PlannerError } from "./errors-DodWX-cb.js";
-import { Q as sample, X as refine, Z as runAgentic, c as reconcileInterruptedSearchCalls, ct as strategyAuthorMethod, et as ObservationError, it as profileChatClient, nt as observe, o as dedicatedLane, r as runtimeShipDecision, rt as renderReport, u as searchExecutor } from "./search-method-wTTS7mGG.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-2tWr38Qw.js";
+import { F as immutableCandidateValue, G as errorMessage, H as cloneSpend, J as isAbortError, K as fnv1a32Hex, L as sha256Bytes$1, Q as randomSuffix, V as chargedTokens, Y as isAsyncIterable, _t as armDeadlineTimer, j as canonicalCandidateDigest$1, nt as stringifySafe, q as hasCompleteCacheBreakdown, st as zeroSpend, tt as sleep, v as WorkspaceScanLimitError, x as captureMaterializedWorkspace, z as addSpend } from "./workspace-streams-ILw0eWZ0.js";
 import { c as profileModelExecutionSettings, i as concreteModelId, l as profileProviderModel, o as enforceTokenLimits, p as canonicalObservedModelParts, t as assertExecutableAgentProfile } from "./model-policy-DydyWTQg.js";
-import { F as sha256Bytes$1, N as immutableCandidateValue, g as WorkspaceScanLimitError, k as canonicalCandidateDigest$1, y as captureMaterializedWorkspace } from "./workspace-streams-D5gHJdTb.js";
 import { i as notifyRuntimeHookEvent } from "./runtime-hooks-tXpAarhW.js";
 import { i as redactProtectedValue, r as redactProtectedReason } from "./protected-redaction-DylCC_ot.js";
-import { O as foldCoordinationRecords, T as createInMemoryRunContext } from "./coordination-driver-vNrdQBSH.js";
-import { C as gateOnDeliverable, r as supervise, w as mapExecutorResult } from "./supervise-BJrEC2Mh.js";
+import { C as createInMemoryRunContext, E as foldCoordinationRecords } from "./coordination-driver-yj9HPXef.js";
+import { C as gateOnDeliverable, r as supervise, w as mapExecutorResult } from "./supervise-DllOHM4M.js";
 import "./run-layout-DSCWdbX2.js";
-import "./provision-supervisor-CS0fBIhp.js";
-import "./delegate-B-jFJcbW.js";
-import "./graph-Dwv_hQB_.js";
+import "./provision-supervisor-WxFEFQeJ.js";
+import "./delegate-KtrL9HWq.js";
+import "./graph-DcdyHbgf.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";
@@ -639,6 +639,10 @@ function inheritedStdioEnv(source = process.env) {
 	}
 	return env;
 }
+/** How long a stdin write failure waits for the server's exit, which reports its stderr. A
+* dying server closes within milliseconds; a live server that dropped its stdin is failed after
+* it, well inside any handshake timeout. */
+const STDIN_FAILURE_GRACE_MS = 250;
 /** A missing start binary / spawn fault: a SETUP bug, never a failed candidate.
 *  Graders (the serve verifier) must rethrow this instead of scoring it. */
 var McpSpawnFault = class extends Error {};
@@ -680,7 +684,8 @@ async function connectStdioMcp(spec) {
 		failAllPending(spawnFault);
 	});
 	child.stdin.on("error", (err) => {
-		failAllPending(new Error(redactReason(`writing to MCP server stdin failed: ${err.message}${stderrTail()}`)));
+		const fail = () => failAllPending(new Error(redactReason(`writing to MCP server stdin failed: ${err.message}${stderrTail()}`)));
+		setTimeout(fail, STDIN_FAILURE_GRACE_MS).unref();
 	});
 	child.on("close", (code, signal) => {
 		failAllPending(spawnFault ?? new Error(redactReason(`MCP server exited (code ${code}, signal ${signal}) before serving${stderrTail()}`)));
@@ -849,173 +854,6 @@ 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/durable/sql-run-store.ts
 /** Refuses a competing or stale SQL run owner before it can publish new work. */
 var SqlRunOwnershipError = class extends Error {
@@ -1276,88 +1114,6 @@ function wait(ms, signal) {
 	});
 }
 //#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.";
-function summarize(trace, maxLines) {
-	const lines = [];
-	for (const ev of trace) {
-		const e = ev;
-		const role = e.role;
-		if (role === "tool") lines.push(`RESULT ${String(e.content).slice(0, 200)}`);
-		else if (role === "assistant") {
-			const calls = e.tool_calls?.map((c) => `${c.function?.name}(${(c.function?.arguments ?? "").slice(0, 120)})`).join(", ");
-			lines.push(calls ? `CALL ${calls}` : `SAY ${String(e.content).slice(0, 160)}`);
-		} else if (role === "user") lines.push(`USER ${String(e.content).slice(0, 160)}`);
-	}
-	return lines.slice(-maxLines).join("\n");
-}
-const auditSchema = {
-	name: "intent_audit",
-	schema: {
-		type: "object",
-		additionalProperties: false,
-		required: [
-			"revealedIntent",
-			"verdict",
-			"evidence",
-			"recommendation",
-			"confidence"
-		],
-		properties: {
-			revealedIntent: { type: "string" },
-			verdict: {
-				type: "string",
-				enum: [
-					"aligned",
-					"drifting",
-					"diverged"
-				]
-			},
-			evidence: { type: "string" },
-			recommendation: {
-				type: "string",
-				enum: [
-					"continue",
-					"steer",
-					"abort"
-				]
-			},
-			steer: { type: "string" },
-			confidence: { type: "number" }
-		}
-	}
-};
-/** The route-rigor analyst: compare declared vs revealed vs user intent over a trajectory and return aligned / drifting / diverged with evidence and one recommended intervention. */
-async function auditIntent(input, opts) {
-	const res = await profileChatClient({
-		profile: opts.profile,
-		executor: opts.executor,
-		context: "intent auditor"
-	}).chat({
-		jsonSchema: auditSchema,
-		messages: [{
-			role: "user",
-			content: `DECLARED INTENT (the task):\n${input.declaredIntent}\n\n` + (input.userIntent ? `USER INTENT (the principal's actual goal):\n${input.userIntent}\n\n` : "") + (input.metaIntent ? `META-INTENT (what the whole run is for):\n${input.metaIntent}\n\n` : "") + `TRAJECTORY (in order):\n${summarize(input.trace, opts.maxTraceLines ?? 80)}\n\nAudit the route: revealed intent, verdict, evidence, one recommendation.`
-		}]
-	}, { ...opts.signal ? { signal: opts.signal } : {} });
-	let parsed;
-	try {
-		parsed = JSON.parse(res.content);
-	} catch {
-		throw new Error(`auditIntent: auditor returned non-JSON: ${res.content.slice(0, 200)}`);
-	}
-	if (!parsed.verdict || !parsed.recommendation) throw new Error(`auditIntent: missing verdict/recommendation: ${res.content.slice(0, 200)}`);
-	return {
-		revealedIntent: parsed.revealedIntent ?? "",
-		verdict: parsed.verdict,
-		evidence: parsed.evidence ?? "",
-		recommendation: parsed.recommendation,
-		...parsed.steer ? { steer: parsed.steer } : {},
-		confidence: typeof parsed.confidence === "number" ? parsed.confidence : .5
-	};
-}
-//#endregion
 //#region src/runtime/benchmark-report.ts
 /**
 * benchmark-report — turn a fleet of `RunRecord`s into a publishable, multi-axis benchmark report:
@@ -1736,12 +1492,7 @@ function completionAuthorizes(v, policy) {
 * emit it VERBATIM when it judges itself done. Unguessable enough that content never trips it.
 */
 function stopSentinel(seed) {
-	let h = 2166136261;
-	for (let i = 0; i < seed.length; i += 1) {
-		h ^= seed.charCodeAt(i);
-		h = Math.imul(h, 16777619);
-	}
-	return `<<<{{STOP:${(h >>> 0).toString(16).padStart(8, "0")}}}>>>`;
+	return `<<<{{STOP:${fnv1a32Hex(seed)}}}>>>`;
 }
 /**
 * Completion for a sandbox-agent node: done iff the latest output carries the node's stop
@@ -2368,9 +2119,17 @@ function assertDeclaredCheck(check, context) {
 	for (const name of check.secrets ?? []) if (!/^[A-Z_][A-Z0-9_]*$/u.test(name)) fail(`secret name ${JSON.stringify(name)} is not an env name`);
 	if (check.containers !== void 0 && typeof check.containers !== "boolean") fail("containers must be a boolean");
 }
-/** The canonical digest of a directory's files: the digest a record names a program by. */
+/**
+* A check program's files as a commit holds them: every file under the directory except Python
+* bytecode caches, which running the program writes and Git ignores. The digest a record names a
+* program by, and the bytes a check box receives, both come from this capture.
+*/
+function captureProgram(dir) {
+	return captureMaterializedWorkspace(dir, { skipPythonBytecode: true });
+}
+/** The canonical digest of a check program's files: the digest a record names a program by. */
 async function checkProgramDigest(dir) {
-	return canonicalCandidateDigest((await captureMaterializedWorkspace(dir)).manifest);
+	return canonicalCandidateDigest((await captureProgram(dir)).manifest);
 }
 /** The digest a version judge records: the program, the sealed cases, and how they are run. */
 function declaredCheckDigest(check) {
@@ -2538,7 +2297,7 @@ function verdictOf(outcome, pass) {
 /** Copy exactly the bytes whose digest was checked: the files are read once, verified, and those
 *  bytes are written, so a file changed after the check cannot reach the box. */
 async function copyVerified(from, digest, to, label) {
-	const captured = await captureMaterializedWorkspace(from);
+	const captured = await captureProgram(from);
 	const actual = canonicalCandidateDigest(captured.manifest);
 	if (actual !== digest) throw new ValidationError(`readDeclaredCheck: the ${label} at ${from} is ${actual}; the record names ${digest}`);
 	await writeFiles(captured.files, to);
@@ -2814,13 +2573,10 @@ function loopDispatch(opts) {
 * There are no sessions, no fs,
 * no fork (those degrade gracefully via the optional `SandboxClient` methods).
 */
-function isAsyncIterable$1(v) {
-	return typeof v === "object" && v !== null && Symbol.asyncIterator in v;
-}
 /** Drive a (possibly streaming) executor to its terminal artifact. */
 async function settle(exec, task, signal) {
 	const r = exec.execute(task, signal);
-	if (isAsyncIterable$1(r)) {
+	if (isAsyncIterable(r)) {
 		for await (const _ of r);
 		return exec.resultArtifact();
 	}
@@ -3538,9 +3294,6 @@ async function harvestCorpus(opts) {
 * picks it up. No cast is needed on the events (the union is structural); only
 * the box object is cast, once, inside this file.
 */
-function isAsyncIterable(v) {
-	return typeof v === "object" && v !== null && Symbol.asyncIterator in v;
-}
 /**
 * Adapt a single `onPrompt(prompt, ctx)` callback into a `SandboxClient` for
 * `runAgentRounds` / `openSandboxRun`. Returns a PROPERLY-TYPED `SandboxClient`: the
@@ -4769,8 +4522,8 @@ async function trajectoryReport(journal, blobs, root, options = {}) {
 		id: ev.id,
 		parent: ev.parent,
 		label: ev.label,
-		runtime: ev.kind === "waiting" ? "wait" : ev.runtime,
-		status: ev.kind === "waiting" ? "waiting" : "pending",
+		runtime: ev.runtime,
+		status: "pending",
 		ownSpend: zeroSpend(),
 		children: []
 	});
@@ -4780,11 +4533,6 @@ async function trajectoryReport(journal, blobs, root, options = {}) {
 			node.status = "cancelled";
 			continue;
 		}
-		if (ev.kind === "woken") {
-			node.status = ev.by === "cancelled" ? "cancelled" : "done";
-			node.outRef = ev.outRef;
-			continue;
-		}
 		node.status = ev.status === "done" ? "done" : "failed";
 		node.ownSpend = cloneSpend(ev.spent);
 		node.verdict = ev.verdict;
@@ -4909,8 +4657,7 @@ function countStatuses(reported) {
 		done: 0,
 		failed: 0,
 		cancelled: 0,
-		pending: 0,
-		waiting: 0
+		pending: 0
 	};
 	for (const node of reported) counts[node.status] += 1;
 	return counts;
@@ -4938,10 +4685,10 @@ function medianOf(values) {
 	if (sorted.length % 2 !== 0) return hi;
 	return (sorted[mid - 1] + hi) / 2;
 }
-/** Node-CREATION events — a spawned child or an armed wait-state. Both mint a node in the
-*  ordinal namespace; their settlements (`settled` / `woken`) close them in the cursor namespace. */
+/** Node-CREATION events: a spawned child mints a node in the ordinal namespace; its settlement
+*  closes it in the cursor namespace. */
 function isNodeCreation(ev) {
-	return ev.kind === "spawned" || ev.kind === "waiting";
+	return ev.kind === "spawned";
 }
 function isNode(node) {
 	return node !== void 0;
@@ -5365,6 +5112,31 @@ function createPrivateCasArtifactPort(root, namespace, options = {}) {
 		async read(ref) {
 			return readRef(ref);
 		},
+		async locate(object, options = {}) {
+			options.signal?.throwIfAborted();
+			const digest = object.sha256;
+			const hex = hexOf(digest);
+			const ref = {
+				locator: {
+					kind: "private-cas",
+					namespace,
+					digest
+				},
+				sha256: digest,
+				byteLength: object.byteLength
+			};
+			try {
+				await checkDirectories(join(store, hex.slice(0, 2)), false);
+				const local = await lstat(destination(digest));
+				if (local.isFile()) return local.size === object.byteLength ? ref : void 0;
+			} catch (error) {
+				if (!missing(error)) throw error;
+			}
+			if (durable === void 0) return void 0;
+			const receipt = await readLocal(join(receipts, hex));
+			if (receipt === void 0) return void 0;
+			return JSON.parse(Buffer.from(receipt).toString("utf8")).byteLength === object.byteLength ? ref : void 0;
+		},
 		offload
 	};
 	async function putBuffered(bytes, digest, sha, signal) {
@@ -5944,7 +5716,7 @@ async function openSandboxRun(client, options, deliverable) {
 	const now = options.now ?? Date.now;
 	const agentRunName = options.agentRun.name ?? options.agentRun.profile.name ?? "agent";
 	const promptOptions = readPromptOptions(options.promptOptions, "openSandboxRun: promptOptions");
-	const lineage = createSandboxLineage(client, await probeSandboxCapabilities(client), { ...options.maxConcurrency !== void 0 ? { maxConcurrency: options.maxConcurrency } : {} });
+	const lineage = createSandboxLineage(client, { ...options.maxConcurrency !== void 0 ? { maxConcurrency: options.maxConcurrency } : {} });
 	let handle;
 	let started = false;
 	let runStartedAt;
@@ -6175,9 +5947,6 @@ function hashText(value) {
 	}
 	return (hash >>> 0).toString(16).padStart(8, "0");
 }
-function errorMessage(error) {
-	return error instanceof Error ? error.message : String(error);
-}
 //#endregion
 //#region src/runtime/authored-code.ts
 /**
@@ -6811,7 +6580,8 @@ async function runStrategyEvolution(cfg) {
 	const { decision, reason } = runtimeShipDecision({
 		claim: claimResult,
 		verified: result.claimVerification.status === "verified",
-		accountingComplete: spend.unknownCostCells === 0 && spend.unknownCostOperations === 0,
+		cost: { accountingComplete: spend.unknownCostCells === 0 && spend.unknownCostOperations === 0 },
+		costCeiling: void 0,
 		lowerBound: shipped?.test?.interval[0] ?? null,
 		minimumLift: 0
 	});
@@ -8047,66 +7817,12 @@ function worktreeFanout(options) {
 	});
 }
 //#endregion
-//#region src/runtime/supervise-surface.ts
+//#region src/runtime/supervise-analysts.ts
 /**
-* 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()`.
+* Analyst lenses a supervised manager reads: the agent-eval trace-analyst registry adapted to the
+* `analysts` option (`analystsFromRegistry`), and `failuresAnalyst`, which reports the tests still
+* failing in the latest structured `run_tests` span and refuses to infer them from worker prose.
 */
-/** 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 trace = createPushTraceSource();
-	return {
-		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
-	};
-}
 /**
 * Adapt an `agent-eval` `AnalystRegistry` into the lens shape `supervise({ analysts })` takes.
 *
@@ -8256,124 +7972,6 @@ function allTestsPassed(report) {
 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) {
-			const guidance = typeof brief === "string" ? brief.trim() : brief ? JSON.stringify(brief) : "";
-			const attemptTask = guidance ? {
-				...task,
-				userPrompt: `${task.userPrompt}\n\n— Supervisor guidance for THIS attempt (incorporate it; do not just repeat a prior approach) —\n${guidance}`
-			} : task;
-			const r = await runAgentic({
-				surface: traced.surface,
-				task: attemptTask,
-				strategy,
-				budget: worker.budget ?? 1,
-				routerBaseUrl: worker.routerBaseUrl,
-				routerKey: worker.routerKey,
-				workerProfile: worker.profile,
-				...worker.analystProfile ? { analystProfile: worker.analystProfile } : {},
-				...worker.innerTurns !== void 0 ? { innerTurns: worker.innerTurns } : {}
-			});
-			const out = {
-				resolved: r.resolved,
-				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 ? [] : traced.failing()
-			};
-			const spent = {
-				iterations: r.completions,
-				tokens: r.tokens,
-				...r.tokensKnown ? {} : { tokensKnown: false },
-				usd: r.usd,
-				...r.usdKnown ? {} : { usdKnown: false },
-				ms: r.ms
-			};
-			artifact = {
-				outRef: `surface-worker:${task.id}:${r.shots}:${r.resolved ? "ok" : "no"}`,
-				out,
-				verdict: {
-					valid: r.resolved,
-					score: r.score
-				},
-				spent
-			};
-			return artifact;
-		},
-		traceSource: () => traced.traceSource,
-		teardown: () => Promise.resolve({ destroyed: true }),
-		resultArtifact() {
-			if (!artifact) throw new Error("surfaceWorkerExecutor: resultArtifact before execute");
-			return artifact;
-		}
-	};
-}
-/** Drive a team of agents (spawned + steered by `profile`) to solve a graded `AgenticSurface` task, and
-*  report the deployable outcome + the full conserved spend. This is `supervise()` configured for surfaces
-*  — there is no other entrypoint to learn. */
-async function superviseSurface(profile, task, opts) {
-	const strategy = opts.strategy ?? refine;
-	const innerTurns = opts.worker.innerTurns ?? 6;
-	const router = opts.router ?? {
-		routerBaseUrl: opts.worker.routerBaseUrl,
-		routerKey: opts.worker.routerKey
-	};
-	const budget = opts.budget ?? {
-		maxIterations: (innerTurns + 2) * 5 + 16,
-		maxTokens: 1e9
-	};
-	const workerMaxTokens = Math.max(1, Math.floor(budget.maxTokens / 8));
-	const makeWorkerAgent = (rawProfile) => {
-		const p = rawProfile ?? {};
-		return {
-			name: typeof p.name === "string" && p.name.length > 0 ? p.name : "surface-worker",
-			act: async () => "",
-			executorSpec: {
-				profile: rawProfile,
-				harness: null,
-				executor: surfaceWorkerExecutor(opts.surface, task, opts.worker, strategy)
-			}
-		};
-	};
-	const deliverable = {
-		describe: `resolve the surface task ${task.id} (every required check passes)`,
-		check: (out) => out?.resolved === true
-	};
-	const analysts = opts.analysts === null ? void 0 : opts.analysts ?? failuresAnalyst();
-	const result = await supervise(profile, task, {
-		makeWorkerAgent,
-		deliverable,
-		budget,
-		workerSlots: opts.workerSlots ?? 1,
-		perWorker: {
-			maxIterations: innerTurns + 2,
-			maxTokens: workerMaxTokens
-		},
-		router,
-		...analysts ? {
-			analysts,
-			analyzeOnSettle: analysts.kinds.map((k) => k.id)
-		} : {}
-	});
-	const out = result.kind === "winner" ? result.out : void 0;
-	const sp = result.spentTotal;
-	return {
-		resolved: out?.resolved ?? false,
-		score: out?.score ?? 0,
-		usd: sp.usd,
-		tokensIn: sp.tokens.input,
-		tokensOut: sp.tokens.output,
-		ms: sp.ms,
-		completions: sp.iterations
-	};
-}
 //#endregion
 //#region src/runtime/surface-diff.ts
 /**
@@ -8988,6 +8586,6 @@ function tail(s) {
 	return s.slice(-400);
 }
 //#endregion
-export { InMemoryCorpus as $, mcpSecretEnvMetadataKey as $t, chatTransportExecutor as A, runIsolatedCheck as At, openSandboxRun as B, renderPairwiseMarkdown as Bt, withUntrackedArtifacts as C, superviseDispatch as Ct, runCoderChecks as D, declaredCheckDigest as Dt, patchDelivered as E, declaredCheckDeliverable as Et, assertStrategyContract as F, leaderboard as Ft, equalKOnCost as G, SqlResultBlobStore as Gt, printBenchmarkReport as H, defaultAuditorInstruction as Ht, authorStrategy as I, pairwiseSignificance as It, runPersonified as J, connectStdioMcp as Jt, trajectoryReport as K, SqlSpawnJournal as Kt, strategyAuthorContract as L, renderLeaderboardHtml as Lt, createChatSessionStore as M, deterministicCompletion as Mt, runStrategyEvolution as N, sentinelCompletion as Nt, codeModeSupervisorTools as O, declaredCheckJudge as Ot, strategyTournament as P, stopSentinel as Pt, FileCorpus as Q, envKeyProvider as Qt, strategyAuthorSystemPrompt as R, renderLeaderboardMarkdown as Rt, copyUntrackedIntoClone as S, loopDispatch as St, createFencedSqlRunContext as T, checkProgramDigest as Tt, runBenchmark as U, SqlRunOwnershipError as Ut, createS3PrivateCasStore as V, auditIntent as Vt, createPrivateCasArtifactPort as W, openSqlRunStore as Wt, createShapeRegistry as X, createMcpEnvironment as Xt, builtinShapes as Y, materializeLocalMcp as Yt, registerShape as Z, sanitizeMcpToolSchema as Zt, NOTE_MAX_CHARS as _, defineLeaderboard as _t, localShell as a, pipeline as at, composeWorkerEvidence as b, inlineSandboxClient as bt, createVerifierEnvironment as c, widen as ct, harvestSurfaceDiffs as d, createScopeAnalyst as dt, resolveMcpServerLaunch as en, renderCorpusToInstructions as et, analystsFromRegistry as f, registryScopeAnalyst as ft, EVIDENCE_MAX_CHARS as g, harvestCorpus as gt, worktreeFanout as h, HarvestError as ht, jjWorkspace as i, panel as it, chatWorkerSeam as j, completionAuthorizes as jt, unsafeInProcessRunner as k, readDeclaredCheck as kt, boxSurfaceReader as l, assertTraceDerivedFindings as lt, superviseSurface as m, inProcessSandboxClient as mt, makeFinding$1 as n, secretEnvOfMcpServer as nn, flatWidenGate as nt, runInWorkspace as o, selectValidWinner as ot, failuresAnalyst as p, observationFromRegistry as pt, definePersona as q, McpSpawnFault as qt, gitWorkspace as r, createTangleSandboxExactProcessProvider as rn, loopUntil as rt, createWaterfallCollector as s, verify as st, computeFindingId$1 as t, resolveSecretEnv as tn, fanout as tt, fsSurfaceReader as u, buildSteerContext as ut, VERIFY_TAIL_CHARS as v, resolveSandboxClient as vt, analyzeTrace as w, assertDeclaredCheck as wt, settledWorkerOut as x, loopCampaignDispatch as xt, closingWorkerNote as y, localSandboxClient as yt, SandboxRunAbortError as z, renderLeaderboardSvg as zt };
+export { renderCorpusToInstructions as $, chatWorkerSeam as A, completionAuthorizes as At, createS3PrivateCasStore as B, SqlRunOwnershipError as Bt, analyzeTrace as C, assertDeclaredCheck as Ct, codeModeSupervisorTools as D, declaredCheckJudge as Dt, runCoderChecks as E, declaredCheckDigest as Et, authorStrategy as F, pairwiseSignificance as Ft, trajectoryReport as G, createMcpEnvironment as Gt, runBenchmark as H, McpSpawnFault as Ht, strategyAuthorContract as I, renderLeaderboardHtml as It, builtinShapes as J, mcpSecretEnvMetadataKey as Jt, definePersona as K, sanitizeMcpToolSchema as Kt, strategyAuthorSystemPrompt as L, renderLeaderboardMarkdown as Lt, runStrategyEvolution as M, sentinelCompletion as Mt, strategyTournament as N, stopSentinel as Nt, unsafeInProcessRunner as O, readDeclaredCheck as Ot, assertStrategyContract as P, leaderboard as Pt, InMemoryCorpus as Q, createTangleSandboxExactProcessProvider as Qt, SandboxRunAbortError as R, renderLeaderboardSvg as Rt, withUntrackedArtifacts as S, superviseDispatch as St, patchDelivered as T, declaredCheckDeliverable as Tt, createPrivateCasArtifactPort as U, connectStdioMcp as Ut, printBenchmarkReport as V, openSqlRunStore as Vt, equalKOnCost as W, materializeLocalMcp as Wt, registerShape as X, resolveSecretEnv as Xt, createShapeRegistry as Y, resolveMcpServerLaunch as Yt, FileCorpus as Z, secretEnvOfMcpServer as Zt, VERIFY_TAIL_CHARS as _, resolveSandboxClient as _t, localShell as a, selectValidWinner as at, settledWorkerOut as b, loopCampaignDispatch as bt, createVerifierEnvironment as c, assertTraceDerivedFindings as ct, harvestSurfaceDiffs as d, registryScopeAnalyst as dt, fanout as et, analystsFromRegistry as f, observationFromRegistry as ft, NOTE_MAX_CHARS as g, defineLeaderboard as gt, EVIDENCE_MAX_CHARS as h, harvestCorpus as ht, jjWorkspace as i, pipeline as it, createChatSessionStore as j, deterministicCompletion as jt, chatTransportExecutor as k, runIsolatedCheck as kt, boxSurfaceReader as l, buildSteerContext as lt, worktreeFanout as m, HarvestError as mt, makeFinding$1 as n, loopUntil as nt, runInWorkspace as o, verify as ot, failuresAnalyst as p, inProcessSandboxClient as pt, runPersonified as q, envKeyProvider as qt, gitWorkspace as r, panel as rt, createWaterfallCollector as s, widen as st, computeFindingId$1 as t, flatWidenGate as tt, fsSurfaceReader as u, createScopeAnalyst as ut, closingWorkerNote as v, localSandboxClient as vt, createFencedSqlRunContext as w, checkProgramDigest as wt, copyUntrackedIntoClone as x, loopDispatch as xt, composeWorkerEvidence as y, inlineSandboxClient as yt, openSandboxRun as z, renderPairwiseMarkdown as zt };
 
-//# sourceMappingURL=runtime-6VPSJVeg.js.map
+//# sourceMappingURL=runtime-B9eBIyws.js.map