@tangle-network/agent-eval 0.190.1 → 0.192.0

package/dist/{llm-judge-BnxAv7ed.js → llm-judge-Z6MkTkd0.js}

@@ -1,20 +1,24 @@
 import { i as JudgeError, s as ValidationError } from "./errors-Dngq5h35.js";
 import { a as hashCanonical, i as compareCodeUnits, r as canonicalString, t as LEDGER_HASH_PATTERN } from "./canonical-BsZVgBhW.js";
+import { t as mulberry32 } from "./random-Dn5fPWkt.js";
 import { o as summarizeNumberSeries, s as weightedComposite, t as confidenceInterval } from "./descriptive-1V17A-qa.js";
-import { t as decidePairedPromotion } from "./paired-promotion-decision-6cn3bLc3.js";
+import { n as DECISION_PAIRED_DELTA_STATISTIC } from "./paired-tests-C8iCsioC.js";
+import { i as pairedDeltaTest, r as minimumPairsForPairedDeltaTest, t as decidePairedPromotion } from "./paired-promotion-decision-6cn3bLc3.js";
 import { a as heldoutSignificance, i as dimensionRegressions, o as pairHoldout } from "./statistical-heldout-GcLIPxk4.js";
 import { i as modelHasSnapshot, l as searchCellRunId } from "./run-record-BRlM99rX.js";
 import { n as contentHash } from "./verdict-cache-BQEsVy9n.js";
-import { o as projectCampaignCellQuality, t as campaignCellCostProvenance } from "./run-record-DnMFyg_g.js";
+import { r as projectCampaignCellQuality, t as campaignCellCostProvenance } from "./run-record-tNnlQIrD.js";
 import { i as CostLedger, t as CostAccountingIncompleteError } from "./cost-ledger-_IbkejCF.js";
-import { A as FinalEvidenceConflictError, B as surfaceContentHash, C as campaignMeanCompositeOrNull, F as summarizeEvaluationUnits, H as surfaceHash, J as assertCampaignSplitIdentity, N as defineEvaluationClaim, P as evaluationClaimSchema, Q as campaignSplitDigest, S as campaignMeanComposite, U as surfaceHashMatches, V as surfaceDispatchRef, W as BackendIntegrityError, X as campaignCoverage, Y as assertCompleteCampaign, Z as campaignScenarioIdentity, b as assertFiniteRankKey, et as formatCoverageFailures, j as FinalEvidenceError, q as assertCampaignDesign, t as createCampaignEvidenceReceipt, w as compareRankKeys, x as campaignBreakdown, z as renderSurfaceDiff } from "./campaign-evidence-D40-LHIL.js";
-import { n as replayLedgerText, p as mapConcurrent, t as FileLedgerJournal } from "./journal-c3qY0SDP.js";
+import { F as surfaceContentHash, G as campaignCoverage, H as assertCampaignDesign, I as surfaceDispatchRef, K as campaignScenarioIdentity, L as surfaceHash, O as FinalEvidenceConflictError, P as renderSurfaceDiff, R as surfaceHashMatches, S as campaignMeanCompositeOrNull, U as assertCampaignSplitIdentity, W as assertCompleteCampaign, Y as formatCoverageFailures, b as campaignBreakdown, k as FinalEvidenceError, q as campaignSplitDigest, t as createCampaignEvidenceReceipt, x as campaignMeanComposite, z as BackendIntegrityError } from "./campaign-evidence-DcQiYhJI.js";
+import { m as mapConcurrent } from "./journal-DvKCvjty.js";
 import { t as deepFreezeCanonicalJson } from "./deep-freeze-CurcOQg3.js";
-import "./ledger-core/index.js";
-import { D as SearchLedgerIntegrityError, E as SearchLedgerError, S as fsCampaignStorage, T as SearchLedgerConflictError, g as isRecord, h as isExternalTextCandidate, w as SEARCH_LEDGER_FILE_CONTEXT, x as createRunCostLedger } from "./external-optimizer-subprocess-kbcPu5po.js";
+import { a as SearchLedgerError } from "./search-ledger-file-DY0AXX3W.js";
+import { C as fsCampaignStorage, S as createRunCostLedger, g as isRecord, h as isExternalTextCandidate, x as acquireSingleRunLock } from "./external-optimizer-subprocess-kbqC-iWf.js";
+import { r as summarizeEvaluationUnits, t as defineEvaluationClaim } from "./claim-V9Zqbq0J.js";
 import { f as redactText, n as REDACTION_VERSION, o as detectCredential, s as detectPersonalData } from "./redact-B7rt9Zot.js";
 import { t as detectRewardHacking } from "./reward-hacking-D0XwhVWE.js";
 import { n as assertProposalFindings, t as combineAbortSignals } from "./abort-signal-CtzAM_sJ.js";
+import { a as validateSearchLedgerEvent, d as searchTaskSetDigest, f as searchUnitScores, i as replaySearchLedgerText, l as searchCellId, n as openSearchLedger, t as FileSearchLedger, u as searchNodeId } from "./search-ledger-Ck7tok0h.js";
 import { d as stripFencedJson, o as costReceiptFromLlm, s as costReceiptFromLlmError, u as maximumChargeForLlmRequest } from "./llm-client-KYQBh9C8.js";
 import { createHash } from "node:crypto";
 import { writeFileSync } from "node:fs";
@@ -1160,8 +1164,8 @@ function detectCalibrationDrift(runs, opts) {
 				alpha,
 				recentN: recent.length,
 				historyN: historical.length,
-				recentMean: mean$1(recent),
-				historyMean: mean$1(historical)
+				recentMean: mean$2(recent),
+				historyMean: mean$2(historical)
 			}
 		}],
 		evaluation: {
@@ -1398,7 +1402,7 @@ function chiSquareCritical(df, alpha) {
 	}
 	return TABLE[10][idx];
 }
-function mean$1(xs) {
+function mean$2(xs) {
 	if (xs.length === 0) return 0;
 	return xs.reduce((s, x) => s + x, 0) / xs.length;
 }
@@ -2531,1438 +2535,994 @@ function paretoFrontierWithCrowding(candidates, objectives) {
 	return crowdingDistance(frontier, objectives).sort((a, b) => b.distance - a.distance);
 }
 //#endregion
-//#region src/campaign/types.ts
-/** Type guard: a proposal carrying its rationale vs a bare
-*  surface. The loop branches on this to populate `GenerationCandidate`. */
-function isProposedCandidate(value) {
-	return typeof value === "object" && value !== null && "surface" in value && "label" in value && "rationale" in value;
-}
-const LABEL_TRUST_RANK = {
-	unverified: 0,
-	"verified-signal": 1,
-	"human-rated": 2
-};
-/** Ordinal rank for a label-trust tier; absent ⇒ `unverified` (rank 0). */
-function labelTrustRank(trust) {
-	return LABEL_TRUST_RANK[trust ?? "unverified"];
+//#region src/campaign/allocation.ts
+/**
+* Every node gets every train and selection task at every repeat: the root as
+* `root` cells, every other node as `train` cells (the proposer's feedback) and
+* `screen` cells (the policy's private evidence). This is the fixed plan the
+* generation loop ran and GEPA runs.
+*/
+function uniform(options = {}) {
+	const reps = options.reps ?? 1;
+	if (!Number.isSafeInteger(reps) || reps < 1) throw new TypeError(`uniform: reps must be a positive integer, got ${String(reps)}`);
+	const cells = (state, root) => {
+		const header = state.header;
+		if (!header) return [];
+		const plan = [];
+		for (const split of ["train", "selection"]) for (const task of header.splits[split].tasks) for (let rep = 0; rep < reps; rep++) plan.push({
+			taskId: task.taskId,
+			split,
+			rep,
+			stage: root ? "root" : split === "train" ? "train" : "screen"
+		});
+		return plan;
+	};
+	return {
+		name: reps === 1 ? "uniform" : `uniform(reps=${reps})`,
+		plan: (state, nodeId) => cells(state, nodeId === state.rootNodeId),
+		screenSize: (state) => cells(state, false).length
+	};
 }
 //#endregion
-//#region src/campaign/search-ledger-ordering.ts
-function artifactKey(artifact) {
-	return canonicalString(artifact);
-}
-function compareStrings(a, b) {
-	return a < b ? -1 : a > b ? 1 : 0;
+//#region src/campaign/estimate-node.ts
+/**
+* Per-node statistics of a search.
+*
+* `estimateNode` is the one paired contrast of two nodes: it averages each
+* node's cells inside their units, pairs the units both nodes scored, and runs
+* `pairedDeltaTest` on the per-unit deltas. `estimateNodeFromCells` is the same
+* computation over cells a caller already holds, such as rows a server read
+* from its database. The bootstrap seed comes from `cellSetDigest`, the digest
+* of exactly the cells used, so a producer and a verifier that hold the same
+* cells report the same bits.
+*
+* `searchPosterior` gives every node a normal posterior on its improvement over
+* the root, which expansion policies sample parents from. Its numbers steer
+* spend and claim nothing.
+*/
+const CONFIDENCE = .95;
+const RESAMPLES = 2e3;
+/** 6 at 95 %: the smallest sample an exact one-sided sign test can resolve. */
+const DESCRIPTIVE_FROM = minimumPairsForPairedDeltaTest(CONFIDENCE);
+/** The estimator every `NodeEstimate` names. */
+const SEARCH_ESTIMATOR = {
+	uri: "npm:@tangle-network/agent-eval#estimateNode",
+	revision: hashCanonical({
+		name: "tangle.estimate-node.2026-09",
+		unit: "mean of the unit’s scored cells, summed in cellId order",
+		pairing: "units both nodes scored, in unitId order",
+		statistic: DECISION_PAIRED_DELTA_STATISTIC,
+		interval: "percentile paired bootstrap",
+		confidence: CONFIDENCE,
+		resamples: RESAMPLES,
+		rng: "mulberry32",
+		seed: "the first 32 bits of cellSetDigest",
+		signTest: "exact, one-sided toward improvement in the objective direction",
+		methods: {
+			none: "below 2 pairs",
+			insufficient: `below ${DESCRIPTIVE_FROM} pairs`,
+			descriptive: `below 20 pairs`,
+			bootstrap: `from 20 pairs`
+		},
+		indeterminate: "every paired delta equal: no interval and no sign p"
+	})
+};
+/** The method a paired sample of `pairs` units supports. */
+function searchEstimateMethod(pairs) {
+	if (pairs < 2) return "none";
+	if (pairs < DESCRIPTIVE_FROM) return "insufficient";
+	if (pairs < 20) return "descriptive";
+	return "bootstrap";
 }
-//#endregion
-//#region src/campaign/search-ledger-types.ts
 /**
-* Schema tag every search-ledger entry carries. A ledger written under another
-* tag, such as the retired `tangle.search-ledger.v1` candidate-slot format, is
-* refused with its tag named; it is never translated.
+* Digest of the cells an estimate reads, with the contrast they serve. Cells
+* are listed in cellId order, so the digest names the set, not the order it
+* was read in.
 */
-const SEARCH_LEDGER_SCHEMA = "tangle.search-ledger.2026-09";
-//#endregion
-//#region src/campaign/search-state.ts
+function searchCellSetDigest(input) {
+	const list = (cells) => [...cells].sort((left, right) => compareCodeUnits(left.cellId, right.cellId)).map((cell) => [
+		cell.cellId,
+		cell.unitId,
+		cell.attempt,
+		cell.score
+	]);
+	return hashCanonical({
+		contrast: [input.nodeId, input.against],
+		split: input.split,
+		nodeCells: list(input.nodeCells),
+		againstCells: list(input.againstCells)
+	});
+}
 /**
-* `SearchState`: the one projection of a search ledger.
+* The paired contrast of `nodeId` against `against` on the units both scored.
 *
-* The same code checks every invariant for the producer's journal, the kernel,
-* and the Intelligence verifier, and builds the read model they share. It keeps
-* compact indexes (nodes, edges, cells, per-unit score sums, running audit
-* totals), not the raw event list, and applies each entry in time proportional
-* to that entry, so a search of any length appends at a constant cost.
+* `delta` is the mean per-unit difference, node minus `against`, in the
+* metric's own units; for a `minimize` objective an improvement is negative.
+* The exact sign test is one-sided toward improvement in the objective's
+* direction. Unscored cells (errored, cancelled or in flight) are absent from
+* the inputs, never zero.
 *
-* The journal asks for a snapshot after every append. A snapshot is a
-* `SearchStateView` that reads the live indexes, so taking one costs nothing.
-* The view is valid until the state applies its next entry; a read after that
-* throws rather than returning numbers from a later ledger position. Read the
-* ledger's state again to see newer entries. The audit, header, head and claim
-* on a view are plain values and stay readable.
+* - `none` (0 or 1 pair): no delta.
+* - `insufficient` (2 to 5): the delta only.
+* - `descriptive` (6 to 19): the bootstrap interval as spread, and the sign-test p.
+* - `bootstrap` (20 or more): the decision-grade bootstrap interval.
+*
+* When every paired delta is equal the interval would have zero width, which
+* is an absence of evidence; the estimate is then `indeterminate` and carries
+* neither an interval nor a p-value.
 */
-/** Deterministic node id: identical content in one search is one node. */
-function searchNodeId(searchId, artifactDigest) {
-	return `node_${shortDigest([searchId, artifactDigest])}`;
-}
-/** Deterministic cell id: one node on one task in one split at one repeat. */
-function searchCellId(searchId, nodeId, taskId, split, rep) {
-	return `cell_${shortDigest([
-		searchId,
-		nodeId,
-		taskId,
+function estimateNodeFromCells(input) {
+	const { nodeId, against, split, direction } = input;
+	if (nodeId === against) throw new SearchLedgerError(`node ${nodeId} cannot be estimated against itself`);
+	assertDistinctCells([...input.nodeCells, ...input.againstCells], nodeId, against);
+	const cellSetDigest = searchCellSetDigest(input);
+	const nodeUnits = searchUnitScores(input.nodeCells);
+	const { node, other } = pairUnits(nodeUnits, unitMeans(searchUnitScores(input.againstCells)));
+	const pairs = node.length;
+	const method = searchEstimateMethod(pairs);
+	const base = {
+		against,
 		split,
-		rep
-	])}`;
-}
-/** Digest a split's task list in taskId order. */
-function searchTaskSetDigest(tasks) {
-	return hashCanonical([...tasks].sort((left, right) => compareCodeUnits(left.taskId, right.taskId)));
-}
-/** 128 bits of SHA-256 over the canonical encoding: collision-safe and short
-* enough for directory names. */
-function shortDigest(value) {
-	return createHash("sha256").update(canonicalString(value)).digest("hex").slice(0, 32);
+		units: nodeUnits.length,
+		pairs,
+		method,
+		cellSetDigest,
+		estimator: SEARCH_ESTIMATOR
+	};
+	if (method === "none") return {
+		...base,
+		delta: null,
+		interval: null,
+		exactSignP: null,
+		indeterminate: false
+	};
+	const maximize = direction === "maximize";
+	const test = pairedDeltaTest(maximize ? other : node, maximize ? node : other, {
+		statistic: DECISION_PAIRED_DELTA_STATISTIC,
+		confidence: CONFIDENCE,
+		resamples: RESAMPLES,
+		seed: seedFromDigest(cellSetDigest)
+	});
+	const { mean, low, high } = test.bootstrap;
+	const indeterminate = test.indeterminate;
+	const spread = (method === "descriptive" || method === "bootstrap") && !indeterminate;
+	return {
+		...base,
+		delta: plain(maximize ? mean : -mean),
+		interval: spread ? maximize ? [plain(low), plain(high)] : [plain(-high), plain(-low)] : null,
+		exactSignP: method === "descriptive" && !indeterminate ? test.pValue : null,
+		indeterminate
+	};
 }
-const MAX_LABEL_CHARS$1 = 200;
-const USD_TOLERANCE = 1e-9;
-const SPLITS = [
-	"train",
-	"selection",
-	"test"
-];
 /**
-* Per-unit means of scored cells, in unitId order. Each unit sums its cells in
-* cellId order, so the result depends on the set of cells alone, never on the
-* order they settled in: a verifier that reads the same cells from a database
-* gets the same bits.
+* `estimateNodeFromCells` over the cells a search state holds: `nodeId`
+* against `against` on one split, in the direction the search's objective
+* declares.
 */
-function searchUnitScores(cells) {
-	const byUnit = /* @__PURE__ */ new Map();
-	for (const cell of cells) {
-		const unit = byUnit.get(cell.unitId);
-		if (unit) unit.push(cell);
-		else byUnit.set(cell.unitId, [cell]);
-	}
-	return [...byUnit.entries()].sort(([left], [right]) => compareCodeUnits(left, right)).map(([unitId, unitCells]) => {
-		let sum = 0;
-		for (const cell of unitCells.sort((left, right) => compareCodeUnits(left.cellId, right.cellId))) sum += cell.score;
-		return {
-			unitId,
-			sum,
-			count: unitCells.length,
-			mean: sum / unitCells.length
-		};
+function estimateNode(state, nodeId, options) {
+	const header = state.header;
+	if (!header) throw new SearchLedgerError(`search ${state.searchId} has not been opened`);
+	for (const id of [nodeId, options.against]) if (!state.hasNode(id)) throw new SearchLedgerError(`node ${id} is not in search ${state.searchId}`);
+	return estimateNodeFromCells({
+		nodeId,
+		against: options.against,
+		split: options.split,
+		direction: header.objective.direction,
+		nodeCells: state.scoredCells(nodeId, options.split),
+		againstCells: state.scoredCells(options.against, options.split)
 	});
 }
 /**
-* The pure, incremental projection of one search ledger. `apply` refuses any
-* entry that breaks an invariant; the journal then discards this instance and
-* replays into a new one, so a refused entry leaves no partial state behind.
+* The posterior every node's parent-selection draw uses. Each node's mean is
+* its improvement over the root on shared units; its variance is the search's
+* pooled between-unit variance divided by its unit count, so a node measured
+* on one unit has a wide posterior rather than none. The root is the reference
+* and sits at exactly 0.
 */
-var SearchState = class {
-	searchId;
-	version = 0;
-	header = null;
-	closed = null;
-	head = null;
-	lastOccurredAt = Number.NEGATIVE_INFINITY;
-	lastOccurredAtText = null;
-	tasks = /* @__PURE__ */ new Map();
-	nodes = /* @__PURE__ */ new Map();
-	nodeOrder = [];
-	nodeByDigest = /* @__PURE__ */ new Map();
-	edges = /* @__PURE__ */ new Map();
-	edgeOrder = [];
-	cells = /* @__PURE__ */ new Map();
-	operations = /* @__PURE__ */ new Map();
-	selectedNodeId = null;
-	claimUsedUsd = 0;
-	audit;
-	constructor(searchId) {
-		this.searchId = searchId;
-		this.audit = {
-			searchId,
-			eventCount: 0,
-			headHash: null,
-			status: "open",
-			closeReason: null,
-			nodes: 0,
-			nodesWithoutEdge: 0,
-			undecidedNodes: 0,
-			selectedNodeId: null,
-			edges: {
-				explicit: 0,
-				correlated: 0,
-				unknown: 0,
-				reproposals: 0
-			},
-			cells: {
-				allocated: 0,
-				settled: 0,
-				cancelled: 0,
-				open: 0
-			},
-			attempts: 0,
-			outcomes: {
-				passed: 0,
-				failed: 0,
-				errored: 0
-			},
-			operations: {
-				started: 0,
-				recorded: 0,
-				open: 0
-			},
-			spend: {
-				knownUsd: 0,
-				floorUsd: 0,
-				unknownCostCells: 0,
-				unknownCostOperations: 0,
-				committedUsd: 0,
-				openReservationUsd: 0,
-				overspendUsd: 0,
-				unreservedCells: 0,
-				boxMinutes: 0
-			},
-			tokens: {
-				inputTokens: 0,
-				outputTokens: 0,
-				cachedTokens: 0,
-				unknownTokenAttempts: 0
-			}
-		};
-	}
-	apply(entry, index) {
-		const event = entry.event;
-		if (this.closed) throw integrity(`event ${event.eventId} follows search-closed ${this.closed.eventId}`);
-		const occurredAt = Date.parse(event.occurredAt);
-		if (occurredAt < this.lastOccurredAt) throw integrity(`event ${event.eventId} occurred before the preceding event`);
-		assertUnique(event.artifacts.map(artifactKey), "artifact receipt", event.eventId);
-		if (event.kind === "search-opened") {
-			if (index !== 0 || this.header) throw integrity("search-opened must be the first and only opening event");
-			this.open(event);
-		} else {
-			if (!this.header) throw integrity(`event ${event.eventId} appears before search-opened`);
-			this.applyEvent(event, index);
+function searchPosterior(state, options = {}) {
+	const split = options.split ?? "selection";
+	const header = state.header;
+	if (!header) throw new SearchLedgerError(`search ${state.searchId} has not been opened`);
+	const rootNodeId = state.rootNodeId;
+	if (rootNodeId === null) throw new SearchLedgerError(`search ${state.searchId} has no root node yet`);
+	const sign = header.objective.direction === "maximize" ? 1 : -1;
+	const root = searchUnitScores(state.scoredCells(rootNodeId, split));
+	const rootMeans = unitMeans(root);
+	const nodes = [];
+	let squares = 0;
+	let degreesOfFreedom = 0;
+	for (const nodeId of state.nodeIds()) {
+		if (nodeId === rootNodeId) {
+			const measured = root.length > 0;
+			nodes.push({
+				nodeId,
+				pairs: root.length,
+				mean: measured ? 0 : null,
+				variance: measured ? 0 : null
+			});
+			continue;
 		}
-		this.lastOccurredAt = occurredAt;
-		this.lastOccurredAtText = event.occurredAt;
-		this.head = {
-			sequence: index,
-			entryHash: entry.entryHash
-		};
-		this.audit.eventCount = index + 1;
-		this.audit.headHash = entry.entryHash;
-		this.version += 1;
+		const { node, other } = pairUnits(searchUnitScores(state.scoredCells(nodeId, split)), rootMeans);
+		const gains = node.map((value, index) => sign * (value - other[index]));
+		const mean = gains.length > 0 ? sum(gains) / gains.length : null;
+		if (mean !== null && gains.length >= 2) {
+			squares += sum(gains.map((gain) => (gain - mean) ** 2));
+			degreesOfFreedom += gains.length - 1;
+		}
+		nodes.push({
+			nodeId,
+			pairs: gains.length,
+			mean: mean === null ? null : plain(mean),
+			variance: null
+		});
 	}
-	snapshot() {
-		return new SearchStateView(this, this.version);
+	const pooledVariance = degreesOfFreedom > 0 ? squares / degreesOfFreedom : null;
+	if (pooledVariance !== null) {
+		for (const posterior of nodes) if (posterior.nodeId !== rootNodeId && posterior.pairs > 0) posterior.variance = pooledVariance / posterior.pairs;
 	}
-	/** @internal Views check this before every read of the live indexes. */
-	isAt(version) {
-		return this.version === version;
+	return {
+		split,
+		rootNodeId,
+		pooledVariance,
+		degreesOfFreedom,
+		nodes
+	};
+}
+function unitMeans(units) {
+	return new Map(units.map((unit) => [unit.unitId, unit.mean]));
+}
+/** Unit means of two nodes on the units both scored, aligned in the node's
+* unitId order. */
+function pairUnits(node, otherMeans) {
+	const paired = {
+		node: [],
+		other: []
+	};
+	for (const unit of node) {
+		const mean = otherMeans.get(unit.unitId);
+		if (mean === void 0) continue;
+		paired.node.push(unit.mean);
+		paired.other.push(mean);
 	}
-	applyEvent(event, index) {
-		switch (event.kind) {
-			case "operation-started":
-				this.startOperation(event);
-				return;
-			case "operation-recorded":
-				this.recordOperation(event);
-				return;
-			case "node-registered":
-				this.registerNode(event, index);
-				return;
-			case "edge-recorded":
-				this.recordEdge(event, index);
-				return;
-			case "cell-allocated":
-				this.allocateCell(event, index);
-				return;
-			case "cell-settled":
-				this.settleCell(event, index);
-				return;
-			case "cell-cancelled":
-				this.cancelCell(event, index);
-				return;
-			case "node-decided":
-				this.decideNode(event, index);
-				return;
-			case "search-closed":
-				this.close(event);
-				return;
+	return paired;
+}
+function assertDistinctCells(cells, nodeId, against) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const cell of cells) {
+		if (seen.has(cell.cellId)) throw new SearchLedgerError(`cell ${cell.cellId} appears twice in the estimate of ${nodeId} against ${against}`);
+		if (!Number.isFinite(cell.score)) throw new SearchLedgerError(`cell ${cell.cellId} has a non-finite score ${cell.score}`);
+		seen.add(cell.cellId);
+	}
+}
+/** The first 32 bits of a `sha256:` digest, as the bootstrap's seed. */
+function seedFromDigest(digest) {
+	return Number.parseInt(digest.slice(7, 15), 16) | 0;
+}
+function sum(values) {
+	let total = 0;
+	for (const value of values) total += value;
+	return total;
+}
+/** Canonical JSON has one zero; never hand it a negative one. */
+function plain(value) {
+	return value === 0 ? 0 : value;
+}
+/** The kernel every `runSearch` ledger names as its search implementation. */
+const SEARCH_KERNEL_SOURCE = {
+	uri: "npm:@tangle-network/agent-eval#runSearch",
+	revision: hashCanonical({
+		name: "tangle.search-kernel.2026-09",
+		dispatch: "claim, then rung and root, then screen, then train; first allocated first within a stage",
+		expansion: "when no cell waits, fewer than twice the lanes capacity run, and the cap admits one proposal and its expected screens",
+		reservation: {
+			hard: "the lane per-cell maximum",
+			estimate: "1.5 times the p99 of the lane settled cells once 20 settled, else the lane prior"
+		},
+		retries: "a retryable errored attempt runs again, up to maxAttempts",
+		resume: "an unrecorded operation is recorded failed at an unknown cost with floor 0; a recorded proposal is finished from its stored output; an unsettled cell is offered to adopt before it runs",
+		writers: "one kernel per ledger file on a host, by a pid lock beside the ledger",
+		close: "the policy leader is selected when it has a scored cell; every other undecided node is rejected"
+	})
+};
+const USD_TOLERANCE = 1e-9;
+/** Settled cells a lane needs before its own cost distribution sets its estimate. */
+const ESTIMATE_FROM_CELLS = 20;
+const ESTIMATE_MARGIN = 1.5;
+const DEFAULT_MAX_ATTEMPTS = 3;
+/** Dispatch order: claim cells first, then rungs and the root, then screens, then train. */
+const STAGE_PRIORITY = {
+	claim: 0,
+	rung: 1,
+	root: 1,
+	screen: 2,
+	train: 3,
+	external: 3
+};
+/** Run a search to its close, or continue one from its ledger. */
+async function runSearch(options) {
+	return new SearchKernel(options).run();
+}
+/** The expansion index a kernel operation id encodes, or null. */
+function searchExpansionIndex(operationId) {
+	const match = /^expand-(\d+)$/.exec(operationId);
+	return match ? Number(match[1]) : null;
+}
+var SearchKernel = class {
+	options;
+	recorder;
+	maxAttempts;
+	now;
+	state;
+	lanes = /* @__PURE__ */ new Map();
+	inFlight = /* @__PURE__ */ new Map();
+	proposal = null;
+	proposalController = null;
+	completions = [];
+	wake = null;
+	/** Unfinished cells per node. */
+	pending = /* @__PURE__ */ new Map();
+	/** Admitted nodes whose screen finished, in registration order. */
+	screened = [];
+	screenedSet = /* @__PURE__ */ new Set();
+	admitted = /* @__PURE__ */ new Set();
+	expansionOf = /* @__PURE__ */ new Map();
+	artifacts = /* @__PURE__ */ new Map();
+	/** Children a proposal returned, by artifact digest, until they are registered. */
+	proposed = /* @__PURE__ */ new Map();
+	/** Cells the ledger showed unsettled at start: an earlier process may hold their attempt. */
+	adoptable = /* @__PURE__ */ new Set();
+	operationCosts = [];
+	/** Operations started: the next one's id. */
+	expansions = 0;
+	/** Proposals that completed, by operation index. A proposal an interrupted
+	* process lost counts toward none of the stop rules, so a resumed search
+	* makes the proposals the uninterrupted one would have made. */
+	completed = [];
+	stopReason = null;
+	failure = null;
+	constructor(options) {
+		this.options = options;
+		this.recorder = options.recorder;
+		this.maxAttempts = options.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+		this.now = options.now ?? Date.now;
+		if (!Number.isSafeInteger(this.maxAttempts) || this.maxAttempts < 1) throw new TypeError("runSearch: maxAttempts must be a positive integer");
+		const { maxExpansions } = options;
+		if (maxExpansions !== void 0 && (!Number.isSafeInteger(maxExpansions) || maxExpansions < 0)) throw new TypeError("runSearch: maxExpansions must be a non-negative integer");
+		for (const lane of options.executor.lanes()) {
+			if (!Number.isSafeInteger(lane.capacity) || lane.capacity < 1) throw new TypeError(`runSearch: lane ${lane.name} needs a positive integer capacity`);
+			if (!Number.isFinite(lane.cellUsd) || lane.cellUsd < 0) throw new TypeError(`runSearch: lane ${lane.name} needs a finite non-negative cellUsd`);
+			if (this.lanes.has(lane.name)) throw new TypeError(`runSearch: lane ${lane.name} is declared twice`);
+			this.lanes.set(lane.name, {
+				...lane,
+				inFlight: 0,
+				queues: [
+					[],
+					[],
+					[],
+					[]
+				],
+				settledCosts: []
+			});
 		}
+		if (this.lanes.size === 0) throw new TypeError("runSearch: the executor declares no lane");
 	}
-	open(event) {
-		if (event.containment?.searchId === this.searchId) throw integrity("a search cannot contain itself");
-		if (event.derivedFrom?.searchId === this.searchId) throw integrity("a search cannot derive from itself");
-		const units = {
-			train: /* @__PURE__ */ new Set(),
-			selection: /* @__PURE__ */ new Set(),
-			test: /* @__PURE__ */ new Set()
-		};
-		for (const split of SPLITS) {
-			const { tasks, taskSetDigest } = event.splits[split];
-			if (searchTaskSetDigest(tasks) !== taskSetDigest) throw integrity(`the ${split} split's taskSetDigest does not match its tasks`);
-			for (const task of tasks) {
-				const owner = this.tasks.get(task.taskId);
-				if (owner) throw integrity(`task ${task.taskId} is in both the ${owner.split} and ${split} splits`);
-				this.tasks.set(task.taskId, {
-					split,
-					unitId: task.unitId
-				});
-				units[split].add(task.unitId);
-			}
+	async run() {
+		const { ledger } = this.recorder;
+		const lock = ledger instanceof FileSearchLedger ? acquireSingleRunLock({ lockPath: `${ledger.path}.run.lock` }) : null;
+		try {
+			return await this.runLocked();
+		} finally {
+			lock?.release();
 		}
-		if (event.splits.heldOutUnits) {
-			const seen = [...units.test].filter((unit) => units.train.has(unit) || units.selection.has(unit));
-			if (seen.length > 0) throw integrity(`test units ${seen.join(", ")} also appear in train or selection, but the splits declare heldOutUnits`);
+	}
+	async runLocked() {
+		await this.refresh();
+		const header = this.state.header;
+		if (!header) throw new Error(`runSearch: search ${this.recorder.searchId} has not been opened`);
+		if (header.policy.expansion !== this.options.policy.name || header.policy.allocation !== this.options.allocation.name) throw new Error(`runSearch: search ${this.recorder.searchId} was opened with policy ${header.policy.expansion} and allocation ${header.policy.allocation}, not ${this.options.policy.name} and ${this.options.allocation.name}`);
+		if (this.state.closed) return this.closedResult();
+		await this.restore();
+		const { signal } = this.options;
+		const onAbort = () => {
+			for (const controller of this.inFlight.values()) controller.abort(signal?.reason);
+			this.proposalController?.abort(signal?.reason);
+			this.wakeUp();
+		};
+		signal?.addEventListener("abort", onAbort, { once: true });
+		try {
+			await this.loop();
+		} finally {
+			signal?.removeEventListener("abort", onAbort);
 		}
-		const { budget } = event;
-		if (budget.maxUsd !== null && budget.reservedClaimUsd > budget.maxUsd + USD_TOLERANCE) throw integrity(`the claim reserve $${budget.reservedClaimUsd} exceeds the search cap $${budget.maxUsd}`);
-		this.header = event;
-	}
-	startOperation(event) {
-		if (this.operations.has(event.operationId)) throw integrity(`operation ${event.operationId} was started twice`);
-		this.admit(event.reservation, false, `operation ${event.operationId}`);
-		this.operations.set(event.operationId, {
-			operationId: event.operationId,
-			operationKind: event.operationKind,
-			reservation: event.reservation,
-			recorded: false,
-			spentUsd: 0
-		});
-		this.audit.operations.started += 1;
-		this.audit.operations.open += 1;
-		this.audit.spend.openReservationUsd += event.reservation?.usd ?? 0;
-	}
-	recordOperation(event) {
-		const operation = this.operations.get(event.operationId);
-		if (!operation) throw integrity(`operation ${event.operationId} was recorded before it started`);
-		if (operation.recorded) throw integrity(`operation ${event.operationId} was recorded twice`);
-		if (operation.operationKind !== event.operationKind) throw integrity(`operation ${event.operationId} started as ${operation.operationKind} but recorded as ${event.operationKind}`);
-		const cost = this.book(event.accounting);
-		if (cost.unknown) this.audit.spend.unknownCostOperations += 1;
-		const reserved = operation.reservation?.usd ?? 0;
-		this.audit.spend.openReservationUsd -= reserved;
-		if (operation.reservation) this.audit.spend.overspendUsd += Math.max(0, cost.usd - reserved);
-		operation.recorded = true;
-		operation.spentUsd = cost.usd;
-		this.audit.operations.recorded += 1;
-		this.audit.operations.open -= 1;
-	}
-	registerNode(event, index) {
-		const expected = searchNodeId(this.searchId, event.artifactDigest);
-		if (event.nodeId !== expected) throw integrity(`node ${event.nodeId} does not match its artifact digest (expected ${expected})`);
-		if (this.nodes.has(event.nodeId)) throw integrity(`node ${event.nodeId} was registered twice; a re-proposal is a second edge into it`);
-		assertUnique(event.surfaces.map((surface) => surface.surfaceId), "surfaceId", event.eventId);
-		const maxNodes = this.header.budget.maxNodes;
-		if (maxNodes !== null && this.nodes.size + 1 > maxNodes) throw integrity(`node ${event.nodeId} exceeds the search's maxNodes ${maxNodes}`);
-		this.nodes.set(event.nodeId, {
-			event,
-			ordinal: this.nodeOrder.length,
-			registeredSequence: index,
-			updatedSequence: index,
-			edgeIds: [],
-			parents: [],
-			parentKeys: /* @__PURE__ */ new Set(),
-			primaryParentId: null,
-			depth: null,
-			children: [],
-			decisions: [],
-			finalist: false,
-			cellIds: [],
-			scoredCells: 0,
-			spend: {
-				knownUsd: 0,
-				floorUsd: 0,
-				unknownCostCells: 0,
-				boxMinutes: 0
-			}
-		});
-		this.nodeOrder.push(event.nodeId);
-		this.nodeByDigest.set(event.artifactDigest, event.nodeId);
-		this.audit.nodes += 1;
-		this.audit.nodesWithoutEdge += 1;
-		this.audit.undecidedNodes += 1;
-	}
-	recordEdge(event, index) {
-		if (this.edges.has(event.edgeId)) throw integrity(`edge ${event.edgeId} was recorded twice`);
-		const child = this.nodes.get(event.childNodeId);
-		if (!child) throw integrity(`edge ${event.edgeId} names unregistered child ${event.childNodeId}`);
-		if (event.label.length > MAX_LABEL_CHARS$1) throw integrity(`edge ${event.edgeId} label exceeds ${MAX_LABEL_CHARS$1} characters`);
-		if (event.diffs.length !== event.parents.length) throw integrity(`edge ${event.edgeId} needs one diff per parent`);
-		assertUnique(event.parents.map((parent) => canonicalString(parent)), "parent", event.eventId);
-		const { operator, attribution, parents } = event;
-		if (operator === "seed" !== (event.proposer === null)) throw integrity(`edge ${event.edgeId}: exactly the seed edge has no proposer`);
-		if (operator === "seed" && (parents.length > 0 || attribution === "unknown")) throw integrity(`seed edge ${event.edgeId} must have no parents and a known attribution`);
-		if (attribution === "unknown" && parents.length > 0) throw integrity(`edge ${event.edgeId} has unknown attribution but names parents`);
-		if (operator !== "seed" && attribution !== "unknown" && parents.length === 0) throw integrity(`${operator} edge ${event.edgeId} names no parent`);
-		if (operator === "merge" && attribution !== "unknown" && parents.length < 2) throw integrity(`merge edge ${event.edgeId} needs at least two parents`);
-		const operationId = event.proposer?.operationId ?? null;
-		if (operationId !== null && !this.operations.has(operationId)) throw integrity(`edge ${event.edgeId} names operation ${operationId}, which never started`);
-		const inSearch = [];
-		for (const parent of parents) {
-			if (parent.searchId !== this.searchId) {
-				const from = this.header.derivedFrom;
-				if (operator !== "derive" || parents.length !== 1 || !from || from.searchId !== parent.searchId || from.nodeId !== parent.nodeId) throw integrity(`edge ${event.edgeId} names a parent in search ${parent.searchId}; only a derive edge matching derivedFrom may`);
+		if (this.failure) throw this.failure.error;
+		await this.close();
+		return this.closedResult();
+	}
+	async restore() {
+		const rootInput = this.options.codec.node(this.recorder, this.options.root);
+		const rootId = this.state.rootNodeId;
+		if (rootId === null) {
+			const { nodeId } = await this.recorder.registerNode(rootInput);
+			await this.recorder.recordEdge({
+				childNodeId: nodeId,
+				parents: [],
+				operator: "seed",
+				attribution: "explicit",
+				proposer: null,
+				proposalKey: "root",
+				rationale: { unknown: "the root is the caller-supplied starting artifact" },
+				diffs: [],
+				label: "root"
+			});
+			await this.refresh();
+		} else if (this.state.node(rootId).artifactDigest !== rootInput.artifactDigest) throw new Error(`runSearch: search ${this.recorder.searchId} started from another root artifact; a changed start is a derived search`);
+		const root = this.state.rootNodeId;
+		this.artifacts.set(root, this.options.root);
+		this.expansionOf.set(root, -1);
+		const recorded = [];
+		for (let expansion = 0;; expansion++) {
+			const operationId = `expand-${expansion}`;
+			const operation = this.state.operation(operationId);
+			if (!operation) break;
+			this.expansions = expansion + 1;
+			if (operation.recorded) {
+				this.operationCosts.push(operation.spentUsd);
+				recorded.push(expansion);
+				if (operation.outcome === "completed") this.completed.push(expansion);
 				continue;
 			}
-			if (operator === "derive") throw integrity(`derive edge ${event.edgeId} must name the parent in derivedFrom`);
-			const record = this.nodes.get(parent.nodeId);
-			if (!record) throw integrity(`edge ${event.edgeId} names unregistered parent ${parent.nodeId}`);
-			if (record.ordinal >= child.ordinal) throw integrity(`edge ${event.edgeId}: parent ${parent.nodeId} registered after child ${child.event.nodeId}`);
-			if (record.edgeIds.length === 0) throw integrity(`edge ${event.edgeId}: parent ${parent.nodeId} has no edge of its own yet`);
-			inSearch.push(record);
+			await this.recorder.recordOperation({
+				operationId,
+				operationKind: "candidate-generation",
+				execution: this.options.proposer.execution,
+				outcome: {
+					status: "failed",
+					failure: {
+						code: "interrupted",
+						message: "the search stopped while this proposal ran; its output was lost"
+					}
+				},
+				accounting: interruptedAccounting()
+			});
+			await this.refresh();
 		}
-		if (child.edgeIds.length === 0) {
-			const primary = inSearch[0];
-			child.primaryParentId = primary?.event.nodeId ?? null;
-			child.depth = operator === "seed" || operator === "derive" ? 0 : primary && primary.depth !== null ? primary.depth + 1 : null;
-			this.audit.nodesWithoutEdge -= 1;
-		} else this.audit.edges.reproposals += 1;
-		child.edgeIds.push(event.edgeId);
-		for (const parent of parents) {
-			const key = canonicalString(parent);
-			if (child.parentKeys.has(key)) continue;
-			child.parentKeys.add(key);
-			child.parents.push(parent);
+		for (const node of this.state.nodes()) {
+			if (node.edgeIds.length === 0) continue;
+			const edge = this.state.edge(node.edgeIds[0]);
+			const expansion = edge.proposer?.operationId ? searchExpansionIndex(edge.proposer.operationId) : null;
+			this.expansionOf.set(node.nodeId, expansion ?? -1);
+			if (node.status !== "invalid") this.admitted.add(node.nodeId);
 		}
-		for (const parent of inSearch) if (!parent.children.includes(child.event.nodeId)) parent.children.push(child.event.nodeId);
-		child.updatedSequence = index;
-		this.edges.set(event.edgeId, event);
-		this.edgeOrder.push(event.edgeId);
-		this.audit.edges[attribution] += 1;
-	}
-	allocateCell(event, index) {
-		const expected = searchCellId(this.searchId, event.nodeId, event.taskId, event.split, event.rep);
-		if (event.cellId !== expected) throw integrity(`cell ${event.cellId} does not match its coordinates (expected ${expected})`);
-		if (this.cells.has(event.cellId)) throw integrity(`cell ${event.cellId} was allocated twice`);
-		const node = this.nodes.get(event.nodeId);
-		if (!node) throw integrity(`cell ${event.cellId} names unregistered node ${event.nodeId}`);
-		if (node.edgeIds.length === 0) throw integrity(`cell ${event.cellId}: node ${event.nodeId} has no edge yet`);
-		const task = this.tasks.get(event.taskId);
-		if (!task || task.split !== event.split) throw integrity(`cell ${event.cellId}: task ${event.taskId} is not in the ${event.split} split`);
-		if (task.unitId !== event.unitId) throw integrity(`cell ${event.cellId}: task ${event.taskId} samples unit ${task.unitId}`);
-		assertStageSplit(event.cellId, event.stage, event.split, node.ordinal === 0);
-		if (event.split === "test" && node.ordinal !== 0 && !node.finalist) throw integrity(`cell ${event.cellId}: the test split is sealed; only the root and finalists run on it`);
-		const maxCells = this.header.budget.maxCells;
-		if (maxCells !== null && this.audit.cells.allocated + 1 > maxCells) throw integrity(`cell ${event.cellId} exceeds the search's maxCells ${maxCells}`);
-		this.admit(event.reservation, event.stage === "claim", `cell ${event.cellId}`);
-		this.cells.set(event.cellId, {
-			cellId: event.cellId,
-			nodeId: event.nodeId,
-			taskId: event.taskId,
-			unitId: event.unitId,
-			split: event.split,
-			rep: event.rep,
-			stage: event.stage,
-			lane: event.lane,
-			reservation: event.reservation,
-			attempts: 0,
-			lastRunId: null,
-			outcome: null,
-			score: null,
-			final: false,
-			cancelled: null,
-			spentUsd: 0,
-			costKnown: true,
-			traceId: null,
-			allocatedSequence: index,
-			updatedSequence: index
-		});
-		node.cellIds.push(event.cellId);
-		node.updatedSequence = index;
-		this.audit.cells.allocated += 1;
-		this.audit.cells.open += 1;
-		this.audit.spend.openReservationUsd += event.reservation?.usd ?? 0;
-		if (event.stage === "claim") this.claimUsedUsd += event.reservation?.usd ?? 0;
-	}
-	settleCell(event, index) {
-		const cell = this.cells.get(event.cellId);
-		if (!cell) throw integrity(`attempt ${event.eventId} names unallocated cell ${event.cellId}`);
-		if (cell.cancelled) throw integrity(`cell ${event.cellId} was settled after it was cancelled`);
-		if (cell.final) throw integrity(`cell ${event.cellId} was attempted again after a final ${cell.outcome} outcome; only a retryable error admits another attempt`);
-		if (event.attempt !== cell.attempts + 1) throw integrity(`cell ${event.cellId} attempt ${event.attempt} is not contiguous (expected ${cell.attempts + 1})`);
-		const runId = searchCellRunId({
-			cellId: event.cellId,
-			attempt: event.attempt
-		});
-		if (event.runId !== runId) throw integrity(`cell ${event.cellId} attempt ${event.attempt} must have runId ${runId}`);
-		const node = this.nodes.get(cell.nodeId);
-		const declared = new Set(node.event.surfaces.map((surface) => surface.surfaceId));
-		assertUnique(event.surfaceEvidence.map((evidence) => evidence.surfaceId), "surface evidence", event.eventId);
-		for (const evidence of event.surfaceEvidence) if (!declared.has(evidence.surfaceId)) throw integrity(`attempt ${event.eventId} reports surface ${evidence.surfaceId}, which node ${cell.nodeId} does not declare`);
-		if (event.artifacts.filter((artifact) => artifact.role === "run-record").length > 1) throw integrity(`attempt ${event.eventId} binds more than one RunRecord`);
-		const before = this.reservationParts(cell);
-		const cost = this.book(event.accounting);
-		if (cell.attempts === 0) {
-			this.audit.cells.settled += 1;
-			this.audit.cells.open -= 1;
-			if (cell.reservation === null) this.audit.spend.unreservedCells += 1;
+		for (const cell of this.state.cells()) {
+			const lane = cell.lane === null ? void 0 : this.lanes.get(cell.lane);
+			if (cell.final && lane) lane.settledCosts.push(cell.spentUsd);
+			if (this.cellDone(cell)) continue;
+			if (!lane) throw new Error(`runSearch: cell ${cell.cellId} was placed on lane ${String(cell.lane)}, which the executor does not declare`);
+			this.adoptable.add(cell.cellId);
+			this.enqueue(cell);
+			this.pending.set(cell.nodeId, (this.pending.get(cell.nodeId) ?? 0) + 1);
 		}
-		if (cost.unknown && cell.costKnown) {
-			cell.costKnown = false;
-			this.audit.spend.unknownCostCells += 1;
-			node.spend.unknownCostCells += 1;
+		for (const expansion of recorded) await this.finishProposal(expansion);
+		for (const node of this.state.nodes()) if (this.admitted.has(node.nodeId) && !isTerminal(node)) await this.allocateFor(node.nodeId);
+		for (const nodeId of this.state.nodeIds()) if (this.admitted.has(nodeId) && (this.pending.get(nodeId) ?? 0) === 0) this.markScreened(nodeId);
+	}
+	async loop() {
+		for (;;) {
+			if (this.failure || this.options.signal?.aborted) {
+				await this.drain(this.failure?.error ?? this.options.signal?.reason);
+				this.failure ??= { error: this.options.signal?.reason ?? /* @__PURE__ */ new Error("aborted") };
+				return;
+			}
+			if (this.pastDeadline()) {
+				this.stopReason ??= "deadline";
+				if (this.queuedCount() > 0) await this.cancelQueued("deadline");
+			}
+			this.dispatch();
+			const blocked = this.stopReason === null && this.proposal === null ? await this.tryExpand() : null;
+			if (!(this.inFlight.size > 0 || this.proposal !== null)) {
+				if (this.queuedCount() > 0) continue;
+				this.stopReason ??= blocked ?? "converged";
+				return;
+			}
+			await this.handle(await this.next());
 		}
-		cell.attempts = event.attempt;
-		cell.lastRunId = runId;
-		cell.outcome = event.outcome.status;
-		cell.spentUsd += cost.usd;
-		cell.updatedSequence = index;
-		if ("traceId" in event.traceRef) cell.traceId = event.traceRef.traceId;
-		if (event.outcome.status === "errored") cell.final = !event.outcome.error.retryable;
-		else {
-			cell.final = true;
-			cell.score = event.outcome.score;
-			node.scoredCells += 1;
+	}
+	/** The next completion, or null when an abort woke the loop without one. */
+	async next() {
+		if (this.completions.length === 0) await new Promise((resolve) => {
+			this.wake = resolve;
+		});
+		return this.completions.shift() ?? null;
+	}
+	push(completion) {
+		this.completions.push(completion);
+		this.wakeUp();
+	}
+	wakeUp() {
+		const wake = this.wake;
+		this.wake = null;
+		wake?.();
+	}
+	async handle(completion) {
+		if (completion === null) return;
+		if (completion.kind === "cell") await this.settle(completion);
+		else await this.recordProposal(completion);
+	}
+	/** Abort everything in flight and record what still completes. */
+	async drain(reason) {
+		for (const controller of this.inFlight.values()) controller.abort(reason);
+		this.proposalController?.abort(reason);
+		while (this.inFlight.size > 0 || this.proposal !== null) await this.handle(await this.next());
+	}
+	/** Fill free lane slots with queued cells. A queued cell was admitted when
+	* it was allocated, so starting it needs no further decision. */
+	dispatch() {
+		if (this.failure || this.options.signal?.aborted || this.pastDeadline()) return;
+		const cap = this.state.header.budget.maxConcurrency;
+		for (const lane of this.lanes.values()) while (lane.inFlight < lane.capacity && (cap === null || this.inFlight.size < cap)) {
+			const cellId = lane.queues.find((queue) => queue.length > 0)?.shift();
+			if (cellId === void 0) break;
+			this.start(cellId, lane);
 		}
-		const after = this.reservationParts(cell);
-		this.audit.spend.openReservationUsd += after.open - before.open;
-		this.audit.spend.overspendUsd += after.over - before.over;
-		if (cell.stage === "claim") this.claimUsedUsd += after.used - before.used;
-		if (cost.unknown) node.spend.floorUsd += cost.usd;
-		else node.spend.knownUsd += cost.usd;
-		const boxMinutes = event.boxMinutes ?? 0;
-		node.spend.boxMinutes += boxMinutes;
-		this.audit.spend.boxMinutes += boxMinutes;
-		node.updatedSequence = index;
-		this.audit.attempts += 1;
-		this.audit.outcomes[event.outcome.status] += 1;
-	}
-	cancelCell(event, index) {
-		const cell = this.cells.get(event.cellId);
-		if (!cell) throw integrity(`cancellation ${event.eventId} names unallocated cell ${event.cellId}`);
-		if (cell.cancelled) throw integrity(`cell ${event.cellId} was cancelled twice`);
-		if (cell.final) throw integrity(`cell ${event.cellId} was cancelled after a final outcome`);
-		const before = this.reservationParts(cell);
-		cell.cancelled = event.reason;
-		cell.updatedSequence = index;
-		const after = this.reservationParts(cell);
-		this.audit.spend.openReservationUsd += after.open - before.open;
-		this.audit.spend.overspendUsd += after.over - before.over;
-		if (cell.stage === "claim") this.claimUsedUsd += after.used - before.used;
-		if (cell.attempts === 0) {
-			this.audit.cells.cancelled += 1;
-			this.audit.cells.open -= 1;
+	}
+	start(cellId, lane) {
+		const cell = this.state.cell(cellId);
+		const attempt = cell.attempts + 1;
+		const controller = new AbortController();
+		const work = {
+			searchId: this.recorder.searchId,
+			cellId,
+			nodeId: cell.nodeId,
+			taskId: cell.taskId,
+			unitId: cell.unitId,
+			split: cell.split,
+			rep: cell.rep,
+			stage: cell.stage,
+			lane: lane.name,
+			attempt,
+			runId: `${cellId}:${attempt}`,
+			artifact: this.artifact(cell.nodeId),
+			signal: controller.signal
+		};
+		const adopt = this.adoptable.delete(cellId);
+		this.inFlight.set(cellId, controller);
+		lane.inFlight += 1;
+		const { executor } = this.options;
+		(async () => (adopt ? await executor.adopt(work) : null) ?? await executor.run(work))().then((result) => this.push({
+			kind: "cell",
+			cellId,
+			attempt,
+			result
+		}), (error) => this.push({
+			kind: "cell",
+			cellId,
+			attempt,
+			error
+		}));
+	}
+	async settle(completion) {
+		const { cellId, attempt } = completion;
+		this.inFlight.delete(cellId);
+		const before = this.state.cell(cellId);
+		const lane = this.lanes.get(before.lane);
+		lane.inFlight -= 1;
+		if (!completion.result) {
+			this.failure ??= { error: completion.error };
+			return;
 		}
-		this.nodes.get(cell.nodeId).updatedSequence = index;
-	}
-	decideNode(event, index) {
-		const node = this.nodes.get(event.nodeId);
-		if (!node) throw integrity(`decision ${event.eventId} names unregistered node ${event.nodeId}`);
-		if (node.edgeIds.length === 0) throw integrity(`decision ${event.eventId}: node ${event.nodeId} has no edge yet`);
-		const status = event.decision.status;
-		if (status === "selected") {
-			if (this.selectedNodeId !== null && this.selectedNodeId !== event.nodeId) throw integrity(`node ${event.nodeId} was selected while ${this.selectedNodeId} is still selected`);
-			if (node.scoredCells === 0) throw integrity(`node ${event.nodeId} cannot be selected without a scored cell`);
+		this.dispatch();
+		if ((this.failure || this.options.signal?.aborted) && completion.result.outcome.status === "errored") return;
+		await this.recorder.settleCell({
+			...completion.result,
+			cellId,
+			attempt
+		});
+		await this.refresh();
+		const cell = this.state.cell(cellId);
+		if (cell.final) lane.settledCosts.push(cell.spentUsd);
+		if (!this.cellDone(cell)) {
+			if (this.failure || this.options.signal?.aborted) return;
+			this.enqueue(cell);
+			return;
 		}
-		const previous = node.decisions.at(-1)?.decision.status ?? null;
-		const wasUndecided = previous === null || previous === "advanced";
-		const isUndecided = status === "advanced";
-		this.audit.undecidedNodes += (isUndecided ? 1 : 0) - (wasUndecided ? 1 : 0);
-		if (previous === "selected" && status !== "selected") this.selectedNodeId = null;
-		if (status === "selected") this.selectedNodeId = event.nodeId;
-		if (status === "finalist") node.finalist = true;
-		node.decisions.push({
-			sequence: index,
-			decision: event.decision,
-			basis: event.basis,
-			rule: event.rule,
-			reason: event.reason
+		const left = (this.pending.get(cell.nodeId) ?? 1) - 1;
+		this.pending.set(cell.nodeId, left);
+		if (left === 0) await this.onScreenDone(cell.nodeId);
+	}
+	async onScreenDone(nodeId) {
+		this.markScreened(nodeId);
+		if (this.stopReason === null && !this.failure) await this.allocateFor(nodeId);
+	}
+	markScreened(nodeId) {
+		if (this.screenedSet.has(nodeId)) return;
+		this.screenedSet.add(nodeId);
+		const ordinal = this.state.node(nodeId).ordinal;
+		let index = this.screened.length;
+		while (index > 0 && this.state.node(this.screened[index - 1]).ordinal > ordinal) index--;
+		this.screened = [
+			...this.screened.slice(0, index),
+			nodeId,
+			...this.screened.slice(index)
+		];
+	}
+	/** Allocate the cells the allocator plans for a node and the ledger lacks. */
+	async allocateFor(nodeId) {
+		const plans = this.options.allocation.plan(this.state, nodeId).filter((plan) => !this.state.cell(searchCellId(this.recorder.searchId, nodeId, plan.taskId, plan.split, plan.rep)));
+		if (plans.length === 0) return;
+		const placed = plans.map((plan) => {
+			const laneName = this.options.executor.place({
+				...plan,
+				nodeId
+			});
+			const lane = this.lanes.get(laneName);
+			if (!lane) throw new Error(`runSearch: the executor placed a cell on unknown lane ${laneName}`);
+			return {
+				plan,
+				lane,
+				reservation: this.cellReservation(lane)
+			};
 		});
-		node.updatedSequence = index;
-		this.audit.selectedNodeId = this.selectedNodeId;
-	}
-	close(event) {
-		const reasons = this.incompleteReasons();
-		if (reasons.length > 0) throw integrity(`search-closed while incomplete: ${reasons.join("; ")}`);
-		if (event.claim) this.checkClaim(event.claim);
-		this.closed = event;
-		this.audit.status = "closed";
-		this.audit.closeReason = event.reason;
-		this.audit.spend.openReservationUsd = 0;
-	}
-	checkClaim(claim) {
-		if (claim.finalists.length > 3) throw integrity(`the claim names ${claim.finalists.length} finalists; at most 3 are allowed`);
-		assertUnique(claim.finalists.map((finalist) => finalist.nodeId), "claim finalist", "search-closed");
-		for (const finalist of claim.finalists) if (!this.nodes.get(finalist.nodeId)?.finalist) throw integrity(`claim finalist ${finalist.nodeId} was never decided finalist`);
-		if (claim.selected !== this.selectedNodeId) throw integrity(`the claim selects ${claim.selected ?? "nothing"} but the selected node is ${this.selectedNodeId ?? "none"}`);
-		const root = this.nodeOrder[0] ?? null;
-		if (claim.decision === "ship") {
-			const shipped = claim.finalists.find((finalist) => finalist.nodeId === claim.selected);
-			if (claim.selected === null || claim.selected === root || !shipped?.promote) throw integrity("a ship claim must select a finalist that the paired test promoted");
-			if (!this.header.splits.heldOutUnits) throw integrity("a ship claim needs test units held out from train and selection");
-		} else if (claim.selected !== null && claim.selected !== root) throw integrity(`a ${claim.decision} claim keeps the root; it cannot select another node`);
-		if (claim.decision === "test-cannot-resolve") {
-			for (const cell of this.cells.values()) if (cell.split === "test" && cell.attempts > 0) throw integrity("a test-cannot-resolve claim spends nothing on test cells");
+		const hold = placed.reduce((sum, { reservation }) => sum + reservation.usd, 0);
+		const { headroomUsd } = this.state.budget;
+		if (headroomUsd !== null && hold > headroomUsd + USD_TOLERANCE) return;
+		const { maxCells } = this.state.header.budget;
+		if (maxCells !== null && this.state.audit.cells.allocated + placed.length > maxCells) return;
+		for (const { plan, lane, reservation } of placed) await this.recorder.allocateCell({
+			nodeId,
+			taskId: plan.taskId,
+			split: plan.split,
+			rep: plan.rep,
+			stage: plan.stage,
+			lane: lane.name,
+			reservation
+		});
+		await this.refresh();
+		for (const { plan } of placed) {
+			const cellId = searchCellId(this.recorder.searchId, nodeId, plan.taskId, plan.split, plan.rep);
+			this.enqueue(this.state.cell(cellId));
+		}
+		this.pending.set(nodeId, (this.pending.get(nodeId) ?? 0) + placed.length);
+		this.dispatch();
+	}
+	enqueue(cell) {
+		this.lanes.get(cell.lane).queues[STAGE_PRIORITY[cell.stage]].push(cell.cellId);
+	}
+	queuedCount() {
+		let count = 0;
+		for (const lane of this.lanes.values()) for (const queue of lane.queues) count += queue.length;
+		return count;
+	}
+	async cancelQueued(reason) {
+		for (const lane of this.lanes.values()) for (const queue of lane.queues) for (const cellId of queue.splice(0)) {
+			const cell = this.state.cell(cellId);
+			if (cell.attempts === 0) {
+				await this.recorder.cancelCell({
+					cellId,
+					reason
+				});
+				await this.refresh();
+			}
+			const left = (this.pending.get(cell.nodeId) ?? 1) - 1;
+			this.pending.set(cell.nodeId, left);
+			if (left === 0) this.markScreened(cell.nodeId);
 		}
 	}
-	/** @internal */
-	incompleteReasons() {
-		const reasons = [];
-		if (!this.header) reasons.push("search-opened is missing");
-		if (this.audit.cells.open > 0) reasons.push(count(this.audit.cells.open, "cell", "has no outcome"));
-		if (this.audit.operations.open > 0) reasons.push(count(this.audit.operations.open, "operation", "is unrecorded"));
-		if (this.audit.nodesWithoutEdge > 0) reasons.push(count(this.audit.nodesWithoutEdge, "node", "has no edge"));
-		if (this.audit.undecidedNodes > 0) reasons.push(count(this.audit.undecidedNodes, "node", "has no terminal decision"));
-		return reasons;
-	}
-	/** Book an attempt's or operation's accounting into the running totals. An
-	* unknown cost counts as its proven floor. */
-	book(accounting) {
-		const { tokens, cost } = accounting;
-		if (tokens.status === "known") {
-			this.audit.tokens.inputTokens += tokens.inputTokens;
-			this.audit.tokens.outputTokens += tokens.outputTokens;
-			this.audit.tokens.cachedTokens += tokens.cachedTokens;
-		} else this.audit.tokens.unknownTokenAttempts += 1;
-		const usd = cost.status === "known" ? cost.usd : cost.knownLowerBoundUsd;
-		if (cost.status === "known") this.audit.spend.knownUsd += usd;
-		else this.audit.spend.floorUsd += usd;
-		this.audit.spend.committedUsd += usd;
-		return {
-			usd,
-			unknown: cost.status === "unknown"
+	/** No further attempt will run: a final outcome, a cancellation, or a
+	* retryable error that used up its attempts. */
+	cellDone(cell) {
+		return cell.final || cell.cancelled !== null || cell.outcome === "errored" && cell.attempts >= this.maxAttempts;
+	}
+	/** Start a proposal when the rules admit one; otherwise say why not. */
+	async tryExpand() {
+		const { maxNodes, maxCells } = this.state.header.budget;
+		if (maxNodes !== null && this.state.audit.nodes >= maxNodes) return "max-nodes";
+		const { maxExpansions } = this.options;
+		if (maxExpansions !== void 0 && this.completed.length >= maxExpansions) return "max-nodes";
+		if (this.queuedCount() > 0) return "converged";
+		if (this.inFlight.size >= 2 * this.capacity()) return "converged";
+		const view = this.policyView();
+		const { policy } = this.options;
+		const leader = policy.leader(view);
+		if (policy.patience !== void 0 && this.completed.filter((index) => index > (this.expansionOf.get(leader) ?? -1)).length >= policy.patience) return "patience";
+		const screen = this.options.allocation.screenSize(this.state);
+		const operation = this.operationReservation();
+		const children = this.options.proposer.childrenPerProposal ?? 1;
+		const need = operation.usd + children * screen * this.maxCellReservation();
+		const { headroomUsd } = this.state.budget;
+		if (headroomUsd !== null && need > headroomUsd + USD_TOLERANCE) return "budget";
+		if (maxCells !== null && this.state.audit.cells.allocated + children * screen > maxCells) return "budget";
+		const expansion = policy.expand(view);
+		if (expansion === null) return "converged";
+		const index = this.expansions++;
+		const operationId = `expand-${index}`;
+		await this.recorder.startOperation({
+			operationId,
+			operationKind: "candidate-generation",
+			reservation: operation
+		});
+		await this.refresh();
+		const controller = new AbortController();
+		const request = {
+			expansion: index,
+			operationId,
+			operator: expansion.operator,
+			parents: expansion.parents.map((nodeId) => ({
+				nodeId,
+				artifact: this.artifact(nodeId)
+			})),
+			leader,
+			signal: controller.signal
 		};
+		this.proposalController = controller;
+		this.proposal = this.options.proposer.propose(request).then((result) => this.push({
+			kind: "proposal",
+			expansion: index,
+			operationId,
+			request,
+			selection: expansion.selection,
+			result
+		}), (error) => this.push({
+			kind: "proposal",
+			expansion: index,
+			operationId,
+			request,
+			selection: expansion.selection,
+			error
+		}));
+		return null;
 	}
-	/** A cell's share of the open reservations, its overspend, and what it draws
-	* from the claim reserve: the larger of its hold and its spend. */
-	reservationParts(cell) {
-		const reserved = cell.reservation?.usd ?? 0;
-		const holding = !cell.final && cell.cancelled === null;
-		return {
-			open: holding ? Math.max(0, reserved - cell.spentUsd) : 0,
-			over: cell.reservation ? Math.max(0, cell.spentUsd - reserved) : 0,
-			used: holding ? Math.max(reserved, cell.spentUsd) : cell.spentUsd
+	async recordProposal(completion) {
+		this.proposal = null;
+		this.proposalController = null;
+		const { operationId, expansion } = completion;
+		const { proposer, codec, admit } = this.options;
+		const result = completion.result;
+		if (!result) {
+			await this.recorder.recordOperation({
+				operationId,
+				operationKind: "candidate-generation",
+				execution: proposer.execution,
+				outcome: {
+					status: "failed",
+					failure: {
+						code: "proposer-error",
+						message: errorMessage(completion.error)
+					}
+				},
+				accounting: interruptedAccounting()
+			});
+			await this.refresh();
+			this.failure ??= { error: completion.error };
+			return;
+		}
+		const { maxNodes } = this.state.header.budget;
+		const room = maxNodes === null ? Number.POSITIVE_INFINITY : maxNodes - this.state.audit.nodes;
+		const parents = completion.request.parents;
+		const blob = {
+			kind: "search-proposal",
+			operator: completion.request.operator,
+			parents: parents.map((parent) => parent.nodeId),
+			selection: completion.selection,
+			children: result.children.slice(0, Math.max(0, room)).map((child) => ({
+				node: codec.node(this.recorder, child.artifact),
+				diffs: parents.map((parent) => codec.diff(this.recorder, parent.artifact, child.artifact)),
+				label: redactText(child.label, { profile: "share" }),
+				rationale: redactText(child.rationale, { profile: "share" }),
+				attribution: child.attribution ?? null,
+				invalid: admit?.(child.artifact) ?? null
+			}))
 		};
+		await this.recorder.recordOperation({
+			operationId,
+			operationKind: "candidate-generation",
+			execution: result.execution ?? proposer.execution,
+			outcome: { status: "completed" },
+			accounting: result.accounting,
+			artifacts: [this.recorder.blob("proposal", blob)]
+		});
+		await this.refresh();
+		this.operationCosts.push(this.state.operation(operationId).spentUsd);
+		this.completed.push(expansion);
+		for (const [index, child] of blob.children.entries()) this.proposed.set(child.node.artifactDigest, result.children[index].artifact);
+		if (result.stop !== void 0 || blob.children.length === 0) this.stopReason ??= "converged";
+		await this.finishProposal(expansion);
+	}
+	/** Register every child a recorded proposal produced, each once. */
+	async finishProposal(expansion) {
+		const operationId = `expand-${expansion}`;
+		const operation = this.state.operation(operationId);
+		const ref = operation?.artifacts.find((artifact) => artifact.role === "proposal");
+		if (!operation?.recorded || operation.outcome !== "completed" || !ref) return;
+		const blob = this.recorder.readBlob(ref);
+		const { proposer } = this.options;
+		for (const [index, child] of blob.children.entries()) {
+			const { nodeId } = await this.recorder.registerNode(child.node);
+			const held = this.proposed.get(child.node.artifactDigest);
+			if (held !== void 0) {
+				this.proposed.delete(child.node.artifactDigest);
+				if (!this.artifacts.has(nodeId)) this.artifacts.set(nodeId, held);
+			}
+			const edgeId = await this.recorder.recordEdge({
+				childNodeId: nodeId,
+				parents: blob.parents,
+				operator: blob.operator,
+				attribution: "explicit",
+				proposer: {
+					kind: proposer.kind,
+					name: proposer.name,
+					operationId,
+					source: proposer.source
+				},
+				proposalKey: `${operationId}:${index}`,
+				selection: blob.selection,
+				rationale: child.rationale,
+				diffs: child.diffs,
+				label: child.label
+			});
+			await this.refresh();
+			if (this.state.node(nodeId).edgeIds[0] !== edgeId) continue;
+			this.expansionOf.set(nodeId, expansion);
+			if (child.invalid !== null) {
+				await this.recorder.decideNode({
+					nodeId,
+					decision: { status: "invalid" },
+					rule: "admission",
+					reason: child.invalid
+				});
+				await this.refresh();
+				continue;
+			}
+			if (this.admitted.has(nodeId)) continue;
+			this.admitted.add(nodeId);
+			await this.allocateFor(nodeId);
+			if ((this.pending.get(nodeId) ?? 0) === 0) this.markScreened(nodeId);
+		}
 	}
-	/** The admission rule: committed spend, open holds, the unspent claim
-	* reserve and the new hold stay within the cap. A claim cell draws on the
-	* claim reserve instead of adding to it. */
-	admit(reservation, claim, subject) {
-		const { maxUsd, reservedClaimUsd } = this.header.budget;
-		if (maxUsd === null) return;
-		const hold = reservation?.usd ?? 0;
-		const remainingClaim = Math.max(0, reservedClaimUsd - this.claimUsedUsd);
-		if (this.audit.spend.committedUsd + this.audit.spend.openReservationUsd + (claim ? Math.max(0, remainingClaim - hold) : remainingClaim) + hold > maxUsd + USD_TOLERANCE) throw integrity(`${subject} is not admissible: committed $${round(this.audit.spend.committedUsd)} + open $${round(this.audit.spend.openReservationUsd)} + claim reserve $${round(remainingClaim)} + hold $${round(hold)} exceeds the cap $${maxUsd}`);
-	}
-	/** @internal */
-	readHeader() {
-		return this.header;
-	}
-	/** @internal */
-	readClosed() {
-		return this.closed;
-	}
-	/** @internal */
-	readHead() {
-		return this.head;
-	}
-	/** @internal */
-	readLastOccurredAt() {
-		return this.lastOccurredAtText;
-	}
-	/** @internal */
-	readAudit() {
-		const audit = this.audit;
+	async close() {
+		await this.refresh();
+		const view = this.policyView();
+		const leader = this.options.policy.leader(view);
+		const { split } = view;
+		const root = this.state.rootNodeId;
+		const rule = this.options.policy.name;
+		const decisions = this.state.nodes().filter((node) => !isTerminal(node)).map((node) => {
+			const scored = this.state.scoredCells(node.nodeId, split).length > 0;
+			const lead = node.nodeId === leader && scored;
+			const against = node.nodeId === leader ? root : leader;
+			const basis = node.nodeId === against || !scored ? null : estimateNode(this.state, node.nodeId, {
+				against,
+				split
+			});
+			return {
+				nodeId: node.nodeId,
+				decision: { status: lead ? "selected" : "rejected" },
+				basis,
+				rule,
+				reason: lead ? `the leader when the search stopped (${this.stopReason}): a budget decision on the ${split} split, which claims nothing` : !this.screenedSet.has(node.nodeId) || !scored ? "the search stopped before this node was measured" : !view.complete(node.nodeId) ? "it left a unit of its screen unscored, so it could not lead" : "it did not beat the leader on the units they share"
+			};
+		});
+		for (const decision of decisions) await this.recorder.decideNode(decision);
+		await this.recorder.close({
+			reason: this.stopReason ?? "converged",
+			claim: null
+		});
+		await this.refresh();
+	}
+	closedResult() {
+		const state = this.state;
 		return {
-			...audit,
-			edges: { ...audit.edges },
-			cells: { ...audit.cells },
-			outcomes: { ...audit.outcomes },
-			operations: { ...audit.operations },
-			spend: { ...audit.spend },
-			tokens: { ...audit.tokens }
+			state,
+			leader: state.audit.selectedNodeId ?? state.rootNodeId,
+			reason: state.closed.reason
 		};
 	}
-	/** @internal */
-	readNode(nodeId) {
-		const record = this.nodes.get(nodeId);
-		return record ? nodeView(record) : void 0;
-	}
-	/** @internal */
-	readNodeIds() {
-		return this.nodeOrder;
-	}
-	/** @internal */
-	readHasNode(nodeId) {
-		return this.nodes.has(nodeId);
-	}
-	/** @internal */
-	readNodeIdForDigest(artifactDigest) {
-		return this.nodeByDigest.get(artifactDigest);
+	policyView() {
+		return searchPolicyView(this.state, {
+			screened: this.screened,
+			screening: this.admitted.size - this.screenedSet.size,
+			expansions: this.completed.length
+		});
 	}
-	/** @internal */
-	readEdge(edgeId) {
-		return this.edges.get(edgeId);
+	artifact(nodeId) {
+		const held = this.artifacts.get(nodeId);
+		if (held !== void 0) return held;
+		const artifact = this.options.codec.load(this.recorder, this.state.node(nodeId));
+		this.artifacts.set(nodeId, artifact);
+		return artifact;
 	}
-	/** @internal */
-	readEdgeIds() {
-		return this.edgeOrder;
+	capacity() {
+		let total = 0;
+		for (const lane of this.lanes.values()) total += lane.capacity;
+		const cap = this.state.header.budget.maxConcurrency;
+		return cap === null ? total : Math.min(cap, total);
+	}
+	/** A hard lane holds its enforced maximum. An estimate lane holds 1.5 times
+	* the 99th percentile of its settled cells once 20 settled, else its prior. */
+	cellReservation(lane) {
+		if (lane.costCap === "hard") return {
+			kind: "hard",
+			usd: lane.cellUsd
+		};
+		return {
+			kind: "estimate",
+			usd: estimate(lane.settledCosts, lane.cellUsd)
+		};
 	}
-	/** @internal */
-	readCell(cellId) {
-		const cell = this.cells.get(cellId);
-		return cell ? { ...cell } : void 0;
+	maxCellReservation() {
+		let most = 0;
+		for (const lane of this.lanes.values()) most = Math.max(most, this.cellReservation(lane).usd);
+		return most;
 	}
-	/** @internal */
-	readCellIds(nodeId) {
-		if (nodeId === void 0) return [...this.cells.keys()];
-		return this.nodes.get(nodeId)?.cellIds ?? [];
+	operationReservation() {
+		return {
+			kind: "estimate",
+			usd: estimate(this.operationCosts, this.options.proposer.reservationUsd ?? 0)
+		};
 	}
-	/** @internal */
-	readOperation(operationId) {
-		const operation = this.operations.get(operationId);
-		return operation ? { ...operation } : void 0;
+	pastDeadline() {
+		const deadline = this.state.header.budget.deadline;
+		return deadline !== null && this.now() >= Date.parse(deadline);
 	}
-	/** @internal */
-	readScoredCells(nodeId, split) {
-		const scored = [];
-		for (const cellId of this.nodes.get(nodeId)?.cellIds ?? []) {
-			const cell = this.cells.get(cellId);
-			if (cell.split === split && cell.score !== null) scored.push({
-				cellId,
-				unitId: cell.unitId,
-				attempt: cell.attempts,
-				score: cell.score
-			});
-		}
-		return scored;
+	async refresh() {
+		this.state = await this.recorder.state();
 	}
 };
 /**
-* A read of `SearchState` at one ledger position. Header, head, audit and
-* claim are values. Node, edge, cell and score reads go to the live indexes and
-* throw once the state has applied a later entry.
+* A policy's read of a search: `screened` lists the admitted nodes whose screen
+* finished, in registration order; `screening` counts the admitted nodes still
+* being screened. Nodes are ranked on the selection split, or on train when
+* the search declares no selection split. The view reads no test cell.
 */
-var SearchStateView = class {
-	searchId;
-	header;
-	closed;
-	head;
-	/** `occurredAt` of the head entry; a writer stamps later events at or after it. */
-	lastOccurredAt;
-	audit;
-	completion;
-	state;
-	version;
-	constructor(state, version) {
-		this.state = state;
-		this.version = version;
-		this.searchId = state.searchId;
-		this.header = state.readHeader();
-		this.closed = state.readClosed();
-		this.head = state.readHead();
-		this.lastOccurredAt = state.readLastOccurredAt();
-		this.audit = state.readAudit();
-		const reasons = state.incompleteReasons();
-		if (!this.closed) reasons.unshift("search is open");
-		this.completion = {
-			complete: this.closed !== null,
-			reasons
-		};
-	}
-	/** The node the search started from: the first registered. */
-	get rootNodeId() {
-		return this.live().readNodeIds()[0] ?? null;
-	}
-	node(nodeId) {
-		return this.live().readNode(nodeId);
-	}
-	hasNode(nodeId) {
-		return this.live().readHasNode(nodeId);
-	}
-	/** Node ids in registration order. */
-	nodeIds() {
-		return [...this.live().readNodeIds()];
-	}
-	/** Nodes in registration order. */
-	nodes() {
-		const state = this.live();
-		return state.readNodeIds().map((nodeId) => state.readNode(nodeId));
-	}
-	nodeIdForDigest(artifactDigest) {
-		return this.live().readNodeIdForDigest(artifactDigest);
-	}
-	edge(edgeId) {
-		return this.live().readEdge(edgeId);
-	}
-	/** Edges in ledger order. */
-	edges() {
-		const state = this.live();
-		return state.readEdgeIds().map((edgeId) => state.readEdge(edgeId));
-	}
-	cell(cellId) {
-		return this.live().readCell(cellId);
-	}
-	/** Cells in allocation order, optionally of one node. */
-	cells(filter = {}) {
-		const state = this.live();
-		return state.readCellIds(filter.nodeId).map((cellId) => state.readCell(cellId));
-	}
-	operation(operationId) {
-		return this.live().readOperation(operationId);
-	}
-	/** A node's scored cells on one split, in allocation order. Unscored cells
-	* (errored, cancelled or in flight) are absent, never zero. */
-	scoredCells(nodeId, split) {
-		return this.live().readScoredCells(nodeId, split);
-	}
-	/** Per-unit score means of a node on one split, in unitId order. */
-	unitScores(nodeId, split) {
-		return searchUnitScores(this.scoredCells(nodeId, split));
-	}
-	/** The lineage a RunRecord mint needs for one cell attempt. */
-	lineage(coordinates) {
-		const state = this.live();
-		if (coordinates.searchId !== this.searchId) throw new SearchLedgerError(`coordinates name search ${coordinates.searchId}, not ${this.searchId}`);
-		const cell = state.readCell(coordinates.cellId);
-		if (!cell || cell.nodeId !== coordinates.nodeId) throw new SearchLedgerError(`cell ${coordinates.cellId} of node ${coordinates.nodeId} is not in search ${this.searchId}`);
-		if (coordinates.attempt < 1 || coordinates.attempt > cell.attempts) throw new SearchLedgerError(`cell ${coordinates.cellId} has ${cell.attempts} settled attempt(s), not attempt ${coordinates.attempt}`);
-		const node = state.readNode(cell.nodeId);
-		if (node.depth === null) throw new SearchLedgerError(`node ${node.nodeId} has unknown lineage, so its depth is unknown`);
-		const containment = this.header?.containment ?? null;
-		return {
-			depth: node.depth,
-			ordinal: node.ordinal,
-			rep: cell.rep,
-			containingRunId: containment ? searchCellRunId({
-				cellId: containment.cellId,
-				attempt: containment.attempt
-			}) : null
-		};
-	}
-	live() {
-		if (!this.state.isAt(this.version)) throw new SearchLedgerError(`this SearchStateView is from sequence ${this.head?.sequence ?? -1}, and the ledger has moved on; read the ledger's state again`);
-		return this.state;
-	}
-};
-function nodeView(record) {
-	const latest = record.decisions.at(-1)?.decision ?? null;
+function searchPolicyView(state, input) {
+	const header = state.header;
+	if (!header) throw new Error(`search ${state.searchId} has not been opened`);
+	const split = header.splits.selection.tasks.length > 0 ? "selection" : "train";
 	return {
-		nodeId: record.event.nodeId,
-		ordinal: record.ordinal,
-		artifactDigest: record.event.artifactDigest,
-		artifact: record.event.artifact,
-		surfaces: record.event.surfaces,
-		primaryParentId: record.primaryParentId,
-		depth: record.depth,
-		parents: [...record.parents],
-		children: [...record.children],
-		edgeIds: [...record.edgeIds],
-		status: latest?.status ?? null,
-		rung: latest?.status === "advanced" ? latest.rung : null,
-		finalist: record.finalist,
-		decisions: [...record.decisions],
-		cellCount: record.cellIds.length,
-		spend: { ...record.spend },
-		registeredSequence: record.registeredSequence,
-		updatedSequence: record.updatedSequence
+		searchId: state.searchId,
+		seed: header.policy.seed,
+		direction: header.objective.direction,
+		split,
+		rootNodeId: state.rootNodeId,
+		expansions: input.expansions,
+		screened: [...input.screened],
+		screening: input.screening,
+		complete: (nodeId) => {
+			const cells = state.cells({ nodeId }).filter((cell) => cell.split === split);
+			return cells.length > 0 && cells.every((cell) => cell.score !== null);
+		},
+		unitScores: (nodeId) => state.unitScores(nodeId, split),
+		estimate: (nodeId, against) => estimateNode(state, nodeId, {
+			against,
+			split
+		})
 	};
 }
-function assertStageSplit(cellId, stage, split, isRoot) {
-	if (!{
-		root: ["train", "selection"],
-		train: ["train"],
-		screen: ["selection"],
-		rung: ["selection"],
-		claim: ["test"],
-		external: ["train", "selection"]
-	}[stage].includes(split)) throw integrity(`cell ${cellId}: a ${stage} cell cannot run on the ${split} split`);
-	if (stage === "root" && !isRoot) throw integrity(`cell ${cellId}: only the root node runs root cells`);
-}
-function assertUnique(values, label, eventId) {
-	if (new Set(values).size !== values.length) throw integrity(`event ${eventId} contains duplicate ${label} values`);
+function isTerminal(node) {
+	return node.status !== null && node.status !== "advanced";
 }
-function count(value, noun, predicate) {
-	const verb = predicate.replace(/^(has|is) /, (word) => value === 1 ? word : word === "has " ? "have " : "are ");
-	return `${value} ${value === 1 ? noun : `${noun}s`} ${verb}`;
+function estimate(costs, prior) {
+	if (costs.length < ESTIMATE_FROM_CELLS) return prior;
+	const sorted = [...costs].sort((a, b) => a - b);
+	const p99 = sorted[Math.min(sorted.length - 1, Math.ceil(.99 * sorted.length) - 1)];
+	return Math.round(ESTIMATE_MARGIN * p99 * 1e9) / 1e9;
 }
-function round(usd) {
-	return Math.round(usd * 1e6) / 1e6;
-}
-function integrity(message) {
-	return new SearchLedgerIntegrityError(message);
-}
-//#endregion
-//#region src/campaign/search-ledger.ts
-/**
-* Durable, append-only event log of one search: nodes (content-addressed
-* artifacts), edges (the proposals that derived them), cells (one run of one
-* node on one task), operations, decisions, and the claim.
-*
-* The ledger is the search's only lineage record and its only resume
-* checkpoint. A RunRecord owns one measured run and `CostLedger` owns per-call
-* accounting; this ledger binds them by digest instead of copying them.
-*
-* The file format is canonical JSONL with a SHA-256 hash chain. Every append is
-* serialized across processes, fsynced before acknowledgement, and idempotent
-* by `eventId`. A malformed, non-canonical, truncated, reordered, or conflicting
-* log fails loudly; a bad row is never skipped. A ledger written under another
-* schema tag is refused with that tag named, never translated.
-*
-* The journal machinery is the generic `ledger-core` journal. This module is
-* the search codec: event schemas and canonical ordering. `SearchState` is the
-* state machine and read model.
-*/
-const NON_EMPTY = z.string().min(1).refine((value) => value.trim() === value, "must not contain surrounding whitespace");
-const HASH = z.string().regex(/^sha256:[a-f0-9]{64}$/);
-const IMMUTABLE_REVISION = z.string().regex(/^(?:[a-f0-9]{40}|[a-f0-9]{64}|sha256:[a-f0-9]{64}|sha512:[A-Za-z0-9+/=]+)$/);
-const ISO_TIMESTAMP = z.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/).refine((value) => Number.isFinite(Date.parse(value)), "invalid timestamp");
-const NON_NEGATIVE_INT = z.number().int().nonnegative().safe();
-const POSITIVE_INT = z.number().int().positive().safe();
-const FINITE_NUMBER = z.number().finite();
-const USD = z.number().finite().nonnegative();
-const NODE_ID = z.string().regex(/^node_[a-f0-9]{32}$/);
-const CELL_ID = z.string().regex(/^cell_[a-f0-9]{32}$/);
-const ArtifactRefSchema = z.object({
-	role: NON_EMPTY,
-	uri: NON_EMPTY,
-	sha256: HASH,
-	byteLength: NON_NEGATIVE_INT
-}).strict();
-const SourceRefSchema = z.object({
-	uri: NON_EMPTY,
-	revision: IMMUTABLE_REVISION
-}).strict();
-const UnknownRefSchema = z.object({ unknown: NON_EMPTY }).strict();
-const FailureReasonSchema = z.object({
-	code: NON_EMPTY,
-	message: NON_EMPTY
-}).strict();
-const ModelIdentitySchema = z.union([z.object({
-	provider: NON_EMPTY,
-	snapshot: NON_EMPTY.refine(modelHasSnapshot, "model must include an immutable snapshot")
-}).strict(), z.object({
-	provider: NON_EMPTY,
-	alias: NON_EMPTY,
-	unknown: NON_EMPTY
-}).strict()]);
-const ExecutionIdentitySchema = z.object({
-	model: ModelIdentitySchema,
-	agent: SourceRefSchema,
-	benchmark: SourceRefSchema
-}).strict();
-const SURFACE_KINDS = [
-	"prompt",
-	"tool-contract",
-	"runtime-config",
-	"memory",
-	"knowledge",
-	"agent-profile",
-	"code",
-	"deployment"
-];
-const SPLIT = z.enum([
-	"train",
-	"selection",
-	"test"
-]);
-const ReservationSchema = z.object({
-	kind: z.enum(["hard", "estimate"]),
-	usd: USD
-}).strict();
-const EventBaseShape = {
-	eventId: NON_EMPTY,
-	occurredAt: ISO_TIMESTAMP,
-	artifacts: z.array(ArtifactRefSchema)
-};
-const OperationKindSchema = z.enum([
-	"candidate-generation",
-	"analysis",
-	"selection",
-	"judge",
-	"other"
-]);
-const KnownTokensSchema = z.object({
-	status: z.literal("known"),
-	inputTokens: NON_NEGATIVE_INT,
-	outputTokens: NON_NEGATIVE_INT,
-	cachedTokens: NON_NEGATIVE_INT
-}).strict();
-const UnknownTokensSchema = z.object({
-	status: z.literal("unknown"),
-	reason: NON_EMPTY
-}).strict();
-const KnownCostSchema = z.object({
-	status: z.literal("known"),
-	usd: USD,
-	source: z.enum([
-		"provider",
-		"pricing-table",
-		"free"
-	])
-}).strict().superRefine((cost, ctx) => {
-	if (cost.source === "free" && cost.usd !== 0) ctx.addIssue({
-		code: "custom",
-		message: "free cost source must have usd 0"
-	});
-});
-const UnknownCostSchema = z.object({
-	status: z.literal("unknown"),
-	knownLowerBoundUsd: USD,
-	reason: NON_EMPTY
-}).strict();
-const AccountingSchema = z.object({
-	tokens: z.discriminatedUnion("status", [KnownTokensSchema, UnknownTokensSchema]),
-	cost: z.discriminatedUnion("status", [KnownCostSchema, UnknownCostSchema])
-}).strict();
-const MetricsSchema = z.record(NON_EMPTY, FINITE_NUMBER).superRefine((metrics, ctx) => {
-	for (const key of Object.keys(metrics)) if (key === "__proto__" || key === "constructor" || key === "prototype") ctx.addIssue({
-		code: "custom",
-		message: `unsafe metric key ${key}`
-	});
-});
-const OutcomeSchema = z.discriminatedUnion("status", [
-	z.object({
-		status: z.literal("passed"),
-		score: FINITE_NUMBER,
-		metrics: MetricsSchema
-	}).strict(),
-	z.object({
-		status: z.literal("failed"),
-		score: FINITE_NUMBER,
-		metrics: MetricsSchema,
-		failure: FailureReasonSchema
-	}).strict(),
-	z.object({
-		status: z.literal("errored"),
-		metrics: MetricsSchema,
-		error: FailureReasonSchema.extend({ retryable: z.boolean() }).strict()
-	}).strict()
-]);
-const EffectSchema = z.discriminatedUnion("status", [z.object({
-	status: z.literal("measured"),
-	metric: NON_EMPTY,
-	baselineValue: FINITE_NUMBER,
-	candidateValue: FINITE_NUMBER,
-	delta: FINITE_NUMBER
-}).strict().superRefine((effect, ctx) => {
-	const expected = effect.candidateValue - effect.baselineValue;
-	const tolerance = Number.EPSILON * Math.max(1, Math.abs(expected), Math.abs(effect.delta)) * 8;
-	if (Math.abs(effect.delta - expected) > tolerance) ctx.addIssue({
-		code: "custom",
-		message: "delta must equal candidateValue - baselineValue"
-	});
-}), z.object({
-	status: z.literal("not-measured"),
-	reason: NON_EMPTY
-}).strict()]);
-const SurfaceEvidenceSchema = z.object({
-	surfaceId: NON_EMPTY,
-	fired: z.boolean(),
-	firingCount: NON_NEGATIVE_INT,
-	effect: EffectSchema,
-	evidence: z.array(ArtifactRefSchema).min(1)
-}).strict().superRefine((evidence, ctx) => {
-	if (evidence.fired !== evidence.firingCount > 0) ctx.addIssue({
-		code: "custom",
-		message: "fired must equal firingCount > 0"
-	});
-	if (!evidence.fired && evidence.effect.status === "measured" && evidence.effect.delta !== 0) ctx.addIssue({
-		code: "custom",
-		message: "a surface that did not fire has no effect"
-	});
-});
-const TaskSchema = z.object({
-	taskId: NON_EMPTY,
-	unitId: NON_EMPTY,
-	source: SourceRefSchema
-}).strict();
-const SplitTasksSchema = z.object({
-	taskSetDigest: HASH,
-	tasks: z.array(TaskSchema)
-}).strict();
-const SearchOpenedSchema = z.object({
-	...EventBaseShape,
-	kind: z.literal("search-opened"),
-	subject: NON_EMPTY,
-	process: z.object({
-		name: NON_EMPTY,
-		executionRef: SourceRefSchema
-	}).strict(),
-	artifactKind: z.enum([...SURFACE_KINDS, "output"]),
-	objective: z.object({
-		metric: NON_EMPTY,
-		direction: z.enum(["maximize", "minimize"]),
-		judge: z.union([SourceRefSchema, UnknownRefSchema]),
-		claim: evaluationClaimSchema
-	}).strict(),
-	splits: z.object({
-		train: SplitTasksSchema,
-		selection: SplitTasksSchema,
-		test: SplitTasksSchema,
-		heldOutUnits: z.boolean()
-	}).strict(),
-	policy: z.object({
-		expansion: NON_EMPTY,
-		allocation: NON_EMPTY,
-		seed: z.number().int().safe()
-	}).strict(),
-	budget: z.object({
-		maxUsd: USD.nullable(),
-		maxCells: POSITIVE_INT.nullable(),
-		maxNodes: POSITIVE_INT.nullable(),
-		deadline: ISO_TIMESTAMP.nullable(),
-		maxConcurrency: POSITIVE_INT.nullable(),
-		reservedClaimUsd: USD
-	}).strict(),
-	containment: z.object({
-		searchId: NON_EMPTY,
-		cellId: CELL_ID,
-		attempt: POSITIVE_INT
-	}).strict().nullable(),
-	derivedFrom: z.object({
-		searchId: NON_EMPTY,
-		nodeId: NODE_ID,
-		headHash: HASH
-	}).strict().nullable(),
-	identity: ExecutionIdentitySchema
-}).strict();
-const OperationStartedSchema = z.object({
-	...EventBaseShape,
-	kind: z.literal("operation-started"),
-	operationId: NON_EMPTY,
-	operationKind: OperationKindSchema,
-	reservation: ReservationSchema.nullable()
-}).strict();
-const OperationRecordedSchema = z.object({
-	...EventBaseShape,
-	kind: z.literal("operation-recorded"),
-	operationId: NON_EMPTY,
-	operationKind: OperationKindSchema,
-	execution: z.discriminatedUnion("kind", [z.object({
-		kind: z.literal("model"),
-		model: ModelIdentitySchema,
-		source: SourceRefSchema
-	}).strict(), z.object({
-		kind: z.literal("deterministic"),
-		source: SourceRefSchema
-	}).strict()]),
-	outcome: z.discriminatedUnion("status", [
-		z.object({ status: z.literal("completed") }).strict(),
-		z.object({
-			status: z.literal("partial"),
-			failure: FailureReasonSchema
-		}).strict(),
-		z.object({
-			status: z.literal("failed"),
-			failure: FailureReasonSchema
-		}).strict()
-	]),
-	accounting: AccountingSchema
-}).strict();
-const NodeRegisteredSchema = z.object({
-	...EventBaseShape,
-	kind: z.literal("node-registered"),
-	nodeId: NODE_ID,
-	artifactDigest: HASH,
-	artifact: ArtifactRefSchema,
-	surfaces: z.array(z.object({
-		surfaceId: NON_EMPTY,
-		kind: z.enum(SURFACE_KINDS),
-		artifact: ArtifactRefSchema
-	}).strict())
-}).strict();
-const NodeRefSchema = z.object({
-	searchId: NON_EMPTY,
-	nodeId: NODE_ID
-}).strict();
-const ArtifactOrUnknownSchema = z.union([ArtifactRefSchema, UnknownRefSchema]);
-const EdgeRecordedSchema = z.object({
-	...EventBaseShape,
-	kind: z.literal("edge-recorded"),
-	edgeId: z.string().regex(/^edge_[a-f0-9]{32}$/),
-	childNodeId: NODE_ID,
-	parents: z.array(NodeRefSchema),
-	operator: z.enum([
-		"seed",
-		"draft",
-		"improve",
-		"debug",
-		"merge",
-		"derive"
-	]),
-	attribution: z.enum([
-		"explicit",
-		"correlated",
-		"unknown"
-	]),
-	proposer: z.object({
-		kind: z.enum([
-			"trace",
-			"frontier-author",
-			"human",
-			"optimizer",
-			"compound"
-		]),
-		name: NON_EMPTY,
-		operationId: NON_EMPTY.nullable(),
-		source: SourceRefSchema
-	}).strict().nullable(),
-	selection: z.object({
-		rule: NON_EMPTY,
-		evidence: z.record(NON_EMPTY, FINITE_NUMBER)
-	}).strict().nullable(),
-	rationale: ArtifactOrUnknownSchema,
-	diffs: z.array(ArtifactOrUnknownSchema),
-	label: z.string()
-}).strict();
-const CellAllocatedSchema = z.object({
-	...EventBaseShape,
-	kind: z.literal("cell-allocated"),
-	cellId: CELL_ID,
-	nodeId: NODE_ID,
-	taskId: NON_EMPTY,
-	unitId: NON_EMPTY,
-	split: SPLIT,
-	rep: NON_NEGATIVE_INT,
-	stage: z.enum([
-		"root",
-		"train",
-		"screen",
-		"rung",
-		"claim",
-		"external"
-	]),
-	lane: NON_EMPTY.nullable(),
-	reservation: ReservationSchema.nullable()
-}).strict();
-const TraceRefSchema = z.union([z.object({
-	traceId: NON_EMPTY,
-	execRunId: NON_EMPTY.nullable(),
-	spansWritten: NON_NEGATIVE_INT.nullable(),
-	spansDropped: NON_NEGATIVE_INT.nullable()
-}).strict(), UnknownRefSchema]);
-const NON_NEGATIVE = z.number().finite().nonnegative();
-const CellSettledSchema = z.object({
-	...EventBaseShape,
-	kind: z.literal("cell-settled"),
-	cellId: CELL_ID,
-	attempt: POSITIVE_INT,
-	runId: NON_EMPTY,
-	outcome: OutcomeSchema,
-	accounting: AccountingSchema,
-	boxMinutes: NON_NEGATIVE.nullable(),
-	wallMs: NON_NEGATIVE.nullable(),
-	queueMs: NON_NEGATIVE.nullable(),
-	placement: z.object({
-		lane: NON_EMPTY,
-		boxId: NON_EMPTY.nullable()
-	}).strict().nullable(),
-	identity: ExecutionIdentitySchema,
-	surfaceEvidence: z.array(SurfaceEvidenceSchema),
-	traceRef: TraceRefSchema
-}).strict();
-const CellCancelledSchema = z.object({
-	...EventBaseShape,
-	kind: z.literal("cell-cancelled"),
-	cellId: CELL_ID,
-	reason: z.enum([
-		"pruned",
-		"budget",
-		"deadline",
-		"aborted"
-	])
-}).strict();
-const NodeEstimateSchema = z.object({
-	against: NODE_ID,
-	split: SPLIT,
-	units: NON_NEGATIVE_INT,
-	pairs: NON_NEGATIVE_INT,
-	delta: FINITE_NUMBER.nullable(),
-	interval: z.tuple([FINITE_NUMBER, FINITE_NUMBER]).nullable(),
-	method: z.enum([
-		"none",
-		"insufficient",
-		"descriptive",
-		"bootstrap"
-	]),
-	exactSignP: z.number().min(0).max(1).nullable(),
-	indeterminate: z.boolean(),
-	cellSetDigest: HASH,
-	estimator: SourceRefSchema
-}).strict();
-const NodeDecidedSchema = z.object({
-	...EventBaseShape,
-	kind: z.literal("node-decided"),
-	nodeId: NODE_ID,
-	decision: z.discriminatedUnion("status", [
-		z.object({
-			status: z.literal("advanced"),
-			rung: NON_NEGATIVE_INT
-		}).strict(),
-		z.object({ status: z.literal("pruned") }).strict(),
-		z.object({ status: z.literal("invalid") }).strict(),
-		z.object({ status: z.literal("finalist") }).strict(),
-		z.object({ status: z.literal("selected") }).strict(),
-		z.object({ status: z.literal("rejected") }).strict()
-	]),
-	basis: NodeEstimateSchema.nullable(),
-	rule: NON_EMPTY,
-	reason: NON_EMPTY
-}).strict();
-const SearchClosedSchema = z.object({
-	...EventBaseShape,
-	kind: z.literal("search-closed"),
-	reason: z.enum([
-		"budget",
-		"deadline",
-		"max-nodes",
-		"patience",
-		"converged",
-		"aborted"
-	]),
-	claim: z.object({
-		power: z.union([z.object({
-			adequate: z.boolean(),
-			minimumEffect: z.number().finite().positive(),
-			powerAtMinimumEffect: z.number().min(0).max(1),
-			units: NON_NEGATIVE_INT
-		}).strict(), UnknownRefSchema]),
-		finalists: z.array(z.object({
-			nodeId: NODE_ID,
-			estimate: NodeEstimateSchema.nullable(),
-			promote: z.boolean()
-		}).strict()),
-		selected: NODE_ID.nullable(),
-		decision: z.enum([
-			"ship",
-			"hold",
-			"test-cannot-resolve"
-		])
-	}).strict().nullable()
-}).strict();
-const EventSchema = z.discriminatedUnion("kind", [
-	SearchOpenedSchema,
-	OperationStartedSchema,
-	OperationRecordedSchema,
-	NodeRegisteredSchema,
-	EdgeRecordedSchema,
-	CellAllocatedSchema,
-	CellSettledSchema,
-	CellCancelledSchema,
-	NodeDecidedSchema,
-	SearchClosedSchema
-]);
-const EntrySchema = z.object({
-	schema: z.literal(SEARCH_LEDGER_SCHEMA),
-	searchId: NON_EMPTY,
-	sequence: NON_NEGATIVE_INT,
-	previousHash: z.union([HASH, z.null()]),
-	event: EventSchema,
-	entryHash: HASH
-}).strict();
-/** Validate and return a canonical copy. Arrays whose order carries no meaning
-* are sorted, so retries from different processes produce identical bytes. */
-function validateSearchLedgerEvent(input) {
-	const parsed = EventSchema.safeParse(input);
-	if (!parsed.success) throw new SearchLedgerError(`invalid search ledger event: ${formatZodError(parsed.error)}`);
-	return normalizeEvent(parsed.data);
-}
-/** Open a durable filesystem search ledger. Construction performs no I/O; the
-* first `append` or `state` verifies the whole existing file. */
-function openSearchLedger(options) {
-	return new FileSearchLedger(options.path, options.searchId, options.trustedHead);
-}
-/** Verify and project immutable search-ledger JSONL through the same codec as
-* `FileSearchLedger`. */
-function replaySearchLedgerText(text, searchId, source) {
-	return replayLedgerText(text, source, searchLedgerCodec(searchId));
-}
-function searchLedgerCodec(searchId) {
+/** Spend of work whose result was lost: unknown, with no proven floor. */
+function interruptedAccounting() {
 	return {
-		...SEARCH_LEDGER_FILE_CONTEXT,
-		header: {
-			schema: SEARCH_LEDGER_SCHEMA,
-			searchId
-		},
-		conflictError: (message) => new SearchLedgerConflictError(message),
-		parseEntry: parseSearchLedgerEntry,
-		checkEntryHeader: (entry, index) => {
-			if (entry.searchId !== searchId) throw new SearchLedgerIntegrityError(`entry ${index} belongs to search ${entry.searchId}, expected ${searchId}`);
+		tokens: {
+			status: "unknown",
+			reason: "the result of this work was lost"
 		},
-		createProjector: () => new SearchState(searchId)
+		cost: {
+			status: "unknown",
+			knownLowerBoundUsd: 0,
+			reason: "the result of this work was lost, so its spend is unknown"
+		}
 	};
 }
-/** Append-only file-backed search ledger with idempotent writes. */
-var FileSearchLedger = class {
-	path;
-	searchId;
-	trustedHeadPath;
-	trustedHeadMode;
-	journal;
-	constructor(path, searchId, trustedHead = "pin") {
-		if (path.trim().length === 0) throw new SearchLedgerError("ledger path is empty");
-		if (searchId.length === 0 || searchId.trim() !== searchId) throw new SearchLedgerError("searchId must be non-empty without surrounding whitespace");
-		this.searchId = searchId;
-		this.trustedHeadMode = trustedHead;
-		this.journal = new FileLedgerJournal(path, searchLedgerCodec(searchId), { requireTrustedHead: trustedHead === "require" });
-		this.path = this.journal.path;
-		this.trustedHeadPath = this.journal.trustedHeadPath;
-	}
-	async state() {
-		return this.journal.replay();
-	}
-	async append(input) {
-		const event = validateSearchLedgerEvent(input);
-		const { entry, appended, projection } = await this.journal.append(event, { pinHead: this.trustedHeadMode !== "off" });
-		return {
-			entry,
-			appended,
-			state: projection
-		};
-	}
-	async trustedHead() {
-		return this.journal.trustedHead();
-	}
-	async pinTrustedHead() {
-		return this.journal.pinTrustedHead();
-	}
-	async clearTrustedHead() {
-		return this.journal.clearTrustedHead();
-	}
-};
-function parseSearchLedgerEntry(raw, context) {
-	const schema = raw?.schema;
-	if (schema !== "tangle.search-ledger.2026-09") throw new SearchLedgerIntegrityError(`search ledger ${context.path} line ${context.line} was written under schema ${JSON.stringify(schema)}; this version reads only ${SEARCH_LEDGER_SCHEMA} and does not translate other formats`);
-	const parsed = EntrySchema.safeParse(raw);
-	if (!parsed.success) throw new SearchLedgerIntegrityError(`search ledger ${context.path} has a malformed entry at line ${context.line}: ${formatZodError(parsed.error)}`);
-	const entry = parsed.data;
-	if (canonicalString(validateSearchLedgerEvent(entry.event)) !== canonicalString(entry.event)) throw new SearchLedgerIntegrityError(`search ledger ${context.path} has non-canonical event ordering at line ${context.line}`);
-	return entry;
-}
-function normalizeEvent(event) {
-	const artifacts = sortArtifacts(event.artifacts);
-	switch (event.kind) {
-		case "search-opened": return {
-			...event,
-			artifacts,
-			splits: {
-				...event.splits,
-				train: {
-					...event.splits.train,
-					tasks: sortTasks(event.splits.train.tasks)
-				},
-				selection: {
-					...event.splits.selection,
-					tasks: sortTasks(event.splits.selection.tasks)
-				},
-				test: {
-					...event.splits.test,
-					tasks: sortTasks(event.splits.test.tasks)
-				}
-			}
-		};
-		case "node-registered": return {
-			...event,
-			artifacts,
-			surfaces: [...event.surfaces].sort((a, b) => compareStrings(a.surfaceId, b.surfaceId))
-		};
-		case "cell-settled": return {
-			...event,
-			artifacts,
-			surfaceEvidence: [...event.surfaceEvidence].map((evidence) => ({
-				...evidence,
-				evidence: sortArtifacts(evidence.evidence)
-			})).sort((a, b) => compareStrings(a.surfaceId, b.surfaceId))
-		};
-		default: return {
-			...event,
-			artifacts
-		};
-	}
-}
-function sortTasks(tasks) {
-	return [...tasks].sort((a, b) => compareStrings(a.taskId, b.taskId));
-}
-function sortArtifacts(artifacts) {
-	return [...artifacts].sort((a, b) => compareStrings(artifactKey(a), artifactKey(b)));
-}
-function formatZodError(error) {
-	return error.issues.map((issue) => `${issue.path.length > 0 ? issue.path.join(".") : "<root>"}: ${issue.message}`).join("; ");
+function errorMessage(error) {
+	const text = error instanceof Error ? error.message : String(error);
+	return text.trim().length > 0 ? text : "the proposer failed without a message";
 }
 //#endregion
 //#region src/campaign/search-history-receipt.ts
@@ -4254,11 +3814,25 @@ var SearchRecorder = class SearchRecorder {
 		}
 		return {
 			role,
-			uri: `file://${path}`,
+			uri: pathToFileURL(path).href,
 			sha256: `sha256:${hex}`,
 			byteLength: bytes.byteLength
 		};
 	}
+	/**
+	* Read back a blob this recorder stored, by its content address. The bytes
+	* must hash to the reference's digest and length, so a resumed search reads
+	* exactly what the ledger bound.
+	*/
+	readBlob(ref) {
+		const hex = ref.sha256.slice(7);
+		const path = join(this.blobDir, `${hex}.json`);
+		const text = this.storage.read(path);
+		if (text === void 0) throw new Error(`search ${this.searchId}: blob ${ref.sha256} (${ref.role}) is missing at ${path}`);
+		const bytes = Buffer.from(text, "utf8");
+		if (createHash("sha256").update(bytes).digest("hex") !== hex || bytes.byteLength !== ref.byteLength) throw new Error(`search ${this.searchId}: blob at ${path} does not match ${ref.sha256}`);
+		return JSON.parse(text);
+	}
 	/** Register a node, or return the existing node with the same artifact digest. */
 	async registerNode(input) {
 		const existing = (await this.ledger.state()).nodeIdForDigest(input.artifactDigest);
@@ -4464,306 +4038,868 @@ function surfaceNode(recorder, surface) {
 		surface
 	});
 	return {
-		artifactDigest: surfaceContentHash(surface),
-		artifact,
-		surfaces: declaredSurfaces(surface, artifact)
+		artifactDigest: surfaceContentHash(surface),
+		artifact,
+		surfaces: declaredSurfaces(surface, artifact)
+	};
+}
+/** A parent-to-child diff of two mutable surfaces, stored as a blob. */
+function surfaceDiff(recorder, parent, child) {
+	return recorder.blob("diff", {
+		kind: "surface-diff",
+		from: surfaceContentHash(parent),
+		to: surfaceContentHash(child),
+		text: renderSurfaceDiff(child, parent)
+	});
+}
+/** Declared surfaces of one node. A component surface declares one surface per
+* named component, so per-component evidence stays addressable. */
+function declaredSurfaces(surface, artifact) {
+	if (typeof surface === "string") return [{
+		surfaceId: "prompt",
+		kind: "prompt",
+		artifact
+	}];
+	if (surface.kind === "code") return [{
+		surfaceId: "code",
+		kind: "code",
+		artifact
+	}];
+	return Object.keys(surface.components).sort().map((name) => ({
+		surfaceId: `component:${name}`,
+		kind: "prompt",
+		artifact
+	}));
+}
+function boundedLabel(label) {
+	const redacted = redactText(label.trim(), { profile: "share" });
+	return redacted.length <= MAX_LABEL_CHARS ? redacted : `${redacted.slice(0, MAX_LABEL_CHARS - 1)}…`;
+}
+/** The header without its stamp, for comparing a resumed opening to the stored one. */
+function headerMaterial(header) {
+	const { occurredAt: _occurredAt, ...material } = header;
+	return canonicalString(material);
+}
+/** The header as the ledger would store it, so the comparison ignores ordering. */
+function canonicalHeader(header) {
+	return validateSearchLedgerEvent({
+		...header,
+		occurredAt: "2000-01-01T00:00:00.000Z"
+	});
+}
+//#endregion
+//#region src/campaign/search-policy.ts
+/**
+* Expansion policies: which node a search expands next, with which operator,
+* and which node it currently keeps.
+*
+* A policy reads a `SearchPolicyView`: nodes whose screen finished and their
+* per-unit scores on the policy's split. The view holds no test cells, so a
+* policy cannot see the sealed claim data. Its decisions spend budget and
+* claim nothing; a claim comes only from the sealed test split.
+*/
+/**
+* The hill climb. The leader starts at the root; a screened node that scored
+* every unit of its screen takes the lead when its mean on the units it shares
+* with the leader beats the leader's mean on those units. Nodes are taken in
+* registration order, so the leader is a pure function of the ledger. The
+* policy expands the leader, and only once every earlier child is screened,
+* so each proposal sees every result before it.
+*/
+function incumbent(options = {}) {
+	const { patience } = options;
+	if (patience !== void 0 && (!Number.isSafeInteger(patience) || patience < 1)) throw new TypeError(`incumbent: patience must be a positive integer, got ${String(patience)}`);
+	return hillClimb({
+		name: patience === void 0 ? "incumbent" : `incumbent(patience=${patience})`,
+		patience,
+		parent: (_view, leader) => ({
+			nodeId: leader,
+			evidence: {}
+		})
+	});
+}
+/**
+* The hill climb with a different parent: each expansion draws two distinct
+* members of the Pareto frontier (per-unit means on the policy split) with a
+* PRNG seeded from `seed` and the expansion index, and keeps the one with the
+* larger crowding distance, the more isolated. Boundary members carry infinite
+* distance. Ties fall to the higher mean, then to the earlier node. The leader
+* rule is the incumbent's: a frontier parent explores, and only a node that
+* beats the leader leads.
+*/
+function crowdedFrontierParent(options) {
+	const { seed } = options;
+	if (!Number.isInteger(seed)) throw new TypeError(`crowdedFrontierParent: seed must be an integer, got ${String(seed)}`);
+	return hillClimb({
+		name: `crowded-frontier(seed=${seed})`,
+		parent: (view, leader) => {
+			const frontier = paretoMembers(view);
+			if (frontier.length <= 1) return {
+				nodeId: frontier[0]?.nodeId ?? leader,
+				evidence: {}
+			};
+			const rng = mulberry32(seed ^ Math.imul(view.expansions + 1, 2654435761) | 0);
+			const first = Math.floor(rng() * frontier.length);
+			const offset = Math.floor(rng() * (frontier.length - 1));
+			const second = offset >= first ? offset + 1 : offset;
+			const a = frontier[first];
+			const b = frontier[second];
+			const winner = compareCrowded(a, b) <= 0 ? a : b;
+			return {
+				nodeId: winner.nodeId,
+				evidence: {
+					frontierSize: frontier.length,
+					crowding: Number.isFinite(winner.distance) ? winner.distance : -1
+				}
+			};
+		}
+	});
+}
+function hillClimb(spec) {
+	const leader = (view) => {
+		let current = view.rootNodeId;
+		for (const nodeId of view.screened) {
+			if (nodeId === current || !view.complete(nodeId)) continue;
+			if (beats(view, nodeId, current)) current = nodeId;
+		}
+		return current;
+	};
+	return {
+		name: spec.name,
+		...spec.patience === void 0 ? {} : { patience: spec.patience },
+		leader,
+		expand(view) {
+			if (view.screening > 0) return null;
+			const kept = leader(view);
+			const chosen = spec.parent(view, kept);
+			const units = view.unitScores(chosen.nodeId);
+			return {
+				parents: [chosen.nodeId],
+				operator: "improve",
+				selection: {
+					rule: spec.name,
+					evidence: {
+						...chosen.evidence,
+						units: units.length,
+						...units.length > 0 ? { mean: mean$1(units.map((unit) => unit.mean)) } : {},
+						isLeader: chosen.nodeId === kept ? 1 : 0
+					}
+				}
+			};
+		}
+	};
+}
+/** True when `challenger` improves on `holder` over the units both scored. */
+function beats(view, challenger, holder) {
+	const held = new Map(view.unitScores(holder).map((unit) => [unit.unitId, unit.mean]));
+	let challengerSum = 0;
+	let holderSum = 0;
+	let shared = 0;
+	for (const unit of view.unitScores(challenger)) {
+		const other = held.get(unit.unitId);
+		if (other === void 0) continue;
+		challengerSum += unit.mean;
+		holderSum += other;
+		shared += 1;
+	}
+	if (shared === 0) return false;
+	return view.direction === "maximize" ? challengerSum > holderSum : challengerSum < holderSum;
+}
+/** Non-dominated complete screened nodes over the root's units, with crowding. */
+function paretoMembers(view) {
+	const units = view.unitScores(view.rootNodeId).map((unit) => unit.unitId);
+	const sign = view.direction === "maximize" ? 1 : -1;
+	const members = [];
+	view.screened.forEach((nodeId, ordinal) => {
+		if (!view.complete(nodeId)) return;
+		const objectives = new Map(view.unitScores(nodeId).map((unit) => [unit.unitId, unit.mean]));
+		if (units.some((unit) => !objectives.has(unit))) return;
+		members.push({
+			nodeId,
+			ordinal,
+			mean: sign * mean$1([...objectives.values()]),
+			objectives,
+			distance: 0
+		});
+	});
+	if (members.length === 0 || units.length === 0) return members;
+	return paretoFrontierWithCrowding(members, units.map((unit) => ({
+		name: unit,
+		direction: view.direction,
+		value: (member) => member.objectives.get(unit)
+	}))).map(({ candidate, distance }) => ({
+		...candidate,
+		distance
+	}));
+}
+/** Negative when `a` wins the tournament. */
+function compareCrowded(a, b) {
+	if (a.distance !== b.distance) return a.distance > b.distance ? -1 : 1;
+	if (a.mean !== b.mean) return a.mean > b.mean ? -1 : 1;
+	return a.ordinal - b.ordinal;
+}
+function mean$1(values) {
+	let total = 0;
+	for (const value of values) total += value;
+	return total / values.length;
+}
+//#endregion
+//#region src/campaign/types.ts
+/** Type guard: a proposal carrying its rationale vs a bare
+*  surface. The loop branches on this to populate `GenerationCandidate`. */
+function isProposedCandidate(value) {
+	return typeof value === "object" && value !== null && "surface" in value && "label" in value && "rationale" in value;
+}
+const LABEL_TRUST_RANK = {
+	unverified: 0,
+	"verified-signal": 1,
+	"human-rated": 2
+};
+/** Ordinal rank for a label-trust tier; absent ⇒ `unverified` (rank 0). */
+function labelTrustRank(trust) {
+	return LABEL_TRUST_RANK[trust ?? "unverified"];
+}
+//#endregion
+//#region src/campaign/presets/run-optimization.ts
+/**
+* `runOptimization` improves a mutable surface with a caller-owned proposer,
+* as a search on the one kernel (`runSearch`).
+*
+* The baseline is the seeded root. The scenarios are the train split: the
+* proposer reads their scores, and the policy ranks on them because the loop
+* has no private selection split. A "generation" is one proposal of
+* `populationSize` candidates from the node the policy chose (by default the
+* incumbent, once every earlier candidate is measured). Every candidate is a
+* node measured on every scenario at every repeat, one cell at a time on the
+* run's lanes. The kept surface is the policy's leader: a budget decision on
+* the train split that claims nothing; `runImprovementLoop` compares it with
+* the baseline on separate cases.
+*
+* The search ledger is always written, beside the run (`<runDir>/search/`) or
+* where `searchLedger` puts it, and it is the run's only checkpoint: running
+* again on the same run directory and options continues an interrupted run
+* instead of starting over, and reruns nothing that settled.
+*/
+/** Improve a surface as a search on the kernel; see the module comment. */
+async function runOptimization(opts) {
+	const candidateConcurrency = opts.candidateConcurrency ?? 1;
+	if (typeof opts.runDir !== "string" || opts.runDir.trim().length === 0) throw new Error("runOptimization: runDir is required and must be a non-empty string");
+	if (!Number.isInteger(candidateConcurrency) || candidateConcurrency < 1) throw new Error("runOptimization: candidateConcurrency must be a positive integer");
+	for (const [name, value] of [["populationSize", opts.populationSize], ["maxGenerations", opts.maxGenerations]]) if (!Number.isSafeInteger(value) || value < 0) throw new Error(`runOptimization: ${name} must be a non-negative integer`);
+	const initialFindings = immutableProposalSnapshot(assertProposalFindings(opts.findings ?? [], "runOptimization initial proposal findings"), "initial findings");
+	const baselineSurface = immutableProposalSnapshot(opts.baselineSurface, "baseline surface");
+	const runDir = resolveRunDir(opts.runDir, opts.repo);
+	const storage = opts.storage ?? fsCampaignStorage();
+	const costLedger = opts.costLedger ?? createRunCostLedger({
+		storage,
+		runDir,
+		costCeilingUsd: opts.costCeiling
+	});
+	const reps = opts.reps ?? 1;
+	const seed = opts.seed ?? 42;
+	const requireJudgeScore = (opts.judges?.length ?? 0) > 0;
+	const premeasured = opts.premeasuredBaseline ? validatedPremeasuredBaseline({
+		input: opts.premeasuredBaseline,
+		baselineSurface,
+		scenarios: opts.scenarios,
+		reps,
+		seed,
+		judges: opts.judges ?? [],
+		dispatchRef: surfaceDispatchRef(baselineSurface, opts.dispatchRef),
+		requireJudgeScore
+	}) : void 0;
+	const splitDigest = campaignSplitDigest(opts.scenarios, reps);
+	const binding = opts.searchLedger ?? await defaultBinding(opts, runDir, storage);
+	const { identity } = binding;
+	const execution = {
+		model: identity.model,
+		agent: identity.agent,
+		benchmark: {
+			uri: "campaign://scenarios",
+			revision: splitDigest
+		}
+	};
+	const policy = opts.policy ?? incumbent();
+	const allocation = uniform({ reps });
+	const recorder = await SearchRecorder.open({
+		ledger: binding.ledger,
+		storage
+	}, {
+		subject: identity.subject ?? opts.proposer.kind,
+		process: {
+			name: "runOptimization",
+			executionRef: identity.search
+		},
+		artifactKind: artifactKindOf(baselineSurface),
+		objective: {
+			metric: "composite",
+			direction: "maximize",
+			judge: identity.judge ?? { unknown: "runOptimization receives its judges as functions without a pinned source" },
+			claim: identity.claim ?? developmentClaim(splitDigest)
+		},
+		splits: {
+			train: opts.scenarios.map((scenario) => ({
+				taskId: scenario.id,
+				unitId: scenario.id,
+				source: {
+					uri: `scenario://${scenario.id}`,
+					revision: hashCanonical(scenario)
+				}
+			})),
+			selection: [],
+			test: [],
+			heldOutUnits: true
+		},
+		policy: {
+			expansion: policy.name,
+			allocation: allocation.name,
+			seed
+		},
+		budget: {
+			maxUsd: opts.costCeiling ?? null,
+			maxCells: null,
+			maxNodes: 1 + opts.populationSize * opts.maxGenerations,
+			deadline: null,
+			maxConcurrency: null,
+			reservedClaimUsd: 0
+		},
+		containment: null,
+		derivedFrom: null,
+		identity: execution
+	});
+	const nodes = new SurfaceNodes({
+		opts,
+		recorder,
+		runDir,
+		costLedger,
+		execution,
+		premeasured
+	});
+	const scenarioById = new Map(opts.scenarios.map((scenario) => [scenario.id, scenario]));
+	let findings = initialFindings;
+	const executor = {
+		lanes: () => [{
+			name: "campaign",
+			capacity: candidateConcurrency * (opts.maxConcurrency ?? 2),
+			costCap: "estimate",
+			cellUsd: 0
+		}],
+		place: () => "campaign",
+		run: (work) => nodes.runCell(work, scenarioById),
+		adopt: (work) => nodes.adoptCell(work)
+	};
+	const proposer = opts.proposer;
+	const proposerSource = identity.proposer.source;
+	const port = {
+		name: proposer.kind,
+		kind: "optimizer",
+		source: proposerSource,
+		execution: identity.proposer,
+		childrenPerProposal: opts.populationSize,
+		async propose(request) {
+			const phases = [
+				"search.proposal",
+				"analysis.baseline",
+				"analysis.generation"
+			];
+			const before = new Set(phases.flatMap((phase) => costLedger.list({ phase })).map(receiptKey));
+			const accounting = () => {
+				const fresh = phases.flatMap((phase) => costLedger.list({ phase })).filter((receipt) => !before.has(receiptKey(receipt)));
+				return {
+					accounting: receiptAccounting(fresh),
+					execution: opts.searchLedger ? identity.proposer : proposalExecution(fresh, identity.model.provider, proposerSource)
+				};
+			};
+			const earlier = await recorder.state();
+			const root = earlier.rootNodeId;
+			const rootCampaign = nodes.campaign(earlier, root);
+			const rootCoverage = campaignCoverage(rootCampaign.cells, opts.scenarios, reps, requireJudgeScore);
+			if (!rootCoverage.complete) throw new Error(`runOptimization: ${premeasured ? "premeasured baseline" : "baseline"} is incomplete (${rootCoverage.scorableCellIds.length}/${rootCoverage.expectedCellIds.length} designed cells scorable) — ${formatCoverageFailures(rootCoverage)}. Refusing to optimize against an incomplete incumbent.`);
+			const generation = nodes.generations(earlier).length;
+			if (opts.analyzeGeneration) {
+				const previous = generation - 1;
+				const candidates = (previous < 0 ? [root] : nodes.expansionNodes(earlier, nodes.generations(earlier)[previous])).map((nodeId) => {
+					const campaign = nodes.campaign(earlier, nodeId);
+					return {
+						surfaceHash: surfaceHash(nodes.surface(earlier, nodeId)),
+						campaign,
+						composite: campaignMeanCompositeOrNull(campaign)
+					};
+				});
+				const history = nodes.history(earlier, policy);
+				if (candidates.some(({ campaign }) => campaign.cells.length > 0)) {
+					const fresh = await opts.analyzeGeneration({
+						generation: previous,
+						runDir: previous < 0 ? rootCampaign.runDir : `${runDir}/candidates`,
+						candidates,
+						history,
+						costLedger,
+						costPhase: previous < 0 ? "analysis.baseline" : "analysis.generation"
+					});
+					if (!Array.isArray(fresh)) throw new TypeError("runOptimization: analyzeGeneration must return an array");
+					findings = immutableProposalSnapshot(assertProposalFindings(fresh, "runOptimization analysis findings"), "analysis findings");
+				}
+			}
+			const state = await recorder.state();
+			const proposalHistory = immutableProposalSnapshot(nodes.history(state, policy), "history");
+			const parent = request.parents[0];
+			const context = Object.freeze({
+				currentSurface: immutableProposalSnapshot(parent.artifact, "current surface"),
+				operator: request.operator,
+				history: proposalHistory,
+				findings: immutableProposalSnapshot(assertProposalFindings(findings, "runOptimization proposal findings"), "findings"),
+				populationSize: opts.populationSize,
+				generation,
+				signal: request.signal,
+				baselineOutcome: immutableProposalSnapshot(nodes.outcome(state, root), "baseline"),
+				incumbentOutcome: immutableProposalSnapshot(nodes.outcome(state, request.leader), "incumbent outcome"),
+				parentOutcome: immutableProposalSnapshot(nodes.outcome(state, parent.nodeId), "parent outcome"),
+				maxImprovementShots: opts.maxImprovementShots,
+				paretoParents: immutableProposalSnapshot(nodes.frontier(state), "Pareto parents"),
+				costLedger,
+				costPhase: "search.proposal"
+			});
+			if (proposer.decide?.({ history: proposalHistory }).stop) return {
+				children: [],
+				stop: "the proposer decided to stop",
+				...accounting()
+			};
+			const proposed = await proposer.propose(context);
+			if (!Array.isArray(proposed)) throw new TypeError("runOptimization: proposer must return an array");
+			return {
+				children: immutableProposalSnapshot(proposed, "candidate outputs").slice(0, opts.populationSize).map((candidate) => isProposedCandidate(candidate) ? {
+					artifact: candidate.surface,
+					label: candidate.label,
+					rationale: candidate.rationale,
+					...candidate.attribution ? { attribution: candidate.attribution } : {}
+				} : {
+					artifact: candidate,
+					label: "",
+					rationale: ""
+				}),
+				...accounting()
+			};
+		}
+	};
+	const result = await runSearch({
+		recorder,
+		root: baselineSurface,
+		codec: surfaceCodec,
+		policy,
+		allocation,
+		proposer: port,
+		executor,
+		maxExpansions: opts.maxGenerations,
+		signal: opts.signal
+	});
+	const state = result.state;
+	const winnerSurface = nodes.surface(state, result.leader);
+	const firstEdge = state.edge(state.node(result.leader).edgeIds[0]);
+	const winnerRationale = firstEdge.operator === "seed" || !("sha256" in firstEdge.rationale) ? void 0 : recorder.readBlob(firstEdge.rationale).text;
+	const expansions = nodes.generations(state);
+	return {
+		generations: nodes.history(state, policy).map((record) => ({
+			record,
+			surfaces: nodes.expansionNodes(state, expansions[record.generationIndex]).map((nodeId) => {
+				const surface = nodes.surface(state, nodeId);
+				return {
+					surfaceHash: surfaceHash(surface),
+					surface,
+					campaign: nodes.campaign(state, nodeId)
+				};
+			})
+		})),
+		baselineSurface,
+		winnerSurface,
+		winnerSurfaceHash: surfaceHash(winnerSurface),
+		...firstEdge.operator !== "seed" && firstEdge.label ? { winnerLabel: firstEdge.label } : {},
+		...winnerRationale ? { winnerRationale } : {},
+		baselineCampaign: nodes.campaign(state, state.rootNodeId),
+		cost: costLedger.summary(),
+		searchHistory: recorder.receipt({
+			producerId: proposer.kind,
+			runId: runDir
+		}),
+		paretoFrontier: nodes.frontier(state)
 	};
 }
-/** A parent-to-child diff of two mutable surfaces, stored as a blob. */
-function surfaceDiff(recorder, parent, child) {
-	return recorder.blob("diff", {
-		kind: "surface-diff",
-		from: surfaceContentHash(parent),
-		to: surfaceContentHash(child),
-		text: renderSurfaceDiff(child, parent)
-	});
-}
-/** Declared surfaces of one node. A component surface declares one surface per
-* named component, so per-component evidence stays addressable. */
-function declaredSurfaces(surface, artifact) {
-	if (typeof surface === "string") return [{
-		surfaceId: "prompt",
-		kind: "prompt",
-		artifact
-	}];
-	if (surface.kind === "code") return [{
-		surfaceId: "code",
-		kind: "code",
-		artifact
-	}];
-	return Object.keys(surface.components).sort().map((name) => ({
-		surfaceId: `component:${name}`,
-		kind: "prompt",
-		artifact
-	}));
-}
-function boundedLabel(label) {
-	const redacted = redactText(label.trim(), { profile: "share" });
-	return redacted.length <= MAX_LABEL_CHARS ? redacted : `${redacted.slice(0, MAX_LABEL_CHARS - 1)}…`;
-}
-/** The header without its stamp, for comparing a resumed opening to the stored one. */
-function headerMaterial(header) {
-	const { occurredAt: _occurredAt, ...material } = header;
-	return canonicalString(material);
-}
-/** The header as the ledger would store it, so the comparison ignores ordering. */
-function canonicalHeader(header) {
-	return validateSearchLedgerEvent({
-		...header,
-		occurredAt: "2000-01-01T00:00:00.000Z"
-	});
-}
-//#endregion
-//#region src/campaign/presets/run-optimization-recording.ts
-var OptimizationSearch = class OptimizationSearch {
+/** A mutable surface as a search artifact. */
+const surfaceCodec = {
+	node: surfaceNode,
+	diff: surfaceDiff,
+	load: (recorder, node) => {
+		const stored = recorder.readBlob(node.artifact);
+		if (stored.kind !== "mutable-surface" || stored.surface === void 0) throw new Error(`runOptimization: node ${node.nodeId} does not hold a mutable surface`);
+		return stored.surface;
+	}
+};
+/**
+* The run's view of its surface nodes: where each one's cells run, its
+* campaign, and the proposer's reads over them. Everything here derives from
+* the ledger and the per-cell campaign cache, so a resumed run reads the same.
+*/
+var SurfaceNodes = class {
+	opts;
 	recorder;
-	binding;
+	runDir;
 	costLedger;
-	scenarioIds;
-	reps;
-	identity;
-	proposerName;
-	proposalReceiptCount = 0;
-	constructor(args) {
-		this.recorder = args.recorder;
-		this.binding = args.binding;
-		this.costLedger = args.costLedger;
-		this.scenarioIds = args.scenarioIds;
-		this.reps = args.reps;
-		this.identity = args.identity;
-		this.proposerName = args.proposerName;
-	}
-	/** Open the search and record the measured baseline as its seeded root. */
-	static async open(args) {
-		const { binding } = args;
-		const identity = {
-			model: binding.identity.model,
-			agent: binding.identity.agent,
-			benchmark: {
-				uri: "campaign://scenarios",
-				revision: args.splitDigest
-			}
-		};
-		const train = args.scenarios.map((scenario) => ({
-			taskId: scenario.id,
-			unitId: scenario.id,
-			source: {
-				uri: `scenario://${scenario.id}`,
-				revision: hashCanonical(scenario)
-			}
+	execution;
+	premeasured;
+	storage;
+	campaigns = /* @__PURE__ */ new Map();
+	proposals = /* @__PURE__ */ new Map();
+	/** Cells this process ran or adopted, by node, keyed `scenarioId:rep`. */
+	cells = /* @__PURE__ */ new Map();
+	constructor(input) {
+		this.opts = input.opts;
+		this.recorder = input.recorder;
+		this.runDir = input.runDir;
+		this.costLedger = input.costLedger;
+		this.execution = input.execution;
+		this.premeasured = input.premeasured;
+		this.storage = input.opts.storage ?? fsCampaignStorage();
+	}
+	/** `<runDir>/baseline` for the root, `<runDir>/candidates/<surfaceHash>`
+	* for every other node: content-addressed, so a cell's directory needs no
+	* ledger read and one surface keeps one cache across the run's searches. */
+	nodeDir(surface, root) {
+		return root ? `${this.runDir}/baseline` : `${this.runDir}/candidates/${surfaceHash(surface)}`;
+	}
+	surface(state, nodeId) {
+		return surfaceCodec.load(this.recorder, state.node(nodeId));
+	}
+	/** Nodes proposal `expansion` registered, in the order it returned them. */
+	expansionNodes(state, expansion) {
+		const blob = this.proposal(state, expansion);
+		if (!blob) return [];
+		const ids = [];
+		for (const child of blob.children) {
+			const nodeId = state.nodeIdForDigest(child.node.artifactDigest);
+			if (nodeId === void 0 || ids.includes(nodeId)) continue;
+			if (this.origin(state, nodeId).expansion === expansion) ids.push(nodeId);
+		}
+		return ids;
+	}
+	/**
+	* The scored attempt of a cell an earlier process ran, from its node's
+	* cache; null otherwise, so the kernel runs the cell. A failure is not
+	* adopted: the stop that interrupted the earlier process may have caused it.
+	*/
+	async adoptCell(work) {
+		if (work.stage === "root" && this.premeasured) return this.premeasuredCell(work);
+		const dir = this.nodeDir(work.artifact, work.stage === "root");
+		const cached = this.storage.read(cellCachePath(dir, `${work.taskId}:${work.rep}`));
+		const cell = cached === void 0 ? void 0 : JSON.parse(cached);
+		if (cell?.manifestHash !== this.manifestFor(work.artifact)) return null;
+		this.remember(work.nodeId, cell);
+		return this.cellResult(cell, work);
+	}
+	/** Run one cell as a one-cell campaign in its node's directory; a cached
+	* cell is read back, not dispatched again. */
+	async runCell(work, scenarios) {
+		if (work.stage === "root" && this.premeasured) return this.premeasuredCell(work);
+		if (!scenarios.has(work.taskId)) throw new Error(`runOptimization: cell ${work.cellId} names unknown scenario ${work.taskId}`);
+		const dir = this.nodeDir(work.artifact, work.stage === "root");
+		const cell = (await this.campaignRun(dir, work.artifact, {
+			signal: work.signal,
+			costPhase: work.stage === "root" ? "search.baseline" : "search.candidate",
+			cellFilter: ({ scenario, rep }) => scenario.id === work.taskId && rep === work.rep
+		})).cells[0];
+		if (!cell) throw new Error(`runOptimization: cell ${work.cellId} produced no campaign cell`);
+		this.remember(work.nodeId, cell);
+		return this.cellResult(cell, work);
+	}
+	/** The node's campaign over the cells the ledger settled: the cells this
+	* process ran, else their cached results or failure receipts. */
+	campaign(state, nodeId) {
+		const root = nodeId === state.rootNodeId;
+		if (root && this.premeasured) return this.premeasured;
+		const surface = this.surface(state, nodeId);
+		const dir = this.nodeDir(surface, root);
+		const settled = state.cells({ nodeId }).filter((cell) => cell.attempts > 0).map((cell) => ({
+			taskId: cell.taskId,
+			rep: cell.rep
 		}));
-		const recorder = await SearchRecorder.open({
-			ledger: binding.ledger,
-			storage: args.storage
-		}, {
-			subject: binding.identity.subject ?? args.proposerName,
-			process: {
-				name: "runOptimization",
-				executionRef: binding.identity.search
-			},
-			artifactKind: "prompt",
-			objective: {
-				metric: "composite",
-				direction: "maximize",
-				judge: binding.identity.judge ?? { unknown: "runOptimization receives its judges as functions without a pinned source" },
-				claim: binding.identity.claim ?? developmentClaim(args.splitDigest)
-			},
-			splits: {
-				train,
-				selection: [],
-				test: [],
-				heldOutUnits: true
-			},
-			policy: {
-				expansion: args.expansion,
-				allocation: "uniform",
-				seed: args.seed
-			},
-			budget: {
-				maxUsd: args.maxUsd,
-				maxCells: null,
-				maxNodes: null,
-				deadline: null,
-				maxConcurrency: null,
-				reservedClaimUsd: 0
-			},
-			containment: null,
-			derivedFrom: null,
-			identity
-		});
-		const search = new OptimizationSearch({
-			recorder,
-			binding,
-			costLedger: args.costLedger,
-			scenarioIds: args.scenarios.map((scenario) => scenario.id),
-			reps: args.reps,
-			identity,
-			proposerName: args.proposerName
+		const key = settled.map(({ taskId, rep }) => `${taskId}:${rep}`).sort().join("\n");
+		const held = this.campaigns.get(nodeId);
+		if (held?.cells === key) return held.campaign;
+		const known = this.cells.get(nodeId);
+		const cells = settled.map(({ taskId, rep }) => {
+			const cell = known?.get(`${taskId}:${rep}`) ?? this.storedCell(dir, surface, taskId, rep);
+			if (!cell) throw new Error(`runOptimization: cell ${taskId}:${rep} of node ${nodeId} settled, but ${dir} holds neither its cached result nor its failure receipt`);
+			return cell;
 		});
-		const root = await recorder.registerNode(surfaceNode(recorder, args.baselineSurface));
-		await recorder.recordEdge({
-			childNodeId: root.nodeId,
-			parents: [],
-			operator: "seed",
-			attribution: "explicit",
-			proposer: null,
-			proposalKey: "baseline",
-			rationale: { unknown: "the baseline is the caller-supplied starting surface" },
-			diffs: [],
-			label: "baseline"
-		});
-		await search.recordCells(root.nodeId, "root", args.baselineCells);
-		return {
-			search,
-			rootNodeId: root.nodeId
+		cells.sort((a, b) => a.cellId < b.cellId ? -1 : a.cellId > b.cellId ? 1 : 0);
+		const reps = this.opts.reps ?? 1;
+		const seed = this.opts.seed ?? 42;
+		const judges = this.opts.judges ?? [];
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const durationMs = cells.reduce((sum, cell) => sum + cell.durationMs, 0);
+		const campaign = {
+			manifestHash: this.manifestFor(surface),
+			splitDigest: campaignSplitDigest(this.opts.scenarios, reps),
+			seed,
+			reps,
+			startedAt: now,
+			endedAt: now,
+			durationMs,
+			cells,
+			aggregates: computeAggregates(cells, judges, seed, this.costLedger.summary({ tags: { runDir: dir } })),
+			runDir: dir,
+			artifactsByPath: {},
+			scenarios: this.opts.scenarios.map(campaignScenarioIdentity)
 		};
-	}
-	/** Start one generation's candidate-generation operation, before `propose()`. */
-	async startGeneration(generation) {
-		await this.recorder.startOperation({
-			operationId: generationOperationId(generation),
-			operationKind: "candidate-generation"
+		this.campaigns.set(nodeId, {
+			cells: key,
+			campaign
 		});
+		return campaign;
 	}
-	/** Record the generation's proposal: its operation, then one node and edge per candidate. */
-	async recordProposal(input) {
-		const operationId = generationOperationId(input.generation);
-		await this.recorder.recordOperation({
-			operationId,
-			operationKind: "candidate-generation",
-			execution: this.binding.identity.proposer,
-			outcome: { status: "completed" },
-			accounting: this.proposalAccounting()
-		});
-		const nodeIds = [];
-		for (const [index, candidate] of input.candidates.entries()) {
-			const { nodeId } = await this.recorder.registerNode(surfaceNode(this.recorder, candidate.surface));
-			await this.recorder.recordEdge({
-				childNodeId: nodeId,
-				parents: [input.parent.nodeId],
-				operator: "improve",
-				attribution: "explicit",
-				proposer: {
-					kind: "optimizer",
-					name: this.proposerName,
-					operationId,
-					source: this.binding.identity.proposer.source
-				},
-				proposalKey: `gen-${input.generation}:candidate-${index}`,
-				selection: {
-					rule: input.selectionRule,
-					evidence: input.parent.composite === null ? {} : { parentComposite: input.parent.composite }
-				},
-				rationale: candidate.rationale,
-				diffs: [surfaceDiff(this.recorder, input.parent.surface, candidate.surface)],
-				label: candidate.label
+	outcome(state, nodeId) {
+		const campaign = this.campaign(state, nodeId);
+		const reps = this.opts.reps ?? 1;
+		const coverage = campaignCoverage(campaign.cells, this.opts.scenarios, reps, (this.opts.judges?.length ?? 0) > 0);
+		const expansion = nodeId === state.rootNodeId ? -1 : this.generationOf(state, this.origin(state, nodeId).expansion);
+		return toScoredSurfaceOutcome(surfaceHash(this.surface(state, nodeId)), campaign, coverage, expansion);
+	}
+	/** The Pareto frontier over every measured, complete node. */
+	frontier(state) {
+		const scored = [];
+		for (const node of state.nodes()) {
+			if (node.status === "invalid" || node.cellCount === 0) continue;
+			const cells = state.cells({ nodeId: node.nodeId });
+			if (cells.some((cell) => cell.attempts === 0 && cell.cancelled === null)) continue;
+			if (cells.some((cell) => cell.score === null)) continue;
+			const campaign = this.campaign(state, node.nodeId);
+			const edge = state.edge(node.edgeIds[0]);
+			scored.push(toParetoParent(this.surface(state, node.nodeId), campaign, node.nodeId === state.rootNodeId ? -1 : this.generationOf(state, this.origin(state, node.nodeId).expansion), edge.operator === "seed" ? void 0 : edge.label || void 0));
+		}
+		return computeParetoFrontier(scored);
+	}
+	/** Kernel expansions that registered a candidate, in order: generation g
+	* is `generations(state)[g]`. */
+	generations(state) {
+		const expansions = [];
+		for (let expansion = 0; state.operation(`expand-${expansion}`); expansion++) if (this.expansionNodes(state, expansion).length > 0) expansions.push(expansion);
+		return expansions;
+	}
+	/** One record per generation, with its candidates and the one that took
+	* the lead, if any. */
+	history(state, policy) {
+		const records = [];
+		const measured = (nodeId) => state.node(nodeId).status !== "invalid" && state.cells({ nodeId }).every((cell) => cell.attempts > 0 || cell.cancelled !== null);
+		const screened = [state.rootNodeId];
+		let leader = policy.leader(searchPolicyView(state, {
+			screened,
+			screening: 0,
+			expansions: 0
+		}));
+		for (const [generation, expansion] of this.generations(state).entries()) {
+			const nodeIds = this.expansionNodes(state, expansion);
+			screened.push(...nodeIds.filter(measured));
+			screened.sort((a, b) => state.node(a).ordinal - state.node(b).ordinal);
+			const next = policy.leader(searchPolicyView(state, {
+				screened,
+				screening: 0,
+				expansions: expansion + 1
+			}));
+			const candidates = [];
+			for (const nodeId of nodeIds) candidates.push(this.candidate(state, nodeId, expansion));
+			records.push({
+				generationIndex: generation,
+				candidates,
+				promoted: next !== leader && nodeIds.includes(next) ? [surfaceHash(this.surface(state, next))] : []
 			});
-			nodeIds.push(nodeId);
+			leader = next;
 		}
-		return nodeIds;
+		return records;
 	}
-	/** Close a generation whose proposer produced nothing or failed. */
-	async failGeneration(generation, message) {
-		await this.recorder.recordOperation({
-			operationId: generationOperationId(generation),
-			operationKind: "candidate-generation",
-			execution: this.binding.identity.proposer,
-			outcome: {
-				status: "failed",
-				failure: {
-					code: "no-candidates",
-					message
-				}
+	candidate(state, nodeId, expansion) {
+		const campaign = this.campaign(state, nodeId);
+		const coverage = campaignCoverage(campaign.cells, this.opts.scenarios, this.opts.reps ?? 1, (this.opts.judges?.length ?? 0) > 0);
+		const breakdown = campaignBreakdown(campaign);
+		const child = this.proposal(state, expansion).children.find((entry) => state.nodeIdForDigest(entry.node.artifactDigest) === nodeId);
+		return {
+			surfaceHash: surfaceHash(this.surface(state, nodeId)),
+			composite: campaignMeanCompositeOrNull(campaign),
+			eligibleForPromotion: coverage.complete,
+			coverage: {
+				expectedCells: coverage.expectedCellIds.length,
+				scorableCells: coverage.scorableCellIds.length,
+				unscorableCells: coverage.unscorableCells
 			},
-			accounting: this.proposalAccounting()
-		});
+			dimensions: breakdown.dimensions,
+			scenarios: breakdown.scenarios,
+			...child.label ? { label: child.label } : {},
+			...child.rationale ? { rationale: child.rationale } : {},
+			...child.attribution ? { attribution: child.attribution } : {}
+		};
 	}
-	/** Allocate every designed cell of a node before its campaign runs. */
-	async allocate(nodeId) {
-		for (const taskId of this.scenarioIds) for (let rep = 0; rep < this.reps; rep++) await this.recorder.allocateCell({
-			nodeId,
-			taskId,
-			split: "train",
-			rep,
-			stage: "train"
-		});
+	generationOf(state, expansion) {
+		return this.generations(state).indexOf(expansion);
 	}
-	/** Settle a node's campaign cells; allocates any the campaign ran beyond the design. */
-	async recordCells(nodeId, stage, cells) {
-		for (const cell of cells) {
-			const cellId = await this.recorder.allocateCell({
-				nodeId,
-				taskId: cell.scenarioId,
-				split: "train",
-				rep: cell.rep,
-				stage
-			});
-			await this.recorder.settleCell({
-				cellId,
-				attempt: 1,
-				outcome: cellOutcome(cell),
-				accounting: cellAccounting(cell),
-				identity: {
-					...this.identity,
-					model: this.cellModel(cell)
-				},
-				wallMs: cell.durationMs,
-				traceRef: { unknown: "runCampaign reports no trace id per cell" }
-			});
-		}
+	origin(state, nodeId) {
+		const node = state.node(nodeId);
+		const operationId = state.edge(node.edgeIds[0])?.proposer?.operationId ?? null;
+		const expansion = operationId === null ? null : searchExpansionIndex(operationId);
+		if (expansion === null) throw new Error(`runOptimization: node ${nodeId} was not proposed by this run's search`);
+		return {
+			expansion,
+			index: this.proposal(state, expansion).children.findIndex((child) => child.node.artifactDigest === node.artifactDigest)
+		};
 	}
-	/**
-	* Decide every node and close. The winner is selected; every other node is
-	* rejected. Allocated cells a campaign never returned are cancelled.
-	*/
-	async finish(input) {
-		const openCells = (await this.recorder.state()).cells().filter((cell) => cell.attempts === 0 && !cell.cancelled);
-		for (const cell of openCells) await this.recorder.cancelCell({
-			cellId: cell.cellId,
-			reason: "aborted"
-		});
-		for (const node of (await this.recorder.state()).nodes()) await this.recorder.decideNode({
-			nodeId: node.nodeId,
-			decision: node.nodeId === input.winnerNodeId ? { status: "selected" } : { status: "rejected" },
-			rule: "incumbent",
-			reason: node.nodeId === input.winnerNodeId ? "the incumbent when the loop stopped" : node.ordinal === 0 || input.promotedNodeIds.has(node.nodeId) ? "a later candidate replaced it as the incumbent" : input.incompleteNodeIds.has(node.nodeId) ? "the candidate missed a designed cell and could not be ranked" : "the candidate did not beat the incumbent"
+	proposal(state, expansion) {
+		const held = this.proposals.get(expansion);
+		if (held) return held;
+		const ref = state.operation(`expand-${expansion}`)?.artifacts.find((artifact) => artifact.role === "proposal");
+		if (!ref) return void 0;
+		const blob = this.recorder.readBlob(ref);
+		this.proposals.set(expansion, blob);
+		return blob;
+	}
+	async campaignRun(runDir, surface, input) {
+		const { baselineSurface: _baselineSurface, premeasuredBaseline: _premeasuredBaseline, dispatchWithSurface, proposer: _proposer, populationSize: _populationSize, maxGenerations: _maxGenerations, candidateConcurrency: _candidateConcurrency, maxImprovementShots: _maxImprovementShots, findings: _findings, analyzeGeneration: _analyzeGeneration, policy: _policy, searchLedger: _searchLedger, ...campaignOptions } = this.opts;
+		return runCampaign({
+			...campaignOptions,
+			signal: input.signal ?? this.opts.signal,
+			costLedger: this.costLedger,
+			costPhase: input.costPhase,
+			dispatchRef: surfaceDispatchRef(surface, this.opts.dispatchRef),
+			dispatch: (scenario, ctx) => dispatchWithSurface(surface, scenario, ctx),
+			runDir,
+			cellFilter: input.cellFilter,
+			resumable: true,
+			maxConcurrency: 1
 		});
-		await this.recorder.close({
-			reason: input.reason,
-			claim: null
-		});
-		return this.recorder.receipt({
-			producerId: this.proposerName,
-			runId: input.runId
+	}
+	premeasuredCell(work) {
+		const cell = this.premeasured.cells.find((candidate) => candidate.scenarioId === work.taskId && candidate.rep === work.rep);
+		if (!cell) throw new Error(`runOptimization: premeasured baseline lacks ${work.taskId}:${work.rep}`);
+		return this.cellResult(cell, work);
+	}
+	/** A cell's result as its campaign stored it: the cache of a scored cell,
+	* the final failure receipt of a failed one. */
+	/** A cell's result as its campaign stored it for this surface: the cache of
+	* a scored cell, the final failure receipt of a failed one. A result another
+	* surface left in the same directory does not count. */
+	storedCell(dir, surface, taskId, rep) {
+		const cellId = `${taskId}:${rep}`;
+		const manifestHash = this.manifestFor(surface);
+		const cached = this.storage.read(cellCachePath(dir, cellId));
+		const scored = cached === void 0 ? void 0 : JSON.parse(cached);
+		if (scored?.manifestHash === manifestHash) return scored;
+		const receipt = this.storage.read(join(cellDirectory(dir, cellId), "failure-receipt.json"));
+		const failed = receipt === void 0 ? void 0 : JSON.parse(receipt).cell;
+		return failed?.manifestHash === manifestHash ? failed : void 0;
+	}
+	manifestFor(surface) {
+		return computeManifestHash({
+			scenarios: this.opts.scenarios,
+			judges: this.opts.judges ?? [],
+			dispatchRef: surfaceDispatchRef(surface, this.opts.dispatchRef),
+			seed: this.opts.seed ?? 42,
+			reps: this.opts.reps ?? 1
 		});
 	}
-	/** Spend booked to candidate generation since the previous generation. */
-	proposalAccounting() {
-		const receipts = this.costLedger.list({ phase: "search.proposal" });
-		const fresh = receipts.slice(this.proposalReceiptCount);
-		this.proposalReceiptCount = receipts.length;
-		return receiptAccounting(fresh);
-	}
-	cellModel(cell) {
-		const resolved = cell.resolvedModel;
-		if (resolved === void 0) return this.identity.model;
-		const provider = this.identity.model.provider;
-		return modelHasSnapshot(resolved) ? {
-			provider,
-			snapshot: resolved
-		} : {
-			provider,
-			alias: resolved,
-			unknown: "the provider reported a moving alias, not a snapshot"
+	remember(nodeId, cell) {
+		const cells = this.cells.get(nodeId) ?? /* @__PURE__ */ new Map();
+		cells.set(`${cell.scenarioId}:${cell.rep}`, cell);
+		this.cells.set(nodeId, cells);
+	}
+	cellResult(cell, work) {
+		return {
+			outcome: cellOutcome(cell),
+			accounting: cellAccounting(cell),
+			identity: {
+				...this.execution,
+				model: cellModel(cell, this.execution.model)
+			},
+			wallMs: cell.durationMs,
+			placement: {
+				lane: work.lane,
+				boxId: null
+			},
+			traceRef: { unknown: "runCampaign reports no trace id per cell" }
 		};
 	}
 };
-function generationOperationId(generation) {
-	return `candidate-generation:gen-${generation}`;
+/** The default ledger and identities when the caller binds none. Revisions are
+* content digests of what the caller declared, and each uri names what its
+* digest covers: the dispatch ref, the proposer kind, the kernel. */
+async function defaultBinding(opts, runDir, storage) {
+	const base = `optimization-${createHash("sha256").update(runDir).digest("hex").slice(0, 16)}`;
+	const dispatchRef = opts.dispatchRef ?? "anonymous";
+	const identity = {
+		agent: {
+			uri: `dispatch-ref:${dispatchRef}`,
+			revision: hashCanonical({ dispatchRef })
+		},
+		proposer: {
+			kind: "deterministic",
+			source: {
+				uri: `proposer:${opts.proposer.kind}`,
+				revision: hashCanonical({ proposer: opts.proposer.kind })
+			}
+		},
+		search: SEARCH_KERNEL_SOURCE,
+		model: {
+			provider: "unspecified",
+			alias: "unspecified",
+			unknown: "runOptimization was not told which model the agent runs"
+		}
+	};
+	for (let slot = 1;; slot++) {
+		const path = `${slot === 1 ? `${runDir}/search` : `${runDir}/search-${slot}`}/ledger.jsonl`;
+		const searchId = slot === 1 ? base : `${base}-${slot}`;
+		const ledger = storage.kind === "filesystem" ? openSearchLedger({
+			path,
+			searchId
+		}) : openSearchLedger({
+			path,
+			searchId,
+			store: storage
+		});
+		if (!(await ledger.state()).closed) return {
+			ledger,
+			identity
+		};
+	}
+}
+function artifactKindOf(surface) {
+	return typeof surface === "object" && surface.kind === "code" ? "code" : "prompt";
+}
+function receiptKey(receipt) {
+	return receipt.callId;
+}
+/** A proposal that made a paid call ran a model; one that made none ran code. */
+function proposalExecution(receipts, provider, source) {
+	const model = receipts.find((receipt) => receipt.channel !== "judge")?.model;
+	if (model === void 0) return {
+		kind: "deterministic",
+		source
+	};
+	return {
+		kind: "model",
+		model: modelIdentity(model, provider),
+		source
+	};
+}
+function modelIdentity(model, provider) {
+	return modelHasSnapshot(model) ? {
+		provider,
+		snapshot: model
+	} : {
+		provider,
+		alias: model,
+		unknown: "the provider reported a moving alias, not a snapshot"
+	};
+}
+function cellModel(cell, fallback) {
+	return cell.resolvedModel === void 0 ? fallback : modelIdentity(cell.resolvedModel, fallback.provider);
 }
 function cellOutcome(cell) {
-	const scores = Object.entries(cell.judgeScores).filter(([, score]) => score.failed !== true && Number.isFinite(score.composite));
-	if (cell.error !== void 0 || scores.length === 0) return {
+	const quality = projectCampaignCellQuality(cell);
+	if (quality.score === void 0) return {
 		status: "errored",
 		metrics: {},
 		error: {
@@ -4772,12 +4908,11 @@ function cellOutcome(cell) {
 			retryable: false
 		}
 	};
-	const composite = scores.reduce((sum, [, score]) => sum + score.composite, 0) / scores.length;
-	const metrics = { composite };
-	for (const [judge, score] of scores) metrics[`judge.${judge}`] = score.composite;
+	const metrics = { composite: quality.score };
+	for (const [judge, score] of Object.entries(quality.successfulJudgeScores)) metrics[`judge.${judge}`] = score.composite;
 	return {
 		status: "passed",
-		score: composite,
+		score: quality.score,
 		metrics
 	};
 }
@@ -4840,332 +4975,6 @@ function receiptAccounting(receipts) {
 		}
 	};
 }
-//#endregion
-//#region src/campaign/presets/run-optimization.ts
-/**
-* `runOptimization` runs a caller-owned candidate generator for a bounded
-* number of rounds. Each candidate is measured on the same cases, and only a
-* candidate that beats the current best becomes the incumbent. By default the
-* incumbent is also the parent every generation mutates; a `selectParent`
-* policy draws the parent from the Pareto frontier instead.
-* The same loop accepts deterministic, model-backed, or agent-backed
-* proposers; they differ only in how `propose()` picks candidates.
-*
-* `runImprovementLoop` adds a separate final comparison, a release decision,
-* and optional pull request creation.
-*/
-/**
-* Improvement loop body: N generations of propose → campaign → rank, maintaining a Pareto frontier and one global incumbent across generations. The parent each generation mutates is the incumbent unless `selectParent` draws it from the frontier.
-*/
-async function runOptimization(opts) {
-	const { proposer } = opts;
-	const candidateConcurrency = opts.candidateConcurrency ?? 1;
-	if (typeof opts.runDir !== "string" || opts.runDir.trim().length === 0) throw new Error("runOptimization: runDir is required and must be a non-empty string");
-	if (!Number.isInteger(candidateConcurrency) || candidateConcurrency < 1) throw new Error("runOptimization: candidateConcurrency must be a positive integer");
-	const initialFindings = immutableProposalSnapshot(assertProposalFindings(opts.findings ?? [], "runOptimization initial proposal findings"), "initial findings");
-	const baselineSurface = immutableProposalSnapshot(opts.baselineSurface, "baseline surface");
-	opts.runDir = resolveRunDir(opts.runDir, opts.repo);
-	const storage = opts.storage ?? fsCampaignStorage();
-	const costLedger = opts.costLedger ?? createRunCostLedger({
-		storage,
-		runDir: opts.runDir,
-		costCeilingUsd: opts.costCeiling
-	});
-	const requireJudgeScore = (opts.judges?.length ?? 0) > 0;
-	const reps = opts.reps ?? 1;
-	const premeasuredBaseline = opts.premeasuredBaseline;
-	const baselineCampaign = premeasuredBaseline ? validatedPremeasuredBaseline({
-		input: premeasuredBaseline,
-		baselineSurface,
-		scenarios: opts.scenarios,
-		reps,
-		seed: opts.seed ?? 42,
-		judges: opts.judges ?? [],
-		dispatchRef: surfaceDispatchRef(baselineSurface, opts.dispatchRef)
-	}) : await runCampaign({
-		...opts,
-		costLedger,
-		costPhase: "search.baseline",
-		dispatchRef: surfaceDispatchRef(baselineSurface, opts.dispatchRef),
-		dispatch: (scenario, ctx) => opts.dispatchWithSurface(baselineSurface, scenario, ctx),
-		runDir: `${opts.runDir}/baseline`
-	});
-	const baselineCoverage = campaignCoverage(baselineCampaign.cells, opts.scenarios, reps, requireJudgeScore);
-	if (!baselineCoverage.complete) {
-		const label = opts.premeasuredBaseline ? "premeasured baseline" : "baseline";
-		throw new Error(`runOptimization: ${label} is incomplete (${baselineCoverage.scorableCellIds.length}/${baselineCoverage.expectedCellIds.length} designed cells scorable) — ${formatCoverageFailures(baselineCoverage)}. Refusing to optimize against an incomplete incumbent.`);
-	}
-	const opened = opts.searchLedger ? await OptimizationSearch.open({
-		binding: opts.searchLedger,
-		storage,
-		costLedger,
-		scenarios: opts.scenarios,
-		reps,
-		seed: opts.seed ?? 42,
-		splitDigest: baselineCampaign.splitDigest,
-		proposerName: proposer.kind,
-		expansion: opts.selectParent ? "select-parent" : "incumbent",
-		maxUsd: opts.costCeiling ?? null,
-		baselineSurface,
-		baselineCells: baselineCampaign.cells
-	}) : void 0;
-	const search = opened?.search;
-	const nodeIdByHash = /* @__PURE__ */ new Map();
-	if (opened) nodeIdByHash.set(surfaceHash(baselineSurface), opened.rootNodeId);
-	const incompleteNodeIds = /* @__PURE__ */ new Set();
-	const promotedNodeIds = /* @__PURE__ */ new Set();
-	let stopReason = "max-nodes";
-	const generations = [];
-	const history = [];
-	let currentFindings = initialFindings;
-	const selectionRankKey = opts.selectionRankKey ?? ((campaign) => [campaignMeanComposite(campaign)]);
-	let winnerSurface = baselineSurface;
-	let winnerSurfaceHash = surfaceHash(baselineSurface);
-	const admittedCandidateHashes = /* @__PURE__ */ new Set([winnerSurfaceHash]);
-	let winnerComposite = campaignMeanComposite(baselineCampaign);
-	let winnerRankKey = selectionRankKey(baselineCampaign);
-	assertFiniteRankKey(winnerRankKey, "selectionRankKey for baseline");
-	const baselineOutcome = toScoredSurfaceOutcome(winnerSurfaceHash, baselineCampaign, baselineCoverage, -1);
-	let winnerOutcome = baselineOutcome;
-	let winnerLabel;
-	let winnerRationale;
-	const scored = [toParetoParent(baselineSurface, winnerSurfaceHash, baselineCampaign, -1)];
-	const measuredByHash = /* @__PURE__ */ new Map([[winnerSurfaceHash, {
-		parent: scored[0],
-		outcome: baselineOutcome
-	}]]);
-	if (opts.analyzeGeneration && opts.maxGenerations > 0 && baselineCampaign.cells.length > 0) {
-		const fresh = await opts.analyzeGeneration({
-			generation: -1,
-			runDir: baselineCampaign.runDir,
-			candidates: [{
-				surfaceHash: winnerSurfaceHash,
-				campaign: baselineCampaign,
-				composite: winnerComposite
-			}],
-			history,
-			costLedger,
-			costPhase: "analysis.baseline"
-		});
-		if (!Array.isArray(fresh)) throw new TypeError("runOptimization: analyzeGeneration must return an array");
-		currentFindings = immutableProposalSnapshot(assertProposalFindings(fresh, "runOptimization baseline analysis findings"), "baseline analysis findings");
-	}
-	for (let gen = 0; gen < opts.maxGenerations; gen++) {
-		const proposalHistory = immutableProposalSnapshot(history, "history");
-		if (proposer.decide?.({ history: proposalHistory }).stop) {
-			stopReason = "converged";
-			break;
-		}
-		const paretoParents = immutableProposalSnapshot(computeParetoFrontier(scored), "Pareto parents");
-		const incumbentOutcome = immutableProposalSnapshot(winnerOutcome, "incumbent outcome");
-		const selected = opts.selectParent ? resolveSelectedParent(opts.selectParent(Object.freeze({
-			frontier: paretoParents,
-			incumbent: incumbentOutcome,
-			history: proposalHistory,
-			generation: gen
-		})), measuredByHash, gen) : void 0;
-		const parentSurface = selected ? selected.parent.surface : winnerSurface;
-		const parentSurfaceHash = selected ? selected.parent.surfaceHash : winnerSurfaceHash;
-		const parentComposite = selected ? selected.outcome.composite : winnerComposite;
-		const parentOutcome = selected ? selected.outcome : winnerOutcome;
-		const proposalContext = Object.freeze({
-			currentSurface: immutableProposalSnapshot(parentSurface, "current surface"),
-			history: proposalHistory,
-			findings: immutableProposalSnapshot(assertProposalFindings(currentFindings, "runOptimization proposal findings"), "findings"),
-			populationSize: opts.populationSize,
-			generation: gen,
-			signal: opts.signal ?? new AbortController().signal,
-			baselineOutcome: immutableProposalSnapshot(baselineOutcome, "baseline outcome"),
-			incumbentOutcome,
-			parentOutcome: immutableProposalSnapshot(parentOutcome, "parent outcome"),
-			maxImprovementShots: opts.maxImprovementShots,
-			paretoParents,
-			costLedger,
-			costPhase: "search.proposal"
-		});
-		await search?.startGeneration(gen);
-		const proposed = await proposer.propose(proposalContext);
-		if (!Array.isArray(proposed)) throw new TypeError("runOptimization: proposer must return an array");
-		const proposalSnapshot = immutableProposalSnapshot(proposed, "candidate outputs");
-		if (proposalSnapshot.length === 0) {
-			await search?.failGeneration(gen, "the proposer returned no candidates");
-			stopReason = "converged";
-			break;
-		}
-		const candidates = proposalSnapshot.map((p) => isProposedCandidate(p) ? p : {
-			surface: p,
-			label: "",
-			rationale: ""
-		});
-		const generationHashes = /* @__PURE__ */ new Set();
-		for (const { surface } of candidates) {
-			const hash = surfaceHash(surface);
-			if (admittedCandidateHashes.has(hash) || generationHashes.has(hash)) throw new Error(`runOptimization: duplicate candidate surface hash "${hash}" in generation ${gen}; candidate surfaces must be unique`);
-			generationHashes.add(hash);
-		}
-		for (const hash of generationHashes) admittedCandidateHashes.add(hash);
-		if (search) {
-			const nodeIds = await search.recordProposal({
-				generation: gen,
-				parent: {
-					nodeId: nodeIdByHash.get(parentSurfaceHash),
-					surface: parentSurface,
-					composite: parentComposite
-				},
-				selectionRule: opts.selectParent ? "select-parent" : "incumbent",
-				candidates
-			});
-			for (const [index, nodeId] of nodeIds.entries()) {
-				nodeIdByHash.set(surfaceHash(candidates[index].surface), nodeId);
-				await search.allocate(nodeId);
-			}
-		}
-		const surfaceResults = await mapConcurrent(candidates, candidateConcurrency, async ({ surface, label, rationale, attribution }, i, signal) => {
-			const hash = surfaceHash(surface);
-			const campaign = await runCampaign({
-				...opts,
-				signal,
-				costLedger,
-				costPhase: "search.candidate",
-				dispatchRef: surfaceDispatchRef(surface, opts.dispatchRef),
-				dispatch: (scenario, ctx) => opts.dispatchWithSurface(surface, scenario, ctx),
-				runDir: `${opts.runDir}/gen-${gen}/candidate-${i}`
-			});
-			const coverage = campaignCoverage(campaign.cells, opts.scenarios, opts.reps ?? 1, requireJudgeScore);
-			const composite = campaignMeanCompositeOrNull(campaign);
-			const rankKey = coverage.complete ? selectionRankKey(campaign) : null;
-			if (rankKey) assertFiniteRankKey(rankKey, `selectionRankKey for generation ${gen} candidate ${i}`, winnerRankKey.length);
-			return {
-				surfaceHash: hash,
-				surface,
-				label,
-				rationale,
-				...attribution ? { attribution } : {},
-				campaign,
-				composite,
-				rankKey,
-				coverage
-			};
-		}, opts.signal);
-		for (const result of surfaceResults) {
-			const { surface, surfaceHash: hash, campaign, coverage, label, rationale } = result;
-			if (coverage.complete) {
-				const parent = toParetoParent(surface, hash, campaign, gen, label || void 0, rationale || void 0);
-				scored.push(parent);
-				measuredByHash.set(hash, {
-					parent,
-					outcome: toScoredSurfaceOutcome(hash, campaign, coverage, gen)
-				});
-			}
-		}
-		if (search) for (const result of surfaceResults) {
-			const nodeId = nodeIdByHash.get(result.surfaceHash);
-			await search.recordCells(nodeId, "train", result.campaign.cells);
-			if (!result.coverage.complete) incompleteNodeIds.add(nodeId);
-		}
-		surfaceResults.sort((a, b) => {
-			if (a.coverage.complete !== b.coverage.complete) return a.coverage.complete ? -1 : 1;
-			if (a.rankKey && b.rankKey) return compareRankKeys(b.rankKey, a.rankKey);
-			return a.surfaceHash.localeCompare(b.surfaceHash);
-		});
-		const top = surfaceResults.filter((result) => result.coverage.complete && result.composite !== null && result.rankKey !== null)[0];
-		const promoted = top && compareRankKeys(top.rankKey, winnerRankKey) > 0 ? [top] : [];
-		if (promoted[0]) {
-			const top = promoted[0];
-			const promotedNodeId = nodeIdByHash.get(top.surfaceHash);
-			if (promotedNodeId) promotedNodeIds.add(promotedNodeId);
-			winnerSurface = top.surface;
-			winnerSurfaceHash = top.surfaceHash;
-			winnerComposite = top.composite;
-			winnerRankKey = top.rankKey;
-			winnerOutcome = toScoredSurfaceOutcome(top.surfaceHash, top.campaign, top.coverage, gen);
-			winnerLabel = top.label || void 0;
-			winnerRationale = top.rationale || void 0;
-		}
-		const record = {
-			generationIndex: gen,
-			candidates: surfaceResults.map((s) => {
-				const breakdown = campaignBreakdown(s.campaign);
-				const candidate = {
-					surfaceHash: s.surfaceHash,
-					composite: s.composite,
-					ci95: null,
-					parentSurfaceHash,
-					parentComposite,
-					...s.coverage.complete ? { observedDeltaFromParent: s.composite - parentComposite } : {},
-					eligibleForPromotion: s.coverage.complete,
-					coverage: {
-						expectedCells: s.coverage.expectedCellIds.length,
-						scorableCells: s.coverage.scorableCellIds.length,
-						unscorableCells: s.coverage.unscorableCells
-					},
-					dimensions: breakdown.dimensions,
-					scenarios: breakdown.scenarios
-				};
-				if (s.label) candidate.label = s.label;
-				if (s.rationale) candidate.rationale = s.rationale;
-				if (s.attribution) candidate.attribution = s.attribution;
-				return candidate;
-			}),
-			promoted: promoted.map((p) => p.surfaceHash)
-		};
-		history.push(record);
-		generations.push({
-			record,
-			surfaces: surfaceResults.map((s) => ({
-				surfaceHash: s.surfaceHash,
-				surface: s.surface,
-				campaign: s.campaign
-			}))
-		});
-		if (opts.analyzeGeneration && gen < opts.maxGenerations - 1) {
-			const fresh = await opts.analyzeGeneration({
-				generation: gen,
-				runDir: `${opts.runDir}/gen-${gen}`,
-				candidates: surfaceResults.map((s) => ({
-					surfaceHash: s.surfaceHash,
-					campaign: s.campaign,
-					composite: s.composite
-				})),
-				history,
-				costLedger,
-				costPhase: "analysis.generation"
-			});
-			if (!Array.isArray(fresh)) throw new TypeError("runOptimization: analyzeGeneration must return an array");
-			currentFindings = immutableProposalSnapshot(assertProposalFindings(fresh, "runOptimization generation analysis findings"), "generation analysis findings");
-		}
-	}
-	const searchHistory = await search?.finish({
-		winnerNodeId: nodeIdByHash.get(winnerSurfaceHash),
-		promotedNodeIds,
-		incompleteNodeIds,
-		reason: stopReason,
-		runId: opts.runDir
-	});
-	return {
-		generations,
-		baselineSurface,
-		winnerSurface,
-		winnerSurfaceHash,
-		winnerLabel,
-		winnerRationale,
-		baselineCampaign,
-		...searchHistory ? { searchHistory } : {},
-		paretoFrontier: computeParetoFrontier(scored),
-		cost: costLedger.summary()
-	};
-}
-/** Resolve the parent a `selectParent` policy returned to the measured record
-*  this run holds for it. Refuses a surface the run never measured to
-*  completion, and a parent whose surface does not hash to its `surfaceHash`. */
-function resolveSelectedParent(returned, measuredByHash, generation) {
-	if (typeof returned !== "object" || returned === null || typeof returned.surfaceHash !== "string") throw new TypeError(`runOptimization: selectParent must return a ParetoParent (generation ${generation})`);
-	const parent = returned;
-	const measured = measuredByHash.get(parent.surfaceHash);
-	if (!measured) throw new Error(`runOptimization: selectParent returned surface "${parent.surfaceHash}" in generation ${generation}, which this run has not measured to completion; a parent must be a scored surface from the frontier`);
-	if (!surfaceHashMatches(parent.surface, parent.surfaceHash)) throw new Error(`runOptimization: selectParent returned a parent whose surface does not match its surfaceHash "${parent.surfaceHash}" (generation ${generation})`);
-	return measured;
-}
 function immutableProposalSnapshot(value, label) {
 	try {
 		return deepFreeze(structuredClone(value));
@@ -5199,58 +5008,42 @@ function validatedPremeasuredBaseline(args) {
 		reps: args.reps
 	});
 	if (campaign.manifestHash !== expectedManifest) throw new Error("runOptimization: premeasured baseline evaluator identity does not match the requested dispatch and judges");
+	const coverage = campaignCoverage(campaign.cells, args.scenarios, args.reps, args.requireJudgeScore);
+	if (!coverage.complete) throw new Error(`runOptimization: premeasured baseline is incomplete (${coverage.scorableCellIds.length}/${coverage.expectedCellIds.length} designed cells scorable) — ${formatCoverageFailures(coverage)}. Refusing to optimize against an incomplete incumbent.`);
 	return campaign;
 }
-/** Build a `ParetoParent` from a scored campaign — objective vector =
-*  per-scenario composite, scalar = mean composite. */
-function toParetoParent(surface, hash, campaign, generation, label, rationale) {
+/** A scored campaign as a frontier member: per-scenario composite objectives. */
+function toParetoParent(surface, campaign, generation, label) {
 	const objectives = {};
 	for (const { scenarioId, composite } of campaignBreakdown(campaign).scenarios) objectives[scenarioId] = composite;
 	const parent = {
 		surface,
-		surfaceHash: hash,
+		surfaceHash: surfaceHash(surface),
 		objectives,
 		composite: campaignMeanComposite(campaign),
 		generation
 	};
 	if (label) parent.label = label;
-	if (rationale) parent.rationale = rationale;
 	return parent;
 }
-/** The non-dominated set over the per-scenario objective vectors. Every
-*  scenario seen across the scored set becomes a `maximize` objective.
-*  `runOptimization` admits only complete campaigns to this set; the finite
-*  floor remains a defensive fallback for manually constructed/no-judge
-*  vectors. Delegates dominance to the package-canonical `paretoFrontier`. */
+/** The non-dominated set over the per-scenario objective vectors. */
 function computeParetoFrontier(scored) {
 	if (scored.length <= 1) return [...scored];
 	const ids = /* @__PURE__ */ new Set();
 	for (const p of scored) for (const id of Object.keys(p.objectives)) ids.add(id);
 	if (ids.size === 0) return [...scored];
-	const floor = {};
-	for (const id of ids) {
-		let min = Number.POSITIVE_INFINITY;
-		for (const p of scored) {
-			const v = p.objectives[id];
-			if (typeof v === "number" && Number.isFinite(v) && v < min) min = v;
-		}
-		floor[id] = Number.isFinite(min) ? min : 0;
-	}
 	return paretoFrontier(scored, [...ids].map((id) => ({
 		name: id,
 		direction: "maximize",
-		value: (p) => {
-			const v = p.objectives[id];
-			return typeof v === "number" && Number.isFinite(v) ? v : floor[id] ?? 0;
-		}
+		value: (p) => p.objectives[id] ?? Number.NEGATIVE_INFINITY
 	}))).frontier;
 }
-function toScoredSurfaceOutcome(surfaceHash, campaign, coverage, generation) {
+function toScoredSurfaceOutcome(hash, campaign, coverage, generation) {
 	const breakdown = campaignBreakdown(campaign);
 	return {
 		split: "search",
 		generation,
-		surfaceHash,
+		surfaceHash: hash,
 		composite: campaignMeanComposite(campaign),
 		dimensions: breakdown.dimensions,
 		scenarios: breakdown.scenarios,
@@ -6670,6 +6463,6 @@ function firstString(value) {
 	return typeof value === "string" && value.trim() ? value : void 0;
 }
 //#endregion
-export { scoreRedTeamOutput as $, FileSearchLedger as A, SEARCH_LEDGER_SCHEMA as B, assertCompleteSearchHistory as C, searchHistoryCoverageRow as D, createSearchHistoryReceipt as E, SearchStateView as F, paretoFrontierWithCrowding as G, labelTrustRank as H, searchCellId as I, captureJudge as J, runFinalComparison as K, searchNodeId as L, replaySearchLedgerText as M, validateSearchLedgerEvent as N, verifySearchHistoryArtifact as O, SearchState as P, redTeamReport as Q, searchTaskSetDigest as R, SearchHistoryRequiredError as S, assertSearchHistoryMatchesState as T, dominates as U, isProposedCandidate as V, paretoFrontier as W, DEFAULT_RED_TEAM_CORPUS as X, defaultProductionGate as Y, redTeamDataset as Z, SearchRecorder as _, transientDispatchFailure as a, runEval as at, surfaceDiff as b, compareOptimizationMethods as c, resolveRunDir as ct, combineComparisonCosts as d, buildCellSchedule as dt, runCanaries as et, costFromLedgerSummary as f, cellCachePath as ft, runOptimization as g, runImprovementLoop as h, quotaExhaustedUntil as i, reserveFinalEvidence as it, openSearchLedger as j, verifySearchHistoryReceipt as k, optimizationTokenUsageFromSummary as l, tangleTracesRoot as lt, readGepaCandidatePopulationArtifact as m, JudgeParseError as n, captureFinalEvidencePolicy as nt, aggregateRunScore as o, runCampaign as ot, assertGepaCandidatePopulationSummary as p, computeManifestHash as pt, openAutoPr as q, isTransientTransportFailure as r, evaluationUnitMap as rt, clamp01 as s, planCampaignRun as st, llmJudge as t, assertIndependentEvaluationSplit as tt, executeOptimizationMethod as u, readCachedCell as ut, developmentClaim as v, assertSearchHistoryAdmissionOptions as w, surfaceNode as x, searchEdgeId as y, searchUnitScores as z };
+export { scoreRedTeamOutput as $, createSearchHistoryReceipt as A, estimateNodeFromCells as B, searchEdgeId as C, assertCompleteSearchHistory as D, SearchHistoryRequiredError as E, runSearch as F, paretoFrontier as G, searchPosterior as H, searchExpansionIndex as I, captureJudge as J, runFinalComparison as K, searchPolicyView as L, verifySearchHistoryArtifact as M, verifySearchHistoryReceipt as N, assertSearchHistoryAdmissionOptions as O, SEARCH_KERNEL_SOURCE as P, redTeamReport as Q, SEARCH_ESTIMATOR as R, developmentClaim as S, surfaceNode as T, uniform as U, searchCellSetDigest as V, dominates as W, DEFAULT_RED_TEAM_CORPUS as X, defaultProductionGate as Y, redTeamDataset as Z, isProposedCandidate as _, transientDispatchFailure as a, runEval as at, incumbent as b, compareOptimizationMethods as c, resolveRunDir as ct, combineComparisonCosts as d, buildCellSchedule as dt, runCanaries as et, costFromLedgerSummary as f, cellCachePath as ft, runOptimization as g, runImprovementLoop as h, quotaExhaustedUntil as i, reserveFinalEvidence as it, searchHistoryCoverageRow as j, assertSearchHistoryMatchesState as k, optimizationTokenUsageFromSummary as l, tangleTracesRoot as lt, readGepaCandidatePopulationArtifact as m, JudgeParseError as n, captureFinalEvidencePolicy as nt, aggregateRunScore as o, runCampaign as ot, assertGepaCandidatePopulationSummary as p, computeManifestHash as pt, openAutoPr as q, isTransientTransportFailure as r, evaluationUnitMap as rt, clamp01 as s, planCampaignRun as st, llmJudge as t, assertIndependentEvaluationSplit as tt, executeOptimizationMethod as u, readCachedCell as ut, labelTrustRank as v, surfaceDiff as w, SearchRecorder as x, crowdedFrontierParent as y, estimateNode as z };
 
-//# sourceMappingURL=llm-judge-BnxAv7ed.js.map
+//# sourceMappingURL=llm-judge-Z6MkTkd0.js.map