@tangle-network/agent-runtime 0.280.0 → 0.281.1

package/dist/durable.js

@@ -1,16 +1,18 @@
-import { $i as detachedSnapshot, Ai as readCommittedJsonLines, Di as isNoEntError, E as failedItems, Kt as loadSpawnForest, Oa as zeroSpend, Oi as parseCommittedJsonLines, Or as contentAddress, Pi as authoredProfileDigest, ga as cloneSpend, ji as writeAllBytes, ki as prepareJsonlAppend, ma as addSpend, zt as FileSpawnJournal } from "./supervisor-BXXjVCbW.js";
+import { $i as detachedSnapshot, Ai as readCommittedJsonLines, Bt as FileSpawnJournal, E as failedItems, Oa as zeroSpend, Oi as isNoEntError, Pi as authoredProfileDigest, ga as cloneSpend, ji as writeAllBytes, ki as prepareJsonlAppend, kr as contentAddress, ma as addSpend, qt as loadSpawnForest } from "./supervisor-UXgaPisu.js";
 import { f as RuntimeRunStateError, m as ValidationError } from "./errors-DodWX-cb.js";
 import { a as withPursuitContext, t as composeRuntimeHooks } from "./runtime-hooks-tXpAarhW.js";
 import { a as writeAtomicDurableFile, r as publishExclusiveDurableFile } from "./durable-file-DWQA4ooo.js";
 import { i as applyExactAgentProfileDiff } from "./profile-D3eXNBQV.js";
-import { _ as readRootStream, g as ROOT_STREAM_FILE, i as superviseRootProfile, r as supervise, v as readRootStreamReceipt } from "./supervise-CWrLq2-F.js";
+import { _ as readRootStream, g as ROOT_STREAM_FILE, i as superviseRootProfile, r as supervise, v as readRootStreamReceipt } from "./supervise-zt91I62x.js";
 import { h as supervisorRunDir } from "./run-layout-vwd4SwX_.js";
-import { canonicalCandidateDigest, canonicalCandidateJson, sha256Bytes } from "@tangle-network/agent-interface";
+import { agentProfileSchema, canonicalAgentProfileDigest, canonicalCandidateDigest, canonicalCandidateJson, sha256Bytes } from "@tangle-network/agent-interface";
 import { createHash } from "node:crypto";
 import { execFile } from "node:child_process";
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
-import { mkdir, open, readFile, realpath, rmdir, unlink } from "node:fs/promises";
+import { access, mkdir, readFile, realpath, rmdir, unlink } from "node:fs/promises";
 import { promisify } from "node:util";
+import { SearchRecorder, developmentClaim, incumbent, openSearchLedger, parseSearchLedgerLine, runSearch, uniform } from "@tangle-network/agent-eval/campaign";
+import { pathToFileURL } from "node:url";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
 //#region src/durable/chat-engine.ts
 const encoder = new TextEncoder();
@@ -928,6 +930,10 @@ async function readSettleRecord(runDir) {
 		if (isNoEntError(error)) return void 0;
 		throw error;
 	}
+	return parseSettleRecord(text, path);
+}
+/** Parse settle-record bytes already read, so a caller hashes and parses the same bytes. */
+function parseSettleRecord(text, path) {
 	let parsed;
 	try {
 		parsed = JSON.parse(text);
@@ -959,6 +965,789 @@ async function readFailureRecord(runDir) {
 	return parsed;
 }
 //#endregion
+//#region src/durable/pursuit-versions.ts
+/**
+* The pursuit version chain, on Eval's search kernel (`runSearch`).
+*
+* A version is a search node: the exact AgentProfile it executes, content-addressed by
+* `canonicalAgentProfileDigest`. Every later version is an edge from the version the chain keeps,
+* whose diff is the one change `next` returned, and one cell: a `supervisePursuit` run of the
+* version, forked from its parent's sealed `result.json`, then scored by the outside judge. The
+* policy is the kernel's hill climb, `incumbent({ patience, minImprovement })`. The search ledger
+* at `<runDir>.search/ledger.jsonl` is the chain's only record and its only checkpoint: a call on
+* a closed chain reads it back, and a call on an open chain continues it.
+*/
+/** Where `'review-of-best'` mounts a review: `inputs/review/version-<n>.md`. One review lives in
+*  a profile at a time. */
+const REVIEW_DIR = "inputs/review/";
+/** The chain's directory beside the first version's: the ledger and its content blobs. */
+function pursuitVersionsLedgerPath(runDir) {
+	return resolve(`${resolve(runDir.trim())}.search`, "ledger.jsonl");
+}
+/**
+* Validate a `versions` option before any compute. The same check runs inside `supervisePursuit`;
+* a caller that records the option as data can run it at preflight.
+*/
+function assertPursuitVersions(versions) {
+	const fail = (message) => {
+		throw new ValidationError(`supervisePursuit versions: ${message}`);
+	};
+	if (typeof versions !== "object" || versions === null) fail("must be an object");
+	const option = versions;
+	const extra = Object.keys(option).filter((key) => ![
+		"judge",
+		"next",
+		"stop"
+	].includes(key));
+	if (extra.length > 0) fail(`unknown fields: ${extra.join(", ")}`);
+	const { judge, next, stop } = option;
+	if (typeof judge !== "object" || judge === null || typeof judge.judge !== "function") fail("judge must be a VersionJudge, such as declaredCheckJudge(check)");
+	else if (!isSha256(judge.digest)) fail("judge.digest must be a sha256 digest (sha256:<64 hex>)");
+	if (next !== "review-of-best" && typeof next !== "function") fail("next must be a function or 'review-of-best'");
+	if (typeof stop !== "object" || stop === null) fail("stop must be an object");
+	const rule = stop;
+	const known = /* @__PURE__ */ new Set([
+		"patience",
+		"maxVersions",
+		"maxUsd",
+		"deadlineMs",
+		"minImprovement"
+	]);
+	const unknown = Object.keys(rule).filter((key) => !known.has(key));
+	if (unknown.length > 0) fail(`stop has unknown fields: ${unknown.join(", ")}`);
+	for (const key of ["patience", "maxVersions"]) if (!Number.isInteger(rule[key]) || rule[key] < 1) fail(`stop.${key} must be an integer of at least 1`);
+	for (const key of ["maxUsd", "deadlineMs"]) if (!isFiniteNumber(rule[key]) || rule[key] <= 0) fail(`stop.${key} must be a finite number above 0`);
+	if (rule.minImprovement !== void 0 && (!isFiniteNumber(rule.minImprovement) || rule.minImprovement < 0)) fail("stop.minImprovement must be a finite number of at least 0");
+}
+/** Every rule the chain adds to the kernel's. Its digest, with the stop rule, is the process
+*  revision the ledger records, so a changed rule or stop rule is a different search. */
+const VERSION_CHAIN_DEFINITION = {
+	name: "agent-runtime.pursuit-versions.2026-09",
+	node: "the exact AgentProfile a version executes, content-addressed by canonicalAgentProfileDigest; a change that does not apply is a node addressed by its parent digest and change, and refused",
+	edge: "one change from the kept version, stored as its Interface profile diff",
+	cell: "one supervisePursuit run of the version on the pursuit task, forked from its parent sealed result.json, then scored by the outside judge; a settled version directory is read back after its root identity and fork seal are checked",
+	outcome: "a scored winner passes; a scored no-winner fails with its reason; an unscored version is a final error; a run that throws fails the call and leaves its cell open",
+	deadline: "the chain deadline aborts a running version; its judge still runs",
+	directories: "version n runs at <runDir>.v<n> with run id <runId>.v<n>; version 1 at <runDir>"
+};
+const VERSION_CHAIN_URI = "npm:@tangle-network/agent-runtime#supervisePursuit.versions";
+/** The pursuit task's one train task. */
+const TASK_ID = "pursuit";
+const LANE = "in-process";
+/** The longest delay Node's setTimeout honors. */
+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;
+	assertPursuitVersions(versions);
+	for (const key of [
+		"journal",
+		"blobs",
+		"rootHandle",
+		"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;
+	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`);
+	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();
+	const runDir = resolve(base.runDir.trim());
+	const runId = base.runId ?? "supervise";
+	const ledgerPath = pursuitVersionsLedgerPath(runDir);
+	const searchId = `versions:${pursuitId}:${runId}`;
+	const retired = resolve(`${runDir}.versions`, "versions.jsonl");
+	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 = digestOf(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 policy = incumbent({
+		patience: stop.patience,
+		...stop.minImprovement === void 0 ? {} : { minImprovement: stop.minImprovement }
+	});
+	const allocation = uniform();
+	const recorder = await SearchRecorder.open({
+		ledger,
+		now
+	}, {
+		subject: pursuitId,
+		process: {
+			name: "pursuit-versions",
+			executionRef: {
+				uri: VERSION_CHAIN_URI,
+				revision: canonicalCandidateDigest({
+					...VERSION_CHAIN_DEFINITION,
+					stop: canonicalStop(stop)
+				})
+			}
+		},
+		artifactKind: "agent-profile",
+		objective: {
+			metric: "version-judge-score",
+			direction: "maximize",
+			judge: {
+				uri: "agent-runtime:version-judge",
+				revision: judge.digest
+			},
+			claim: developmentClaim(pursuitId)
+		},
+		splits: {
+			train: [{
+				taskId: TASK_ID,
+				unitId: TASK_ID,
+				source: {
+					uri: `pursuit:${pursuitId}`,
+					revision: taskRevision
+				}
+			}],
+			selection: [],
+			test: [],
+			heldOutUnits: true
+		},
+		policy: {
+			expansion: policy.name,
+			allocation: allocation.name,
+			seed: 0
+		},
+		budget: {
+			maxUsd: stop.maxUsd,
+			maxCells: null,
+			maxNodes: stop.maxVersions,
+			deadline,
+			maxConcurrency: 1,
+			reservedClaimUsd: 0
+		},
+		containment: null,
+		derivedFrom: null,
+		identity: identity(firstProfile)
+	});
+	const deadlineAt = Date.parse(deadline);
+	const expired = new AbortController();
+	let timer;
+	const arm = () => {
+		const remaining = deadlineAt - now();
+		if (remaining <= 0) {
+			expired.abort(/* @__PURE__ */ new Error("the version chain reached its deadline"));
+			return;
+		}
+		timer = setTimeout(arm, Math.min(remaining, MAX_TIMER_MS));
+		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 {
+				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);
+		}
+	};
+	const executor = {
+		lanes: () => [base.budget.maxUsd === void 0 ? {
+			name: LANE,
+			capacity: 1,
+			costCap: "estimate",
+			cellUsd: 0
+		} : {
+			name: LANE,
+			capacity: 1,
+			costCap: "hard",
+			cellUsd: base.budget.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$1(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);
+		}
+	};
+	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) })
+	};
+	const proposer = {
+		name: versions.next === "review-of-best" ? "review-of-best" : "next",
+		kind: "optimizer",
+		source: proposerSource,
+		execution: {
+			kind: "deterministic",
+			source: proposerSource
+		},
+		childrenPerProposal: 1,
+		async propose(request) {
+			const parent = request.parents[0];
+			const judged = await judgedVersions(await versionsOf());
+			const best = judged.find((version) => version.nodeId === parent.nodeId);
+			if (best === void 0 || parent.artifact.profile === null) throw new RuntimeRunStateError(`supervisePursuit versions: the kept version ${parent.nodeId} has no judged run to fork from`);
+			const returned = await next({
+				best,
+				last: judged.at(-1),
+				versions: Object.freeze(judged)
+			}, 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$1(error)
+				};
+			}
+			return {
+				children: [{
+					artifact: child,
+					label: change.title ?? returned.id,
+					rationale: (change.source?.notes ?? []).join("\n")
+				}],
+				accounting: versions.next === "review-of-best" ? FREE : {
+					tokens: {
+						status: "unknown",
+						reason: "the caller's next reports no usage"
+					},
+					cost: {
+						status: "unknown",
+						knownLowerBoundUsd: 0,
+						reason: "the caller's next reports no spend"
+					}
+				}
+			};
+		}
+	};
+	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 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,
+				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
+		};
+	}
+	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);
+		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
+			})]
+		};
+	}
+	/** 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;
+	}
+}
+/** The bytes of a version's sealed `result.json` and the record they hold, parsed from the same
+*  bytes that are hashed. */
+async function readSealed(runDir, version) {
+	const path = resolve(runDir, SETTLE_RECORD_FILE);
+	let bytes;
+	try {
+		bytes = await readFile(path);
+	} catch (error) {
+		if (!isNoEntError(error)) throw error;
+		throw new RuntimeRunStateError(`supervisePursuit versions: version ${version} has no settle record in ${runDir}`);
+	}
+	return {
+		bytes,
+		result: parseSettleRecord(Buffer.from(bytes).toString("utf8"), path)
+	};
+}
+/** A profile as the JSON the ledger stores: validated, with undefined entries absent. */
+function jsonProfile(profile) {
+	canonicalAgentProfileDigest(profile);
+	return JSON.parse(JSON.stringify(agentProfileSchema.parse(profile)));
+}
+function loadNode(store, node) {
+	const stored = store.readBlob(node.artifact);
+	if (stored.kind === "agent-profile") {
+		const parsed = agentProfileSchema.safeParse(stored.profile);
+		if (!parsed.success) throw new RuntimeRunStateError(`version node ${node.nodeId} holds an invalid AgentProfile`);
+		return {
+			profile: parsed.data,
+			refusal: null
+		};
+	}
+	if (stored.kind === "unapplied-change") return {
+		profile: null,
+		...stored.change ? { change: stored.change } : {},
+		...stored.parentDigest ? { parentDigest: stored.parentDigest } : {},
+		refusal: stored.refusal ?? "the change did not apply"
+	};
+	throw new RuntimeRunStateError(`version node ${node.nodeId} holds no version artifact`);
+}
+/** The `<runDir>.v<n>` directory and `<runId>.v<n>` id of version `n`, beside the first. */
+function versionRun(runDir, runId, version) {
+	return version === 1 ? {
+		runDir,
+		runId
+	} : {
+		runDir: `${runDir}.v${version}`,
+		runId: `${runId}.v${version}`
+	};
+}
+/** A version's settled spend as the ledger's accounting. Unknown dollars carry the part a
+*  provider is known to have billed as their floor. */
+function versionAccounting(spent) {
+	const tokensKnown = spent !== void 0 && spent.tokensKnown !== false && spent.tokens?.tokensKnown !== false && Number.isSafeInteger(spent.tokens?.input) && Number.isSafeInteger(spent.tokens?.output) && Number.isSafeInteger(spent.tokens?.cacheRead);
+	const usdKnown = spent !== void 0 && spent.usdKnown !== false && isFiniteNumber(spent.usd);
+	return {
+		tokens: tokensKnown ? {
+			status: "known",
+			inputTokens: spent.tokens.input,
+			outputTokens: spent.tokens.output,
+			cachedTokens: spent.tokens.cacheRead
+		} : {
+			status: "unknown",
+			reason: `the version's settled spend reports no complete token count with its cache split (input ${spent?.tokens?.input ?? "none"}, output ${spent?.tokens?.output ?? "none"})`
+		},
+		cost: usdKnown ? {
+			status: "known",
+			usd: spent.usd,
+			source: "provider"
+		} : {
+			status: "unknown",
+			knownLowerBoundUsd: Math.max(0, isFiniteNumber(spent?.usd) ? spent.usd - (spent.usdEstimated ?? 0) : 0),
+			reason: "the version's settled spend names unpriced or unreported work"
+		}
+	};
+}
+/** How long a version that settled before its chain opened ran, from its settle record. */
+function settledElapsed(settled) {
+	const elapsed = settled?.spentTotal?.ms;
+	return isFiniteNumber(elapsed) ? elapsed : 0;
+}
+const FREE = {
+	tokens: {
+		status: "known",
+		inputTokens: 0,
+		outputTokens: 0,
+		cachedTokens: 0
+	},
+	cost: {
+		status: "known",
+		usd: 0,
+		source: "free"
+	}
+};
+function canonicalStop(stop) {
+	return {
+		patience: stop.patience,
+		maxVersions: stop.maxVersions,
+		maxUsd: stop.maxUsd,
+		deadlineMs: stop.deadlineMs,
+		...stop.minImprovement === void 0 ? {} : { minImprovement: stop.minImprovement }
+	};
+}
+/**
+* `'review-of-best'`: fork from the kept version with its check's verdict mounted under
+* {@link REVIEW_DIR} and the profile's review words as one instruction. The previous review's
+* mount and instruction are removed, so a profile carries one review.
+*/
+function reviewOfBest(runId, words) {
+	return ({ best, versions }) => {
+		const n = versions.length + 1;
+		const verdict = best.verdict.check;
+		const path = `${REVIEW_DIR}version-${best.version}.md`;
+		const instruction = words.replaceAll("{version}", String(best.version)).replaceAll("{path}", path).replaceAll("{score}", best.verdict.score === null ? "none" : String(best.verdict.score)).trim();
+		const page = reviewPage(best.version, best.verdict.score, verdict);
+		const earlier = best.change?.set?.prompt?.instructions ?? [];
+		const earlierInstructions = earlier.filter((text) => text !== instruction);
+		const earlierMounts = (best.profile.resources?.files ?? []).map((file) => file.path).filter((mounted) => mounted.startsWith("inputs/review/") && mounted !== path);
+		return {
+			kind: "agent-profile-diff",
+			id: `${runId}-v${n}-review-of-v${best.version}`,
+			title: `Version ${n}: review of version ${best.version}`,
+			source: {
+				kind: "optimizer",
+				notes: [`review-of-best: version ${best.version}`, `judge ${best.verdict.judgeDigest}`]
+			},
+			set: {
+				...earlier.includes(instruction) ? {} : { prompt: { instructions: [instruction] } },
+				resources: { files: [{
+					path,
+					resource: {
+						kind: "inline",
+						name: path,
+						content: page
+					}
+				}] }
+			},
+			...earlierInstructions.length > 0 || earlierMounts.length > 0 ? { remove: {
+				...earlierInstructions.length > 0 ? { prompt: { instructions: [...earlierInstructions] } } : {},
+				...earlierMounts.length > 0 ? { resources: { files: earlierMounts } } : {}
+			} } : {}
+		};
+	};
+}
+/** The review page: facts only, in the check's own lines. */
+function reviewPage(version, score, verdict) {
+	if (verdict === void 0) return [
+		`# Version ${version}`,
+		"",
+		`Score: ${score ?? "none"}. The judge reported no per-item verdict.`,
+		""
+	].join("\n");
+	const failing = failedItems(verdict);
+	return [
+		`# Version ${version}`,
+		"",
+		`Score: ${score ?? "none"}.${verdict.threshold === void 0 ? "" : ` The check passes at ${verdict.threshold}.`}`,
+		"",
+		"## Items",
+		"",
+		...Object.entries(verdict.items ?? {}).map(([item, value]) => `- ${item}: ${value >= 1 ? "passes" : `fails (${value})`}`),
+		"",
+		...failing.length === 0 ? [] : [
+			"## Failures",
+			"",
+			...verdict.failures ?? [],
+			""
+		],
+		...verdict.review === void 0 ? [] : [
+			"## The check's review",
+			"",
+			verdict.review,
+			""
+		]
+	].join("\n");
+}
+function digestOf(value, name) {
+	try {
+		return canonicalCandidateDigest(value);
+	} catch (error) {
+		throw new ValidationError(`supervisePursuit versions: the ${name} must be canonical JSON to pin the chain: ${errorMessage$1(error)}`);
+	}
+}
+async function exists(path) {
+	try {
+		await access(path);
+		return true;
+	} catch (error) {
+		if (isNoEntError(error)) return false;
+		throw error;
+	}
+}
+function isSha256(value) {
+	return typeof value === "string" && /^sha256:[0-9a-f]{64}$/u.test(value);
+}
+function isFiniteNumber(value) {
+	return typeof value === "number" && Number.isFinite(value);
+}
+function errorMessage$1(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
 //#region src/durable/run-fork.ts
 /**
 * The `execution.correlation` keys a fork records on its root. Runtime writes them; a caller that
@@ -1254,500 +2043,6 @@ async function removeIfPresent(path) {
 	}
 }
 //#endregion
-//#region src/durable/pursuit-versions.ts
-/** The longest delay Node's setTimeout honors. */
-const MAX_TIMER_MS = 2147483647;
-/** The ledger file inside the lineage directory. */
-const PURSUIT_VERSIONS_FILE = "versions.jsonl";
-/** The `<runDir>.v<n>` directory and `<runId>.v<n>` id of version `n`, beside the first. */
-function pursuitVersionRun(runDir, runId, version) {
-	return version === 1 ? {
-		runDir,
-		runId
-	} : {
-		runDir: `${runDir}.v${version}`,
-		runId: `${runId}.v${version}`
-	};
-}
-/**
-* Validate a `versions` option before any compute. The same check runs inside `supervisePursuit`;
-* a caller that records the option as data can run it at preflight.
-*/
-function assertPursuitVersions(versions) {
-	const fail = (message) => {
-		throw new ValidationError(`supervisePursuit versions: ${message}`);
-	};
-	if (typeof versions !== "object" || versions === null) fail("must be an object");
-	const { judge, next, stop, run } = versions;
-	if (typeof judge !== "object" || judge === null || typeof judge.judge !== "function") fail("judge must be a VersionJudge, such as declaredCheckJudge(check)");
-	else if (!isSha256(judge.digest)) fail("judge.digest must be a sha256 digest (sha256:<64 hex>)");
-	if (next !== "review-of-best" && typeof next !== "function") fail("next must be a function or 'review-of-best'");
-	if (run !== void 0 && typeof run !== "function") fail("run must be a function when set");
-	const { usd } = versions;
-	if (usd !== void 0 && typeof usd !== "function") fail("usd must be a function when set");
-	if (typeof stop !== "object" || stop === null) fail("stop must be an object");
-	const rule = stop;
-	const known = /* @__PURE__ */ new Set([
-		"patience",
-		"maxVersions",
-		"maxUsd",
-		"deadlineMs",
-		"minImprovement"
-	]);
-	const unknown = Object.keys(rule).filter((key) => !known.has(key));
-	if (unknown.length > 0) fail(`stop has unknown fields: ${unknown.join(", ")}`);
-	for (const key of ["patience", "maxVersions"]) if (!Number.isInteger(rule[key]) || rule[key] < 1) fail(`stop.${key} must be an integer of at least 1`);
-	for (const key of ["maxUsd", "deadlineMs"]) if (typeof rule[key] !== "number" || !Number.isFinite(rule[key]) || rule[key] <= 0) fail(`stop.${key} must be a finite number above 0`);
-	if (rule.minImprovement !== void 0 && (typeof rule.minImprovement !== "number" || !Number.isFinite(rule.minImprovement) || rule.minImprovement < 0)) fail("stop.minImprovement must be a finite number of at least 0");
-}
-/** Run a version chain. `supervisePursuit` calls this when `versions` is set. */
-async function runPursuitVersions(profile, task, opts, runOne) {
-	const { versions, ...rest } = opts;
-	assertPursuitVersions(versions);
-	for (const key of [
-		"journal",
-		"blobs",
-		"rootHandle",
-		"steerDir"
-	]) if (rest[key] !== void 0) throw new ValidationError(`supervisePursuit versions: ${key} names one run, and a version chain has one per version; omit it`);
-	const judge = versions.judge;
-	if (versions.next === "review-of-best" && rest.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 next = versions.next === "review-of-best" ? reviewOfBest(rest.runId ?? "supervise", rest.continuation?.profile.review ?? "") : versions.next;
-	const stop = versions.stop;
-	const minImprovement = stop.minImprovement ?? 0;
-	const now = rest.now ?? Date.now;
-	const pursuitId = rest.pursuitId.trim();
-	const runDir = resolve(rest.runDir.trim());
-	const runId = rest.runId ?? "supervise";
-	const { fork: firstFork, signal: callerSignal, ...base } = rest;
-	const lineageDir = `${runDir}.versions`;
-	const ledgerPath = resolve(lineageDir, PURSUIT_VERSIONS_FILE);
-	const firstProfile = firstFork === void 0 ? profile : applyExactAgentProfileDiff(profile, firstFork.change, "supervisePursuit versions");
-	await mkdir(lineageDir, { recursive: true });
-	const lock = await acquireRunDirectoryLock(lineageDir, `${runId}:versions`, now);
-	try {
-		const ledger = await readLedger(ledgerPath);
-		let chain = ledger.find((line) => line.kind === "chain");
-		if (chain === void 0) {
-			const elapsed = (await readSettleRecord(runDir))?.spentTotal?.ms;
-			const startedAt = new Date(now() - (typeof elapsed === "number" && Number.isFinite(elapsed) ? elapsed : 0)).toISOString();
-			chain = {
-				kind: "chain",
-				pursuitId,
-				runId,
-				runDir,
-				judgeDigest: judge.digest,
-				stop: canonicalStop(stop),
-				startedAt
-			};
-			await appendLedger(ledgerPath, chain);
-		} else {
-			const mismatch = [
-				chain.pursuitId !== pursuitId ? `pursuitId '${chain.pursuitId}'` : void 0,
-				chain.runId !== runId ? `runId '${chain.runId}'` : void 0,
-				chain.runDir !== runDir ? `runDir '${chain.runDir}'` : void 0,
-				chain.judgeDigest !== judge.digest ? `judge digest ${chain.judgeDigest}` : void 0,
-				contentAddress(chain.stop) !== contentAddress(canonicalStop(stop)) ? "another stop rule" : void 0
-			].filter((item) => item !== void 0);
-			if (mismatch.length > 0) throw new ValidationError(`supervisePursuit versions: ${ledgerPath} records a chain with ${mismatch.join(", ")}; a chain keeps its identity, judge and stop rule`);
-		}
-		const startedAtMs = Date.parse(chain.startedAt);
-		const deadline = new AbortController();
-		let timer;
-		const arm = () => {
-			const remaining = startedAtMs + stop.deadlineMs - now();
-			if (remaining <= 0) {
-				deadline.abort(/* @__PURE__ */ new Error("the version chain reached its deadline"));
-				return;
-			}
-			timer = setTimeout(arm, Math.min(remaining, MAX_TIMER_MS));
-			timer.unref?.();
-		};
-		arm();
-		const signal = callerSignal === void 0 ? deadline.signal : AbortSignal.any([callerSignal, deadline.signal]);
-		try {
-			const judged = [];
-			const profiles = /* @__PURE__ */ new Map([[1, firstProfile]]);
-			let pending = {
-				version: 1,
-				runId,
-				runDir
-			};
-			let stopped;
-			for (const line of ledger) if (line.kind === "start") {
-				const parentProfile = profiles.get(line.parent.version);
-				if (parentProfile === void 0) throw new RuntimeRunStateError(`supervisePursuit versions: ${ledgerPath} starts version ${line.version} from unknown version ${line.parent.version}`);
-				profiles.set(line.version, applyExactAgentProfileDiff(parentProfile, line.change, "supervisePursuit versions"));
-				pending = {
-					version: line.version,
-					runId: line.runId,
-					runDir: line.runDir,
-					parent: line.parent,
-					change: line.change
-				};
-			} else if (line.kind === "judged") {
-				if (line.version !== judged.length + 1 || line.version !== pending?.version) throw new RuntimeRunStateError(`supervisePursuit versions: ${ledgerPath} judges version ${line.version} out of order`);
-				if (line.verdict.judgeDigest !== judge.digest) throw new ValidationError(`supervisePursuit versions: version ${line.version} was judged under ${line.verdict.judgeDigest}, not ${judge.digest}`);
-				const settled = await readSettled(pending, profiles);
-				if (settled.settleDigest !== line.settleDigest) throw new RuntimeRunStateError(`supervisePursuit versions: version ${line.version}'s result.json changed after it was judged`);
-				judged.push(Object.freeze({
-					...settled,
-					verdict: line.verdict,
-					improved: line.improved,
-					usd: line.usd,
-					usdKnown: line.usdKnown,
-					usdSource: line.usdSource,
-					...line.lineage === void 0 ? {} : { lineage: line.lineage }
-				}));
-				pending = void 0;
-			} else if (line.kind === "stopped") stopped = line;
-			while (stopped === void 0) {
-				if (pending !== void 0) {
-					const spec = pending;
-					const settled = await settle(spec);
-					const verdict = await judgeVersion(settled);
-					const bestScore = bestOf(judged)?.verdict.score;
-					const improved = isFiniteNumber(verdict.score) && (!isFiniteNumber(bestScore) || verdict.score > bestScore + minImprovement);
-					const spent = settled.result.spentTotal;
-					const measured = versions.usd === void 0 ? void 0 : await versions.usd(settled, signal);
-					const usdSource = measured === void 0 ? "runtime" : "caller";
-					const usd = measured === void 0 ? isFiniteNumber(spent?.usd) ? spent.usd : null : isFiniteNumber(measured) ? measured : null;
-					const usdKnown = usd !== null && (measured !== void 0 || spent?.usdKnown !== false);
-					const lineage = versionLineage(spec, firstFork);
-					await appendLedger(ledgerPath, {
-						kind: "judged",
-						version: spec.version,
-						runId: spec.runId,
-						runDir: spec.runDir,
-						settleDigest: settled.settleDigest,
-						...spec.parent === void 0 ? {} : { parent: spec.parent },
-						...spec.change?.id === void 0 ? {} : { changeId: spec.change.id },
-						verdict,
-						improved,
-						usd,
-						usdKnown,
-						usdSource,
-						...lineage === void 0 ? {} : { lineage }
-					});
-					judged.push(Object.freeze({
-						...settled,
-						verdict,
-						improved,
-						usd,
-						usdKnown,
-						usdSource,
-						...lineage === void 0 ? {} : { lineage }
-					}));
-					pending = void 0;
-				}
-				const reason = stopReason(judged);
-				if (reason !== void 0) {
-					stopped = {
-						kind: "stopped",
-						reason,
-						at: new Date(now()).toISOString(),
-						best: (bestOf(judged) ?? judged[0]).version,
-						spentUsd: spentOf(judged)
-					};
-					await appendLedger(ledgerPath, stopped);
-					break;
-				}
-				const best = bestOf(judged) ?? judged[0];
-				const last = judged[judged.length - 1];
-				const change = await next({
-					best,
-					last,
-					versions: Object.freeze([...judged])
-				}, signal);
-				if (typeof change?.id !== "string" || change.id.trim().length === 0) throw new ValidationError("supervisePursuit versions: next must return a change with an id");
-				const version = judged.length + 1;
-				const spec = {
-					version,
-					...pursuitVersionRun(runDir, runId, version),
-					parent: {
-						version: best.version,
-						runId: best.runId,
-						settleDigest: best.settleDigest
-					},
-					change
-				};
-				profiles.set(version, applyExactAgentProfileDiff(best.profile, change, "supervisePursuit versions"));
-				await appendLedger(ledgerPath, {
-					kind: "start",
-					version,
-					runId: spec.runId,
-					runDir: spec.runDir,
-					parent: spec.parent,
-					change
-				});
-				pending = spec;
-			}
-			const bestVersion = judged.find((item) => item.version === stopped.best) ?? judged[0];
-			const record = Object.freeze({
-				lineageDir,
-				judgeDigest: judge.digest,
-				stop: canonicalStop(stop),
-				startedAt: chain.startedAt,
-				versions: Object.freeze([...judged]),
-				best: bestVersion.version,
-				spentUsd: stopped.spentUsd,
-				stopped: Object.freeze({
-					reason: stopped.reason,
-					at: stopped.at
-				})
-			});
-			const observerPath = resolve(bestVersion.runDir, "observer.jsonl");
-			return Object.freeze({
-				result: bestVersion.result,
-				pursuit: projectPursuit(await new FileObserverJournal(observerPath, pursuitId).read()),
-				observerPath,
-				settlePath: resolve(bestVersion.runDir, SETTLE_RECORD_FILE),
-				versions: record
-			});
-			/** Run the version unless its directory already settled, then read it back. */
-			async function settle(spec) {
-				if (await readSettleRecord(spec.runDir) === void 0) {
-					if (signal.aborted) throw new RuntimeRunStateError(`supervisePursuit versions: version ${spec.version} was not started: ${abortMessage(signal)}`);
-					if (spec.parent === void 0 || spec.change === void 0) await runOne(profile, task, {
-						...base,
-						...firstFork === void 0 ? {} : { fork: firstFork },
-						signal
-					});
-					else {
-						const parent = judged.find((item) => item.version === spec.parent.version);
-						if (parent === void 0) throw new RuntimeRunStateError(`supervisePursuit versions: version ${spec.version}'s parent ${spec.parent.version} is not judged`);
-						const fork = {
-							runDir: parent.runDir,
-							settleDigest: parent.settleDigest,
-							change: spec.change,
-							acceptUncertain: true
-						};
-						const bar = base.continuation !== void 0 && parent.verdict.check !== void 0 ? { continuation: {
-							...base.continuation,
-							best: {
-								label: `v${parent.version}`,
-								verdict: parent.verdict.check
-							}
-						} } : {};
-						const options = {
-							...base,
-							...bar,
-							runId: spec.runId,
-							runDir: spec.runDir,
-							fork,
-							signal
-						};
-						if (versions.run === void 0) await runOne(parent.profile, task, options);
-						else {
-							const prepared = await prepareRunFork(parent.profile, task, options, fork);
-							await versions.run(Object.freeze({
-								version: spec.version,
-								runId: spec.runId,
-								runDir: spec.runDir,
-								pursuitId,
-								profile: prepared.profile,
-								task,
-								budget: base.budget,
-								execution: prepared.execution,
-								fork,
-								parentProfile: parent.profile
-							}), signal);
-						}
-					}
-				}
-				const settled = await readSettled(spec, profiles);
-				if (settled === void 0) throw new RuntimeRunStateError(`supervisePursuit versions: version ${spec.version} returned without a settle record in ${spec.runDir}`);
-				return settled;
-			}
-			async function judgeVersion(settled) {
-				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 stopReason(done) {
-				if (callerSignal?.aborted) return "aborted";
-				if (done.length >= stop.maxVersions) return "max-versions";
-				let stale = 0;
-				for (let index = done.length - 1; index >= 0 && !done[index].improved; index -= 1) stale += 1;
-				if (stale >= stop.patience) return "no-improvement";
-				if (done.some((item) => item.usd === null)) return "spend-unknown";
-				if (spentOf(done) >= stop.maxUsd) return "max-usd";
-				if (deadline.signal.aborted || now() - startedAtMs >= stop.deadlineMs) return "deadline";
-			}
-		} finally {
-			if (timer !== void 0) clearTimeout(timer);
-		}
-	} finally {
-		await lock.release();
-	}
-}
-async function readSettled(spec, profiles) {
-	let bytes;
-	try {
-		bytes = await readFile(resolve(spec.runDir, SETTLE_RECORD_FILE));
-	} catch (error) {
-		if (!isNoEntError(error)) throw error;
-		throw new RuntimeRunStateError(`supervisePursuit versions: version ${spec.version} has no settle record in ${spec.runDir}`);
-	}
-	const result = await readSettleRecord(spec.runDir);
-	const profile = profiles.get(spec.version);
-	if (profile === void 0) throw new RuntimeRunStateError(`supervisePursuit versions: version ${spec.version} has no recorded profile`);
-	return Object.freeze({
-		version: spec.version,
-		runId: spec.runId,
-		runDir: spec.runDir,
-		settleDigest: sha256Bytes(bytes),
-		result,
-		profile,
-		...spec.parent === void 0 ? {} : { parent: spec.parent },
-		...spec.change === void 0 ? {} : { change: spec.change }
-	});
-}
-function versionLineage(spec, firstFork) {
-	if (spec.parent !== void 0 && spec.change !== void 0) return {
-		source: lineageSource(spec.change),
-		runIds: [spec.parent.runId],
-		profileDiffIds: [spec.change.id]
-	};
-	if (firstFork !== void 0) return {
-		source: lineageSource(firstFork.change),
-		profileDiffIds: [firstFork.change.id]
-	};
-}
-/** The change's author, in the lineage's words. A trace-derived change is a compound of runs. */
-function lineageSource(change) {
-	const kind = change.source?.kind;
-	return kind === "human" || kind === "optimizer" || kind === "frontier-author" ? kind : "compound";
-}
-function bestOf(done) {
-	let best;
-	for (const item of done) {
-		if (!isFiniteNumber(item.verdict.score)) continue;
-		if (best === void 0 || item.verdict.score > best.verdict.score) best = item;
-	}
-	return best;
-}
-function spentOf(done) {
-	return done.reduce((sum, item) => sum + (item.usd ?? 0), 0);
-}
-function canonicalStop(stop) {
-	return {
-		patience: stop.patience,
-		maxVersions: stop.maxVersions,
-		maxUsd: stop.maxUsd,
-		deadlineMs: stop.deadlineMs,
-		...stop.minImprovement === void 0 ? {} : { minImprovement: stop.minImprovement }
-	};
-}
-/** Where `'review-of-best'` mounts a review: `inputs/review/version-<n>.md`. One review lives in
-*  a profile at a time. */
-const REVIEW_DIR = "inputs/review/";
-/**
-* `'review-of-best'`: fork from the best version with its check's verdict mounted under
-* {@link REVIEW_DIR} and the profile's review words as one instruction. The previous review's
-* mount and instruction are removed, so a profile carries one review. This is what the Lab's
-* `continue-best` changes did in Lab code, now written once from the check's own verdict.
-*/
-function reviewOfBest(runId, words) {
-	return ({ best, versions }) => {
-		const n = versions.length + 1;
-		const verdict = best.verdict.check;
-		const path = `${REVIEW_DIR}version-${best.version}.md`;
-		const instruction = words.replaceAll("{version}", String(best.version)).replaceAll("{path}", path).replaceAll("{score}", best.verdict.score === null ? "none" : String(best.verdict.score)).trim();
-		const page = reviewPage(best.version, best.verdict.score, verdict);
-		const earlierInstructions = best.change?.set?.prompt?.instructions ?? [];
-		const earlierMounts = (best.profile.resources?.files ?? []).map((file) => file.path).filter((mounted) => mounted.startsWith("inputs/review/") && mounted !== path);
-		return {
-			kind: "agent-profile-diff",
-			id: `${runId}-v${n}-review-of-v${best.version}`,
-			title: `Version ${n}: review of version ${best.version}`,
-			source: {
-				kind: "optimizer",
-				notes: [`review-of-best: version ${best.version}`, `judge ${best.verdict.judgeDigest}`]
-			},
-			set: {
-				prompt: { instructions: [instruction] },
-				resources: { files: [{
-					path,
-					resource: {
-						kind: "inline",
-						name: path,
-						content: page
-					}
-				}] }
-			},
-			...earlierInstructions.length > 0 || earlierMounts.length > 0 ? { remove: {
-				...earlierInstructions.length > 0 ? { prompt: { instructions: [...earlierInstructions] } } : {},
-				...earlierMounts.length > 0 ? { resources: { files: earlierMounts } } : {}
-			} } : {}
-		};
-	};
-}
-/** The review page: facts only, in the check's own lines. */
-function reviewPage(version, score, verdict) {
-	if (verdict === void 0) return [
-		`# Version ${version}`,
-		"",
-		`Score: ${score ?? "none"}. The judge reported no per-item verdict.`,
-		""
-	].join("\n");
-	const failing = failedItems(verdict);
-	return [
-		`# Version ${version}`,
-		"",
-		`Score: ${score ?? "none"}.${verdict.threshold === void 0 ? "" : ` The check passes at ${verdict.threshold}.`}`,
-		"",
-		"## Items",
-		"",
-		...Object.entries(verdict.items ?? {}).map(([item, value]) => `- ${item}: ${value >= 1 ? "passes" : `fails (${value})`}`),
-		"",
-		...failing.length === 0 ? [] : [
-			"## Failures",
-			"",
-			...verdict.failures ?? [],
-			""
-		],
-		...verdict.review === void 0 ? [] : [
-			"## The check's review",
-			"",
-			verdict.review,
-			""
-		]
-	].join("\n");
-}
-async function readLedger(path) {
-	let text;
-	try {
-		text = await readFile(path, "utf8");
-	} catch (error) {
-		if (isNoEntError(error)) return [];
-		throw error;
-	}
-	return parseCommittedJsonLines(text, path);
-}
-async function appendLedger(path, line) {
-	const endsWithRecord = await prepareJsonlAppend(path);
-	const handle = await open(path, "a");
-	try {
-		await writeAllBytes(handle, `${endsWithRecord ? "\n" : ""}${JSON.stringify(line)}\n`);
-		await handle.sync();
-	} finally {
-		await handle.close();
-	}
-}
-function isSha256(value) {
-	return typeof value === "string" && /^sha256:[0-9a-f]{64}$/u.test(value);
-}
-function isFiniteNumber(value) {
-	return typeof value === "number" && Number.isFinite(value);
-}
-function abortMessage(signal) {
-	const reason = signal.reason;
-	return reason instanceof Error ? reason.message : String(reason ?? "aborted");
-}
-//#endregion
 //#region src/durable/supervise-pursuit.ts
 /** A failed Runtime execution whose complete third-person projection was retained. */
 var SupervisePursuitError = class extends Error {
@@ -1946,6 +2241,6 @@ function compareText(left, right) {
 	return left < right ? -1 : left > right ? 1 : 0;
 }
 //#endregion
-export { FAILURE_RECORD_FILE, FORK_PARENT_UNCERTAIN_NODES_KEY, FileObserverJournal, PURSUIT_VERSIONS_FILE, REVIEW_DIR, ROOT_STREAM_FILE, RUN_DIRECTORY_LOCK_FILE, RUN_FORK_CORRELATION_KEYS, RunDirectoryLockedError, SETTLE_RECORD_FILE, SettledRunDirectoryError, SupervisePursuitError, acquireRunDirectoryLock, assertPursuitVersions, createFileObserverHooks, deriveExecutionId, discoverDurableSupervisionRun, handleChatTurn, observerRecordDigest, projectPursuit, pursuitVersionRun, readFailureRecord, readRootStream, readRootStreamReceipt, readRunDirectoryLock, readSettleRecord, runDirectoryHolderIsLive, settleRecordJson, supervisePursuit, verifyObserverRecords };
+export { FAILURE_RECORD_FILE, FORK_PARENT_UNCERTAIN_NODES_KEY, FileObserverJournal, REVIEW_DIR, ROOT_STREAM_FILE, RUN_DIRECTORY_LOCK_FILE, RUN_FORK_CORRELATION_KEYS, RunDirectoryLockedError, SETTLE_RECORD_FILE, SettledRunDirectoryError, SupervisePursuitError, acquireRunDirectoryLock, assertPursuitVersions, createFileObserverHooks, deriveExecutionId, discoverDurableSupervisionRun, handleChatTurn, observerRecordDigest, projectPursuit, pursuitVersionsLedgerPath, readFailureRecord, readRootStream, readRootStreamReceipt, readRunDirectoryLock, readSettleRecord, runDirectoryHolderIsLive, settleRecordJson, supervisePursuit, verifyObserverRecords };
 
 //# sourceMappingURL=durable.js.map