@tangle-network/agent-eval 0.216.0 → 0.217.1

package/dist/{analyze-runs-3xpby3p2.js → analyze-runs-DqPJaJ4X.js}

@@ -1,443 +1,225 @@
-import { i as pairedCohensDz } from "./effect-sizes-DiH8MGOH.js";
-import { r as welchsTTest } from "./baseline-Dm8966du.js";
-import { a as spearmanR, r as pearsonR } from "./descriptive-CnU8Yq29.js";
-import { r as continuousAgreement } from "./judge-calibration-N44V04Se.js";
-import { o as pairedTTest, r as pairedBootstrap } from "./paired-tests-jbwPdSz5.js";
-import { i as requiredPairedSampleSize, r as pairedMde } from "./power-and-mde-fK5Qocwo.js";
-import { r as pairRunRecords } from "./paired-arms-DzKn0TfY.js";
-import { n as aggregatePairedHoldout } from "./statistical-heldout-1Gbmex7v.js";
-import "./query-B1D1qp2Z.js";
+import { s as ValidationError } from "./errors-BcOs5MKW.js";
 import { r as observedSplitScore } from "./reward-nw2xZGZG.js";
-import { c as validateRunRecord } from "./run-record-DlTZ_lqe.js";
-import { r as paretoChart } from "./summary-report-DtdRucM0.js";
-//#region src/contamination-guard.ts
-function checkCanaries(output, scenarios) {
-	const leaks = [];
-	for (const s of scenarios) {
-		if (!s.canary) continue;
-		if (output.includes(s.canary)) leaks.push({
-			scenarioId: s.id,
-			canary: s.canary,
-			evidence: excerpt(output, s.canary)
-		});
-	}
-	return leaks;
+import { c as validateRunRecord } from "./run-record-DhEJgoPz.js";
+import { c as pairedCohensDz, o as cohensD, r as paretoChart } from "./summary-report-BsXJoYX5.js";
+import { t as interpolatedQuantile } from "./quantile--0yb07pD.js";
+import { c as lnGamma, l as regularizedIncompleteBeta, t as assertFiniteSample$1 } from "./internal-BTK91Bqt.js";
+import { a as spearmanR, r as pearsonR } from "./descriptive-CVNy48rR.js";
+import { r as continuousAgreement } from "./judge-calibration-BkXMIWA4.js";
+import { o as normalCdf, r as pairRunRecords } from "./paired-arms-Ct4LTKc1.js";
+import { i as pairedBootstrap, l as studentTQuantile, s as pairedTTest, t as mean$1 } from "./mean-BbA_JCzW.js";
+import { i as requiredPairedSampleSize, r as pairedMde } from "./power-and-mde-N5nU4_Ly.js";
+import { n as aggregatePairedHoldout } from "./statistical-heldout-Bksv92Th.js";
+import "./query-B_RZ36an.js";
+//#region src/statistics/inference.ts
+/** Two-sided normal tail, evaluated without subtracting a near-one CDF. */
+function normalTwoSidedPValue(z) {
+	if (Number.isNaN(z)) throw new ValidationError("normalTwoSidedPValue: z must not be NaN");
+	return Math.min(1, 2 * normalCdf(-Math.abs(z)));
 }
-function excerpt(source, needle) {
-	const at = source.indexOf(needle);
-	if (at < 0) return "";
-	const start = Math.max(0, at - 30);
-	const end = Math.min(source.length, at + needle.length + 30);
-	return (start > 0 ? "…" : "") + source.slice(start, end) + (end < source.length ? "…" : "");
+/** Two-sided Student-t tail, preserving small tail probabilities. */
+function studentTTwoSidedPValue(t, df) {
+	if (Number.isNaN(t) || !Number.isFinite(df) || df <= 0) throw new ValidationError("studentTTwoSidedPValue: t must not be NaN and df must be positive and finite");
+	return regularizedIncompleteBeta(df / (df + t * t), df / 2, .5);
 }
-//#endregion
-//#region src/contract/analyze-runs.ts
-/** Summarize runtime facts without interpreting task quality or promotion readiness. */
-function summarizeExecution(opts) {
-	const runs = opts.runs.map(validateRunRecord);
-	return {
-		execution: computeExecutionInsight(runs, opts.histogramBins ?? 12),
-		costProvenance: summarizeCostProvenance(runs)
-	};
+function table(a, b, c, d) {
+	if (![
+		a,
+		b,
+		c,
+		d
+	].every((value) => Number.isSafeInteger(value) && value >= 0) || !Number.isSafeInteger(a + b + c + d)) throw new ValidationError("contingency table: counts and total must be nonnegative safe integers");
+	return a + b + c + d;
 }
-/** A bootstrap interval with no spread: every resample landed on the same
-*  value, so the interval carries no information about how far the point
-*  estimate could be wrong and cannot support a directional claim. */
-function zeroWidth(ci) {
-	return !Number.isFinite(ci[0]) || !Number.isFinite(ci[1]) || ci[0] === ci[1];
+/** Pearson statistic for a 2x2 table; empty or fixed margins have statistic zero. */
+function chiSquared(a, b, c, d) {
+	const n = table(a, b, c, d);
+	if (!n) return 0;
+	const expected = [
+		(a + b) * (a + c) / n,
+		(a + b) * (b + d) / n,
+		(c + d) * (a + c) / n,
+		(c + d) * (b + d) / n
+	];
+	if (expected.some((value) => value === 0)) return 0;
+	return [
+		a,
+		b,
+		c,
+		d
+	].reduce((sum, value, i) => sum + (value - expected[i]) ** 2 / expected[i], 0);
 }
-async function analyzeRuns(opts) {
-	const runs = opts.runs.map(validateRunRecord);
-	const bins = opts.histogramBins ?? 12;
-	const threshold = opts.decisionThreshold ?? .02;
-	if (!Number.isFinite(threshold)) throw new Error(`analyzeRuns: decisionThreshold must be finite, got ${threshold}`);
-	const split = resolveSplit(runs, opts.split ?? "auto");
-	const compositeWithIds = runs.map((r) => ({
-		runId: r.runId,
-		score: compositeOf(r, split)
-	})).filter((p) => Number.isFinite(p.score));
-	const composite = distributionOf(compositeWithIds.map((p) => p.score), bins, compositeWithIds);
-	const perDimension = computePerDimension(runs, bins);
-	const { execution, costProvenance: provenance } = summarizeExecution({
-		runs,
-		histogramBins: bins
-	});
-	const knownCostRuns = runs.filter((run) => run.costProvenance.usd !== null);
-	const costs = knownCostRuns.map((r) => r.costUsd).filter(isFiniteNumber);
-	const costDist = distributionOf(costs, bins);
-	const pareto = paretoChart(knownCostRuns, { split });
-	const degraded = {};
-	if (provenance.uncaptured.n + provenance.lowerBound.n > 0) degraded.cost = diagnoseCostCoverage(runs, provenance);
-	else if (costs.length === 0 || costs.every((c) => c === 0)) degraded.cost = `all ${runs.length} explicitly observed or estimated USD values are $0`;
-	if (pareto.points.length < 2) degraded.pareto = pareto.points.length === 0 ? "no candidates — Pareto unavailable" : "single candidate — Pareto is a single point, not a frontier";
-	const costQuality = {
-		cost: costDist,
-		pareto,
-		provenance,
-		...degraded.cost || degraded.pareto ? { degraded } : {}
+/** One-degree-of-freedom chi-squared survival probability. */
+function chiSquaredPValue(statistic) {
+	if (Number.isNaN(statistic) || statistic < 0) throw new ValidationError("chiSquaredPValue: statistic must be nonnegative and not NaN");
+	return normalTwoSidedPValue(Math.sqrt(statistic));
+}
+/** Fisher two-sided probability: sum all fixed-margin tables no likelier than the observed table. */
+function fisherExactTwoSided(a, b, c, d) {
+	const n = table(a, b, c, d), row1 = a + b, row2 = c + d, col1 = a + c;
+	if (!n || !row1 || !row2 || !col1 || col1 === n) return 1;
+	const logChoose = (total, count) => lnGamma(total + 1) - lnGamma(count + 1) - lnGamma(total - count + 1);
+	const denominator = logChoose(n, col1);
+	const logP = (count) => logChoose(row1, count) + logChoose(row2, col1 - count) - denominator;
+	const threshold = logP(a) + 1e-7;
+	let p = 0;
+	for (let k = Math.max(0, col1 - row2); k <= Math.min(row1, col1); k++) {
+		const probability = logP(k);
+		if (probability <= threshold) p += Math.exp(probability);
+	}
+	return Math.min(1, p);
+}
+/** Fisher when any expected count is below five; otherwise Pearson's chi-squared tail. */
+function twoByTwoPValue(a, b, c, d) {
+	const n = table(a, b, c, d);
+	if (!n) return 1;
+	return Math.min((a + b) * (a + c), (a + b) * (b + d), (c + d) * (a + c), (c + d) * (b + d)) / n < 5 ? fisherExactTwoSided(a, b, c, d) : chiSquaredPValue(chiSquared(a, b, c, d));
+}
+/** Centered least-squares slope; null p-value means no slope test was possible. */
+function linearRegressionSlope(points) {
+	assertFiniteSample$1("linearRegressionSlope", "x", points.map((point) => point.x));
+	assertFiniteSample$1("linearRegressionSlope", "y", points.map((point) => point.y));
+	if (points.length < 2) return {
+		slope: 0,
+		rSquared: 0,
+		slopePValue: null
 	};
-	const judges = computeJudgeInsights(runs);
-	const interRater = opts.raterScores ? computeInterRater(opts.raterScores) : void 0;
-	const lift = computeLift(runs, opts.baselineCandidateId, opts.candidateCandidateId, split, opts.independentUnitByScenarioId);
-	const failureClusters = opts.analyst ? await computeFailureClusters(runs, opts.analyst, split) : void 0;
-	const failureClasses = computeFailureClasses(runs, split);
-	const contamination = opts.canaryScenarios ? computeContamination(runs, opts.canaryScenarios) : void 0;
-	const outcomeCorrelation = opts.outcomeSignal ? computeOutcomeCorrelation(runs, opts.outcomeSignal, split) : void 0;
-	const release = buildReleaseScorecard(composite, lift, contamination);
-	const priorPeriodComparison = opts.baselineRuns ? computePriorPeriodComparison(runs, opts.baselineRuns, split, opts.baselineLabel) : void 0;
-	const recommendations = buildRecommendations({
-		composite,
-		judges,
-		interRater,
-		lift,
-		failureClusters,
-		failureClasses,
-		contamination,
-		outcomeCorrelation,
-		priorPeriodComparison,
-		threshold
-	});
+	const n = points.length;
+	const meanX = points.reduce((sum, point) => sum + point.x / n, 0);
+	const meanY = points.reduce((sum, point) => sum + point.y / n, 0);
+	const sxx = points.reduce((sum, point) => sum + (point.x - meanX) ** 2, 0);
+	const syy = points.reduce((sum, point) => sum + (point.y - meanY) ** 2, 0);
+	const sxy = points.reduce((sum, point) => sum + (point.x - meanX) * (point.y - meanY), 0);
+	if (!sxx) return {
+		slope: 0,
+		rSquared: 0,
+		slopePValue: null
+	};
+	const slope = sxy / sxx;
+	const residual = points.reduce((sum, point) => sum + (point.y - meanY - slope * (point.x - meanX)) ** 2, 0);
+	if (![
+		slope,
+		residual,
+		sxx,
+		sxy,
+		syy
+	].every(Number.isFinite)) throw new ValidationError("linearRegressionSlope: sample arithmetic exceeded finite range");
 	return {
-		n: runs.length,
-		execution,
-		composite,
-		perDimension,
-		costQuality,
-		judges,
-		interRater,
-		lift,
-		failureClusters,
-		contamination,
-		outcomeCorrelation,
-		release,
-		...failureClasses ? { failureClasses } : {},
-		...priorPeriodComparison ? { priorPeriodComparison } : {},
-		recommendations
+		slope,
+		rSquared: syy === 0 ? 0 : Math.max(0, 1 - residual / syy),
+		slopePValue: n < 3 ? null : residual === 0 ? slope === 0 ? 1 : 0 : studentTTwoSidedPValue(slope / Math.sqrt(residual / (n - 2) / sxx), n - 2)
 	};
 }
-function computeExecutionInsight(runs, bins) {
-	const aggregateRows = runs.flatMap((run) => {
-		const usage = aggregateTokenUsage(run);
-		return usage ? [{
-			usage,
-			costUsd: finiteRaw(run, "aggregate_cost_usd")
-		}] : [];
-	});
-	const aggregateCosts = aggregateRows.flatMap((row) => row.costUsd !== void 0 ? [row.costUsd] : []);
-	const modelCounts = /* @__PURE__ */ new Map();
-	let executionErrorRuns = 0;
-	let executionErrorEvents = 0;
-	let errorReportingRuns = 0;
-	let errorSpanEvents = 0;
-	let errorSpanReportingRuns = 0;
-	const terminalOutcomes = {
-		succeeded: 0,
-		failed: 0,
-		cancelled: 0,
-		incomplete: 0,
-		unknown: 0
+//#endregion
+//#region src/baseline.ts
+/**
+* Baseline regression detection.
+*
+* Lifted from ADC baseline.ts. Every promotion-blocking signal boils down
+* to: "is this run measurably worse than baseline?" — with enough
+* statistical rigor to distinguish noise from drift.
+*
+* Uses:
+*   - Welch's t-test (unequal variance) for per-metric mean comparison
+*   - Cohen's d for effect size magnitude
+*   - IQR for stability flag (unstable samples can't be trusted for comparisons)
+*
+* Returns a structured verdict: improved | regressed | stable | unstable.
+*/
+function mean(xs) {
+	return xs.length ? xs.reduce((sum, value) => sum + value / xs.length, 0) : NaN;
+}
+/** Inter-quartile range; 0 when the sample has no spread. */
+function iqr(xs) {
+	if (xs.length === 0) return 0;
+	const sorted = [...xs].sort((a, b) => a - b);
+	return interpolatedQuantile(sorted, .75) - interpolatedQuantile(sorted, .25);
+}
+/**
+* Welch's t-test and 95% interval for two independent samples.
+*
+* Uses the Student-t distribution at every finite degree of freedom. Fewer
+* than two observations per side and zero observed standard error cannot
+* define a t reference distribution; those cases return an explicit status,
+* `NaN` inferential fields, and no interval rather than fabricated certainty.
+*/
+function welchsTTest(a, b) {
+	assertFiniteSample("a", a);
+	assertFiniteSample("b", b);
+	const mA = mean(a);
+	const mB = mean(b);
+	const delta = mB - mA;
+	if (a.length && !Number.isFinite(mA) || b.length && !Number.isFinite(mB) || a.length && b.length && !Number.isFinite(delta)) throw new RangeError("welchsTTest: sample arithmetic exceeded finite range");
+	if (a.length < 2 || b.length < 2) return {
+		status: "insufficient-sample",
+		meanA: mA,
+		meanB: mB,
+		delta,
+		standardError: NaN,
+		t: NaN,
+		df: NaN,
+		p: NaN,
+		ci95: null,
+		cohensD: null
 	};
-	const errorsByTerminalOutcome = {
-		succeeded: {
-			withErrors: 0,
-			withoutErrors: 0,
-			unreported: 0
-		},
-		failed: {
-			withErrors: 0,
-			withoutErrors: 0,
-			unreported: 0
-		},
-		cancelled: {
-			withErrors: 0,
-			withoutErrors: 0,
-			unreported: 0
-		},
-		incomplete: {
-			withErrors: 0,
-			withoutErrors: 0,
-			unreported: 0
-		},
-		unknown: {
-			withErrors: 0,
-			withoutErrors: 0,
-			unreported: 0
-		}
+	const vA = variance(a, mA);
+	const vB = variance(b, mB);
+	const seSquared = vA / a.length + vB / b.length;
+	if (!Number.isFinite(seSquared)) throw new RangeError("welchsTTest: sample arithmetic exceeded finite range");
+	const d = cohensD(a, b);
+	if (seSquared === 0) return {
+		status: "zero-variance",
+		meanA: mA,
+		meanB: mB,
+		delta,
+		standardError: 0,
+		t: delta === 0 ? 0 : Math.sign(delta) * Number.POSITIVE_INFINITY,
+		df: NaN,
+		p: NaN,
+		ci95: null,
+		cohensD: null
 	};
-	let modelCallRuns = 0;
-	let modelCallEvents = 0;
-	let modelCallReportingRuns = 0;
-	for (const run of runs) {
-		modelCounts.set(run.model, (modelCounts.get(run.model) ?? 0) + 1);
-		const terminalOutcome = run.terminalOutcome;
-		terminalOutcomes[terminalOutcome] += 1;
-		const modelCalls = nonNegativeCountRaw(run, "llm_span_count");
-		if (modelCalls !== void 0) {
-			modelCallEvents += modelCalls;
-			modelCallReportingRuns += 1;
-		}
-		const usage = run.tokenUsage;
-		if ((modelCalls ?? 0) > 0 || usage.input > 0 || usage.output > 0 || (usage.cached ?? 0) > 0 || (usage.cacheWrite ?? 0) > 0) modelCallRuns += 1;
-		const errorEvents = reportedExecutionErrorEvents(run);
-		if (errorEvents !== void 0) {
-			executionErrorEvents += errorEvents;
-			errorReportingRuns += 1;
-			if (errorEvents > 0) {
-				executionErrorRuns += 1;
-				errorsByTerminalOutcome[terminalOutcome].withErrors += 1;
-			} else errorsByTerminalOutcome[terminalOutcome].withoutErrors += 1;
-		} else errorsByTerminalOutcome[terminalOutcome].unreported += 1;
-		const reportedErrorSpans = nonNegativeCountRaw(run, "error_span_count");
-		if (reportedErrorSpans !== void 0) {
-			errorSpanEvents += reportedErrorSpans;
-			errorSpanReportingRuns += 1;
-		}
-	}
+	const standardError = Math.sqrt(seSquared);
+	const t = delta / standardError;
+	const fractionA = vA / a.length / seSquared;
+	const fractionB = vB / b.length / seSquared;
+	const df = 1 / (fractionA ** 2 / (a.length - 1) + fractionB ** 2 / (b.length - 1));
+	const p = studentTTwoSidedPValue(t, df);
+	if (d === null) throw new Error("welchsTTest: non-zero standard error produced no pooled effect size");
+	const halfWidth = studentTQuantile(.975, df) * standardError;
+	if (![
+		df,
+		d,
+		halfWidth,
+		delta - halfWidth,
+		delta + halfWidth
+	].every(Number.isFinite)) throw new RangeError("welchsTTest: sample arithmetic exceeded finite range");
 	return {
-		durationMs: distributionOf(runs.map((run) => run.wallMs), bins),
-		queueMs: distributionOf(runs.filter((run) => run.queueMs !== void 0).map((run) => run.queueMs), bins),
-		tokenUsage: summarizeTokenUsage(runs.map((run) => run.tokenUsage), bins),
-		aggregateUsage: {
-			runs: aggregateRows.length,
-			tokenUsage: summarizeTokenUsage(aggregateRows.map((row) => row.usage), bins),
-			costUsd: distributionOf(aggregateCosts, bins),
-			totalCostUsd: aggregateCosts.reduce((total, value) => total + value, 0)
-		},
-		models: [...modelCounts.entries()].map(([model, count]) => ({
-			model,
-			runs: count
-		})).sort((left, right) => right.runs - left.runs || left.model.localeCompare(right.model)),
-		modelCalls: {
-			runs: modelCallRuns,
-			events: modelCallEvents,
-			reportingRuns: modelCallReportingRuns
-		},
-		executionErrors: {
-			runs: executionErrorRuns,
-			fraction: errorReportingRuns > 0 ? executionErrorRuns / errorReportingRuns : null,
-			events: executionErrorEvents,
-			reportingRuns: errorReportingRuns,
-			errorSpanEvents,
-			errorSpanReportingRuns,
-			byTerminalOutcome: errorsByTerminalOutcome
-		},
-		terminalOutcomes
+		status: "ok",
+		meanA: mA,
+		meanB: mB,
+		delta,
+		standardError,
+		t,
+		df,
+		p,
+		ci95: [delta - halfWidth, delta + halfWidth],
+		cohensD: d
 	};
 }
-function reportedExecutionErrorEvents(run) {
-	return nonNegativeCountRaw(run, "execution_error_count");
+function variance(xs, m) {
+	return xs.reduce((acc, x) => acc + (x - m) ** 2, 0) / (xs.length - 1);
 }
-function nonNegativeCountRaw(run, key) {
-	const value = finiteRaw(run, key);
-	return value !== void 0 && Number.isInteger(value) && value >= 0 ? value : void 0;
+function assertFiniteSample(name, sample) {
+	const invalid = sample.find((value) => !Number.isFinite(value));
+	if (invalid !== void 0) throw new RangeError(`welchsTTest: sample ${name} must contain only finite values, got ${invalid}`);
 }
-function summarizeTokenUsage(usages, bins) {
-	const reasoning = usages.flatMap((usage) => usage.reasoning !== void 0 ? [usage.reasoning] : []);
-	const cached = usages.flatMap((usage) => usage.cached !== void 0 ? [usage.cached] : []);
-	const cacheWrite = usages.flatMap((usage) => usage.cacheWrite !== void 0 ? [usage.cacheWrite] : []);
-	return {
-		input: distributionOf(usages.map((usage) => usage.input), bins),
-		output: distributionOf(usages.map((usage) => usage.output), bins),
-		reasoning: distributionOf(reasoning, bins),
-		cached: distributionOf(cached, bins),
-		cacheWrite: distributionOf(cacheWrite, bins),
-		totals: {
-			input: usages.reduce((total, usage) => total + usage.input, 0),
-			output: usages.reduce((total, usage) => total + usage.output, 0),
-			reasoning: reasoning.reduce((total, value) => total + value, 0),
-			cached: cached.reduce((total, value) => total + value, 0),
-			cacheWrite: cacheWrite.reduce((total, value) => total + value, 0)
-		}
-	};
-}
-function aggregateTokenUsage(run) {
-	const input = finiteRaw(run, "aggregate_prompt_tokens");
-	const output = finiteRaw(run, "aggregate_completion_tokens");
-	const reasoning = finiteRaw(run, "aggregate_reasoning_tokens");
-	const cached = finiteRaw(run, "aggregate_cached_tokens");
-	const cacheWrite = finiteRaw(run, "aggregate_cache_write_tokens");
-	if (input === void 0 && output === void 0 && reasoning === void 0 && cached === void 0 && cacheWrite === void 0) return void 0;
-	return {
-		input: input ?? 0,
-		output: output ?? 0,
-		...reasoning !== void 0 ? { reasoning } : {},
-		...cached !== void 0 ? { cached } : {},
-		...cacheWrite !== void 0 ? { cacheWrite } : {}
-	};
-}
-function finiteRaw(run, key) {
-	const value = run.outcome.raw[key];
-	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
-}
-function summarizeCostProvenance(runs) {
-	const summary = {
-		observed: {
-			n: 0,
-			totalUsd: 0
-		},
-		estimated: {
-			n: 0,
-			totalUsd: 0
-		},
-		lowerBound: {
-			n: 0,
-			floorUsd: 0
-		},
-		uncaptured: { n: 0 },
-		knownFraction: 0
-	};
-	for (const run of runs) {
-		const cost = run.costProvenance;
-		if (cost.kind === "uncaptured") summary.uncaptured.n += 1;
-		else if (cost.kind === "lower-bound") {
-			summary.lowerBound.n += 1;
-			summary.lowerBound.floorUsd += cost.knownLowerBoundUsd;
-		} else {
-			summary[cost.kind].n += 1;
-			summary[cost.kind].totalUsd += cost.usd;
-		}
-	}
-	const known = summary.observed.n + summary.estimated.n;
-	summary.knownFraction = runs.length > 0 ? known / runs.length : 0;
-	return summary;
-}
-function diagnoseCostCoverage(runs, provenance) {
-	const unknown = provenance.uncaptured.n + provenance.lowerBound.n;
-	const known = provenance.observed.n + provenance.estimated.n;
-	const floor = provenance.lowerBound.n > 0 ? ` (${provenance.lowerBound.n} of them cost at least $${provenance.lowerBound.floorUsd.toFixed(6)} together)` : "";
-	if (unknown === runs.length) return `USD cost total unknown for all ${runs.length} runs${floor} — no observed or estimated USD values; token and wall-time metrics remain available.`;
-	return `USD cost total unknown for ${unknown}/${runs.length} runs${floor}; excluded those rows from cost statistics (${known}/${runs.length} retained: ${provenance.observed.n} observed, ${provenance.estimated.n} estimated).`;
-}
-/**
-* Model-free task-failure tally.
-*
-* Explicit non-success classes are task-failure evidence.
-* A low task score without a class is counted as `unknown`.
-*/
-function computeFailureClasses(runs, split) {
-	const counts = /* @__PURE__ */ new Map();
-	for (const r of runs) {
-		if (!isTaskFailure(r, split)) continue;
-		const key = r.failureClass !== void 0 && r.failureClass !== "success" ? r.failureClass : "unknown";
-		counts.set(key, (counts.get(key) ?? 0) + 1);
-	}
-	if (counts.size === 0) return void 0;
-	const n = runs.length;
-	return [...counts.entries()].map(([failureClass, count]) => ({
-		failureClass,
-		count,
-		share: n > 0 ? count / n : 0
-	})).sort((a, b) => b.count - a.count || a.failureClass.localeCompare(b.failureClass));
-}
-function computePriorPeriodComparison(current, baseline, split, windowLabel) {
-	if (current.length === 0 || baseline.length === 0) return void 0;
-	const metrics = {};
-	const directions = {};
-	const compositeCurrent = current.map((r) => compositeOf(r, split)).filter(Number.isFinite);
-	const compositeBaseline = baseline.map((r) => compositeOf(r, split)).filter(Number.isFinite);
-	if (compositeCurrent.length > 0 && compositeBaseline.length > 0) {
-		metrics.composite = welchCompare(compositeBaseline, compositeCurrent);
-		directions.composite = "higher-is-better";
-	}
-	const costCurrent = knownCostValues(current);
-	const costBaseline = knownCostValues(baseline);
-	if (costCurrent.length > 0 && costBaseline.length > 0) {
-		metrics.cost = welchCompare(costBaseline, costCurrent);
-		directions.cost = "lower-is-better";
-	}
-	const durCurrent = current.map((r) => r.wallMs).filter(Number.isFinite);
-	const durBaseline = baseline.map((r) => r.wallMs).filter(Number.isFinite);
-	if (durCurrent.length > 0 && durBaseline.length > 0) {
-		metrics.duration = welchCompare(durBaseline, durCurrent);
-		directions.duration = "lower-is-better";
-	}
-	const tokCurrent = current.map((r) => (r.tokenUsage.input ?? 0) + (r.tokenUsage.output ?? 0)).filter(Number.isFinite);
-	const tokBaseline = baseline.map((r) => (r.tokenUsage.input ?? 0) + (r.tokenUsage.output ?? 0)).filter(Number.isFinite);
-	if (tokCurrent.length > 0 && tokBaseline.length > 0) {
-		metrics.tokenUsage = welchCompare(tokBaseline, tokCurrent);
-		directions.tokenUsage = "lower-is-better";
-	}
-	const dimsCurrent = collectPerDimension(current);
-	const dimsBaseline = collectPerDimension(baseline);
-	for (const dim of Object.keys(dimsCurrent)) {
-		const b = dimsBaseline[dim];
-		const c = dimsCurrent[dim];
-		if (!b || b.length === 0 || !c || c.length === 0) continue;
-		metrics[`dim.${dim}`] = welchCompare(b, c);
-		directions[`dim.${dim}`] = "higher-is-better";
-	}
-	const regressedMetrics = [];
-	const improvedMetrics = [];
-	const inconclusiveMetrics = [];
-	for (const [name, delta] of Object.entries(metrics)) {
-		if (delta.status !== "ok") {
-			inconclusiveMetrics.push(name);
-			continue;
-		}
-		if (!delta.significant) continue;
-		if ((directions[name] ?? "higher-is-better") === "higher-is-better" ? delta.delta > 0 : delta.delta < 0) improvedMetrics.push(name);
-		else regressedMetrics.push(name);
-	}
-	return {
-		baselineN: baseline.length,
-		currentN: current.length,
-		...windowLabel ? { windowLabel } : {},
-		metrics,
-		regressedMetrics,
-		improvedMetrics,
-		inconclusiveMetrics
-	};
-}
-function knownCostValues(runs) {
-	return runs.filter((run) => run.costProvenance.usd !== null).map((run) => run.costUsd).filter(isFiniteNumber);
-}
-function isFiniteNumber(value) {
-	return typeof value === "number" && Number.isFinite(value);
-}
-/** Collect per-dimension values across runs (from outcome.judgeScores.perDimMean). */
-function collectPerDimension(runs) {
-	const out = {};
-	for (const r of runs) {
-		const perDim = r.outcome.judgeScores?.perDimMean;
-		if (!perDim) continue;
-		for (const [dim, value] of Object.entries(perDim)) {
-			if (!Number.isFinite(value)) continue;
-			if (!out[dim]) out[dim] = [];
-			out[dim].push(value);
-		}
-	}
-	return out;
-}
-/** Adapt the shared two-sample Welch result to the report contract. */
-function welchCompare(baseline, current) {
-	const result = welchsTTest(baseline, current);
-	const base = {
-		current: result.meanB,
-		baseline: result.meanA,
-		delta: result.delta,
-		baselineN: baseline.length,
-		currentN: current.length
-	};
-	if (result.status !== "ok") return {
-		...base,
-		status: result.status,
-		ci95: null,
-		pValue: null,
-		cohensD: null,
-		significant: false
-	};
-	return {
-		...base,
-		status: "ok",
-		ci95: result.ci95,
-		pValue: result.p,
-		cohensD: result.cohensD,
-		significant: result.p < .05 && Math.abs(result.cohensD) >= .2
-	};
-}
-function resolveSplit(runs, pref) {
-	if (pref !== "auto") return pref;
-	return runs.some((r) => Number.isFinite(observedSplitScore(r, "holdout"))) ? "holdout" : "search";
+//#endregion
+//#region src/contract/quality-insight.ts
+/** Observed score distributions, judge agreement, and downstream quality correlation. */
+function resolveSplit(runs, pref) {
+	if (pref !== "auto") return pref;
+	return runs.some((r) => Number.isFinite(observedSplitScore(r, "holdout"))) ? "holdout" : "search";
 }
 /**
 * RAW (`observedSplitScore`): `analyzeRuns` describes what a set of runs
@@ -462,15 +244,15 @@ function distributionOf(values, bins, withIds) {
 	};
 	const sorted = [...values].sort((a, b) => a - b);
 	const n = sorted.length;
-	const mean = sorted.reduce((s, v) => s + v, 0) / n;
+	const mean = mean$1(sorted);
 	const variance = sorted.reduce((s, v) => s + (v - mean) ** 2, 0) / n;
 	const stddev = Math.sqrt(variance);
 	const tailRuns = withIds ? [...withIds].sort((a, b) => a.score - b.score).slice(0, Math.min(5, withIds.length)) : void 0;
 	return {
 		n,
 		mean,
-		p50: percentile(sorted, .5),
-		p95: percentile(sorted, .95),
+		p50: interpolatedQuantile(sorted, .5),
+		p95: interpolatedQuantile(sorted, .95),
 		stddev,
 		min: sorted[0],
 		max: sorted[n - 1],
@@ -478,16 +260,6 @@ function distributionOf(values, bins, withIds) {
 		...tailRuns ? { tailRuns } : {}
 	};
 }
-function percentile(sorted, q) {
-	if (sorted.length === 0) return 0;
-	if (sorted.length === 1) return sorted[0];
-	const idx = (sorted.length - 1) * q;
-	const lo = Math.floor(idx);
-	const hi = Math.ceil(idx);
-	if (lo === hi) return sorted[lo];
-	const w = idx - lo;
-	return sorted[lo] * (1 - w) + sorted[hi] * w;
-}
 /** Even-width histogram over the value range. Returns inclusive-lo /
 *  exclusive-hi bins (closed on right for the last bin) compatible with
 *  the substrate's `GainDistributionBin` shape. */
@@ -533,6 +305,20 @@ function computePerDimension(runs, bins) {
 	for (const [dim, values] of byDim) out[dim] = distributionOf(values, bins);
 	return out;
 }
+/** Collect per-dimension values across runs (from outcome.judgeScores.perDimMean). */
+function collectPerDimension(runs) {
+	const out = {};
+	for (const r of runs) {
+		const perDim = r.outcome.judgeScores?.perDimMean;
+		if (!perDim) continue;
+		for (const [dim, value] of Object.entries(perDim)) {
+			if (!Number.isFinite(value)) continue;
+			if (!out[dim]) out[dim] = [];
+			out[dim].push(value);
+		}
+	}
+	return out;
+}
 function computeJudgeInsights(runs) {
 	const out = {};
 	const byJudge = /* @__PURE__ */ new Map();
@@ -617,84 +403,469 @@ function computeInterRater(ratings) {
 		perPair,
 		disagreementCases
 	};
-}
-function computeLift(runs, baselineId, candidateId, split, independentUnitByScenarioId) {
-	let bId = baselineId;
-	let cId = candidateId;
-	if (!bId || !cId) {
-		const ids = [...new Set(runs.map((r) => r.candidateId))];
-		if (ids.length !== 2) return void 0;
-		const [idA, idB] = ids;
-		const scoresA = finiteCompositeScores(runs.filter((run) => run.candidateId === idA), split);
-		const scoresB = finiteCompositeScores(runs.filter((run) => run.candidateId === idB), split);
-		if (scoresA.length === 0 || scoresB.length === 0) return void 0;
-		const meanA = mean(scoresA);
-		const meanB = mean(scoresB);
-		bId = meanA <= meanB ? idA : idB;
-		cId = meanA <= meanB ? idB : idA;
+}
+function computeOutcomeCorrelation(runs, outcome, split) {
+	const xs = [];
+	const ys = [];
+	for (const run of runs) {
+		const y = outcome.valueByRunId[run.runId];
+		if (y === void 0 || !Number.isFinite(y)) continue;
+		const x = compositeOf(run, split);
+		if (!Number.isFinite(x)) continue;
+		xs.push(x);
+		ys.push(y);
+	}
+	if (xs.length < 3) return void 0;
+	const p = pearsonR(xs, ys);
+	const s = spearmanR(xs, ys);
+	const meanX = meanOrZero(xs);
+	const meanY = meanOrZero(ys);
+	let num = 0;
+	let denom = 0;
+	for (let i = 0; i < xs.length; i++) {
+		num += (xs[i] - meanX) * (ys[i] - meanY);
+		denom += (xs[i] - meanX) ** 2;
+	}
+	const slope = denom === 0 ? 0 : num / denom;
+	const intercept = meanY - slope * meanX;
+	const ssTot = ys.reduce((a, y) => a + (y - meanY) ** 2, 0);
+	const ssRes = ys.reduce((a, y, i) => a + (y - (intercept + slope * xs[i])) ** 2, 0);
+	const r2 = ssTot === 0 ? 0 : 1 - ssRes / ssTot;
+	return {
+		metric: outcome.metric,
+		n: xs.length,
+		pearson: p,
+		spearman: s,
+		rewardModel: {
+			intercept,
+			slope,
+			r2
+		}
+	};
+}
+function finiteCompositeScores(runs, split) {
+	return runs.map((run) => compositeOf(run, split)).filter(Number.isFinite);
+}
+function isFiniteNumber(value) {
+	return typeof value === "number" && Number.isFinite(value);
+}
+function meanOrZero(arr) {
+	return arr.length === 0 ? 0 : mean$1(arr);
+}
+//#endregion
+//#region src/contract/comparison-insight.ts
+/** Paired candidate lift and independent prior-period metric comparisons. */
+function computePriorPeriodComparison(current, baseline, split, windowLabel) {
+	if (current.length === 0 || baseline.length === 0) return void 0;
+	const metrics = {};
+	const directions = {};
+	const compositeCurrent = current.map((r) => compositeOf(r, split)).filter(Number.isFinite);
+	const compositeBaseline = baseline.map((r) => compositeOf(r, split)).filter(Number.isFinite);
+	if (compositeCurrent.length > 0 && compositeBaseline.length > 0) {
+		metrics.composite = welchCompare(compositeBaseline, compositeCurrent);
+		directions.composite = "higher-is-better";
+	}
+	const costCurrent = knownCostValues(current);
+	const costBaseline = knownCostValues(baseline);
+	if (costCurrent.length > 0 && costBaseline.length > 0) {
+		metrics.cost = welchCompare(costBaseline, costCurrent);
+		directions.cost = "lower-is-better";
+	}
+	const durCurrent = current.map((r) => r.wallMs).filter(Number.isFinite);
+	const durBaseline = baseline.map((r) => r.wallMs).filter(Number.isFinite);
+	if (durCurrent.length > 0 && durBaseline.length > 0) {
+		metrics.duration = welchCompare(durBaseline, durCurrent);
+		directions.duration = "lower-is-better";
+	}
+	const tokCurrent = current.map((r) => (r.tokenUsage.input ?? 0) + (r.tokenUsage.output ?? 0)).filter(Number.isFinite);
+	const tokBaseline = baseline.map((r) => (r.tokenUsage.input ?? 0) + (r.tokenUsage.output ?? 0)).filter(Number.isFinite);
+	if (tokCurrent.length > 0 && tokBaseline.length > 0) {
+		metrics.tokenUsage = welchCompare(tokBaseline, tokCurrent);
+		directions.tokenUsage = "lower-is-better";
+	}
+	const dimsCurrent = collectPerDimension(current);
+	const dimsBaseline = collectPerDimension(baseline);
+	for (const dim of Object.keys(dimsCurrent)) {
+		const b = dimsBaseline[dim];
+		const c = dimsCurrent[dim];
+		if (!b || b.length === 0 || !c || c.length === 0) continue;
+		metrics[`dim.${dim}`] = welchCompare(b, c);
+		directions[`dim.${dim}`] = "higher-is-better";
+	}
+	const regressedMetrics = [];
+	const improvedMetrics = [];
+	const inconclusiveMetrics = [];
+	for (const [name, delta] of Object.entries(metrics)) {
+		if (delta.status !== "ok") {
+			inconclusiveMetrics.push(name);
+			continue;
+		}
+		if (!delta.significant) continue;
+		if ((directions[name] ?? "higher-is-better") === "higher-is-better" ? delta.delta > 0 : delta.delta < 0) improvedMetrics.push(name);
+		else regressedMetrics.push(name);
+	}
+	return {
+		baselineN: baseline.length,
+		currentN: current.length,
+		...windowLabel ? { windowLabel } : {},
+		metrics,
+		regressedMetrics,
+		improvedMetrics,
+		inconclusiveMetrics
+	};
+}
+function knownCostValues(runs) {
+	return runs.filter((run) => run.costProvenance.usd !== null).map((run) => run.costUsd).filter(isFiniteNumber);
+}
+/** Adapt the shared two-sample Welch result to the report contract. */
+function welchCompare(baseline, current) {
+	const result = welchsTTest(baseline, current);
+	const base = {
+		current: result.meanB,
+		baseline: result.meanA,
+		delta: result.delta,
+		baselineN: baseline.length,
+		currentN: current.length
+	};
+	if (result.status !== "ok") return {
+		...base,
+		status: result.status,
+		ci95: null,
+		pValue: null,
+		cohensD: null,
+		significant: false
+	};
+	return {
+		...base,
+		status: "ok",
+		ci95: result.ci95,
+		pValue: result.p,
+		cohensD: result.cohensD,
+		significant: result.p < .05 && Math.abs(result.cohensD) >= .2
+	};
+}
+function computeLift(runs, baselineId, candidateId, split, independentUnitByScenarioId) {
+	let bId = baselineId;
+	let cId = candidateId;
+	if (!bId || !cId) {
+		const ids = [...new Set(runs.map((r) => r.candidateId))];
+		if (ids.length !== 2) return void 0;
+		const [idA, idB] = ids;
+		const scoresA = finiteCompositeScores(runs.filter((run) => run.candidateId === idA), split);
+		const scoresB = finiteCompositeScores(runs.filter((run) => run.candidateId === idB), split);
+		if (scoresA.length === 0 || scoresB.length === 0) return void 0;
+		const meanA = meanOrZero(scoresA);
+		const meanB = meanOrZero(scoresB);
+		bId = meanA <= meanB ? idA : idB;
+		cId = meanA <= meanB ? idB : idA;
+	}
+	const baseline = runs.filter((r) => r.candidateId === bId);
+	const candidate = runs.filter((r) => r.candidateId === cId);
+	if (baseline.length === 0 || candidate.length === 0) return void 0;
+	const scoredBaseline = baseline.filter((run) => Number.isFinite(compositeOf(run, split)));
+	const scoredCandidate = candidate.filter((run) => Number.isFinite(compositeOf(run, split)));
+	const pairing = pairRunRecords(scoredBaseline, scoredCandidate);
+	let pairedBaseline = pairing.pairs.map((pair) => compositeOf(pair.baseline, split));
+	let pairedCandidate = pairing.pairs.map((pair) => compositeOf(pair.treatment, split));
+	if (pairedBaseline.length === 0) return void 0;
+	const grouped = independentUnitByScenarioId ? aggregatePairedHoldout({
+		before: pairedBaseline,
+		after: pairedCandidate,
+		cellIds: pairing.pairs.map((pair, index) => `${pair.pairKey}:${index}`)
+	}, new Map(pairing.pairs.map((pair) => [pair.pairKey, independentUnitByScenarioId.get(pair.baseline.scenarioId)]))) : void 0;
+	if (grouped) {
+		pairedBaseline = grouped.before;
+		pairedCandidate = grouped.after;
+	}
+	const reverseInferredArms = grouped !== void 0 && (!baselineId || !candidateId) && meanOrZero(pairedBaseline) > meanOrZero(pairedCandidate);
+	if (reverseInferredArms) [pairedBaseline, pairedCandidate] = [pairedCandidate, pairedBaseline];
+	const baselineMean = meanOrZero(pairedBaseline);
+	const candidateMean = meanOrZero(pairedCandidate);
+	const delta = candidateMean - baselineMean;
+	const bootstrap = pairedBootstrap(pairedBaseline, pairedCandidate, {
+		confidence: .95,
+		resamples: 2e3,
+		statistic: "mean"
+	});
+	const tTest = pairedTTest(pairedBaseline, pairedCandidate);
+	const d = pairedCohensDz(pairedBaseline, pairedCandidate);
+	const mde = pairedMde({
+		nPaired: pairedBaseline.length,
+		power: .8,
+		alpha: .05
+	});
+	const requiredN = d === null || d === 0 ? null : requiredPairedSampleSize({
+		effect: Math.abs(d),
+		power: .8,
+		alpha: .05
+	});
+	return {
+		baselineMean,
+		candidateMean,
+		delta,
+		ci95: [bootstrap.low, bootstrap.high],
+		pValue: tTest.p,
+		n: pairedBaseline.length,
+		...grouped ? {
+			pairedRunN: pairing.pairs.length,
+			independentUnitIds: grouped.unitIds
+		} : {},
+		minimumRequired: 20,
+		decisionEligible: bootstrap.gateEligible,
+		unpairedBaseline: (reverseInferredArms ? pairing.unpairedTreatment : pairing.unpairedBaseline).length,
+		unpairedCandidate: (reverseInferredArms ? pairing.unpairedBaseline : pairing.unpairedTreatment).length,
+		cohensD: d,
+		mde,
+		requiredN
+	};
+}
+//#endregion
+//#region src/contract/execution-insight.ts
+/** Runtime usage, terminal outcomes, execution errors, and cost capture facts. */
+/** Summarize runtime facts without interpreting task quality or promotion readiness. */
+function summarizeExecution(opts) {
+	const runs = opts.runs.map(validateRunRecord);
+	return {
+		execution: computeExecutionInsight(runs, opts.histogramBins ?? 12),
+		costProvenance: summarizeCostProvenance(runs)
+	};
+}
+function computeExecutionInsight(runs, bins) {
+	const aggregateRows = runs.flatMap((run) => {
+		const usage = aggregateTokenUsage(run);
+		return usage ? [{
+			usage,
+			costUsd: finiteRaw(run, "aggregate_cost_usd")
+		}] : [];
+	});
+	const aggregateCosts = aggregateRows.flatMap((row) => row.costUsd !== void 0 ? [row.costUsd] : []);
+	const modelCounts = /* @__PURE__ */ new Map();
+	let executionErrorRuns = 0;
+	let executionErrorEvents = 0;
+	let errorReportingRuns = 0;
+	let errorSpanEvents = 0;
+	let errorSpanReportingRuns = 0;
+	const terminalOutcomes = {
+		succeeded: 0,
+		failed: 0,
+		cancelled: 0,
+		incomplete: 0,
+		unknown: 0
+	};
+	const errorsByTerminalOutcome = {
+		succeeded: {
+			withErrors: 0,
+			withoutErrors: 0,
+			unreported: 0
+		},
+		failed: {
+			withErrors: 0,
+			withoutErrors: 0,
+			unreported: 0
+		},
+		cancelled: {
+			withErrors: 0,
+			withoutErrors: 0,
+			unreported: 0
+		},
+		incomplete: {
+			withErrors: 0,
+			withoutErrors: 0,
+			unreported: 0
+		},
+		unknown: {
+			withErrors: 0,
+			withoutErrors: 0,
+			unreported: 0
+		}
+	};
+	let modelCallRuns = 0;
+	let modelCallEvents = 0;
+	let modelCallReportingRuns = 0;
+	for (const run of runs) {
+		modelCounts.set(run.model, (modelCounts.get(run.model) ?? 0) + 1);
+		const terminalOutcome = run.terminalOutcome;
+		terminalOutcomes[terminalOutcome] += 1;
+		const modelCalls = nonNegativeCountRaw(run, "llm_span_count");
+		if (modelCalls !== void 0) {
+			modelCallEvents += modelCalls;
+			modelCallReportingRuns += 1;
+		}
+		const usage = run.tokenUsage;
+		if ((modelCalls ?? 0) > 0 || usage.input > 0 || usage.output > 0 || (usage.cached ?? 0) > 0 || (usage.cacheWrite ?? 0) > 0) modelCallRuns += 1;
+		const errorEvents = reportedExecutionErrorEvents(run);
+		if (errorEvents !== void 0) {
+			executionErrorEvents += errorEvents;
+			errorReportingRuns += 1;
+			if (errorEvents > 0) {
+				executionErrorRuns += 1;
+				errorsByTerminalOutcome[terminalOutcome].withErrors += 1;
+			} else errorsByTerminalOutcome[terminalOutcome].withoutErrors += 1;
+		} else errorsByTerminalOutcome[terminalOutcome].unreported += 1;
+		const reportedErrorSpans = nonNegativeCountRaw(run, "error_span_count");
+		if (reportedErrorSpans !== void 0) {
+			errorSpanEvents += reportedErrorSpans;
+			errorSpanReportingRuns += 1;
+		}
+	}
+	return {
+		durationMs: distributionOf(runs.map((run) => run.wallMs), bins),
+		queueMs: distributionOf(runs.filter((run) => run.queueMs !== void 0).map((run) => run.queueMs), bins),
+		tokenUsage: summarizeTokenUsage(runs.map((run) => run.tokenUsage), bins),
+		aggregateUsage: {
+			runs: aggregateRows.length,
+			tokenUsage: summarizeTokenUsage(aggregateRows.map((row) => row.usage), bins),
+			costUsd: distributionOf(aggregateCosts, bins),
+			totalCostUsd: aggregateCosts.reduce((total, value) => total + value, 0)
+		},
+		models: [...modelCounts.entries()].map(([model, count]) => ({
+			model,
+			runs: count
+		})).sort((left, right) => right.runs - left.runs || left.model.localeCompare(right.model)),
+		modelCalls: {
+			runs: modelCallRuns,
+			events: modelCallEvents,
+			reportingRuns: modelCallReportingRuns
+		},
+		executionErrors: {
+			runs: executionErrorRuns,
+			fraction: errorReportingRuns > 0 ? executionErrorRuns / errorReportingRuns : null,
+			events: executionErrorEvents,
+			reportingRuns: errorReportingRuns,
+			errorSpanEvents,
+			errorSpanReportingRuns,
+			byTerminalOutcome: errorsByTerminalOutcome
+		},
+		terminalOutcomes
+	};
+}
+function reportedExecutionErrorEvents(run) {
+	return nonNegativeCountRaw(run, "execution_error_count");
+}
+function nonNegativeCountRaw(run, key) {
+	const value = finiteRaw(run, key);
+	return value !== void 0 && Number.isInteger(value) && value >= 0 ? value : void 0;
+}
+function summarizeTokenUsage(usages, bins) {
+	const reasoning = usages.flatMap((usage) => usage.reasoning !== void 0 ? [usage.reasoning] : []);
+	const cached = usages.flatMap((usage) => usage.cached !== void 0 ? [usage.cached] : []);
+	const cacheWrite = usages.flatMap((usage) => usage.cacheWrite !== void 0 ? [usage.cacheWrite] : []);
+	return {
+		input: distributionOf(usages.map((usage) => usage.input), bins),
+		output: distributionOf(usages.map((usage) => usage.output), bins),
+		reasoning: distributionOf(reasoning, bins),
+		cached: distributionOf(cached, bins),
+		cacheWrite: distributionOf(cacheWrite, bins),
+		totals: {
+			input: usages.reduce((total, usage) => total + usage.input, 0),
+			output: usages.reduce((total, usage) => total + usage.output, 0),
+			reasoning: reasoning.reduce((total, value) => total + value, 0),
+			cached: cached.reduce((total, value) => total + value, 0),
+			cacheWrite: cacheWrite.reduce((total, value) => total + value, 0)
+		}
+	};
+}
+function aggregateTokenUsage(run) {
+	const input = finiteRaw(run, "aggregate_prompt_tokens");
+	const output = finiteRaw(run, "aggregate_completion_tokens");
+	const reasoning = finiteRaw(run, "aggregate_reasoning_tokens");
+	const cached = finiteRaw(run, "aggregate_cached_tokens");
+	const cacheWrite = finiteRaw(run, "aggregate_cache_write_tokens");
+	if (input === void 0 && output === void 0 && reasoning === void 0 && cached === void 0 && cacheWrite === void 0) return void 0;
+	return {
+		input: input ?? 0,
+		output: output ?? 0,
+		...reasoning !== void 0 ? { reasoning } : {},
+		...cached !== void 0 ? { cached } : {},
+		...cacheWrite !== void 0 ? { cacheWrite } : {}
+	};
+}
+function finiteRaw(run, key) {
+	const value = run.outcome.raw[key];
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+function summarizeCostProvenance(runs) {
+	const summary = {
+		observed: {
+			n: 0,
+			totalUsd: 0
+		},
+		estimated: {
+			n: 0,
+			totalUsd: 0
+		},
+		lowerBound: {
+			n: 0,
+			floorUsd: 0
+		},
+		uncaptured: { n: 0 },
+		knownFraction: 0
+	};
+	for (const run of runs) {
+		const cost = run.costProvenance;
+		if (cost.kind === "uncaptured") summary.uncaptured.n += 1;
+		else if (cost.kind === "lower-bound") {
+			summary.lowerBound.n += 1;
+			summary.lowerBound.floorUsd += cost.knownLowerBoundUsd;
+		} else {
+			summary[cost.kind].n += 1;
+			summary[cost.kind].totalUsd += cost.usd;
+		}
 	}
-	const baseline = runs.filter((r) => r.candidateId === bId);
-	const candidate = runs.filter((r) => r.candidateId === cId);
-	if (baseline.length === 0 || candidate.length === 0) return void 0;
-	const scoredBaseline = baseline.filter((run) => Number.isFinite(compositeOf(run, split)));
-	const scoredCandidate = candidate.filter((run) => Number.isFinite(compositeOf(run, split)));
-	const pairing = pairRunRecords(scoredBaseline, scoredCandidate);
-	let pairedBaseline = pairing.pairs.map((pair) => compositeOf(pair.baseline, split));
-	let pairedCandidate = pairing.pairs.map((pair) => compositeOf(pair.treatment, split));
-	if (pairedBaseline.length === 0) return void 0;
-	const grouped = independentUnitByScenarioId ? aggregatePairedHoldout({
-		before: pairedBaseline,
-		after: pairedCandidate,
-		cellIds: pairing.pairs.map((pair, index) => `${pair.pairKey}:${index}`)
-	}, new Map(pairing.pairs.map((pair) => [pair.pairKey, independentUnitByScenarioId.get(pair.baseline.scenarioId)]))) : void 0;
-	if (grouped) {
-		pairedBaseline = grouped.before;
-		pairedCandidate = grouped.after;
+	const known = summary.observed.n + summary.estimated.n;
+	summary.knownFraction = runs.length > 0 ? known / runs.length : 0;
+	return summary;
+}
+function diagnoseCostCoverage(runs, provenance) {
+	const unknown = provenance.uncaptured.n + provenance.lowerBound.n;
+	const known = provenance.observed.n + provenance.estimated.n;
+	const floor = provenance.lowerBound.n > 0 ? ` (${provenance.lowerBound.n} of them cost at least $${provenance.lowerBound.floorUsd.toFixed(6)} together)` : "";
+	if (unknown === runs.length) return `USD cost total unknown for all ${runs.length} runs${floor} — no observed or estimated USD values; token and wall-time metrics remain available.`;
+	return `USD cost total unknown for ${unknown}/${runs.length} runs${floor}; excluded those rows from cost statistics (${known}/${runs.length} retained: ${provenance.observed.n} observed, ${provenance.estimated.n} estimated).`;
+}
+//#endregion
+//#region src/contamination-guard.ts
+function checkCanaries(output, scenarios) {
+	const leaks = [];
+	for (const s of scenarios) {
+		if (!s.canary) continue;
+		if (output.includes(s.canary)) leaks.push({
+			scenarioId: s.id,
+			canary: s.canary,
+			evidence: excerpt(output, s.canary)
+		});
 	}
-	const reverseInferredArms = grouped !== void 0 && (!baselineId || !candidateId) && mean(pairedBaseline) > mean(pairedCandidate);
-	if (reverseInferredArms) [pairedBaseline, pairedCandidate] = [pairedCandidate, pairedBaseline];
-	const baselineMean = mean(pairedBaseline);
-	const candidateMean = mean(pairedCandidate);
-	const delta = candidateMean - baselineMean;
-	const bootstrap = pairedBootstrap(pairedBaseline, pairedCandidate, {
-		confidence: .95,
-		resamples: 2e3,
-		statistic: "mean"
-	});
-	const tTest = pairedTTest(pairedBaseline, pairedCandidate);
-	const d = pairedCohensDz(pairedBaseline, pairedCandidate);
-	const mde = pairedMde({
-		nPaired: pairedBaseline.length,
-		power: .8,
-		alpha: .05
-	});
-	const requiredN = d === null || d === 0 ? null : requiredPairedSampleSize({
-		effect: Math.abs(d),
-		power: .8,
-		alpha: .05
-	});
-	return {
-		baselineMean,
-		candidateMean,
-		delta,
-		ci95: [bootstrap.low, bootstrap.high],
-		pValue: tTest.p,
-		n: pairedBaseline.length,
-		...grouped ? {
-			pairedRunN: pairing.pairs.length,
-			independentUnitIds: grouped.unitIds
-		} : {},
-		minimumRequired: 20,
-		decisionEligible: bootstrap.gateEligible,
-		unpairedBaseline: (reverseInferredArms ? pairing.unpairedTreatment : pairing.unpairedBaseline).length,
-		unpairedCandidate: (reverseInferredArms ? pairing.unpairedBaseline : pairing.unpairedTreatment).length,
-		cohensD: d,
-		mde,
-		requiredN
-	};
+	return leaks;
 }
-function mean(arr) {
-	return arr.length === 0 ? 0 : arr.reduce((s, v) => s + v, 0) / arr.length;
+function excerpt(source, needle) {
+	const at = source.indexOf(needle);
+	if (at < 0) return "";
+	const start = Math.max(0, at - 30);
+	const end = Math.min(source.length, at + needle.length + 30);
+	return (start > 0 ? "…" : "") + source.slice(start, end) + (end < source.length ? "…" : "");
+}
+//#endregion
+//#region src/contract/failure-insight.ts
+/**
+* Model-free task-failure tally.
+*
+* Explicit non-success classes are task-failure evidence.
+* A low task score without a class is counted as `unknown`.
+*/
+function computeFailureClasses(runs, split) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const r of runs) {
+		if (!isTaskFailure(r, split)) continue;
+		const key = r.failureClass !== void 0 && r.failureClass !== "success" ? r.failureClass : "unknown";
+		counts.set(key, (counts.get(key) ?? 0) + 1);
+	}
+	if (counts.size === 0) return void 0;
+	const n = runs.length;
+	return [...counts.entries()].map(([failureClass, count]) => ({
+		failureClass,
+		count,
+		share: n > 0 ? count / n : 0
+	})).sort((a, b) => b.count - a.count || a.failureClass.localeCompare(b.failureClass));
 }
 async function computeFailureClusters(runs, analyst, split) {
 	const failed = runs.filter((run) => isTaskFailure(run, split));
@@ -731,9 +902,6 @@ async function computeFailureClusters(runs, analyst, split) {
 		totalFailures: failed.length
 	};
 }
-function finiteCompositeScores(runs, split) {
-	return runs.map((run) => compositeOf(run, split)).filter(Number.isFinite);
-}
 function isTaskFailure(run, split) {
 	if (run.failureClass !== void 0 && run.failureClass !== "success") return true;
 	const score = compositeOf(run, split);
@@ -766,44 +934,13 @@ function stringifyOutput(run) {
 	if (typeof metadata?.output === "string") return metadata.output;
 	if (typeof metadata?.text === "string") return metadata.text;
 }
-function computeOutcomeCorrelation(runs, outcome, split) {
-	const xs = [];
-	const ys = [];
-	for (const run of runs) {
-		const y = outcome.valueByRunId[run.runId];
-		if (y === void 0 || !Number.isFinite(y)) continue;
-		const x = compositeOf(run, split);
-		if (!Number.isFinite(x)) continue;
-		xs.push(x);
-		ys.push(y);
-	}
-	if (xs.length < 3) return void 0;
-	const p = pearsonR(xs, ys);
-	const s = spearmanR(xs, ys);
-	const meanX = mean(xs);
-	const meanY = mean(ys);
-	let num = 0;
-	let denom = 0;
-	for (let i = 0; i < xs.length; i++) {
-		num += (xs[i] - meanX) * (ys[i] - meanY);
-		denom += (xs[i] - meanX) ** 2;
-	}
-	const slope = denom === 0 ? 0 : num / denom;
-	const intercept = meanY - slope * meanX;
-	const ssTot = ys.reduce((a, y) => a + (y - meanY) ** 2, 0);
-	const ssRes = ys.reduce((a, y, i) => a + (y - (intercept + slope * xs[i])) ** 2, 0);
-	const r2 = ssTot === 0 ? 0 : 1 - ssRes / ssTot;
-	return {
-		metric: outcome.metric,
-		n: xs.length,
-		pearson: p,
-		spearman: s,
-		rewardModel: {
-			intercept,
-			slope,
-			r2
-		}
-	};
+//#endregion
+//#region src/contract/insight-recommendations.ts
+/** A bootstrap interval with no spread: every resample landed on the same
+*  value, so the interval carries no information about how far the point
+*  estimate could be wrong and cannot support a directional claim. */
+function zeroWidth(ci) {
+	return !Number.isFinite(ci[0]) || !Number.isFinite(ci[1]) || ci[0] === ci[1];
 }
 function buildReleaseScorecard(composite, lift, contamination) {
 	const axes = [];
@@ -985,6 +1122,77 @@ function buildRecommendations(ctx) {
 	return out;
 }
 //#endregion
-export { summarizeExecution as n, checkCanaries as r, analyzeRuns as t };
+//#region src/contract/analyze-runs.ts
+async function analyzeRuns(opts) {
+	const runs = opts.runs.map(validateRunRecord);
+	const bins = opts.histogramBins ?? 12;
+	const threshold = opts.decisionThreshold ?? .02;
+	if (!Number.isFinite(threshold)) throw new Error(`analyzeRuns: decisionThreshold must be finite, got ${threshold}`);
+	const split = resolveSplit(runs, opts.split ?? "auto");
+	const compositeWithIds = runs.map((r) => ({
+		runId: r.runId,
+		score: compositeOf(r, split)
+	})).filter((p) => Number.isFinite(p.score));
+	const composite = distributionOf(compositeWithIds.map((p) => p.score), bins, compositeWithIds);
+	const perDimension = computePerDimension(runs, bins);
+	const { execution, costProvenance: provenance } = summarizeExecution({
+		runs,
+		histogramBins: bins
+	});
+	const knownCostRuns = runs.filter((run) => run.costProvenance.usd !== null);
+	const costs = knownCostRuns.map((r) => r.costUsd).filter(isFiniteNumber);
+	const costDist = distributionOf(costs, bins);
+	const pareto = paretoChart(knownCostRuns, { split });
+	const degraded = {};
+	if (provenance.uncaptured.n + provenance.lowerBound.n > 0) degraded.cost = diagnoseCostCoverage(runs, provenance);
+	else if (costs.length === 0 || costs.every((c) => c === 0)) degraded.cost = `all ${runs.length} explicitly observed or estimated USD values are $0`;
+	if (pareto.points.length < 2) degraded.pareto = pareto.points.length === 0 ? "no candidates — Pareto unavailable" : "single candidate — Pareto is a single point, not a frontier";
+	const costQuality = {
+		cost: costDist,
+		pareto,
+		provenance,
+		...degraded.cost || degraded.pareto ? { degraded } : {}
+	};
+	const judges = computeJudgeInsights(runs);
+	const interRater = opts.raterScores ? computeInterRater(opts.raterScores) : void 0;
+	const lift = computeLift(runs, opts.baselineCandidateId, opts.candidateCandidateId, split, opts.independentUnitByScenarioId);
+	const failureClusters = opts.analyst ? await computeFailureClusters(runs, opts.analyst, split) : void 0;
+	const failureClasses = computeFailureClasses(runs, split);
+	const contamination = opts.canaryScenarios ? computeContamination(runs, opts.canaryScenarios) : void 0;
+	const outcomeCorrelation = opts.outcomeSignal ? computeOutcomeCorrelation(runs, opts.outcomeSignal, split) : void 0;
+	const release = buildReleaseScorecard(composite, lift, contamination);
+	const priorPeriodComparison = opts.baselineRuns ? computePriorPeriodComparison(runs, opts.baselineRuns, split, opts.baselineLabel) : void 0;
+	const recommendations = buildRecommendations({
+		composite,
+		judges,
+		interRater,
+		lift,
+		failureClusters,
+		failureClasses,
+		contamination,
+		outcomeCorrelation,
+		priorPeriodComparison,
+		threshold
+	});
+	return {
+		n: runs.length,
+		execution,
+		composite,
+		perDimension,
+		costQuality,
+		judges,
+		interRater,
+		lift,
+		failureClusters,
+		contamination,
+		outcomeCorrelation,
+		release,
+		...failureClasses ? { failureClasses } : {},
+		...priorPeriodComparison ? { priorPeriodComparison } : {},
+		recommendations
+	};
+}
+//#endregion
+export { welchsTTest as a, fisherExactTwoSided as c, studentTTwoSidedPValue as d, twoByTwoPValue as f, iqr as i, linearRegressionSlope as l, checkCanaries as n, chiSquared as o, summarizeExecution as r, chiSquaredPValue as s, analyzeRuns as t, normalTwoSidedPValue as u };
 
-//# sourceMappingURL=analyze-runs-3xpby3p2.js.map
+//# sourceMappingURL=analyze-runs-DqPJaJ4X.js.map