@tangle-network/agent-eval 0.197.0 → 0.198.1

package/dist/search-summary-CcavvYLe.js

@@ -1,378 +0,0 @@
-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-9W0g5FP6.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-CcavvYLe.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"search-summary-CcavvYLe.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/tool-groups-B4JVrH3g.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tool-groups-B4JVrH3g.d.ts","names":[],"sources":["../src/analyst/tool-groups.ts"],"mappings":";;;;KAmBY;;;;;;;;;;;;;;;;;;;;iBAyDI,wBACd,OAAO,oBACP,OAAO,qBACN"}

package/dist/types-B2673PBj.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types-B2673PBj.d.ts","names":[],"sources":["../src/campaign/search-state.ts","../src/campaign/search-summary.ts","../src/campaign/types.ts"],"mappings":"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"}

package/dist/types-B3jzCp0p.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types-B3jzCp0p.js","names":[],"sources":["../src/multishot/types.ts"],"sourcesContent":["// Public types for the multishot substrate.\n\nimport type { CostProvenance } from '../cost-ledger'\n\nexport interface MultishotMessage {\n  role: 'user' | 'assistant' | 'tool'\n  content: string\n  toolCallId?: string\n  toolCalls?: Array<{ id: string; name: string; args: Record<string, unknown> }>\n}\n\nexport interface MultishotArtifact {\n  type: string\n  turn: number\n  invocation: { name: string; args: Record<string, unknown> }\n  content: string\n}\n\nexport interface MultishotResult {\n  transcript: MultishotMessage[]\n  artifacts: MultishotArtifact[]\n  toolCalls: number\n  durationMs: number\n  /** Known spend. A subtotal, not a total, when `costProvenance.kind` is\n   *  `uncaptured`. */\n  costUsd: number\n  /** Origin of `costUsd`. A shot that priced every call reports `estimated`\n   *  or `observed`; a shot with a call the router priced at nothing reports\n   *  `uncaptured`, and the matrix records the cell as under-counted instead of\n   *  presenting the subtotal as a complete estimate.\n   *\n   *  Optional so an engine written before this field keeps working; the matrix\n   *  then judges the cell on judge receipts alone, as it did before. */\n  costProvenance?: CostProvenance\n}\n\nexport interface MultishotToolDefinition {\n  type: 'function'\n  function: {\n    name: string\n    description: string\n    parameters: Record<string, unknown>\n  }\n}\n\n/** One chat-completion request the multishot loop issues for a single agent\n *  (or driver) inference step. Mirrors the OpenAI-compat body the loop would\n *  otherwise POST to the Tangle router. */\nexport interface MultishotTransportRequest {\n  model: string\n  messages: Array<Record<string, unknown>>\n  tools?: MultishotToolDefinition[]\n  temperature?: number\n  maxTokens?: number\n  signal?: AbortSignal\n}\n\nexport interface MultishotTransportToolCall {\n  id: string\n  type: 'function'\n  function: { name: string; arguments: string }\n}\n\nexport interface MultishotTransportResponse {\n  message: { content?: string | null; tool_calls?: MultishotTransportToolCall[] }\n  usage?: { prompt_tokens?: number; completion_tokens?: number }\n  /** Actual spend for this call. When omitted, the loop meters cost from\n   *  `usage` via the per-model estimator (estimateMultishotCost). */\n  costUsd?: number\n  /** Model identity the provider reported, when the transport observed one.\n   *  Omitted means unreported, and the requested model is used for\n   *  attribution — which is not proof that model answered. */\n  model?: string\n}\n\n/** Execution seam for one leg of the multishot loop. The caller owns model\n *  execution: agent-eval issues no provider request and holds no credential.\n *  The loop still owns turn scheduling, tool dispatch, transcript capture, and\n *  cost metering. agent-eval has no dependency on agent-runtime; adapt\n *  agent-runtime's `profileChatClient` (or any sandbox, bridge, or router\n *  client) into this signature product-side. */\nexport type MultishotTransport = (\n  req: MultishotTransportRequest,\n) => Promise<MultishotTransportResponse>\n\nexport type MultishotToolExecutor = (\n  args: Record<string, unknown>,\n  ctx: {\n    /** Caller-owned execution seam for the specialist leg this tool runs. */\n    transport: MultishotTransport\n    signal?: AbortSignal\n  },\n) => Promise<{ content: string; costUsd: number }>\n\nexport interface MultishotPersona {\n  /** Stable identifier — used for per-cell artifact paths + matrix axis keys. */\n  id: string\n  /** Per-domain payload (income/profile/voice/etc.) shaped by the consumer. */\n  [k: string]: unknown\n}\n\n/**\n * Persona-shaping callbacks. Both are OPTIONAL: when omitted, the loop derives\n * them from the `AgentProfile` + persona payload (see `defaultShapeFromProfile`)\n * so a pure-profile call — `runMultishot({ profile, persona })` — works with no\n * role-builder functions. Provide callbacks only to override the derived shape.\n */\nexport interface MultishotShape<TPersona extends MultishotPersona> {\n  /** Opening user message (turn 0) — the persona's first ask. */\n  buildOpener?: (persona: TPersona) => string\n  /** System prompt the driver LLM uses to roleplay the persona. Should set\n   *  voice, goals, constraints, time-pressure, and the \"never go silent\" rule. */\n  buildDriverSystemPrompt?: (persona: TPersona) => string\n}\n\nexport class MultishotDriverEmptyError extends Error {\n  constructor(public readonly turn: number) {\n    super(`multishot: driver returned empty content twice at turn ${turn} — failing loud`)\n    this.name = 'MultishotDriverEmptyError'\n  }\n}\n\nexport class MultishotFatalToolError extends Error {\n  constructor(message: string) {\n    super(message)\n    this.name = 'MultishotFatalToolError'\n  }\n}\n\nexport class MultishotShotResultError extends Error {\n  constructor(reason: string) {\n    super(`multishot: shot returned an invalid MultishotResult — ${reason}`)\n    this.name = 'MultishotShotResultError'\n  }\n}\n\nconst MULTISHOT_ROLES = new Set(['user', 'assistant', 'tool'])\n\n/** Contract guard for the value a caller-supplied shot resolves with. The\n *  matrix writes per-cell artifacts, builds judge inputs, and meters cost from\n *  this value, so a malformed result must stop the cell instead of scoring a\n *  degraded one. Two silent degradations this closes: an artifact with no\n *  `type` matches neither the code nor the content artifact set, so the cell\n *  scores as though the artifact was never produced; a non-finite `costUsd`\n *  reaches `summary.totalCostUsd` and makes every cost number NaN.\n *\n *  A rejected cell is still billed: the matrix cell reads the shot's own\n *  `costUsd` when it is a usable amount and declares that spend on the throw,\n *  so money the shot spent before returning a malformed result stays in the\n *  cumulative sum the cost ceiling reads. A result whose `costUsd` is itself\n *  malformed carries no usable amount, and the cell records as `uncaptured`.\n *\n *  Every required field of `MultishotMessage` and `MultishotArtifact` is\n *  checked, including `toolCalls` elements and `invocation.args`. Optional\n *  fields are checked only when present. */\nexport function assertMultishotShotResult(value: unknown): asserts value is MultishotResult {\n  if (typeof value !== 'object' || value === null) {\n    throw new MultishotShotResultError(`expected an object, received ${describeValue(value)}`)\n  }\n  const result = value as Record<string, unknown>\n  if (!Array.isArray(result.transcript)) {\n    throw new MultishotShotResultError(\n      `transcript must be an array, received ${describeValue(result.transcript)}`,\n    )\n  }\n  if (!Array.isArray(result.artifacts)) {\n    throw new MultishotShotResultError(\n      `artifacts must be an array, received ${describeValue(result.artifacts)}`,\n    )\n  }\n  result.transcript.forEach(assertMessage)\n  result.artifacts.forEach(assertArtifact)\n  assertFiniteCount(result.toolCalls, 'toolCalls')\n  assertFiniteCount(result.durationMs, 'durationMs')\n  assertFiniteCount(result.costUsd, 'costUsd')\n  if (result.costProvenance !== undefined) assertCostProvenance(result.costProvenance)\n}\n\nfunction assertCostProvenance(value: unknown): void {\n  const row = requireRow(value, 'costProvenance')\n  if (row.kind !== 'observed' && row.kind !== 'estimated' && row.kind !== 'uncaptured') {\n    throw new MultishotShotResultError(\n      `costProvenance.kind must be observed, estimated or uncaptured, received ${describeValue(row.kind)}`,\n    )\n  }\n  // The matrix reads the amount from `costUsd`; `usd` only has to agree with\n  // the kind, so an uncaptured provenance cannot smuggle in a total.\n  if (row.kind === 'uncaptured') {\n    if (row.usd !== null) {\n      throw new MultishotShotResultError(\n        `uncaptured costProvenance.usd must be null, received ${describeValue(row.usd)}`,\n      )\n    }\n    return\n  }\n  assertFiniteCount(row.usd, 'costProvenance.usd')\n}\n\nfunction assertMessage(value: unknown, index: number): void {\n  const row = requireRow(value, `transcript[${index}]`)\n  if (typeof row.role !== 'string' || !MULTISHOT_ROLES.has(row.role)) {\n    throw new MultishotShotResultError(\n      `transcript[${index}].role must be user, assistant or tool, received ${describeValue(row.role)}`,\n    )\n  }\n  assertString(row.content, `transcript[${index}].content`)\n  if (row.toolCallId !== undefined) {\n    assertString(row.toolCallId, `transcript[${index}].toolCallId`)\n  }\n  if (row.toolCalls === undefined) return\n  if (!Array.isArray(row.toolCalls)) {\n    throw new MultishotShotResultError(\n      `transcript[${index}].toolCalls must be an array when present, received ${describeValue(row.toolCalls)}`,\n    )\n  }\n  row.toolCalls.forEach((call, callIndex) => {\n    const field = `transcript[${index}].toolCalls[${callIndex}]`\n    const row = requireRow(call, field)\n    assertString(row.id, `${field}.id`)\n    assertString(row.name, `${field}.name`)\n    requireRow(row.args, `${field}.args`)\n  })\n}\n\nfunction assertArtifact(value: unknown, index: number): void {\n  const row = requireRow(value, `artifacts[${index}]`)\n  assertString(row.type, `artifacts[${index}].type`)\n  assertString(row.content, `artifacts[${index}].content`)\n  assertFiniteCount(row.turn, `artifacts[${index}].turn`)\n  const invocation = requireRow(row.invocation, `artifacts[${index}].invocation`)\n  assertString(invocation.name, `artifacts[${index}].invocation.name`)\n  requireRow(invocation.args, `artifacts[${index}].invocation.args`)\n}\n\nfunction requireRow(value: unknown, field: string): Record<string, unknown> {\n  if (typeof value !== 'object' || value === null || Array.isArray(value)) {\n    throw new MultishotShotResultError(\n      `${field} must be an object, received ${describeValue(value)}`,\n    )\n  }\n  return value as Record<string, unknown>\n}\n\nfunction assertString(value: unknown, field: string): void {\n  if (typeof value !== 'string') {\n    throw new MultishotShotResultError(\n      `${field} must be a string, received ${describeValue(value)}`,\n    )\n  }\n}\n\nfunction assertFiniteCount(value: unknown, field: string): void {\n  if (typeof value !== 'number' || !Number.isFinite(value) || value < 0) {\n    throw new MultishotShotResultError(\n      `${field} must be a finite number >= 0, received ${describeValue(value)}`,\n    )\n  }\n}\n\nfunction describeValue(value: unknown): string {\n  if (value === null) return 'null'\n  if (Array.isArray(value)) return 'an array'\n  if (typeof value === 'object') return 'an object'\n  return `${typeof value} ${String(value)}`\n}\n"],"mappings":"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"}