@tangle-network/agent-eval 0.145.18 → 0.145.20

package/dist/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { o as runRolloutReleaseCli } from "./hf-dataset-XggBupCr.js";
-import { n as runAnalystBenchmarkCommand } from "./benchmark-command-CyqmP3uA.js";
+import { n as runAnalystBenchmarkCommand } from "./benchmark-command-CkgLXHoN.js";
 import { a as runRpcBatch, o as runRpcOnce, p as handleVersion, r as startServerAsync, s as buildOpenApi } from "./server-ulsOdrTI.js";
 import { writeFileSync } from "node:fs";
 //#region src/cli-config.ts

package/dist/index-D_P7Ye43.d.ts

@@ -0,0 +1,198 @@
+import { t as DefaultVerdict } from "./verdict-E4eRNf7-.js";
+import { p as CostProvenance } from "./cost-ledger-DbQdN3nO.js";
+//#region src/matrix/cell-spend.d.ts
+/**
+ * Spend carrier for a cell that fails after it has already spent money.
+ *
+ * `runCell` reports what a cell cost by returning a `CellResult`. A throw
+ * carries no result, so the runner cannot know what the cell spent before it
+ * failed: the cumulative sum the cost ceiling reads, and `totalCostUsd`, both
+ * miss that money. A throw that carries a `CellSpend` closes the gap — the
+ * runner bills the failed cell for the spend the carrier declares, and records
+ * a cell that declared nothing as `uncaptured` instead of a zero that reads
+ * like "this cell spent nothing".
+ *
+ * The carrier is read structurally, never by `instanceof`, so a throw that
+ * crosses a package or realm boundary still bills.
+ */
+/** Money and wall time a cell consumed before it threw. */
+interface CellSpend {
+  /** KNOWN subtotal in USD. When `kind` is `uncaptured` the cell spent this
+   *  much AND an unknown amount more, so the value must not be read as the
+   *  cell's total. */
+  costUsd: number;
+  /** Wall time the cell consumed before the throw, in milliseconds. */
+  durationMs: number;
+  /** `observed` = provider-reported amounts, `estimated` = computed from token
+   *  prices, `uncaptured` = `costUsd` is a subtotal and part of the spend
+   *  could not be measured. */
+  kind: 'observed' | 'estimated' | 'uncaptured';
+}
+/**
+ * Return `error` carrying `spend`, for a throw site inside `runCell`:
+ * `throw withCellSpend(err, { costUsd, durationMs, kind })`.
+ *
+ * A value that cannot hold the carrier — a thrown string or number, or a
+ * frozen, sealed, or otherwise non-extensible object — is wrapped in an
+ * `Error` that keeps the original as `cause`, so the spend is never dropped.
+ * A later call overwrites an earlier carrier — the outer frame knows more
+ * than the inner one.
+ *
+ * Throws `TypeError` on a non-finite or negative amount. A poisoned amount
+ * would reach `cumulativeCost` and disable the cost ceiling for the whole run,
+ * because `NaN >= ceiling` is false.
+ */
+declare function withCellSpend(error: unknown, spend: CellSpend): unknown;
+/** Read the spend a thrown value carries. `undefined` when the value carries
+ *  none, or carries one that does not satisfy `CellSpend` — the runner records
+ *  both as `uncaptured`. */
+declare function readCellSpend(error: unknown): CellSpend | undefined;
+//#endregion
+//#region src/matrix/types.d.ts
+/** One axis = one dimension to iterate. `V` is the value type — pass any
+ *  substrate type (AgentProfile, Driver, Validator, rubric record). */
+interface MatrixAxis<V> {
+  /** Axis name. Becomes the key in `MatrixResult.byAxis`. */
+  name: string;
+  /** Stable id per value. Used as the bucket key in aggregation. */
+  values: Array<{
+    id: string;
+    value: V;
+  }>;
+  /** Optional bucket label override. Receives the same `(value, id)` the
+   *  runner stored on the cell; default label is `id`. */
+  label?: (value: V, id: string) => string;
+}
+/** A cell carries one picked value from each axis, keyed by axis name. */
+interface MatrixCell {
+  axes: Record<string, {
+    id: string;
+    value: unknown;
+  }>;
+  /** 0-based replicate index within the same axis combination. */
+  rep: number;
+  /** Stable sort key — preserves cartesian order across concurrent execution. */
+  ordinal: number;
+}
+interface CellResult<Output> {
+  output: Output;
+  verdict: DefaultVerdict;
+  /** Known subtotal in USD. When `costProvenance.kind` is `uncaptured` the
+   *  cell spent this much AND an unknown amount more, so the value must not be
+   *  read as the cell's total. Counts toward `costCeiling` either way. */
+  costUsd: number;
+  durationMs: number;
+  runId?: string;
+  /** Origin of `costUsd`. Absent on a result `runCell` returned — that
+   *  `costUsd` is measured by contract. The runner always sets it on a cell
+   *  that threw, where a bare number cannot say whether `0` means "spent
+   *  nothing" or "spend unknown".
+   *
+   *  Converting to `RunRecord` needs one translation: a `RunRecord` rejects a
+   *  numeric `costUsd` beside `uncaptured` provenance, so an uncaptured cell
+   *  becomes `costUsd: null` there. A cell keeps the subtotal because a cost
+   *  ceiling must charge the part it can see; a record drops it because a
+   *  record must never read as a total. */
+  costProvenance?: CostProvenance;
+  /** Populated when `runCell` threw, or when it returned a cost the runner
+   *  cannot bill. The cell contributes 0 to passRate AND meanScore regardless
+   *  of `verdict`. */
+  error?: {
+    message: string;
+    kind: string;
+  };
+}
+interface AxisSummary {
+  axisName: string;
+  axisValue: string;
+  cells: number;
+  passRate: number;
+  meanScore: number;
+  p50Score: number;
+  p90Score: number;
+  /** Sum of the known cost subtotals in this bucket. Under-counts real spend
+   *  by an unknown amount when `costUncapturedCells` is above 0. */
+  totalCostUsd: number;
+  /** Cells in this bucket whose cost is a subtotal, not a total. */
+  costUncapturedCells: number;
+  meanDurationMs: number;
+}
+interface MatrixResult<Output> {
+  cells: Array<{
+    cell: MatrixCell;
+    runs: CellResult<Output>[];
+  }>;
+  /** `byAxis[axisName][axisValueId] = summary`. Populated only for axes
+   *  named in `aggregateBy` (default = every axis in `axes`). */
+  byAxis: Record<string, Record<string, AxisSummary>>;
+  summary: {
+    totalCells: number;
+    runsExecuted: number;
+    /** Cells removed by `filter` plus cells unscheduled after the cost
+     *  ceiling or abort signal tripped. */
+    cellsSkipped: number;
+    overallPassRate: number;
+    overallMeanScore: number;
+    /** Sum of every cell's known cost subtotal. Read it together with
+     *  `costUncapturedCells`: above 0, this number is a floor on real spend,
+     *  and the cost ceiling stopped the run later than true spend deserved. */
+    totalCostUsd: number;
+    /** Cells whose cost is a subtotal rather than a total — a failure that
+     *  reported no spend, a failure that reported a partial amount, or a
+     *  result the runner could not bill. */
+    costUncapturedCells: number;
+    /** What the cost ceiling actually read. Equals `totalCostUsd` unless
+     *  `maxCellCostUsd` was set and a cell's cost was a subtotal, in which case
+     *  the ceiling charged the bound and this figure is higher. */
+    ceilingChargedUsd: number;
+    durationMs: number;
+  };
+  /** Stable id-like string generated at the end of the run. */
+  matrixId: string;
+}
+interface RunAgentMatrixOptions<Output> {
+  axes: MatrixAxis<unknown>[];
+  /** User-supplied cell executor. May throw; the matrix captures throws as
+   *  `CellResult.error` and continues. A cell that spends money before it
+   *  throws must declare that spend — `throw withCellSpend(err, spend)` — or
+   *  the money is missing from `totalCostUsd` and from the sum `costCeiling`
+   *  reads. */
+  runCell: (cell: MatrixCell) => Promise<CellResult<Output>>;
+  /** Replicates per cell. Default 1. */
+  reps?: number;
+  /** Prune cells from the cartesian BEFORE rep expansion. */
+  filter?: (cell: Omit<MatrixCell, 'rep' | 'ordinal'>) => boolean;
+  /** Axes to aggregate into `byAxis`. Default: every axis in `axes`. */
+  aggregateBy?: string[];
+  /** Max concurrent in-flight `runCell` invocations. Default 4. */
+  maxConcurrency?: number;
+  /** Cumulative-cost abort threshold (USD). When the running sum of
+   *  `result.costUsd` crosses this value, no new cells are scheduled.
+   *  In-flight cells finish. Failed cells count for the spend they declare.
+   *  Default `Infinity`. */
+  costCeiling?: number;
+  /** Upper bound on what ONE cell can spend (USD). A cell whose cost is a
+   *  subtotal — a failure that declared nothing, a partial amount, a result
+   *  the runner could not bill — is charged this bound against `costCeiling`
+   *  instead of its known subtotal, so hidden spend cannot walk the run past
+   *  its budget.
+   *
+   *  It changes only what the ceiling reads. `CellResult.costUsd` and
+   *  `summary.totalCostUsd` keep reporting known spend, never a bound that was
+   *  charged but not spent; `summary.ceilingChargedUsd` reports the
+   *  conservative figure. Omit it and the ceiling stays fail-open for exactly
+   *  the cells that hid their spend, with `costUncapturedCells` as the only
+   *  signal. */
+  maxCellCostUsd?: number;
+  /** Fires once per executed cell, after its promise settles. */
+  onCellComplete?: (cell: MatrixCell, result: CellResult<Output>) => void;
+  /** External cancellation. Aborts in-flight cells via a forwarded signal
+   *  and suppresses scheduling of new ones. */
+  signal?: AbortSignal;
+}
+//#endregion
+//#region src/matrix/runner.d.ts
+declare function runAgentMatrix<Output>(opts: RunAgentMatrixOptions<Output>): Promise<MatrixResult<Output>>;
+//#endregion
+export { MatrixCell as a, CellSpend as c, MatrixAxis as i, readCellSpend as l, AxisSummary as n, MatrixResult as o, CellResult as r, RunAgentMatrixOptions as s, runAgentMatrix as t, withCellSpend as u };
+//# sourceMappingURL=index-D_P7Ye43.d.ts.map

package/dist/index-D_P7Ye43.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-D_P7Ye43.d.ts","names":[],"sources":["../src/matrix/cell-spend.ts","../src/matrix/types.ts","../src/matrix/runner.ts"],"mappings":";;;;;;;;;;;;;;;;;;UAoBiB;;;;EAIf;;EAEA;;;;EAIA;;;;;;;;;;;;;;;;iBAiBc,cAAc,gBAAgB,OAAO;;;;iBA+CrC,cAAc,iBAAiB;;;;;UC5E9B,WAAW;;EAE1B;;EAEA,QAAQ;IAAQ;IAAY,OAAO;;;;EAGnC,SAAS,OAAO,GAAG;;;UAIJ;EACf,MAAM;IAAiB;IAAY;;;EAEnC;;EAEA;;UAGe,WAAW;EAC1B,QAAQ;EACR,SAAS;;;;EAIT;EACA;EACA;;;;;;;;;;;EAWA,iBAAiB;;;;EAIjB;IAAU;IAAiB;;;UAGZ;EACf;EACA;EACA;EACA;EACA;EACA;EACA;;;EAGA;;EAEA;EACA;;UAGe,aAAa;EAC5B,OAAO;IAAQ,MAAM;IAAY,MAAM,WAAW;;;;EAGlD,QAAQ,eAAe,eAAe;EACtC;IACE;IACA;;;IAGA;IACA;IACA;;;;IAIA;;;;IAIA;;;;IAIA;IACA;;;EAGF;;UAGe,sBAAsB;EACrC,MAAM;;;;;;EAMN,UAAU,MAAM,eAAe,QAAQ,WAAW;;EAElD;;EAEA,UAAU,MAAM,KAAK;;EAErB;;EAEA;;;;;EAKA;;;;;;;;;;;;;EAaA;;EAEA,kBAAkB,MAAM,YAAY,QAAQ,WAAW;;;EAGvD,SAAS;;;;iBC1BW,eAAe,QACnC,MAAM,sBAAsB,UAC3B,QAAQ,aAAa"}

package/dist/matrix/index.d.ts

@@ -1,3 +1,4 @@
 import { t as DefaultVerdict } from "../verdict-E4eRNf7-.js";
-import { a as MatrixCell, i as MatrixAxis, n as AxisSummary, o as MatrixResult, r as CellResult, s as RunAgentMatrixOptions, t as runAgentMatrix } from "../index-CvjYbU0D.js";
-export { type AxisSummary, type CellResult, type DefaultVerdict, type MatrixAxis, type MatrixCell, type MatrixResult, type RunAgentMatrixOptions, runAgentMatrix };
+import { p as CostProvenance } from "../cost-ledger-DbQdN3nO.js";
+import { a as MatrixCell, c as CellSpend, i as MatrixAxis, l as readCellSpend, n as AxisSummary, o as MatrixResult, r as CellResult, s as RunAgentMatrixOptions, t as runAgentMatrix, u as withCellSpend } from "../index-D_P7Ye43.js";
+export { type AxisSummary, type CellResult, type CellSpend, type CostProvenance, type DefaultVerdict, type MatrixAxis, type MatrixCell, type MatrixResult, type RunAgentMatrixOptions, readCellSpend, runAgentMatrix, withCellSpend };

package/dist/matrix/index.js

@@ -1,2 +1,2 @@
-import { t as runAgentMatrix } from "../matrix-BzQnu2S6.js";
-export { runAgentMatrix };
+import { n as readCellSpend, r as withCellSpend, t as runAgentMatrix } from "../matrix-pWinRMPl.js";
+export { readCellSpend, runAgentMatrix, withCellSpend };

package/dist/{matrix-BzQnu2S6.js → matrix-pWinRMPl.js}

@@ -1,3 +1,94 @@
+//#region src/matrix/cell-spend.ts
+/**
+* Spend carrier for a cell that fails after it has already spent money.
+*
+* `runCell` reports what a cell cost by returning a `CellResult`. A throw
+* carries no result, so the runner cannot know what the cell spent before it
+* failed: the cumulative sum the cost ceiling reads, and `totalCostUsd`, both
+* miss that money. A throw that carries a `CellSpend` closes the gap — the
+* runner bills the failed cell for the spend the carrier declares, and records
+* a cell that declared nothing as `uncaptured` instead of a zero that reads
+* like "this cell spent nothing".
+*
+* The carrier is read structurally, never by `instanceof`, so a throw that
+* crosses a package or realm boundary still bills.
+*/
+/** Property key the carrier occupies on a thrown object. Stable across
+*  versions — two copies of this package must agree on it. */
+const CELL_SPEND_KEY = "__agentEvalCellSpend";
+/**
+* Return `error` carrying `spend`, for a throw site inside `runCell`:
+* `throw withCellSpend(err, { costUsd, durationMs, kind })`.
+*
+* A value that cannot hold the carrier — a thrown string or number, or a
+* frozen, sealed, or otherwise non-extensible object — is wrapped in an
+* `Error` that keeps the original as `cause`, so the spend is never dropped.
+* A later call overwrites an earlier carrier — the outer frame knows more
+* than the inner one.
+*
+* Throws `TypeError` on a non-finite or negative amount. A poisoned amount
+* would reach `cumulativeCost` and disable the cost ceiling for the whole run,
+* because `NaN >= ceiling` is false.
+*/
+function withCellSpend(error, spend) {
+	assertAmount(spend.costUsd, "costUsd");
+	assertAmount(spend.durationMs, "durationMs");
+	if (spend.kind !== "observed" && spend.kind !== "estimated" && spend.kind !== "uncaptured") throw new TypeError(`withCellSpend: kind must be observed, estimated or uncaptured, received ${String(spend.kind)}`);
+	const carrier = {
+		costUsd: spend.costUsd,
+		durationMs: spend.durationMs,
+		kind: spend.kind
+	};
+	if (typeof error === "object" && error !== null && attach(error, carrier)) return error;
+	const wrapper = new Error(`cell failed: ${messageOf(error)}`, { cause: error });
+	attach(wrapper, carrier);
+	return wrapper;
+}
+/** True when the carrier landed. `defineProperty` throws on a non-extensible
+*  target, so the caller must be able to fall back. */
+function attach(target, carrier) {
+	try {
+		Object.defineProperty(target, CELL_SPEND_KEY, {
+			value: carrier,
+			enumerable: false,
+			configurable: true,
+			writable: true
+		});
+		return true;
+	} catch {
+		return false;
+	}
+}
+function messageOf(error) {
+	if (error instanceof Error) return error.message;
+	return String(error);
+}
+/** Read the spend a thrown value carries. `undefined` when the value carries
+*  none, or carries one that does not satisfy `CellSpend` — the runner records
+*  both as `uncaptured`. */
+function readCellSpend(error) {
+	if (typeof error !== "object" || error === null) return void 0;
+	const raw = error[CELL_SPEND_KEY];
+	if (typeof raw !== "object" || raw === null) return void 0;
+	const candidate = raw;
+	if (!isAmount(candidate.costUsd) || !isAmount(candidate.durationMs)) return void 0;
+	const kind = candidate.kind;
+	if (kind !== "observed" && kind !== "estimated" && kind !== "uncaptured") return void 0;
+	return {
+		costUsd: candidate.costUsd,
+		durationMs: candidate.durationMs,
+		kind
+	};
+}
+/** A number the matrix can add to a running cost or duration: finite and not
+*  negative. Anything else would poison a sum the cost ceiling reads. */
+function isAmount(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function assertAmount(value, field) {
+	if (!isAmount(value)) throw new TypeError(`withCellSpend: ${field} must be a finite number >= 0, received ${String(value)}`);
+}
+//#endregion
 //#region src/matrix/aggregation.ts
 function flattenRuns(cells) {
 	const rows = [];
@@ -27,12 +118,14 @@ function summariseRows(rows, axisName, axisValue) {
 		p50Score: 0,
 		p90Score: 0,
 		totalCostUsd: 0,
+		costUncapturedCells: 0,
 		meanDurationMs: 0
 	};
 	let pass = 0;
 	let scoreSum = 0;
 	let costSum = 0;
 	let durSum = 0;
+	let costUncapturedCells = 0;
 	const scores = [];
 	for (const { result } of rows) {
 		const errored = result.error !== void 0;
@@ -42,6 +135,7 @@ function summariseRows(rows, axisName, axisValue) {
 		scores.push(score);
 		costSum += result.costUsd;
 		durSum += result.durationMs;
+		if (result.costProvenance?.kind === "uncaptured") costUncapturedCells++;
 	}
 	scores.sort((a, b) => a - b);
 	return {
@@ -53,6 +147,7 @@ function summariseRows(rows, axisName, axisValue) {
 		p50Score: quantile(scores, .5),
 		p90Score: quantile(scores, .9),
 		totalCostUsd: costSum,
+		costUncapturedCells,
 		meanDurationMs: durSum / rows.length
 	};
 }
@@ -139,28 +234,62 @@ function makeMatrixId() {
 	for (let i = 0; i < 8; i++) r += Math.floor(Math.random() * 16).toString(16);
 	return `mtx_${t}_${r}`;
 }
+/** Fresh per result — a shared object would let one consumer's mutation reach
+*  every other cell in the run. */
+function uncaptured() {
+	return {
+		kind: "uncaptured",
+		usd: null
+	};
+}
 function makeErrorResult(err) {
 	const e = err;
+	const spend = readCellSpend(err);
 	return {
 		output: void 0,
 		verdict: {
 			valid: false,
 			score: 0
 		},
-		costUsd: 0,
-		durationMs: 0,
+		costUsd: spend?.costUsd ?? 0,
+		durationMs: spend?.durationMs ?? 0,
+		costProvenance: spend === void 0 || spend.kind === "uncaptured" ? uncaptured() : {
+			kind: spend.kind,
+			usd: spend.costUsd
+		},
 		error: {
 			message: typeof e?.message === "string" ? e.message : String(err),
 			kind: typeof e?.name === "string" ? e.name : "Error"
 		}
 	};
 }
+/** Make a result safe to sum.
+*
+*  A `costUsd` that cannot be summed fails the cell: `NaN` in `cumulativeCost`
+*  makes `>= costCeiling` false forever, so one bad cell would disable the
+*  ceiling for every cell after it.
+*
+*  A bad `durationMs` reaches only `meanDurationMs`, never the ceiling, so it
+*  cannot justify throwing away a real verdict and a real cost. It is reported
+*  as 0 and warned about, and the rest of the result stands. A wall clock that
+*  steps back mid-cell makes `Date.now() - startedAt` negative, so this is a
+*  reachable state, not only a caller bug. */
+function billableResult(result, onBadDuration) {
+	if (!isAmount(result.costUsd)) return makeErrorResult(/* @__PURE__ */ new RangeError(`runCell reported costUsd=${String(result.costUsd)}; a cell cost must be a finite number >= 0 so the cost ceiling stays enforceable`));
+	if (isAmount(result.durationMs)) return result;
+	onBadDuration(result.durationMs);
+	return {
+		...result,
+		durationMs: 0
+	};
+}
 async function runAgentMatrix(opts) {
 	const startedAt = Date.now();
 	const reps = Math.max(1, opts.reps ?? 1);
 	const maxConcurrency = Math.max(1, opts.maxConcurrency ?? 4);
 	const costCeiling = opts.costCeiling ?? Number.POSITIVE_INFINITY;
 	const aggregateBy = opts.aggregateBy ?? opts.axes.map((a) => a.name);
+	if (opts.maxCellCostUsd !== void 0 && !isAmount(opts.maxCellCostUsd)) throw new RangeError(`runAgentMatrix: maxCellCostUsd must be a finite number >= 0, received ${String(opts.maxCellCostUsd)}`);
 	const base = cartesian(opts.axes);
 	const filtered = opts.filter ? base.filter((c) => opts.filter(c)) : base;
 	const filteredOut = base.length - filtered.length;
@@ -175,6 +304,8 @@ async function runAgentMatrix(opts) {
 	let costCeilingReached = false;
 	let runsExecuted = 0;
 	let cellsUnscheduled = 0;
+	let costUncapturedCells = 0;
+	let badDurationCells = 0;
 	const aborted = () => opts.signal?.aborted === true;
 	let inFlight = 0;
 	let cursor = 0;
@@ -203,10 +334,19 @@ async function runAgentMatrix(opts) {
 				} catch (err) {
 					return makeErrorResult(err);
 				}
-			})().then((result) => {
+			})().then((settled) => {
+				const result = billableResult(settled, (reported) => {
+					badDurationCells++;
+					if (badDurationCells === 1) console.warn(`[matrix] a cell reported durationMs=${String(reported)}; recorded as 0 — meanDurationMs under-reports this run`);
+				});
 				record.runs.push(result);
 				runsExecuted++;
-				cumulativeCost += result.costUsd;
+				const uncapturedCost = result.costProvenance?.kind === "uncaptured";
+				cumulativeCost += uncapturedCost && opts.maxCellCostUsd !== void 0 ? Math.max(result.costUsd, opts.maxCellCostUsd) : result.costUsd;
+				if (uncapturedCost) {
+					costUncapturedCells++;
+					if (costUncapturedCells === 1) console.warn("[matrix] a cell's cost is a subtotal, not a total — totalCostUsd and the cost ceiling under-count this run");
+				}
 				if (cumulativeCost >= costCeiling && !costCeilingReached) {
 					costCeilingReached = true;
 					console.warn("[matrix] cost ceiling reached");
@@ -259,12 +399,14 @@ async function runAgentMatrix(opts) {
 			overallPassRate: runCount === 0 ? 0 : pass / runCount,
 			overallMeanScore: runCount === 0 ? 0 : scoreSum / runCount,
 			totalCostUsd: totalCost,
+			costUncapturedCells,
+			ceilingChargedUsd: cumulativeCost,
 			durationMs: Date.now() - startedAt
 		},
 		matrixId: makeMatrixId()
 	};
 }
 //#endregion
-export { runAgentMatrix as t };
+export { readCellSpend as n, withCellSpend as r, runAgentMatrix as t };
 
-//# sourceMappingURL=matrix-BzQnu2S6.js.map
+//# sourceMappingURL=matrix-pWinRMPl.js.map

package/dist/matrix-pWinRMPl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"matrix-pWinRMPl.js","names":[],"sources":["../src/matrix/cell-spend.ts","../src/matrix/aggregation.ts","../src/matrix/runner.ts"],"sourcesContent":["/**\n * Spend carrier for a cell that fails after it has already spent money.\n *\n * `runCell` reports what a cell cost by returning a `CellResult`. A throw\n * carries no result, so the runner cannot know what the cell spent before it\n * failed: the cumulative sum the cost ceiling reads, and `totalCostUsd`, both\n * miss that money. A throw that carries a `CellSpend` closes the gap — the\n * runner bills the failed cell for the spend the carrier declares, and records\n * a cell that declared nothing as `uncaptured` instead of a zero that reads\n * like \"this cell spent nothing\".\n *\n * The carrier is read structurally, never by `instanceof`, so a throw that\n * crosses a package or realm boundary still bills.\n */\n\n/** Property key the carrier occupies on a thrown object. Stable across\n *  versions — two copies of this package must agree on it. */\nconst CELL_SPEND_KEY = '__agentEvalCellSpend'\n\n/** Money and wall time a cell consumed before it threw. */\nexport interface CellSpend {\n  /** KNOWN subtotal in USD. When `kind` is `uncaptured` the cell spent this\n   *  much AND an unknown amount more, so the value must not be read as the\n   *  cell's total. */\n  costUsd: number\n  /** Wall time the cell consumed before the throw, in milliseconds. */\n  durationMs: number\n  /** `observed` = provider-reported amounts, `estimated` = computed from token\n   *  prices, `uncaptured` = `costUsd` is a subtotal and part of the spend\n   *  could not be measured. */\n  kind: 'observed' | 'estimated' | 'uncaptured'\n}\n\n/**\n * Return `error` carrying `spend`, for a throw site inside `runCell`:\n * `throw withCellSpend(err, { costUsd, durationMs, kind })`.\n *\n * A value that cannot hold the carrier — a thrown string or number, or a\n * frozen, sealed, or otherwise non-extensible object — is wrapped in an\n * `Error` that keeps the original as `cause`, so the spend is never dropped.\n * A later call overwrites an earlier carrier — the outer frame knows more\n * than the inner one.\n *\n * Throws `TypeError` on a non-finite or negative amount. A poisoned amount\n * would reach `cumulativeCost` and disable the cost ceiling for the whole run,\n * because `NaN >= ceiling` is false.\n */\nexport function withCellSpend(error: unknown, spend: CellSpend): unknown {\n  assertAmount(spend.costUsd, 'costUsd')\n  assertAmount(spend.durationMs, 'durationMs')\n  if (spend.kind !== 'observed' && spend.kind !== 'estimated' && spend.kind !== 'uncaptured') {\n    throw new TypeError(\n      `withCellSpend: kind must be observed, estimated or uncaptured, received ${String(spend.kind)}`,\n    )\n  }\n  const carrier: CellSpend = {\n    costUsd: spend.costUsd,\n    durationMs: spend.durationMs,\n    kind: spend.kind,\n  }\n  if (typeof error === 'object' && error !== null && attach(error, carrier)) return error\n  // A primitive cannot hold a property, and a frozen or sealed object refuses\n  // one. Carry the spend on a fresh Error that keeps the original as `cause`\n  // rather than lose it — a dropped carrier bills the cell as uncaptured,\n  // which is the under-billing this module exists to prevent.\n  const wrapper = new Error(`cell failed: ${messageOf(error)}`, { cause: error })\n  attach(wrapper, carrier)\n  return wrapper\n}\n\n/** True when the carrier landed. `defineProperty` throws on a non-extensible\n *  target, so the caller must be able to fall back. */\nfunction attach(target: object, carrier: CellSpend): boolean {\n  try {\n    Object.defineProperty(target, CELL_SPEND_KEY, {\n      value: carrier,\n      enumerable: false,\n      configurable: true,\n      writable: true,\n    })\n    return true\n  } catch {\n    return false\n  }\n}\n\nfunction messageOf(error: unknown): string {\n  if (error instanceof Error) return error.message\n  return String(error)\n}\n\n/** Read the spend a thrown value carries. `undefined` when the value carries\n *  none, or carries one that does not satisfy `CellSpend` — the runner records\n *  both as `uncaptured`. */\nexport function readCellSpend(error: unknown): CellSpend | undefined {\n  if (typeof error !== 'object' || error === null) return undefined\n  const raw = (error as Record<string, unknown>)[CELL_SPEND_KEY]\n  if (typeof raw !== 'object' || raw === null) return undefined\n  const candidate = raw as Record<string, unknown>\n  if (!isAmount(candidate.costUsd) || !isAmount(candidate.durationMs)) return undefined\n  const kind = candidate.kind\n  if (kind !== 'observed' && kind !== 'estimated' && kind !== 'uncaptured') return undefined\n  return { costUsd: candidate.costUsd, durationMs: candidate.durationMs, kind }\n}\n\n/** A number the matrix can add to a running cost or duration: finite and not\n *  negative. Anything else would poison a sum the cost ceiling reads. */\nexport function isAmount(value: unknown): value is number {\n  return typeof value === 'number' && Number.isFinite(value) && value >= 0\n}\n\nfunction assertAmount(value: number, field: string): void {\n  if (!isAmount(value)) {\n    throw new TypeError(\n      `withCellSpend: ${field} must be a finite number >= 0, received ${String(value)}`,\n    )\n  }\n}\n","/**\n * Per-axis aggregation of cell runs into `AxisSummary` rows.\n *\n * Pure: consumes the final `cells: [{cell, runs}]` array and returns the\n * `byAxis` table. Error runs contribute 0 to passRate and meanScore. Cost and\n * duration always count — the budget was spent regardless. A run whose cost is\n * a subtotal rather than a total raises `costUncapturedCells` for its bucket,\n * so a per-axis cost row says when it under-counts.\n */\n\nimport type { AxisSummary, CellResult, MatrixAxis, MatrixCell, MatrixResult } from './types'\n\ninterface Row<Output> {\n  cell: MatrixCell\n  result: CellResult<Output>\n}\n\nfunction flattenRuns<Output>(cells: MatrixResult<Output>['cells']): Row<Output>[] {\n  const rows: Row<Output>[] = []\n  for (const { cell, runs } of cells) {\n    for (const result of runs) rows.push({ cell, result })\n  }\n  return rows\n}\n\nfunction quantile(sorted: number[], q: number): number {\n  if (sorted.length === 0) return 0\n  if (sorted.length === 1) return sorted[0] as number\n  const pos = (sorted.length - 1) * q\n  const lo = Math.floor(pos)\n  const hi = Math.ceil(pos)\n  if (lo === hi) return sorted[lo] as number\n  const frac = pos - lo\n  return (sorted[lo] as number) * (1 - frac) + (sorted[hi] as number) * frac\n}\n\nexport function summariseRows<Output>(\n  rows: Row<Output>[],\n  axisName: string,\n  axisValue: string,\n): AxisSummary {\n  if (rows.length === 0) {\n    return {\n      axisName,\n      axisValue,\n      cells: 0,\n      passRate: 0,\n      meanScore: 0,\n      p50Score: 0,\n      p90Score: 0,\n      totalCostUsd: 0,\n      costUncapturedCells: 0,\n      meanDurationMs: 0,\n    }\n  }\n  let pass = 0\n  let scoreSum = 0\n  let costSum = 0\n  let durSum = 0\n  let costUncapturedCells = 0\n  const scores: number[] = []\n  for (const { result } of rows) {\n    const errored = result.error !== undefined\n    const score = errored ? 0 : result.verdict.score\n    const valid = !errored && result.verdict.valid\n    if (valid) pass++\n    scoreSum += score\n    scores.push(score)\n    costSum += result.costUsd\n    durSum += result.durationMs\n    if (result.costProvenance?.kind === 'uncaptured') costUncapturedCells++\n  }\n  scores.sort((a, b) => a - b)\n  return {\n    axisName,\n    axisValue,\n    cells: rows.length,\n    passRate: pass / rows.length,\n    meanScore: scoreSum / rows.length,\n    p50Score: quantile(scores, 0.5),\n    p90Score: quantile(scores, 0.9),\n    totalCostUsd: costSum,\n    costUncapturedCells,\n    meanDurationMs: durSum / rows.length,\n  }\n}\n\nfunction bucketBy<Output>(\n  rows: Row<Output>[],\n  axisName: string,\n  labelFor: (id: string) => string,\n): Record<string, AxisSummary> {\n  const buckets = new Map<string, Row<Output>[]>()\n  for (const row of rows) {\n    const slot = row.cell.axes[axisName]\n    if (!slot) continue\n    const id = slot.id\n    let arr = buckets.get(id)\n    if (!arr) {\n      arr = []\n      buckets.set(id, arr)\n    }\n    arr.push(row)\n  }\n  const out: Record<string, AxisSummary> = {}\n  // Sorted keys for deterministic JSON serialisation.\n  for (const id of [...buckets.keys()].sort()) {\n    out[id] = summariseRows(buckets.get(id) as Row<Output>[], axisName, labelFor(id))\n  }\n  return out\n}\n\nexport function buildByAxis<Output>(\n  cells: MatrixResult<Output>['cells'],\n  axes: MatrixAxis<unknown>[],\n  aggregateBy: string[],\n): Record<string, Record<string, AxisSummary>> {\n  const rows = flattenRuns(cells)\n  const byName = new Map(axes.map((a) => [a.name, a]))\n  const byAxis: Record<string, Record<string, AxisSummary>> = {}\n  for (const name of aggregateBy) {\n    const axis = byName.get(name)\n    const labelFor = (id: string): string => {\n      if (!axis?.label) return id\n      const found = axis.values.find((v) => v.id === id)\n      if (!found) return id\n      return axis.label(found.value, id)\n    }\n    byAxis[name] = bucketBy(rows, name, labelFor)\n  }\n  return byAxis\n}\n","/**\n * N-axis cartesian runner.\n *\n * Expansion order: cartesian over `axes` in declared order, then `reps` as the\n * inner-most dim → `ordinal = (cartIdx * reps) + rep`. The returned\n * `cells[]` is sorted by `ordinal` so concurrent execution does not reorder\n * the output.\n *\n * Scheduling is a sliding window of in-flight promises capped at\n * `maxConcurrency`. The window stops admitting new cells when the cost\n * ceiling trips or the abort signal fires; in-flight cells finish.\n */\n\nimport { buildByAxis } from './aggregation'\nimport { isAmount, readCellSpend } from './cell-spend'\nimport type {\n  CellResult,\n  CostProvenance,\n  MatrixAxis,\n  MatrixCell,\n  MatrixResult,\n  RunAgentMatrixOptions,\n} from './types'\n\ninterface BaseCell {\n  axes: Record<string, { id: string; value: unknown }>\n}\n\nfunction cartesian(axes: MatrixAxis<unknown>[]): BaseCell[] {\n  // Empty axes (`values=[]`) collapse the whole product to zero cells. An\n  // empty `axes` array yields a single empty-axes cell — degenerate but\n  // valid (caller is iterating only reps).\n  if (axes.length === 0) return [{ axes: {} }]\n  for (const a of axes) if (a.values.length === 0) return []\n  const out: BaseCell[] = []\n  const idx = new Array(axes.length).fill(0)\n  while (true) {\n    const slot: Record<string, { id: string; value: unknown }> = {}\n    for (let i = 0; i < axes.length; i++) {\n      const axis = axes[i] as MatrixAxis<unknown>\n      const v = axis.values[idx[i] as number] as { id: string; value: unknown }\n      slot[axis.name] = { id: v.id, value: v.value }\n    }\n    out.push({ axes: slot })\n    // Increment like an odometer, left-most axis is fastest.\n    let i = 0\n    while (i < axes.length) {\n      const next = (idx[i] as number) + 1\n      const axis = axes[i] as MatrixAxis<unknown>\n      if (next < axis.values.length) {\n        idx[i] = next\n        break\n      }\n      idx[i] = 0\n      i++\n    }\n    if (i === axes.length) break\n  }\n  return out\n}\n\nfunction makeMatrixId(): string {\n  // Stable id-like string: time + 8 random hex chars. Avoids node:crypto\n  // import to keep the matrix dep-free.\n  const t = Date.now().toString(36)\n  let r = ''\n  for (let i = 0; i < 8; i++) r += Math.floor(Math.random() * 16).toString(16)\n  return `mtx_${t}_${r}`\n}\n\n/** Fresh per result — a shared object would let one consumer's mutation reach\n *  every other cell in the run. */\nfunction uncaptured(): CostProvenance {\n  return { kind: 'uncaptured', usd: null }\n}\n\nfunction makeErrorResult<Output>(err: unknown): CellResult<Output> {\n  const e = err as { message?: string; name?: string }\n  const spend = readCellSpend(err)\n  return {\n    output: undefined as unknown as Output,\n    verdict: { valid: false, score: 0 },\n    costUsd: spend?.costUsd ?? 0,\n    durationMs: spend?.durationMs ?? 0,\n    costProvenance:\n      spend === undefined || spend.kind === 'uncaptured'\n        ? uncaptured()\n        : { kind: spend.kind, usd: spend.costUsd },\n    error: {\n      message: typeof e?.message === 'string' ? e.message : String(err),\n      kind: typeof e?.name === 'string' ? e.name : 'Error',\n    },\n  }\n}\n\n/** Make a result safe to sum.\n *\n *  A `costUsd` that cannot be summed fails the cell: `NaN` in `cumulativeCost`\n *  makes `>= costCeiling` false forever, so one bad cell would disable the\n *  ceiling for every cell after it.\n *\n *  A bad `durationMs` reaches only `meanDurationMs`, never the ceiling, so it\n *  cannot justify throwing away a real verdict and a real cost. It is reported\n *  as 0 and warned about, and the rest of the result stands. A wall clock that\n *  steps back mid-cell makes `Date.now() - startedAt` negative, so this is a\n *  reachable state, not only a caller bug. */\nfunction billableResult<Output>(\n  result: CellResult<Output>,\n  onBadDuration: (reported: unknown) => void,\n): CellResult<Output> {\n  if (!isAmount(result.costUsd)) {\n    return makeErrorResult<Output>(\n      new RangeError(\n        `runCell reported costUsd=${String(result.costUsd)}; a cell cost must be a finite number >= 0 so the cost ceiling stays enforceable`,\n      ),\n    )\n  }\n  if (isAmount(result.durationMs)) return result\n  onBadDuration(result.durationMs)\n  return { ...result, durationMs: 0 }\n}\n\nexport async function runAgentMatrix<Output>(\n  opts: RunAgentMatrixOptions<Output>,\n): Promise<MatrixResult<Output>> {\n  const startedAt = Date.now()\n  const reps = Math.max(1, opts.reps ?? 1)\n  const maxConcurrency = Math.max(1, opts.maxConcurrency ?? 4)\n  const costCeiling = opts.costCeiling ?? Number.POSITIVE_INFINITY\n  const aggregateBy = opts.aggregateBy ?? opts.axes.map((a) => a.name)\n  if (opts.maxCellCostUsd !== undefined && !isAmount(opts.maxCellCostUsd)) {\n    throw new RangeError(\n      `runAgentMatrix: maxCellCostUsd must be a finite number >= 0, received ${String(opts.maxCellCostUsd)}`,\n    )\n  }\n\n  const base = cartesian(opts.axes)\n  const filtered = opts.filter\n    ? base.filter((c) => (opts.filter as (b: BaseCell) => boolean)(c))\n    : base\n  const filteredOut = base.length - filtered.length\n\n  const planned: MatrixCell[] = []\n  for (let i = 0; i < filtered.length; i++) {\n    for (let r = 0; r < reps; r++) {\n      planned.push({\n        axes: (filtered[i] as BaseCell).axes,\n        rep: r,\n        ordinal: i * reps + r,\n      })\n    }\n  }\n\n  const cellRecords: Array<{ cell: MatrixCell; runs: CellResult<Output>[] }> = []\n  // What the ceiling reads. It runs ahead of the reported total whenever a\n  // cell's cost is a subtotal and `maxCellCostUsd` bounds what it could have\n  // been — a budget must assume the worst about spend it cannot see.\n  let cumulativeCost = 0\n  let costCeilingReached = false\n  let runsExecuted = 0\n  let cellsUnscheduled = 0\n  let costUncapturedCells = 0\n  let badDurationCells = 0\n\n  const aborted = (): boolean => opts.signal?.aborted === true\n\n  // Per-run abort controller forwards the external signal so cell executors\n  // see cancellation. We don't expose it on `MatrixCell` — the signature on\n  // `runCell` per the public API is `(cell) => Promise<...>`. Executors that\n  // need cancellation use the external signal directly via closure.\n\n  let inFlight = 0\n  let cursor = 0\n  let resolveAll: (() => void) | undefined\n  const done = new Promise<void>((res) => {\n    resolveAll = res\n  })\n\n  const pump = (): void => {\n    while (inFlight < maxConcurrency && cursor < planned.length) {\n      if (aborted() || costCeilingReached) {\n        // Drain remaining as unscheduled.\n        const left = planned.length - cursor\n        cellsUnscheduled += left\n        cursor = planned.length\n        break\n      }\n      const cell = planned[cursor++] as MatrixCell\n      inFlight++\n      // Lazily allocate the record so cells appear in `cells[]` in any\n      // arrival order; we sort by ordinal at the end.\n      const record = { cell, runs: [] as CellResult<Output>[] }\n      cellRecords.push(record)\n      const promise: Promise<CellResult<Output>> = (async () => {\n        try {\n          return await opts.runCell(cell)\n        } catch (err) {\n          return makeErrorResult<Output>(err)\n        }\n      })()\n      promise.then((settled) => {\n        const result = billableResult(settled, (reported) => {\n          badDurationCells++\n          if (badDurationCells === 1) {\n            // eslint-disable-next-line no-console\n            console.warn(\n              `[matrix] a cell reported durationMs=${String(reported)}; recorded as 0 — meanDurationMs under-reports this run`,\n            )\n          }\n        })\n        record.runs.push(result)\n        runsExecuted++\n        const uncapturedCost = result.costProvenance?.kind === 'uncaptured'\n        cumulativeCost +=\n          uncapturedCost && opts.maxCellCostUsd !== undefined\n            ? Math.max(result.costUsd, opts.maxCellCostUsd)\n            : result.costUsd\n        if (uncapturedCost) {\n          costUncapturedCells++\n          if (costUncapturedCells === 1) {\n            // eslint-disable-next-line no-console\n            console.warn(\n              \"[matrix] a cell's cost is a subtotal, not a total — totalCostUsd and the cost ceiling under-count this run\",\n            )\n          }\n        }\n        if (cumulativeCost >= costCeiling && !costCeilingReached) {\n          costCeilingReached = true\n          // eslint-disable-next-line no-console\n          console.warn('[matrix] cost ceiling reached')\n        }\n        try {\n          opts.onCellComplete?.(cell, result)\n        } catch {\n          // onCellComplete is observational — swallow throws so a noisy\n          // callback can't tank the run.\n        }\n        inFlight--\n        if (cursor < planned.length) {\n          pump()\n        } else if (inFlight === 0) {\n          resolveAll?.()\n        }\n      })\n    }\n    if (cursor >= planned.length && inFlight === 0) resolveAll?.()\n  }\n\n  const onAbort = (): void => {\n    // External abort: stop scheduling. In-flight cells finish; their\n    // executors observe `opts.signal.aborted` directly via closure.\n    if (cursor < planned.length) {\n      cellsUnscheduled += planned.length - cursor\n      cursor = planned.length\n    }\n    if (inFlight === 0) resolveAll?.()\n  }\n  if (opts.signal) {\n    if (opts.signal.aborted) {\n      cellsUnscheduled = planned.length\n      cursor = planned.length\n      resolveAll?.()\n    } else {\n      opts.signal.addEventListener('abort', onAbort, { once: true })\n    }\n  }\n\n  if (planned.length === 0) {\n    resolveAll?.()\n  } else {\n    pump()\n  }\n\n  await done\n  if (opts.signal) opts.signal.removeEventListener('abort', onAbort)\n\n  cellRecords.sort((a, b) => a.cell.ordinal - b.cell.ordinal)\n\n  let pass = 0\n  let scoreSum = 0\n  let totalCost = 0\n  let runCount = 0\n  for (const { runs } of cellRecords) {\n    for (const r of runs) {\n      runCount++\n      const errored = r.error !== undefined\n      if (!errored && r.verdict.valid) pass++\n      scoreSum += errored ? 0 : r.verdict.score\n      totalCost += r.costUsd\n    }\n  }\n\n  const byAxis = buildByAxis(cellRecords, opts.axes, aggregateBy)\n\n  return {\n    cells: cellRecords,\n    byAxis,\n    summary: {\n      totalCells: planned.length,\n      runsExecuted,\n      cellsSkipped: cellsUnscheduled + filteredOut * reps,\n      overallPassRate: runCount === 0 ? 0 : pass / runCount,\n      overallMeanScore: runCount === 0 ? 0 : scoreSum / runCount,\n      totalCostUsd: totalCost,\n      costUncapturedCells,\n      ceilingChargedUsd: cumulativeCost,\n      durationMs: Date.now() - startedAt,\n    },\n    matrixId: makeMatrixId(),\n  }\n}\n"],"mappings":"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"}