@tangle-network/agent-eval 0.191.0 → 0.193.0

package/dist/search-summary-BhY8p0Av.js

@@ -0,0 +1,378 @@
+import { a as hashCanonical, i as compareCodeUnits } from "./canonical-BsZVgBhW.js";
+import { n as DECISION_PAIRED_DELTA_STATISTIC } from "./paired-tests-C8iCsioC.js";
+import { n as pairedDeltaTest, t as minimumPairsForPairedDeltaTest } from "./paired-delta-test-BF-FEP8V.js";
+import { a as SearchLedgerError } from "./search-ledger-file-DY0AXX3W.js";
+import { f as searchUnitScores } from "./search-ledger-CJiAEU3j.js";
+//#region src/campaign/estimate-node.ts
+/**
+* Per-node statistics of a search.
+*
+* `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.
+*
+* `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.
+*/
+const CONFIDENCE = .95;
+const RESAMPLES = 2e3;
+/** 6 at 95 %: the smallest sample an exact one-sided sign test can resolve. */
+const DESCRIPTIVE_FROM$1 = 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$1} 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$1) 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.
+*/
+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)
+	});
+}
+/**
+* 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.
+*/
+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
+	};
+	if (method === "none") return {
+		...base,
+		delta: null,
+		interval: null,
+		exactSignP: null,
+		indeterminate: false
+	};
+	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;
+	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
+	};
+}
+/**
+* `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)
+	});
+}
+/**
+* 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.
+*/
+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
+			});
+			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
+		});
+	}
+	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;
+	}
+	return {
+		split,
+		rootNodeId,
+		pooledVariance,
+		degreesOfFreedom,
+		nodes
+	};
+}
+function unitMeans(units) {
+	return new Map(units.map((unit) => [unit.unitId, unit.mean]));
+}
+/** 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: []
+	};
+	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);
+	}
+	return paired;
+}
+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 first 32 bits of a `sha256:` digest, as a bootstrap's seed. */
+function seedFromDigest(digest) {
+	return Number.parseInt(digest.slice(7, 15), 16) | 0;
+}
+function sum(values) {
+	let total = 0;
+	for (const value of values) total += value;
+	return total;
+}
+/** Canonical JSON has one zero; never hand it a negative one. */
+function plain(value) {
+	return value === 0 ? 0 : value;
+}
+//#endregion
+//#region src/campaign/search-summary.ts
+/**
+* The agent's view of a search: the same projection a human reads.
+*
+* `renderSearchSummary` turns a `SearchStateView` into compact text — the
+* leading nodes with their estimates, the most recently discarded ideas with
+* why they were discarded, and a log of recent proposals — as AIDE's journal
+* summary does for its own search. `agent-eval search show <ledger>` prints
+* the same text for a terminal; `runOptimization` puts it on every
+* `ProposeContext` a proposer receives.
+*
+* `searchProposerView` is the train-only read `ProposeContext.train` carries.
+* It has no parameter that can select another split, so a proposer built on
+* it cannot reach the selection or test split even by mistake: the sealed
+* splits (§6.6 of the search-tree design) are unreachable by construction,
+* not by convention.
+*/
+const DESCRIPTIVE_FROM = minimumPairsForPairedDeltaTest(.95);
+/** The train-only view `ProposeContext.train` carries. */
+function searchProposerView(state) {
+	const header = state.header;
+	if (!header) throw new SearchLedgerError(`search ${state.searchId} has not been opened`);
+	return {
+		searchId: state.searchId,
+		direction: header.objective.direction,
+		scoredCells: (nodeId) => state.scoredCells(nodeId, "train"),
+		unitScores: (nodeId) => state.unitScores(nodeId, "train")
+	};
+}
+/**
+* `SearchState` as compact text: a header line with the search's shape and
+* spend, the leading nodes against the root with their estimates, the most
+* recently discarded nodes with the measurement that discarded them, and a
+* log of recent proposals (operator and label — the ledger's inline,
+* redacted summary of each rationale; the full rationale is a blob this
+* function never reads, so it stays a pure, I/O-free projection of the
+* state already in hand).
+*/
+function renderSearchSummary(state, options) {
+	const header = state.header;
+	if (!header) return `search ${state.searchId}: not yet opened`;
+	const limit = options.limit ?? 5;
+	if (limit < 1 || !Number.isInteger(limit)) throw new SearchLedgerError(`renderSearchSummary: limit must be a positive integer, got ${limit}`);
+	const split = options.split;
+	const direction = header.objective.direction;
+	const root = state.rootNodeId;
+	const lines = [
+		headerLine(state),
+		spendLine(state),
+		statusLine(state)
+	];
+	if (root === null) {
+		lines.push("", "No nodes yet.");
+		return lines.join("\n");
+	}
+	const others = state.nodes().filter((node) => node.nodeId !== root);
+	const leading = others.filter((node) => node.status !== "invalid").map((node) => ({
+		node,
+		estimate: estimateNode(state, node.nodeId, {
+			against: root,
+			split
+		})
+	})).filter(({ estimate }) => estimate.delta !== null).sort((a, b) => signed(b.estimate, direction) - signed(a.estimate, direction)).slice(0, limit);
+	lines.push("", `Leading nodes (vs root, ${split} split):`);
+	if (leading.length === 0) lines.push("  none measured yet");
+	for (const { node, estimate } of leading) lines.push(`  ${nodeLine(node)}: ${formatEstimate(estimate)}`);
+	const discarded = others.filter((node) => node.status === "pruned" || node.status === "rejected" || node.status === "invalid").sort((a, b) => b.updatedSequence - a.updatedSequence).slice(0, limit);
+	lines.push("", "Recently discarded:");
+	if (discarded.length === 0) lines.push("  none yet");
+	for (const node of discarded) lines.push(`  ${nodeLine(node)}: ${discardLine(node)}`);
+	const recent = [...state.edges()].reverse().slice(0, limit);
+	lines.push("", "Recent proposals:");
+	if (recent.length === 0) lines.push("  none yet");
+	for (const edge of recent) {
+		const childId = edge.childNodeId;
+		const label = edge.label.length > 0 ? edge.label : "(no label)";
+		lines.push(`  ${edge.operator} → ${childId}: ${label}`);
+	}
+	return lines.join("\n");
+}
+function headerLine(state) {
+	const header = state.header;
+	return `search ${state.searchId} — ${header.subject} — ${header.objective.direction} ${header.objective.metric}`;
+}
+function spendLine(state) {
+	const { audit } = state;
+	const known = audit.spend.knownUsd.toFixed(2);
+	const floor = audit.spend.floorUsd.toFixed(2);
+	const unknown = audit.spend.unknownCostCells;
+	const floorPart = unknown > 0 ? ` + floor $${floor} across ${unknown} unknown-cost cell${unknown === 1 ? "" : "s"}` : "";
+	return `  ${audit.nodes} nodes · ${audit.cells.settled} settled cells (${audit.cells.open} open) · $${known} known${floorPart}`;
+}
+function statusLine(state) {
+	if (!state.closed) return "  status: open";
+	const claim = state.closed.claim;
+	const claimText = claim === null ? "" : claim.decision === "ship" ? ` · claim: ship ${claim.selected}` : ` · claim: ${claim.decision}`;
+	return `  status: closed (${state.closed.reason})${claimText}`;
+}
+function nodeLine(node) {
+	const rung = node.status === "advanced" ? ` rung ${node.rung}` : "";
+	return `${node.nodeId} (${node.status ?? "undecided"}${rung})`;
+}
+function discardLine(node) {
+	const decision = node.decisions.at(-1);
+	if (!decision) return "no decision recorded";
+	return `${decision.basis === null ? "no measured basis" : formatEstimate(decision.basis)} — ${decision.rule}: ${decision.reason}`;
+}
+/** `estimate.delta` in the objective's own units; positive is always better. */
+function signed(estimate, direction) {
+	if (estimate.delta === null) return Number.NEGATIVE_INFINITY;
+	return direction === "maximize" ? estimate.delta : -estimate.delta;
+}
+/** The display rules of search-tree-design §6.4: no whisker below 6 shared
+* units, a dashed descriptive interval with its exact sign p from 6 to 19,
+* a decision-grade whisker from `BOOTSTRAP_GATE_MIN_N`. */
+function formatEstimate(estimate) {
+	const unit = (n) => `${n} unit${n === 1 ? "" : "s"}`;
+	if (estimate.method === "none") return `unknown (${unit(estimate.pairs)})`;
+	if (estimate.indeterminate) return `no measurable difference (indeterminate, ${unit(estimate.pairs)})`;
+	const delta = estimate.delta === null ? "null" : (estimate.delta >= 0 ? "+" : "") + estimate.delta.toFixed(4);
+	if (estimate.method === "insufficient") return `Δ=${delta} (${estimate.pairs} of ${DESCRIPTIVE_FROM} units, insufficient)`;
+	const interval = estimate.interval ? ` [${estimate.interval[0].toFixed(4)}, ${estimate.interval[1].toFixed(4)}]` : "";
+	if (estimate.method === "descriptive") return `Δ=${delta}${interval} dashed, sign p=${estimate.exactSignP === null ? "null" : estimate.exactSignP.toPrecision(3)} (${unit(estimate.pairs)})`;
+	return `Δ=${delta}${interval} (${unit(estimate.pairs)}, ≥20)`;
+}
+//#endregion
+export { estimateNodeFromCells as a, seedFromDigest as c, estimateNode as i, searchProposerView as n, searchCellSetDigest as o, SEARCH_ESTIMATOR as r, searchPosterior as s, renderSearchSummary as t };
+
+//# sourceMappingURL=search-summary-BhY8p0Av.js.map

package/dist/search-summary-BhY8p0Av.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-summary-BhY8p0Av.js","names":["DESCRIPTIVE_FROM"],"sources":["../src/campaign/estimate-node.ts","../src/campaign/search-summary.ts"],"sourcesContent":["/**\n * Per-node statistics of a search.\n *\n * `estimateNode` is the one paired contrast of two nodes: it averages each\n * node's cells inside their units, pairs the units both nodes scored, and runs\n * `pairedDeltaTest` on the per-unit deltas. `estimateNodeFromCells` is the same\n * computation over cells a caller already holds, such as rows a server read\n * from its database. The bootstrap seed comes from `cellSetDigest`, the digest\n * of exactly the cells used, so a producer and a verifier that hold the same\n * cells report the same bits.\n *\n * `searchPosterior` gives every node a normal posterior on its improvement over\n * the root, which expansion policies sample parents from. Its numbers steer\n * spend and claim nothing.\n */\n\nimport { compareCodeUnits, hashCanonical } from '../ledger-core/canonical'\nimport { minimumPairsForPairedDeltaTest, pairedDeltaTest } from '../paired-delta-test'\nimport { BOOTSTRAP_GATE_MIN_N, DECISION_PAIRED_DELTA_STATISTIC } from '../statistics'\nimport { SearchLedgerError } from './search-ledger-errors'\nimport type {\n  NodeEstimate,\n  SearchEstimateMethod,\n  SearchLedgerHash,\n  SearchSourceRef,\n  SearchSplit,\n} from './search-ledger-types'\nimport {\n  type SearchScoredCell,\n  type SearchStateView,\n  type SearchUnitScore,\n  searchUnitScores,\n} from './search-state'\n\nconst CONFIDENCE = 0.95\nconst RESAMPLES = 2000\n/** 6 at 95 %: the smallest sample an exact one-sided sign test can resolve. */\nconst DESCRIPTIVE_FROM = minimumPairsForPairedDeltaTest(CONFIDENCE)\n\n/**\n * Every choice the numbers depend on. Its digest is the estimator's revision:\n * a producer and a verifier that report the same revision and the same\n * `cellSetDigest` report the same estimate. Change a value here whenever the\n * computation changes, so the revision moves with it.\n */\nconst ESTIMATOR_DEFINITION = {\n  name: 'tangle.estimate-node.2026-09',\n  unit: 'mean of the unit’s scored cells, summed in cellId order',\n  pairing: 'units both nodes scored, in unitId order',\n  statistic: DECISION_PAIRED_DELTA_STATISTIC,\n  interval: 'percentile paired bootstrap',\n  confidence: CONFIDENCE,\n  resamples: RESAMPLES,\n  rng: 'mulberry32',\n  seed: 'the first 32 bits of cellSetDigest',\n  signTest: 'exact, one-sided toward improvement in the objective direction',\n  methods: {\n    none: 'below 2 pairs',\n    insufficient: `below ${DESCRIPTIVE_FROM} pairs`,\n    descriptive: `below ${BOOTSTRAP_GATE_MIN_N} pairs`,\n    bootstrap: `from ${BOOTSTRAP_GATE_MIN_N} pairs`,\n  },\n  indeterminate: 'every paired delta equal: no interval and no sign p',\n} as const\n\n/** The estimator every `NodeEstimate` names. */\nexport const SEARCH_ESTIMATOR: SearchSourceRef = {\n  uri: 'npm:@tangle-network/agent-eval#estimateNode',\n  revision: hashCanonical(ESTIMATOR_DEFINITION),\n}\n\n/** The method a paired sample of `pairs` units supports. */\nfunction searchEstimateMethod(pairs: number): SearchEstimateMethod {\n  if (pairs < 2) return 'none'\n  if (pairs < DESCRIPTIVE_FROM) return 'insufficient'\n  if (pairs < BOOTSTRAP_GATE_MIN_N) return 'descriptive'\n  return 'bootstrap'\n}\n\nexport interface EstimateNodeCellsInput {\n  nodeId: string\n  against: string\n  split: SearchSplit\n  direction: 'maximize' | 'minimize'\n  /** Every scored cell of `nodeId` on `split`. */\n  nodeCells: readonly SearchScoredCell[]\n  /** Every scored cell of `against` on `split`. */\n  againstCells: readonly SearchScoredCell[]\n}\n\n/**\n * Digest of the cells an estimate reads, with the contrast they serve. Cells\n * are listed in cellId order, so the digest names the set, not the order it\n * was read in.\n */\nexport function searchCellSetDigest(\n  input: Omit<EstimateNodeCellsInput, 'direction'>,\n): SearchLedgerHash {\n  const list = (cells: readonly SearchScoredCell[]) =>\n    [...cells]\n      .sort((left, right) => compareCodeUnits(left.cellId, right.cellId))\n      .map((cell) => [cell.cellId, cell.unitId, cell.attempt, cell.score])\n  return hashCanonical({\n    contrast: [input.nodeId, input.against],\n    split: input.split,\n    nodeCells: list(input.nodeCells),\n    againstCells: list(input.againstCells),\n  })\n}\n\n/**\n * The paired contrast of `nodeId` against `against` on the units both scored.\n *\n * `delta` is the mean per-unit difference, node minus `against`, in the\n * metric's own units; for a `minimize` objective an improvement is negative.\n * The exact sign test is one-sided toward improvement in the objective's\n * direction. Unscored cells (errored, cancelled or in flight) are absent from\n * the inputs, never zero.\n *\n * - `none` (0 or 1 pair): no delta.\n * - `insufficient` (2 to 5): the delta only.\n * - `descriptive` (6 to 19): the bootstrap interval as spread, and the sign-test p.\n * - `bootstrap` (20 or more): the decision-grade bootstrap interval.\n *\n * When every paired delta is equal the interval would have zero width, which\n * is an absence of evidence; the estimate is then `indeterminate` and carries\n * neither an interval nor a p-value.\n */\nexport function estimateNodeFromCells(input: EstimateNodeCellsInput): NodeEstimate {\n  const { nodeId, against, split, direction } = input\n  if (nodeId === against) {\n    throw new SearchLedgerError(`node ${nodeId} cannot be estimated against itself`)\n  }\n  assertDistinctCells([...input.nodeCells, ...input.againstCells], nodeId, against)\n  const cellSetDigest = searchCellSetDigest(input)\n  const nodeUnits = searchUnitScores(input.nodeCells)\n  const { node, other } = pairUnits(nodeUnits, unitMeans(searchUnitScores(input.againstCells)))\n  const pairs = node.length\n  const method = searchEstimateMethod(pairs)\n  const base = {\n    against,\n    split,\n    units: nodeUnits.length,\n    pairs,\n    method,\n    cellSetDigest,\n    estimator: SEARCH_ESTIMATOR,\n  }\n  if (method === 'none') {\n    return { ...base, delta: null, interval: null, exactSignP: null, indeterminate: false }\n  }\n  // The test's `after - before` is the improvement: node minus against when\n  // larger is better, against minus node when smaller is.\n  const maximize = direction === 'maximize'\n  const test = pairedDeltaTest(maximize ? other : node, maximize ? node : other, {\n    statistic: DECISION_PAIRED_DELTA_STATISTIC,\n    confidence: CONFIDENCE,\n    resamples: RESAMPLES,\n    seed: seedFromDigest(cellSetDigest),\n  })\n  const { mean, low, high } = test.bootstrap\n  const indeterminate = test.indeterminate\n  const spread = (method === 'descriptive' || method === 'bootstrap') && !indeterminate\n  return {\n    ...base,\n    delta: plain(maximize ? mean : -mean),\n    interval: spread ? (maximize ? [plain(low), plain(high)] : [plain(-high), plain(-low)]) : null,\n    exactSignP: method === 'descriptive' && !indeterminate ? test.pValue : null,\n    indeterminate,\n  }\n}\n\n/**\n * `estimateNodeFromCells` over the cells a search state holds: `nodeId`\n * against `against` on one split, in the direction the search's objective\n * declares.\n */\nexport function estimateNode(\n  state: SearchStateView,\n  nodeId: string,\n  options: { against: string; split: SearchSplit },\n): NodeEstimate {\n  const header = state.header\n  if (!header) throw new SearchLedgerError(`search ${state.searchId} has not been opened`)\n  for (const id of [nodeId, options.against]) {\n    if (!state.hasNode(id)) {\n      throw new SearchLedgerError(`node ${id} is not in search ${state.searchId}`)\n    }\n  }\n  return estimateNodeFromCells({\n    nodeId,\n    against: options.against,\n    split: options.split,\n    direction: header.objective.direction,\n    nodeCells: state.scoredCells(nodeId, options.split),\n    againstCells: state.scoredCells(options.against, options.split),\n  })\n}\n\n/** A node's normal posterior on its improvement over the root. */\nexport interface NodePosterior {\n  nodeId: string\n  /** Units the node and the root both scored. */\n  pairs: number\n  /** Mean per-unit improvement over the root in the objective's direction,\n   * so larger is better for either direction. Null without a shared unit. */\n  mean: number | null\n  /** The pooled variance divided by `pairs`. Null when either is unknown. */\n  variance: number | null\n}\n\nexport interface SearchPosterior {\n  split: SearchSplit\n  rootNodeId: string\n  /**\n   * Between-unit variance of the per-unit improvements over the root, pooled\n   * across every non-root node with at least 2 shared units. Null until some\n   * node has 2.\n   */\n  pooledVariance: number | null\n  /** Sum over the pooled nodes of their shared units minus one. */\n  degreesOfFreedom: number\n  /** Every node in registration order; the root first, at exactly 0. */\n  nodes: NodePosterior[]\n}\n\n/**\n * The posterior every node's parent-selection draw uses. Each node's mean is\n * its improvement over the root on shared units; its variance is the search's\n * pooled between-unit variance divided by its unit count, so a node measured\n * on one unit has a wide posterior rather than none. The root is the reference\n * and sits at exactly 0.\n */\nexport function searchPosterior(\n  state: SearchStateView,\n  options: { split?: SearchSplit } = {},\n): SearchPosterior {\n  const split = options.split ?? 'selection'\n  const header = state.header\n  if (!header) throw new SearchLedgerError(`search ${state.searchId} has not been opened`)\n  const rootNodeId = state.rootNodeId\n  if (rootNodeId === null) {\n    throw new SearchLedgerError(`search ${state.searchId} has no root node yet`)\n  }\n  const sign = header.objective.direction === 'maximize' ? 1 : -1\n  const root = searchUnitScores(state.scoredCells(rootNodeId, split))\n  const rootMeans = unitMeans(root)\n  const nodes: NodePosterior[] = []\n  let squares = 0\n  let degreesOfFreedom = 0\n  for (const nodeId of state.nodeIds()) {\n    if (nodeId === rootNodeId) {\n      const measured = root.length > 0\n      nodes.push({\n        nodeId,\n        pairs: root.length,\n        mean: measured ? 0 : null,\n        variance: measured ? 0 : null,\n      })\n      continue\n    }\n    const { node, other } = pairUnits(searchUnitScores(state.scoredCells(nodeId, split)), rootMeans)\n    const gains = node.map((value, index) => sign * (value - other[index]!))\n    const mean = gains.length > 0 ? sum(gains) / gains.length : null\n    if (mean !== null && gains.length >= 2) {\n      squares += sum(gains.map((gain) => (gain - mean) ** 2))\n      degreesOfFreedom += gains.length - 1\n    }\n    nodes.push({\n      nodeId,\n      pairs: gains.length,\n      mean: mean === null ? null : plain(mean),\n      variance: null,\n    })\n  }\n  const pooledVariance = degreesOfFreedom > 0 ? squares / degreesOfFreedom : null\n  if (pooledVariance !== null) {\n    for (const posterior of nodes) {\n      if (posterior.nodeId !== rootNodeId && posterior.pairs > 0) {\n        posterior.variance = pooledVariance / posterior.pairs\n      }\n    }\n  }\n  return { split, rootNodeId, pooledVariance, degreesOfFreedom, nodes }\n}\n\nfunction unitMeans(units: readonly SearchUnitScore[]): ReadonlyMap<string, number> {\n  return new Map(units.map((unit) => [unit.unitId, unit.mean]))\n}\n\n/** Unit means of two nodes on the units both scored, aligned in the node's\n * unitId order. */\nfunction pairUnits(\n  node: readonly SearchUnitScore[],\n  otherMeans: ReadonlyMap<string, number>,\n): { node: number[]; other: number[] } {\n  const paired = { node: [] as number[], other: [] as number[] }\n  for (const unit of node) {\n    const mean = otherMeans.get(unit.unitId)\n    if (mean === undefined) continue\n    paired.node.push(unit.mean)\n    paired.other.push(mean)\n  }\n  return paired\n}\n\nfunction assertDistinctCells(\n  cells: readonly SearchScoredCell[],\n  nodeId: string,\n  against: string,\n): void {\n  const seen = new Set<string>()\n  for (const cell of cells) {\n    if (seen.has(cell.cellId)) {\n      throw new SearchLedgerError(\n        `cell ${cell.cellId} appears twice in the estimate of ${nodeId} against ${against}`,\n      )\n    }\n    if (!Number.isFinite(cell.score)) {\n      throw new SearchLedgerError(`cell ${cell.cellId} has a non-finite score ${cell.score}`)\n    }\n    seen.add(cell.cellId)\n  }\n}\n\n/** The first 32 bits of a `sha256:` digest, as a bootstrap's seed. */\nexport function seedFromDigest(digest: SearchLedgerHash): number {\n  return Number.parseInt(digest.slice('sha256:'.length, 'sha256:'.length + 8), 16) | 0\n}\n\nfunction sum(values: readonly number[]): number {\n  let total = 0\n  for (const value of values) total += value\n  return total\n}\n\n/** Canonical JSON has one zero; never hand it a negative one. */\nfunction plain(value: number): number {\n  return value === 0 ? 0 : value\n}\n","/**\n * The agent's view of a search: the same projection a human reads.\n *\n * `renderSearchSummary` turns a `SearchStateView` into compact text — the\n * leading nodes with their estimates, the most recently discarded ideas with\n * why they were discarded, and a log of recent proposals — as AIDE's journal\n * summary does for its own search. `agent-eval search show <ledger>` prints\n * the same text for a terminal; `runOptimization` puts it on every\n * `ProposeContext` a proposer receives.\n *\n * `searchProposerView` is the train-only read `ProposeContext.train` carries.\n * It has no parameter that can select another split, so a proposer built on\n * it cannot reach the selection or test split even by mistake: the sealed\n * splits (§6.6 of the search-tree design) are unreachable by construction,\n * not by convention.\n */\n\nimport { minimumPairsForPairedDeltaTest } from '../paired-delta-test'\nimport { BOOTSTRAP_GATE_MIN_N } from '../statistics'\nimport { estimateNode } from './estimate-node'\nimport { SearchLedgerError } from './search-ledger-errors'\nimport type { NodeEstimate, SearchSplit } from './search-ledger-types'\nimport type { SearchNode, SearchScoredCell, SearchStateView, SearchUnitScore } from './search-state'\n\nconst DESCRIPTIVE_FROM = minimumPairsForPairedDeltaTest(0.95)\n\n/** The proposer's own read of a search: its node's cells on the train split,\n * the only split a proposer may ever see. */\nexport interface SearchProposerView {\n  readonly searchId: string\n  readonly direction: 'maximize' | 'minimize'\n  /** `nodeId`'s scored train cells. Unscored cells (errored, cancelled or in\n   * flight) are absent, never zero. */\n  scoredCells(nodeId: string): readonly SearchScoredCell[]\n  /** Per-unit train-split means of `nodeId`, in unitId order. */\n  unitScores(nodeId: string): readonly SearchUnitScore[]\n}\n\n/** The train-only view `ProposeContext.train` carries. */\nexport function searchProposerView(state: SearchStateView): SearchProposerView {\n  const header = state.header\n  if (!header) throw new SearchLedgerError(`search ${state.searchId} has not been opened`)\n  return {\n    searchId: state.searchId,\n    direction: header.objective.direction,\n    scoredCells: (nodeId) => state.scoredCells(nodeId, 'train'),\n    unitScores: (nodeId) => state.unitScores(nodeId, 'train'),\n  }\n}\n\nexport interface SearchSummaryOptions {\n  /**\n   * The split every estimate in the summary is computed on. A proposer's\n   * context must always pass `'train'`: the selection and test splits stay\n   * unread by anything a proposer's text can reach. The CLI passes the\n   * search's own ranking split, `'selection'` when the search declares one\n   * else `'train'`, matching `searchPolicyView`.\n   */\n  split: SearchSplit\n  /** Nodes shown under \"Leading\" and under \"Recently discarded\". Default 5. */\n  limit?: number\n}\n\n/**\n * `SearchState` as compact text: a header line with the search's shape and\n * spend, the leading nodes against the root with their estimates, the most\n * recently discarded nodes with the measurement that discarded them, and a\n * log of recent proposals (operator and label — the ledger's inline,\n * redacted summary of each rationale; the full rationale is a blob this\n * function never reads, so it stays a pure, I/O-free projection of the\n * state already in hand).\n */\nexport function renderSearchSummary(state: SearchStateView, options: SearchSummaryOptions): string {\n  const header = state.header\n  if (!header) return `search ${state.searchId}: not yet opened`\n  const limit = options.limit ?? 5\n  if (limit < 1 || !Number.isInteger(limit)) {\n    throw new SearchLedgerError(\n      `renderSearchSummary: limit must be a positive integer, got ${limit}`,\n    )\n  }\n  const split = options.split\n  const direction = header.objective.direction\n  const root = state.rootNodeId\n  const lines: string[] = [headerLine(state), spendLine(state), statusLine(state)]\n\n  if (root === null) {\n    lines.push('', 'No nodes yet.')\n    return lines.join('\\n')\n  }\n\n  const others = state.nodes().filter((node) => node.nodeId !== root)\n  const estimated = others\n    .filter((node) => node.status !== 'invalid')\n    .map((node) => ({ node, estimate: estimateNode(state, node.nodeId, { against: root, split }) }))\n\n  const leading = estimated\n    .filter(({ estimate }) => estimate.delta !== null)\n    .sort((a, b) => signed(b.estimate, direction) - signed(a.estimate, direction))\n    .slice(0, limit)\n  lines.push('', `Leading nodes (vs root, ${split} split):`)\n  if (leading.length === 0) lines.push('  none measured yet')\n  for (const { node, estimate } of leading)\n    lines.push(`  ${nodeLine(node)}: ${formatEstimate(estimate)}`)\n\n  const discarded = others\n    .filter(\n      (node) => node.status === 'pruned' || node.status === 'rejected' || node.status === 'invalid',\n    )\n    .sort((a, b) => b.updatedSequence - a.updatedSequence)\n    .slice(0, limit)\n  lines.push('', 'Recently discarded:')\n  if (discarded.length === 0) lines.push('  none yet')\n  for (const node of discarded) lines.push(`  ${nodeLine(node)}: ${discardLine(node)}`)\n\n  const recent = [...state.edges()].reverse().slice(0, limit)\n  lines.push('', 'Recent proposals:')\n  if (recent.length === 0) lines.push('  none yet')\n  for (const edge of recent) {\n    const childId = edge.childNodeId\n    const label = edge.label.length > 0 ? edge.label : '(no label)'\n    lines.push(`  ${edge.operator} → ${childId}: ${label}`)\n  }\n\n  return lines.join('\\n')\n}\n\nfunction headerLine(state: SearchStateView): string {\n  const header = state.header!\n  return `search ${state.searchId} — ${header.subject} — ${header.objective.direction} ${header.objective.metric}`\n}\n\nfunction spendLine(state: SearchStateView): string {\n  const { audit } = state\n  const known = audit.spend.knownUsd.toFixed(2)\n  const floor = audit.spend.floorUsd.toFixed(2)\n  const unknown = audit.spend.unknownCostCells\n  const floorPart =\n    unknown > 0\n      ? ` + floor $${floor} across ${unknown} unknown-cost cell${unknown === 1 ? '' : 's'}`\n      : ''\n  return `  ${audit.nodes} nodes · ${audit.cells.settled} settled cells (${audit.cells.open} open) · $${known} known${floorPart}`\n}\n\nfunction statusLine(state: SearchStateView): string {\n  if (!state.closed) return '  status: open'\n  const claim = state.closed.claim\n  const claimText =\n    claim === null\n      ? ''\n      : claim.decision === 'ship'\n        ? ` · claim: ship ${claim.selected}`\n        : ` · claim: ${claim.decision}`\n  return `  status: closed (${state.closed.reason})${claimText}`\n}\n\nfunction nodeLine(node: SearchNode): string {\n  const rung = node.status === 'advanced' ? ` rung ${node.rung}` : ''\n  return `${node.nodeId} (${node.status ?? 'undecided'}${rung})`\n}\n\nfunction discardLine(node: SearchNode): string {\n  const decision = node.decisions.at(-1)\n  if (!decision) return 'no decision recorded'\n  const basis = decision.basis === null ? 'no measured basis' : formatEstimate(decision.basis)\n  return `${basis} — ${decision.rule}: ${decision.reason}`\n}\n\n/** `estimate.delta` in the objective's own units; positive is always better. */\nfunction signed(estimate: NodeEstimate, direction: 'maximize' | 'minimize'): number {\n  if (estimate.delta === null) return Number.NEGATIVE_INFINITY\n  return direction === 'maximize' ? estimate.delta : -estimate.delta\n}\n\n/** The display rules of search-tree-design §6.4: no whisker below 6 shared\n * units, a dashed descriptive interval with its exact sign p from 6 to 19,\n * a decision-grade whisker from `BOOTSTRAP_GATE_MIN_N`. */\nfunction formatEstimate(estimate: NodeEstimate): string {\n  const unit = (n: number) => `${n} unit${n === 1 ? '' : 's'}`\n  if (estimate.method === 'none') return `unknown (${unit(estimate.pairs)})`\n  if (estimate.indeterminate)\n    return `no measurable difference (indeterminate, ${unit(estimate.pairs)})`\n  const delta =\n    estimate.delta === null ? 'null' : (estimate.delta >= 0 ? '+' : '') + estimate.delta.toFixed(4)\n  if (estimate.method === 'insufficient') {\n    return `Δ=${delta} (${estimate.pairs} of ${DESCRIPTIVE_FROM} units, insufficient)`\n  }\n  const interval = estimate.interval\n    ? ` [${estimate.interval[0].toFixed(4)}, ${estimate.interval[1].toFixed(4)}]`\n    : ''\n  if (estimate.method === 'descriptive') {\n    const signP = estimate.exactSignP === null ? 'null' : estimate.exactSignP.toPrecision(3)\n    return `Δ=${delta}${interval} dashed, sign p=${signP} (${unit(estimate.pairs)})`\n  }\n  return `Δ=${delta}${interval} (${unit(estimate.pairs)}, ≥${BOOTSTRAP_GATE_MIN_N})`\n}\n"],"mappings":"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"}

package/dist/{semantic-concept-judge-Bt7bXAAo.js → semantic-concept-judge-Bg-560H0.js}

@@ -1,9 +1,9 @@
 import { i as CostLedger } from "./cost-ledger-_IbkejCF.js";
-import { f as Mutex } from "./journal-c3qY0SDP.js";
+import { p as Mutex } from "./journal-DvKCvjty.js";
 import { N as RawAnalystFindingSchema } from "./kind-factory-CdPPHtGZ.js";
 import { c as extractJsonPayload } from "./llm-client-KYQBh9C8.js";
 import { n as paidJsonChat, t as paidChat } from "./chat-json-call-CXHBvUz8.js";
-import { n as decodeRawFindingArray } from "./dspy-rlm-engine-MfpwoEaj.js";
+import { n as decodeRawFindingArray } from "./dspy-rlm-engine-BX34vPVY.js";
 import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
 import { z } from "zod";
 import { dirname } from "node:path";
@@ -777,4 +777,4 @@ async function runSemanticConceptJudge(input, options) {
 //#endregion
 export { diffFindings as a, defaultIsMaterial as i, runSemanticConceptJudge as n, createChatTraceEngine as o, FindingsStore as r, SEMANTIC_CONCEPT_JUDGE_VERSION as t };
 
-//# sourceMappingURL=semantic-concept-judge-Bt7bXAAo.js.map
+//# sourceMappingURL=semantic-concept-judge-Bg-560H0.js.map