@tangle-network/agent-eval 0.198.0 → 0.198.1

package/dist/{tree-DHHWsH-X.js → tree-DxGfhISA.js}

@@ -1,10 +1,10 @@
 import { a as hashCanonical, i as compareCodeUnits, r as canonicalString } from "./canonical-BsZVgBhW.js";
-import { s as zQuantile } from "./internal-BMFSR8Ns.js";
+import { a as medianInPlace, s as zQuantile } from "./internal-BMFSR8Ns.js";
 import { t as mulberry32 } from "./random-Dn5fPWkt.js";
 import { r as holm } from "./multiplicity-D9cjmStq.js";
 import { a as pairedSignTest, n as DECISION_PAIRED_DELTA_STATISTIC } from "./paired-tests-C8iCsioC.js";
 import { i as pairedDeltaTest, r as minimumPairsForPairedDeltaTest } from "./paired-promotion-decision-D5B1Cxc2.js";
-import { C as searchPosterior, E as paretoFrontier, _ as rankingSplit, a as searchPolicyView, b as estimateNode, g as INSUFFICIENT_FROM, u as verifySearchClaim, v as summarizeSamples, w as seedFromDigest } from "./search-kernel-D8_kxChy.js";
+import { C as searchEstimateMethod, D as paretoFrontier, T as seedFromDigest, _ as rankingSplit, a as searchPolicyView, b as estimateNode, g as INSUFFICIENT_FROM, u as verifySearchClaim, v as summarizeSamples, w as searchPosterior } from "./search-kernel-CumYAjA3.js";
 import { f as searchUnitScores } from "./search-ledger-BnUytR8X.js";
 import { defineInlineResource } from "@tangle-network/agent-interface";
 //#region src/search/lenses/edit-credit.ts
@@ -594,7 +594,7 @@ function lineageRows(state, nodes, byId, contents, carried) {
 */
 function pairedEstimate(input) {
 	const pairs = input.carrier.length;
-	const method = methodFor(pairs);
+	const method = searchEstimateMethod(pairs);
 	const base = {
 		against: input.against,
 		split: input.split,
@@ -663,12 +663,6 @@ const chanceReusable = (() => {
 		return size;
 	};
 })();
-function methodFor(units) {
-	if (units < 2) return "none";
-	if (units < DESCRIPTIVE_FROM) return "insufficient";
-	if (units < 20) return "descriptive";
-	return "bootstrap";
-}
 /** The worse end of the interval, as an improvement; -Infinity without one. */
 function improvementLow(credit, sign) {
 	if (credit.interval === null) return Number.NEGATIVE_INFINITY;
@@ -765,7 +759,7 @@ function interactionPairs(input) {
 }
 function interactionEstimate(genes, steps, values, sign) {
 	const units = values.length;
-	const method = methodFor(units);
+	const method = searchEstimateMethod(units);
 	const base = {
 		genes,
 		steps,
@@ -933,6 +927,25 @@ function plain(value) {
 }
 //#endregion
 //#region src/search/lenses/front.ts
+/**
+* `front(state, axes)`: the Pareto front over a node's score and its known
+* cost per cell, with room for caller-declared axes (search-tree-design §12).
+*
+* Reuses the existing frontier primitive (`../../pareto`, already the parent
+* selector behind `crowdedFrontierParent` in `search-policy.ts`) rather than
+* a second dominance implementation.
+*
+* The cost axis is the node's cost per attempted cell on the ranking split,
+* not its total spend: an allocator gives a node more cells as it advances,
+* so a total would rank a node by how far it was measured, and a node pruned
+* after its screen would look cheap only for having run fewer cells. A node
+* enters the frontier only when its score rests on 2 or more units (one unit
+* is no estimate, §6.4), every attempted cell on the split has a known cost
+* (an unknown cost is never floored to its known partial or imputed), and it
+* was not decided `invalid` (a judge integrity or admission failure, whose
+* score a reward hack may have produced; such a node never becomes a parent,
+* §6.6).
+*/
 function front(state, options = {}) {
 	const split = options.split ?? rankingSplit(state);
 	const direction = state.header?.objective.direction ?? "maximize";
@@ -940,15 +953,31 @@ function front(state, options = {}) {
 	const rows = state.nodes().map((node) => {
 		const units = state.unitScores(node.nodeId, split);
 		const score = units.length > 0 ? units.reduce((sum, u) => sum + u.mean, 0) / units.length : null;
+		let attempted = 0;
+		let spent = 0;
+		let known = true;
+		for (const cell of state.cells({ nodeId: node.nodeId })) {
+			if (cell.split !== split || cell.attempts === 0) continue;
+			attempted += 1;
+			spent += cell.spentUsd;
+			if (!cell.costKnown) known = false;
+		}
+		const extra = extraAxes.map((axis) => axis.value(state, node.nodeId));
+		const costPerCellUsd = known && attempted > 0 ? spent / attempted : null;
+		const excluded = node.status === "invalid" ? "invalid" : score === null ? "unscored" : units.length < 2 ? "one-unit" : costPerCellUsd === null ? "unknown-cost" : extra.every((value) => Number.isFinite(value)) ? null : "extra-axis";
 		return {
 			nodeId: node.nodeId,
 			score,
+			units: units.length,
+			method: searchEstimateMethod(units.length),
+			costPerCellUsd,
 			knownCostUsd: node.spend.knownUsd,
 			costKnown: node.spend.unknownCostCells === 0,
-			extra: extraAxes.map((axis) => axis.value(state, node.nodeId))
+			excluded,
+			extra
 		};
 	});
-	const eligible = rows.filter((row) => row.score !== null && row.costKnown && row.extra.every((value) => Number.isFinite(value)));
+	const eligible = rows.filter((row) => row.excluded === null);
 	const objectives = [
 		{
 			name: "score",
@@ -956,9 +985,9 @@ function front(state, options = {}) {
 			value: (row) => row.score
 		},
 		{
-			name: "knownCostUsd",
+			name: "costPerCellUsd",
 			direction: "minimize",
-			value: (row) => row.knownCostUsd
+			value: (row) => row.costPerCellUsd
 		},
 		...extraAxes.map((axis, index) => ({
 			name: axis.name,
@@ -967,13 +996,20 @@ function front(state, options = {}) {
 		}))
 	];
 	const frontierIds = eligible.length > 0 ? new Set(paretoFrontier(eligible, objectives).frontier.map((r) => r.nodeId)) : /* @__PURE__ */ new Set();
-	const outRows = rows.map((row) => ({
-		nodeId: row.nodeId,
-		score: row.score,
-		knownCostUsd: row.knownCostUsd,
-		costKnown: row.costKnown,
-		onFront: frontierIds.has(row.nodeId)
-	}));
+	const exclusions = {
+		invalid: 0,
+		unscored: 0,
+		"one-unit": 0,
+		"unknown-cost": 0,
+		"extra-axis": 0
+	};
+	const outRows = rows.map(({ extra: _extra, ...row }) => {
+		if (row.excluded) exclusions[row.excluded] += 1;
+		return {
+			...row,
+			onFront: frontierIds.has(row.nodeId)
+		};
+	});
 	const signalValue = {};
 	for (const row of outRows) signalValue[row.nodeId] = row.onFront ? 1 : 0;
 	return {
@@ -982,7 +1018,8 @@ function front(state, options = {}) {
 			axes: objectives.map((o) => o.name),
 			rows: outRows,
 			frontierSize: frontierIds.size,
-			excludedCount: rows.length - eligible.length
+			excludedCount: rows.length - eligible.length,
+			exclusions
 		},
 		signal: {
 			name: "front.membership",
@@ -990,13 +1027,6 @@ function front(state, options = {}) {
 		}
 	};
 }
-/** The method `estimateNode` reports for a paired sample of `pairs` units. */
-function estimateMethodFor(pairs) {
-	if (pairs < 2) return "none";
-	if (pairs < INSUFFICIENT_FROM) return "insufficient";
-	if (pairs < 20) return "descriptive";
-	return "bootstrap";
-}
 /**
 * Nodes whose screen finished, in registration order, root first: the
 * ledger's reading of the kernel's `screened` list. A node counts once it is
@@ -1034,10 +1064,7 @@ function round9(value) {
 	return rounded === 0 ? 0 : rounded;
 }
 function median(values) {
-	if (values.length === 0) return null;
-	const sorted = [...values].sort((left, right) => left - right);
-	const middle = Math.floor(sorted.length / 2);
-	return sorted.length % 2 === 1 ? sorted[middle] : (sorted[middle - 1] + sorted[middle]) / 2;
+	return values.length === 0 ? null : medianInPlace([...values]);
 }
 /** At most `cap` items, evenly spaced by position: a deterministic sample
 * that keeps a quadratic step bounded on a large search. */
@@ -1446,11 +1473,11 @@ function lineEditDistance(a, b) {
 	}
 	return max;
 }
-const GRID_METHOD = "Gaussian-process regression (ordinary kriging) of node scores: a constant mean (generalized least squares), a squared-exponential covariance whose prior variance is the between-node variance of the scores minus their mean noise and whose length scale maximizes the marginal likelihood over 0.5, 1, 2 and 4 times the median nearest-neighbour distance, and each node's own noise variance (the pooled between-unit variance over its units shared with the root; the root is the reference at exactly 0); nodes with fewer than 2 shared units are left out; a cell is null where the posterior variance exceeds half the prior variance, so the surface never extends past the nodes that support it; no surface is drawn unless the length scale raises the log-likelihood by 1 or more over independent node scores";
+const GRID_METHOD = "Gaussian-process regression (ordinary kriging) of node scores: a constant mean (generalized least squares), a squared-exponential covariance whose prior variance is the between-node variance of the scores minus their mean noise and whose length scale maximizes the marginal likelihood over 0.5, 1, 2 and 4 times the median nearest-neighbour distance, and each node's own noise variance (the pooled between-unit variance over its units shared with the root; the root is the reference at exactly 0); nodes with fewer than 2 shared units, and nodes decided invalid, are left out; a cell is null where the posterior variance exceeds half the prior variance, so the surface never extends past the nodes that support it; no surface is drawn unless the length scale raises the log-likelihood by 1 or more over independent node scores";
 /** Scored nodes a surface or a basin count needs: the library's minimum
 * sample for anything descriptive, as for units. */
 const SURFACE_MIN_NODES = INSUFFICIENT_FROM;
-const BASIN_METHOD = "0-dimensional persistence of node scores on the symmetric k-nearest-neighbour graph of placed nodes, read on the leading MDS axes that hold 80% of the positive eigenvalue mass (2 to 8), joined into one component by the shortest edge between components (ToMATo, Chazal et al. 2013): nodes enter from the highest score down, and where two components meet, the lower peak merges into the higher unless it stands above that saddle node by z standard errors of their difference, sqrt(pooled variance / shared units) per node, where z is the standard-normal quantile at 1 − 0.05 / (local maxima − 1), a Bonferroni bound over every peak that could survive, so a flat landscape of noisy nodes counts one basin at least 95% of the time; at most 2000 nodes, evenly spaced by registration plus the 100 best";
+const BASIN_METHOD = "0-dimensional persistence of node scores on the symmetric k-nearest-neighbour graph of placed nodes (not decided invalid, 2 or more units shared with the root), read on the leading MDS axes that hold 80% of the positive eigenvalue mass (2 to 8), joined into one component by the shortest edge between components (ToMATo, Chazal et al. 2013): nodes enter from the highest score down, and where two components meet, the lower peak merges into the higher unless it stands above that saddle node by z standard errors of their difference, sqrt(pooled variance / shared units) per node, where z is the standard-normal quantile at 1 − 0.05 / (local maxima − 1), a Bonferroni bound over every peak that could survive, so a flat landscape of noisy nodes counts one basin at least 95% of the time; at most 2000 nodes, evenly spaced by registration plus the 100 best";
 /** Nodes the basin graph holds: evenly spaced by registration, plus the best. */
 const BASIN_NODES = 2e3;
 const BASIN_TOP = 100;
@@ -1506,7 +1533,7 @@ function landscape(state, embed = lineageEdits(), options = {}) {
 			score: entry.mean === null || entry.pairs < 2 && node.nodeId !== rootNodeId ? null : round9(entry.mean),
 			standardError: entry.variance === null ? null : round9(Math.sqrt(entry.variance)),
 			pairs: entry.pairs,
-			method: estimateMethodFor(entry.pairs),
+			method: searchEstimateMethod(entry.pairs),
 			basin: null
 		};
 	});
@@ -1522,7 +1549,7 @@ function landscape(state, embed = lineageEdits(), options = {}) {
 			});
 		}
 	}
-	const scored = records.filter((record) => record.x !== null && record.score !== null && record.pairs >= 2);
+	const scored = records.filter((record) => record.x !== null && record.score !== null && record.pairs >= 2 && record.status !== "invalid");
 	const gridResult = krige(records, scored, new Map(posterior.nodes.map((entry) => [entry.nodeId, entry.variance])), columns, surfaceNodes);
 	const fullOf = /* @__PURE__ */ new Map();
 	nodes.forEach((node, position) => {
@@ -1785,7 +1812,7 @@ function distanceRows(nodes, embed, adjacency) {
 function krige(records, scored, variances, columns, surfaceNodes) {
 	if (scored.length < SURFACE_MIN_NODES) return {
 		grid: null,
-		insufficient: `${plural$1(scored.length, "placed node")} share 2 or more units with the root; a surface needs ${SURFACE_MIN_NODES}`
+		insufficient: `${plural$1(scored.length, "placed node")} not decided invalid share 2 or more units with the root; a surface needs ${SURFACE_MIN_NODES}`
 	};
 	const noiseOf = (node) => variances.get(node.nodeId) ?? null;
 	if (scored.some((node) => noiseOf(node) === null)) return {
@@ -2013,7 +2040,7 @@ function graphBasins(records, scoredNodes, fullOf, space, pooledVariance, degree
 		peaks: []
 	});
 	let scored = scoredNodes;
-	if (scored.length < SURFACE_MIN_NODES) return empty(`${plural$1(scored.length, "placed node")} share 2 or more units with the root; basins need ${SURFACE_MIN_NODES}`);
+	if (scored.length < SURFACE_MIN_NODES) return empty(`${plural$1(scored.length, "placed node")} not decided invalid share 2 or more units with the root; basins need ${SURFACE_MIN_NODES}`);
 	if (pooledVariance === null || pooledVariance <= 0) return empty("no pooled between-unit variance, so the noise a peak must clear is unknown");
 	const sample = new Set(evenSample(scored, BASIN_NODES));
 	for (const node of [...scored].sort((left, right) => right.score - left.score || left.ordinal - right.ordinal).slice(0, BASIN_TOP)) sample.add(node);
@@ -3045,7 +3072,7 @@ function skillManifold(state, k = "auto", options = {}) {
 	} else leaderRows = matrix.rows.map((row, index) => ({
 		row,
 		index
-	})).filter(({ row }) => row.observed.size >= leaderFloor).sort((left, right) => sign * (predicted(fit.coordinates[right.index]) - predicted(fit.coordinates[left.index])) || left.row.ordinal - right.row.ordinal).slice(0, leaderCount).map(({ index }) => index);
+	})).filter(({ row }) => row.observed.size >= leaderFloor && row.status !== "invalid").sort((left, right) => sign * (predicted(fit.coordinates[right.index]) - predicted(fit.coordinates[left.index])) || left.row.ordinal - right.row.ordinal).slice(0, leaderCount).map(({ index }) => index);
 	const leaderSet = new Set(leaderRows);
 	const next = intrinsic.value === 0 ? {
 		ranked: [],
@@ -3858,9 +3885,13 @@ function fixedOrDash(value) {
 }
 //#endregion
 //#region src/search/lenses/task-matrix.ts
+const SPECIALIST_GAIN_METHOD = `per unit cluster, the best node's mean over the cluster's units minus the mean of the node means, in the objective's direction and the metric's units, among nodes not decided invalid that scored every unit of the cluster; reported from 2 such nodes and ${INSUFFICIENT_FROM} units; a point value with no interval: the largest of several noisy means exceeds their mean even when no node specializes, so read it against the spread of the node means`;
 function taskMatrix(state, options = {}) {
 	const split = options.split ?? rankingSplit(state);
+	const direction = state.header?.objective.direction ?? "maximize";
+	const sign = direction === "maximize" ? 1 : -1;
 	const nodeIds = state.nodeIds();
+	const invalid = new Set(state.nodes().filter((node) => node.status === "invalid").map((node) => node.nodeId));
 	const byNodeUnit = /* @__PURE__ */ new Map();
 	const unitSet = /* @__PURE__ */ new Set();
 	for (const nodeId of nodeIds) {
@@ -3871,7 +3902,7 @@ function taskMatrix(state, options = {}) {
 		}
 		byNodeUnit.set(nodeId, units);
 	}
-	const unitIds = [...unitSet].sort((a, b) => a.localeCompare(b));
+	const unitIds = [...unitSet].sort(compareCodeUnits);
 	const nodeClusters = clusterBy(nodeIds, (a, b) => nodeDistance(byNodeUnit, a, b));
 	const unitClusters = clusterBy(unitIds, (a, b) => unitDistance(byNodeUnit, nodeIds, a, b));
 	const orderedNodeIds = nodeClusters.flatMap((c) => c.members);
@@ -3886,25 +3917,43 @@ function taskMatrix(state, options = {}) {
 		});
 	}
 	const specialistGain = unitClusters.map((cluster) => {
-		const nodeMeans = [];
+		const contributing = [];
 		for (const nodeId of nodeIds) {
+			if (invalid.has(nodeId)) continue;
 			const units = byNodeUnit.get(nodeId);
-			const scored = cluster.members.map((unitId) => units.get(unitId)).filter((v) => v !== void 0);
-			if (scored.length > 0) nodeMeans.push(scored.reduce((a, b) => a + b, 0) / scored.length);
+			let total = 0;
+			let complete = true;
+			for (const unitId of cluster.members) {
+				const value = units.get(unitId);
+				if (value === void 0) {
+					complete = false;
+					break;
+				}
+				total += value;
+			}
+			if (complete) contributing.push({
+				nodeId,
+				oriented: sign * total / cluster.members.length
+			});
 		}
-		if (nodeMeans.length < 2) return {
+		let best = null;
+		for (const entry of contributing) if (best === null || entry.oriented > best.oriented) best = entry;
+		const row = {
 			clusterId: cluster.id,
 			unitIds: cluster.members,
+			bestNodeId: best?.nodeId ?? null,
+			nodesContributing: contributing.length
+		};
+		if (contributing.length < 2 || cluster.members.length < INSUFFICIENT_FROM) return {
+			...row,
 			gain: null,
-			nodesContributing: nodeMeans.length
+			insufficient: contributing.length < 2 ? `${contributing.length} node${contributing.length === 1 ? "" : "s"} scored every unit of the cluster; a gain needs 2` : `${cluster.members.length} of ${INSUFFICIENT_FROM} units`
 		};
-		const mean = nodeMeans.reduce((a, b) => a + b, 0) / nodeMeans.length;
-		const gain = Math.max(...nodeMeans) - mean;
+		const mean = contributing.reduce((sum, entry) => sum + entry.oriented, 0) / contributing.length;
 		return {
-			clusterId: cluster.id,
-			unitIds: cluster.members,
-			gain,
-			nodesContributing: nodeMeans.length
+			...row,
+			gain: best.oriented - mean,
+			insufficient: null
 		};
 	});
 	const signalValue = {};
@@ -3912,6 +3961,8 @@ function taskMatrix(state, options = {}) {
 	return {
 		data: {
 			split,
+			direction,
+			method: SPECIALIST_GAIN_METHOD,
 			nodeIds: orderedNodeIds,
 			unitIds: orderedUnitIds,
 			nodeClusters,
@@ -3936,7 +3987,7 @@ function nodeDistance(byNodeUnit, a, b) {
 		sumSquares += (valueA - valueB) ** 2;
 		shared += 1;
 	}
-	return shared === 0 ? Number.POSITIVE_INFINITY : Math.sqrt(sumSquares);
+	return shared === 0 ? Number.POSITIVE_INFINITY : Math.sqrt(sumSquares / shared);
 }
 function unitDistance(byNodeUnit, nodeIds, a, b) {
 	let sumSquares = 0;
@@ -3949,15 +4000,17 @@ function unitDistance(byNodeUnit, nodeIds, a, b) {
 		sumSquares += (valueA - valueB) ** 2;
 		shared += 1;
 	}
-	return shared === 0 ? Number.POSITIVE_INFINITY : Math.sqrt(sumSquares);
+	return shared === 0 ? Number.POSITIVE_INFINITY : Math.sqrt(sumSquares / shared);
 }
 /**
 * Single-linkage agglomerative clustering. The cutoff is the median of the
 * finite pairwise distances measured before any merge — a threshold the data
 * itself sets, not a constant this lens chooses. Two items with no finite
-* distance (no shared observation) can never merge. Deterministic: ties in
-* the merge order break on the lexicographically smaller pair, and the
-* returned clusters and their members are both sorted.
+* distance (no shared observation) can never merge. Stopped at a cutoff,
+* single linkage yields the connected components of the graph whose edges
+* are the pairs at most the cutoff apart, so the merge order cannot change
+* the result. The clusters and their members are sorted by UTF-16 code unit,
+* never by the host's locale, so a cluster id is the same on every machine.
 */
 function clusterBy(ids, distance) {
 	let clusters = ids.map((id) => [id]);
@@ -3987,10 +4040,10 @@ function clusterBy(ids, distance) {
 		clusters = clusters.filter((_, index) => index !== best.i && index !== best.j);
 		clusters.push(merged);
 	}
-	return clusters.map(toCluster).sort((a, b) => a.id.localeCompare(b.id));
+	return clusters.map(toCluster).sort((a, b) => compareCodeUnits(a.id, b.id));
 }
 function toCluster(members) {
-	const sorted = [...members].sort((a, b) => a.localeCompare(b));
+	const sorted = [...members].sort(compareCodeUnits);
 	return {
 		id: sorted[0],
 		members: sorted
@@ -4023,6 +4076,8 @@ function tree(state) {
 			depth: node.depth,
 			cellCount: node.cellCount,
 			knownCostUsd: node.spend.knownUsd,
+			floorUsd: node.spend.floorUsd,
+			unknownCostCells: node.spend.unknownCostCells,
 			operator: primaryOperator.get(node.nodeId) ?? null,
 			children: (childrenOf.get(nodeId) ?? []).map((childId) => build(childId))
 		};
@@ -4042,4 +4097,4 @@ function tree(state) {
 //#endregion
 export { editCreditText as A, draftOnPlateau as C, EDIT_CREDIT_ESTIMATOR as D, front as E, EDIT_CREDIT_SIGNAL as O, vectorEmbedding as S, screenedNodes as T, lineageEdits as _, skillCalibration as a, surfaceDigestEdits as b, META_SEARCH_SIGNAL as c, objectiveKey as d, renderMetaSearchText as f, lineEditDistance as g, landscape as h, nextUnitExtension as i, editCredit as k, metaSearch as l, formatLandscape as m, taskMatrix as n, skillManifold as o, searchPolicyGenome as p, formatSkillManifold as r, META_SEARCH_SCORE_SOURCE as s, tree as t, metaSearchScore as u, nearestNeighbours as v, searchPlateau as w, surfaceTextEdits as x, profileTextLines as y };
 
-//# sourceMappingURL=tree-DHHWsH-X.js.map
+//# sourceMappingURL=tree-DxGfhISA.js.map