@tangle-network/agent-eval 0.192.0 → 0.193.0

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

@@ -2,23 +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 { n as DECISION_PAIRED_DELTA_STATISTIC } from "./paired-tests-C8iCsioC.js";
-import { i as pairedDeltaTest, r as minimumPairsForPairedDeltaTest, t as decidePairedPromotion } from "./paired-promotion-decision-6cn3bLc3.js";
-import { a as heldoutSignificance, i as dimensionRegressions, o as pairHoldout } from "./statistical-heldout-GcLIPxk4.js";
+import { v as wilson } from "./paired-arms-JSDcs2zx.js";
+import { t as decidePairedPromotion } from "./paired-promotion-decision-DTKl6-G8.js";
+import { a as heldoutSignificance, i as dimensionRegressions, o as pairHoldout } from "./statistical-heldout-DANVmyug.js";
 import { i as modelHasSnapshot, l as searchCellRunId } from "./run-record-BRlM99rX.js";
 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-DcQiYhJI.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 { m as mapConcurrent } from "./journal-DvKCvjty.js";
 import { t as deepFreezeCanonicalJson } from "./deep-freeze-CurcOQg3.js";
-import { a as SearchLedgerError } from "./search-ledger-file-DY0AXX3W.js";
 import { C as fsCampaignStorage, S as createRunCostLedger, g as isRecord, h as isExternalTextCandidate, x as acquireSingleRunLock } from "./external-optimizer-subprocess-kbqC-iWf.js";
 import { r as summarizeEvaluationUnits, t as defineEvaluationClaim } from "./claim-V9Zqbq0J.js";
 import { f as redactText, n as REDACTION_VERSION, o as detectCredential, s as detectPersonalData } from "./redact-B7rt9Zot.js";
 import { t as detectRewardHacking } from "./reward-hacking-D0XwhVWE.js";
 import { n as assertProposalFindings, t as combineAbortSignals } from "./abort-signal-CtzAM_sJ.js";
-import { a as validateSearchLedgerEvent, d as searchTaskSetDigest, f as searchUnitScores, i as replaySearchLedgerText, l as searchCellId, n as openSearchLedger, t as FileSearchLedger, u as searchNodeId } from "./search-ledger-Ck7tok0h.js";
+import { a as validateSearchLedgerEvent, d as searchTaskSetDigest, i as replaySearchLedgerText, l as searchCellId, n as openSearchLedger, t as FileSearchLedger, u as searchNodeId } from "./search-ledger-CJiAEU3j.js";
+import { c as seedFromDigest, i as estimateNode, n as searchProposerView, s as searchPosterior, t as renderSearchSummary } from "./search-summary-BhY8p0Av.js";
 import { d as stripFencedJson, o as costReceiptFromLlm, s as costReceiptFromLlmError, u as maximumChargeForLlmRequest } from "./llm-client-KYQBh9C8.js";
 import { createHash } from "node:crypto";
 import { writeFileSync } from "node:fs";
@@ -1164,8 +1164,8 @@ function detectCalibrationDrift(runs, opts) {
 				alpha,
 				recentN: recent.length,
 				historyN: historical.length,
-				recentMean: mean$2(recent),
-				historyMean: mean$2(historical)
+				recentMean: mean$3(recent),
+				historyMean: mean$3(historical)
 			}
 		}],
 		evaluation: {
@@ -1402,7 +1402,7 @@ function chiSquareCritical(df, alpha) {
 	}
 	return TABLE[10][idx];
 }
-function mean$2(xs) {
+function mean$3(xs) {
 	if (xs.length === 0) return 0;
 	return xs.reduce((s, x) => s + x, 0) / xs.length;
 }
@@ -2559,249 +2559,757 @@ function uniform(options = {}) {
 	};
 	return {
 		name: reps === 1 ? "uniform" : `uniform(reps=${reps})`,
+		reps,
 		plan: (state, nodeId) => cells(state, nodeId === state.rootNodeId),
 		screenSize: (state) => cells(state, false).length
 	};
 }
 //#endregion
-//#region src/campaign/estimate-node.ts
+//#region src/paired-promotion-power.ts
 /**
-* Per-node statistics of a search.
+* @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.
 *
-* `estimateNode` is the one paired contrast of two nodes: it averages each
-* node's cells inside their units, pairs the units both nodes scored, and runs
-* `pairedDeltaTest` on the per-unit deltas. `estimateNodeFromCells` is the same
-* computation over cells a caller already holds, such as rows a server read
-* from its database. The bootstrap seed comes from `cellSetDigest`, the digest
-* of exactly the cells used, so a producer and a verifier that hold the same
-* cells report the same bits.
+* 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.
 *
-* `searchPosterior` gives every node a normal posterior on its improvement over
-* the root, which expansion policies sample parents from. Its numbers steer
-* spend and claim nothing.
+* 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.
 */
-const CONFIDENCE = .95;
-const RESAMPLES = 2e3;
-/** 6 at 95 %: the smallest sample an exact one-sided sign test can resolve. */
-const DESCRIPTIVE_FROM = minimumPairsForPairedDeltaTest(CONFIDENCE);
-/** The estimator every `NodeEstimate` names. */
-const SEARCH_ESTIMATOR = {
-	uri: "npm:@tangle-network/agent-eval#estimateNode",
-	revision: hashCanonical({
-		name: "tangle.estimate-node.2026-09",
-		unit: "mean of the unit’s scored cells, summed in cellId order",
-		pairing: "units both nodes scored, in unitId order",
-		statistic: DECISION_PAIRED_DELTA_STATISTIC,
-		interval: "percentile paired bootstrap",
-		confidence: CONFIDENCE,
-		resamples: RESAMPLES,
-		rng: "mulberry32",
-		seed: "the first 32 bits of cellSetDigest",
-		signTest: "exact, one-sided toward improvement in the objective direction",
-		methods: {
-			none: "below 2 pairs",
-			insufficient: `below ${DESCRIPTIVE_FROM} pairs`,
-			descriptive: `below 20 pairs`,
-			bootstrap: `from 20 pairs`
-		},
-		indeterminate: "every paired delta equal: no interval and no sign p"
-	})
-};
-/** The method a paired sample of `pairs` units supports. */
-function searchEstimateMethod(pairs) {
-	if (pairs < 2) return "none";
-	if (pairs < DESCRIPTIVE_FROM) return "insufficient";
-	if (pairs < 20) return "descriptive";
-	return "bootstrap";
-}
 /**
-* Digest of the cells an estimate reads, with the contrast they serve. Cells
-* are listed in cellId order, so the digest names the set, not the order it
-* was read in.
+* Joint power of the configured calls at `n` under the registered alternative:
+* the fraction of simulated data sets on which every call promotes.
 */
-function searchCellSetDigest(input) {
-	const list = (cells) => [...cells].sort((left, right) => compareCodeUnits(left.cellId, right.cellId)).map((cell) => [
-		cell.cellId,
-		cell.unitId,
-		cell.attempt,
-		cell.score
-	]);
-	return hashCanonical({
-		contrast: [input.nodeId, input.against],
-		split: input.split,
-		nodeCells: list(input.nodeCells),
-		againstCells: list(input.againstCells)
-	});
+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]))
+		}))
+	};
 }
 /**
-* The paired contrast of `nodeId` against `against` on the units both scored.
-*
-* `delta` is the mean per-unit difference, node minus `against`, in the
-* metric's own units; for a `minimize` objective an improvement is negative.
-* The exact sign test is one-sided toward improvement in the objective's
-* direction. Unscored cells (errored, cancelled or in flight) are absent from
-* the inputs, never zero.
-*
-* - `none` (0 or 1 pair): no delta.
-* - `insufficient` (2 to 5): the delta only.
-* - `descriptive` (6 to 19): the bootstrap interval as spread, and the sign-test p.
-* - `bootstrap` (20 or more): the decision-grade bootstrap interval.
-*
-* When every paired delta is equal the interval would have zero width, which
-* is an absence of evidence; the estimate is then `indeterminate` and carries
-* neither an interval nor a p-value.
+* 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 estimateNodeFromCells(input) {
-	const { nodeId, against, split, direction } = input;
-	if (nodeId === against) throw new SearchLedgerError(`node ${nodeId} cannot be estimated against itself`);
-	assertDistinctCells([...input.nodeCells, ...input.againstCells], nodeId, against);
-	const cellSetDigest = searchCellSetDigest(input);
-	const nodeUnits = searchUnitScores(input.nodeCells);
-	const { node, other } = pairUnits(nodeUnits, unitMeans(searchUnitScores(input.againstCells)));
-	const pairs = node.length;
-	const method = searchEstimateMethod(pairs);
-	const base = {
-		against,
-		split,
-		units: nodeUnits.length,
-		pairs,
-		method,
-		cellSetDigest,
-		estimator: SEARCH_ESTIMATOR
+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
 	};
-	if (method === "none") return {
-		...base,
-		delta: null,
-		interval: null,
-		exactSignP: null,
-		indeterminate: false
+}
+/** 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 maximize = direction === "maximize";
-	const test = pairedDeltaTest(maximize ? other : node, maximize ? node : other, {
-		statistic: DECISION_PAIRED_DELTA_STATISTIC,
-		confidence: CONFIDENCE,
-		resamples: RESAMPLES,
-		seed: seedFromDigest(cellSetDigest)
-	});
-	const { mean, low, high } = test.bootstrap;
-	const indeterminate = test.indeterminate;
-	const spread = (method === "descriptive" || method === "bootstrap") && !indeterminate;
+	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 {
-		...base,
-		delta: plain(maximize ? mean : -mean),
-		interval: spread ? maximize ? [plain(low), plain(high)] : [plain(-high), plain(-low)] : null,
-		exactSignP: method === "descriptive" && !indeterminate ? test.pValue : null,
-		indeterminate
+		control,
+		candidate,
+		controlPass,
+		candidatePass
 	};
 }
-/**
-* `estimateNodeFromCells` over the cells a search state holds: `nodeId`
-* against `against` on one split, in the direction the search's objective
-* declares.
-*/
-function estimateNode(state, nodeId, options) {
-	const header = state.header;
-	if (!header) throw new SearchLedgerError(`search ${state.searchId} has not been opened`);
-	for (const id of [nodeId, options.against]) if (!state.hasNode(id)) throw new SearchLedgerError(`node ${id} is not in search ${state.searchId}`);
-	return estimateNodeFromCells({
-		nodeId,
-		against: options.against,
-		split: options.split,
-		direction: header.objective.direction,
-		nodeCells: state.scoredCells(nodeId, options.split),
-		againstCells: state.scoredCells(options.against, options.split)
+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 posterior every node's parent-selection draw uses. Each node's mean is
-* its improvement over the root on shared units; its variance is the search's
-* pooled between-unit variance divided by its unit count, so a node measured
-* on one unit has a wide posterior rather than none. The root is the reference
-* and sits at exactly 0.
+* 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.
 */
-function searchPosterior(state, options = {}) {
-	const split = options.split ?? "selection";
-	const header = state.header;
-	if (!header) throw new SearchLedgerError(`search ${state.searchId} has not been opened`);
-	const rootNodeId = state.rootNodeId;
-	if (rootNodeId === null) throw new SearchLedgerError(`search ${state.searchId} has no root node yet`);
-	const sign = header.objective.direction === "maximize" ? 1 : -1;
-	const root = searchUnitScores(state.scoredCells(rootNodeId, split));
-	const rootMeans = unitMeans(root);
-	const nodes = [];
-	let squares = 0;
-	let degreesOfFreedom = 0;
-	for (const nodeId of state.nodeIds()) {
-		if (nodeId === rootNodeId) {
-			const measured = root.length > 0;
-			nodes.push({
-				nodeId,
-				pairs: root.length,
-				mean: measured ? 0 : null,
-				variance: measured ? 0 : null
-			});
+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;
 		}
-		const { node, other } = pairUnits(searchUnitScores(state.scoredCells(nodeId, split)), rootMeans);
-		const gains = node.map((value, index) => sign * (value - other[index]));
-		const mean = gains.length > 0 ? sum(gains) / gains.length : null;
-		if (mean !== null && gains.length >= 2) {
-			squares += sum(gains.map((gain) => (gain - mean) ** 2));
-			degreesOfFreedom += gains.length - 1;
-		}
-		nodes.push({
-			nodeId,
-			pairs: gains.length,
-			mean: mean === null ? null : plain(mean),
-			variance: null
-		});
+		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 pooledVariance = degreesOfFreedom > 0 ? squares / degreesOfFreedom : null;
-	if (pooledVariance !== null) {
-		for (const posterior of nodes) if (posterior.nodeId !== rootNodeId && posterior.pairs > 0) posterior.variance = pooledVariance / posterior.pairs;
+	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 {
-		split,
-		rootNodeId,
-		pooledVariance,
-		degreesOfFreedom,
-		nodes
+		claim: claimOf(tested.map((entry) => ({
+			nodeId: entry.nodeId,
+			estimate: entry.estimate,
+			test: entry.test,
+			promote: entry.promote
+		})), selected, ship ? "ship" : "hold", reason),
+		decisions
 	};
 }
-function unitMeans(units) {
-	return new Map(units.map((unit) => [unit.unitId, unit.mean]));
+/** Per-finalist confidence for `k` finalists. */
+function bonferroni(k) {
+	return 1 - (1 - FAMILY_CONFIDENCE) / k;
 }
-/** Unit means of two nodes on the units both scored, aligned in the node's
-* unitId order. */
-function pairUnits(node, otherMeans) {
-	const paired = {
-		node: [],
-		other: []
+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"
 	};
-	for (const unit of node) {
-		const mean = otherMeans.get(unit.unitId);
-		if (mean === void 0) continue;
-		paired.node.push(unit.mean);
-		paired.other.push(mean);
+}
+/** 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
+		});
 	}
-	return paired;
+	ranked.sort((a, b) => sign * (b.selectionMean - a.selectionMean) || a.ordinal - b.ordinal);
+	return ranked.slice(0, 3).map(({ nodeId, selectionMean }) => ({
+		nodeId,
+		selectionMean
+	}));
 }
-function assertDistinctCells(cells, nodeId, against) {
-	const seen = /* @__PURE__ */ new Set();
-	for (const cell of cells) {
-		if (seen.has(cell.cellId)) throw new SearchLedgerError(`cell ${cell.cellId} appears twice in the estimate of ${nodeId} against ${against}`);
-		if (!Number.isFinite(cell.score)) throw new SearchLedgerError(`cell ${cell.cellId} has a non-finite score ${cell.score}`);
-		seen.add(cell.cellId);
+/**
+* The 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
+	};
 }
-/** The first 32 bits of a `sha256:` digest, as the bootstrap's seed. */
-function seedFromDigest(digest) {
-	return Number.parseInt(digest.slice(7, 15), 16) | 0;
+function 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 sum(values) {
+function mean$2(values) {
 	let total = 0;
 	for (const value of values) total += value;
-	return total;
+	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) {
@@ -2821,10 +3329,14 @@ const SEARCH_KERNEL_SOURCE = {
 		retries: "a retryable errored attempt runs again, up to maxAttempts",
 		resume: "an unrecorded operation is recorded failed at an unknown cost with floor 0; a recorded proposal is finished from its stored output; an unsettled cell is offered to adopt before it runs",
 		writers: "one kernel per ledger file on a host, by a pid lock beside the ledger",
-		close: "the policy leader is selected when it has a scored cell; every other undecided node is rejected"
+		divergence: "a node whose train mean over shared units rises above its parent while its descriptive or bootstrap selection interval against the parent lies wholly on the worse side is decided invalid when its cells finish",
+		claim: "with a test split: after expansion stops, the claim plan is stored on the claim operation, the finalists are decided, the root and finalist test cells run together, and the claim decides; the kernel refuses to start a claim without a selection split, a minimumEffect, a pinned judge, or (under a cap) a claim reserve for the root and 3 finalists plus a cap for one screening round",
+		close: "without a test split, the policy leader is selected when it has a scored cell; every other undecided node is rejected"
 	})
 };
 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;
@@ -2880,6 +3392,8 @@ var SearchKernel = class {
 	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;
@@ -2930,7 +3444,12 @@ var SearchKernel = class {
 		};
 		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);
 		}
@@ -2959,6 +3478,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();
 		const recorded = [];
 		for (let expansion = 0;; expansion++) {
 			const operationId = `expand-${expansion}`;
@@ -3000,11 +3521,55 @@ var SearchKernel = class {
 			if (!lane) throw new Error(`runSearch: cell ${cell.cellId} was placed on lane ${String(cell.lane)}, which the executor does not declare`);
 			this.adoptable.add(cell.cellId);
 			this.enqueue(cell);
-			this.pending.set(cell.nodeId, (this.pending.get(cell.nodeId) ?? 0) + 1);
+			if (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) this.markScreened(nodeId);
+		for (const nodeId of this.state.nodeIds()) if (this.admitted.has(nodeId) && (this.pending.get(nodeId) ?? 0) === 0) await this.screenDone(nodeId);
+	}
+	/**
+	* 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).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 (;;) {
@@ -3057,10 +3622,11 @@ var SearchKernel = class {
 	/** Fill free lane slots with queued cells. A queued cell was admitted when
 	* it was allocated, so starting it needs no further decision. */
 	dispatch() {
-		if (this.failure || this.options.signal?.aborted || this.pastDeadline()) return;
+		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 = lane.queues.find((queue) => queue.length > 0)?.shift();
+			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);
 		}
@@ -3125,14 +3691,40 @@ var SearchKernel = class {
 			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.onScreenDone(cell.nodeId);
 	}
 	async onScreenDone(nodeId) {
-		this.markScreened(nodeId);
+		if (!await this.screenDone(nodeId)) return;
 		if (this.stopReason === null && !this.failure) await this.allocateFor(nodeId);
 	}
+	/**
+	* 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)) {
+			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);
@@ -3192,19 +3784,140 @@ var SearchKernel = class {
 		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 queue of lane.queues) for (const cellId of queue.splice(0)) {
-			const cell = this.state.cell(cellId);
-			if (cell.attempts === 0) {
-				await this.recorder.cancelCell({
-					cellId,
-					reason
-				});
-				await this.refresh();
+		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);
 			}
-			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
@@ -3380,6 +4093,10 @@ var SearchKernel = class {
 	}
 	async close() {
 		await this.refresh();
+		if (this.claimPlan) {
+			await this.closeWithClaim(this.claimPlan);
+			return;
+		}
 		const view = this.policyView();
 		const leader = this.options.policy.leader(view);
 		const { split } = view;
@@ -3408,12 +4125,39 @@ 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();
+	}
 	closedResult() {
 		const state = this.state;
 		return {
 			state,
 			leader: state.audit.selectedNodeId ?? state.rootNodeId,
-			reason: state.closed.reason
+			reason: state.closed.reason,
+			claim: state.closed.claim
 		};
 	}
 	policyView() {
@@ -3497,6 +4241,43 @@ function searchPolicyView(state, input) {
 		})
 	};
 }
+/**
+* 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";
 }
@@ -3895,7 +4676,7 @@ var SearchRecorder = class SearchRecorder {
 			kind: "operation-started",
 			eventId: `operation-started:${input.operationId}`,
 			occurredAt: this.stamp(),
-			artifacts: [],
+			artifacts: input.artifacts ?? [],
 			operationId: input.operationId,
 			operationKind: input.operationKind,
 			reservation: input.reservation ?? null
@@ -4446,6 +5227,12 @@ async function runOptimization(opts) {
 			const context = Object.freeze({
 				currentSurface: immutableProposalSnapshot(parent.artifact, "current surface"),
 				operator: request.operator,
+				parents: immutableProposalSnapshot(request.parents.map(({ nodeId, artifact }) => ({
+					nodeId,
+					artifact: immutableProposalSnapshot(artifact, "parent surface")
+				})), "parents"),
+				train: searchProposerView(state),
+				summary: renderSearchSummary(state, { split: "train" }),
 				history: proposalHistory,
 				findings: immutableProposalSnapshot(assertProposalFindings(findings, "runOptimization proposal findings"), "findings"),
 				populationSize: opts.populationSize,
@@ -6463,6 +7250,6 @@ function firstString(value) {
 	return typeof value === "string" && value.trim() ? value : void 0;
 }
 //#endregion
-export { scoreRedTeamOutput as $, createSearchHistoryReceipt as A, estimateNodeFromCells as B, searchEdgeId as C, assertCompleteSearchHistory as D, SearchHistoryRequiredError as E, runSearch as F, paretoFrontier as G, searchPosterior as H, searchExpansionIndex as I, captureJudge as J, runFinalComparison as K, searchPolicyView as L, verifySearchHistoryArtifact as M, verifySearchHistoryReceipt as N, assertSearchHistoryAdmissionOptions as O, SEARCH_KERNEL_SOURCE as P, redTeamReport as Q, SEARCH_ESTIMATOR as R, developmentClaim as S, surfaceNode as T, uniform as U, searchCellSetDigest as V, dominates as W, DEFAULT_RED_TEAM_CORPUS as X, defaultProductionGate as Y, redTeamDataset as Z, isProposedCandidate as _, transientDispatchFailure as a, runEval as at, incumbent as b, compareOptimizationMethods as c, resolveRunDir as ct, combineComparisonCosts as d, buildCellSchedule as dt, runCanaries as et, costFromLedgerSummary as f, cellCachePath as ft, runOptimization as g, runImprovementLoop as h, quotaExhaustedUntil as i, reserveFinalEvidence as it, searchHistoryCoverageRow as j, assertSearchHistoryMatchesState as k, optimizationTokenUsageFromSummary as l, tangleTracesRoot as lt, readGepaCandidatePopulationArtifact as m, JudgeParseError as n, captureFinalEvidencePolicy as nt, aggregateRunScore as o, runCampaign as ot, assertGepaCandidatePopulationSummary as p, computeManifestHash as pt, openAutoPr as q, isTransientTransportFailure as r, evaluationUnitMap as rt, clamp01 as s, planCampaignRun as st, llmJudge as t, assertIndependentEvaluationSplit as tt, executeOptimizationMethod as u, readCachedCell as ut, labelTrustRank as v, surfaceDiff as w, SearchRecorder as x, crowdedFrontierParent as y, estimateNode as z };
+export { redTeamDataset as $, createSearchHistoryReceipt as A, decideSearchClaim as B, searchEdgeId as C, assertCompleteSearchHistory as D, SearchHistoryRequiredError as E, runSearch as F, uniform as G, searchClaimReserveUsd as H, searchDivergence as I, runFinalComparison as J, dominates as K, searchExpansionIndex as L, verifySearchHistoryArtifact as M, verifySearchHistoryReceipt as N, assertSearchHistoryAdmissionOptions as O, SEARCH_KERNEL_SOURCE as P, DEFAULT_RED_TEAM_CORPUS as Q, searchPolicyView as R, developmentClaim as S, surfaceNode as T, pairedPromotionPower as U, planSearchClaim as V, requiredPairsForPairedPromotion as W, captureJudge as X, openAutoPr as Y, defaultProductionGate as Z, isProposedCandidate as _, transientDispatchFailure as a, evaluationUnitMap as at, incumbent as b, compareOptimizationMethods as c, runCampaign as ct, combineComparisonCosts as d, tangleTracesRoot as dt, redTeamReport as et, costFromLedgerSummary as f, readCachedCell as ft, runOptimization as g, runImprovementLoop as h, computeManifestHash as ht, quotaExhaustedUntil as i, captureFinalEvidencePolicy as it, searchHistoryCoverageRow as j, assertSearchHistoryMatchesState as k, optimizationTokenUsageFromSummary as l, planCampaignRun as lt, readGepaCandidatePopulationArtifact as m, cellCachePath as mt, JudgeParseError as n, runCanaries as nt, aggregateRunScore as o, reserveFinalEvidence as ot, assertGepaCandidatePopulationSummary as p, buildCellSchedule as pt, paretoFrontier as q, isTransientTransportFailure as r, assertIndependentEvaluationSplit as rt, clamp01 as s, runEval as st, llmJudge as t, scoreRedTeamOutput as tt, executeOptimizationMethod as u, resolveRunDir as ut, labelTrustRank as v, surfaceDiff as w, SearchRecorder as x, crowdedFrontierParent as y, SEARCH_CLAIM_RULE as z };
 
-//# sourceMappingURL=llm-judge-Z6MkTkd0.js.map
+//# sourceMappingURL=llm-judge-ChbWfeWl.js.map