@tangle-network/agent-eval 0.20.12 → 0.22.0

package/dist/chunk-IOXMGMHQ.js

@@ -0,0 +1,1226 @@
+import {
+  canonicalize,
+  hashJson
+} from "./chunk-6M774GY6.js";
+
+// src/statistics.ts
+var INVERTED_DIMENSIONS = /* @__PURE__ */ new Set([
+  "hallucination",
+  "false_confidence",
+  "worst_failure"
+]);
+function normalizeScores(scores) {
+  return scores.map((s) => {
+    if (INVERTED_DIMENSIONS.has(s.dimension)) {
+      return s;
+    }
+    return s;
+  });
+}
+function weightedMean(scores) {
+  if (scores.length === 0) return 0;
+  let totalWeight = 0;
+  let weightedSum = 0;
+  for (const { score, weight } of scores) {
+    const w = weight ?? 1;
+    weightedSum += score * w;
+    totalWeight += w;
+  }
+  return totalWeight > 0 ? weightedSum / totalWeight : 0;
+}
+function confidenceInterval(scores, confidence = 0.95) {
+  if (scores.length === 0) return { mean: 0, lower: 0, upper: 0 };
+  if (scores.length === 1) return { mean: scores[0], lower: scores[0], upper: scores[0] };
+  const n = scores.length;
+  const mean = scores.reduce((a, b) => a + b, 0) / n;
+  const B = 1e3;
+  const bootstrapMeans = [];
+  for (let i = 0; i < B; i++) {
+    let sum = 0;
+    for (let j = 0; j < n; j++) {
+      sum += scores[Math.floor(Math.random() * n)];
+    }
+    bootstrapMeans.push(sum / n);
+  }
+  bootstrapMeans.sort((a, b) => a - b);
+  const alpha = 1 - confidence;
+  const lowerIdx = Math.floor(alpha / 2 * B);
+  const upperIdx = Math.floor((1 - alpha / 2) * B) - 1;
+  return {
+    mean,
+    lower: bootstrapMeans[lowerIdx],
+    upper: bootstrapMeans[Math.min(upperIdx, B - 1)]
+  };
+}
+function interRaterReliability(judgeScores) {
+  if (judgeScores.length < 2) return 1;
+  const dimensionMap = /* @__PURE__ */ new Map();
+  for (const judgeSet of judgeScores) {
+    for (const s of judgeSet) {
+      if (!dimensionMap.has(s.dimension)) dimensionMap.set(s.dimension, []);
+      const arr = dimensionMap.get(s.dimension);
+      if (arr.length === 0 || arr[arr.length - 1].length >= judgeScores.length) {
+        arr.push([s.score]);
+      } else {
+        arr[arr.length - 1].push(s.score);
+      }
+    }
+  }
+  const allValues = [];
+  const pairDiffs = [];
+  for (const items of dimensionMap.values()) {
+    for (const ratings of items) {
+      if (ratings.length < 2) continue;
+      for (const v of ratings) allValues.push(v);
+      for (let i = 0; i < ratings.length; i++) {
+        for (let j = i + 1; j < ratings.length; j++) {
+          pairDiffs.push((ratings[i] - ratings[j]) ** 2);
+        }
+      }
+    }
+  }
+  if (pairDiffs.length === 0 || allValues.length < 2) return 1;
+  const observedDisagreement = pairDiffs.reduce((a, b) => a + b, 0) / pairDiffs.length;
+  let expectedDisagreement = 0;
+  let expectedCount = 0;
+  for (let i = 0; i < allValues.length; i++) {
+    for (let j = i + 1; j < allValues.length; j++) {
+      expectedDisagreement += (allValues[i] - allValues[j]) ** 2;
+      expectedCount++;
+    }
+  }
+  expectedDisagreement = expectedCount > 0 ? expectedDisagreement / expectedCount : 0;
+  if (expectedDisagreement === 0) return 1;
+  return 1 - observedDisagreement / expectedDisagreement;
+}
+function mannWhitneyU(a, b) {
+  if (a.length === 0 || b.length === 0) return { u: 0, p: 1 };
+  const n1 = a.length;
+  const n2 = b.length;
+  const combined = [
+    ...a.map((v) => ({ v, group: "a" })),
+    ...b.map((v) => ({ v, group: "b" }))
+  ].sort((x, y) => x.v - y.v);
+  const ranks = new Array(combined.length);
+  let i = 0;
+  while (i < combined.length) {
+    let j = i;
+    while (j < combined.length && combined[j].v === combined[i].v) j++;
+    const avgRank = (i + 1 + j) / 2;
+    for (let k = i; k < j; k++) ranks[k] = avgRank;
+    i = j;
+  }
+  let r1 = 0;
+  for (let k = 0; k < combined.length; k++) {
+    if (combined[k].group === "a") r1 += ranks[k];
+  }
+  const u1 = r1 - n1 * (n1 + 1) / 2;
+  const u2 = n1 * n2 - u1;
+  const u = Math.min(u1, u2);
+  const mu = n1 * n2 / 2;
+  const sigma = Math.sqrt(n1 * n2 * (n1 + n2 + 1) / 12);
+  if (sigma === 0) return { u, p: 1 };
+  const z = Math.abs(u - mu) / sigma;
+  const p = 2 * (1 - normalCdf(z));
+  return { u, p };
+}
+function partialCredit(current, target) {
+  if (target <= 0) return 1;
+  return Math.min(1, Math.max(0, current / target));
+}
+function pairedTTest(before, after) {
+  if (before.length !== after.length) {
+    throw new Error(`pairedTTest: unequal sample sizes (${before.length} vs ${after.length})`);
+  }
+  const n = before.length;
+  if (n < 2) return { t: 0, df: 0, p: 1 };
+  const diffs = before.map((b, i) => after[i] - b);
+  const mean = diffs.reduce((a, b) => a + b, 0) / n;
+  const variance = diffs.reduce((acc, d) => acc + (d - mean) ** 2, 0) / (n - 1);
+  const se = Math.sqrt(variance / n);
+  if (se === 0) return { t: mean === 0 ? 0 : Infinity, df: n - 1, p: mean === 0 ? 1 : 0 };
+  const t = mean / se;
+  const df = n - 1;
+  const p = 2 * (1 - studentTCdf(Math.abs(t), df));
+  return { t, df, p };
+}
+function wilcoxonSignedRank(before, after) {
+  if (before.length !== after.length) {
+    throw new Error(`wilcoxonSignedRank: unequal sample sizes (${before.length} vs ${after.length})`);
+  }
+  const diffs = before.map((b, i2) => after[i2] - b).filter((d) => d !== 0);
+  const n = diffs.length;
+  if (n < 6) return { w: 0, p: 1 };
+  const absRanks = diffs.map((d, i2) => ({ abs: Math.abs(d), sign: Math.sign(d), i: i2 })).sort((a, b) => a.abs - b.abs);
+  const ranks = new Array(n);
+  let i = 0;
+  while (i < n) {
+    let j = i;
+    while (j < n && absRanks[j].abs === absRanks[i].abs) j++;
+    const avg2 = (i + 1 + j) / 2;
+    for (let k = i; k < j; k++) ranks[absRanks[k].i] = avg2;
+    i = j;
+  }
+  let wPlus = 0;
+  for (let k = 0; k < n; k++) if (diffs[k] > 0) wPlus += ranks[k];
+  const mean = n * (n + 1) / 4;
+  const variance = n * (n + 1) * (2 * n + 1) / 24;
+  const z = (wPlus - mean) / Math.sqrt(variance);
+  const p = 2 * (1 - normalCdf(Math.abs(z)));
+  return { w: wPlus, p };
+}
+function cohensD(a, b) {
+  if (a.length < 2 || b.length < 2) return 0;
+  const meanA = a.reduce((x, y) => x + y, 0) / a.length;
+  const meanB = b.reduce((x, y) => x + y, 0) / b.length;
+  const varA = a.reduce((acc, x) => acc + (x - meanA) ** 2, 0) / (a.length - 1);
+  const varB = b.reduce((acc, x) => acc + (x - meanB) ** 2, 0) / (b.length - 1);
+  const pooled = Math.sqrt(
+    ((a.length - 1) * varA + (b.length - 1) * varB) / (a.length + b.length - 2)
+  );
+  if (pooled === 0) return 0;
+  return (meanB - meanA) / pooled;
+}
+function studentTCdf(t, df) {
+  if (df <= 0) return 0.5;
+  if (df > 100) return normalCdf(t);
+  const x = df / (df + t * t);
+  const a = df / 2;
+  const b = 0.5;
+  const ib = incompleteBeta(x, a, b);
+  return t >= 0 ? 1 - 0.5 * ib : 0.5 * ib;
+}
+function incompleteBeta(x, a, b) {
+  if (x <= 0) return 0;
+  if (x >= 1) return 1;
+  const lnBeta = lnGamma(a) + lnGamma(b) - lnGamma(a + b);
+  const front = Math.exp(Math.log(x) * a + Math.log(1 - x) * b - lnBeta) / a;
+  const maxIter = 200;
+  const eps = 3e-7;
+  let c = 1;
+  let d = 1 - (a + b) * x / (a + 1);
+  if (Math.abs(d) < 1e-30) d = 1e-30;
+  d = 1 / d;
+  let f = d;
+  for (let m = 1; m <= maxIter; m++) {
+    const m2 = 2 * m;
+    let num = m * (b - m) * x / ((a + m2 - 1) * (a + m2));
+    d = 1 + num * d;
+    if (Math.abs(d) < 1e-30) d = 1e-30;
+    c = 1 + num / c;
+    if (Math.abs(c) < 1e-30) c = 1e-30;
+    d = 1 / d;
+    f *= d * c;
+    num = -((a + m) * (a + b + m) * x) / ((a + m2) * (a + m2 + 1));
+    d = 1 + num * d;
+    if (Math.abs(d) < 1e-30) d = 1e-30;
+    c = 1 + num / c;
+    if (Math.abs(c) < 1e-30) c = 1e-30;
+    d = 1 / d;
+    const delta = d * c;
+    f *= delta;
+    if (Math.abs(delta - 1) < eps) break;
+  }
+  return front * f;
+}
+function lnGamma(z) {
+  const g = 7;
+  const coefs = [
+    0.9999999999998099,
+    676.5203681218851,
+    -1259.1392167224028,
+    771.3234287776531,
+    -176.6150291621406,
+    12.507343278686905,
+    -0.13857109526572012,
+    9984369578019572e-21,
+    15056327351493116e-23
+  ];
+  if (z < 0.5) {
+    return Math.log(Math.PI / Math.sin(Math.PI * z)) - lnGamma(1 - z);
+  }
+  z -= 1;
+  let x = coefs[0];
+  for (let i = 1; i < g + 2; i++) x += coefs[i] / (z + i);
+  const t = z + g + 0.5;
+  return 0.5 * Math.log(2 * Math.PI) + (z + 0.5) * Math.log(t) - t + Math.log(x);
+}
+function normalCdf(x) {
+  const a1 = 0.254829592;
+  const a2 = -0.284496736;
+  const a3 = 1.421413741;
+  const a4 = -1.453152027;
+  const a5 = 1.061405429;
+  const p = 0.3275911;
+  const sign = x < 0 ? -1 : 1;
+  const absX = Math.abs(x);
+  const t = 1 / (1 + p * absX);
+  const y = 1 - ((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * t * Math.exp(-absX * absX / 2);
+  return 0.5 * (1 + sign * y);
+}
+
+// src/power-analysis.ts
+function requiredSampleSize(opts) {
+  const effect = opts.effect;
+  if (!Number.isFinite(effect) || effect <= 0) return Infinity;
+  const alpha = opts.alpha ?? 0.05;
+  const power = opts.power ?? 0.8;
+  const twoSided = opts.twoSided ?? true;
+  const zAlpha = zQuantile(twoSided ? 1 - alpha / 2 : 1 - alpha);
+  const zBeta = zQuantile(power);
+  const n = 2 * Math.pow((zAlpha + zBeta) / effect, 2);
+  return Math.ceil(n);
+}
+function pairedMde(opts) {
+  if (!Number.isFinite(opts.nPaired) || opts.nPaired <= 0) return Infinity;
+  const alpha = opts.alpha ?? 0.05;
+  const power = opts.power ?? 0.8;
+  const twoSided = opts.twoSided ?? true;
+  const zAlpha = zQuantile(twoSided ? 1 - alpha / 2 : 1 - alpha);
+  const zBeta = zQuantile(power);
+  return (zAlpha + zBeta) / Math.sqrt(opts.nPaired);
+}
+function bonferroni(pValues, alpha = 0.05) {
+  const k = pValues.length;
+  const adjusted = pValues.map((p) => Math.min(1, p * k));
+  const significant = adjusted.map((p) => p < alpha);
+  return { adjusted, significant };
+}
+function benjaminiHochberg(pValues, fdr = 0.05) {
+  const n = pValues.length;
+  if (n === 0) return { qValues: [], significant: [] };
+  const indexed = pValues.map((p, i) => ({ p, i })).sort((a, b) => a.p - b.p);
+  const q = new Array(n);
+  let minRight = 1;
+  for (let k = n - 1; k >= 0; k--) {
+    const rank = k + 1;
+    const raw = indexed[k].p * n / rank;
+    const bounded = Math.min(minRight, raw);
+    minRight = bounded;
+    q[indexed[k].i] = Math.min(1, bounded);
+  }
+  const significant = q.map((v) => v < fdr);
+  return { qValues: q, significant };
+}
+function zQuantile(p) {
+  if (p <= 0 || p >= 1) {
+    if (p === 0) return -Infinity;
+    if (p === 1) return Infinity;
+    return NaN;
+  }
+  const a = [-39.69683028665376, 220.9460984245205, -275.9285104469687, 138.357751867269, -30.66479806614716, 2.506628277459239];
+  const b = [-54.47609879822406, 161.5858368580409, -155.6989798598866, 66.80131188771972, -13.28068155288572];
+  const c = [-0.007784894002430293, -0.3223964580411365, -2.400758277161838, -2.549732539343734, 4.374664141464968, 2.938163982698783];
+  const d = [0.007784695709041462, 0.3224671290700398, 2.445134137142996, 3.754408661907416];
+  const pLow = 0.02425;
+  const pHigh = 1 - pLow;
+  let q;
+  let r;
+  if (p < pLow) {
+    q = Math.sqrt(-2 * Math.log(p));
+    return (((((c[0] * q + c[1]) * q + c[2]) * q + c[3]) * q + c[4]) * q + c[5]) / ((((d[0] * q + d[1]) * q + d[2]) * q + d[3]) * q + 1);
+  }
+  if (p <= pHigh) {
+    q = p - 0.5;
+    r = q * q;
+    return (((((a[0] * r + a[1]) * r + a[2]) * r + a[3]) * r + a[4]) * r + a[5]) * q / (((((b[0] * r + b[1]) * r + b[2]) * r + b[3]) * r + b[4]) * r + 1);
+  }
+  q = Math.sqrt(-2 * Math.log(1 - p));
+  return -(((((c[0] * q + c[1]) * q + c[2]) * q + c[3]) * q + c[4]) * q + c[5]) / ((((d[0] * q + d[1]) * q + d[2]) * q + d[3]) * q + 1);
+}
+
+// src/paired-stats.ts
+function pairedBootstrap(before, after, opts = {}) {
+  if (before.length !== after.length) {
+    throw new Error(
+      `pairedBootstrap: unequal sample sizes (${before.length} vs ${after.length})`
+    );
+  }
+  const confidence = opts.confidence ?? 0.95;
+  const resamples = opts.resamples ?? 2e3;
+  const statistic = opts.statistic ?? "median";
+  if (confidence <= 0 || confidence >= 1) {
+    throw new Error(`pairedBootstrap: confidence must be in (0,1), got ${confidence}`);
+  }
+  const n = before.length;
+  const deltas = before.map((b, i) => after[i] - b);
+  if (n === 0) {
+    return { n: 0, median: 0, mean: 0, low: 0, high: 0, confidence, resamples };
+  }
+  if (n === 1) {
+    const d = deltas[0];
+    return { n: 1, median: d, mean: d, low: d, high: d, confidence, resamples };
+  }
+  const rng = makeRng(opts.seed);
+  const samples = new Array(resamples);
+  for (let b = 0; b < resamples; b++) {
+    let acc = null;
+    if (statistic === "mean") {
+      let sum = 0;
+      for (let k = 0; k < n; k++) {
+        sum += deltas[Math.floor(rng() * n)];
+      }
+      samples[b] = sum / n;
+    } else {
+      acc = new Array(n);
+      for (let k = 0; k < n; k++) {
+        acc[k] = deltas[Math.floor(rng() * n)];
+      }
+      samples[b] = medianInPlace(acc);
+    }
+  }
+  samples.sort((a, b) => a - b);
+  const alpha = 1 - confidence;
+  const lowIdx = Math.floor(alpha / 2 * resamples);
+  const highIdx = Math.min(resamples - 1, Math.ceil((1 - alpha / 2) * resamples) - 1);
+  return {
+    n,
+    median: medianInPlace([...deltas]),
+    mean: deltas.reduce((s, x) => s + x, 0) / n,
+    low: samples[lowIdx],
+    high: samples[Math.max(highIdx, lowIdx)],
+    confidence,
+    resamples
+  };
+}
+function pairedWilcoxon(before, after) {
+  return wilcoxonSignedRank(before, after);
+}
+function bhAdjust(pValues, fdr = 0.05) {
+  return benjaminiHochberg(pValues, fdr);
+}
+function medianInPlace(xs) {
+  if (xs.length === 0) return 0;
+  xs.sort((a, b) => a - b);
+  const mid = Math.floor(xs.length / 2);
+  return xs.length % 2 === 0 ? (xs[mid - 1] + xs[mid]) / 2 : xs[mid];
+}
+function makeRng(seed) {
+  if (seed === void 0) return Math.random;
+  let s = seed | 0 || 2654435769;
+  return () => {
+    s = s + 1831565813 | 0;
+    let t = s;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+
+// src/summary-report.ts
+function summaryTable(runs, opts = {}) {
+  const split = opts.split ?? "holdout";
+  const confidence = opts.confidence ?? 0.95;
+  const fdr = opts.fdr ?? 0.05;
+  const comparator = opts.comparator ?? null;
+  const scoreField = split === "holdout" ? "holdoutScore" : "searchScore";
+  const byCandidate = /* @__PURE__ */ new Map();
+  for (const r of runs) {
+    if (r.splitTag !== split) continue;
+    const v = r.outcome[scoreField];
+    if (typeof v !== "number" || !Number.isFinite(v)) continue;
+    const bucket = byCandidate.get(r.candidateId) ?? { runs: [], scores: [] };
+    bucket.runs.push(r);
+    bucket.scores.push(v);
+    byCandidate.set(r.candidateId, bucket);
+  }
+  const candidateIds = [...byCandidate.keys()].sort();
+  const compRuns = comparator ? byCandidate.get(comparator) : void 0;
+  const tentative = [];
+  for (const id of candidateIds) {
+    const bucket = byCandidate.get(id);
+    const ci = confidenceInterval(bucket.scores, confidence);
+    let rawP = Number.NaN;
+    let d = Number.NaN;
+    if (comparator && compRuns && id !== comparator) {
+      const paired = pairScoresByKey(bucket.runs, compRuns.runs, scoreField);
+      if (paired.before.length >= 6) {
+        rawP = wilcoxonSignedRank(paired.before, paired.after).p;
+      }
+      d = cohensD(compRuns.scores, bucket.scores);
+    }
+    tentative.push({
+      candidateId: id,
+      n: bucket.scores.length,
+      mean: ci.mean,
+      ciLow: ci.lower,
+      ciHigh: ci.upper,
+      qValue: rawP,
+      cohensD: d,
+      rawP
+    });
+  }
+  if (comparator) {
+    const idxs = [];
+    const ps = [];
+    for (let i = 0; i < tentative.length; i++) {
+      const r = tentative[i];
+      if (r.candidateId === comparator) continue;
+      if (!Number.isFinite(r.rawP)) continue;
+      idxs.push(i);
+      ps.push(r.rawP);
+    }
+    if (ps.length > 0) {
+      const { qValues } = benjaminiHochberg(ps, fdr);
+      for (let k = 0; k < idxs.length; k++) {
+        tentative[idxs[k]].qValue = qValues[k];
+      }
+    }
+  }
+  const rows = tentative.map(({ rawP: _rawP, ...rest }) => rest);
+  const markdown = renderSummaryTableMarkdown(rows, comparator, split);
+  return { rows, comparator, split, markdown };
+}
+function pairScoresByKey(candidate, baseline, scoreField) {
+  const baseIdx = /* @__PURE__ */ new Map();
+  for (const r of baseline) {
+    const v = r.outcome[scoreField];
+    if (typeof v === "number" && Number.isFinite(v)) {
+      baseIdx.set(`${r.experimentId}::${r.seed}`, v);
+    }
+  }
+  const before = [];
+  const after = [];
+  for (const r of candidate) {
+    const v = r.outcome[scoreField];
+    if (typeof v !== "number" || !Number.isFinite(v)) continue;
+    const key = `${r.experimentId}::${r.seed}`;
+    const b = baseIdx.get(key);
+    if (b === void 0) continue;
+    before.push(b);
+    after.push(v);
+  }
+  return { before, after };
+}
+function renderSummaryTableMarkdown(rows, comparator, split) {
+  const lines = [];
+  const cmpLabel = comparator ? ` (vs ${comparator})` : "";
+  lines.push(`Summary Table \u2014 ${split} split${cmpLabel}`);
+  lines.push("");
+  lines.push("| Candidate | N | Mean | 95% CI | q (BH) | Cohen's d |");
+  lines.push("|---|---:|---:|---|---:|---:|");
+  for (const r of rows) {
+    const ci = `[${fmt(r.ciLow)}, ${fmt(r.ciHigh)}]`;
+    const q = Number.isFinite(r.qValue) ? r.qValue.toFixed(4) : "\u2014";
+    const d = Number.isFinite(r.cohensD) ? r.cohensD.toFixed(3) : "\u2014";
+    lines.push(`| ${r.candidateId} | ${r.n} | ${fmt(r.mean)} | ${ci} | ${q} | ${d} |`);
+  }
+  return lines.join("\n");
+}
+function paretoChart(runs, opts = {}) {
+  const split = opts.split ?? "holdout";
+  const scoreField = split === "holdout" ? "holdoutScore" : "searchScore";
+  const buckets = /* @__PURE__ */ new Map();
+  for (const r of runs) {
+    if (r.splitTag !== split) continue;
+    const v = r.outcome[scoreField];
+    if (typeof v !== "number" || !Number.isFinite(v)) continue;
+    const bucket = buckets.get(r.candidateId) ?? { cost: [], quality: [] };
+    bucket.cost.push(r.costUsd);
+    bucket.quality.push(v);
+    buckets.set(r.candidateId, bucket);
+  }
+  const points = [];
+  for (const [candidateId, bucket] of buckets.entries()) {
+    points.push({
+      candidateId,
+      cost: avg(bucket.cost),
+      quality: avg(bucket.quality),
+      n: bucket.cost.length,
+      onFrontier: false,
+      gate: opts.gateDecisions?.[candidateId] ? gateLabel(opts.gateDecisions[candidateId]) : void 0
+    });
+  }
+  for (const p of points) {
+    p.onFrontier = !points.some((q) => q !== p && dominates(q, p));
+  }
+  return {
+    kind: "pareto-cost-quality",
+    split,
+    axes: { x: "costUsd", y: "score" },
+    points
+  };
+}
+function dominates(a, b) {
+  return a.cost <= b.cost && a.quality >= b.quality && (a.cost < b.cost || a.quality > b.quality);
+}
+function gateLabel(d) {
+  if (d.promote) return "promote";
+  if (d.rejectionCode === "few_runs") return "reject_few_runs";
+  if (d.rejectionCode === "negative_delta") return "reject_negative_delta";
+  if (d.rejectionCode === "overfit_gap") return "reject_overfit_gap";
+  return null;
+}
+function gainHistogram(runs, candidateId, comparator, opts = {}) {
+  const split = opts.split ?? "holdout";
+  const scoreField = split === "holdout" ? "holdoutScore" : "searchScore";
+  const binCount = opts.bins ?? 11;
+  if (binCount < 1) throw new Error("gainHistogram: bins must be \u2265 1");
+  const candidate = runs.filter((r) => r.candidateId === candidateId && r.splitTag === split);
+  const baseline = runs.filter((r) => r.candidateId === comparator && r.splitTag === split);
+  const { before, after } = pairScoresByKey(candidate, baseline, scoreField);
+  const n = before.length;
+  if (n === 0) {
+    return {
+      kind: "gain-distribution",
+      candidateId,
+      comparator,
+      split,
+      n: 0,
+      bins: [],
+      median: 0,
+      ci: { low: 0, high: 0 }
+    };
+  }
+  const deltas = before.map((b, i) => after[i] - b);
+  const sortedDeltas = [...deltas].sort((a, b) => a - b);
+  const median = medianOfSorted(sortedDeltas);
+  const min = sortedDeltas[0];
+  const max = sortedDeltas[sortedDeltas.length - 1];
+  const bound = Math.max(Math.abs(min), Math.abs(max), 1e-6);
+  const lo = -bound;
+  const hi = bound;
+  const width = (hi - lo) / binCount;
+  const bins = [];
+  for (let i = 0; i < binCount; i++) {
+    bins.push({ lo: lo + i * width, hi: lo + (i + 1) * width, count: 0 });
+  }
+  for (const d of deltas) {
+    let idx = Math.floor((d - lo) / width);
+    if (idx < 0) idx = 0;
+    if (idx >= binCount) idx = binCount - 1;
+    bins[idx].count += 1;
+  }
+  const ci = pairedBootstrap(before, after, {
+    confidence: opts.confidence ?? 0.95,
+    resamples: opts.resamples ?? 2e3,
+    statistic: "median",
+    seed: opts.seed
+  });
+  return {
+    kind: "gain-distribution",
+    candidateId,
+    comparator,
+    split,
+    n,
+    bins,
+    median,
+    ci: { low: ci.low, high: ci.high }
+  };
+}
+var RESEARCH_REPORT_HARD_PAIR_FLOOR = 6;
+function pairedPosterior(runs, candidateId, comparator, opts) {
+  const scoreField = opts.split === "holdout" ? "holdoutScore" : "searchScore";
+  const candidate = runs.filter((r) => r.candidateId === candidateId && r.splitTag === opts.split);
+  const baseline = runs.filter((r) => r.candidateId === comparator && r.splitTag === opts.split);
+  const { before, after } = pairScoresByKey(candidate, baseline, scoreField);
+  const n = before.length;
+  if (n === 0) return null;
+  const deltas = before.map((b, i) => after[i] - b);
+  const meanDelta = deltas.reduce((s, x) => s + x, 0) / n;
+  const sortedDeltas = [...deltas].sort((a, b) => a - b);
+  const medianDelta = medianOfSorted(sortedDeltas);
+  const sdDelta = stdev(deltas, meanDelta);
+  const ci = pairedBootstrap(before, after, {
+    confidence: opts.confidence,
+    resamples: 2e3,
+    statistic: "median",
+    seed: opts.seed
+  });
+  const meanSamples = bootstrapMeanSamples(deltas, 2e3, opts.seed);
+  const prGreaterThanZero = meanSamples.length === 0 ? 0 : meanSamples.filter((s) => s > 0).length / meanSamples.length;
+  const prInRope = opts.rope === null || meanSamples.length === 0 ? null : meanSamples.filter((s) => s >= opts.rope.low && s <= opts.rope.high).length / meanSamples.length;
+  const dStandardised = pairedMde({ nPaired: n, alpha: opts.mdeAlpha, power: opts.mdePower });
+  const mde = sdDelta === 0 ? 0 : dStandardised * sdDelta;
+  return {
+    n,
+    meanDelta,
+    medianDelta,
+    sdDelta,
+    ci: { low: ci.low, high: ci.high },
+    prGreaterThanZero,
+    prInRope,
+    mde
+  };
+}
+function bootstrapMeanSamples(deltas, resamples, seed) {
+  const n = deltas.length;
+  if (n === 0) return [];
+  if (n === 1) return new Array(resamples).fill(deltas[0]);
+  const rng = seedRng(seed);
+  const samples = new Array(resamples);
+  for (let b = 0; b < resamples; b++) {
+    let sum = 0;
+    for (let k = 0; k < n; k++) sum += deltas[Math.floor(rng() * n)];
+    samples[b] = sum / n;
+  }
+  return samples;
+}
+function seedRng(seed) {
+  if (seed === void 0) return Math.random;
+  let s = seed >>> 0;
+  return () => {
+    s = s + 1831565813 >>> 0;
+    let t = s;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function stdev(xs, mean) {
+  if (xs.length < 2) return 0;
+  let sse = 0;
+  for (const x of xs) sse += (x - mean) ** 2;
+  return Math.sqrt(sse / (xs.length - 1));
+}
+async function researchReport(runs, opts = {}) {
+  const split = opts.split ?? "holdout";
+  const comparator = opts.comparator ?? null;
+  const confidence = opts.confidence ?? 0.95;
+  const fdr = opts.fdr ?? 0.05;
+  const minPairs = Math.max(opts.minPairs ?? 20, RESEARCH_REPORT_HARD_PAIR_FLOOR);
+  const rope = opts.rope ?? null;
+  const mdePower = opts.mdePower ?? 0.8;
+  const mdeAlpha = opts.mdeAlpha ?? fdr;
+  const title = opts.title ?? "Agent Evaluation Research Report";
+  const generatedAt = opts.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  const preregistrationHash = opts.preregistrationHash ?? null;
+  if (rope && !(Number.isFinite(rope.low) && Number.isFinite(rope.high) && rope.low <= rope.high)) {
+    throw new Error(`researchReport: rope must satisfy low \u2264 high with finite bounds, got ${JSON.stringify(rope)}`);
+  }
+  const summary = summaryTable(runs, {
+    comparator: comparator ?? void 0,
+    split,
+    confidence,
+    fdr
+  });
+  const pareto = paretoChart(runs, { split, gateDecisions: opts.gateDecisions });
+  const candidateIds = opts.candidateIds ?? summary.rows.map((r) => r.candidateId).filter((id) => id !== comparator);
+  const gains = comparator ? candidateIds.map((id) => gainHistogram(runs, id, comparator, {
+    split,
+    confidence,
+    seed: opts.seed
+  })) : [];
+  const gainByCandidate = new Map(gains.map((g) => [g.candidateId, g]));
+  const paretoByCandidate = new Map(pareto.points.map((p) => [p.candidateId, p]));
+  const posteriorByCandidate = /* @__PURE__ */ new Map();
+  if (comparator) {
+    for (const id of candidateIds) {
+      posteriorByCandidate.set(id, pairedPosterior(runs, id, comparator, {
+        split,
+        confidence,
+        seed: opts.seed,
+        rope,
+        mdePower,
+        mdeAlpha
+      }));
+    }
+  }
+  const candidates = summary.rows.map((row) => {
+    const gain = gainByCandidate.get(row.candidateId);
+    const point = paretoByCandidate.get(row.candidateId);
+    const posterior = posteriorByCandidate.get(row.candidateId) ?? null;
+    const classified = classifyCandidate(row, {
+      comparator,
+      posterior,
+      point,
+      fdr,
+      minPairs,
+      rope
+    });
+    return {
+      candidateId: row.candidateId,
+      n: row.n,
+      mean: row.mean,
+      ciLow: row.ciLow,
+      ciHigh: row.ciHigh,
+      qValue: row.qValue,
+      cohensD: row.cohensD,
+      meanDeltaVsComparator: posterior ? posterior.meanDelta : null,
+      pairedN: posterior?.n ?? gain?.n ?? 0,
+      medianGain: posterior ? posterior.medianDelta : gain ? gain.median : null,
+      meanGain: posterior ? posterior.meanDelta : null,
+      gainCi: posterior ? posterior.ci : gain ? gain.ci : null,
+      prGreaterThanZero: posterior ? posterior.prGreaterThanZero : null,
+      prInRope: posterior ? posterior.prInRope : null,
+      mde: posterior ? posterior.mde : null,
+      onParetoFrontier: point?.onFrontier ?? false,
+      gate: point?.gate,
+      decision: classified.decision,
+      decisionReason: classified.reason
+    };
+  }).sort((a, b) => {
+    const decisionRank = decisionWeight(b.decision) - decisionWeight(a.decision);
+    if (decisionRank !== 0) return decisionRank;
+    return b.mean - a.mean;
+  });
+  const recommendation = buildRecommendation(candidates, {
+    comparator,
+    failureClusters: opts.failureClusters,
+    rope,
+    minPairs,
+    preregistrationHash
+  });
+  const executiveSummary = buildExecutiveSummary(candidates, recommendation, {
+    comparator,
+    split,
+    failureClusters: opts.failureClusters,
+    preregistrationHash
+  });
+  const methodology = buildMethodology({ split, comparator, fdr, minPairs, rope, confidence, mdePower, mdeAlpha });
+  const runFingerprint = await hashJson(canonicalize({
+    triples: runs.filter((r) => r.splitTag === split).map((r) => ({ runId: r.runId, candidateId: r.candidateId, splitTag: r.splitTag })).sort((a, b) => a.runId.localeCompare(b.runId)),
+    comparator,
+    split
+  }));
+  const markdown = renderResearchMarkdown({
+    title,
+    generatedAt,
+    split,
+    comparator,
+    rope,
+    runFingerprint,
+    preregistrationHash,
+    executiveSummary,
+    recommendation,
+    candidates,
+    summary,
+    pareto,
+    gains,
+    methodology,
+    failureClusters: opts.failureClusters
+  });
+  const html = renderResearchHtml(markdown, title);
+  return {
+    kind: "agent-eval-research-report",
+    title,
+    generatedAt,
+    split,
+    comparator,
+    runFingerprint,
+    preregistrationHash,
+    rope,
+    executiveSummary,
+    recommendation,
+    candidates,
+    summary,
+    charts: { pareto, gains },
+    methodology,
+    failureClusters: opts.failureClusters,
+    markdown,
+    html
+  };
+}
+function buildMethodology(ctx) {
+  const assumptions = [
+    "Pairs are matched by (experimentId, seed); the candidate and comparator see the same scenarios in the same order.",
+    "Paired deltas are exchangeable conditional on the matched scenario \u2014 no mid-run distribution shift.",
+    `Decisions are pre-specified at fdr=${ctx.fdr}, minPairs=${ctx.minPairs}, confidence=${ctx.confidence}; deviating from these post-hoc invalidates the false-discovery control.`
+  ];
+  if (ctx.rope) {
+    assumptions.push(`The Region of Practical Equivalence ${formatRope(ctx.rope)} is supplied by the domain owner; equivalent verdicts are only meaningful if that range is treated as the standing definition of "no material difference."`);
+  }
+  if (ctx.comparator === null) {
+    assumptions.push("No comparator was configured; this run is descriptive, not causal.");
+  }
+  const methods = [
+    "Marginal scores summarised with BH-FDR-adjusted Wilcoxon signed-rank q-values and Cohen's d via summaryTable.",
+    "Paired evidence summarised with bootstrap CI on the median delta and Bayesian-bootstrap-style Pr(\u0394>0) and Pr(\u0394\u2208ROPE) on the mean delta.",
+    `Minimum detectable effect reported per candidate at \u03B1=${ctx.mdeAlpha} (two-sided), power=${ctx.mdePower}, standardised by the observed paired-delta SD.`,
+    "Pareto frontier flagged as a separate axis (cost vs quality); a candidate can be on-frontier without winning the paired test.",
+    "Held-out gate decisions, when supplied, override the statistical verdict in the reject direction."
+  ];
+  const alternatives = [
+    "Paired t-test rejected: not robust to the heavy-tailed score distributions common in agent benchmarks.",
+    "Unpaired Mann\u2013Whitney rejected: matched scenarios make pairing free; unpaired throws away that variance reduction.",
+    "Sequential / always-valid inference (e-values, mSPRT) is the right tool for iterative sweeps and is out of scope for this single-look report \u2014 preregister and run once, or wrap this report in an alpha-spending schedule.",
+    "Hierarchical Bayesian shrinkage across many candidates is future work; the current ranking uses raw paired statistics."
+  ];
+  const whenNotToApply = [
+    `Paired N below ${RESEARCH_REPORT_HARD_PAIR_FLOOR} on any candidate \u2014 the bootstrap CI is degenerate.`,
+    "Comparator chosen post-hoc by inspecting the same data; q-values are no longer false-discovery-controlled.",
+    "Scenarios not drawn under a stable preregistered protocol; the report can describe the data but cannot anchor a launch decision.",
+    "Score distributions with mid-run shift (judge model swap, rubric change, infra outage) \u2014 pair exchangeability is violated."
+  ];
+  const citations = [
+    "Benjamini, Y. & Hochberg, Y. (1995). Controlling the false discovery rate: a practical and powerful approach to multiple testing. JRSS B, 57(1), 289\u2013300.",
+    "Wilcoxon, F. (1945). Individual comparisons by ranking methods. Biometrics Bulletin, 1(6), 80\u201383.",
+    "Efron, B. (1979). Bootstrap methods: another look at the jackknife. Annals of Statistics, 7(1), 1\u201326.",
+    "Rubin, D. B. (1981). The Bayesian bootstrap. Annals of Statistics, 9(1), 130\u2013134.",
+    "Kruschke, J. K. (2018). Rejecting or accepting parameter values in Bayesian estimation. Advances in Methods and Practices in Psychological Science, 1(2), 270\u2013280. (ROPE.)"
+  ];
+  return { assumptions, methods, alternatives, whenNotToApply, citations };
+}
+function formatRope(rope) {
+  return `[${fmt(rope.low)}, ${fmt(rope.high)}]`;
+}
+function classifyCandidate(row, ctx) {
+  if (ctx.comparator && row.candidateId === ctx.comparator) {
+    return { decision: "hold", reason: "Comparator baseline." };
+  }
+  if (!ctx.comparator) {
+    return {
+      decision: ctx.point?.onFrontier ? "hold" : "needs_more_data",
+      reason: "No comparator configured; report ranks candidates but cannot anchor a promotion call."
+    };
+  }
+  if (ctx.point?.gate && ctx.point.gate !== "promote") {
+    return { decision: "reject", reason: `Held-out gate returned ${ctx.point.gate}.` };
+  }
+  if (!ctx.posterior || ctx.posterior.n < RESEARCH_REPORT_HARD_PAIR_FLOOR) {
+    return {
+      decision: "needs_more_data",
+      reason: `Only ${ctx.posterior?.n ?? 0} paired observations; below hard floor of ${RESEARCH_REPORT_HARD_PAIR_FLOOR} for any paired inference.`
+    };
+  }
+  const ci = ctx.posterior.ci;
+  if (ctx.rope && ci.low >= ctx.rope.low && ci.high <= ctx.rope.high) {
+    return {
+      decision: "equivalent",
+      reason: `Paired-delta CI [${fmt(ci.low)}, ${fmt(ci.high)}] is fully inside ROPE ${formatRope(ctx.rope)}; candidate is practically equivalent to comparator.`
+    };
+  }
+  const significant = Number.isFinite(row.qValue) && row.qValue <= ctx.fdr;
+  const gainPositive = ci.low > 0;
+  const gainNegative = ci.high < 0;
+  if (gainNegative) {
+    return { decision: "reject", reason: `Paired-delta CI [${fmt(ci.low)}, ${fmt(ci.high)}] lies entirely below zero.` };
+  }
+  if (ctx.posterior.n < ctx.minPairs) {
+    return {
+      decision: "needs_more_data",
+      reason: `Only ${ctx.posterior.n} paired observations; minimum detectable effect at this N is ${fmt(ctx.posterior.mde)} score units (need \u2265 ${ctx.minPairs} pairs to issue a directional verdict).`
+    };
+  }
+  if (significant && gainPositive) {
+    return {
+      decision: "promote",
+      reason: `BH-adjusted q=${fmt(row.qValue)} \u2264 ${ctx.fdr} and paired-delta CI [${fmt(ci.low)}, ${fmt(ci.high)}] excludes zero; Pr(\u0394>0)=${fmt(ctx.posterior.prGreaterThanZero)}.`
+    };
+  }
+  return {
+    decision: "hold",
+    reason: `Pr(\u0394>0)=${fmt(ctx.posterior.prGreaterThanZero)} but CI [${fmt(ci.low)}, ${fmt(ci.high)}] crosses zero; effect not decisive at fdr=${ctx.fdr}.`
+  };
+}
+function buildRecommendation(candidates, ctx) {
+  const nonComparator = candidates.filter((c) => c.candidateId !== ctx.comparator);
+  const bestPromote = nonComparator.find((c) => c.decision === "promote");
+  const bestEquivalent = nonComparator.find((c) => c.decision === "equivalent");
+  const chosen = bestPromote ?? bestEquivalent ?? nonComparator[0] ?? null;
+  const decision = bestPromote ? "promote" : nonComparator.some((c) => c.decision === "needs_more_data") ? "needs_more_data" : bestEquivalent ? "equivalent" : nonComparator.some((c) => c.decision === "hold") ? "hold" : "reject";
+  const rationale = [];
+  const risks = [];
+  const nextActions = [];
+  if (chosen) {
+    rationale.push(`${chosen.candidateId}: ${chosen.decisionReason}`);
+    if (chosen.gainCi) {
+      const probSummary = chosen.prGreaterThanZero !== null ? `, Pr(\u0394>0)=${fmt(chosen.prGreaterThanZero)}` : "";
+      rationale.push(`Median paired gain CI: [${fmt(chosen.gainCi.low)}, ${fmt(chosen.gainCi.high)}]${probSummary}.`);
+    }
+    if (chosen.mde !== null && Number.isFinite(chosen.mde)) {
+      rationale.push(`MDE at current paired N=${chosen.pairedN}: ${fmt(chosen.mde)} score units.`);
+    }
+  }
+  if (!ctx.comparator) {
+    risks.push("No comparator was configured; verdict is descriptive, not causal.");
+    nextActions.push("Re-run with a stable comparator candidate for paired inference.");
+  }
+  if (!ctx.preregistrationHash) {
+    risks.push("No preregistration hash supplied; readers cannot verify the analysis was specified before data inspection.");
+    nextActions.push("Sign a HypothesisManifest before the next sweep and pass `preregistrationHash` so the report cites it.");
+  }
+  if (ctx.rope === null && nonComparator.length > 0) {
+    risks.push('No ROPE configured; the report cannot distinguish "equivalent" from "inconclusive".');
+    nextActions.push("Define a domain-specific Region of Practical Equivalence and pass it to lock in the equivalence threshold.");
+  }
+  const inconclusive = nonComparator.filter((c) => c.decision === "needs_more_data");
+  if (inconclusive.length > 0) {
+    const worst = inconclusive.reduce((a, b) => b.pairedN < a.pairedN ? b : a);
+    risks.push(`${inconclusive.length} candidate(s) below soft floor (${ctx.minPairs} pairs); thinnest is ${worst.candidateId} with ${worst.pairedN}.`);
+    nextActions.push(`Collect at least ${ctx.minPairs - worst.pairedN} more matched holdout runs for ${worst.candidateId}.`);
+  }
+  const rejected = nonComparator.filter((c) => c.decision === "reject");
+  if (rejected.length > 0) {
+    risks.push(`${rejected.length} candidate(s) failed the paired test or held-out gate; do not ship those variants.`);
+  }
+  if (ctx.failureClusters && ctx.failureClusters.clusters.length > 0) {
+    const top = ctx.failureClusters.clusters[0];
+    risks.push(`Top failure cluster: ${top.failureClass} across ${top.runCount} run(s).`);
+    nextActions.push("Prioritize the largest failure cluster before broad rollout.");
+  }
+  if (decision === "promote") {
+    nextActions.push("Ship behind the existing promotion gate and monitor canaries.");
+  } else if (decision === "hold") {
+    nextActions.push("Keep current production candidate while expanding holdout evidence.");
+  } else if (decision === "equivalent") {
+    nextActions.push("Either keep the comparator (no quality regression) or promote on cost/latency grounds \u2014 equivalence does not justify either; the choice is a product decision, not a stats one.");
+  } else if (decision === "reject") {
+    nextActions.push("Do not promote this sweep; inspect failures and generate a revised candidate.");
+  }
+  return {
+    decision,
+    candidateId: chosen?.candidateId ?? null,
+    rationale,
+    risks,
+    nextActions
+  };
+}
+function buildExecutiveSummary(candidates, recommendation, ctx) {
+  const lines = [];
+  const nonComparator = candidates.filter((c) => c.candidateId !== ctx.comparator);
+  lines.push(`Evaluated ${nonComparator.length} candidate(s) on the ${ctx.split} split${ctx.comparator ? ` against ${ctx.comparator}` : ""}.`);
+  lines.push(`Recommendation: ${recommendation.decision}${recommendation.candidateId ? ` ${recommendation.candidateId}` : ""}.`);
+  const promoted = nonComparator.filter((c) => c.decision === "promote").length;
+  const held = nonComparator.filter((c) => c.decision === "hold").length;
+  const equivalent = nonComparator.filter((c) => c.decision === "equivalent").length;
+  const rejected = nonComparator.filter((c) => c.decision === "reject").length;
+  const more = nonComparator.filter((c) => c.decision === "needs_more_data").length;
+  lines.push(`Decision mix: ${promoted} promote, ${equivalent} equivalent, ${held} hold, ${rejected} reject, ${more} need more data.`);
+  const frontier = nonComparator.filter((c) => c.onParetoFrontier).map((c) => c.candidateId);
+  if (frontier.length > 0) lines.push(`Pareto-frontier candidates: ${frontier.join(", ")}.`);
+  if (ctx.failureClusters) {
+    lines.push(`Failure clustering found ${ctx.failureClusters.totalFailures}/${ctx.failureClusters.totalRuns} failed runs across ${ctx.failureClusters.clusters.length} reportable cluster(s).`);
+  }
+  lines.push(ctx.preregistrationHash ? `Preregistered analysis: ${ctx.preregistrationHash.slice(0, 12)}\u2026` : "Analysis is post-hoc \u2014 no preregistration hash supplied.");
+  return lines;
+}
+function renderResearchMarkdown(report) {
+  const lines = [];
+  lines.push(`# ${report.title}`);
+  lines.push("");
+  lines.push(`**Generated:** ${report.generatedAt}`);
+  lines.push(`**Primary split:** ${report.split}`);
+  lines.push(`**Comparator:** ${report.comparator ?? "not configured"}`);
+  lines.push(`**ROPE:** ${report.rope ? formatRope(report.rope) : "not configured"}`);
+  lines.push(`**Run fingerprint:** \`${report.runFingerprint}\``);
+  lines.push(`**Preregistration:** ${report.preregistrationHash ? `\`${report.preregistrationHash}\`` : "none"}`);
+  lines.push("");
+  lines.push("## Executive Summary");
+  lines.push("");
+  for (const item of report.executiveSummary) lines.push(`- ${item}`);
+  lines.push("");
+  lines.push("## Recommendation");
+  lines.push("");
+  lines.push(`**Decision:** ${report.recommendation.decision}`);
+  lines.push(`**Candidate:** ${report.recommendation.candidateId ?? "N/A"}`);
+  lines.push("");
+  lines.push("### Rationale");
+  lines.push("");
+  for (const item of report.recommendation.rationale) lines.push(`- ${item}`);
+  lines.push("");
+  lines.push("### Risks");
+  lines.push("");
+  for (const item of report.recommendation.risks.length ? report.recommendation.risks : ["No material report-level risks detected."]) {
+    lines.push(`- ${item}`);
+  }
+  lines.push("");
+  lines.push("### Next Actions");
+  lines.push("");
+  for (const item of report.recommendation.nextActions) lines.push(`- ${item}`);
+  lines.push("");
+  lines.push("## Candidate Decision Table");
+  lines.push("");
+  lines.push("| Candidate | Decision | Mean | \u0394\u0304 | Pr(\u0394>0) | q | d | Paired N | Median Gain CI | MDE | Pareto | Gate |");
+  lines.push("|---|---|---:|---:|---:|---:|---:|---:|---|---:|---|---|");
+  for (const c of report.candidates) {
+    const delta = c.meanDeltaVsComparator === null ? "-" : signed(c.meanDeltaVsComparator);
+    const prGt = c.prGreaterThanZero === null ? "-" : c.prGreaterThanZero.toFixed(3);
+    const q = Number.isFinite(c.qValue) ? c.qValue.toFixed(4) : "-";
+    const d = Number.isFinite(c.cohensD) ? c.cohensD.toFixed(3) : "-";
+    const gain = c.gainCi ? `[${fmt(c.gainCi.low)}, ${fmt(c.gainCi.high)}]` : "-";
+    const mde = c.mde === null || !Number.isFinite(c.mde) ? "-" : fmt(c.mde);
+    lines.push(`| ${c.candidateId} | ${c.decision} | ${fmt(c.mean)} | ${delta} | ${prGt} | ${q} | ${d} | ${c.pairedN} | ${gain} | ${mde} | ${c.onParetoFrontier ? "yes" : "no"} | ${c.gate ?? "-"} |`);
+  }
+  lines.push("");
+  lines.push("## Statistical Summary");
+  lines.push("");
+  lines.push(report.summary.markdown);
+  lines.push("");
+  lines.push("## Methodology");
+  lines.push("");
+  lines.push("### Assumptions");
+  lines.push("");
+  for (const item of report.methodology.assumptions) lines.push(`- ${item}`);
+  lines.push("");
+  lines.push("### Methods");
+  lines.push("");
+  for (const item of report.methodology.methods) lines.push(`- ${item}`);
+  lines.push("");
+  lines.push("### Alternatives Considered");
+  lines.push("");
+  for (const item of report.methodology.alternatives) lines.push(`- ${item}`);
+  lines.push("");
+  lines.push("### When NOT To Apply");
+  lines.push("");
+  for (const item of report.methodology.whenNotToApply) lines.push(`- ${item}`);
+  lines.push("");
+  lines.push("### Citations");
+  lines.push("");
+  for (const item of report.methodology.citations) lines.push(`- ${item}`);
+  lines.push("");
+  lines.push("## Chart Specs");
+  lines.push("");
+  lines.push("The report carries JSON chart specs for Pareto cost/quality and paired gain histograms.");
+  lines.push("");
+  lines.push("```json");
+  lines.push(JSON.stringify({ pareto: report.pareto, gains: report.gains }, null, 2));
+  lines.push("```");
+  if (report.failureClusters) {
+    lines.push("");
+    lines.push("## Failure Clusters");
+    lines.push("");
+    lines.push("| Failure Class | Runs | Scenarios | Tool | Example |");
+    lines.push("|---|---:|---:|---|---|");
+    for (const c of report.failureClusters.clusters.slice(0, 10)) {
+      lines.push(`| ${c.failureClass} | ${c.runCount} | ${c.scenarioIds.length} | ${c.toolName ?? "-"} | ${escapePipes(c.exampleError ?? c.exampleRunId)} |`);
+    }
+  }
+  return lines.join("\n");
+}
+function renderResearchHtml(markdown, title) {
+  const body = markdownToHtml(markdown);
+  return [
+    "<!doctype html>",
+    '<html lang="en">',
+    "<head>",
+    '<meta charset="utf-8">',
+    '<meta name="viewport" content="width=device-width, initial-scale=1">',
+    `<title>${escapeHtml(title)}</title>`,
+    "<style>",
+    'body{font-family:Inter,ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif;margin:0;color:#172026;background:#f7f8f8;}',
+    "main{max-width:1080px;margin:0 auto;padding:40px 24px 64px;background:#fff;min-height:100vh;}",
+    "h1{font-size:34px;line-height:1.15;margin:0 0 20px;}h2{margin-top:34px;border-top:1px solid #d9dfdf;padding-top:22px;}h3{margin-top:22px;}",
+    "p,li{line-height:1.55;}table{border-collapse:collapse;width:100%;margin:16px 0;font-size:14px;}th,td{border:1px solid #d9dfdf;padding:8px;text-align:left;}th{background:#eef2f2;}",
+    "code,pre{font-family:ui-monospace,SFMono-Regular,Menlo,monospace;}pre{overflow:auto;background:#111827;color:#f9fafb;padding:16px;border-radius:6px;}",
+    "</style>",
+    "</head>",
+    "<body><main>",
+    body,
+    "</main></body></html>"
+  ].join("\n");
+}
+function markdownToHtml(markdown) {
+  const lines = markdown.split("\n");
+  const html = [];
+  let inList = false;
+  let inCode = false;
+  let code = [];
+  let table = [];
+  const flushList = () => {
+    if (inList) {
+      html.push("</ul>");
+      inList = false;
+    }
+  };
+  const flushTable = () => {
+    if (table.length === 0) return;
+    html.push(renderMarkdownTable(table));
+    table = [];
+  };
+  for (const line of lines) {
+    if (line.startsWith("```")) {
+      if (inCode) {
+        html.push(`<pre><code>${escapeHtml(code.join("\n"))}</code></pre>`);
+        code = [];
+        inCode = false;
+      } else {
+        flushList();
+        flushTable();
+        inCode = true;
+      }
+      continue;
+    }
+    if (inCode) {
+      code.push(line);
+      continue;
+    }
+    if (line.startsWith("|")) {
+      flushList();
+      table.push(line);
+      continue;
+    }
+    flushTable();
+    if (line.startsWith("- ")) {
+      if (!inList) {
+        html.push("<ul>");
+        inList = true;
+      }
+      html.push(`<li>${inlineMarkdown(line.slice(2))}</li>`);
+      continue;
+    }
+    flushList();
+    if (line.startsWith("# ")) html.push(`<h1>${inlineMarkdown(line.slice(2))}</h1>`);
+    else if (line.startsWith("## ")) html.push(`<h2>${inlineMarkdown(line.slice(3))}</h2>`);
+    else if (line.startsWith("### ")) html.push(`<h3>${inlineMarkdown(line.slice(4))}</h3>`);
+    else if (line.trim() === "") html.push("");
+    else html.push(`<p>${inlineMarkdown(line)}</p>`);
+  }
+  flushList();
+  flushTable();
+  return html.join("\n");
+}
+function renderMarkdownTable(lines) {
+  const rows = lines.filter((line) => !/^\|[-:\s|]+\|$/.test(line)).map((line) => line.slice(1, -1).split("|").map((cell) => inlineMarkdown(cell.trim())));
+  if (rows.length === 0) return "";
+  const [head, ...body] = rows;
+  const th = head.map((cell) => `<th>${cell}</th>`).join("");
+  const trs = body.map((row) => `<tr>${row.map((cell) => `<td>${cell}</td>`).join("")}</tr>`).join("\n");
+  return `<table><thead><tr>${th}</tr></thead><tbody>${trs}</tbody></table>`;
+}
+function inlineMarkdown(s) {
+  return escapeHtml(s).replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>");
+}
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function escapePipes(s) {
+  return s.replace(/\|/g, "\\|");
+}
+function decisionWeight(decision) {
+  if (decision === "promote") return 5;
+  if (decision === "equivalent") return 4;
+  if (decision === "hold") return 3;
+  if (decision === "needs_more_data") return 2;
+  return 1;
+}
+function signed(x) {
+  return `${x >= 0 ? "+" : ""}${fmt(x)}`;
+}
+function avg(xs) {
+  if (xs.length === 0) return Number.NaN;
+  return xs.reduce((s, x) => s + x, 0) / xs.length;
+}
+function medianOfSorted(sorted) {
+  if (sorted.length === 0) return 0;
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+}
+function fmt(x) {
+  if (!Number.isFinite(x)) return String(x);
+  return x.toFixed(4);
+}
+
+export {
+  normalizeScores,
+  weightedMean,
+  confidenceInterval,
+  interRaterReliability,
+  mannWhitneyU,
+  partialCredit,
+  pairedTTest,
+  wilcoxonSignedRank,
+  cohensD,
+  requiredSampleSize,
+  bonferroni,
+  benjaminiHochberg,
+  pairedBootstrap,
+  pairedWilcoxon,
+  bhAdjust,
+  summaryTable,
+  paretoChart,
+  gainHistogram,
+  RESEARCH_REPORT_HARD_PAIR_FLOOR,
+  researchReport
+};
+//# sourceMappingURL=chunk-IOXMGMHQ.js.map