@tangle-network/agent-eval 0.215.1 → 0.216.1

package/dist/{search-kernel-BztlERLv.js → pareto-Cm6ndrWN.js}

@@ -1,90 +1,17 @@
-import { a as hashCanonical, i as compareCodeUnits, r as canonicalString } from "./canonical-BsZVgBhW.js";
-import { t as mulberry32 } from "./random-Dn5fPWkt.js";
-import { t as confidenceInterval } from "./descriptive-CnU8Yq29.js";
-import { c as wilson } from "./paired-binary-Q36bhn2R.js";
-import { n as DECISION_PAIRED_DELTA_STATISTIC } from "./paired-tests-jbwPdSz5.js";
-import { i as pairedDeltaTest, r as minimumPairsForPairedDeltaTest, t as decidePairedPromotion } from "./paired-promotion-decision-BN6IQTiu.js";
-import { a as SearchLedgerError } from "./search-ledger-file-BqOo-bVo.js";
-import { f as redactText } from "./redact-Dk1ZdJEm.js";
-import { f as searchUnitScores, l as searchCellId, t as FileSearchLedger } from "./search-ledger-d7V8o9Lk.js";
-import { t as acquireSingleRunLock } from "./single-run-lock-fVu3MZWH.js";
-//#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);
+import { a as hashCanonical, i as compareCodeUnits, r as canonicalString } from "./canonical-B2RqLofv.js";
+import { t as mulberry32 } from "./random-ByUSnV9w.js";
+import { t as confidenceInterval } from "./descriptive-DboxPZrG.js";
+import { c as wilson } from "./paired-binary-CvpFHfKZ.js";
+import { r as DECISION_PAIRED_DELTA_STATISTIC } from "./mean-DHoMiudD.js";
+import { i as pairedDeltaTest, r as minimumPairsForPairedDeltaTest, t as decidePairedPromotion } from "./paired-promotion-decision-DsAPYGCm.js";
+import { a as SearchLedgerError } from "./search-ledger-file-DDQUgvCg.js";
+import { c as redactText } from "./redact-B5xXKqQ3.js";
+import { l as searchUnitScores, p as USD_TOLERANCE, t as FileSearchLedger, u as searchCellId } from "./search-ledger-CVUGLDZp.js";
+import { t as acquireSingleRunLock } from "./single-run-lock-CV9Eyd_q.js";
+//#region src/statistics/normalize-signed-zero.ts
+/** Normalize IEEE negative zero before numerical evidence reaches canonical JSON. */
+function normalizeSignedZero(value) {
+	return value === 0 ? 0 : value;
 }
 //#endregion
 //#region src/campaign/estimate-node.ts
@@ -219,8 +146,8 @@ function estimateNodeFromCells(input) {
 	const spread = (method === "descriptive" || method === "bootstrap") && !indeterminate;
 	return {
 		...base,
-		delta: plain$1(maximize ? mean : -mean),
-		interval: spread ? maximize ? [plain$1(low), plain$1(high)] : [plain$1(-high), plain$1(-low)] : null,
+		delta: normalizeSignedZero(maximize ? mean : -mean),
+		interval: spread ? maximize ? [normalizeSignedZero(low), normalizeSignedZero(high)] : [normalizeSignedZero(-high), normalizeSignedZero(-low)] : null,
 		exactSignP: method === "descriptive" && !indeterminate ? test.pValue : null,
 		indeterminate
 	};
@@ -283,7 +210,7 @@ function searchPosterior(state, options = {}) {
 		nodes.push({
 			nodeId,
 			pairs: gains.length,
-			mean: mean === null ? null : plain$1(mean),
+			mean: mean === null ? null : normalizeSignedZero(mean),
 			variance: null
 		});
 	}
@@ -334,315 +261,110 @@ function sum(values) {
 	for (const value of values) total += value;
 	return total;
 }
-/** Canonical JSON has one zero; never hand it a negative one. */
-function plain$1(value) {
-	return value === 0 ? 0 : value;
-}
 //#endregion
-//#region src/search/lenses/shared.ts
+//#region src/paired-promotion-power.ts
 /**
-* Shared, pure helpers for `src/search/lenses/*`.
+* @module
+* Joint power of a configured {@link decidePairedPromotion} call, computed by
+* running that call on data drawn from a registered alternative.
 *
-* Every lens is a pure function of a `SearchStateView` (search-tree-design
-* §12): it reads no other record type and does no I/O. These helpers exist so
-* each lens states its own numbers instead of re-deriving thresholds; they
-* reuse agent-eval's own statistics and estimator revisions rather than
-* inventing new ones.
+* 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.
 */
-/** The search's own ranking split: selection when the search declares one,
-* else train. Matches `searchPolicyView` and `agent-eval search show`, so a
-* lens ranks nodes on exactly the split the search itself ranks them on. */
-function rankingSplit(state) {
-	const header = state.header;
-	return header && header.splits.selection.tasks.length > 0 ? "selection" : "train";
-}
-/** The smallest sample an exact one-sided sign test can resolve at 95%: the
-* same gate `NodeEstimate.method` uses for `insufficient`. */
-const INSUFFICIENT_FROM = minimumPairsForPairedDeltaTest(.95);
-function summarizeSamples(samples, seed) {
-	const n = samples.length;
-	const method = searchEstimateMethod(n);
-	if (method === "none") return {
-		n,
-		mean: null,
-		method,
-		interval: null,
-		intervalMethod: null
-	};
-	const mean = samples.reduce((a, b) => a + b, 0) / n;
-	if (method === "insufficient") return {
-		n,
-		mean,
-		method,
-		interval: null,
-		intervalMethod: null
-	};
-	const { lower, upper } = confidenceInterval([...samples], .95, seed === void 0 ? {} : { seed });
+/**
+* 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,
-		mean,
-		method,
-		interval: [lower, upper],
-		intervalMethod: "percentile-bootstrap-of-mean"
-	};
-}
-//#endregion
-//#region src/search/lenses/operator-yield.ts
-/**
-* `operatorYield(state)`: outcome counts and yield per known dollar, by the
-* operator each edge names (search-tree-design §12).
-*
-* A node counts once, under the operator of the edge that registered it. A
-* re-proposal (an edge into a node an earlier edge registered) adds a
-* proposal and a `reproposals` count to its operator, but no outcome and no
-* yield sample: it produced no new artifact and no new measurement, so
-* counting its node again would repeat one measurement as independent
-* evidence.
-*
-* "Yield" reuses `searchPosterior` (E3, `../../campaign/estimate-node`): its
-* per-node mean is already the node's improvement over the root, oriented so
-* larger is always better regardless of the objective's direction — this
-* lens adds no second orientation rule of its own. A child's sample is
-* `posteriorMean / screenCostUsd`: the gain over the known cost of producing
-* and screening the node, which is the operator's doing. That cost is the
-* node's share of its proposal (the candidate-generation operation's cost
-* split evenly over every child edge the operation recorded, re-proposals
-* included) plus its cells allocated before its first decision: the first
-* rung and the proposer's train feedback, which the allocator plans together
-* at admission. Cells a later rung or the claim adds come after an
-* `advanced` or `finalist` decision; they are the allocator's and the
-* claim's choice, not the operator's, so an operator whose children advance
-* is not charged for the measurement their success earned. A seed edge
-* proposed nothing, so the root's cost is its cells alone.
-*
-* A child enters the sample only when both numbers are known: the node
-* shares 2 or more units with the root (one shared unit is no estimate,
-* §6.4); the edge names a recorded proposal operation whose cost is known;
-* every screen cell has run and has a known cost (an unpriced or unrecorded
-* part never floors a node to an artificially cheap, inflated yield); and it
-* was not decided `invalid` (a judge integrity or admission failure: its
-* score is not evidence of improvement, and `editCredit` excludes such nodes
-* the same way). A $0-known-cost node is excluded from yield (division by
-* zero is not a yield), not treated as free.
-*/
-/** The operators an expansion may choose (`SearchExpansion.operator` in
-* `search-policy.ts`): every edge operator except `seed` (the search's own
-* start) and `derive` (a cross-search edge a proposer never chooses). */
-const EXPANSION_OPERATORS = [
-	"draft",
-	"improve",
-	"debug",
-	"merge"
-];
-/** The bandit's own gate: an operator's weight is used only once it has this
-* many yield-eligible outcomes; below it, the policy falls back to a fixed
-* weight for that operator. Same threshold `NodeEstimate.method` uses for
-* `insufficient` (`minimumPairsForPairedDeltaTest(0.95)` = 6). */
-const MIN_OUTCOMES_FOR_WEIGHT = 6;
-const YIELD_METHOD = "per registered node, searchPosterior's mean gain over the root divided by the known cost of producing and screening the node: its even share of the proposal operation's cost over the operation's child edges, plus its cells allocated before its first decision (first rung and train feedback; later rungs and the claim excluded); no sample when the node was decided invalid, shares fewer than 2 units with the root, or any part of that cost is unknown, unrecorded or zero";
-function operatorYield(state, options = {}) {
-	const split = options.split ?? rankingSplit(state);
-	const posteriorByNode = new Map(state.header && state.rootNodeId !== null ? searchPosterior(state, { split }).nodes.map((node) => [node.nodeId, node]) : []);
-	const grouped = /* @__PURE__ */ new Map();
-	const group = (operator) => {
-		let existing = grouped.get(operator);
-		if (!existing) {
-			existing = {
-				proposals: 0,
-				reproposals: 0,
-				outcomes: {
-					advanced: 0,
-					finalist: 0,
-					selected: 0,
-					pruned: 0,
-					rejected: 0,
-					invalid: 0,
-					undecided: 0
-				},
-				excluded: 0,
-				samples: []
-			};
-			grouped.set(operator, existing);
-		}
-		return existing;
-	};
-	const edges = state.edges();
-	const childEdges = /* @__PURE__ */ new Map();
-	for (const edge of edges) {
-		const operationId = edge.proposer?.operationId;
-		if (operationId) childEdges.set(operationId, (childEdges.get(operationId) ?? 0) + 1);
-	}
-	for (const edge of edges) {
-		const child = state.node(edge.childNodeId);
-		if (!child) continue;
-		const bucket = group(edge.operator);
-		bucket.proposals += 1;
-		if (child.edgeIds[0] !== edge.edgeId) {
-			bucket.reproposals += 1;
-			continue;
-		}
-		bucket.outcomes[statusKey(child.status)] += 1;
-		const posterior = posteriorByNode.get(child.nodeId);
-		const costUsd = screenCostUsd(state, child, edge, childEdges);
-		if (child.status === "invalid" || !posterior || posterior.mean === null || posterior.pairs < 2 || costUsd === null || costUsd <= 0) {
-			bucket.excluded += 1;
-			continue;
-		}
-		bucket.samples.push(posterior.mean / costUsd);
-	}
-	const rows = [...grouped.entries()].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([operator, bucket]) => ({
-		operator,
-		proposals: bucket.proposals,
-		reproposals: bucket.reproposals,
-		outcomes: bucket.outcomes,
-		excluded: bucket.excluded,
-		yield: summarizeSamples(bucket.samples)
-	}));
-	const signalValue = {};
-	for (const operator of EXPANSION_OPERATORS) {
-		const row = rows.find((r) => r.operator === operator);
-		signalValue[operator] = row && row.yield.n >= 6 && row.yield.mean !== null ? row.yield.mean : null;
-	}
-	return {
-		data: {
-			split,
-			method: YIELD_METHOD,
-			rows
-		},
-		signal: {
-			name: "operatorYield.weights",
-			value: signalValue
-		}
-	};
-}
-/** The known cost of producing and screening `node`, which `edge` registered;
-* null when any part of it is unknown. The screen ends at the node's first
-* decision: the allocator records `advanced` before it allocates a further
-* rung, and the claim decides `finalist` before it allocates test cells. */
-function screenCostUsd(state, node, edge, childEdges) {
-	let usd = 0;
-	if (edge.proposer !== null) {
-		const { operationId } = edge.proposer;
-		if (operationId === null) return null;
-		const operation = state.operation(operationId);
-		if (!operation?.recorded || !operation.costKnown) return null;
-		usd += operation.spentUsd / childEdges.get(operationId);
-	}
-	const screenEnd = node.decisions[0]?.sequence ?? Number.POSITIVE_INFINITY;
-	for (const cell of state.cells({ nodeId: node.nodeId })) {
-		if (cell.allocatedSequence > screenEnd) continue;
-		if (!cell.costKnown || cell.attempts === 0 && cell.cancelled === null) return null;
-		usd += cell.spentUsd;
-	}
-	return usd;
-}
-function statusKey(status) {
-	return status ?? "undecided";
-}
-//#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]))
-		}))
+		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]))
+		}))
 	};
 }
 /**
@@ -1363,92 +1085,633 @@ function pairedTest(input) {
 		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`;
+	const test = {
+		pairs,
+		confidence: input.confidence,
+		method: decision.method,
+		delta: normalizeSignedZero(input.maximize ? decision.delta : -decision.delta),
+		interval: input.maximize ? [normalizeSignedZero(decision.low), normalizeSignedZero(decision.high)] : [normalizeSignedZero(-decision.high), normalizeSignedZero(-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,
+		decision,
+		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(values) {
+	let total = 0;
+	for (const value of values) total += value;
+	return total / values.length;
+}
+function round(value) {
+	return Math.round(value * 1e4) / 1e4;
+}
+//#endregion
+//#region src/campaign/search-kernel-close.ts
+/** Final unclaimed selections and verification of the closed search receipt. */
+/** Decisions for a search without a held-out claim, derived before its ledger advances. */
+function unclaimedSearchDecisions(state, view, leader, context) {
+	const { split } = view;
+	const root = state.rootNodeId;
+	const leaderUnits = view.unitScores(leader).map((unit) => unit.unitId);
+	return state.nodes().filter((node) => !isTerminal(node)).map((node) => {
+		const scored = 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(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: context.rule,
+			reason: lead ? `the leader when the search stopped (${context.stopReason}): a budget decision on the ${split} split, which claims nothing` : !context.screened.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"
+		};
+	});
+}
+function closedSearchResult(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
+	};
+}
+function isTerminal(node) {
+	return node.status !== null && node.status !== "advanced";
+}
+/** 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",
+		parents: "a policy names at least one parent, and every parent finished its screen",
+		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"
+	})
+};
+/** The operation that holds the claim's plan. */
+const CLAIM_OPERATION = "claim";
+const ESTIMATE_MARGIN = 1.5;
+/** 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
+};
+/** 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;
+}
+//#endregion
+//#region src/campaign/search-kernel-claim.ts
+/** The sealed-test lifecycle: preflight, durable plan, cell allocation, and final claim. */
+var SearchKernelClaim = class {
+	host;
+	plan = null;
+	constructor(host) {
+		this.host = host;
+	}
+	/** Refuse an unclaimable search before its first paid cell starts. */
+	assertReady() {
+		const header = this.host.state.header;
+		const testTasks = header.splits.test.tasks.length;
+		if (testTasks === 0) return;
+		const refuse = (why) => {
+			throw new Error(`runSearch: search ${this.host.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.host.maxCellReservation();
+		const need = searchClaimReserveUsd({
+			testTasks,
+			reps: this.host.options.allocation.reps,
+			cellUsd
+		});
+		if (reservedClaimUsd + 1e-9 < 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.host.options.allocation.plan(this.host.state, this.host.state.rootNodeId, 0).length;
+		const screens = (this.host.options.proposer.childrenPerProposal ?? 1) * this.host.options.allocation.screenSize(this.host.state);
+		const round = this.host.operationReservation().usd + (rootCells + screens) * cellUsd;
+		if (maxUsd - reservedClaimUsd + 1e-9 < round) refuse(`its cap $${maxUsd} less the claim reserve $${reservedClaimUsd} does not cover the root and one screening round ($${round})`);
+	}
+	/** Recover the exact durable claim design left by an earlier process. */
+	async restore() {
+		const operation = this.host.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.host.recorder.readBlob(ref);
+		if (!operation.recorded) await this.recordClaimOperation();
+		this.plan = plan;
+		this.host.stopReason = plan.stopReason;
+	}
+	async begin() {
+		await this.host.refresh();
+		const stopReason = this.host.stopReason ?? "converged";
+		const header = this.host.state.header;
+		const reps = this.host.options.allocation.reps;
+		const plan = planSearchClaim(this.host.state, {
+			stopReason,
+			reps,
+			affordable: (finalists) => {
+				const placed = this.claimCells(finalists, this.host.state.rootNodeId);
+				const hold = placed.reduce((sum, cell) => sum + cell.reservation.usd, 0);
+				const { headroomUsd, claimReserveUsd } = this.host.state.budget;
+				const { maxCells } = header.budget;
+				return (headroomUsd === null || hold <= headroomUsd + claimReserveUsd + 1e-9) && (maxCells === null || this.host.state.audit.cells.allocated + placed.length <= maxCells);
+			}
+		});
+		await this.host.recorder.startOperation({
+			operationId: CLAIM_OPERATION,
+			operationKind: "selection",
+			reservation: null,
+			artifacts: [this.host.recorder.blob("claim-plan", plan)]
+		});
+		await this.recordClaimOperation();
+		this.plan = plan;
+		this.host.stopReason = stopReason;
+		await this.apply(plan);
+	}
+	async recordClaimOperation() {
+		await this.host.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.host.refresh();
+	}
+	/** Decide finalists and allocate all interleaved test cells before any starts. Idempotent. */
+	async apply(plan) {
+		const root = this.host.state.rootNodeId;
+		const bases = plan.finalists.map((finalist) => estimateNode(this.host.state, finalist.nodeId, {
+			against: root,
+			split: "selection"
+		}));
+		for (const [rank, finalist] of plan.finalists.entries()) await this.host.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.host.refresh();
+		if (plan.test !== "run") return;
+		const missing = this.claimCells(plan.finalists.length, root, plan).map((cell) => ({
+			...cell,
+			cellId: searchCellId(this.host.recorder.searchId, cell.nodeId, cell.plan.taskId, "test", cell.plan.rep)
+		})).filter((cell) => !this.host.state.cell(cell.cellId));
+		for (const cell of missing) await this.host.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.host.refresh();
+		for (const cell of missing) this.host.enqueue(this.host.state.cell(cell.cellId));
+	}
+	claimCells(finalists, root, plan) {
+		const header = this.host.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.host.options.allocation.reps; rep++) for (const nodeId of arms) {
+			const cellPlan = {
+				taskId: task.taskId,
+				split: "test",
+				rep,
+				stage: "claim"
+			};
+			const laneName = this.host.options.executor.place({
+				...cellPlan,
+				nodeId
+			});
+			const lane = this.host.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.host.cellReservation(lane)
+			});
+		}
+		return cells;
+	}
+	async close(plan) {
+		const { claim, decisions } = decideSearchClaim(this.host.state, plan);
+		const decided = new Set(decisions.map((decision) => decision.nodeId));
+		const root = this.host.state.rootNodeId;
+		const rest = this.host.state.nodes().filter((node) => !decided.has(node.nodeId) && !isTerminal(node)).map((node) => {
+			const scored = this.host.state.scoredCells(node.nodeId, "selection").length > 0;
+			return {
+				nodeId: node.nodeId,
+				decision: { status: "rejected" },
+				basis: scored ? estimateNode(this.host.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.host.recorder.decideNode(decision);
+		await this.host.recorder.close({
+			reason: plan.stopReason,
+			claim
+		});
+		await this.host.refresh();
+	}
+};
+//#endregion
+//#region src/search/lenses/shared.ts
+/**
+* Shared, pure helpers for `src/search/lenses/*`.
+*
+* Every lens is a pure function of a `SearchStateView` (search-tree-design
+* §12): it reads no other record type and does no I/O. These helpers exist so
+* each lens states its own numbers instead of re-deriving thresholds; they
+* reuse agent-eval's own statistics and estimator revisions rather than
+* inventing new ones.
+*/
+/** The search's own ranking split: selection when the search declares one,
+* else train. Matches `searchPolicyView` and `agent-eval search show`, so a
+* lens ranks nodes on exactly the split the search itself ranks them on. */
+function rankingSplit(state) {
+	const header = state.header;
+	return header && header.splits.selection.tasks.length > 0 ? "selection" : "train";
+}
+/** The smallest sample an exact one-sided sign test can resolve at 95%: the
+* same gate `NodeEstimate.method` uses for `insufficient`. */
+const INSUFFICIENT_FROM = minimumPairsForPairedDeltaTest(.95);
+function summarizeSamples(samples, seed) {
+	const n = samples.length;
+	const method = searchEstimateMethod(n);
+	if (method === "none") return {
+		n,
+		mean: null,
+		method,
+		interval: null,
+		intervalMethod: null
+	};
+	const mean = samples.reduce((a, b) => a + b, 0) / n;
+	if (method === "insufficient") return {
+		n,
+		mean,
+		method,
+		interval: null,
+		intervalMethod: null
+	};
+	const { lower, upper } = confidenceInterval([...samples], .95, seed === void 0 ? {} : { seed });
+	return {
+		n,
+		mean,
+		method,
+		interval: [lower, upper],
+		intervalMethod: "percentile-bootstrap-of-mean"
+	};
+}
+//#endregion
+//#region src/search/lenses/operator-yield.ts
+/**
+* `operatorYield(state)`: outcome counts and yield per known dollar, by the
+* operator each edge names (search-tree-design §12).
+*
+* A node counts once, under the operator of the edge that registered it. A
+* re-proposal (an edge into a node an earlier edge registered) adds a
+* proposal and a `reproposals` count to its operator, but no outcome and no
+* yield sample: it produced no new artifact and no new measurement, so
+* counting its node again would repeat one measurement as independent
+* evidence.
+*
+* "Yield" reuses `searchPosterior` (E3, `../../campaign/estimate-node`): its
+* per-node mean is already the node's improvement over the root, oriented so
+* larger is always better regardless of the objective's direction — this
+* lens adds no second orientation rule of its own. A child's sample is
+* `posteriorMean / screenCostUsd`: the gain over the known cost of producing
+* and screening the node, which is the operator's doing. That cost is the
+* node's share of its proposal (the candidate-generation operation's cost
+* split evenly over every child edge the operation recorded, re-proposals
+* included) plus its cells allocated before its first decision: the first
+* rung and the proposer's train feedback, which the allocator plans together
+* at admission. Cells a later rung or the claim adds come after an
+* `advanced` or `finalist` decision; they are the allocator's and the
+* claim's choice, not the operator's, so an operator whose children advance
+* is not charged for the measurement their success earned. A seed edge
+* proposed nothing, so the root's cost is its cells alone.
+*
+* A child enters the sample only when both numbers are known: the node
+* shares 2 or more units with the root (one shared unit is no estimate,
+* §6.4); the edge names a recorded proposal operation whose cost is known;
+* every screen cell has run and has a known cost (an unpriced or unrecorded
+* part never floors a node to an artificially cheap, inflated yield); and it
+* was not decided `invalid` (a judge integrity or admission failure: its
+* score is not evidence of improvement, and `editCredit` excludes such nodes
+* the same way). A $0-known-cost node is excluded from yield (division by
+* zero is not a yield), not treated as free.
+*/
+/** The operators an expansion may choose (`SearchExpansion.operator` in
+* `search-policy.ts`): every edge operator except `seed` (the search's own
+* start) and `derive` (a cross-search edge a proposer never chooses). */
+const EXPANSION_OPERATORS = [
+	"draft",
+	"improve",
+	"debug",
+	"merge"
+];
+/** The bandit's own gate: an operator's weight is used only once it has this
+* many yield-eligible outcomes; below it, the policy falls back to a fixed
+* weight for that operator. Same threshold `NodeEstimate.method` uses for
+* `insufficient` (`minimumPairsForPairedDeltaTest(0.95)` = 6). */
+const MIN_OUTCOMES_FOR_WEIGHT = 6;
+const YIELD_METHOD = "per registered node, searchPosterior's mean gain over the root divided by the known cost of producing and screening the node: its even share of the proposal operation's cost over the operation's child edges, plus its cells allocated before its first decision (first rung and train feedback; later rungs and the claim excluded); no sample when the node was decided invalid, shares fewer than 2 units with the root, or any part of that cost is unknown, unrecorded or zero";
+function operatorYield(state, options = {}) {
+	const split = options.split ?? rankingSplit(state);
+	const posteriorByNode = new Map(state.header && state.rootNodeId !== null ? searchPosterior(state, { split }).nodes.map((node) => [node.nodeId, node]) : []);
+	const grouped = /* @__PURE__ */ new Map();
+	const group = (operator) => {
+		let existing = grouped.get(operator);
+		if (!existing) {
+			existing = {
+				proposals: 0,
+				reproposals: 0,
+				outcomes: {
+					advanced: 0,
+					finalist: 0,
+					selected: 0,
+					pruned: 0,
+					rejected: 0,
+					invalid: 0,
+					undecided: 0
+				},
+				excluded: 0,
+				samples: []
+			};
+			grouped.set(operator, existing);
+		}
+		return existing;
+	};
+	const edges = state.edges();
+	const childEdges = /* @__PURE__ */ new Map();
+	for (const edge of edges) {
+		const operationId = edge.proposer?.operationId;
+		if (operationId) childEdges.set(operationId, (childEdges.get(operationId) ?? 0) + 1);
+	}
+	for (const edge of edges) {
+		const child = state.node(edge.childNodeId);
+		if (!child) continue;
+		const bucket = group(edge.operator);
+		bucket.proposals += 1;
+		if (child.edgeIds[0] !== edge.edgeId) {
+			bucket.reproposals += 1;
+			continue;
+		}
+		bucket.outcomes[statusKey(child.status)] += 1;
+		const posterior = posteriorByNode.get(child.nodeId);
+		const costUsd = screenCostUsd(state, child, edge, childEdges);
+		if (child.status === "invalid" || !posterior || posterior.mean === null || posterior.pairs < 2 || costUsd === null || costUsd <= 0) {
+			bucket.excluded += 1;
+			continue;
+		}
+		bucket.samples.push(posterior.mean / costUsd);
+	}
+	const rows = [...grouped.entries()].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([operator, bucket]) => ({
+		operator,
+		proposals: bucket.proposals,
+		reproposals: bucket.reproposals,
+		outcomes: bucket.outcomes,
+		excluded: bucket.excluded,
+		yield: summarizeSamples(bucket.samples)
+	}));
+	const signalValue = {};
+	for (const operator of EXPANSION_OPERATORS) {
+		const row = rows.find((r) => r.operator === operator);
+		signalValue[operator] = row && row.yield.n >= 6 && row.yield.mean !== null ? row.yield.mean : null;
+	}
+	return {
+		data: {
+			split,
+			method: YIELD_METHOD,
+			rows
+		},
+		signal: {
+			name: "operatorYield.weights",
+			value: signalValue
+		}
+	};
+}
+/** The known cost of producing and screening `node`, which `edge` registered;
+* null when any part of it is unknown. The screen ends at the node's first
+* decision: the allocator records `advanced` before it allocates a further
+* rung, and the claim decides `finalist` before it allocates test cells. */
+function screenCostUsd(state, node, edge, childEdges) {
+	let usd = 0;
+	if (edge.proposer !== null) {
+		const { operationId } = edge.proposer;
+		if (operationId === null) return null;
+		const operation = state.operation(operationId);
+		if (!operation?.recorded || !operation.costKnown) return null;
+		usd += operation.spentUsd / childEdges.get(operationId);
+	}
+	const screenEnd = node.decisions[0]?.sequence ?? Number.POSITIVE_INFINITY;
+	for (const cell of state.cells({ nodeId: node.nodeId })) {
+		if (cell.allocatedSequence > screenEnd) continue;
+		if (!cell.costKnown || cell.attempts === 0 && cell.cancelled === null) return null;
+		usd += cell.spentUsd;
+	}
+	return usd;
+}
+function statusKey(status) {
+	return status ?? "undecided";
+}
+//#endregion
+//#region src/campaign/search-kernel-policy-view.ts
+/** Policy observations and divergence decisions from train and selection evidence. */
+/**
+* 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 ?? 3;
+	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";
+	let nodes;
+	let operatorWeights;
+	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
+		}),
+		nodes: () => {
+			nodes ??= policyNodes(state);
+			return nodes;
+		},
+		get posterior() {
+			let posterior = POSTERIORS.get(state);
+			if (!posterior) {
+				posterior = searchPosterior(state, { split });
+				POSTERIORS.set(state, posterior);
+			}
+			return posterior;
+		},
+		get operatorWeights() {
+			operatorWeights ??= operatorYield(state, { split }).signal.value;
+			return operatorWeights;
+		}
+	};
+}
+/** One posterior per ledger state: a state view is retired when the ledger
+* moves on, so the view it was computed from names the sequence. */
+const POSTERIORS = /* @__PURE__ */ new WeakMap();
+/** Every node whose edge is recorded, with its lineage and its defects outside
+* the test split. */
+function policyNodes(state) {
+	const nodes = [];
+	for (const node of state.nodes()) {
+		const edgeId = node.edgeIds[0];
+		if (edgeId === void 0) continue;
+		let outcomes = 0;
+		let defects = 0;
+		for (const cell of state.cells({ nodeId: node.nodeId })) {
+			if (cell.split === "test" || !cell.final) continue;
+			outcomes += 1;
+			if (cell.outcome === "failed") defects += 1;
+		}
+		const edge = state.edge(edgeId);
+		nodes.push({
+			nodeId: node.nodeId,
+			ordinal: node.ordinal,
+			parent: node.primaryParentId,
+			operator: edge.operator,
+			rule: edge.selection?.rule ?? null,
+			children: node.children,
+			status: node.status,
+			outcomes,
+			defects
+		});
+	}
+	return nodes;
+}
+/**
+* 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 {
-		test,
-		decision,
-		promote,
-		improvement: decision.delta,
-		why
+		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 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(values) {
-	let total = 0;
-	for (const value of values) total += value;
-	return total / values.length;
-}
-function round(value) {
+function round4(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",
-		parents: "a policy names at least one parent, and every parent finished its screen",
-		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;
-}
+//#endregion
+//#region src/campaign/search-kernel-runner.ts
+/** Event loop and mutable scheduling state for one ledger-backed search. */
 var SearchKernel = class {
 	options;
 	recorder;
@@ -1483,11 +1746,11 @@ var SearchKernel = class {
 	stopReason = null;
 	failure = null;
 	/** The claim's design once expansion stopped; the search then only claims. */
-	claimPlan = null;
+	claim;
 	constructor(options) {
 		this.options = options;
 		this.recorder = options.recorder;
-		this.maxAttempts = options.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+		this.maxAttempts = options.maxAttempts ?? 3;
 		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;
@@ -1509,6 +1772,26 @@ var SearchKernel = class {
 			});
 		}
 		if (this.lanes.size === 0) throw new TypeError("runSearch: the executor declares no lane");
+		const kernel = this;
+		this.claim = new SearchKernelClaim({
+			get state() {
+				return kernel.state;
+			},
+			get stopReason() {
+				return kernel.stopReason;
+			},
+			set stopReason(reason) {
+				kernel.stopReason = reason;
+			},
+			recorder: this.recorder,
+			options,
+			lanes: this.lanes,
+			refresh: () => this.refresh(),
+			cellReservation: (lane) => this.cellReservation(this.lanes.get(lane.name)),
+			maxCellReservation: () => this.maxCellReservation(),
+			operationReservation: () => this.operationReservation(),
+			enqueue: (cell) => this.enqueue(cell)
+		});
 	}
 	async run() {
 		const { ledger } = this.recorder;
@@ -1524,7 +1807,7 @@ var SearchKernel = class {
 		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();
+		if (this.state.closed) return closedSearchResult(this.state);
 		await this.restore();
 		const { signal } = this.options;
 		const onAbort = () => {
@@ -1534,10 +1817,10 @@ var SearchKernel = class {
 		};
 		signal?.addEventListener("abort", onAbort, { once: true });
 		try {
-			if (this.claimPlan) await this.applyClaimPlan(this.claimPlan);
+			if (this.claim.plan) await this.claim.apply(this.claim.plan);
 			await this.loop();
-			if (!this.failure && !this.claimPlan && this.state.header.splits.test.tasks.length > 0) {
-				await this.beginClaim();
+			if (!this.failure && !this.claim.plan && this.state.header.splits.test.tasks.length > 0) {
+				await this.claim.begin();
 				await this.loop();
 			}
 		} finally {
@@ -1545,7 +1828,7 @@ var SearchKernel = class {
 		}
 		if (this.failure) throw this.failure.error;
 		await this.close();
-		return this.closedResult();
+		return closedSearchResult(this.state);
 	}
 	async restore() {
 		const rootInput = this.options.codec.node(this.recorder, this.options.root);
@@ -1568,8 +1851,8 @@ var SearchKernel = class {
 		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();
+		if (this.state.audit.cells.allocated === 0) this.claim.assertReady();
+		await this.claim.restore();
 		const recorded = [];
 		for (let expansion = 0;; expansion++) {
 			const operationId = `expand-${expansion}`;
@@ -1613,7 +1896,7 @@ var SearchKernel = class {
 			this.enqueue(cell);
 			if (cell.stage !== "claim") this.pending.set(cell.nodeId, (this.pending.get(cell.nodeId) ?? 0) + 1);
 		}
-		if (this.claimPlan) return;
+		if (this.claim.plan) 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()) {
@@ -1623,49 +1906,6 @@ var SearchKernel = class {
 		}
 		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) {
@@ -1801,7 +2041,7 @@ var SearchKernel = class {
 	* 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;
+		if (this.claim.plan || 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);
 	}
 	/**
@@ -1811,7 +2051,7 @@ var SearchKernel = class {
 	* becomes a parent; any other node is screened. Returns whether it was.
 	*/
 	async screenDone(nodeId) {
-		if (!this.claimPlan && !this.screenedSet.has(nodeId) && this.state.node(nodeId).status !== "advanced") {
+		if (!this.claim.plan && !this.screenedSet.has(nodeId) && this.state.node(nodeId).status !== "advanced") {
 			const divergence = searchDivergence(this.state, nodeId);
 			if (divergence) {
 				await this.recorder.decideNode({
@@ -1869,7 +2109,7 @@ var SearchKernel = class {
 		});
 		const hold = placed.reduce((sum, { reservation }) => sum + reservation.usd, 0);
 		const { headroomUsd } = this.state.budget;
-		if (headroomUsd !== null && hold > headroomUsd + USD_TOLERANCE) return false;
+		if (headroomUsd !== null && hold > headroomUsd + 1e-9) 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);
@@ -1883,143 +2123,25 @@ var SearchKernel = class {
 			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)
-			});
+		for (const { plan } of placed) {
+			const cellId = searchCellId(this.recorder.searchId, nodeId, plan.taskId, plan.split, plan.rep);
+			this.enqueue(this.state.cell(cellId));
 		}
-		return cells;
+		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;
 	}
 	async cancelQueued(reason) {
 		for (const lane of this.lanes.values()) for (const [priority, queue] of lane.queues.entries()) {
@@ -2061,7 +2183,7 @@ var SearchKernel = class {
 		const children = this.options.proposer.childrenPerProposal ?? 1;
 		const need = operation.usd + children * screen * this.maxCellReservation();
 		const { headroomUsd } = this.state.budget;
-		if (headroomUsd !== null && (need > headroomUsd + USD_TOLERANCE || this.overCap())) return "budget";
+		if (headroomUsd !== null && (need > headroomUsd + 1e-9 || 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";
@@ -2218,32 +2340,16 @@ var SearchKernel = class {
 		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);
+		if (this.claim.plan) {
+			await this.claim.close(this.claim.plan);
 			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"
-			};
+		const decisions = unclaimedSearchDecisions(this.state, view, leader, {
+			rule: this.options.policy.name,
+			stopReason: this.stopReason,
+			screened: this.screenedSet
 		});
 		for (const decision of decisions) await this.recorder.decideNode(decision);
 		await this.recorder.close({
@@ -2252,47 +2358,6 @@ var SearchKernel = class {
 		});
 		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,
@@ -2359,136 +2424,8 @@ var SearchKernel = class {
 		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";
-	let nodes;
-	let operatorWeights;
-	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
-		}),
-		nodes: () => {
-			nodes ??= policyNodes(state);
-			return nodes;
-		},
-		get posterior() {
-			let posterior = POSTERIORS.get(state);
-			if (!posterior) {
-				posterior = searchPosterior(state, { split });
-				POSTERIORS.set(state, posterior);
-			}
-			return posterior;
-		},
-		get operatorWeights() {
-			operatorWeights ??= operatorYield(state, { split }).signal.value;
-			return operatorWeights;
-		}
-	};
-}
-/** One posterior per ledger state: a state view is retired when the ledger
-* moves on, so the view it was computed from names the sequence. */
-const POSTERIORS = /* @__PURE__ */ new WeakMap();
-/** Every node whose edge is recorded, with its lineage and its defects outside
-* the test split. */
-function policyNodes(state) {
-	const nodes = [];
-	for (const node of state.nodes()) {
-		const edgeId = node.edgeIds[0];
-		if (edgeId === void 0) continue;
-		let outcomes = 0;
-		let defects = 0;
-		for (const cell of state.cells({ nodeId: node.nodeId })) {
-			if (cell.split === "test" || !cell.final) continue;
-			outcomes += 1;
-			if (cell.outcome === "failed") defects += 1;
-		}
-		const edge = state.edge(edgeId);
-		nodes.push({
-			nodeId: node.nodeId,
-			ordinal: node.ordinal,
-			parent: node.primaryParentId,
-			operator: edge.operator,
-			rule: edge.selection?.rule ?? null,
-			children: node.children,
-			status: node.status,
-			outcomes,
-			defects
-		});
-	}
-	return nodes;
-}
-/**
-* 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;
+	if (costs.length < 20) 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;
@@ -2512,6 +2449,91 @@ function errorMessage(error) {
 	return text.trim().length > 0 ? text : "the proposer failed without a message";
 }
 //#endregion
-export { searchCellSetDigest as C, dominates as D, seedFromDigest as E, paretoFrontier as O, estimateNodeFromCells as S, searchPosterior as T, INSUFFICIENT_FROM as _, searchPolicyView as a, SEARCH_ESTIMATOR as b, planSearchClaim as c, verifySearchClaim as d, pairedPromotionPower as f, operatorYield as g, MIN_OUTCOMES_FOR_WEIGHT as h, searchExpansionIndex as i, paretoFrontierWithCrowding as k, searchClaimDecision as l, EXPANSION_OPERATORS as m, runSearch as n, SEARCH_CLAIM_RULE as o, requiredPairsForPairedPromotion as p, searchDivergence as r, decideSearchClaim as s, SEARCH_KERNEL_SOURCE as t, searchClaimReserveUsd as u, rankingSplit as v, searchEstimateMethod as w, estimateNode as x, summarizeSamples as y };
+//#region src/campaign/search-kernel.ts
+/** Run a search to its close, or continue one from its ledger. */
+async function runSearch(options) {
+	return new SearchKernel(options).run();
+}
+//#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
+export { normalizeSignedZero as A, SEARCH_ESTIMATOR as C, searchEstimateMethod as D, searchCellSetDigest as E, searchPosterior as O, requiredPairsForPairedPromotion as S, estimateNodeFromCells as T, planSearchClaim as _, searchDivergence as a, verifySearchClaim as b, MIN_OUTCOMES_FOR_WEIGHT as c, rankingSplit as d, summarizeSamples as f, decideSearchClaim as g, SEARCH_CLAIM_RULE as h, runSearch as i, seedFromDigest as k, operatorYield as l, searchExpansionIndex as m, paretoFrontier as n, searchPolicyView as o, SEARCH_KERNEL_SOURCE as p, paretoFrontierWithCrowding as r, EXPANSION_OPERATORS as s, dominates as t, INSUFFICIENT_FROM as u, searchClaimDecision as v, estimateNode as w, pairedPromotionPower as x, searchClaimReserveUsd as y };
 
-//# sourceMappingURL=search-kernel-BztlERLv.js.map
+//# sourceMappingURL=pareto-Cm6ndrWN.js.map