@tangle-network/agent-eval 0.193.2 → 0.195.0

package/dist/{llm-judge-Cififl_V.js → llm-judge-CvKpaRKY.js}

@@ -3,6 +3,7 @@ import { a as hashCanonical, i as compareCodeUnits, r as canonicalString, t as L
 import { t as mulberry32 } from "./random-Dn5fPWkt.js";
 import { o as summarizeNumberSeries, s as weightedComposite, t as confidenceInterval } from "./descriptive-1V17A-qa.js";
 import { v as wilson } from "./paired-arms-JSDcs2zx.js";
+import { t as minimumPairsForPairedDeltaTest } from "./paired-delta-test-BF-FEP8V.js";
 import { t as decidePairedPromotion } from "./paired-promotion-decision-DTKl6-G8.js";
 import { a as heldoutSignificance, i as dimensionRegressions, o as pairHoldout } from "./statistical-heldout-DANVmyug.js";
 import { i as modelHasSnapshot, l as searchCellRunId } from "./run-record-BRlM99rX.js";
@@ -17,8 +18,8 @@ import { r as summarizeEvaluationUnits, t as defineEvaluationClaim } from "./cla
 import { f as redactText, n as REDACTION_VERSION, o as detectCredential, s as detectPersonalData } from "./redact-Dk1ZdJEm.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, i as replaySearchLedgerText, l as searchCellId, n as openSearchLedger, t as FileSearchLedger, u as searchNodeId } from "./search-ledger-CJiAEU3j.js";
-import { c as seedFromDigest, i as estimateNode, n as searchProposerView, s as searchPosterior, t as renderSearchSummary } from "./search-summary-BhY8p0Av.js";
+import { a as validateSearchLedgerEvent, d as searchTaskSetDigest, i as replaySearchLedgerText, l as searchCellId, n as openSearchLedger, t as FileSearchLedger, u as searchNodeId } from "./search-ledger-BbKtG_WF.js";
+import { c as seedFromDigest, i as estimateNode, n as searchProposerView, s as searchPosterior, t as renderSearchSummary } from "./search-summary-DnDGR702.js";
 import { d as stripFencedJson, o as costReceiptFromLlm, s as costReceiptFromLlmError, u as maximumChargeForLlmRequest } from "./llm-client-c_bKHTXz.js";
 import { createHash } from "node:crypto";
 import { writeFileSync } from "node:fs";
@@ -2537,14 +2538,25 @@ function paretoFrontierWithCrowding(candidates, objectives) {
 //#endregion
 //#region src/campaign/allocation.ts
 /**
+* Allocation: where a search spends rollouts.
+*
+* An allocator says which cells a node needs given the evidence so far; the
+* kernel allocates the ones the ledger does not hold yet, so a resumed search
+* plans exactly what the interrupted one planned. It also decides which nodes
+* earn more measurement (`advanced`) and, at close, which were left waiting
+* (`pruned`). Those are rank decisions: they spend budget and claim nothing.
+* Expansion (which parent, which operator) belongs to the `SearchPolicy`; the
+* claim belongs to the claim step.
+*/
+/**
 * 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.
+* generation loop ran and GEPA runs. It has one rung, so it never advances or
+* prunes a node.
 */
 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 reps = positiveInteger("uniform", "reps", options.reps ?? 1);
 	const cells = (state, root) => {
 		const header = state.header;
 		if (!header) return [];
@@ -2561,9 +2573,281 @@ function uniform(options = {}) {
 		name: reps === 1 ? "uniform" : `uniform(reps=${reps})`,
 		reps,
 		plan: (state, nodeId) => cells(state, nodeId === state.rootNodeId),
-		screenSize: (state) => cells(state, false).length
+		screenSize: (state) => cells(state, false).length,
+		advance: () => [],
+		prune: () => []
+	};
+}
+/**
+* Asynchronous successive halving (Li et al., 2020) over one seeded
+* permutation of the ranked split's units, fixed by the search's seed.
+*
+* Rung k is the first `units × 2^k` units of the permutation; the top rung is
+* every unit. The root runs every unit before anything else, so every rung
+* pairs against it. A new node screens on rung 0 plus `trainUnits` train
+* units. Every node at a rung runs the same units as its parent, the root and
+* its siblings, so every contrast pairs.
+*
+* A node that finished rung k advances once it ranks in the top
+* floor(n / eta) of the n nodes that finished rung k, the root included, by
+* mean over the rung's units; a node with an unscored unit ranks last and
+* never advances. There is no barrier: a node outside the top waits, because
+* the set grows as more nodes finish. At close a waiting node is pruned with
+* its rank. The ranked split is selection, or train when a search declares no
+* selection split, as the policy's.
+*/
+function asha(options = {}) {
+	const firstRung = minimumPairsForPairedDeltaTest();
+	const units = positiveInteger("asha", "units", options.units ?? firstRung);
+	const eta = positiveInteger("asha", "eta", options.eta ?? 3);
+	if (eta < 2) throw new TypeError(`asha: eta must be at least 2, got ${eta}`);
+	const trainUnits = nonNegativeInteger("asha", "trainUnits", options.trainUnits ?? 2);
+	const reps = positiveInteger("asha", "reps", options.reps ?? 1);
+	const name = units === firstRung && eta === 3 && trainUnits === 2 && reps === 1 ? "asha" : `asha(units=${units},eta=${eta},train=${trainUnits},reps=${reps})`;
+	const layouts = /* @__PURE__ */ new WeakMap();
+	const layoutOf = (state) => {
+		const header = state.header;
+		if (!header) return null;
+		let layout = layouts.get(header);
+		if (!layout) {
+			layout = ashaLayout(header, {
+				units,
+				trainUnits
+			});
+			layouts.set(header, layout);
+		}
+		return layout;
+	};
+	const cellsThrough = (layout, rung, root) => {
+		const plan = [];
+		const through = root ? layout.top : Math.min(rung, layout.top);
+		layout.order.slice(0, layout.sizes[through]).forEach((unitId, position) => {
+			const stage = root ? "root" : layout.split === "train" ? "train" : position < layout.sizes[0] ? "screen" : "rung";
+			for (const task of layout.tasks.get(unitId)) for (let rep = 0; rep < reps; rep++) plan.push({
+				taskId: task.taskId,
+				split: layout.split,
+				rep,
+				stage
+			});
+		});
+		for (const task of layout.feedback) for (let rep = 0; rep < reps; rep++) plan.push({
+			taskId: task.taskId,
+			split: "train",
+			rep,
+			stage: root ? "root" : "train"
+		});
+		return plan;
+	};
+	/**
+	* Per node: the deepest rung it finished and its unit means on the ranked
+	* split. A later decision (finalist, selected, pruned) does not unfinish a
+	* rung, so every node but an invalid one keeps its place in the ranks; only
+	* an undecided or advanced node is `open` to a new decision.
+	*/
+	const standings = (view, layout) => {
+		const { state } = view;
+		const rootId = state.rootNodeId;
+		const standing = [];
+		for (const node of state.nodes()) {
+			if (node.status === "invalid") continue;
+			const root = node.nodeId === rootId;
+			let advancedTo = 0;
+			for (const { decision } of node.decisions) if (decision.status === "advanced") advancedTo = Math.max(advancedTo, decision.rung);
+			const rung = root ? layout.top : Math.min(advancedTo, layout.top);
+			const allocated = /* @__PURE__ */ new Set();
+			let cancelled = false;
+			for (const cell of state.cells({ nodeId: node.nodeId })) {
+				if (cell.split !== layout.split) continue;
+				const position = layout.position.get(cell.unitId);
+				if (position !== void 0 && position < layout.sizes[rung]) {
+					allocated.add(`${cell.taskId}\u0000${cell.rep}`);
+					if (cell.cancelled !== null) cancelled = true;
+				}
+			}
+			const covered = !cancelled && allocated.size === layout.cellsThrough[rung] * reps;
+			const finished = view.idle(node.nodeId) && covered ? rung : root ? -1 : rung - 1;
+			if (finished < 0) continue;
+			const means = /* @__PURE__ */ new Map();
+			for (const unit of state.unitScores(node.nodeId, layout.split)) means.set(unit.unitId, unit.mean);
+			const open = node.status === null || node.status === "advanced";
+			standing.push({
+				nodeId: node.nodeId,
+				ordinal: node.ordinal,
+				root,
+				open,
+				rung,
+				finished,
+				means
+			});
+		}
+		return standing;
+	};
+	/** The nodes that finished rung k, best first; an unscored unit ranks last. */
+	const ranking = (state, layout, standing, k) => {
+		const rungUnits = [...layout.order.slice(0, layout.sizes[k])].sort(compareCodeUnits);
+		const sign = state.header.objective.direction === "maximize" ? 1 : -1;
+		const ranked = [];
+		for (const entry of standing) {
+			if (entry.finished < k) continue;
+			let sum = 0;
+			let complete = true;
+			for (const unitId of rungUnits) {
+				const mean = entry.means.get(unitId);
+				if (mean === void 0) {
+					complete = false;
+					break;
+				}
+				sum += mean;
+			}
+			ranked.push({
+				...entry,
+				mean: complete ? sum / rungUnits.length : null,
+				sign
+			});
+		}
+		return ranked.sort(compareRanked);
+	};
+	const reason = (ranked, index, k, layout) => {
+		const entry = ranked[index];
+		const top = Math.floor(ranked.length / eta);
+		const mean = entry.mean === null ? "an unscored unit" : `mean ${round$1(entry.mean)}`;
+		return `rank ${index + 1} of ${ranked.length} on rung ${k} (${layout.sizes[k]} units, ${mean}); the top ${top} advance (eta ${eta})`;
+	};
+	return {
+		name,
+		reps,
+		plan(state, nodeId, rung) {
+			const layout = layoutOf(state);
+			return layout ? cellsThrough(layout, rung, nodeId === state.rootNodeId) : [];
+		},
+		screenSize(state) {
+			const layout = layoutOf(state);
+			return layout ? cellsThrough(layout, 0, false).length : 0;
+		},
+		advance(view) {
+			const { state } = view;
+			const layout = layoutOf(state);
+			const rootId = state.rootNodeId;
+			if (!layout || layout.top === 0 || rootId === null) return [];
+			const standing = standings(view, layout);
+			const decisions = [];
+			for (let k = layout.top - 1; k >= 0; k--) {
+				const ranked = ranking(state, layout, standing, k);
+				const top = Math.floor(ranked.length / eta);
+				for (let index = 0; index < top; index++) {
+					const entry = ranked[index];
+					if (!entry.open || entry.root || entry.mean === null) continue;
+					if (entry.finished !== k || entry.rung !== k) continue;
+					decisions.push({
+						nodeId: entry.nodeId,
+						decision: {
+							status: "advanced",
+							rung: k + 1
+						},
+						basis: estimateNode(state, entry.nodeId, {
+							against: rootId,
+							split: layout.split
+						}),
+						rule: name,
+						reason: reason(ranked, index, k, layout)
+					});
+				}
+			}
+			return decisions;
+		},
+		prune(view, keep) {
+			const { state } = view;
+			const layout = layoutOf(state);
+			const rootId = state.rootNodeId;
+			if (!layout || layout.top === 0 || rootId === null) return [];
+			const standing = standings(view, layout);
+			const decisions = [];
+			for (let k = layout.top - 1; k >= 0; k--) {
+				const ranked = ranking(state, layout, standing, k);
+				const top = Math.floor(ranked.length / eta);
+				ranked.forEach((entry, index) => {
+					if (!entry.open || entry.root || entry.nodeId === keep) return;
+					if (entry.finished !== k || entry.rung !== k || entry.means.size === 0) return;
+					const why = index < top && entry.mean !== null ? `it earned rung ${k + 1}, but the cap, the cell limit or the deadline did not admit its cells` : "it waited outside the top when the search closed";
+					decisions.push({
+						nodeId: entry.nodeId,
+						decision: { status: "pruned" },
+						basis: estimateNode(state, entry.nodeId, {
+							against: rootId,
+							split: layout.split
+						}),
+						rule: name,
+						reason: `${reason(ranked, index, k, layout)}; ${why}`
+					});
+				});
+			}
+			return decisions;
+		}
+	};
+}
+function compareRanked(left, right) {
+	if (left.mean === null || right.mean === null) {
+		if (left.mean !== right.mean) return left.mean === null ? 1 : -1;
+	} else if (left.mean !== right.mean) return left.sign * (right.mean - left.mean);
+	return left.ordinal - right.ordinal;
+}
+function ashaLayout(header, options) {
+	const split = header.splits.selection.tasks.length > 0 ? "selection" : "train";
+	const tasks = unitsOf(header.splits[split].tasks);
+	const order = permute([...tasks.keys()], header.policy.seed, split);
+	const sizes = [];
+	for (let size = options.units;; size *= 2) {
+		sizes.push(Math.min(size, order.length));
+		if (size >= order.length) break;
+	}
+	const cellsThrough = sizes.map((size) => order.slice(0, size).reduce((sum, unitId) => sum + tasks.get(unitId).length, 0));
+	let feedback = [];
+	if (split === "selection") {
+		const train = unitsOf(header.splits.train.tasks);
+		feedback = permute([...train.keys()], header.policy.seed, "train").slice(0, options.trainUnits).flatMap((unitId) => train.get(unitId));
+	}
+	return {
+		split,
+		order,
+		position: new Map(order.map((unitId, index) => [unitId, index])),
+		tasks,
+		sizes,
+		cellsThrough,
+		top: sizes.length - 1,
+		feedback
 	};
 }
+/** Tasks grouped by unit, units and tasks in code-unit order. */
+function unitsOf(tasks) {
+	const byUnit = /* @__PURE__ */ new Map();
+	for (const task of [...tasks].sort((left, right) => compareCodeUnits(left.taskId, right.taskId))) {
+		const unit = byUnit.get(task.unitId);
+		if (unit) unit.push(task);
+		else byUnit.set(task.unitId, [task]);
+	}
+	return new Map([...byUnit.entries()].sort(([left], [right]) => compareCodeUnits(left, right)));
+}
+/** Fisher-Yates over units in code-unit order, from the search seed and the split. */
+function permute(unitIds, seed, split) {
+	const rng = mulberry32(seed ^ (split === "train" ? 2050776593 : 731729763) | 0);
+	const order = [...unitIds];
+	for (let index = order.length - 1; index > 0; index--) {
+		const other = Math.floor(rng() * (index + 1));
+		[order[index], order[other]] = [order[other], order[index]];
+	}
+	return order;
+}
+function positiveInteger(owner, name, value) {
+	if (!Number.isSafeInteger(value) || value < 1) throw new TypeError(`${owner}: ${name} must be a positive integer, got ${String(value)}`);
+	return value;
+}
+function nonNegativeInteger(owner, name, value) {
+	if (!Number.isSafeInteger(value) || value < 0) throw new TypeError(`${owner}: ${name} must be a non-negative integer, got ${String(value)}`);
+	return value;
+}
+function round$1(value) {
+	return Math.round(value * 1e4) / 1e4;
+}
 //#endregion
 //#region src/paired-promotion-power.ts
 /**
@@ -3064,6 +3348,76 @@ function decideSearchClaim(state, plan) {
 		decisions
 	};
 }
+/**
+* Make a closed search's claim again from its ledger alone and compare it with
+* the recorded one, byte for byte: the power check, the finalists, each
+* finalist's test estimate and deciding interval, the selection, the decision
+* and the reason. A producer's claim is not evidence until this holds; a store
+* keeps what this function derives, not what the producer wrote.
+*
+* It needs no blob, so it works on a store that keeps digests only. The
+* finalists are the nodes the ledger decided `finalist`, in decision order.
+* The one input the ledger cannot replay is whether the budget covered k
+* finalists' test cells; the claim cells that ran answer it (none ran: the
+* budget covered none). Test repeats come from the claim cells too; without
+* test cells, the recorded estimator stands for them (binary needs one repeat,
+* so any other count reproduces continuous).
+*
+* Returns null for a search that made no claim.
+*/
+function verifySearchClaim(state) {
+	const closed = state.closed;
+	if (!closed) throw new Error(`search ${state.searchId} is open; its claim is made when it closes`);
+	const recorded = closed.claim;
+	if (recorded === null) return null;
+	if (recorded.rule.revision !== SEARCH_CLAIM_RULE.revision) return {
+		status: "unknown",
+		reason: `the claim names rule revision ${recorded.rule.revision}; this code implements ${SEARCH_CLAIM_RULE.revision}`
+	};
+	const claimCells = state.cells().filter((cell) => cell.stage === "claim");
+	const decided = state.nodes().flatMap((node) => {
+		const first = node.decisions.find((record) => record.decision.status === "finalist");
+		return first ? [{
+			nodeId: node.nodeId,
+			sequence: first.sequence
+		}] : [];
+	}).sort((a, b) => a.sequence - b.sequence).map((entry) => entry.nodeId);
+	const reps = claimCells.length > 0 ? 1 + Math.max(...claimCells.map((cell) => cell.rep)) : "adequate" in recorded.power && recorded.power.estimator.kind === "binary" ? 1 : 2;
+	const plan = planSearchClaim(state, {
+		stopReason: closed.reason,
+		reps,
+		affordable: (finalists) => claimCells.length > 0 && finalists <= decided.length
+	});
+	const differences = [];
+	const planned = plan.finalists.map((finalist) => finalist.nodeId);
+	if (canonicalString(planned) !== canonicalString(decided)) differences.push(`finalists: the rule picks [${planned.join(", ")}], the ledger decided [${decided.join(", ")}]`);
+	if (plan.test === "run" !== claimCells.length > 0) differences.push(`test: the plan ${plan.test === "run" ? "runs" : "skips"} the test cells, and ${claimCells.length} ran`);
+	const expected = decideSearchClaim(state, plan).claim;
+	for (const key of [
+		"decision",
+		"selected",
+		"confidence",
+		"power",
+		"reason"
+	]) if (canonicalString(expected[key]) !== canonicalString(recorded[key])) differences.push(`${key}: the ledger supports ${canonicalString(expected[key])}, the claim records ${canonicalString(recorded[key])}`);
+	const count = Math.max(expected.finalists.length, recorded.finalists.length);
+	for (let index = 0; index < count; index++) {
+		const want = expected.finalists[index];
+		const have = recorded.finalists[index];
+		if (canonicalString(want ?? null) === canonicalString(have ?? null)) continue;
+		const fields = [
+			"nodeId",
+			"promote",
+			"test",
+			"estimate"
+		].filter((field) => canonicalString(want?.[field] ?? null) !== canonicalString(have?.[field] ?? null));
+		differences.push(`finalist ${index + 1} (${have?.nodeId ?? want?.nodeId}): ${fields.join(", ")} differ from what the ledger supports`);
+	}
+	return differences.length === 0 ? { status: "verified" } : {
+		status: "mismatch",
+		differences
+	};
+}
 /** Per-finalist confidence for `k` finalists. */
 function bonferroni(k) {
 	return 1 - (1 - FAMILY_CONFIDENCE) / k;
@@ -3321,17 +3675,19 @@ const SEARCH_KERNEL_SOURCE = {
 	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",
+		expansion: "when no cell waits, fewer than twice the lanes capacity run, the cap admits one proposal and its expected screens, and overspend has not taken the search past its cap",
 		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",
+		rungs: "when a node finishes its cells, the allocator names the nodes it advances, deepest rung first; each is recorded advanced and its rung allocated when the cap admits the rung",
 		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",
 		divergence: "a node whose train mean over shared units rises above its parent while its descriptive or bootstrap selection interval against the parent lies wholly on the worse side is decided invalid when its cells finish",
 		claim: "with a test split: after expansion stops, the claim plan is stored on the claim operation, the finalists are decided, the root and finalist test cells run together, and the claim decides; the kernel refuses to start a claim without a selection split, a minimumEffect, a pinned judge, or (under a cap) a claim reserve for the root and 3 finalists plus a cap for one screening round",
-		close: "without a test split, the policy leader is selected when it has a scored cell; every other undecided node is rejected"
+		close: "the allocator prunes the nodes left waiting on a rung, except the policy leader; then, with a test split, the claim decides; without one, the policy leader is selected when it has a scored cell; every other undecided node is rejected",
+		complete: "a node leads only when it has a scored cell on the ranked split and no cell there ended unscored: a final unscored outcome, or an error with no attempt left"
 	})
 };
 const USD_TOLERANCE = 1e-9;
@@ -3527,6 +3883,7 @@ var SearchKernel = class {
 		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) await this.screenDone(nodeId);
+		await this.advance();
 	}
 	/**
 	* A search that will claim must be able to: finalists come from a selection
@@ -3555,7 +3912,7 @@ var SearchKernel = class {
 			cellUsd
 		});
 		if (reservedClaimUsd + USD_TOLERANCE < need) refuse(`its claim reserve $${reservedClaimUsd} is below the $${need} the root and 3 finalists need on ${testTasks} test tasks at $${cellUsd} a cell`);
-		const rootCells = this.options.allocation.plan(this.state, this.state.rootNodeId).length;
+		const rootCells = this.options.allocation.plan(this.state, this.state.rootNodeId, 0).length;
 		const screens = (this.options.proposer.childrenPerProposal ?? 1) * this.options.allocation.screenSize(this.state);
 		const round = this.operationReservation().usd + (rootCells + screens) * cellUsd;
 		if (maxUsd - reservedClaimUsd + USD_TOLERANCE < round) refuse(`its cap $${maxUsd} less the claim reserve $${reservedClaimUsd} does not cover the root and one screening round ($${round})`);
@@ -3694,11 +4051,20 @@ var SearchKernel = class {
 		if (cell.stage === "claim") return;
 		const left = (this.pending.get(cell.nodeId) ?? 1) - 1;
 		this.pending.set(cell.nodeId, left);
-		if (left === 0) await this.onScreenDone(cell.nodeId);
+		if (left === 0) await this.onNodeIdle(cell.nodeId);
 	}
-	async onScreenDone(nodeId) {
+	/** Every cell allocated to the node is done: its screen, or a rung. */
+	async onNodeIdle(nodeId) {
 		if (!await this.screenDone(nodeId)) return;
-		if (this.stopReason === null && !this.failure) await this.allocateFor(nodeId);
+		await this.advance();
+	}
+	/** Record the rank decisions the allocator now supports and allocate the
+	* rungs they open. Past the deadline, once the claim began, or once the
+	* search fails or is aborted, no rung opens; a search that stopped
+	* expanding still measures the nodes that earned it. */
+	async advance() {
+		if (this.claimPlan || this.failure || this.options.signal?.aborted || this.pastDeadline()) return;
+		for (const decision of this.options.allocation.advance(this.allocationView())) await this.allocateFor(decision.nodeId, decision);
 	}
 	/**
 	* A node's allocated cells all finished. A node that diverges (its train
@@ -3707,7 +4073,7 @@ var SearchKernel = class {
 	* becomes a parent; any other node is screened. Returns whether it was.
 	*/
 	async screenDone(nodeId) {
-		if (!this.claimPlan && !this.screenedSet.has(nodeId)) {
+		if (!this.claimPlan && !this.screenedSet.has(nodeId) && this.state.node(nodeId).status !== "advanced") {
 			const divergence = searchDivergence(this.state, nodeId);
 			if (divergence) {
 				await this.recorder.decideNode({
@@ -3737,10 +4103,19 @@ var SearchKernel = class {
 			...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;
+	/**
+	* Allocate the cells the allocator plans for a node through its rung and the
+	* ledger lacks. With a rank decision, the rung is the decision's, and the
+	* decision is recorded first, only once the cap admits the rung's cells.
+	* Returns false when the cap or `maxCells` refused them.
+	*/
+	async allocateFor(nodeId, decision) {
+		const rung = decision?.decision.status === "advanced" ? decision.decision.rung : this.state.node(nodeId).rung ?? 0;
+		const plans = this.options.allocation.plan(this.state, nodeId, rung).filter((plan) => !this.state.cell(searchCellId(this.recorder.searchId, nodeId, plan.taskId, plan.split, plan.rep)));
+		if (plans.length === 0) {
+			if (decision) await this.decide(decision);
+			return true;
+		}
 		const placed = plans.map((plan) => {
 			const laneName = this.options.executor.place({
 				...plan,
@@ -3756,9 +4131,10 @@ var SearchKernel = class {
 		});
 		const hold = placed.reduce((sum, { reservation }) => sum + reservation.usd, 0);
 		const { headroomUsd } = this.state.budget;
-		if (headroomUsd !== null && hold > headroomUsd + USD_TOLERANCE) return;
+		if (headroomUsd !== null && hold > headroomUsd + USD_TOLERANCE) return false;
 		const { maxCells } = this.state.header.budget;
-		if (maxCells !== null && this.state.audit.cells.allocated + placed.length > maxCells) return;
+		if (maxCells !== null && this.state.audit.cells.allocated + placed.length > maxCells) return false;
+		if (decision) await this.decide(decision);
 		for (const { plan, lane, reservation } of placed) await this.recorder.allocateCell({
 			nodeId,
 			taskId: plan.taskId,
@@ -3775,6 +4151,11 @@ var SearchKernel = class {
 		}
 		this.pending.set(nodeId, (this.pending.get(nodeId) ?? 0) + placed.length);
 		this.dispatch();
+		return true;
+	}
+	async decide(decision) {
+		await this.recorder.decideNode(decision);
+		await this.refresh();
 	}
 	enqueue(cell) {
 		this.lanes.get(cell.lane).queues[STAGE_PRIORITY[cell.stage]].push(cell.cellId);
@@ -3942,7 +4323,7 @@ var SearchKernel = class {
 		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 (headroomUsd !== null && (need > headroomUsd + USD_TOLERANCE || this.overCap())) 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";
@@ -4093,6 +4474,8 @@ var SearchKernel = class {
 	}
 	async close() {
 		await this.refresh();
+		const keep = this.options.policy.leader(this.policyView());
+		for (const decision of this.options.allocation.prune(this.allocationView(), keep)) await this.decide(decision);
 		if (this.claimPlan) {
 			await this.closeWithClaim(this.claimPlan);
 			return;
@@ -4102,6 +4485,7 @@ var SearchKernel = class {
 		const { split } = view;
 		const root = this.state.rootNodeId;
 		const rule = this.options.policy.name;
+		const leaderUnits = view.unitScores(leader).map((unit) => unit.unitId);
 		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;
@@ -4110,12 +4494,13 @@ var SearchKernel = class {
 				against,
 				split
 			});
+			const units = new Set(view.unitScores(node.nodeId).map((unit) => unit.unitId));
 			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"
+				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 unscored, so it could not lead" : leaderUnits.some((unitId) => !units.has(unitId)) ? "the search stopped before it was measured on every unit the leader was" : "it did not beat the leader on the units they share"
 			};
 		});
 		for (const decision of decisions) await this.recorder.decideNode(decision);
@@ -4151,22 +4536,35 @@ var SearchKernel = class {
 		});
 		await this.refresh();
 	}
+	/** The closed search, with its claim made again from the ledger alone. A
+	* claim the ledger does not support throws: a tampered ledger, or a
+	* producer and verifier that disagree. */
 	closedResult() {
 		const state = this.state;
+		const claimVerification = verifySearchClaim(state);
+		if (claimVerification?.status === "mismatch") throw new Error(`runSearch: search ${state.searchId} closed with a claim its ledger does not support: ${claimVerification.differences.join("; ")}`);
 		return {
 			state,
 			leader: state.audit.selectedNodeId ?? state.rootNodeId,
 			reason: state.closed.reason,
-			claim: state.closed.claim
+			claim: state.closed.claim,
+			claimVerification
 		};
 	}
 	policyView() {
 		return searchPolicyView(this.state, {
 			screened: this.screened,
 			screening: this.admitted.size - this.screenedSet.size,
-			expansions: this.completed.length
+			expansions: this.completed.length,
+			maxAttempts: this.maxAttempts
 		});
 	}
+	allocationView() {
+		return {
+			state: this.state,
+			idle: (nodeId) => this.admitted.has(nodeId) && (this.pending.get(nodeId) ?? 0) === 0
+		};
+	}
 	artifact(nodeId) {
 		const held = this.artifacts.get(nodeId);
 		if (held !== void 0) return held;
@@ -4203,6 +4601,14 @@ var SearchKernel = class {
 			usd: estimate(this.operationCosts, this.options.proposer.reservationUsd ?? 0)
 		};
 	}
+	/** Overspend took committed spend, open holds and the unspent claim reserve
+	* past the cap. Nothing new is proposed then, even at a zero-dollar prior. */
+	overCap() {
+		const { maxUsd } = this.state.header.budget;
+		if (maxUsd === null) return false;
+		const { committedUsd, openReservationUsd } = this.state.audit.spend;
+		return committedUsd + openReservationUsd + this.state.budget.claimReserveUsd > maxUsd + USD_TOLERANCE;
+	}
 	pastDeadline() {
 		const deadline = this.state.header.budget.deadline;
 		return deadline !== null && this.now() >= Date.parse(deadline);
@@ -4216,8 +4622,11 @@ var SearchKernel = class {
 * 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.
+* `maxAttempts` (default 3, the kernel's) says when an errored cell has no
+* attempt left, which makes its unit a dodge.
 */
 function searchPolicyView(state, input) {
+	const maxAttempts = input.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
 	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";
@@ -4231,8 +4640,13 @@ function searchPolicyView(state, input) {
 		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);
+			let scored = false;
+			for (const cell of state.cells({ nodeId })) {
+				if (cell.split !== split) continue;
+				if (cell.score !== null) scored = true;
+				else if (cell.final || cell.outcome === "errored" && cell.attempts >= maxAttempts) return false;
+			}
+			return scored;
 		},
 		unitScores: (nodeId) => state.unitScores(nodeId, split),
 		estimate: (nodeId, against) => estimateNode(state, nodeId, {
@@ -4880,12 +5294,14 @@ function canonicalHeader(header) {
 * 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.
+* The hill climb. The leader starts at the root; a screened node that dodged no
+* unit takes the lead when it scored every unit the leader scored and its mean
+* on them beats the leader's. A node measured on fewer units than the leader,
+* such as one an allocator has only screened, cannot take the lead on less
+* evidence than the leader holds. 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;
@@ -4970,20 +5386,20 @@ function hillClimb(spec) {
 		}
 	};
 }
-/** True when `challenger` improves on `holder` over the units both scored. */
+/** True when `challenger` scored every unit `holder` scored and improves on
+* `holder` over them. */
 function beats(view, challenger, holder) {
-	const held = new Map(view.unitScores(holder).map((unit) => [unit.unitId, unit.mean]));
+	const held = view.unitScores(holder);
+	if (held.length === 0) return false;
+	const own = new Map(view.unitScores(challenger).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;
+	for (const unit of held) {
+		const mean = own.get(unit.unitId);
+		if (mean === void 0) return false;
+		challengerSum += mean;
+		holderSum += unit.mean;
 	}
-	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. */
@@ -7250,6 +7666,6 @@ function firstString(value) {
 	return typeof value === "string" && value.trim() ? value : void 0;
 }
 //#endregion
-export { redTeamDataset as $, createSearchHistoryReceipt as A, decideSearchClaim as B, searchEdgeId as C, assertCompleteSearchHistory as D, SearchHistoryRequiredError as E, runSearch as F, uniform as G, searchClaimReserveUsd as H, searchDivergence as I, runFinalComparison as J, dominates as K, searchExpansionIndex as L, verifySearchHistoryArtifact as M, verifySearchHistoryReceipt as N, assertSearchHistoryAdmissionOptions as O, SEARCH_KERNEL_SOURCE as P, DEFAULT_RED_TEAM_CORPUS as Q, searchPolicyView as R, developmentClaim as S, surfaceNode as T, pairedPromotionPower as U, planSearchClaim as V, requiredPairsForPairedPromotion as W, captureJudge as X, openAutoPr as Y, defaultProductionGate as Z, isProposedCandidate as _, transientDispatchFailure as a, evaluationUnitMap as at, incumbent as b, compareOptimizationMethods as c, runCampaign as ct, combineComparisonCosts as d, tangleTracesRoot as dt, redTeamReport as et, costFromLedgerSummary as f, readCachedCell as ft, runOptimization as g, runImprovementLoop as h, computeManifestHash as ht, quotaExhaustedUntil as i, captureFinalEvidencePolicy as it, searchHistoryCoverageRow as j, assertSearchHistoryMatchesState as k, optimizationTokenUsageFromSummary as l, planCampaignRun as lt, readGepaCandidatePopulationArtifact as m, cellCachePath as mt, JudgeParseError as n, runCanaries as nt, aggregateRunScore as o, reserveFinalEvidence as ot, assertGepaCandidatePopulationSummary as p, buildCellSchedule as pt, paretoFrontier as q, isTransientTransportFailure as r, assertIndependentEvaluationSplit as rt, clamp01 as s, runEval as st, llmJudge as t, scoreRedTeamOutput as tt, executeOptimizationMethod as u, resolveRunDir as ut, labelTrustRank as v, surfaceDiff as w, SearchRecorder as x, crowdedFrontierParent as y, SEARCH_CLAIM_RULE as z };
+export { defaultProductionGate as $, createSearchHistoryReceipt as A, decideSearchClaim as B, searchEdgeId as C, assertCompleteSearchHistory as D, SearchHistoryRequiredError as E, runSearch as F, requiredPairsForPairedPromotion as G, searchClaimReserveUsd as H, searchDivergence as I, dominates as J, asha as K, searchExpansionIndex as L, verifySearchHistoryArtifact as M, verifySearchHistoryReceipt as N, assertSearchHistoryAdmissionOptions as O, SEARCH_KERNEL_SOURCE as P, captureJudge as Q, searchPolicyView as R, developmentClaim as S, surfaceNode as T, verifySearchClaim as U, planSearchClaim as V, pairedPromotionPower as W, runFinalComparison as X, paretoFrontier as Y, openAutoPr as Z, isProposedCandidate as _, computeManifestHash as _t, transientDispatchFailure as a, assertIndependentEvaluationSplit as at, incumbent as b, compareOptimizationMethods as c, reserveFinalEvidence as ct, combineComparisonCosts as d, planCampaignRun as dt, DEFAULT_RED_TEAM_CORPUS as et, costFromLedgerSummary as f, resolveRunDir as ft, runOptimization as g, cellCachePath as gt, runImprovementLoop as h, buildCellSchedule as ht, quotaExhaustedUntil as i, runCanaries as it, searchHistoryCoverageRow as j, assertSearchHistoryMatchesState as k, optimizationTokenUsageFromSummary as l, runEval as lt, readGepaCandidatePopulationArtifact as m, readCachedCell as mt, JudgeParseError as n, redTeamReport as nt, aggregateRunScore as o, captureFinalEvidencePolicy as ot, assertGepaCandidatePopulationSummary as p, tangleTracesRoot as pt, uniform as q, isTransientTransportFailure as r, scoreRedTeamOutput as rt, clamp01 as s, evaluationUnitMap as st, llmJudge as t, redTeamDataset as tt, executeOptimizationMethod as u, runCampaign as ut, labelTrustRank as v, surfaceDiff as w, SearchRecorder as x, crowdedFrontierParent as y, SEARCH_CLAIM_RULE as z };
 
-//# sourceMappingURL=llm-judge-Cififl_V.js.map
+//# sourceMappingURL=llm-judge-CvKpaRKY.js.map