@tangle-network/agent-eval 0.197.0 → 0.198.1

package/dist/{llm-judge-fhkFQL1N.js → llm-judge-3ncNcWNT.js}

@@ -2,24 +2,23 @@ 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 { 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 { r as minimumPairsForPairedDeltaTest, t as decidePairedPromotion } from "./paired-promotion-decision-D5B1Cxc2.js";
+import { a as heldoutSignificance, i as dimensionRegressions, o as pairHoldout } from "./statistical-heldout-BAFDCo07.js";
 import { i as modelHasSnapshot, l as searchCellRunId } from "./run-record-BRlM99rX.js";
 import { n as contentHash } from "./verdict-cache-BQEsVy9n.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 { 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-DJc60F9C.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-jL_U7Ikv.js";
 import { m as mapConcurrent } from "./journal-DvKCvjty.js";
 import { t as deepFreezeCanonicalJson } from "./deep-freeze-CurcOQg3.js";
-import { C as fsCampaignStorage, S as createRunCostLedger, g as isRecord, h as isExternalTextCandidate, x as acquireSingleRunLock } from "./external-optimizer-subprocess-BrghTvEp.js";
+import { S as fsCampaignStorage, g as isRecord, h as isExternalTextCandidate, x as createRunCostLedger } from "./external-optimizer-subprocess-laM1-UDV.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-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-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 paretoFrontier, O as paretoFrontierWithCrowding, a as searchPolicyView, b as estimateNode, i as searchExpansionIndex, n as runSearch, p as EXPANSION_OPERATORS, t as SEARCH_KERNEL_SOURCE } from "./search-kernel-CumYAjA3.js";
+import { a as validateSearchLedgerEvent, d as searchTaskSetDigest, i as replaySearchLedgerText, l as searchCellId, n as openSearchLedger, u as searchNodeId } from "./search-ledger-BnUytR8X.js";
+import { n as searchProposerView, t as renderSearchSummary } from "./search-summary-dJOaZ3Dw.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";
@@ -1165,8 +1164,8 @@ function detectCalibrationDrift(runs, opts) {
 				alpha,
 				recentN: recent.length,
 				historyN: historical.length,
-				recentMean: mean$3(recent),
-				historyMean: mean$3(historical)
+				recentMean: mean$2(recent),
+				historyMean: mean$2(historical)
 			}
 		}],
 		evaluation: {
@@ -1403,7 +1402,7 @@ function chiSquareCritical(df, alpha) {
 	}
 	return TABLE[10][idx];
 }
-function mean$3(xs) {
+function mean$2(xs) {
 	if (xs.length === 0) return 0;
 	return xs.reduce((s, x) => s + x, 0) / xs.length;
 }
@@ -2457,85 +2456,6 @@ async function runFinalComparison(opts) {
 	};
 }
 //#endregion
-//#region src/pareto.ts
-/** Does candidate A weakly dominate B — strictly better on at least one objective and no worse on any? */
-function dominates(a, b, objectives) {
-	let strictlyBetter = false;
-	for (const obj of objectives) {
-		const av = obj.value(a);
-		const bv = obj.value(b);
-		if (!Number.isFinite(av) || !Number.isFinite(bv)) return false;
-		const aIsBetter = obj.direction === "maximize" ? av > bv : av < bv;
-		if (obj.direction === "maximize" ? av < bv : av > bv) return false;
-		if (aIsBetter) strictlyBetter = true;
-	}
-	return strictlyBetter;
-}
-/**
-* Compute the non-dominated frontier. Candidates with NaN/Infinity on any
-* objective are excluded (can't rank them). A candidate enters the frontier
-* iff no other candidate dominates it.
-*/
-function paretoFrontier(candidates, objectives) {
-	if (objectives.length === 0) throw new Error("paretoFrontier: at least 1 objective required");
-	const valid = candidates.filter((c) => objectives.every((o) => Number.isFinite(o.value(c))));
-	const frontier = [];
-	const dominated = [];
-	for (const c of valid) if (valid.some((other) => other !== c && dominates(other, c, objectives))) dominated.push(c);
-	else frontier.push(c);
-	return {
-		frontier,
-		dominated,
-		dominanceMap: frontier.map((d) => ({
-			dominator: d,
-			dominated: dominated.filter((x) => dominates(d, x, objectives))
-		}))
-	};
-}
-/**
-* NSGA-II crowding distance — secondary sort for ties on the frontier.
-*
-* When the Pareto front collapses to a single point (or many candidates tie
-* on dominance), naive selection picks arbitrarily and the population
-* degenerates over generations. NSGA-II preserves diversity by preferring
-* candidates with more empty space around them on the frontier.
-*
-* Returns an array of `{ candidate, distance }` in the SAME order as the
-* input. Higher distance = more isolated = should be preferred when
-* preserving diversity.
-*/
-function crowdingDistance(candidates, objectives) {
-	const distances = new Map(candidates.map((c) => [c, 0]));
-	for (const obj of objectives) {
-		const sorted = [...candidates].sort((a, b) => obj.value(a) - obj.value(b));
-		const min = obj.value(sorted[0]);
-		const range = obj.value(sorted[sorted.length - 1]) - min || 1;
-		distances.set(sorted[0], Infinity);
-		distances.set(sorted[sorted.length - 1], Infinity);
-		for (let i = 1; i < sorted.length - 1; i++) {
-			const prev = obj.value(sorted[i - 1]);
-			const next = obj.value(sorted[i + 1]);
-			const current = distances.get(sorted[i]);
-			if (current === Infinity) continue;
-			distances.set(sorted[i], current + (next - prev) / range);
-		}
-	}
-	return candidates.map((c) => ({
-		candidate: c,
-		distance: distances.get(c) ?? 0
-	}));
-}
-/**
-* Pareto frontier with tie-break by crowding distance — the canonical
-* NSGA-II selection step. Returns the frontier sorted by descending crowding
-* distance so callers can `.slice(0, k)` to pick K diverse winners.
-*/
-function paretoFrontierWithCrowding(candidates, objectives) {
-	const { frontier } = paretoFrontier(candidates, objectives);
-	if (frontier.length === 0) return [];
-	return crowdingDistance(frontier, objectives).sort((a, b) => b.distance - a.distance);
-}
-//#endregion
 //#region src/campaign/allocation.ts
 /**
 * Allocation: where a search spends rollouts.
@@ -2603,9 +2523,11 @@ function asha(options = {}) {
 	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 extend = options.extend ?? null;
+	const name = units === firstRung && eta === 3 && trainUnits === 2 && reps === 1 && extend === null ? "asha" : `asha(units=${units},eta=${eta},train=${trainUnits},reps=${reps}${extend ? `,extend=${extend.name}` : ""})`;
 	const layouts = /* @__PURE__ */ new WeakMap();
-	const layoutOf = (state) => {
+	const extensions = /* @__PURE__ */ new WeakMap();
+	const seededLayout = (state) => {
 		const header = state.header;
 		if (!header) return null;
 		let layout = layouts.get(header);
@@ -2618,6 +2540,74 @@ function asha(options = {}) {
 		}
 		return layout;
 	};
+	/**
+	* With `extend`, each opened rung's added units come from the chooser at
+	* the sequence of the first decision that opened it; units of rungs not yet
+	* opened follow in the seeded order, which only the root, measured on every
+	* unit, ever reads.
+	*/
+	const layoutOf = (state) => {
+		const seeded = seededLayout(state);
+		if (!seeded || extend === null || seeded.top === 0) return seeded;
+		const opened = /* @__PURE__ */ new Map();
+		for (const node of state.nodes()) for (const record of node.decisions) {
+			if (record.decision.status !== "advanced") continue;
+			const known = opened.get(record.decision.rung);
+			if (known === void 0 || record.sequence < known) opened.set(record.decision.rung, record.sequence);
+		}
+		if (opened.size === 0) return seeded;
+		const header = state.header;
+		let cache = extensions.get(header);
+		if (!cache) {
+			cache = /* @__PURE__ */ new Map();
+			extensions.set(header, cache);
+		}
+		const order = seeded.order.slice(0, seeded.sizes[0]);
+		const chosen = new Set(order);
+		for (let rung = 1; rung <= seeded.top; rung++) {
+			const sequence = opened.get(rung);
+			if (sequence === void 0) break;
+			let entry = cache.get(rung);
+			if (!entry || entry.sequence !== sequence) {
+				const remaining = seeded.order.filter((unitId) => !chosen.has(unitId));
+				const count = seeded.sizes[rung] - seeded.sizes[rung - 1];
+				const allowed = new Set(remaining);
+				const picked = [];
+				for (const unitId of extend.choose({
+					state,
+					asOfSequence: sequence,
+					split: seeded.split,
+					rung,
+					measured: [...order],
+					remaining,
+					count
+				})) {
+					if (picked.length === count) break;
+					if (allowed.delete(unitId)) picked.push(unitId);
+				}
+				for (const unitId of remaining) {
+					if (picked.length === count) break;
+					if (allowed.delete(unitId)) picked.push(unitId);
+				}
+				entry = {
+					sequence,
+					units: picked
+				};
+				cache.set(rung, entry);
+			}
+			for (const unitId of entry.units) {
+				order.push(unitId);
+				chosen.add(unitId);
+			}
+		}
+		for (const unitId of seeded.order) if (!chosen.has(unitId)) order.push(unitId);
+		return {
+			...seeded,
+			order,
+			position: new Map(order.map((unitId, index) => [unitId, index])),
+			cellsThrough: seeded.sizes.map((size) => order.slice(0, size).reduce((sum, unitId) => sum + seeded.tasks.get(unitId).length, 0))
+		};
+	};
 	const cellsThrough = (layout, rung, root) => {
 		const plan = [];
 		const through = root ? layout.top : Math.min(rung, layout.top);
@@ -2710,7 +2700,7 @@ function asha(options = {}) {
 	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)}`;
+		const mean = entry.mean === null ? "an unscored unit" : `mean ${round(entry.mean)}`;
 		return `rank ${index + 1} of ${ranked.length} on rung ${k} (${layout.sizes[k]} units, ${mean}); the top ${top} advance (eta ${eta})`;
 	};
 	return {
@@ -2845,7 +2835,7 @@ 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) {
+function round(value) {
 	return Math.round(value * 1e4) / 1e4;
 }
 //#endregion
@@ -2979,1877 +2969,6 @@ function searchProposalExecution(receipts, provider, source) {
 	};
 }
 //#endregion
-//#region src/paired-promotion-power.ts
-/**
-* @module
-* Joint power of a configured {@link decidePairedPromotion} call, computed by
-* running that call on data drawn from a registered alternative.
-*
-* Why a simulation and not a formula: `decidePairedPromotion` is not one test.
-* It routes by sample size (exact sign test below `BOOTSTRAP_GATE_MIN_N`,
-* paired bootstrap at or above it) and by shape (Tango's score interval on a
-* two-point outcome), and on top of the deciding interval it applies a
-* sufficiency floor, a zero-width refusal and McNemar's exact veto. A
-* preregistration usually seals two such calls, a continuous primary and a
-* pass/fail veto drawn from the same episodes, and promotes only when both
-* promote. The sample size at which THAT procedure reaches a target power is
-* not the power of any one channel: the sign-test power at n can be 0.8 while
-* the promotion probability is well below it because the veto binds
-* (agent-eval#785). Closed forms exist for single channels only, and each one
-* shipped here under-sized the call it stood in for (`mcnemarRequiredN` is
-* Lachin's normal approximation, 0.65 exact power where it promised 0.8 at 14
-* pairs; `requiredPairedSampleSize` sizes a paired t the procedure never runs).
-* So the only faithful power is the procedure's own promotion rate under the
-* alternative, and that is what this module computes: draw n pairs from the
-* registered law, run every configured call on them exactly as the caller
-* will, repeat, count.
-*
-* The alternative is DECLARATIVE and serializable, never a sampler function,
-* so a preregistration can seal it as bytes: a mixture of cells, each with a
-* probability, an optional pass/fail outcome per arm for the binary calls,
-* and a law for the candidate-minus-baseline delta on the continuous scale.
-* Drawing the cell first and the delta given the cell is what makes the two
-* channels one joint law rather than two marginals.
-*
-* Everything is seeded (`mulberry32`), so a sizing is reproducible from its
-* inputs, and every estimate carries its Monte Carlo standard error and a
-* Wilson interval: a power read at 0.80 from 1,000 simulations is 0.80 ± 0.013.
-*/
-/**
-* Joint power of the configured calls at `n` under the registered alternative:
-* the fraction of simulated data sets on which every call promotes.
-*/
-function pairedPromotionPower(options) {
-	const n = options.n;
-	if (!Number.isInteger(n) || n < 1) throw new Error(`pairedPromotionPower: n must be a positive integer, got ${n}`);
-	const simulations = options.simulations ?? 1e3;
-	if (!Number.isInteger(simulations) || simulations < 1) throw new Error(`pairedPromotionPower: simulations must be a positive integer, got ${simulations}`);
-	const seed = options.seed ?? 1;
-	if (!Number.isFinite(seed)) throw new Error(`pairedPromotionPower: seed must be finite, got ${seed}`);
-	const calls = validateCalls(options.calls);
-	const alternative = validateAlternative(options.alternative, calls);
-	const rng = mulberry32(seed);
-	let promotions = 0;
-	let refusals = 0;
-	const perCall = calls.map(() => ({
-		promote: 0,
-		insufficient: 0,
-		indeterminate: 0,
-		exactTestVetoes: 0,
-		hold: 0,
-		methods: /* @__PURE__ */ new Map()
-	}));
-	for (let s = 0; s < simulations; s++) {
-		const pairs = drawPairs(alternative, n, rng);
-		let all = true;
-		let anyRefusal = false;
-		for (let c = 0; c < calls.length; c++) {
-			const call = calls[c];
-			const decision = runCall(call, pairs, n);
-			const tally = perCall[c];
-			tally.methods.set(decision.method, (tally.methods.get(decision.method) ?? 0) + 1);
-			if (decision.promote) tally.promote++;
-			else {
-				if (!decision.sufficient) tally.insufficient++;
-				if (decision.indeterminate) tally.indeterminate++;
-				if (decision.exactTestVetoes) tally.exactTestVetoes++;
-				if (decision.sufficient && !decision.indeterminate && !decision.exactTestVetoes) tally.hold++;
-			}
-			if (!decision.promote) all = false;
-			if (!decision.sufficient || decision.indeterminate || decision.exactTestVetoes) anyRefusal = true;
-		}
-		if (all) promotions++;
-		else if (anyRefusal) refusals++;
-	}
-	const power = promotions / simulations;
-	const interval = wilson(promotions, simulations, .95);
-	return {
-		n,
-		simulations,
-		seed,
-		power,
-		standardError: Math.sqrt(power * (1 - power) / simulations),
-		low: interval.lower,
-		high: interval.upper,
-		refuse: refusals / simulations,
-		hold: (simulations - promotions - refusals) / simulations,
-		calls: perCall.map((tally, c) => ({
-			outcome: calls[c].outcome,
-			promote: tally.promote / simulations,
-			insufficient: tally.insufficient / simulations,
-			indeterminate: tally.indeterminate / simulations,
-			exactTestVetoes: tally.exactTestVetoes / simulations,
-			hold: tally.hold / simulations,
-			methods: Object.fromEntries([...tally.methods.entries()].map(([method, count]) => [method, count / simulations]))
-		}))
-	};
-}
-/**
-* First n at which {@link pairedPromotionPower} reaches the target, scanning
-* every n from `minPairs` upward. Both the point-estimate answer and the
-* confirmed lower-bound answer are returned; the scan runs until the latter is
-* reached (so the curve past `n` is retained) or `maxPairs` is exhausted. A
-* candidate selected by the scan's bound is certified only by an independent
-* simulation at that n on a different seed; a candidate that fails it is
-* recorded and the scan continues.
-*/
-function requiredPairsForPairedPromotion(options) {
-	const target = options.target ?? .8;
-	if (!Number.isFinite(target) || target <= 0 || target >= 1) throw new Error(`requiredPairsForPairedPromotion: target must be in (0,1), got ${target}`);
-	const minPairs = options.minPairs ?? 1;
-	const maxPairs = options.maxPairs ?? 200;
-	if (!Number.isInteger(minPairs) || minPairs < 1) throw new Error(`requiredPairsForPairedPromotion: minPairs must be a positive integer, got ${minPairs}`);
-	if (!Number.isInteger(maxPairs) || maxPairs < minPairs) throw new Error(`requiredPairsForPairedPromotion: maxPairs must be an integer >= minPairs, got ${maxPairs}`);
-	const seed = options.seed ?? 1;
-	const curve = [];
-	const rejected = [];
-	let n = null;
-	let nAtLowerBound = null;
-	let confirmation = null;
-	for (let candidate = minPairs; candidate <= maxPairs; candidate++) {
-		const result = pairedPromotionPower({
-			n: candidate,
-			alternative: options.alternative,
-			calls: options.calls,
-			simulations: options.simulations,
-			seed
-		});
-		curve.push(result);
-		if (n === null && result.power >= target) n = candidate;
-		if (result.low >= target) {
-			const check = pairedPromotionPower({
-				n: candidate,
-				alternative: options.alternative,
-				calls: options.calls,
-				simulations: options.simulations,
-				seed: confirmationSeed(seed, candidate)
-			});
-			if (check.low >= target) {
-				nAtLowerBound = candidate;
-				confirmation = check;
-				break;
-			}
-			rejected.push(check);
-		}
-	}
-	return {
-		target,
-		n,
-		nAtLowerBound,
-		confirmation,
-		curve,
-		rejected
-	};
-}
-/** A seed for the confirmation at `n` that never equals the scan seed. */
-function confirmationSeed(seed, n) {
-	return (Math.imul((seed | 0) ^ 2654435769, 2246822507) + Math.imul(n, 3266489909) | 1) >>> 0;
-}
-function drawPairs(alternative, n, rng) {
-	const baseline = alternative.baseline ?? {
-		kind: "point",
-		value: 0
-	};
-	const control = new Array(n);
-	const candidate = new Array(n);
-	const controlPass = new Array(n);
-	const candidatePass = new Array(n);
-	for (let i = 0; i < n; i++) {
-		const cell = drawCell(alternative.cells, rng);
-		const base = drawValue(baseline, rng);
-		control[i] = base;
-		candidate[i] = base + drawValue(cell.delta, rng);
-		controlPass[i] = cell.pass?.control ?? false;
-		candidatePass[i] = cell.pass?.treatment ?? false;
-	}
-	return {
-		control,
-		candidate,
-		controlPass,
-		candidatePass
-	};
-}
-function drawCell(cells, rng) {
-	const u = rng();
-	let cumulative = 0;
-	for (const cell of cells) {
-		cumulative += cell.probability;
-		if (u < cumulative) return cell;
-	}
-	return cells[cells.length - 1];
-}
-function drawValue(law, rng) {
-	switch (law.kind) {
-		case "point": return law.value;
-		case "atoms": {
-			const u = rng();
-			let cumulative = 0;
-			for (const atom of law.atoms) {
-				cumulative += atom.probability;
-				if (u < cumulative) return atom.value;
-			}
-			return law.atoms[law.atoms.length - 1].value;
-		}
-		case "normal": {
-			const u1 = 1 - rng();
-			const u2 = rng();
-			return law.mean + law.sd * Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
-		}
-	}
-}
-function runCall(call, pairs, n) {
-	const options = {
-		minPairs: n,
-		...call.options
-	};
-	if (call.outcome === "pass") {
-		const scale = call.options.binaryScale;
-		return decidePairedPromotion(pairs.controlPass.map((p) => p ? scale : 0), pairs.candidatePass.map((p) => p ? scale : 0), options);
-	}
-	return decidePairedPromotion(pairs.control, pairs.candidate, options);
-}
-function validateCalls(calls) {
-	if (!Array.isArray(calls) || calls.length === 0) throw new Error("pairedPromotionPower: at least one call is required");
-	calls.forEach((call, i) => {
-		if (call.outcome !== "delta" && call.outcome !== "pass") throw new Error(`pairedPromotionPower: calls[${i}].outcome must be 'delta' or 'pass'`);
-		if (call.options === null || typeof call.options !== "object") throw new Error(`pairedPromotionPower: calls[${i}].options must be an object`);
-		if (call.options.minPairs !== void 0 && (!Number.isInteger(call.options.minPairs) || call.options.minPairs < 1)) throw new Error(`pairedPromotionPower: calls[${i}].options.minPairs must be a positive integer`);
-		if (call.outcome === "pass") {
-			const scale = call.options.binaryScale;
-			if (scale === void 0 || !Number.isFinite(scale) || scale <= 0) throw new Error(`pairedPromotionPower: calls[${i}] is a 'pass' call and must declare a finite positive options.binaryScale`);
-			if (call.options.continuous) throw new Error(`pairedPromotionPower: calls[${i}] is a 'pass' call; continuous cannot accompany it`);
-			if (call.options.statistic === "median") throw new Error(`pairedPromotionPower: calls[${i}] is a 'pass' call; binaryScale requires the mean statistic, not median`);
-		} else if (call.options.binaryScale !== void 0) throw new Error(`pairedPromotionPower: calls[${i}] is a 'delta' call and cannot declare binaryScale; use a 'pass' call for a two-point outcome`);
-	});
-	return calls;
-}
-function validateAlternative(alternative, calls) {
-	if (!alternative || !Array.isArray(alternative.cells) || alternative.cells.length === 0) throw new Error("pairedPromotionPower: alternative.cells must be a non-empty array");
-	const needsPass = calls.some((call) => call.outcome === "pass");
-	let total = 0;
-	alternative.cells.forEach((cell, i) => {
-		if (!Number.isFinite(cell.probability) || cell.probability < 0) throw new Error(`pairedPromotionPower: cells[${i}].probability must be a finite number >= 0`);
-		total += cell.probability;
-		if (needsPass) {
-			if (!cell.pass || typeof cell.pass.control !== "boolean" || typeof cell.pass.treatment !== "boolean") throw new Error(`pairedPromotionPower: cells[${i}].pass must give control and treatment booleans when a 'pass' call is configured`);
-		}
-		validateLaw(cell.delta, `cells[${i}].delta`);
-	});
-	if (Math.abs(total - 1) > 1e-9) throw new Error(`pairedPromotionPower: cell probabilities must sum to 1, got ${total}`);
-	if (alternative.baseline !== void 0) validateLaw(alternative.baseline, "baseline");
-	return alternative;
-}
-function validateLaw(law, where) {
-	if (!law || typeof law !== "object") throw new Error(`pairedPromotionPower: ${where} must be a law object`);
-	switch (law.kind) {
-		case "point":
-			if (!Number.isFinite(law.value)) throw new Error(`pairedPromotionPower: ${where}.value must be finite`);
-			return;
-		case "atoms": {
-			if (!Array.isArray(law.atoms) || law.atoms.length === 0) throw new Error(`pairedPromotionPower: ${where}.atoms must be a non-empty array`);
-			let total = 0;
-			law.atoms.forEach((atom, i) => {
-				if (!Number.isFinite(atom.value)) throw new Error(`pairedPromotionPower: ${where}.atoms[${i}].value must be finite`);
-				if (!Number.isFinite(atom.probability) || atom.probability < 0) throw new Error(`pairedPromotionPower: ${where}.atoms[${i}].probability must be a finite number >= 0`);
-				total += atom.probability;
-			});
-			if (Math.abs(total - 1) > 1e-9) throw new Error(`pairedPromotionPower: ${where}.atoms probabilities must sum to 1, got ${total}`);
-			return;
-		}
-		case "normal":
-			if (!Number.isFinite(law.mean) || !Number.isFinite(law.sd) || law.sd < 0) throw new Error(`pairedPromotionPower: ${where} needs a finite mean and a finite sd >= 0`);
-			return;
-		default: throw new Error(`pairedPromotionPower: ${where}.kind must be 'point', 'atoms' or 'normal'`);
-	}
-}
-//#endregion
-//#region src/campaign/search-claim.ts
-/**
-* The claim: the one statement a search makes about its nodes, made once, on
-* its sealed test split, after the search stops expanding.
-*
-* `planSearchClaim` fixes the claim's design from the ledger before any test
-* cell runs: up to 3 finalists ranked by selection mean, the estimator the
-* paired decision will use, the number of finalists the family-wise confidence
-* is divided among, and a power check on selection data. The kernel stores the
-* plan on the ledger's `claim` operation, so the ledger proves the design was
-* fixed before the test data existed. `decideSearchClaim` then reads the test
-* cells of the root and the finalists, which ran together, and decides each
-* finalist against the root with `decidePairedPromotion` at the Bonferroni
-* confidence `1 - 0.05 / k`.
-*
-* Every number is a pure function of the ledger: the power simulation is
-* seeded from the search's seed and the decisions from the digest of the test
-* cells they read, so a verifier with the same ledger gets the same claim.
-*/
-const FAMILY_CONFIDENCE = .95;
-const TARGET_POWER = .8;
-const POWER_SIMULATIONS = 500;
-const RESAMPLES = 2e3;
-/**
-* Every rule and parameter the claim depends on. Its digest is the claim's
-* revision; change a value here whenever the procedure changes, so the
-* revision moves with it.
-*/
-const CLAIM_DEFINITION = {
-	name: "tangle.search-claim.2026-09",
-	finalists: `up to 3 non-root nodes not decided invalid that scored every selection unit and beat the root's mean on the selection units they share, ranked by selection mean in the objective's direction, then registration order`,
-	familyConfidence: FAMILY_CONFIDENCE,
-	correction: "Bonferroni: each of k finalists against the root at 1 - (1 - familyConfidence) / k",
-	finalistCount: "the largest k whose test cells the unspent claim reserve and headroom cover and whose power reaches the target",
-	estimator: "binary with scale s when every train, selection and test unit has one task at one repeat and every pre-test score is 0 or s; otherwise continuous",
-	power: {
-		method: "pairedPromotionPower of the claim decision, simulated at the claim minimumEffect",
-		continuous: "per-unit improvement normal with the pooled selection variance",
-		binary: "discordant units at the pooled selection variance over 2 s^2 per side, shifted by minimumEffect / s; concordant units pass at the root selection pass rate",
-		targetPower: TARGET_POWER,
-		simulations: POWER_SIMULATIONS,
-		seed: "the first 32 bits of hashCanonical([search seed, k])"
-	},
-	decision: {
-		call: "decidePairedPromotion(root, finalist) on per-unit test means in the objective direction",
-		threshold: 0,
-		minPairs: "every test unit",
-		resamples: RESAMPLES,
-		seed: "the first 32 bits of the finalist's test cellSetDigest"
-	},
-	select: "the promoted finalist with the largest improvement; ties to the better selection rank",
-	ship: "a promoted finalist that scored every test unit, with the root, on held-out units, under a pinned judge"
-};
-/** The claim procedure every `SearchClaim` and claim plan names. */
-const SEARCH_CLAIM_RULE = {
-	uri: "npm:@tangle-network/agent-eval#searchClaim",
-	revision: hashCanonical(CLAIM_DEFINITION)
-};
-/** The rule name decisions made by the claim record. */
-const SEARCH_CLAIM_RULE_NAME = CLAIM_DEFINITION.name;
-/**
-* The claim reserve a search needs: the root and 3 finalists on every test
-* task at `reps` repeats, each held at `cellUsd`. Declare at least this as
-* `budget.reservedClaimUsd`; `runSearch` refuses to start a capped search
-* with less.
-*/
-function searchClaimReserveUsd(input) {
-	return 4 * input.testTasks * input.reps * input.cellUsd;
-}
-/** Fix the claim's design from a search that stopped expanding. */
-function planSearchClaim(state, input) {
-	const header = requireHeader(state);
-	const root = state.rootNodeId;
-	const plan = (finalists, power, test, reason) => ({
-		kind: "search-claim-plan",
-		rule: SEARCH_CLAIM_RULE,
-		stopReason: input.stopReason,
-		finalists,
-		power,
-		test,
-		reason
-	});
-	const selectionUnits = unitIds(header.splits.selection.tasks);
-	const testUnits = unitIds(header.splits.test.tasks);
-	if (testUnits.length === 0) return plan([], { unknown: "the search has no test split" }, "hold", "the search has no test split, so it makes no claim");
-	if (selectionUnits.length === 0) return plan([], { unknown: "the search has no selection split to choose finalists on" }, "hold", "the search has no selection split, so no finalist can be chosen without the test data");
-	const candidates = rankFinalists(state, selectionUnits);
-	if (candidates.length === 0) return plan([], { unknown: "no node went to test" }, "hold", "no node scored every selection unit and beat the root's selection mean, so the search keeps the root");
-	const minimumEffect = header.objective.claim.minimumEffect;
-	if (minimumEffect === void 0) return plan(candidates.slice(0, 1), { unknown: "the claim declares no minimumEffect" }, "test-cannot-resolve", "the claim declares no minimumEffect, so no test split can be shown to resolve it");
-	const { pooledVariance } = searchPosterior(state, { split: "selection" });
-	if (pooledVariance === null) return plan(candidates.slice(0, 1), { unknown: "no node shares 2 selection units with the root, so the variance is unknown" }, "test-cannot-resolve", "the selection split gives no variance for the power check, so the test cannot be shown to resolve the minimum effect");
-	const estimator = claimEstimator(state, input.reps);
-	const rootPassRate = passRate(state.unitScores(root, "selection"), estimator);
-	let best = null;
-	let budgetBound = false;
-	for (let k = candidates.length; k >= 1; k--) {
-		const power = claimPower({
-			units: testUnits.length,
-			finalists: k,
-			minimumEffect,
-			pooledVariance,
-			estimator,
-			rootPassRate,
-			seed: header.policy.seed
-		});
-		best = power;
-		if (!power.adequate) continue;
-		if (!input.affordable(k)) {
-			budgetBound = true;
-			continue;
-		}
-		return plan(candidates.slice(0, k), power, "run", `${k} finalist${k === 1 ? "" : "s"} go to test: power ${round(power.powerAtMinimumEffect)} at an improvement of ${minimumEffect} on ${testUnits.length} test units reaches ${TARGET_POWER} at confidence ${round(bonferroni(k))} each`);
-	}
-	const power = best;
-	return plan(candidates.slice(0, 1), power, "test-cannot-resolve", budgetBound ? "the unspent claim reserve and headroom do not cover the test cells of the root and one finalist" : `even one finalist reaches power ${round("adequate" in power ? power.powerAtMinimumEffect : 0)} at an improvement of ${minimumEffect} on ${testUnits.length} test units, below ${TARGET_POWER}`);
-}
-/**
-* Decide the claim from the test cells of the root and the finalists. Call it
-* once every claim cell is settled or cancelled. It returns the claim and the
-* terminal decisions of the root and every finalist.
-*/
-function decideSearchClaim(state, plan) {
-	const header = requireHeader(state);
-	const root = state.rootNodeId;
-	const rootScored = [
-		"train",
-		"selection",
-		"test"
-	].some((split) => state.scoredCells(root, split).length > 0);
-	const keepRoot = rootScored ? root : null;
-	const rule = SEARCH_CLAIM_RULE_NAME;
-	const decisions = [];
-	const claimOf = (finalists, selected, decision, reason) => ({
-		rule: SEARCH_CLAIM_RULE,
-		confidence: FAMILY_CONFIDENCE,
-		power: plan.power,
-		finalists,
-		selected,
-		decision,
-		reason
-	});
-	if (plan.test !== "run") {
-		for (const finalist of plan.finalists) decisions.push({
-			nodeId: finalist.nodeId,
-			decision: { status: "rejected" },
-			basis: null,
-			rule,
-			reason: `no test cell ran: ${plan.reason}`
-		});
-		decisions.push(rootDecision(root, rootScored ? "kept" : "unscored", rule, plan.reason));
-		return {
-			claim: claimOf(plan.finalists.map((finalist) => ({
-				nodeId: finalist.nodeId,
-				estimate: null,
-				test: null,
-				promote: false
-			})), keepRoot, plan.test, plan.reason),
-			decisions
-		};
-	}
-	const power = plan.power;
-	if (!("adequate" in power)) throw new Error("a claim that runs its test cells has a known power");
-	const k = plan.finalists.length;
-	const confidence = bonferroni(k);
-	const testUnits = unitIds(header.splits.test.tasks);
-	const maximize = header.objective.direction === "maximize";
-	const rootUnits = state.unitScores(root, "test");
-	const tested = plan.finalists.map(({ nodeId }) => {
-		const estimate = estimateNode(state, nodeId, {
-			against: root,
-			split: "test"
-		});
-		return {
-			nodeId,
-			estimate,
-			...pairedTest({
-				root: rootUnits,
-				node: state.unitScores(nodeId, "test"),
-				testUnits,
-				confidence,
-				estimator: power.estimator,
-				maximize,
-				seed: seedFromDigest(estimate.cellSetDigest)
-			})
-		};
-	});
-	const winner = tested.map((entry, rank) => ({
-		...entry,
-		rank
-	})).filter((entry) => entry.promote).sort((a, b) => b.improvement - a.improvement || a.rank - b.rank)[0] ?? null;
-	const blockers = [];
-	if (!header.splits.heldOutUnits) blockers.push("the test units also appear in train or selection");
-	if ("unknown" in header.objective.judge) blockers.push("the judge is not pinned");
-	const ship = winner !== null && blockers.length === 0;
-	const selected = ship ? winner.nodeId : keepRoot;
-	const reason = ship ? `finalist ${winner.nodeId} beat the root on the ${testUnits.length} test units at confidence ${round(confidence)} (${k} finalist${k === 1 ? "" : "s"}, family-wise ${FAMILY_CONFIDENCE})` : winner !== null ? `finalist ${winner.nodeId} beat the root, but the claim cannot ship: ${blockers.join("; ")}` : `no finalist beat the root on the test split at confidence ${round(confidence)} (${k} finalist${k === 1 ? "" : "s"}, family-wise ${FAMILY_CONFIDENCE})`;
-	for (const entry of tested) decisions.push({
-		nodeId: entry.nodeId,
-		decision: { status: ship && entry.nodeId === winner.nodeId ? "selected" : "rejected" },
-		basis: entry.estimate,
-		rule,
-		reason: ship && entry.nodeId === winner.nodeId ? reason : entry.promote ? ship ? `promoted, but finalist ${winner.nodeId} improved more on the test split` : reason : entry.why
-	});
-	decisions.push(rootDecision(root, ship ? "replaced" : rootScored ? "kept" : "unscored", rule, reason));
-	return {
-		claim: claimOf(tested.map((entry) => ({
-			nodeId: entry.nodeId,
-			estimate: entry.estimate,
-			test: entry.test,
-			promote: entry.promote
-		})), selected, ship ? "ship" : "hold", reason),
-		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;
-}
-function rootDecision(root, fate, rule, reason) {
-	return {
-		nodeId: root,
-		decision: { status: fate === "kept" ? "selected" : "rejected" },
-		basis: null,
-		rule,
-		reason: fate === "kept" ? `the search keeps the root: ${reason}` : fate === "replaced" ? `a finalist replaces the root: ${reason}` : "the root has no scored cell, so the search keeps nothing"
-	};
-}
-/** Nodes eligible to go to test, best first, at most `SEARCH_CLAIM_MAX_FINALISTS`. */
-function rankFinalists(state, selectionUnits) {
-	const sign = requireHeader(state).objective.direction === "maximize" ? 1 : -1;
-	const root = state.rootNodeId;
-	const rootMeans = new Map(state.unitScores(root, "selection").map((unit) => [unit.unitId, unit.mean]));
-	const ranked = [];
-	for (const node of state.nodes()) {
-		if (node.nodeId === root || node.status === "invalid") continue;
-		const units = state.unitScores(node.nodeId, "selection");
-		if (units.length !== selectionUnits.length) continue;
-		let gain = 0;
-		let shared = 0;
-		for (const unit of units) {
-			const rootMean = rootMeans.get(unit.unitId);
-			if (rootMean === void 0) continue;
-			gain += sign * (unit.mean - rootMean);
-			shared += 1;
-		}
-		if (shared === 0 || gain <= 0) continue;
-		ranked.push({
-			nodeId: node.nodeId,
-			selectionMean: mean$2(units.map((unit) => unit.mean)),
-			ordinal: node.ordinal
-		});
-	}
-	ranked.sort((a, b) => sign * (b.selectionMean - a.selectionMean) || a.ordinal - b.ordinal);
-	return ranked.slice(0, 3).map(({ nodeId, selectionMean }) => ({
-		nodeId,
-		selectionMean
-	}));
-}
-/**
-* The paired decision's estimator, fixed from pre-test data. A per-unit mean
-* is binary only when each unit holds one task at one repeat and every score
-* seen before the test is 0 or one positive value.
-*/
-function claimEstimator(state, reps) {
-	const header = requireHeader(state);
-	if (![
-		"train",
-		"selection",
-		"test"
-	].every((split) => {
-		const tasks = header.splits[split].tasks;
-		return unitIds(tasks).length === tasks.length;
-	}) || reps !== 1) return { kind: "continuous" };
-	let scale = null;
-	for (const nodeId of state.nodeIds()) for (const split of ["train", "selection"]) for (const cell of state.scoredCells(nodeId, split)) {
-		if (cell.score === 0) continue;
-		if (cell.score < 0 || scale !== null && cell.score !== scale) return { kind: "continuous" };
-		scale = cell.score;
-	}
-	return scale === null ? { kind: "continuous" } : {
-		kind: "binary",
-		scale
-	};
-}
-function passRate(units, estimator) {
-	if (estimator.kind !== "binary" || units.length === 0) return 0;
-	return units.filter((unit) => unit.mean === estimator.scale).length / units.length;
-}
-function claimPower(input) {
-	const { units, finalists, minimumEffect, pooledVariance, estimator } = input;
-	const confidence = bonferroni(finalists);
-	let alternative;
-	let call;
-	if (estimator.kind === "binary") {
-		const s = estimator.scale;
-		const shift = Math.min(1, minimumEffect / s);
-		const discordance = Math.min(.5, pooledVariance / (2 * s * s));
-		const loss = Math.max(0, discordance - shift / 2);
-		const win = Math.min(1 - loss, loss + shift);
-		const concordant = Math.max(0, 1 - win - loss);
-		alternative = { cells: [
-			{
-				probability: win,
-				pass: {
-					control: false,
-					treatment: true
-				},
-				delta: {
-					kind: "point",
-					value: s
-				}
-			},
-			{
-				probability: loss,
-				pass: {
-					control: true,
-					treatment: false
-				},
-				delta: {
-					kind: "point",
-					value: -s
-				}
-			},
-			{
-				probability: concordant * input.rootPassRate,
-				pass: {
-					control: true,
-					treatment: true
-				},
-				delta: {
-					kind: "point",
-					value: 0
-				}
-			},
-			{
-				probability: concordant * (1 - input.rootPassRate),
-				pass: {
-					control: false,
-					treatment: false
-				},
-				delta: {
-					kind: "point",
-					value: 0
-				}
-			}
-		] };
-		call = {
-			outcome: "pass",
-			options: {
-				binaryScale: s,
-				confidence,
-				threshold: 0
-			}
-		};
-	} else {
-		alternative = { cells: [{
-			probability: 1,
-			delta: {
-				kind: "normal",
-				mean: minimumEffect,
-				sd: Math.sqrt(pooledVariance)
-			}
-		}] };
-		call = {
-			outcome: "delta",
-			options: {
-				continuous: true,
-				confidence,
-				threshold: 0,
-				resamples: RESAMPLES
-			}
-		};
-	}
-	const simulated = pairedPromotionPower({
-		n: units,
-		alternative,
-		calls: [call],
-		simulations: POWER_SIMULATIONS,
-		seed: seedFromDigest(hashCanonical([input.seed, finalists]))
-	});
-	return {
-		adequate: simulated.power >= TARGET_POWER,
-		minimumEffect,
-		powerAtMinimumEffect: simulated.power,
-		targetPower: TARGET_POWER,
-		units,
-		finalists,
-		pooledVariance,
-		estimator
-	};
-}
-/**
-* One finalist against the root on the test split, in the objective's
-* direction, requiring every test unit scored by both.
-*/
-function pairedTest(input) {
-	const rootMeans = new Map(input.root.map((unit) => [unit.unitId, unit.mean]));
-	const before = [];
-	const after = [];
-	for (const unit of input.node) {
-		const rootMean = rootMeans.get(unit.unitId);
-		if (rootMean === void 0) continue;
-		before.push(input.maximize ? rootMean : unit.mean);
-		after.push(input.maximize ? unit.mean : rootMean);
-	}
-	const pairs = before.length;
-	if (pairs === 0) return {
-		test: null,
-		promote: false,
-		improvement: null,
-		why: "no test unit was scored by both it and the root"
-	};
-	const { estimator } = input;
-	if (estimator.kind === "binary" && [...before, ...after].some((value) => value !== 0 && value !== estimator.scale)) return {
-		test: null,
-		promote: false,
-		improvement: null,
-		why: `a test score left the two-point scale {0, ${estimator.scale}} the claim fixed before the test`
-	};
-	const decision = decidePairedPromotion(before, after, {
-		confidence: input.confidence,
-		threshold: 0,
-		minPairs: input.testUnits.length,
-		resamples: RESAMPLES,
-		seed: input.seed,
-		...estimator.kind === "binary" ? { binaryScale: estimator.scale } : { continuous: true }
-	});
-	const test = {
-		pairs,
-		confidence: input.confidence,
-		method: decision.method,
-		delta: plain(input.maximize ? decision.delta : -decision.delta),
-		interval: input.maximize ? [plain(decision.low), plain(decision.high)] : [plain(-decision.high), plain(-decision.low)]
-	};
-	const complete = pairs === input.testUnits.length;
-	const promote = decision.promote && complete;
-	const why = !complete ? `it and the root scored ${pairs} of ${input.testUnits.length} test units, and a claim needs every one` : decision.promote ? "promoted" : !decision.sufficient ? `${pairs} test units are below the ${decision.minimumPairs} its paired test needs` : decision.indeterminate ? `its test interval has no width: ${decision.indeterminateCause}` : decision.exactTestVetoes ? "McNemar's exact test vetoes the improvement" : `its improvement interval [${round(decision.low)}, ${round(decision.high)}] at confidence ${round(input.confidence)} does not exclude 0`;
-	return {
-		test,
-		promote,
-		improvement: decision.delta,
-		why
-	};
-}
-function requireHeader(state) {
-	const header = state.header;
-	if (!header) throw new Error(`search ${state.searchId} has not been opened`);
-	if (state.rootNodeId === null) throw new Error(`search ${state.searchId} has no root node`);
-	return header;
-}
-function unitIds(tasks) {
-	return [...new Set(tasks.map((task) => task.unitId))];
-}
-function mean$2(values) {
-	let total = 0;
-	for (const value of values) total += value;
-	return total / values.length;
-}
-function round(value) {
-	return Math.round(value * 1e4) / 1e4;
-}
-/** 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, 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: "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;
-/** The operation that holds the claim's plan. */
-const CLAIM_OPERATION = "claim";
-/** 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;
-	/** The claim's design once expansion stopped; the search then only claims. */
-	claimPlan = 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");
-	}
-	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();
-		}
-	}
-	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 {
-			if (this.claimPlan) await this.applyClaimPlan(this.claimPlan);
-			await this.loop();
-			if (!this.failure && !this.claimPlan && this.state.header.splits.test.tasks.length > 0) {
-				await this.beginClaim();
-				await this.loop();
-			}
-		} finally {
-			signal?.removeEventListener("abort", onAbort);
-		}
-		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);
-		if (this.state.audit.cells.allocated === 0) this.assertClaimReady();
-		await this.restoreClaimPlan();
-		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;
-			}
-			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();
-		}
-		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 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);
-			if (cell.stage !== "claim") this.pending.set(cell.nodeId, (this.pending.get(cell.nodeId) ?? 0) + 1);
-		}
-		if (this.claimPlan) return;
-		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
-	* split, the power check needs the claim's minimum effect, a ship needs a
-	* pinned judge, and under a cap the claim reserve must cover the root and 3
-	* finalists on every test task while the rest of the cap covers one
-	* screening round. Checked before the first cell, so a search that cannot
-	* claim spends nothing.
-	*/
-	assertClaimReady() {
-		const header = this.state.header;
-		const testTasks = header.splits.test.tasks.length;
-		if (testTasks === 0) return;
-		const refuse = (why) => {
-			throw new Error(`runSearch: search ${this.recorder.searchId} has a test split, but ${why}`);
-		};
-		if (header.splits.selection.tasks.length === 0) refuse("no selection split to choose its finalists on");
-		if (header.objective.claim.minimumEffect === void 0) refuse("its claim declares no minimumEffect for the power check");
-		if ("unknown" in header.objective.judge) refuse("its judge is not pinned; a claim with an unknown judge cannot ship, and a resumed search could mix two judges");
-		const { maxUsd, reservedClaimUsd } = header.budget;
-		if (maxUsd === null) return;
-		const cellUsd = this.maxCellReservation();
-		const need = searchClaimReserveUsd({
-			testTasks,
-			reps: this.options.allocation.reps,
-			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, 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})`);
-	}
-	/** A claim an earlier process began: continue it from its stored plan. */
-	async restoreClaimPlan() {
-		const operation = this.state.operation(CLAIM_OPERATION);
-		if (!operation) return;
-		const ref = operation.artifacts.find((artifact) => artifact.role === "claim-plan");
-		if (!ref) throw new Error(`runSearch: the ${CLAIM_OPERATION} operation has no stored plan`);
-		const plan = this.recorder.readBlob(ref);
-		if (!operation.recorded) await this.recordClaimOperation();
-		this.claimPlan = plan;
-		this.stopReason = plan.stopReason;
-	}
-	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());
-		}
-	}
-	/** 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) return;
-		const claimOnly = this.pastDeadline();
-		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 = (claimOnly ? lane.queues[STAGE_PRIORITY.claim] : lane.queues.find((waiting) => waiting.length > 0))?.shift();
-			if (cellId === void 0) break;
-			this.start(cellId, lane);
-		}
-	}
-	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.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;
-		}
-		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.onNodeIdle(cell.nodeId);
-	}
-	/** Every cell allocated to the node is done: its screen, or a rung. */
-	async onNodeIdle(nodeId) {
-		if (!await this.screenDone(nodeId)) return;
-		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
-	* mean rose over its parent's while its selection interval against the
-	* parent lies wholly on the worse side) is decided `invalid` and never
-	* becomes a parent; any other node is screened. Returns whether it was.
-	*/
-	async screenDone(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({
-					nodeId,
-					decision: { status: "invalid" },
-					basis: divergence.basis,
-					rule: "divergence",
-					reason: divergence.reason
-				});
-				await this.refresh();
-				this.admitted.delete(nodeId);
-				return false;
-			}
-		}
-		this.markScreened(nodeId);
-		return true;
-	}
-	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 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,
-				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)
-			};
-		});
-		const hold = placed.reduce((sum, { reservation }) => sum + reservation.usd, 0);
-		const { headroomUsd } = this.state.budget;
-		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 false;
-		if (decision) await this.decide(decision);
-		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();
-		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);
-	}
-	queuedCount() {
-		let count = 0;
-		for (const lane of this.lanes.values()) for (const queue of lane.queues) count += queue.length;
-		return count;
-	}
-	/** Fix the claim's design, store it, and start its test cells. */
-	async beginClaim() {
-		await this.refresh();
-		const stopReason = this.stopReason ?? "converged";
-		const header = this.state.header;
-		const reps = this.options.allocation.reps;
-		const plan = planSearchClaim(this.state, {
-			stopReason,
-			reps,
-			affordable: (finalists) => {
-				const placed = this.claimCells(finalists, this.state.rootNodeId);
-				const hold = placed.reduce((sum, cell) => sum + cell.reservation.usd, 0);
-				const { headroomUsd, claimReserveUsd } = this.state.budget;
-				const { maxCells } = header.budget;
-				return (headroomUsd === null || hold <= headroomUsd + claimReserveUsd + USD_TOLERANCE) && (maxCells === null || this.state.audit.cells.allocated + placed.length <= maxCells);
-			}
-		});
-		await this.recorder.startOperation({
-			operationId: CLAIM_OPERATION,
-			operationKind: "selection",
-			reservation: null,
-			artifacts: [this.recorder.blob("claim-plan", plan)]
-		});
-		await this.recordClaimOperation();
-		this.claimPlan = plan;
-		this.stopReason = stopReason;
-		await this.applyClaimPlan(plan);
-	}
-	async recordClaimOperation() {
-		await this.recorder.recordOperation({
-			operationId: CLAIM_OPERATION,
-			operationKind: "selection",
-			execution: {
-				kind: "deterministic",
-				source: SEARCH_CLAIM_RULE
-			},
-			outcome: { status: "completed" },
-			accounting: {
-				tokens: {
-					status: "known",
-					inputTokens: 0,
-					outputTokens: 0,
-					cachedTokens: 0
-				},
-				cost: {
-					status: "known",
-					usd: 0,
-					source: "free"
-				}
-			}
-		});
-		await this.refresh();
-	}
-	/**
-	* Decide the plan's finalists and allocate the test cells of the root and
-	* the finalists, interleaved by task so the arms of one task run side by
-	* side. Allocation finishes before any claim cell starts. Idempotent.
-	*/
-	async applyClaimPlan(plan) {
-		const root = this.state.rootNodeId;
-		const bases = plan.finalists.map((finalist) => estimateNode(this.state, finalist.nodeId, {
-			against: root,
-			split: "selection"
-		}));
-		for (const [rank, finalist] of plan.finalists.entries()) await this.recorder.decideNode({
-			nodeId: finalist.nodeId,
-			decision: { status: "finalist" },
-			basis: bases[rank],
-			rule: SEARCH_CLAIM_RULE_NAME,
-			reason: `rank ${rank + 1} of ${plan.finalists.length} by selection mean (${finalist.selectionMean}); ${plan.reason}`
-		});
-		await this.refresh();
-		if (plan.test !== "run") return;
-		const missing = this.claimCells(plan.finalists.length, root, plan).map((cell) => ({
-			...cell,
-			cellId: searchCellId(this.recorder.searchId, cell.nodeId, cell.plan.taskId, "test", cell.plan.rep)
-		})).filter((cell) => !this.state.cell(cell.cellId));
-		for (const cell of missing) await this.recorder.allocateCell({
-			nodeId: cell.nodeId,
-			taskId: cell.plan.taskId,
-			split: "test",
-			rep: cell.plan.rep,
-			stage: "claim",
-			lane: cell.lane.name,
-			reservation: cell.reservation
-		});
-		await this.refresh();
-		for (const cell of missing) this.enqueue(this.state.cell(cell.cellId));
-	}
-	/** The test cells of the root and the first `finalists` of the plan (or of
-	* the finalist count being priced), task by task, with their lanes and holds. */
-	claimCells(finalists, root, plan) {
-		const header = this.state.header;
-		const arms = [root, ...plan ? plan.finalists.map((entry) => entry.nodeId) : []];
-		while (arms.length < finalists + 1) arms.push(root);
-		const cells = [];
-		for (const task of header.splits.test.tasks) for (let rep = 0; rep < this.options.allocation.reps; rep++) for (const nodeId of arms) {
-			const cellPlan = {
-				taskId: task.taskId,
-				split: "test",
-				rep,
-				stage: "claim"
-			};
-			const laneName = this.options.executor.place({
-				...cellPlan,
-				nodeId
-			});
-			const lane = this.lanes.get(laneName);
-			if (!lane) throw new Error(`runSearch: the executor placed a cell on unknown lane ${laneName}`);
-			cells.push({
-				nodeId,
-				plan: cellPlan,
-				lane,
-				reservation: this.cellReservation(lane)
-			});
-		}
-		return cells;
-	}
-	async cancelQueued(reason) {
-		for (const lane of this.lanes.values()) for (const [priority, queue] of lane.queues.entries()) {
-			if (priority === STAGE_PRIORITY.claim) continue;
-			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);
-			}
-		}
-	}
-	/** 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 || 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";
-		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;
-	}
-	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);
-		}
-	}
-	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;
-		}
-		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 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;
-			const against = node.nodeId === leader ? root : leader;
-			const basis = node.nodeId === against || !scored ? null : estimateNode(this.state, node.nodeId, {
-				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 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);
-		await this.recorder.close({
-			reason: this.stopReason ?? "converged",
-			claim: null
-		});
-		await this.refresh();
-	}
-	/** Close with the claim: the claim's decisions, then every other open node
-	* rejected with its selection estimate against the root. */
-	async closeWithClaim(plan) {
-		const { claim, decisions } = decideSearchClaim(this.state, plan);
-		const decided = new Set(decisions.map((decision) => decision.nodeId));
-		const root = this.state.rootNodeId;
-		const rest = this.state.nodes().filter((node) => !decided.has(node.nodeId) && !isTerminal(node)).map((node) => {
-			const scored = this.state.scoredCells(node.nodeId, "selection").length > 0;
-			return {
-				nodeId: node.nodeId,
-				decision: { status: "rejected" },
-				basis: scored ? estimateNode(this.state, node.nodeId, {
-					against: root,
-					split: "selection"
-				}) : null,
-				rule: SEARCH_CLAIM_RULE_NAME,
-				reason: scored ? "not a finalist: the claim tests at most 3 nodes that scored every selection unit and beat the root, best selection mean first" : "the search stopped before this node was measured on the selection split"
-			};
-		});
-		for (const decision of [...decisions, ...rest]) await this.recorder.decideNode(decision);
-		await this.recorder.close({
-			reason: plan.stopReason,
-			claim
-		});
-		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,
-			claimVerification
-		};
-	}
-	policyView() {
-		return searchPolicyView(this.state, {
-			screened: this.screened,
-			screening: this.admitted.size - this.screenedSet.size,
-			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;
-		const artifact = this.options.codec.load(this.recorder, this.state.node(nodeId));
-		this.artifacts.set(nodeId, artifact);
-		return artifact;
-	}
-	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)
-		};
-	}
-	maxCellReservation() {
-		let most = 0;
-		for (const lane of this.lanes.values()) most = Math.max(most, this.cellReservation(lane).usd);
-		return most;
-	}
-	operationReservation() {
-		return {
-			kind: "estimate",
-			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);
-	}
-	async refresh() {
-		this.state = await this.recorder.state();
-	}
-};
-/**
-* 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.
-* `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";
-	return {
-		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) => {
-			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, {
-			against,
-			split
-		})
-	};
-}
-/**
-* The divergence rule: a node whose train mean rose over its parent's on the
-* train units they share while its selection interval against the parent (6
-* or more units, not indeterminate) lies wholly on the worse side. Train is
-* what the proposer reads; a gain there that selection contradicts is the
-* signature of fitting the feedback instead of the task.
-*/
-function searchDivergence(state, nodeId) {
-	const header = state.header;
-	const parent = state.node(nodeId)?.primaryParentId ?? null;
-	if (!header || parent === null || header.splits.selection.tasks.length === 0) return null;
-	const selection = estimateNode(state, nodeId, {
-		against: parent,
-		split: "selection"
-	});
-	if (selection.interval === null) return null;
-	const maximize = header.objective.direction === "maximize";
-	const [low, high] = selection.interval;
-	if (maximize ? high >= 0 : low <= 0) return null;
-	const parentTrain = new Map(state.unitScores(parent, "train").map((unit) => [unit.unitId, unit.mean]));
-	let gain = 0;
-	let shared = 0;
-	for (const unit of state.unitScores(nodeId, "train")) {
-		const before = parentTrain.get(unit.unitId);
-		if (before === void 0) continue;
-		gain += maximize ? unit.mean - before : before - unit.mean;
-		shared += 1;
-	}
-	if (shared === 0 || gain <= 0) return null;
-	return {
-		basis: selection,
-		reason: `its train mean rose ${Math.round(gain / shared * 1e4) / 1e4} over its parent's on ${shared} shared train unit${shared === 1 ? "" : "s"}, while its selection interval against the parent, [${round4(low)}, ${round4(high)}] on ${selection.pairs} units, lies wholly on the worse side`
-	};
-}
-function round4(value) {
-	return Math.round(value * 1e4) / 1e4;
-}
-function isTerminal(node) {
-	return node.status !== null && node.status !== "advanced";
-}
-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;
-}
-/** Spend of work whose result was lost: unknown, with no proven floor. */
-function interruptedAccounting() {
-	return {
-		tokens: {
-			status: "unknown",
-			reason: "the result of this work was lost"
-		},
-		cost: {
-			status: "unknown",
-			knownLowerBoundUsd: 0,
-			reason: "the result of this work was lost, so its spend is unknown"
-		}
-	};
-}
-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
 const SEARCH_HISTORY_RECEIPT_SCHEMA_VERSION = "2026-09";
 const SEARCH_HISTORY_RECEIPT_DIGEST_ALGORITHM = "rfc8785-sha256";
@@ -5418,10 +3537,16 @@ function canonicalHeader(header) {
 * 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.
+* A policy reads a `SearchPolicyView`: the nodes, their lineage, their
+* per-unit scores and posterior on the policy's split, and how many of their
+* cells failed as defects. 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.
+*
+* `incumbent`, `incumbentWithOperatorBandit` and `crowdedFrontierParent` are
+* hill climbs and pair with the `uniform` allocator. `aide` and `beam` choose parents from each node's
+* posterior, which is honest about a node measured on few units, so they pair
+* with `asha`, which measures most nodes on only the first rung.
 */
 /**
 * The hill climb. The leader starts at the root; a screened node that dodged no
@@ -5446,6 +3571,65 @@ function incumbent(options = {}) {
 	});
 }
 /**
+* The hill climb (as `incumbent`), with its operator drawn from the
+* `operatorYield` lens instead of fixed at `improve` (search-tree-design
+* §12): a weighted draw, seeded from `seed` and the expansion index like
+* `crowdedFrontierParent`, over the lens's per-operator yield. The fallback
+* is per operator, not all-or-nothing: an operator the lens has not yet
+* measured `MIN_OUTCOMES_FOR_WEIGHT` outcomes for draws on `fixedWeights`
+* (uniform by default) instead, so it is never starved while unmeasured, and
+* an operator that does have enough outcomes draws on its own measured
+* yield right away rather than waiting for every other operator to catch
+* up — proved against real search-sim ledgers where a hill climb had only
+* ever proposed `improve`: an all-or-nothing gate would keep every draw
+* uniform forever, because `draft`/`debug`/`merge` are never measured by a
+* policy that never chooses them. A measured operator's weight is its own
+* `fixedWeights` prior plus its yield, not the yield alone: the two are on
+* different scales (yield is improvement per known dollar; the prior is an
+* arbitrary share), so using the yield by itself would let a small positive
+* yield draw LESS than an untested operator sitting on the default prior of
+* 1 — the same real ledgers caught exactly that before this was fixed. The
+* sum is floored just above zero, so a so-far-bad operator can still be
+* re-measured rather than excluded outright.
+*/
+function incumbentWithOperatorBandit(options = { seed: 0 }) {
+	const { patience, seed } = options;
+	if (!Number.isInteger(seed)) throw new TypeError(`incumbentWithOperatorBandit: seed must be an integer, got ${String(seed)}`);
+	const fixedWeights = {
+		draft: options.fixedWeights?.draft ?? 1,
+		improve: options.fixedWeights?.improve ?? 1,
+		debug: options.fixedWeights?.debug ?? 1,
+		merge: options.fixedWeights?.merge ?? 1
+	};
+	for (const operator of EXPANSION_OPERATORS) {
+		const weight = fixedWeights[operator];
+		if (!Number.isFinite(weight) || weight < 0) throw new TypeError(`incumbentWithOperatorBandit: fixedWeights.${operator} must be >= 0, got ${weight}`);
+	}
+	return hillClimb({
+		name: patience === void 0 ? `incumbent-operator-bandit(seed=${seed})` : `incumbent-operator-bandit(seed=${seed},patience=${patience})`,
+		patience,
+		parent: (_view, leader) => ({
+			nodeId: leader,
+			evidence: {}
+		}),
+		operator: (view) => chooseOperator(view.operatorWeights, fixedWeights, seed, view.expansions)
+	});
+}
+function chooseOperator(measured, fixedWeights, seed, expansionIndex) {
+	const weights = EXPANSION_OPERATORS.map((operator) => {
+		const yieldMean = measured[operator];
+		const prior = fixedWeights[operator];
+		return yieldMean === null ? prior : Math.max(prior + yieldMean, 1e-6);
+	});
+	const total = weights.reduce((a, b) => a + b, 0);
+	let draw = mulberry32(seed ^ Math.imul(expansionIndex + 1, 2654435761) | 0)() * total;
+	for (let index = 0; index < EXPANSION_OPERATORS.length; index++) {
+		draw -= weights[index];
+		if (draw <= 0) return EXPANSION_OPERATORS[index];
+	}
+	return EXPANSION_OPERATORS[EXPANSION_OPERATORS.length - 1];
+}
+/**
 * 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
@@ -5482,27 +3666,261 @@ function crowdedFrontierParent(options) {
 		}
 	});
 }
-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;
+/**
+* AIDE's search policy (`aide/agent.py`, `search_policy`) with three changes
+* for noisy scores.
+*
+* 1. **Draft** while fewer than `drafts` nodes were drafted: the root is the
+*    parent, and the proposer writes a whole alternative, not an edit.
+* 2. **Debug**, with probability `debugProbability`: a buggy leaf, drawn
+*    uniformly, whose chain holds fewer than `maxDebugDepth` debug edges. A
+*    node is buggy when at least half of its final cells outside the test
+*    split failed: defects, not a low score. An `errored` cell is the
+*    environment's fault; it is retried and never makes a node buggy.
+* 3. **Improve** otherwise. The parent is drawn by Thompson sampling, not
+*    AIDE's argmax, from every screened node that is not buggy and has a
+*    posterior (`searchPosterior`): the root sits at 0, and every other node
+*    at its mean improvement over the root with the search's pooled
+*    between-unit variance divided by its shared units, so a node measured on
+*    few units draws from a wide posterior. Until some node shares 2 units
+*    with the root the pooled variance is unknown, every posterior is as wide
+*    as it can be, and the draw is uniform. With no such node, the policy
+*    drafts.
+* 4. **Stall:** when the drawn parent's lineage (the nodes under its nearest
+*    draft, or under the root) has had `stallAfter` improve children in a row
+*    that did not raise the lineage's best posterior mean, the improve forks
+*    from the node with the best posterior mean instead. This is AIDE²'s
+*    inner policy. A fork's children restart the run of the lineage they
+*    join, so a stalled lineage that holds the global best forks once, not
+*    on every later expansion.
+*
+* A parent is always a node whose screen finished; a node refused at
+* admission or decided invalid never is. Draws come from a PRNG seeded by the
+* search seed and the count of completed expansions, so the policy is a pure
+* function of the ledger. The leader is the incumbent's.
+*/
+function aide(options = {}) {
+	const drafts = integerOption("aide", "drafts", options.drafts ?? 5, 0);
+	const debugProbability = options.debugProbability ?? .5;
+	if (!(debugProbability >= 0 && debugProbability <= 1)) throw new TypeError(`aide: debugProbability must be in [0, 1], got ${String(options.debugProbability)}`);
+	const maxDebugDepth = integerOption("aide", "maxDebugDepth", options.maxDebugDepth ?? 3, 0);
+	const stallAfter = integerOption("aide", "stallAfter", options.stallAfter ?? 4, 1);
+	const name = drafts === 5 && debugProbability === .5 && maxDebugDepth === 3 && stallAfter === 4 ? "aide" : `aide(drafts=${drafts},debug=${debugProbability},maxDebugDepth=${maxDebugDepth},stallAfter=${stallAfter})`;
+	return {
+		name,
+		leader: leaderOf,
+		expand(view) {
+			const root = view.rootNodeId;
+			const screened = new Set(view.screened);
+			if (!screened.has(root)) return null;
+			const nodes = view.nodes();
+			const byId = new Map(nodes.map((node) => [node.nodeId, node]));
+			const rng = mulberry32(view.seed ^ Math.imul(view.expansions + 1, 2654435761) ^ AIDE_SALT | 0);
+			const drafted = nodes.filter((node) => node.operator === "draft").length;
+			const draft = (evidence) => ({
+				parents: [root],
+				operator: "draft",
+				selection: {
+					rule: `${name}:draft`,
+					evidence: {
+						drafted,
+						drafts,
+						...evidence
+					}
+				}
+			});
+			if (drafted < drafts) return draft({});
+			if (rng() < debugProbability) {
+				const debuggable = nodes.filter((node) => screened.has(node.nodeId) && buggy(node) && node.children.length === 0 && debugDepth(node, byId) < maxDebugDepth);
+				if (debuggable.length > 0) {
+					const pick = debuggable[Math.floor(rng() * debuggable.length)];
+					return {
+						parents: [pick.nodeId],
+						operator: "debug",
+						selection: {
+							rule: `${name}:debug`,
+							evidence: {
+								debuggable: debuggable.length,
+								defects: pick.defects,
+								outcomes: pick.outcomes,
+								debugDepth: debugDepth(pick, byId)
+							}
+						}
+					};
+				}
+			}
+			const posterior = new Map(view.posterior.nodes.map((entry) => [entry.nodeId, entry]));
+			const good = nodes.filter((node) => screened.has(node.nodeId) && !buggy(node) && (posterior.get(node.nodeId)?.mean ?? null) !== null);
+			if (good.length === 0) return draft({ good: 0 });
+			const meanOf = (node) => posterior.get(node.nodeId).mean;
+			const known = view.posterior.pooledVariance !== null;
+			let drawn = good[0];
+			let draw = Number.NEGATIVE_INFINITY;
+			if (!known) drawn = good[Math.floor(rng() * good.length)];
+			else for (const node of good) {
+				const value = meanOf(node) + Math.sqrt(posterior.get(node.nodeId).variance) * normal(rng);
+				if (value > draw) {
+					draw = value;
+					drawn = node;
+				}
+			}
+			const stalled = stalledRun(drawn, nodes, screened, posterior, `${name}:stall-fork`);
+			if (stalled >= stallAfter) {
+				let best = good[0];
+				for (const node of good) if (meanOf(node) > meanOf(best)) best = node;
+				return {
+					parents: [best.nodeId],
+					operator: "improve",
+					selection: {
+						rule: `${name}:stall-fork`,
+						evidence: {
+							candidates: good.length,
+							mean: plain(meanOf(best)),
+							units: posterior.get(best.nodeId).pairs,
+							drawnOrdinal: drawn.ordinal,
+							stalledChildren: stalled
+						}
+					}
+				};
+			}
+			const entry = posterior.get(drawn.nodeId);
+			return {
+				parents: [drawn.nodeId],
+				operator: "improve",
+				selection: {
+					rule: `${name}:${known ? "thompson" : "uniform-draw"}`,
+					evidence: {
+						candidates: good.length,
+						mean: plain(entry.mean),
+						units: entry.pairs,
+						...known ? {
+							sd: plain(Math.sqrt(entry.variance)),
+							draw: plain(draw)
+						} : {}
+					}
+				}
+			};
 		}
-		return current;
 	};
+}
+/**
+* Beam search: the beam is the top `width` nodes by posterior mean
+* (`searchPosterior`), and the member with the fewest children is expanded,
+* so each member is expanded in turn, as in a generation of `width`. A member
+* is the root, a node an allocator advanced, or a node that scored every unit
+* the root scored: a node an allocator has only screened waits for its rank
+* before it enters. Ties go to the higher mean, then to the earlier node. The
+* leader is the incumbent's. Strategy evolution is `beam` with its population
+* as the width.
+*/
+function beam(options) {
+	const width = integerOption("beam", "width", options.width, 1);
+	const name = `beam(width=${width})`;
+	return {
+		name,
+		leader: leaderOf,
+		expand(view) {
+			const root = view.rootNodeId;
+			const screened = new Set(view.screened);
+			if (!screened.has(root)) return null;
+			const posterior = new Map(view.posterior.nodes.map((entry) => [entry.nodeId, entry.mean]));
+			const rootUnits = view.unitScores(root).map((unit) => unit.unitId);
+			const members = view.nodes().filter((node) => screened.has(node.nodeId) && (posterior.get(node.nodeId) ?? null) !== null && (node.nodeId === root || node.status === "advanced" || scoredEvery(view, node.nodeId, rootUnits))).sort((left, right) => posterior.get(right.nodeId) - posterior.get(left.nodeId) || left.ordinal - right.ordinal).slice(0, width);
+			let rank = 0;
+			members.forEach((member, index) => {
+				if (member.children.length < members[rank].children.length) rank = index;
+			});
+			const pick = members[rank];
+			return {
+				parents: [pick.nodeId],
+				operator: "improve",
+				selection: {
+					rule: name,
+					evidence: {
+						rank: rank + 1,
+						members: members.length,
+						mean: plain(posterior.get(pick.nodeId)),
+						children: pick.children.length
+					}
+				}
+			};
+		}
+	};
+}
+/** Salts the aide PRNG, so its draws differ from `crowdedFrontierParent`'s at one seed. */
+const AIDE_SALT = 1095320645;
+/** At least half of the node's final cells failed as defects. */
+function buggy(node) {
+	return node.outcomes > 0 && 2 * node.defects >= node.outcomes;
+}
+/** Debug edges in a row ending at `node`. */
+function debugDepth(node, byId) {
+	let depth = 0;
+	let current = node;
+	while (current?.operator === "debug") {
+		depth += 1;
+		current = current.parent === null ? void 0 : byId.get(current.parent);
+	}
+	return depth;
+}
+/**
+* Improve children in a row, in registration order, that did not raise the
+* best posterior mean of `node`'s lineage: the nodes under its nearest draft,
+* or under the root. Only screened nodes with a posterior count, and a child
+* placed by `forkRule` restarts the run.
+*/
+function stalledRun(node, nodes, screened, posterior, forkRule) {
+	const heads = /* @__PURE__ */ new Map();
+	for (const entry of nodes) {
+		const parentHead = entry.parent === null ? void 0 : heads.get(entry.parent);
+		const starts = entry.operator === "draft" || entry.operator === "seed" || entry.operator === "derive" || parentHead === void 0;
+		heads.set(entry.nodeId, starts ? entry.nodeId : parentHead);
+	}
+	const headOf = (entry) => heads.get(entry.nodeId);
+	const lineage = headOf(node);
+	let best = Number.NEGATIVE_INFINITY;
+	let run = 0;
+	for (const entry of nodes) {
+		const mean = posterior.get(entry.nodeId)?.mean ?? null;
+		if (mean === null || !screened.has(entry.nodeId) || headOf(entry) !== lineage) continue;
+		if (entry.rule === forkRule) run = 0;
+		else if (entry.operator === "improve") run = mean > best ? 0 : run + 1;
+		best = Math.max(best, mean);
+	}
+	return run;
+}
+/** True when the node scored every one of `units`. */
+function scoredEvery(view, nodeId, units) {
+	if (units.length === 0 || !view.complete(nodeId)) return false;
+	const own = new Set(view.unitScores(nodeId).map((unit) => unit.unitId));
+	return units.every((unit) => own.has(unit));
+}
+/** A standard normal draw (Box-Muller). */
+function normal(rng) {
+	return Math.sqrt(-2 * Math.log(1 - rng())) * Math.cos(2 * Math.PI * rng());
+}
+function integerOption(owner, name, value, minimum) {
+	if (!Number.isSafeInteger(value) || value < minimum) throw new TypeError(`${owner}: ${name} must be an integer of at least ${minimum}, got ${String(value)}`);
+	return value;
+}
+/** Evidence is canonical JSON, which has one zero. */
+function plain(value) {
+	const rounded = Math.round(value * 1e9) / 1e9;
+	return rounded === 0 ? 0 : rounded;
+}
+function hillClimb(spec) {
 	return {
 		name: spec.name,
 		...spec.patience === void 0 ? {} : { patience: spec.patience },
-		leader,
+		leader: leaderOf,
 		expand(view) {
 			if (view.screening > 0) return null;
-			const kept = leader(view);
+			const kept = leaderOf(view);
 			const chosen = spec.parent(view, kept);
 			const units = view.unitScores(chosen.nodeId);
 			return {
 				parents: [chosen.nodeId],
-				operator: "improve",
+				operator: spec.operator ? spec.operator(view) : "improve",
 				selection: {
 					rule: spec.name,
 					evidence: {
@@ -5516,6 +3934,22 @@ function hillClimb(spec) {
 		}
 	};
 }
+/**
+* The leader every built-in policy keeps: it starts at the root, and 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. Nodes are taken
+* in registration order, so the leader is a pure function of the ledger. A
+* node an allocator has only screened cannot take the lead from one measured
+* on more units.
+*/
+function leaderOf(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;
+}
 /** True when `challenger` scored every unit `holder` scored and improves on
 * `holder` over them. */
 function beats(view, challenger, holder) {
@@ -7682,6 +6116,6 @@ function firstString(value) {
 	return typeof value === "string" && value.trim() ? value : void 0;
 }
 //#endregion
-export { paretoFrontier 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, searchProposalExecution as J, campaignCellSearchResult as K, searchExpansionIndex as L, verifySearchHistoryArtifact as M, verifySearchHistoryReceipt as N, assertSearchHistoryAdmissionOptions as O, SEARCH_KERNEL_SOURCE as P, dominates as Q, searchPolicyView as R, developmentClaim as S, surfaceNode as T, verifySearchClaim as U, planSearchClaim as V, pairedPromotionPower as W, asha as X, searchReceiptAccounting as Y, uniform as Z, isProposedCandidate as _, tangleTracesRoot as _t, transientDispatchFailure as a, redTeamDataset as at, incumbent as b, cellCachePath as bt, compareOptimizationMethods as c, runCanaries as ct, combineComparisonCosts as d, evaluationUnitMap as dt, runFinalComparison as et, costFromLedgerSummary as f, reserveFinalEvidence as ft, runOptimization as g, resolveRunDir as gt, runImprovementLoop as h, planCampaignRun as ht, quotaExhaustedUntil as i, DEFAULT_RED_TEAM_CORPUS as it, searchHistoryCoverageRow as j, assertSearchHistoryMatchesState as k, optimizationTokenUsageFromSummary as l, assertIndependentEvaluationSplit as lt, readGepaCandidatePopulationArtifact as m, runCampaign as mt, JudgeParseError as n, captureJudge as nt, aggregateRunScore as o, redTeamReport as ot, assertGepaCandidatePopulationSummary as p, runEval as pt, searchModelIdentity as q, isTransientTransportFailure as r, defaultProductionGate as rt, clamp01 as s, scoreRedTeamOutput as st, llmJudge as t, openAutoPr as tt, executeOptimizationMethod as u, captureFinalEvidencePolicy as ut, labelTrustRank as v, readCachedCell as vt, surfaceDiff as w, SearchRecorder as x, computeManifestHash as xt, crowdedFrontierParent as y, buildCellSchedule as yt, SEARCH_CLAIM_RULE as z };
+export { captureFinalEvidencePolicy as $, assertCompleteSearchHistory as A, searchReceiptAccounting as B, incumbentWithOperatorBandit as C, surfaceDiff as D, searchEdgeId as E, verifySearchHistoryArtifact as F, captureJudge as G, uniform as H, verifySearchHistoryReceipt as I, redTeamDataset as J, defaultProductionGate as K, campaignCellSearchResult as L, assertSearchHistoryMatchesState as M, createSearchHistoryReceipt as N, surfaceNode as O, searchHistoryCoverageRow as P, assertIndependentEvaluationSplit as Q, searchModelIdentity as R, incumbent as S, developmentClaim as T, runFinalComparison as U, asha as V, openAutoPr as W, scoreRedTeamOutput as X, redTeamReport as Y, runCanaries as Z, isProposedCandidate as _, transientDispatchFailure as a, resolveRunDir as at, beam as b, compareOptimizationMethods as c, buildCellSchedule as ct, combineComparisonCosts as d, evaluationUnitMap as et, costFromLedgerSummary as f, runOptimization as g, runImprovementLoop as h, quotaExhaustedUntil as i, planCampaignRun as it, assertSearchHistoryAdmissionOptions as j, SearchHistoryRequiredError as k, optimizationTokenUsageFromSummary as l, cellCachePath as lt, readGepaCandidatePopulationArtifact as m, JudgeParseError as n, runEval as nt, aggregateRunScore as o, tangleTracesRoot as ot, assertGepaCandidatePopulationSummary as p, DEFAULT_RED_TEAM_CORPUS as q, isTransientTransportFailure as r, runCampaign as rt, clamp01 as s, readCachedCell as st, llmJudge as t, reserveFinalEvidence as tt, executeOptimizationMethod as u, computeManifestHash as ut, labelTrustRank as v, SearchRecorder as w, crowdedFrontierParent as x, aide as y, searchProposalExecution as z };
 
-//# sourceMappingURL=llm-judge-fhkFQL1N.js.map
+//# sourceMappingURL=llm-judge-3ncNcWNT.js.map