@tangle-network/agent-eval 0.194.0 → 0.195.1

package/dist/{llm-judge-D6NIvyrM.js → llm-judge-CxfoYqdk.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-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 { a as validateSearchLedgerEvent, d as searchTaskSetDigest, i as replaySearchLedgerText, l as searchCellId, n as openSearchLedger, t as FileSearchLedger, u as searchNodeId } from "./search-ledger-9W0g5FP6.js";
+import { c as seedFromDigest, i as estimateNode, n as searchProposerView, s as searchPosterior, t as renderSearchSummary } from "./search-summary-CcavvYLe.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
 /**
@@ -3397,11 +3681,13 @@ const SEARCH_KERNEL_SOURCE = {
 			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;
@@ -3597,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
@@ -3625,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})`);
@@ -3764,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
@@ -3777,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({
@@ -3807,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,
@@ -3826,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,
@@ -3845,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);
@@ -4163,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;
@@ -4172,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;
@@ -4180,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);
@@ -4240,9 +4555,16 @@ var SearchKernel = class {
 		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;
@@ -4300,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";
@@ -4315,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, {
@@ -4964,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;
@@ -5054,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. */
@@ -5446,7 +5778,7 @@ var SurfaceNodes = class {
 		const ids = [];
 		for (const child of blob.children) {
 			const nodeId = state.nodeIdForDigest(child.node.artifactDigest);
-			if (nodeId === void 0 || ids.includes(nodeId)) continue;
+			if (nodeId === void 0 || nodeId === state.rootNodeId || ids.includes(nodeId)) continue;
 			if (this.origin(state, nodeId).expansion === expansion) ids.push(nodeId);
 		}
 		return ids;
@@ -7334,6 +7666,6 @@ function firstString(value) {
 	return typeof value === "string" && value.trim() ? value : void 0;
 }
 //#endregion
-export { DEFAULT_RED_TEAM_CORPUS 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, paretoFrontier as J, uniform as K, searchExpansionIndex as L, verifySearchHistoryArtifact as M, verifySearchHistoryReceipt as N, assertSearchHistoryAdmissionOptions as O, SEARCH_KERNEL_SOURCE as P, defaultProductionGate as Q, searchPolicyView as R, developmentClaim as S, surfaceNode as T, verifySearchClaim as U, planSearchClaim as V, pairedPromotionPower as W, openAutoPr as X, runFinalComparison as Y, captureJudge as Z, isProposedCandidate as _, transientDispatchFailure as a, captureFinalEvidencePolicy as at, incumbent as b, compareOptimizationMethods as c, runEval as ct, combineComparisonCosts as d, resolveRunDir as dt, redTeamDataset as et, costFromLedgerSummary as f, tangleTracesRoot as ft, runOptimization as g, computeManifestHash as gt, runImprovementLoop as h, cellCachePath as ht, quotaExhaustedUntil as i, assertIndependentEvaluationSplit as it, searchHistoryCoverageRow as j, assertSearchHistoryMatchesState as k, optimizationTokenUsageFromSummary as l, runCampaign as lt, readGepaCandidatePopulationArtifact as m, buildCellSchedule as mt, JudgeParseError as n, scoreRedTeamOutput as nt, aggregateRunScore as o, evaluationUnitMap as ot, assertGepaCandidatePopulationSummary as p, readCachedCell as pt, dominates as q, isTransientTransportFailure as r, runCanaries as rt, clamp01 as s, reserveFinalEvidence as st, llmJudge as t, redTeamReport as tt, executeOptimizationMethod as u, planCampaignRun 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-D6NIvyrM.js.map
+//# sourceMappingURL=llm-judge-CxfoYqdk.js.map