@tangle-network/agent-runtime 0.339.0 → 0.342.0

package/dist/durable.js

@@ -1,14 +1,14 @@
 import { i as publishExclusiveDurableFile, o as writeAtomicDurableFile } from "./durable-file-gNI9ILAn.js";
-import { Di as contentAddress, Ei as detachedSnapshot, S as FileSpawnJournal, ar as isFiniteNumber, ir as failedItems, it as loadSpawnForest, qr as authoredProfileDigest } from "./supervisor-DHrUJhEZ.js";
+import { Hr as authoredProfileDigest, S as FileSpawnJournal, Si as contentAddress, ar as isFiniteNumber, at as loadSpawnForest, ir as failedItems, xi as detachedSnapshot } from "./supervisor-DUWcecAd.js";
 import { f as RuntimeRunStateError, m as ValidationError } from "./errors-DodWX-cb.js";
 import { t as isRecord } from "./record-value-B6bwJxLa.js";
-import { G as addSpend, J as cloneSpend, Z as errorMessage, pt as zeroSpend } from "./sandbox-profile-compat-BzVBFqrz.js";
+import { W as addSpend, X as errorMessage, ft as zeroSpend, q as cloneSpend } from "./sandbox-profile-compat-FN2kab2-.js";
 import { a as withPursuitContext, t as composeRuntimeHooks } from "./runtime-hooks-tXpAarhW.js";
 import { a as readCommittedJsonLines, n as isNoEntError, t as appendCommittedJsonLine } from "./jsonl-file-C9Kde_0Z.js";
-import { J as readRootStreamReceipt, a as superviseRootProfile, q as readRootStream, t as supervise } from "./supervise-qAwXmPtD.js";
-import { a as applyExactAgentProfileDiff } from "./profile-Dpei_Sq0.js";
+import { J as readRootStreamReceipt, a as superviseRootProfile, q as readRootStream, t as supervise } from "./supervise-DmOi7gll.js";
+import { a as applyExactAgentProfileDiff } from "./profile-CbMw5hAn.js";
 import { g as supervisorRunDir } from "./run-cancellation-C9oL62sW.js";
-import { i as superviseAgentGraph } from "./graph-CI9JXKqO.js";
+import { i as superviseAgentGraph } from "./graph-Ce-59ZXn.js";
 import { agentProfileSchema, canonicalAgentProfileDigest, canonicalCandidateDigest, canonicalCandidateJson, sha256Bytes } from "@tangle-network/agent-interface";
 import { createHash } from "node:crypto";
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
@@ -1217,6 +1217,269 @@ function reviewPage(version, score, verdict) {
 	].join("\n");
 }
 //#endregion
+//#region src/durable/pursuit-version-run.ts
+/**
+* One pursuit version chain at run time: running a version in its directory, reading it back
+* and checking it is this node's run, judging it, turning it into the kernel's cell result, and
+* reading the chain back from its search ledger.
+*/
+/** The execution identity a version's node and cell record. */
+function versionExecutionIdentity(pursuitId, taskRevision, nodeProfile) {
+	return {
+		model: {
+			provider: "agent-runtime",
+			alias: "supervisePursuit",
+			unknown: "a version runs every model its tree chose; the version's settle record names them"
+		},
+		agent: {
+			uri: `agent-profile:${pursuitId}`,
+			revision: canonicalAgentProfileDigest(nodeProfile)
+		},
+		benchmark: {
+			uri: `pursuit:${pursuitId}`,
+			revision: taskRevision
+		}
+	};
+}
+/** A version as the judge and `next` read it. */
+function versionOf(record, parent, settleDigest, result) {
+	return Object.freeze({
+		version: record.version,
+		nodeId: record.nodeId,
+		runId: record.runId,
+		runDir: record.runDir,
+		settleDigest,
+		result,
+		profile: record.profile,
+		...parent?.seal === void 0 ? {} : { parent: {
+			version: parent.version,
+			runId: parent.runId,
+			settleDigest: parent.seal.sha256
+		} },
+		...record.change === void 0 ? {} : { change: record.change }
+	});
+}
+function outcomeOf(settled, verdict) {
+	if (verdict.score === null) return {
+		status: "errored",
+		metrics: {},
+		error: {
+			code: "unscored",
+			message: `the judge could not score version ${settled.version}`,
+			retryable: false
+		}
+	};
+	if (settled.result.kind === "winner") return {
+		status: "passed",
+		score: verdict.score,
+		metrics: {}
+	};
+	return {
+		status: "failed",
+		score: verdict.score,
+		metrics: {},
+		failure: {
+			code: settled.result.reason,
+			message: `version ${settled.version} settled without a winner: ${settled.result.reason}`
+		}
+	};
+}
+var VersionChainRun = class {
+	ctx;
+	sealed = /* @__PURE__ */ new Map();
+	constructor(ctx) {
+		this.ctx = ctx;
+	}
+	/** Run a version if its directory holds no settle record, read it back, and judge it. */
+	async runCell(work) {
+		const chain = await this.versionsOf();
+		const record = chain.get(work.nodeId);
+		if (record?.profile == null) throw new RuntimeRunStateError(`version node ${work.nodeId} has no profile to run`);
+		const parent = record.parentNodeId === null ? void 0 : chain.get(record.parentNodeId);
+		if (parent !== void 0 && (parent.seal === void 0 || parent.profile === null)) throw new RuntimeRunStateError(`version ${record.version}'s parent has no sealed result`);
+		if (await readSettleRecord(record.runDir) === void 0) {
+			const signal = AbortSignal.any([work.signal, this.ctx.expired]);
+			if (signal.aborted) throw new RuntimeRunStateError(`supervisePursuit versions: version ${record.version} was not started: ${errorMessage(signal.reason)}`);
+			await this.runVersion(record, parent, signal);
+		}
+		const { settled, byteLength } = await this.readVersion(record, parent);
+		const verdict = await this.judgeVersion(settled, work.signal);
+		return this.cellResult(settled, byteLength, verdict, work.lane);
+	}
+	/** Run one version: the first as the call's own run, a later one as a fork of its parent. */
+	async runVersion(record, parent, signal) {
+		const { profile, task, base, firstFork, runOne } = this.ctx;
+		if (parent === void 0 || record.change === void 0) {
+			await runOne(profile, task, {
+				...base,
+				runId: record.runId,
+				runDir: record.runDir,
+				...firstFork === void 0 ? {} : { fork: firstFork },
+				signal
+			});
+			return;
+		}
+		const fork = {
+			runDir: parent.runDir,
+			settleDigest: parent.seal.sha256,
+			change: record.change,
+			acceptUncertain: true
+		};
+		const check = parent.verdict?.check;
+		await runOne(parent.profile, task, {
+			...base,
+			...base.continuation !== void 0 && check !== void 0 ? { continuation: {
+				...base.continuation,
+				best: {
+					label: `v${parent.version}`,
+					verdict: check
+				}
+			} } : {},
+			runId: record.runId,
+			runDir: record.runDir,
+			fork,
+			signal
+		});
+	}
+	/**
+	* Read a settled version back and check it is this node's run: its root ran the node's profile
+	* and, for a fork, recorded the parent's seal and the change. A directory that holds another
+	* run is refused, never adopted.
+	*/
+	async readVersion(record, parent) {
+		const { base, firstFork, taskRevision } = this.ctx;
+		const { bytes, result } = await readSealed(record.runDir, record.version);
+		if (result.tree.root !== record.runId) throw new RuntimeRunStateError(`supervisePursuit versions: ${record.runDir} holds run '${result.tree.root}', not version ${record.version}'s '${record.runId}'`);
+		const root = (await new FileSpawnJournal(resolve(record.runDir, "spawn-journal.jsonl")).loadTree(record.runId))?.find((event) => event.kind === "spawned" && event.parent === void 0);
+		const ran = root?.identity?.profileDigest;
+		const expected = authoredProfileDigest(superviseRootProfile(record.profile, base.profileGuidance));
+		const ranTask = root?.identity?.taskDigest;
+		const correlation = root?.identity?.correlation;
+		const fork = parent !== void 0 ? {
+			settleDigest: parent.seal?.sha256,
+			changeId: record.change?.id
+		} : firstFork === void 0 ? void 0 : {
+			settleDigest: firstFork.settleDigest,
+			changeId: firstFork.change.id
+		};
+		const mismatch = [
+			ran !== expected ? `its root ran profile ${ran}, not ${expected}` : void 0,
+			ranTask !== taskRevision ? `its root ran task ${ranTask}, not ${taskRevision}` : void 0,
+			contentAddress(root?.budget) !== contentAddress(base.budget) ? "its root ran under another budget" : void 0,
+			fork !== void 0 && correlation?.forkParentSettleDigest !== fork.settleDigest ? `its root forked from seal ${correlation?.forkParentSettleDigest}, not ${fork.settleDigest}` : void 0,
+			fork !== void 0 && correlation?.forkProfileDiffId !== fork.changeId ? `its root applied change ${correlation?.forkProfileDiffId}, not ${fork.changeId}` : void 0
+		].filter((item) => item !== void 0);
+		if (mismatch.length > 0) throw new RuntimeRunStateError(`supervisePursuit versions: version ${record.version} at ${record.runDir} is not this chain's run: ${mismatch.join("; ")}`);
+		const settled = versionOf(record, parent, sha256Bytes(bytes), result);
+		this.sealed.set(settled.settleDigest, result);
+		return {
+			settled,
+			byteLength: bytes.byteLength
+		};
+	}
+	async judgeVersion(settled, signal) {
+		const { judge } = this.ctx;
+		const verdict = await judge.judge(settled, signal);
+		if (typeof verdict !== "object" || verdict === null) throw new ValidationError("supervisePursuit versions: the judge returned no verdict");
+		if (verdict.judgeDigest !== judge.digest) throw new ValidationError(`supervisePursuit versions: the verdict for version ${settled.version} carries ${String(verdict.judgeDigest)}, not the pinned judge ${judge.digest}`);
+		if (verdict.score !== null && !isFiniteNumber(verdict.score)) throw new ValidationError("supervisePursuit versions: a verdict score must be a finite number or null");
+		return JSON.parse(JSON.stringify(verdict));
+	}
+	cellResult(settled, byteLength, verdict, lane) {
+		const spent = settled.result.spentTotal;
+		const settlePath = resolve(settled.runDir, SETTLE_RECORD_FILE);
+		return {
+			outcome: outcomeOf(settled, verdict),
+			accounting: versionAccounting(spent),
+			identity: versionExecutionIdentity(this.ctx.pursuitId, this.ctx.taskRevision, settled.profile),
+			boxMinutes: isFiniteNumber(spent.boxMinutes) && spent.boxMinutesKnown !== false ? spent.boxMinutes : null,
+			wallMs: isFiniteNumber(spent.ms) ? Math.max(0, Math.round(spent.ms)) : null,
+			placement: {
+				lane,
+				boxId: null
+			},
+			traceRef: { unknown: `version ${settled.version} is run ${settled.runId}; the chain records no trace id` },
+			artifacts: [{
+				role: "settle-record",
+				uri: pathToFileURL(settlePath).href,
+				sha256: settled.settleDigest,
+				byteLength
+			}, this.ctx.recorder.blob("verdict", {
+				kind: "version-verdict",
+				version: settled.version,
+				runId: settled.runId,
+				verdict
+			})]
+		};
+	}
+	/** Every version whose latest settled cell carries a verdict, first first, each read back from
+	*  its sealed `result.json`. */
+	async judgedVersions(chain) {
+		const judged = [];
+		for (const record of chain.values()) {
+			if (record.seal === void 0 || record.verdict === void 0) continue;
+			const seal = record.seal.sha256;
+			let result = this.sealed.get(seal);
+			if (result === void 0) {
+				const read = await readSealed(record.runDir, record.version);
+				if (sha256Bytes(read.bytes) !== seal) throw new RuntimeRunStateError(`supervisePursuit versions: version ${record.version}'s result.json changed after it was judged`);
+				result = read.result;
+				this.sealed.set(seal, result);
+			}
+			const parent = record.parentNodeId === null ? void 0 : chain.get(record.parentNodeId);
+			judged.push(Object.freeze({
+				...versionOf(record, parent, seal, result),
+				verdict: record.verdict
+			}));
+		}
+		return judged;
+	}
+	/**
+	* Every node of the chain, in registration order, from the ledger. The state holds cells, not
+	* their events' artifacts, so each cell's seal and verdict are read from the ledger lines the
+	* state verified, through Eval's own line parser.
+	*/
+	async versionsOf() {
+		const { recorder, ledgerPath, searchId, runDir, runId } = this.ctx;
+		const state = await recorder.state();
+		const head = state.head?.sequence ?? -1;
+		const nodes = state.nodes().map((node) => ({
+			node,
+			cellId: state.cells({ nodeId: node.nodeId })[0]?.cellId,
+			diff: node.edgeIds[0] === void 0 ? void 0 : state.edge(node.edgeIds[0])?.diffs[0]
+		}));
+		const settledCells = /* @__PURE__ */ new Map();
+		const text = await readFile(ledgerPath, "utf8");
+		for (const [index, line] of text.split("\n").entries()) {
+			if (line.length === 0) continue;
+			const entry = parseSearchLedgerLine(line, searchId, {
+				path: ledgerPath,
+				line: index + 1
+			});
+			if (entry.sequence > head) break;
+			if (entry.event.kind === "cell-settled") settledCells.set(entry.event.cellId, entry.event);
+		}
+		const chain = /* @__PURE__ */ new Map();
+		for (const { node, cellId, diff } of nodes) {
+			const settled = cellId === void 0 ? void 0 : settledCells.get(cellId);
+			const artifact = (role) => settled?.artifacts.find((candidate) => candidate.role === role);
+			const seal = artifact("settle-record");
+			const verdict = artifact("verdict");
+			chain.set(node.nodeId, {
+				nodeId: node.nodeId,
+				version: node.ordinal + 1,
+				...versionRun(runDir, runId, node.ordinal + 1),
+				profile: loadNode(recorder, node).profile,
+				parentNodeId: node.primaryParentId,
+				...diff === void 0 || "unknown" in diff ? {} : { change: recorder.readBlob(diff).diffs[0] },
+				...seal === void 0 ? {} : { seal },
+				...verdict === void 0 ? {} : { verdict: recorder.readBlob(verdict).verdict }
+			});
+		}
+		return chain;
+	}
+};
+//#endregion
 //#region src/durable/pursuit-versions.ts
 /**
 * The pursuit version chain, on Eval's search kernel (`runSearch`).
@@ -1287,9 +1550,8 @@ const MAX_TIMER_MS = 2147483647;
 /** 9999-12-31T23:59:59.999Z: the latest instant the ledger's four-digit-year timestamps hold, so
 *  a deadline such as `Number.MAX_SAFE_INTEGER` means no deadline rather than an invalid date. */
 const LATEST_DEADLINE_MS = 0xe677d21fdbff;
-/** Run a version chain. `supervisePursuit` calls this when `versions` is set. */
-async function runPursuitVersions(profile, task, opts, runOne) {
-	const { versions, fork: firstFork, signal: callerSignal, ...base } = opts;
+/** Refuse a chain call that no version could satisfy, before any compute. */
+function assertChainCall(versions, base) {
 	assertPursuitVersions(versions);
 	for (const key of [
 		"journal",
@@ -1298,8 +1560,14 @@ async function runPursuitVersions(profile, task, opts, runOne) {
 		"steerDir"
 	]) if (base[key] !== void 0) throw new ValidationError(`supervisePursuit versions: ${key} names one run, and a version chain has one per version; omit it`);
 	if (versions.next === "review-of-best" && base.continuation?.profile.review === void 0) throw new ValidationError("supervisePursuit versions: next 'review-of-best' needs continuation.profile.review, the words the next version reads about its review");
-	const { judge, stop } = versions;
+	const { stop } = versions;
 	if (base.budget.maxUsd !== void 0 && base.budget.maxUsd > stop.maxUsd) throw new ValidationError(`supervisePursuit versions: budget.maxUsd ${base.budget.maxUsd} is above stop.maxUsd ${stop.maxUsd}, so no version could start`);
+}
+/** Run a version chain. `supervisePursuit` calls this when `versions` is set. */
+async function runPursuitVersions(profile, task, opts, runOne) {
+	const { versions, fork: firstFork, signal: callerSignal, ...base } = opts;
+	assertChainCall(versions, base);
+	const { judge, stop } = versions;
 	const next = versions.next === "review-of-best" ? reviewOfBest(base.runId ?? "supervise", base.continuation?.profile.review ?? "") : versions.next;
 	const now = base.now ?? Date.now;
 	const pursuitId = base.pursuitId.trim();
@@ -1311,33 +1579,98 @@ async function runPursuitVersions(profile, task, opts, runOne) {
 	if (await exists(retired)) throw new ValidationError(`supervisePursuit versions: ${retired} holds a chain in the retired versions.jsonl format; finish it on the agent-runtime release that wrote it, or start a new chain in another runDir`);
 	const firstProfile = jsonProfile(firstFork === void 0 ? profile : applyExactAgentProfileDiff(profile, firstFork.change, "supervisePursuit versions"));
 	const taskRevision = pursuitValueDigest(task, "task");
-	const identity = (nodeProfile) => ({
-		model: {
-			provider: "agent-runtime",
-			alias: "supervisePursuit",
-			unknown: "a version runs every model its tree chose; the version's settle record names them"
-		},
-		agent: {
-			uri: `agent-profile:${pursuitId}`,
-			revision: canonicalAgentProfileDigest(nodeProfile)
-		},
-		benchmark: {
-			uri: `pursuit:${pursuitId}`,
-			revision: taskRevision
-		}
-	});
 	const ledger = openSearchLedger({
 		path: ledgerPath,
 		searchId
 	});
-	const deadline = (await ledger.state()).header?.budget.deadline ?? new Date(Math.min(now() - settledElapsed(await readSettleRecord(runDir)) + stop.deadlineMs, LATEST_DEADLINE_MS)).toISOString();
-	const failureLimit = stop.identicalFailures ?? DEFAULT_IDENTICAL_FAILURES;
+	const deadline = await chainDeadline((await ledger.state()).header, now, runDir, stop);
 	const policy = incumbent({
 		patience: stop.patience,
 		...stop.minImprovement === void 0 ? {} : { minImprovement: stop.minImprovement }
 	});
 	const allocation = uniform();
-	const recorder = await SearchRecorder.open({
+	const recorder = await openVersionRecorder({
+		ledger,
+		now,
+		pursuitId,
+		taskRevision,
+		judge,
+		stop,
+		policy,
+		allocation,
+		deadline,
+		firstProfile
+	});
+	const clock = armChainDeadline(deadline, now);
+	const chain = new VersionChainRun({
+		profile,
+		task,
+		base,
+		firstFork,
+		runOne,
+		judge,
+		recorder,
+		expired: clock.signal,
+		pursuitId,
+		runDir,
+		runId,
+		ledgerPath,
+		searchId,
+		taskRevision
+	});
+	const failureLimit = stop.identicalFailures ?? DEFAULT_IDENTICAL_FAILURES;
+	try {
+		const closed = await runSearch({
+			recorder,
+			root: {
+				profile: firstProfile,
+				refusal: null
+			},
+			codec: versionCodec,
+			policy,
+			allocation,
+			proposer: versionProposer(versions.next, next, chain, failureLimit),
+			executor: versionExecutor(chain, base.budget.maxUsd),
+			admit: (node) => node.refusal,
+			...callerSignal === void 0 ? {} : { signal: callerSignal },
+			now
+		});
+		const judged = await chain.judgedVersions(await chain.versionsOf());
+		const failed = closed.reason === "converged" ? identicalFailureStreak(judged, failureLimit) : null;
+		const stopped = failed === null ? null : {
+			versions: failureLimit,
+			failure: failed
+		};
+		const best = judged.find((version) => version.nodeId === closed.leader);
+		if (best === void 0) throw new RuntimeRunStateError(`supervisePursuit versions: the chain in ${ledgerPath} closed (${closed.reason}) without a judged version to keep`);
+		const observerPath = resolve(best.runDir, "observer.jsonl");
+		return Object.freeze({
+			result: best.result,
+			pursuit: projectPursuit(await new FileObserverJournal(observerPath, pursuitId).read()),
+			observerPath,
+			settlePath: resolve(best.runDir, SETTLE_RECORD_FILE),
+			versions: Object.freeze({
+				ledgerPath,
+				searchId,
+				reason: closed.reason,
+				...stopped === null ? {} : { identicalFailures: stopped },
+				best: best.version,
+				versions: Object.freeze(judged),
+				spend: closed.state.audit.spend,
+				receipt: recorder.receipt({
+					producerId: "pursuit-versions",
+					runId
+				})
+			})
+		});
+	} finally {
+		clock.cancel();
+	}
+}
+/** Open the chain's search recorder: its subject, process revision, splits, policy and budget. */
+function openVersionRecorder(input) {
+	const { ledger, now, pursuitId, taskRevision, judge, stop, policy, allocation, deadline } = input;
+	return SearchRecorder.open({
 		ledger,
 		now
 	}, {
@@ -1390,8 +1723,21 @@ async function runPursuitVersions(profile, task, opts, runOne) {
 		},
 		containment: null,
 		derivedFrom: null,
-		identity: identity(firstProfile)
+		identity: versionExecutionIdentity(pursuitId, taskRevision, input.firstProfile)
 	});
+}
+/**
+* The chain's clock starts with its first version, or when the chain opened on a first version
+* that had already settled. A resumed chain keeps the deadline its ledger recorded.
+*/
+async function chainDeadline(opened, now, runDir, stop) {
+	return opened?.budget.deadline ?? new Date(Math.min(now() - settledElapsed(await readSettleRecord(runDir)) + stop.deadlineMs, LATEST_DEADLINE_MS)).toISOString();
+}
+/**
+* The chain's deadline aborts a running version. A timer longer than 2^31 - 1 ms fires at once
+* in Node, so a long chain re-arms in steps.
+*/
+function armChainDeadline(deadline, now) {
 	const deadlineAt = Date.parse(deadline);
 	const expired = new AbortController();
 	let timer;
@@ -1405,35 +1751,22 @@ async function runPursuitVersions(profile, task, opts, runOne) {
 		timer.unref?.();
 	};
 	arm();
-	const sealed = /* @__PURE__ */ new Map();
-	const codec = {
-		node(store, node) {
-			if (node.profile !== null) {
-				const artifact = store.blob("agent-profile", {
-					kind: "agent-profile",
-					profile: node.profile
-				});
-				return {
-					artifactDigest: canonicalAgentProfileDigest(node.profile),
-					artifact,
-					surfaces: [{
-						surfaceId: "profile",
-						kind: "agent-profile",
-						artifact
-					}]
-				};
-			}
-			const refused = {
-				kind: "unapplied-change",
-				parentDigest: node.parentDigest ?? null,
-				change: node.change ?? null
-			};
-			const artifact = store.blob("change", {
-				...refused,
-				refusal: node.refusal
+	return {
+		signal: expired.signal,
+		cancel() {
+			if (timer !== void 0) clearTimeout(timer);
+		}
+	};
+}
+const versionCodec = {
+	node(store, node) {
+		if (node.profile !== null) {
+			const artifact = store.blob("agent-profile", {
+				kind: "agent-profile",
+				profile: node.profile
 			});
 			return {
-				artifactDigest: canonicalCandidateDigest(refused),
+				artifactDigest: canonicalAgentProfileDigest(node.profile),
 				artifact,
 				surfaces: [{
 					surfaceId: "profile",
@@ -1441,24 +1774,44 @@ async function runPursuitVersions(profile, task, opts, runOne) {
 					artifact
 				}]
 			};
-		},
-		diff(store, parent, child) {
-			if (parent.profile === null || child.profile === null || child.change === void 0) return { unknown: "a refused change has no profile to diff" };
-			const from = canonicalAgentProfileDigest(parent.profile);
-			if (child.parentDigest !== from) return { unknown: "the change was written against another parent" };
-			return store.blob("diff", {
-				kind: "agent-profile-diff",
-				from,
-				to: canonicalAgentProfileDigest(child.profile),
-				diffs: [child.change]
-			});
-		},
-		load(store, node) {
-			return loadNode(store, node);
 		}
-	};
-	const executor = {
-		lanes: () => [base.budget.maxUsd === void 0 ? {
+		const refused = {
+			kind: "unapplied-change",
+			parentDigest: node.parentDigest ?? null,
+			change: node.change ?? null
+		};
+		const artifact = store.blob("change", {
+			...refused,
+			refusal: node.refusal
+		});
+		return {
+			artifactDigest: canonicalCandidateDigest(refused),
+			artifact,
+			surfaces: [{
+				surfaceId: "profile",
+				kind: "agent-profile",
+				artifact
+			}]
+		};
+	},
+	diff(store, parent, child) {
+		if (parent.profile === null || child.profile === null || child.change === void 0) return { unknown: "a refused change has no profile to diff" };
+		const from = canonicalAgentProfileDigest(parent.profile);
+		if (child.parentDigest !== from) return { unknown: "the change was written against another parent" };
+		return store.blob("diff", {
+			kind: "agent-profile-diff",
+			from,
+			to: canonicalAgentProfileDigest(child.profile),
+			diffs: [child.change]
+		});
+	},
+	load(store, node) {
+		return loadNode(store, node);
+	}
+};
+function versionExecutor(chain, maxUsd) {
+	return {
+		lanes: () => [maxUsd === void 0 ? {
 			name: LANE,
 			capacity: 1,
 			costCap: "estimate",
@@ -1467,31 +1820,22 @@ async function runPursuitVersions(profile, task, opts, runOne) {
 			name: LANE,
 			capacity: 1,
 			costCap: "hard",
-			cellUsd: base.budget.maxUsd
+			cellUsd: maxUsd
 		}],
 		place: () => LANE,
 		adopt: async () => null,
-		async run(work) {
-			const chain = await versionsOf();
-			const record = chain.get(work.nodeId);
-			if (record?.profile == null) throw new RuntimeRunStateError(`version node ${work.nodeId} has no profile to run`);
-			const parent = record.parentNodeId === null ? void 0 : chain.get(record.parentNodeId);
-			if (parent !== void 0 && (parent.seal === void 0 || parent.profile === null)) throw new RuntimeRunStateError(`version ${record.version}'s parent has no sealed result`);
-			if (await readSettleRecord(record.runDir) === void 0) {
-				const signal = AbortSignal.any([work.signal, expired.signal]);
-				if (signal.aborted) throw new RuntimeRunStateError(`supervisePursuit versions: version ${record.version} was not started: ${errorMessage(signal.reason)}`);
-				await runVersion(record, parent, signal);
-			}
-			const { settled, byteLength } = await readVersion(record, parent);
-			return cellResult(settled, byteLength, await judgeVersion(settled, work.signal), work.lane);
-		}
+		run: (work) => chain.runCell(work)
 	};
+}
+/** The proposer: the caller's `next` (or the review of the kept version) as the one edge. */
+function versionProposer(nextOption, next, chain, failureLimit) {
+	const reviewing = nextOption === "review-of-best";
 	const proposerSource = {
-		uri: versions.next === "review-of-best" ? `${VERSION_CHAIN_URI}.review-of-best` : `${VERSION_CHAIN_URI}.next`,
-		revision: canonicalCandidateDigest({ next: versions.next === "review-of-best" ? "review-of-best" : Function.prototype.toString.call(versions.next) })
+		uri: reviewing ? `${VERSION_CHAIN_URI}.review-of-best` : `${VERSION_CHAIN_URI}.next`,
+		revision: canonicalCandidateDigest({ next: reviewing ? "review-of-best" : Function.prototype.toString.call(nextOption) })
 	};
-	const proposer = {
-		name: versions.next === "review-of-best" ? "review-of-best" : "next",
+	return {
+		name: reviewing ? "review-of-best" : "next",
 		kind: "optimizer",
 		source: proposerSource,
 		execution: {
@@ -1501,7 +1845,7 @@ async function runPursuitVersions(profile, task, opts, runOne) {
 		childrenPerProposal: 1,
 		async propose(request) {
 			const parent = request.parents[0];
-			const judged = await judgedVersions(await versionsOf());
+			const judged = await chain.judgedVersions(await chain.versionsOf());
 			const failure = identicalFailureStreak(judged, failureLimit);
 			if (failure !== null) return {
 				children: [],
@@ -1517,30 +1861,13 @@ async function runPursuitVersions(profile, task, opts, runOne) {
 			}, request.signal);
 			if (typeof returned?.id !== "string" || returned.id.trim().length === 0) throw new ValidationError("supervisePursuit versions: next must return a change with an id");
 			const change = JSON.parse(JSON.stringify(returned));
-			const parentDigest = canonicalAgentProfileDigest(parent.artifact.profile);
-			let child;
-			try {
-				child = {
-					profile: applyExactAgentProfileDiff(parent.artifact.profile, change, "supervisePursuit versions"),
-					change,
-					parentDigest,
-					refusal: null
-				};
-			} catch (error) {
-				child = {
-					profile: null,
-					change,
-					parentDigest,
-					refusal: errorMessage(error)
-				};
-			}
 			return {
 				children: [{
-					artifact: child,
+					artifact: childNode(parent.artifact.profile, change),
 					label: change.title ?? returned.id,
 					rationale: (change.source?.notes ?? []).join("\n")
 				}],
-				accounting: versions.next === "review-of-best" ? FREE : {
+				accounting: reviewing ? FREE : {
 					tokens: {
 						status: "unknown",
 						reason: "the caller's next reports no usage"
@@ -1554,259 +1881,25 @@ async function runPursuitVersions(profile, task, opts, runOne) {
 			};
 		}
 	};
+}
+/** The node a change makes, or the refused node when it does not apply to the parent. */
+function childNode(parentProfile, change) {
+	const parentDigest = canonicalAgentProfileDigest(parentProfile);
 	try {
-		const closed = await runSearch({
-			recorder,
-			root: {
-				profile: firstProfile,
-				refusal: null
-			},
-			codec,
-			policy,
-			allocation,
-			proposer,
-			executor,
-			admit: (node) => node.refusal,
-			...callerSignal === void 0 ? {} : { signal: callerSignal },
-			now
-		});
-		const judged = await judgedVersions(await versionsOf());
-		const failed = closed.reason === "converged" ? identicalFailureStreak(judged, failureLimit) : null;
-		const stopped = failed === null ? null : {
-			versions: failureLimit,
-			failure: failed
-		};
-		const best = judged.find((version) => version.nodeId === closed.leader);
-		if (best === void 0) throw new RuntimeRunStateError(`supervisePursuit versions: the chain in ${ledgerPath} closed (${closed.reason}) without a judged version to keep`);
-		const observerPath = resolve(best.runDir, "observer.jsonl");
-		return Object.freeze({
-			result: best.result,
-			pursuit: projectPursuit(await new FileObserverJournal(observerPath, pursuitId).read()),
-			observerPath,
-			settlePath: resolve(best.runDir, SETTLE_RECORD_FILE),
-			versions: Object.freeze({
-				ledgerPath,
-				searchId,
-				reason: closed.reason,
-				...stopped === null ? {} : { identicalFailures: stopped },
-				best: best.version,
-				versions: Object.freeze(judged),
-				spend: closed.state.audit.spend,
-				receipt: recorder.receipt({
-					producerId: "pursuit-versions",
-					runId
-				})
-			})
-		});
-	} finally {
-		if (timer !== void 0) clearTimeout(timer);
-	}
-	/** Run one version: the first as the call's own run, a later one as a fork of its parent. */
-	async function runVersion(record, parent, signal) {
-		if (parent === void 0 || record.change === void 0) {
-			await runOne(profile, task, {
-				...base,
-				runId: record.runId,
-				runDir: record.runDir,
-				...firstFork === void 0 ? {} : { fork: firstFork },
-				signal
-			});
-			return;
-		}
-		const fork = {
-			runDir: parent.runDir,
-			settleDigest: parent.seal.sha256,
-			change: record.change,
-			acceptUncertain: true
-		};
-		const check = parent.verdict?.check;
-		await runOne(parent.profile, task, {
-			...base,
-			...base.continuation !== void 0 && check !== void 0 ? { continuation: {
-				...base.continuation,
-				best: {
-					label: `v${parent.version}`,
-					verdict: check
-				}
-			} } : {},
-			runId: record.runId,
-			runDir: record.runDir,
-			fork,
-			signal
-		});
-	}
-	/**
-	* Read a settled version back and check it is this node's run: its root ran the node's profile
-	* and, for a fork, recorded the parent's seal and the change. A directory that holds another
-	* run is refused, never adopted.
-	*/
-	async function readVersion(record, parent) {
-		const { bytes, result } = await readSealed(record.runDir, record.version);
-		if (result.tree.root !== record.runId) throw new RuntimeRunStateError(`supervisePursuit versions: ${record.runDir} holds run '${result.tree.root}', not version ${record.version}'s '${record.runId}'`);
-		const root = (await new FileSpawnJournal(resolve(record.runDir, "spawn-journal.jsonl")).loadTree(record.runId))?.find((event) => event.kind === "spawned" && event.parent === void 0);
-		const ran = root?.identity?.profileDigest;
-		const expected = authoredProfileDigest(superviseRootProfile(record.profile, base.profileGuidance));
-		const ranTask = root?.identity?.taskDigest;
-		const correlation = root?.identity?.correlation;
-		const fork = parent !== void 0 ? {
-			settleDigest: parent.seal?.sha256,
-			changeId: record.change?.id
-		} : firstFork === void 0 ? void 0 : {
-			settleDigest: firstFork.settleDigest,
-			changeId: firstFork.change.id
-		};
-		const mismatch = [
-			ran !== expected ? `its root ran profile ${ran}, not ${expected}` : void 0,
-			ranTask !== taskRevision ? `its root ran task ${ranTask}, not ${taskRevision}` : void 0,
-			contentAddress(root?.budget) !== contentAddress(base.budget) ? "its root ran under another budget" : void 0,
-			fork !== void 0 && correlation?.forkParentSettleDigest !== fork.settleDigest ? `its root forked from seal ${correlation?.forkParentSettleDigest}, not ${fork.settleDigest}` : void 0,
-			fork !== void 0 && correlation?.forkProfileDiffId !== fork.changeId ? `its root applied change ${correlation?.forkProfileDiffId}, not ${fork.changeId}` : void 0
-		].filter((item) => item !== void 0);
-		if (mismatch.length > 0) throw new RuntimeRunStateError(`supervisePursuit versions: version ${record.version} at ${record.runDir} is not this chain's run: ${mismatch.join("; ")}`);
-		const settled = versionOf(record, parent, sha256Bytes(bytes), result);
-		sealed.set(settled.settleDigest, result);
 		return {
-			settled,
-			byteLength: bytes.byteLength
+			profile: applyExactAgentProfileDiff(parentProfile, change, "supervisePursuit versions"),
+			change,
+			parentDigest,
+			refusal: null
 		};
-	}
-	async function judgeVersion(settled, signal) {
-		const verdict = await judge.judge(settled, signal);
-		if (typeof verdict !== "object" || verdict === null) throw new ValidationError("supervisePursuit versions: the judge returned no verdict");
-		if (verdict.judgeDigest !== judge.digest) throw new ValidationError(`supervisePursuit versions: the verdict for version ${settled.version} carries ${String(verdict.judgeDigest)}, not the pinned judge ${judge.digest}`);
-		if (verdict.score !== null && !isFiniteNumber(verdict.score)) throw new ValidationError("supervisePursuit versions: a verdict score must be a finite number or null");
-		return JSON.parse(JSON.stringify(verdict));
-	}
-	function cellResult(settled, byteLength, verdict, lane) {
-		const spent = settled.result.spentTotal;
-		const settlePath = resolve(settled.runDir, SETTLE_RECORD_FILE);
+	} catch (error) {
 		return {
-			outcome: verdict.score === null ? {
-				status: "errored",
-				metrics: {},
-				error: {
-					code: "unscored",
-					message: `the judge could not score version ${settled.version}`,
-					retryable: false
-				}
-			} : settled.result.kind === "winner" ? {
-				status: "passed",
-				score: verdict.score,
-				metrics: {}
-			} : {
-				status: "failed",
-				score: verdict.score,
-				metrics: {},
-				failure: {
-					code: settled.result.reason,
-					message: `version ${settled.version} settled without a winner: ${settled.result.reason}`
-				}
-			},
-			accounting: versionAccounting(spent),
-			identity: identity(settled.profile),
-			boxMinutes: isFiniteNumber(spent.boxMinutes) && spent.boxMinutesKnown !== false ? spent.boxMinutes : null,
-			wallMs: isFiniteNumber(spent.ms) ? Math.max(0, Math.round(spent.ms)) : null,
-			placement: {
-				lane,
-				boxId: null
-			},
-			traceRef: { unknown: `version ${settled.version} is run ${settled.runId}; the chain records no trace id` },
-			artifacts: [{
-				role: "settle-record",
-				uri: pathToFileURL(settlePath).href,
-				sha256: settled.settleDigest,
-				byteLength
-			}, recorder.blob("verdict", {
-				kind: "version-verdict",
-				version: settled.version,
-				runId: settled.runId,
-				verdict
-			})]
+			profile: null,
+			change,
+			parentDigest,
+			refusal: errorMessage(error)
 		};
 	}
-	/** A version as the judge and `next` read it. */
-	function versionOf(record, parent, settleDigest, result) {
-		return Object.freeze({
-			version: record.version,
-			nodeId: record.nodeId,
-			runId: record.runId,
-			runDir: record.runDir,
-			settleDigest,
-			result,
-			profile: record.profile,
-			...parent?.seal === void 0 ? {} : { parent: {
-				version: parent.version,
-				runId: parent.runId,
-				settleDigest: parent.seal.sha256
-			} },
-			...record.change === void 0 ? {} : { change: record.change }
-		});
-	}
-	/** Every version whose latest settled cell carries a verdict, first first, each read back from
-	*  its sealed `result.json`. */
-	async function judgedVersions(chain) {
-		const judged = [];
-		for (const record of chain.values()) {
-			if (record.seal === void 0 || record.verdict === void 0) continue;
-			const seal = record.seal.sha256;
-			let result = sealed.get(seal);
-			if (result === void 0) {
-				const read = await readSealed(record.runDir, record.version);
-				if (sha256Bytes(read.bytes) !== seal) throw new RuntimeRunStateError(`supervisePursuit versions: version ${record.version}'s result.json changed after it was judged`);
-				result = read.result;
-				sealed.set(seal, result);
-			}
-			const parent = record.parentNodeId === null ? void 0 : chain.get(record.parentNodeId);
-			judged.push(Object.freeze({
-				...versionOf(record, parent, seal, result),
-				verdict: record.verdict
-			}));
-		}
-		return judged;
-	}
-	/**
-	* Every node of the chain, in registration order, from the ledger. The state holds cells, not
-	* their events' artifacts, so each cell's seal and verdict are read from the ledger lines the
-	* state verified, through Eval's own line parser.
-	*/
-	async function versionsOf() {
-		const state = await recorder.state();
-		const head = state.head?.sequence ?? -1;
-		const nodes = state.nodes().map((node) => ({
-			node,
-			cellId: state.cells({ nodeId: node.nodeId })[0]?.cellId,
-			diff: node.edgeIds[0] === void 0 ? void 0 : state.edge(node.edgeIds[0])?.diffs[0]
-		}));
-		const settledCells = /* @__PURE__ */ new Map();
-		const text = await readFile(ledgerPath, "utf8");
-		for (const [index, line] of text.split("\n").entries()) {
-			if (line.length === 0) continue;
-			const entry = parseSearchLedgerLine(line, searchId, {
-				path: ledgerPath,
-				line: index + 1
-			});
-			if (entry.sequence > head) break;
-			if (entry.event.kind === "cell-settled") settledCells.set(entry.event.cellId, entry.event);
-		}
-		const chain = /* @__PURE__ */ new Map();
-		for (const { node, cellId, diff } of nodes) {
-			const settled = cellId === void 0 ? void 0 : settledCells.get(cellId);
-			const artifact = (role) => settled?.artifacts.find((candidate) => candidate.role === role);
-			const seal = artifact("settle-record");
-			const verdict = artifact("verdict");
-			chain.set(node.nodeId, {
-				nodeId: node.nodeId,
-				version: node.ordinal + 1,
-				...versionRun(runDir, runId, node.ordinal + 1),
-				profile: loadNode(recorder, node).profile,
-				parentNodeId: node.primaryParentId,
-				...diff === void 0 || "unknown" in diff ? {} : { change: recorder.readBlob(diff).diffs[0] },
-				...seal === void 0 ? {} : { seal },
-				...verdict === void 0 ? {} : { verdict: recorder.readBlob(verdict).verdict }
-			});
-		}
-		return chain;
-	}
 }
 function canonicalStop(stop) {
 	return {