@tangle-network/agent-eval 0.216.0 → 0.216.1

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

@@ -1,37 +1,423 @@
-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 { 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)
+import { c as validateRunRecord } from "./run-record-Boc5IUTp.js";
+import { r as paretoChart } from "./summary-report-V_JACR4Y.js";
+import { t as interpolatedQuantile } from "./quantile--0yb07pD.js";
+import { a as spearmanR, r as pearsonR } from "./descriptive-DboxPZrG.js";
+import { r as continuousAgreement } from "./judge-calibration-BpCy5XQl.js";
+import { i as pairedCohensDz } from "./effect-sizes-BhzEpXMc.js";
+import { r as welchsTTest } from "./baseline-Udi_PLuT.js";
+import { i as pairedBootstrap, s as pairedTTest, t as mean$1 } from "./mean-DHoMiudD.js";
+import { i as requiredPairedSampleSize, r as pairedMde } from "./power-and-mde-Hj2ubb4B.js";
+import { r as pairRunRecords } from "./paired-arms-CwMGJsrS.js";
+import { n as aggregatePairedHoldout } from "./statistical-heldout-42NlCNDe.js";
+import "./query-BUCZCK7F.js";
+//#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
+* reported, and every downstream reader of this composite — distributions,
+* per-candidate summaries, the reward-hacking correlation — needs the ungated
+* number to see an inflated run at all.
+*/
+function compositeOf(run, split) {
+	const score = observedSplitScore(run, split);
+	return Number.isFinite(score) ? score : NaN;
+}
+function distributionOf(values, bins, withIds) {
+	if (values.length === 0) return {
+		n: 0,
+		mean: null,
+		p50: null,
+		p95: null,
+		stddev: null,
+		min: null,
+		max: null,
+		histogram: []
+	};
+	const sorted = [...values].sort((a, b) => a - b);
+	const n = sorted.length;
+	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: interpolatedQuantile(sorted, .5),
+		p95: interpolatedQuantile(sorted, .95),
+		stddev,
+		min: sorted[0],
+		max: sorted[n - 1],
+		histogram: histogram(sorted, bins),
+		...tailRuns ? { tailRuns } : {}
+	};
+}
+/** 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. */
+function histogram(sorted, bins) {
+	if (sorted.length === 0 || bins < 1) return [];
+	const min = sorted[0];
+	const max = sorted[sorted.length - 1];
+	if (min === max) return [{
+		lo: min,
+		hi: max,
+		count: sorted.length
+	}];
+	const width = (max - min) / bins;
+	const out = [];
+	for (let i = 0; i < bins; i++) {
+		const lo = min + i * width;
+		const hi = i === bins - 1 ? max : lo + width;
+		out.push({
+			lo,
+			hi,
+			count: 0
 		});
 	}
-	return leaks;
+	for (const v of sorted) {
+		const idx = Math.min(bins - 1, Math.floor((v - min) / width));
+		out[idx].count++;
+	}
+	return out;
 }
-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 ? "…" : "");
+function computePerDimension(runs, bins) {
+	const byDim = /* @__PURE__ */ new Map();
+	for (const run of runs) {
+		const scores = run.outcome.judgeScores;
+		if (!scores) continue;
+		for (const [dim, value] of Object.entries(scores.perDimMean ?? {})) {
+			if (!Number.isFinite(value)) continue;
+			const arr = byDim.get(dim) ?? [];
+			arr.push(value);
+			byDim.set(dim, arr);
+		}
+	}
+	const out = {};
+	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();
+	for (const run of runs) {
+		const scores = run.outcome.judgeScores;
+		if (!scores?.perJudge) continue;
+		for (const [judgeId, dims] of Object.entries(scores.perJudge)) {
+			const dimValues = Object.values(dims).filter(Number.isFinite);
+			if (dimValues.length === 0) continue;
+			const judgeMean = dimValues.reduce((s, v) => s + v, 0) / dimValues.length;
+			const arr = byJudge.get(judgeId) ?? [];
+			arr.push(judgeMean);
+			byJudge.set(judgeId, arr);
+		}
+	}
+	for (const [judgeId, values] of byJudge) out[judgeId] = {
+		n: values.length,
+		meanScore: values.reduce((s, v) => s + v, 0) / values.length
+	};
+	return out;
+}
+function computeInterRater(ratings) {
+	const byRun = /* @__PURE__ */ new Map();
+	for (const r of ratings) {
+		if (!Number.isFinite(r.score)) continue;
+		const list = byRun.get(r.runId) ?? [];
+		list.push({
+			rater: r.rater,
+			score: r.score
+		});
+		byRun.set(r.runId, list);
+	}
+	const raters = new Set(ratings.map((r) => r.rater));
+	const jointlyRated = [];
+	for (const [runId, ratersForRun] of byRun) {
+		const seen = new Set(ratersForRun.map((r) => r.rater));
+		let all = true;
+		for (const r of raters) if (!seen.has(r)) all = false;
+		if (all) jointlyRated.push(runId);
+	}
+	if (raters.size < 2 || jointlyRated.length === 0) return void 0;
+	const raterList = [...raters].sort();
+	const perPair = {};
+	for (let i = 0; i < raterList.length; i++) for (let j = i + 1; j < raterList.length; j++) {
+		const a = raterList[i];
+		const b = raterList[j];
+		const aScores = [];
+		const bScores = [];
+		for (const runId of jointlyRated) {
+			const ratersForRun = byRun.get(runId);
+			const sa = ratersForRun.find((r) => r.rater === a)?.score;
+			const sb = ratersForRun.find((r) => r.rater === b)?.score;
+			if (sa !== void 0 && sb !== void 0) {
+				aScores.push(sa);
+				bScores.push(sb);
+			}
+		}
+		const agreement = continuousAgreement(aScores.map((score, index) => [score, bScores[index]]), { bootstrap: 0 });
+		perPair[`${a}::${b}`] = agreement.weightedKappa;
+	}
+	const matrix = jointlyRated.map((runId) => {
+		const ratingsByRater = new Map(byRun.get(runId).map((rating) => [rating.rater, rating.score]));
+		return raterList.map((rater) => ratingsByRater.get(rater));
+	});
+	const agreement = continuousAgreement(matrix, { bootstrap: 0 });
+	const disagreementCases = jointlyRated.map((runId) => {
+		const ratersForRun = byRun.get(runId);
+		const scores = ratersForRun.map((r) => r.score);
+		return {
+			runId,
+			ratings: ratersForRun,
+			range: Math.max(...scores) - Math.min(...scores)
+		};
+	}).sort((a, b) => b.range - a.range).slice(0, 20);
+	return {
+		raters: raters.size,
+		jointlyRated: jointlyRated.length,
+		kappa: Number.isFinite(agreement.weightedKappa) ? agreement.weightedKappa : 0,
+		icc: agreement.icc,
+		pearson: agreement.pearson,
+		spearman: agreement.spearman,
+		perPair,
+		disagreementCases
+	};
+}
+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
+		}
+	};
+}
+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 mean(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 = mean(scoresA);
+		const meanB = mean(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) && 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
+	};
 }
 //#endregion
-//#region src/contract/analyze-runs.ts
+//#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);
@@ -40,81 +426,6 @@ function summarizeExecution(opts) {
 		costProvenance: summarizeCostProvenance(runs)
 	};
 }
-/** 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];
-}
-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
-	};
-}
 function computeExecutionInsight(runs, bins) {
 	const aggregateRows = runs.flatMap((run) => {
 		const usage = aggregateTokenUsage(run);
@@ -224,477 +535,133 @@ function computeExecutionInsight(runs, bins) {
 		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 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);
+function reportedExecutionErrorEvents(run) {
+	return nonNegativeCountRaw(run, "execution_error_count");
 }
-/** 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 nonNegativeCountRaw(run, key) {
+	const value = finiteRaw(run, key);
+	return value !== void 0 && Number.isInteger(value) && value >= 0 ? value : void 0;
 }
-/** 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
-	};
+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 {
-		...base,
-		status: "ok",
-		ci95: result.ci95,
-		pValue: result.p,
-		cohensD: result.cohensD,
-		significant: result.p < .05 && Math.abs(result.cohensD) >= .2
+		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 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
-* reported, and every downstream reader of this composite — distributions,
-* per-candidate summaries, the reward-hacking correlation — needs the ungated
-* number to see an inflated run at all.
-*/
-function compositeOf(run, split) {
-	const score = observedSplitScore(run, split);
-	return Number.isFinite(score) ? score : NaN;
-}
-function distributionOf(values, bins, withIds) {
-	if (values.length === 0) return {
-		n: 0,
-		mean: null,
-		p50: null,
-		p95: null,
-		stddev: null,
-		min: null,
-		max: null,
-		histogram: []
-	};
-	const sorted = [...values].sort((a, b) => a - b);
-	const n = sorted.length;
-	const mean = sorted.reduce((s, v) => s + v, 0) / n;
-	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;
+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 {
-		n,
-		mean,
-		p50: percentile(sorted, .5),
-		p95: percentile(sorted, .95),
-		stddev,
-		min: sorted[0],
-		max: sorted[n - 1],
-		histogram: histogram(sorted, bins),
-		...tailRuns ? { tailRuns } : {}
+		input: input ?? 0,
+		output: output ?? 0,
+		...reasoning !== void 0 ? { reasoning } : {},
+		...cached !== void 0 ? { cached } : {},
+		...cacheWrite !== void 0 ? { cacheWrite } : {}
 	};
 }
-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. */
-function histogram(sorted, bins) {
-	if (sorted.length === 0 || bins < 1) return [];
-	const min = sorted[0];
-	const max = sorted[sorted.length - 1];
-	if (min === max) return [{
-		lo: min,
-		hi: max,
-		count: sorted.length
-	}];
-	const width = (max - min) / bins;
-	const out = [];
-	for (let i = 0; i < bins; i++) {
-		const lo = min + i * width;
-		const hi = i === bins - 1 ? max : lo + width;
-		out.push({
-			lo,
-			hi,
-			count: 0
-		});
-	}
-	for (const v of sorted) {
-		const idx = Math.min(bins - 1, Math.floor((v - min) / width));
-		out[idx].count++;
-	}
-	return out;
-}
-function computePerDimension(runs, bins) {
-	const byDim = /* @__PURE__ */ new Map();
-	for (const run of runs) {
-		const scores = run.outcome.judgeScores;
-		if (!scores) continue;
-		for (const [dim, value] of Object.entries(scores.perDimMean ?? {})) {
-			if (!Number.isFinite(value)) continue;
-			const arr = byDim.get(dim) ?? [];
-			arr.push(value);
-			byDim.set(dim, arr);
-		}
-	}
-	const out = {};
-	for (const [dim, values] of byDim) out[dim] = distributionOf(values, bins);
-	return out;
-}
-function computeJudgeInsights(runs) {
-	const out = {};
-	const byJudge = /* @__PURE__ */ new Map();
-	for (const run of runs) {
-		const scores = run.outcome.judgeScores;
-		if (!scores?.perJudge) continue;
-		for (const [judgeId, dims] of Object.entries(scores.perJudge)) {
-			const dimValues = Object.values(dims).filter(Number.isFinite);
-			if (dimValues.length === 0) continue;
-			const judgeMean = dimValues.reduce((s, v) => s + v, 0) / dimValues.length;
-			const arr = byJudge.get(judgeId) ?? [];
-			arr.push(judgeMean);
-			byJudge.set(judgeId, arr);
-		}
-	}
-	for (const [judgeId, values] of byJudge) out[judgeId] = {
-		n: values.length,
-		meanScore: values.reduce((s, v) => s + v, 0) / values.length
-	};
-	return out;
+function finiteRaw(run, key) {
+	const value = run.outcome.raw[key];
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
 }
-function computeInterRater(ratings) {
-	const byRun = /* @__PURE__ */ new Map();
-	for (const r of ratings) {
-		if (!Number.isFinite(r.score)) continue;
-		const list = byRun.get(r.runId) ?? [];
-		list.push({
-			rater: r.rater,
-			score: r.score
-		});
-		byRun.set(r.runId, list);
-	}
-	const raters = new Set(ratings.map((r) => r.rater));
-	const jointlyRated = [];
-	for (const [runId, ratersForRun] of byRun) {
-		const seen = new Set(ratersForRun.map((r) => r.rater));
-		let all = true;
-		for (const r of raters) if (!seen.has(r)) all = false;
-		if (all) jointlyRated.push(runId);
-	}
-	if (raters.size < 2 || jointlyRated.length === 0) return void 0;
-	const raterList = [...raters].sort();
-	const perPair = {};
-	for (let i = 0; i < raterList.length; i++) for (let j = i + 1; j < raterList.length; j++) {
-		const a = raterList[i];
-		const b = raterList[j];
-		const aScores = [];
-		const bScores = [];
-		for (const runId of jointlyRated) {
-			const ratersForRun = byRun.get(runId);
-			const sa = ratersForRun.find((r) => r.rater === a)?.score;
-			const sb = ratersForRun.find((r) => r.rater === b)?.score;
-			if (sa !== void 0 && sb !== void 0) {
-				aScores.push(sa);
-				bScores.push(sb);
-			}
-		}
-		const agreement = continuousAgreement(aScores.map((score, index) => [score, bScores[index]]), { bootstrap: 0 });
-		perPair[`${a}::${b}`] = agreement.weightedKappa;
-	}
-	const matrix = jointlyRated.map((runId) => {
-		const ratingsByRater = new Map(byRun.get(runId).map((rating) => [rating.rater, rating.score]));
-		return raterList.map((rater) => ratingsByRater.get(rater));
-	});
-	const agreement = continuousAgreement(matrix, { bootstrap: 0 });
-	const disagreementCases = jointlyRated.map((runId) => {
-		const ratersForRun = byRun.get(runId);
-		const scores = ratersForRun.map((r) => r.score);
-		return {
-			runId,
-			ratings: ratersForRun,
-			range: Math.max(...scores) - Math.min(...scores)
-		};
-	}).sort((a, b) => b.range - a.range).slice(0, 20);
-	return {
-		raters: raters.size,
-		jointlyRated: jointlyRated.length,
-		kappa: Number.isFinite(agreement.weightedKappa) ? agreement.weightedKappa : 0,
-		icc: agreement.icc,
-		pearson: agreement.pearson,
-		spearman: agreement.spearman,
-		perPair,
-		disagreementCases
+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
 	};
-}
-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;
+	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 +698,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 +730,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 +918,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 { checkCanaries as n, summarizeExecution as r, analyzeRuns as t };
 
-//# sourceMappingURL=analyze-runs-3xpby3p2.js.map
+//# sourceMappingURL=analyze-runs-C84irm4i.js.map