@tangle-network/agent-eval 0.23.1 → 0.24.0

package/dist/chunk-LZKIOBG2.js

@@ -1,2026 +0,0 @@
-import {
-  runEvalCampaign
-} from "./chunk-EXGR4XEM.js";
-import {
-  evaluateInterimReleaseConfidence,
-  rubricPredictiveValidity
-} from "./chunk-AXHNWLIX.js";
-import {
-  benjaminiHochberg,
-  wilcoxonSignedRank
-} from "./chunk-IOXMGMHQ.js";
-
-// src/rl/run-record-adapters.ts
-function trialToRunRecord(trial, ctx, opts = {}) {
-  const splitTag = ctx.splitTag ?? "search";
-  const promptHash = typeof ctx.promptHash === "function" ? ctx.promptHash(trial) : ctx.promptHash;
-  const configHash = typeof ctx.configHash === "function" ? ctx.configHash(trial) : ctx.configHash;
-  const runId = opts.runId ?? defaultRunId(ctx, trial);
-  const experimentId = opts.experimentIdPerTrial?.(trial) ?? ctx.experimentId;
-  const costRecorded = typeof trial.cost === "number" && Number.isFinite(trial.cost);
-  const costUsd = costRecorded ? trial.cost : ctx.defaultCostUsd ?? 0;
-  const raw = { ...trial.metrics ?? {} };
-  if (!costRecorded) raw.cost_unknown = 1;
-  if (typeof trial.durationMs === "number") raw.duration_ms = trial.durationMs;
-  raw.rep = trial.rep;
-  const score = Number.isFinite(trial.score) ? trial.score : 0;
-  const outcome = { raw };
-  if (splitTag === "holdout") outcome.holdoutScore = score;
-  else outcome.searchScore = score;
-  return {
-    runId,
-    experimentId,
-    candidateId: trial.variantId,
-    seed: trial.rep,
-    model: ctx.model,
-    promptHash,
-    configHash,
-    commitSha: ctx.commitSha,
-    wallMs: trial.durationMs ?? 0,
-    costUsd,
-    tokenUsage: { input: 0, output: 0 },
-    outcome,
-    failureMode: trial.ok ? void 0 : trial.error ? "optimizer_trial_error" : "optimizer_trial_failed",
-    splitTag,
-    scenarioId: trial.scenarioId
-  };
-}
-function trialsToRunRecords(trials, ctx) {
-  return trials.map((t) => trialToRunRecord(t, ctx));
-}
-function verificationReportToRunRecord(report, ctx, opts = {}) {
-  const splitTag = ctx.splitTag ?? "search";
-  const runId = opts.runId ?? `run-${ctx.candidateId}-${ctx.experimentId}-${report.startedAt}`;
-  const promptHash = typeof ctx.promptHash === "function" ? "p".repeat(64) : ctx.promptHash;
-  const configHash = typeof ctx.configHash === "function" ? "c".repeat(64) : ctx.configHash;
-  const raw = {
-    pass_count: report.passCount,
-    fail_count: report.failCount,
-    error_count: report.errorCount,
-    skipped_count: report.skippedCount,
-    duration_ms: report.durationMs,
-    blended_score: report.blendedScore
-  };
-  for (const layer of report.layers) {
-    if (typeof layer.score === "number") raw[`layer.${layer.layer}`] = layer.score;
-    raw[`layer_${layer.layer}_pass`] = layer.status === "pass" ? 1 : 0;
-    if (layer.diagnostics) {
-      for (const [k, v] of Object.entries(layer.diagnostics)) {
-        if (typeof v === "number" && Number.isFinite(v)) raw[`layer.${layer.layer}.${k}`] = v;
-      }
-    }
-  }
-  const firstFail = report.layers.find((l) => l.status === "fail" || l.status === "error");
-  const outcome = { raw };
-  if (splitTag === "holdout") outcome.holdoutScore = report.blendedScore;
-  else outcome.searchScore = report.blendedScore;
-  return {
-    runId,
-    experimentId: ctx.experimentId,
-    candidateId: ctx.candidateId,
-    seed: 0,
-    model: ctx.model,
-    promptHash,
-    configHash,
-    commitSha: ctx.commitSha,
-    wallMs: report.durationMs,
-    costUsd: ctx.defaultCostUsd ?? 0,
-    tokenUsage: { input: 0, output: 0 },
-    outcome,
-    failureMode: firstFail ? failureModeFromLayer(firstFail) : void 0,
-    splitTag,
-    scenarioId: ctx.scenarioId
-  };
-}
-function variantAggregateToRunRecord(agg, ctx, opts = {}) {
-  const splitTag = ctx.splitTag ?? "search";
-  const runId = opts.runId ?? `agg-${agg.variantId}-${ctx.experimentId}`;
-  const promptHash = typeof ctx.promptHash === "function" ? "p".repeat(64) : ctx.promptHash;
-  const configHash = typeof ctx.configHash === "function" ? "c".repeat(64) : ctx.configHash;
-  const raw = {
-    ...agg.metrics,
-    ok_rate: agg.okRate,
-    duration_ms: agg.meanDurationMs,
-    n_scenarios: agg.scenarios.length
-  };
-  const outcome = { raw };
-  if (splitTag === "holdout") outcome.holdoutScore = agg.meanScore;
-  else outcome.searchScore = agg.meanScore;
-  return {
-    runId,
-    experimentId: ctx.experimentId,
-    candidateId: agg.variantId,
-    seed: 0,
-    model: ctx.model,
-    promptHash,
-    configHash,
-    commitSha: ctx.commitSha,
-    wallMs: agg.meanDurationMs,
-    costUsd: agg.meanCost,
-    tokenUsage: { input: 0, output: 0 },
-    outcome,
-    splitTag
-  };
-}
-function defaultRunId(ctx, t) {
-  return `run-${ctx.experimentId}-${t.variantId}-${t.scenarioId}-${t.rep}`;
-}
-function failureModeFromLayer(layer) {
-  if (layer.status === "error") return `layer_${layer.layer}_error`;
-  if (layer.status === "fail") return `layer_${layer.layer}_fail`;
-  if (layer.status === "timeout") return `layer_${layer.layer}_timeout`;
-  return `layer_${layer.layer}_${layer.status}`;
-}
-
-// src/rl/verifiable-reward.ts
-var DEFAULT_DETERMINISTIC_LAYERS = /* @__PURE__ */ new Set([
-  "install",
-  "typecheck",
-  "build",
-  "lint",
-  "test",
-  "compile",
-  "schema",
-  "sandbox",
-  "unit_tests",
-  "integration_tests"
-]);
-var DEFAULT_SOURCE_FOR = (name) => {
-  const lower = name.toLowerCase();
-  if (lower.includes("test")) return "test";
-  if (lower.includes("compile") || lower.includes("build") || lower.includes("typecheck") || lower.includes("lint")) return "compile";
-  if (lower.includes("schema")) return "schema";
-  if (lower.includes("sandbox")) return "sandbox";
-  if (lower.includes("judge") || lower.includes("semantic")) return "judge";
-  return "composite";
-};
-function extractVerifiableReward(report, opts = {}) {
-  const deterministicSet = new Set(opts.deterministicLayers ?? [...DEFAULT_DETERMINISTIC_LAYERS]);
-  const sourceFor = opts.sourceFor ?? DEFAULT_SOURCE_FOR;
-  const fallbackToJudge = opts.fallbackToJudge ?? true;
-  const judgeFloor = opts.judgeConfidenceFloor ?? 0.7;
-  const deterministic = report.layers.filter(
-    (l) => deterministicSet.has(l.layer) && typeof l.score === "number" && Number.isFinite(l.score)
-  );
-  if (deterministic.length === 1) {
-    const layer = deterministic[0];
-    return {
-      value: clamp01(layer.score),
-      source: sourceFor(layer.layer),
-      determinism: "deterministic",
-      confidence: 1,
-      origin: layer.layer,
-      breakdown: layerBreakdown(layer)
-    };
-  }
-  if (deterministic.length > 1) {
-    let num = 0;
-    let denom = 0;
-    const breakdown = {};
-    for (const l of deterministic) {
-      const w = l.detail?.weight ?? 1;
-      num += w * (l.score ?? 0);
-      denom += w;
-      breakdown[l.layer] = l.score;
-    }
-    return {
-      value: denom === 0 ? 0 : clamp01(num / denom),
-      source: "composite",
-      determinism: "deterministic",
-      confidence: 1,
-      origin: deterministic.map((l) => l.layer).join("+"),
-      breakdown
-    };
-  }
-  if (!fallbackToJudge) return null;
-  const judge = report.layers.find(
-    (l) => typeof l.score === "number" && Number.isFinite(l.score) && sourceFor(l.layer) === "judge"
-  ) ?? report.layers.find((l) => typeof l.score === "number" && Number.isFinite(l.score));
-  if (!judge) return null;
-  const confFromDetail = judge.detail?.confidence;
-  return {
-    value: clamp01(judge.score),
-    source: "judge",
-    determinism: "probabilistic",
-    confidence: typeof confFromDetail === "number" ? confFromDetail : judgeFloor,
-    origin: judge.layer,
-    breakdown: layerBreakdown(judge)
-  };
-}
-function extractVerifiableRewardsFromRecords(runs, opts = {}) {
-  const sourceFor = opts.sourceFor ?? DEFAULT_SOURCE_FOR;
-  const deterministicSet = new Set(opts.deterministicLayers ?? [...DEFAULT_DETERMINISTIC_LAYERS]);
-  const fallbackToJudge = opts.fallbackToJudge ?? true;
-  const judgeFloor = opts.judgeConfidenceFloor ?? 0.7;
-  return runs.map((run) => {
-    const layerScores = [];
-    for (const [k, v] of Object.entries(run.outcome.raw)) {
-      if (k.startsWith("layer.") && !k.includes(".", 6) && typeof v === "number" && Number.isFinite(v)) {
-        layerScores.push({ name: k.slice("layer.".length), score: v });
-      }
-    }
-    const det = layerScores.filter((l) => deterministicSet.has(l.name));
-    if (det.length === 1) {
-      const layer = det[0];
-      return {
-        runId: run.runId,
-        reward: {
-          value: clamp01(layer.score),
-          source: sourceFor(layer.name),
-          determinism: "deterministic",
-          confidence: 1,
-          origin: layer.name
-        }
-      };
-    }
-    if (det.length > 1) {
-      const value = det.reduce((s, l) => s + l.score, 0) / det.length;
-      const breakdown = Object.fromEntries(det.map((l) => [l.name, l.score]));
-      return {
-        runId: run.runId,
-        reward: {
-          value: clamp01(value),
-          source: "composite",
-          determinism: "deterministic",
-          confidence: 1,
-          origin: det.map((l) => l.name).join("+"),
-          breakdown
-        }
-      };
-    }
-    if (!fallbackToJudge) return { runId: run.runId, reward: null };
-    const primary = run.outcome.holdoutScore ?? run.outcome.searchScore;
-    if (typeof primary !== "number" || !Number.isFinite(primary)) {
-      return { runId: run.runId, reward: null };
-    }
-    return {
-      runId: run.runId,
-      reward: {
-        value: clamp01(primary),
-        source: "judge",
-        determinism: "probabilistic",
-        confidence: judgeFloor,
-        origin: "run.outcome.score"
-      }
-    };
-  });
-}
-function filterDeterministicallyRewarded(runs, opts = {}) {
-  const rewarded = extractVerifiableRewardsFromRecords(runs, { ...opts, fallbackToJudge: false });
-  const out = [];
-  for (let i = 0; i < runs.length; i++) {
-    const r = rewarded[i];
-    if (r.reward && r.reward.determinism === "deterministic") {
-      out.push({ run: runs[i], reward: r.reward });
-    }
-  }
-  return out;
-}
-function clamp01(x) {
-  if (!Number.isFinite(x)) return 0;
-  return Math.max(0, Math.min(1, x));
-}
-function layerBreakdown(l) {
-  const out = {};
-  if (l.diagnostics) {
-    for (const [k, v] of Object.entries(l.diagnostics)) {
-      if (typeof v === "number" && Number.isFinite(v)) out[k] = v;
-    }
-  }
-  return out;
-}
-
-// src/rl/preferences.ts
-var SPLIT_TAG_DEFAULT = "holdout";
-var DEFAULT_REWARD = (run) => {
-  const v = run.outcome.holdoutScore ?? run.outcome.searchScore;
-  return typeof v === "number" && Number.isFinite(v) ? v : null;
-};
-function extractPreferences(runs, opts = {}) {
-  const strategy = opts.strategy ?? "paired-by-scenario-and-seed";
-  const minMargin = opts.minMargin ?? 0.05;
-  const splitTag = opts.splitTag ?? SPLIT_TAG_DEFAULT;
-  const rewardOf = opts.rewardOf ?? DEFAULT_REWARD;
-  const filtered = runs.filter((r) => r.splitTag === splitTag);
-  const scoredEntries = [];
-  for (const run of filtered) {
-    const s = rewardOf(run);
-    if (s === null) continue;
-    scoredEntries.push({ run, score: s });
-  }
-  const pairs = [];
-  let pairsBelowMargin = 0;
-  let cellsSingleton = 0;
-  let cellsInspected = 0;
-  if (strategy === "paired-by-scenario-and-seed") {
-    const groups = /* @__PURE__ */ new Map();
-    for (const e of scoredEntries) {
-      const sid = scenarioOf(e.run);
-      const key = `${sid}::${e.run.seed}`;
-      const arr = groups.get(key) ?? [];
-      arr.push(e);
-      groups.set(key, arr);
-    }
-    for (const [key, members] of groups.entries()) {
-      cellsInspected++;
-      if (members.length < 2) {
-        cellsSingleton++;
-        continue;
-      }
-      for (let i = 0; i < members.length; i++) {
-        for (let j = i + 1; j < members.length; j++) {
-          const a = members[i];
-          const b = members[j];
-          if (a.run.candidateId === b.run.candidateId) continue;
-          const result = makePair(a, b, key.split("::")[0], minMargin);
-          if (result.kind === "admit") pairs.push(result.pair);
-          else pairsBelowMargin++;
-        }
-      }
-    }
-  } else if (strategy === "paired-by-scenario") {
-    const byScenarioVariant = /* @__PURE__ */ new Map();
-    for (const e of scoredEntries) {
-      const sid = scenarioOf(e.run);
-      let perScenario = byScenarioVariant.get(sid);
-      if (!perScenario) {
-        perScenario = /* @__PURE__ */ new Map();
-        byScenarioVariant.set(sid, perScenario);
-      }
-      const cur = perScenario.get(e.run.candidateId);
-      if (cur) {
-        cur.sum += e.score;
-        cur.n++;
-      } else perScenario.set(e.run.candidateId, { run: e.run, sum: e.score, n: 1 });
-    }
-    for (const [sid, perVariant] of byScenarioVariant.entries()) {
-      cellsInspected++;
-      const arr = [...perVariant.entries()].map(([vid, agg]) => ({
-        run: agg.run,
-        score: agg.sum / agg.n,
-        variantId: vid
-      }));
-      if (arr.length < 2) {
-        cellsSingleton++;
-        continue;
-      }
-      for (let i = 0; i < arr.length; i++) {
-        for (let j = i + 1; j < arr.length; j++) {
-          const result = makePair(arr[i], arr[j], sid, minMargin);
-          if (result.kind === "admit") pairs.push(result.pair);
-          else pairsBelowMargin++;
-        }
-      }
-    }
-  } else {
-    const byScenario = /* @__PURE__ */ new Map();
-    for (const e of scoredEntries) {
-      const sid = scenarioOf(e.run);
-      const arr = byScenario.get(sid) ?? [];
-      arr.push(e);
-      byScenario.set(sid, arr);
-    }
-    for (const [sid, arr] of byScenario.entries()) {
-      cellsInspected++;
-      if (arr.length < 2) {
-        cellsSingleton++;
-        continue;
-      }
-      const sorted = [...arr].sort((a, b) => a.score - b.score);
-      const top = sorted[sorted.length - 1];
-      const bot = sorted[0];
-      if (top.run.candidateId === bot.run.candidateId) {
-        cellsSingleton++;
-        continue;
-      }
-      const result = makePair(bot, top, sid, minMargin);
-      if (result.kind === "admit") pairs.push(result.pair);
-      else pairsBelowMargin++;
-    }
-  }
-  return { pairs, cellsInspected, pairsBelowMargin, cellsSingleton, strategy };
-}
-function toTRLFormat(triples, promptOf) {
-  return triples.map((t) => ({
-    prompt: promptOf(t.meta.chosenPromptHash),
-    chosen: t.meta.chosenPromptHash,
-    // caller substitutes the model output via the runId map
-    rejected: t.meta.rejectedPromptHash
-  }));
-}
-function toAnthropicFormat(triples) {
-  return triples.map((t) => ({
-    scenarioId: t.scenarioId,
-    chosenRunId: t.chosenRunId,
-    rejectedRunId: t.rejectedRunId,
-    margin: t.marginScore
-  }));
-}
-function makePair(a, b, scenarioId, minMargin) {
-  const margin = Math.abs(a.score - b.score);
-  if (margin < minMargin) return { kind: "reject" };
-  const [chosen, rejected] = a.score > b.score ? [a, b] : [b, a];
-  return {
-    kind: "admit",
-    pair: {
-      scenarioId,
-      chosenRunId: chosen.run.runId,
-      rejectedRunId: rejected.run.runId,
-      chosenVariantId: chosen.run.candidateId,
-      rejectedVariantId: rejected.run.candidateId,
-      marginScore: chosen.score - rejected.score,
-      scores: { chosen: chosen.score, rejected: rejected.score },
-      seed: chosen.run.seed === rejected.run.seed ? chosen.run.seed : void 0,
-      meta: {
-        chosenPromptHash: chosen.run.promptHash,
-        rejectedPromptHash: rejected.run.promptHash,
-        chosenConfigHash: chosen.run.configHash,
-        rejectedConfigHash: rejected.run.configHash,
-        chosenModel: chosen.run.model,
-        rejectedModel: rejected.run.model
-      }
-    }
-  };
-}
-function scenarioOf(run) {
-  if (typeof run.scenarioId === "string" && run.scenarioId.length > 0) return run.scenarioId;
-  const fromRaw = run.outcome.raw.scenario_id;
-  if (typeof fromRaw === "number" && Number.isFinite(fromRaw)) return String(fromRaw);
-  if (typeof fromRaw === "string") return fromRaw;
-  return run.experimentId;
-}
-
-// src/rl/off-policy.ts
-function inverseProbabilityWeighting(trajectories, opts = {}) {
-  const cap = opts.weightCap ?? Infinity;
-  const clip = opts.rewardClip ?? { low: 0, high: 1 };
-  if (trajectories.length === 0) {
-    return zeroEstimate();
-  }
-  const weights = [];
-  const weightedRewards = [];
-  let maxW = 0;
-  for (const t of trajectories) {
-    if (t.behaviorProb <= 0) {
-      throw new Error(`inverseProbabilityWeighting: behaviorProb must be > 0 (runId=${t.runId})`);
-    }
-    const w = Math.min(cap, t.targetProb / t.behaviorProb);
-    const r = clamp(t.reward, clip.low, clip.high);
-    weights.push(w);
-    weightedRewards.push(w * r);
-    if (w > maxW) maxW = w;
-  }
-  const n = weights.length;
-  const value = weightedRewards.reduce((s, x) => s + x, 0) / n;
-  const variance = weightedRewards.reduce((s, x) => s + (x - value) ** 2, 0) / Math.max(1, n - 1);
-  const sumW = weights.reduce((s, w) => s + w, 0);
-  const sumW2 = weights.reduce((s, w) => s + w * w, 0);
-  const effN = sumW === 0 ? 0 : sumW * sumW / sumW2;
-  return {
-    value,
-    standardError: Math.sqrt(variance / n),
-    effectiveSampleSize: effN,
-    n,
-    maxImportanceWeight: maxW
-  };
-}
-function selfNormalizedImportanceWeighting(trajectories, opts = {}) {
-  const cap = opts.weightCap ?? Infinity;
-  const clip = opts.rewardClip ?? { low: 0, high: 1 };
-  if (trajectories.length === 0) return zeroEstimate();
-  const weights = [];
-  const rewards = [];
-  let maxW = 0;
-  for (const t of trajectories) {
-    if (t.behaviorProb <= 0) {
-      throw new Error(`selfNormalizedImportanceWeighting: behaviorProb must be > 0 (runId=${t.runId})`);
-    }
-    const w = Math.min(cap, t.targetProb / t.behaviorProb);
-    weights.push(w);
-    rewards.push(clamp(t.reward, clip.low, clip.high));
-    if (w > maxW) maxW = w;
-  }
-  const sumW = weights.reduce((s, w) => s + w, 0);
-  const sumWR = weights.reduce((s, w, i) => s + w * rewards[i], 0);
-  const value = sumW === 0 ? 0 : sumWR / sumW;
-  const sumW2 = weights.reduce((s, w) => s + w * w, 0);
-  const effN = sumW === 0 ? 0 : sumW * sumW / sumW2;
-  const phi = weights.map((w, i) => w * (rewards[i] - value));
-  const variance = phi.reduce((s, x) => s + x * x, 0) / Math.max(1, sumW * sumW);
-  return {
-    value,
-    standardError: Math.sqrt(variance),
-    effectiveSampleSize: effN,
-    n: trajectories.length,
-    maxImportanceWeight: maxW
-  };
-}
-function doublyRobust(trajectories, opts = {}) {
-  const cap = opts.weightCap ?? Infinity;
-  const clip = opts.rewardClip ?? { low: 0, high: 1 };
-  if (trajectories.length === 0) return zeroEstimate();
-  const contributions = [];
-  let maxW = 0;
-  let sumW = 0;
-  let sumW2 = 0;
-  for (const t of trajectories) {
-    if (t.behaviorProb <= 0) {
-      throw new Error(`doublyRobust: behaviorProb must be > 0 (runId=${t.runId})`);
-    }
-    const w = Math.min(cap, t.targetProb / t.behaviorProb);
-    const r = clamp(t.reward, clip.low, clip.high);
-    const q = typeof t.qHat === "number" && Number.isFinite(t.qHat) ? clamp(t.qHat, clip.low, clip.high) : null;
-    if (q === null) {
-      contributions.push(w * r);
-    } else {
-      contributions.push(q + w * (r - q));
-    }
-    if (w > maxW) maxW = w;
-    sumW += w;
-    sumW2 += w * w;
-  }
-  const n = contributions.length;
-  const value = contributions.reduce((s, x) => s + x, 0) / n;
-  const variance = contributions.reduce((s, x) => s + (x - value) ** 2, 0) / Math.max(1, n - 1);
-  const effN = sumW === 0 ? 0 : sumW * sumW / sumW2;
-  return {
-    value,
-    standardError: Math.sqrt(variance / n),
-    effectiveSampleSize: effN,
-    n,
-    maxImportanceWeight: maxW
-  };
-}
-function offPolicyEstimateAll(trajectories, opts = {}) {
-  return {
-    ips: inverseProbabilityWeighting(trajectories, opts),
-    snips: selfNormalizedImportanceWeighting(trajectories, opts),
-    dr: doublyRobust(trajectories, opts)
-  };
-}
-function zeroEstimate() {
-  return { value: 0, standardError: 0, effectiveSampleSize: 0, n: 0, maxImportanceWeight: 0 };
-}
-function clamp(x, lo, hi) {
-  if (!Number.isFinite(x)) return lo;
-  return Math.max(lo, Math.min(hi, x));
-}
-
-// src/rl/process-reward.ts
-async function extractStepRewards(store, runId, opts) {
-  const spans = await store.spans({ runId });
-  const ordered = [...spans].sort((a, b) => a.startedAt - b.startedAt);
-  const out = [];
-  let idx = 0;
-  for (const span of ordered) {
-    if (opts.preFilter && !opts.preFilter(span)) continue;
-    let scored = null;
-    for (const s of opts.scorers) {
-      if (!s.appliesTo.includes(span.kind)) continue;
-      const r = await s.score(span);
-      if (r) {
-        scored = r;
-        break;
-      }
-    }
-    if (!scored) continue;
-    out.push({
-      spanId: span.spanId,
-      runId,
-      stepIndex: idx++,
-      kind: span.kind,
-      name: span.name,
-      reward: scored.reward,
-      determinism: scored.determinism,
-      rationale: scored.rationale,
-      weight: scored.weight
-    });
-  }
-  return out;
-}
-function runwiseStepRewardSummary(stepRewards) {
-  if (stepRewards.length === 0) {
-    return {
-      runId: "",
-      totalSteps: 0,
-      meanReward: 0,
-      sumWeightedReward: 0,
-      failureFraction: 0,
-      worstStepDelta: 0,
-      worstStepIndex: null
-    };
-  }
-  const runId = stepRewards[0].runId;
-  let sumW = 0;
-  let sumWR = 0;
-  let failures = 0;
-  let worstDelta = 0;
-  let worstIdx = null;
-  let prev = stepRewards[0].reward;
-  for (let i = 0; i < stepRewards.length; i++) {
-    const s = stepRewards[i];
-    const w = s.weight ?? 1;
-    sumW += w;
-    sumWR += w * s.reward;
-    if (s.reward < 0.5) failures++;
-    if (i > 0) {
-      const delta = s.reward - prev;
-      if (delta < worstDelta) {
-        worstDelta = delta;
-        worstIdx = i;
-      }
-      prev = s.reward;
-    } else {
-      prev = s.reward;
-    }
-  }
-  return {
-    runId,
-    totalSteps: stepRewards.length,
-    meanReward: sumW === 0 ? 0 : sumWR / sumW,
-    sumWeightedReward: sumWR,
-    failureFraction: failures / stepRewards.length,
-    worstStepDelta: worstDelta,
-    worstStepIndex: worstIdx
-  };
-}
-function prmTrainingPairs(stepRewardsByRun, opts = {}) {
-  const minMargin = opts.minMargin ?? 0.2;
-  const minPrefix = opts.minPrefixLength ?? 1;
-  const runs = [...stepRewardsByRun.entries()].map(([runId, steps]) => ({ runId, steps }));
-  const triples = [];
-  for (let i = 0; i < runs.length; i++) {
-    for (let j = i + 1; j < runs.length; j++) {
-      const a = runs[i];
-      const b = runs[j];
-      const minLen = Math.min(a.steps.length, b.steps.length);
-      if (minLen < minPrefix + 1) continue;
-      let divergenceIdx = -1;
-      for (let k = 0; k < minLen; k++) {
-        const sa = a.steps[k];
-        const sb = b.steps[k];
-        const structuralDivergence = sa.kind !== sb.kind || sa.name !== sb.name;
-        const rewardGap = Math.abs(sa.reward - sb.reward);
-        if (structuralDivergence || rewardGap >= minMargin) {
-          divergenceIdx = k;
-          break;
-        }
-      }
-      if (divergenceIdx < 0) continue;
-      if (divergenceIdx < minPrefix) continue;
-      const aNext = a.steps[divergenceIdx];
-      const bNext = b.steps[divergenceIdx];
-      const margin = Math.abs(aNext.reward - bNext.reward);
-      if (margin < minMargin) continue;
-      const chosen = aNext.reward > bNext.reward ? aNext : bNext;
-      const rejected = aNext.reward > bNext.reward ? bNext : aNext;
-      const chosenRun = aNext.reward > bNext.reward ? a.runId : b.runId;
-      const rejectedRun = aNext.reward > bNext.reward ? b.runId : a.runId;
-      triples.push({
-        prefixRunId: chosenRun,
-        prefixStepIndex: divergenceIdx - 1,
-        chosenSpanId: chosen.spanId,
-        chosenReward: chosen.reward,
-        rejectedSpanId: rejected.spanId,
-        rejectedReward: rejected.reward,
-        rejectedRunId: rejectedRun,
-        marginScore: chosen.reward - rejected.reward
-      });
-    }
-  }
-  return triples;
-}
-
-// src/rl/contamination.ts
-async function runContaminationProbe(input, opts = {}) {
-  const fdr = opts.fdr ?? 0.05;
-  const minMedianDrop = opts.minMedianDrop ?? 0.05;
-  const floor = opts.scoreFloor ?? 0;
-  if (!input.perturbed && !input.perturbation) {
-    throw new Error("runContaminationProbe: must supply either `perturbed` or `perturbation`.");
-  }
-  const perturbed = input.perturbed ?? await Promise.all(
-    input.originals.map((s) => input.perturbation.apply(s))
-  );
-  if (perturbed.length !== input.originals.length) {
-    throw new Error(`runContaminationProbe: perturbed length ${perturbed.length} \u2260 originals ${input.originals.length}`);
-  }
-  const origScores = await Promise.all(input.originals.map((s) => input.scoreFn(s)));
-  const pertScores = await Promise.all(perturbed.map((s) => input.scoreFn(s)));
-  const perScenario = input.originals.map((s, i) => ({
-    scenarioId: input.scenarioId(s),
-    originalScore: origScores[i],
-    perturbedScore: pertScores[i],
-    delta: pertScores[i] - origScores[i],
-    qValue: NaN
-  }));
-  const valid = perScenario.filter((p) => p.originalScore >= floor && p.perturbedScore >= floor);
-  if (valid.length < 4) {
-    return {
-      perScenario,
-      pairedTest: { w: 0, p: 1 },
-      medianDelta: 0,
-      meanDelta: 0,
-      contaminationSuspected: false,
-      reason: `insufficient valid scenarios (n=${valid.length}, need \u2265 4)`,
-      n: valid.length
-    };
-  }
-  const origValid = valid.map((p) => p.originalScore);
-  const pertValid = valid.map((p) => p.perturbedScore);
-  const pairedTest = wilcoxonSignedRank(origValid, pertValid);
-  const deltas = valid.map((p) => p.delta);
-  const sortedDeltas = [...deltas].sort((a, b) => a - b);
-  const median = sortedDeltas[Math.floor(sortedDeltas.length / 2)];
-  const mean2 = deltas.reduce((s, d) => s + d, 0) / deltas.length;
-  const pseudoP = valid.map((p) => Math.min(1, Math.max(1e-6, 1 - Math.abs(p.delta) / 1)));
-  const { qValues } = benjaminiHochberg(pseudoP, fdr);
-  for (let i = 0; i < valid.length; i++) {
-    const v = valid[i];
-    const idx = perScenario.findIndex((p) => p.scenarioId === v.scenarioId);
-    if (idx >= 0) perScenario[idx].qValue = qValues[i];
-  }
-  const contaminationSuspected = pairedTest.p < fdr && median <= -minMedianDrop;
-  const reason = contaminationSuspected ? `paired p=${pairedTest.p.toFixed(4)} < ${fdr} and median drop ${median.toFixed(4)} \u2265 ${minMedianDrop}` : pairedTest.p >= fdr ? `no significant difference (paired p=${pairedTest.p.toFixed(4)})` : `significant but small effect (median delta ${median.toFixed(4)})`;
-  return {
-    perScenario,
-    pairedTest,
-    medianDelta: median,
-    meanDelta: mean2,
-    contaminationSuspected,
-    reason,
-    n: valid.length
-  };
-}
-function renameVariables(identifiers, rename = (n, i) => `${n}_${(i % 26 + 10).toString(36)}`) {
-  return {
-    kind: "rename_variables",
-    apply(scenario) {
-      let prompt = scenario.prompt;
-      identifiers.forEach((id, i) => {
-        const replacement = rename(id, i);
-        const re = new RegExp(`\\b${escapeRegex(id)}\\b`, "g");
-        prompt = prompt.replace(re, replacement);
-      });
-      return { ...scenario, prompt };
-    }
-  };
-}
-function shuffleOrder(shuffleSection, seed) {
-  let s = seed >>> 0;
-  const rng = () => {
-    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;
-  };
-  return {
-    kind: "shuffle_order",
-    apply(scenario) {
-      const newPrompt = shuffleSection(scenario.prompt, rng);
-      return { ...scenario, prompt: newPrompt };
-    }
-  };
-}
-function injectIrrelevantClause(clause, position = "prefix") {
-  return {
-    kind: "inject_irrelevant_clause",
-    apply(scenario) {
-      const prompt = position === "prefix" ? `${clause} ${scenario.prompt}` : `${scenario.prompt} ${clause}`;
-      return { ...scenario, prompt };
-    }
-  };
-}
-function escapeRegex(s) {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-// src/rl/tournament.ts
-function fitBradleyTerry(outcomes, opts = {}) {
-  const tol = opts.tolerance ?? 1e-6;
-  const maxIter = opts.maxIterations ?? 256;
-  const smoothing = opts.smoothing ?? 0.1;
-  const candidates = /* @__PURE__ */ new Set();
-  for (const o of outcomes) {
-    candidates.add(o.winner);
-    candidates.add(o.loser);
-  }
-  const ids = [...candidates].sort();
-  const idx = new Map(ids.map((id, i) => [id, i]));
-  const n = ids.length;
-  if (n === 0) return { ratings: [], iterations: 0, finalDelta: 0, converged: true };
-  if (n === 1) {
-    return {
-      ratings: [{ candidateId: ids[0], strength: 1, logStrength: 0, n: 0, wins: 0 }],
-      iterations: 0,
-      finalDelta: 0,
-      converged: true
-    };
-  }
-  const W = Array.from({ length: n }, () => new Array(n).fill(0));
-  const N = Array.from({ length: n }, () => new Array(n).fill(0));
-  for (const o of outcomes) {
-    const i = idx.get(o.winner);
-    const j = idx.get(o.loser);
-    const w = o.weight ?? 1;
-    if (o.draw) {
-      W[i][j] += 0.5 * w;
-      W[j][i] += 0.5 * w;
-    } else {
-      W[i][j] += w;
-    }
-    N[i][j] += w;
-    N[j][i] += w;
-  }
-  const winsTotal = new Array(n).fill(0);
-  for (let i = 0; i < n; i++) {
-    for (let j = 0; j < n; j++) winsTotal[i] += W[i][j];
-    winsTotal[i] += smoothing;
-  }
-  const compsTotal = new Array(n).fill(0);
-  for (let i = 0; i < n; i++) {
-    for (let j = 0; j < n; j++) compsTotal[i] += N[i][j];
-  }
-  let theta = new Array(n).fill(1);
-  let iter = 0;
-  let delta = Infinity;
-  for (; iter < maxIter; iter++) {
-    const newTheta = new Array(n);
-    for (let i = 0; i < n; i++) {
-      let denom = 0;
-      for (let j = 0; j < n; j++) {
-        if (j === i) continue;
-        if (N[i][j] === 0) continue;
-        denom += N[i][j] / (theta[i] + theta[j]);
-      }
-      newTheta[i] = denom === 0 ? theta[i] : winsTotal[i] / denom;
-    }
-    let logSum = 0;
-    for (let i = 0; i < n; i++) logSum += Math.log(Math.max(1e-300, newTheta[i]));
-    const norm = Math.exp(logSum / n);
-    for (let i = 0; i < n; i++) newTheta[i] = newTheta[i] / norm;
-    delta = 0;
-    for (let i = 0; i < n; i++) {
-      const d = Math.abs(newTheta[i] - theta[i]) / Math.max(1e-12, theta[i]);
-      if (d > delta) delta = d;
-    }
-    theta = newTheta;
-    if (delta < tol) break;
-  }
-  const minLog = Math.min(...theta.map((t) => Math.log(Math.max(1e-300, t))));
-  const ratings = ids.map((id, i) => ({
-    candidateId: id,
-    strength: theta[i],
-    logStrength: Math.log(Math.max(1e-300, theta[i])) - minLog,
-    n: compsTotal[i],
-    wins: winsTotal[i] - smoothing
-  }));
-  return {
-    ratings: ratings.sort((a, b) => b.strength - a.strength),
-    iterations: iter,
-    finalDelta: delta,
-    converged: delta < tol
-  };
-}
-function applyEloUpdate(ratings, outcome, opts = {}) {
-  const defaultRating = opts.defaultRating ?? 1500;
-  const k = opts.kFactor ?? 32;
-  const rW = ratings.get(outcome.winner) ?? defaultRating;
-  const rL = ratings.get(outcome.loser) ?? defaultRating;
-  const expectedW = 1 / (1 + Math.pow(10, (rL - rW) / 400));
-  const scoreW = outcome.draw ? 0.5 : 1;
-  const scoreL = outcome.draw ? 0.5 : 0;
-  const w = outcome.weight ?? 1;
-  const winnerDelta = k * w * (scoreW - expectedW);
-  const loserDelta = k * w * (scoreL - (1 - expectedW));
-  ratings.set(outcome.winner, rW + winnerDelta);
-  ratings.set(outcome.loser, rL + loserDelta);
-  return { winnerDelta, loserDelta };
-}
-function buildPairwiseFromCampaign(input) {
-  const drawMargin = input.drawMargin ?? 0;
-  const byKey = /* @__PURE__ */ new Map();
-  for (const r of input.runs) {
-    const arr = byKey.get(r.matchKey) ?? [];
-    arr.push({ candidateId: r.candidateId, score: r.score });
-    byKey.set(r.matchKey, arr);
-  }
-  const outcomes = [];
-  for (const arr of byKey.values()) {
-    for (let i = 0; i < arr.length; i++) {
-      for (let j = i + 1; j < arr.length; j++) {
-        const a = arr[i];
-        const b = arr[j];
-        if (a.candidateId === b.candidateId) continue;
-        const margin = Math.abs(a.score - b.score);
-        if (margin <= drawMargin) {
-          outcomes.push({ winner: a.candidateId, loser: b.candidateId, draw: true, weight: 1 });
-        } else {
-          const [winner, loser] = a.score > b.score ? [a, b] : [b, a];
-          outcomes.push({ winner: winner.candidateId, loser: loser.candidateId, weight: margin });
-        }
-      }
-    }
-  }
-  return outcomes;
-}
-
-// src/rl/adversarial.ts
-async function adversarialScenarioSearch(opts) {
-  const failureThreshold = opts.failureThreshold ?? 0.5;
-  const rounds = opts.rounds ?? 3;
-  const children = opts.childrenPerParent ?? 4;
-  const budget = opts.budget ?? Number.POSITIVE_INFINITY;
-  const seed = opts.seed ?? 1;
-  const rng = mulberry32(seed);
-  const scenarios = [];
-  const seen = /* @__PURE__ */ new Set();
-  let scoreCalls = 0;
-  for (const s of opts.seeds) {
-    const id = opts.mutateScenarioId(s);
-    if (seen.has(id)) continue;
-    seen.add(id);
-    if (scoreCalls >= budget) break;
-    const score = await opts.scoreFn(s);
-    scoreCalls++;
-    scenarios.push({
-      id,
-      generation: 0,
-      parentId: null,
-      scenario: s,
-      score,
-      mutationStrategy: null
-    });
-  }
-  for (let g = 1; g <= rounds; g++) {
-    if (scoreCalls >= budget) break;
-    const parents = scenarios.filter((s) => s.generation === g - 1);
-    for (const parent of parents) {
-      for (const mutation of opts.mutations) {
-        if (scoreCalls >= budget) break;
-        const produced = await mutation.mutate(parent.scenario, rng);
-        const childArr = Array.isArray(produced) ? produced : [produced];
-        for (let k = 0; k < Math.min(children, childArr.length); k++) {
-          if (scoreCalls >= budget) break;
-          const child = childArr[k];
-          const cid = opts.mutateScenarioId(child);
-          if (seen.has(cid)) continue;
-          seen.add(cid);
-          const cscore = await opts.scoreFn(child);
-          scoreCalls++;
-          scenarios.push({
-            id: cid,
-            generation: g,
-            parentId: parent.id,
-            scenario: child,
-            score: cscore,
-            mutationStrategy: mutation.id
-          });
-        }
-      }
-    }
-  }
-  const failures = scenarios.filter((s) => s.score !== null && s.score < failureThreshold).sort((a, b) => (a.score ?? 0) - (b.score ?? 0));
-  const byGeneration = [];
-  const maxGen = scenarios.reduce((m, s) => Math.max(m, s.generation), 0);
-  for (let g = 0; g <= maxGen; g++) {
-    const gens = scenarios.filter((s) => s.generation === g);
-    if (gens.length === 0) continue;
-    const fails = gens.filter((s) => s.score !== null && s.score < failureThreshold).length;
-    const meanScore = gens.reduce((sum, s) => sum + (s.score ?? 0), 0) / gens.length;
-    byGeneration.push({ generation: g, total: gens.length, failures: fails, meanScore });
-  }
-  return { scenarios, failures, byGeneration, scoreCalls };
-}
-function mulberry32(seed) {
-  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;
-  };
-}
-
-// src/rl/compute-curves.ts
-async function runComputeCurve(opts) {
-  const points = [];
-  for (const budget of opts.budgets) {
-    const r = await opts.runAtBudget(budget);
-    points.push({
-      budgetId: budget.id,
-      cost: budget.cost,
-      score: r.score,
-      samples: r.samples,
-      std: r.std,
-      metrics: r.metrics
-    });
-  }
-  const sorted = [...points].sort((a, b) => a.cost - b.cost);
-  const logSlope = sorted.length >= 2 ? fitLogSlope(sorted) : null;
-  const best = points.reduce((a, b) => b.score > a.score ? b : a);
-  return { candidateId: opts.candidateId, points: sorted, logSlope, best };
-}
-async function bestOfN(opts) {
-  if (opts.n <= 0) throw new Error("bestOfN: n must be > 0");
-  const rollouts = [];
-  const scores = [];
-  for (let i = 0; i < opts.n; i++) {
-    const r = await opts.sample(i);
-    rollouts.push(r);
-    scores.push(await opts.scoreFn(r));
-  }
-  let bestIndex = 0;
-  for (let i = 1; i < scores.length; i++) if (scores[i] > scores[bestIndex]) bestIndex = i;
-  const meanScore = scores.reduce((s, x) => s + x, 0) / scores.length;
-  return {
-    best: rollouts[bestIndex],
-    bestScore: scores[bestIndex],
-    scores,
-    meanScore,
-    bestIndex
-  };
-}
-async function selfConsistency(opts) {
-  if (opts.n <= 0) throw new Error("selfConsistency: n must be > 0");
-  const rollouts = [];
-  const histogram = {};
-  for (let i = 0; i < opts.n; i++) {
-    const r = await opts.sample(i);
-    rollouts.push(r);
-    const key = opts.answerKey(r);
-    histogram[key] = (histogram[key] ?? 0) + 1;
-  }
-  let answer = "";
-  let max = -1;
-  for (const [k, v] of Object.entries(histogram)) {
-    if (v > max) {
-      max = v;
-      answer = k;
-    }
-  }
-  const representative = rollouts.find((r) => opts.answerKey(r) === answer) ?? rollouts[0];
-  return {
-    answer,
-    agreement: max / opts.n,
-    histogram,
-    representative,
-    rollouts
-  };
-}
-function paretoFrontier(points) {
-  const onFrontier = [];
-  for (const p of points) {
-    const dominated = points.some(
-      (q) => q !== p && q.cost <= p.cost && q.score >= p.score && (q.cost < p.cost || q.score > p.score)
-    );
-    if (!dominated) onFrontier.push(p);
-  }
-  return onFrontier.sort((a, b) => a.cost - b.cost);
-}
-function fitLogSlope(points) {
-  const xs = points.map((p) => Math.log(Math.max(1e-12, p.cost)));
-  const ys = points.map((p) => p.score);
-  const n = xs.length;
-  const mx = xs.reduce((s, x) => s + x, 0) / n;
-  const my = ys.reduce((s, y) => s + y, 0) / n;
-  let num = 0;
-  let den = 0;
-  for (let i = 0; i < n; i++) {
-    num += (xs[i] - mx) * (ys[i] - my);
-    den += (xs[i] - mx) ** 2;
-  }
-  return den === 0 ? 0 : num / den;
-}
-
-// src/rl/active-curriculum.ts
-function varianceBasedCurriculum(observations, candidateCells, opts) {
-  const variancePrior = opts.variancePrior ?? 0.05;
-  const floor = opts.floorPerCell ?? 1;
-  const budget = opts.budget;
-  const grouped = /* @__PURE__ */ new Map();
-  for (const o of observations) {
-    const k = `${o.variantId}::${o.scenarioId}`;
-    const arr = grouped.get(k) ?? [];
-    arr.push(o.score);
-    grouped.set(k, arr);
-  }
-  const cellStats = candidateCells.map((c) => {
-    const k = `${c.variantId}::${c.scenarioId}`;
-    const samples = grouped.get(k) ?? [];
-    const n = samples.length;
-    const mean2 = n === 0 ? 0.5 : samples.reduce((s, v) => s + v, 0) / n;
-    const variance = n < 2 ? variancePrior : samples.reduce((s, v) => s + (v - mean2) ** 2, 0) / (n - 1) + variancePrior;
-    const weight = Math.sqrt(variance) + 1 / Math.sqrt(Math.max(1, n));
-    return { variantId: c.variantId, scenarioId: c.scenarioId, n, mean: mean2, variance, weight };
-  });
-  const floorTotal = floor * cellStats.length;
-  if (floorTotal >= budget) {
-    const each = Math.max(1, Math.floor(budget / Math.max(1, cellStats.length)));
-    return cellStats.map((c) => ({
-      variantId: c.variantId,
-      scenarioId: c.scenarioId,
-      count: each,
-      reason: `floor allocation (budget tight; n=${c.n})`
-    }));
-  }
-  const remaining = budget - floorTotal;
-  const totalWeight = cellStats.reduce((s, c) => s + c.weight, 0);
-  return cellStats.map((c) => {
-    const proportional = totalWeight === 0 ? 0 : Math.round(c.weight / totalWeight * remaining);
-    return {
-      variantId: c.variantId,
-      scenarioId: c.scenarioId,
-      count: floor + proportional,
-      reason: `variance ${c.variance.toFixed(3)} (n=${c.n}, mean=${c.mean.toFixed(3)})`
-    };
-  });
-}
-function thompsonCurriculum(observations, candidateCells, opts) {
-  const threshold = opts.decisionThreshold ?? 0.5;
-  const alpha0 = opts.priorAlpha ?? 1;
-  const beta0 = opts.priorBeta ?? 1;
-  const rng = makeRng(opts.seed);
-  const grouped = /* @__PURE__ */ new Map();
-  for (const o of observations) {
-    const k = `${o.variantId}::${o.scenarioId}`;
-    const cur = grouped.get(k) ?? { passes: 0, failures: 0 };
-    const pass = o.pass ?? o.score >= threshold;
-    if (pass) cur.passes += 1;
-    else cur.failures += 1;
-    grouped.set(k, cur);
-  }
-  const stats = candidateCells.map((c) => {
-    const k = `${c.variantId}::${c.scenarioId}`;
-    const cur = grouped.get(k) ?? { passes: 0, failures: 0 };
-    const a = alpha0 + cur.passes;
-    const b = beta0 + cur.failures;
-    const sampled = sampleBeta(a, b, rng);
-    const distance = Math.abs(sampled - threshold);
-    const variance = a * b / ((a + b) ** 2 * (a + b + 1));
-    const sigma = Math.max(0.05, Math.sqrt(variance));
-    const weight = Math.exp(-((distance / sigma) ** 2));
-    return {
-      variantId: c.variantId,
-      scenarioId: c.scenarioId,
-      n: cur.passes + cur.failures,
-      sampled,
-      sigma,
-      weight,
-      a,
-      b
-    };
-  });
-  const totalWeight = stats.reduce((s, c) => s + c.weight, 0);
-  return stats.map((c) => {
-    const proportional = totalWeight === 0 ? 0 : Math.round(c.weight / totalWeight * opts.budget);
-    return {
-      variantId: c.variantId,
-      scenarioId: c.scenarioId,
-      count: Math.max(0, proportional),
-      reason: `Beta(${c.a.toFixed(1)},${c.b.toFixed(1)}) sample=${c.sampled.toFixed(3)} (target ${threshold})`
-    };
-  });
-}
-function observationsFromRunRecords(runs, opts = {}) {
-  const threshold = opts.passThreshold ?? 0.5;
-  const useHoldout = opts.useHoldout ?? true;
-  const out = [];
-  for (const r of runs) {
-    if (!r.scenarioId) continue;
-    const score = useHoldout ? r.outcome.holdoutScore ?? r.outcome.searchScore : r.outcome.searchScore ?? r.outcome.holdoutScore;
-    if (typeof score !== "number" || !Number.isFinite(score)) continue;
-    out.push({
-      variantId: r.candidateId,
-      scenarioId: r.scenarioId,
-      score,
-      pass: score >= threshold
-    });
-  }
-  return out;
-}
-function makeRng(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 sampleBeta(alpha, beta, rng) {
-  const a = Math.max(1, alpha);
-  const b = Math.max(1, beta);
-  const x = sampleGamma(a, rng);
-  const y = sampleGamma(b, rng);
-  return x / (x + y);
-}
-function sampleGamma(shape, rng) {
-  const d = shape - 1 / 3;
-  const c = 1 / Math.sqrt(9 * d);
-  while (true) {
-    let x;
-    let v;
-    do {
-      const u1 = rng() || 1e-12;
-      const u2 = rng() || 1e-12;
-      x = Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
-      v = 1 + c * x;
-    } while (v <= 0);
-    v = v * v * v;
-    const u = rng();
-    if (u < 1 - 0.0331 * x ** 4) return d * v;
-    if (Math.log(u) < 0.5 * x * x + d * (1 - v + Math.log(v))) return d * v;
-  }
-}
-
-// src/rl/reward-hacking.ts
-var DEFAULT_PROXY = (r) => {
-  const v = r.outcome.holdoutScore ?? r.outcome.searchScore;
-  return typeof v === "number" && Number.isFinite(v) ? v : null;
-};
-function detectRewardHacking(input) {
-  const proxyOf = input.proxyOf ?? DEFAULT_PROXY;
-  const truthOf = input.truthOf;
-  const sus = input.thresholds?.suspect ?? 0.3;
-  const gam = input.thresholds?.gaming ?? 0.6;
-  const runs = input.runs.filter((r) => proxyOf(r) !== null);
-  const n = runs.length;
-  if (n < 4) {
-    return {
-      findings: [],
-      verdict: "clean",
-      n,
-      rationale: [`fewer than 4 runs with proxy reward (n=${n}); insufficient evidence`]
-    };
-  }
-  const windowSize = Math.max(1, input.windowSize ?? Math.min(50, Math.floor(n / 2)));
-  const before = runs.slice(0, n - windowSize);
-  const after = runs.slice(n - windowSize);
-  const findings = [];
-  if (truthOf) {
-    const beforeProxy = before.map(proxyOf).filter((v) => typeof v === "number");
-    const afterProxy = after.map(proxyOf).filter((v) => typeof v === "number");
-    const beforeTruth = before.map(truthOf).filter((v) => typeof v === "number");
-    const afterTruth = after.map(truthOf).filter((v) => typeof v === "number");
-    if (beforeProxy.length >= 2 && afterProxy.length >= 2 && beforeTruth.length >= 2 && afterTruth.length >= 2) {
-      const proxyDelta = mean(afterProxy) - mean(beforeProxy);
-      const truthDelta = mean(afterTruth) - mean(beforeTruth);
-      const gap = Math.max(0, proxyDelta - truthDelta);
-      const severity = clamp012(gap * 5);
-      findings.push({
-        signal: "reward_divergence",
-        severity,
-        message: severity >= sus ? `proxy reward rose by ${proxyDelta.toFixed(3)} while truth changed by ${truthDelta.toFixed(3)} \u2014 potential Goodhart` : `proxy and truth moved together (proxy ${proxyDelta.toFixed(3)}, truth ${truthDelta.toFixed(3)})`,
-        detail: { proxyDelta, truthDelta, gap, beforeN: beforeProxy.length, afterN: afterProxy.length }
-      });
-    }
-  }
-  {
-    const beforeP = before.map(proxyOf).filter((v) => typeof v === "number");
-    const afterP = after.map(proxyOf).filter((v) => typeof v === "number");
-    if (beforeP.length >= 4 && afterP.length >= 4) {
-      const ks = ksStatistic(beforeP, afterP);
-      const severity = clamp012(ks - 0.2);
-      findings.push({
-        signal: "distribution_shift",
-        severity,
-        message: severity >= sus ? `KS=${ks.toFixed(3)} between before/after windows \u2014 distributional shift large` : `KS=${ks.toFixed(3)} between before/after windows \u2014 within-distribution drift`,
-        detail: { ks, beforeN: beforeP.length, afterN: afterP.length }
-      });
-    }
-  }
-  {
-    const secondaryOf = input.secondaryRewardOf ?? defaultSecondary(input.verifiableRewardOptions);
-    const aligned = runs.map((r) => ({ p: proxyOf(r), s: secondaryOf(r) })).filter((x) => typeof x.p === "number" && typeof x.s === "number");
-    if (aligned.length >= 4) {
-      const ps = aligned.map((x) => x.p);
-      const ss = aligned.map((x) => x.s);
-      const r = pearsonR(ps, ss);
-      const severity = clamp012(0.5 - Math.max(0, r));
-      findings.push({
-        signal: "reward_disagreement",
-        severity,
-        message: severity >= sus ? `proxy and independent secondary reward correlate \u03C1=${r.toFixed(3)} \u2014 possibly hacking proxy` : `proxy and secondary reward correlate \u03C1=${r.toFixed(3)}`,
-        detail: { pearson: r, n: aligned.length }
-      });
-    }
-  }
-  {
-    const detRuns = filterDeterministicallyRewarded(runs, input.verifiableRewardOptions ?? {});
-    if (detRuns.length >= 4) {
-      const detBefore = detRuns.slice(0, Math.floor(detRuns.length / 2));
-      const detAfter = detRuns.slice(Math.floor(detRuns.length / 2));
-      const detDelta = mean(detAfter.map((r) => r.reward.value)) - mean(detBefore.map((r) => r.reward.value));
-      const proxyDelta = mean(after.map(proxyOf).filter((v) => typeof v === "number")) - mean(before.map(proxyOf).filter((v) => typeof v === "number"));
-      const driftGap = Math.max(0, proxyDelta - detDelta);
-      const severity = clamp012(driftGap * 5);
-      findings.push({
-        signal: "judge_drift",
-        severity,
-        message: severity >= sus ? `judge proxy +${proxyDelta.toFixed(3)} while deterministic reward +${detDelta.toFixed(3)} \u2014 judge drifting up without verifiable backing` : `judge and deterministic rewards move in step (judge ${proxyDelta.toFixed(3)}, det ${detDelta.toFixed(3)})`,
-        detail: { proxyDelta, detDelta, driftGap, n: detRuns.length }
-      });
-    }
-  }
-  const maxSev = findings.reduce((m, f) => Math.max(m, f.severity), 0);
-  const verdict = maxSev >= gam ? "gaming" : maxSev >= sus ? "suspect" : "clean";
-  const rationale = findings.filter((f) => f.severity >= sus).map((f) => `${f.signal}: severity ${f.severity.toFixed(2)} \u2014 ${f.message}`);
-  if (rationale.length === 0) rationale.push("no signals fired above suspect threshold");
-  return { findings, verdict, rationale, n };
-}
-function mean(xs) {
-  if (xs.length === 0) return 0;
-  return xs.reduce((s, x) => s + x, 0) / xs.length;
-}
-function clamp012(x) {
-  if (!Number.isFinite(x)) return 0;
-  return Math.max(0, Math.min(1, x));
-}
-function pearsonR(a, b) {
-  if (a.length !== b.length || a.length < 2) return 0;
-  const ma = mean(a);
-  const mb = mean(b);
-  let num = 0, da = 0, db = 0;
-  for (let i = 0; i < a.length; i++) {
-    const xa = a[i] - ma;
-    const xb = b[i] - mb;
-    num += xa * xb;
-    da += xa * xa;
-    db += xb * xb;
-  }
-  if (da === 0 || db === 0) return 0;
-  return num / Math.sqrt(da * db);
-}
-function ksStatistic(a, b) {
-  const sortedA = [...a].sort((x, y) => x - y);
-  const sortedB = [...b].sort((x, y) => x - y);
-  const all = [.../* @__PURE__ */ new Set([...sortedA, ...sortedB])].sort((x, y) => x - y);
-  let max = 0;
-  for (const v of all) {
-    const fa = sortedA.filter((x) => x <= v).length / sortedA.length;
-    const fb = sortedB.filter((x) => x <= v).length / sortedB.length;
-    max = Math.max(max, Math.abs(fa - fb));
-  }
-  return max;
-}
-function defaultSecondary(verifiableOpts) {
-  return (run) => {
-    const filtered = filterDeterministicallyRewarded([run], verifiableOpts ?? {});
-    return filtered.length === 1 ? filtered[0].reward.value : null;
-  };
-}
-
-// src/rl/adaptation-eval.ts
-async function runAdaptationCurve(opts) {
-  const ks = opts.ks ?? [0, 1, 2, 4, 8, 16];
-  const reps = opts.reps ?? 3;
-  const passThreshold = opts.passThreshold ?? 0.5;
-  const sortedKs = [...ks].sort((a, b) => a - b);
-  const points = [];
-  for (const k of sortedKs) {
-    const perScenario = [];
-    const allScores = [];
-    let totalPasses = 0;
-    let totalAttempts = 0;
-    for (const scenario of opts.scenarios) {
-      const sid = scenario.scenarioId ?? `scenario-${opts.scenarios.indexOf(scenario)}`;
-      let scores = [];
-      let passes = 0;
-      for (let r = 0; r < reps; r++) {
-        const score = await opts.runner.run({ scenario, k, rep: r });
-        scores.push(score);
-        if (score >= passThreshold) passes++;
-        allScores.push(score);
-        if (score >= passThreshold) totalPasses++;
-        totalAttempts++;
-      }
-      const meanS = scores.reduce((s, v) => s + v, 0) / scores.length;
-      perScenario.push({ scenarioId: sid, meanScore: meanS, passes, total: scores.length });
-    }
-    const meanScore = allScores.reduce((s, v) => s + v, 0) / Math.max(1, allScores.length);
-    const variance = allScores.length < 2 ? 0 : allScores.reduce((s, v) => s + (v - meanScore) ** 2, 0) / (allScores.length - 1);
-    points.push({
-      k,
-      meanScore,
-      passRate: totalPasses / Math.max(1, totalAttempts),
-      std: Math.sqrt(variance),
-      n: allScores.length,
-      perScenario
-    });
-  }
-  const firstPassK2 = points.find((p) => p.passRate >= passThreshold)?.k ?? null;
-  const maxK = sortedKs[sortedKs.length - 1] ?? 1;
-  let area = 0;
-  for (let i = 1; i < points.length; i++) {
-    const x1 = points[i - 1].k;
-    const x2 = points[i].k;
-    const y1 = points[i - 1].meanScore;
-    const y2 = points[i].meanScore;
-    area += (y1 + y2) / 2 * (x2 - x1);
-  }
-  const adaptationArea = maxK === 0 ? 0 : area / maxK;
-  return { points, firstPassK: firstPassK2, adaptationArea };
-}
-function compareAdaptationCurves(a, b, opts = {}) {
-  const conf = opts.confidence ?? 0.95;
-  const resamples = opts.bootstrapResamples ?? 500;
-  const rng = makeRng2(opts.seed);
-  const perK = [];
-  for (const ap of a.points) {
-    const bp = b.points.find((p) => p.k === ap.k);
-    if (!bp) continue;
-    const aMeans = ap.perScenario.map((s) => s.meanScore);
-    const bMeans = bp.perScenario.map((s) => s.meanScore);
-    const aCi = bootstrapMeanCi(aMeans, resamples, conf, rng);
-    const bCi = bootstrapMeanCi(bMeans, resamples, conf, rng);
-    perK.push({
-      k: ap.k,
-      deltaMean: ap.meanScore - bp.meanScore,
-      aLow: aCi.low,
-      aHigh: aCi.high,
-      bLow: bCi.low,
-      bHigh: bCi.high
-    });
-  }
-  const areaDelta = a.adaptationArea - b.adaptationArea;
-  const firstPassKDelta = a.firstPassK !== null && b.firstPassK !== null ? b.firstPassK - a.firstPassK : null;
-  const meanDelta = perK.reduce((s, p) => s + p.deltaMean, 0) / Math.max(1, perK.length);
-  let verdict;
-  if (Math.abs(meanDelta) < 0.02 && Math.abs(areaDelta) < 0.02) verdict = "similar";
-  else if (meanDelta > 0 && areaDelta > 0) verdict = "a_better";
-  else if (meanDelta < 0 && areaDelta < 0) verdict = "b_better";
-  else verdict = "similar";
-  const rationale = `mean per-k delta=${meanDelta.toFixed(3)}, area delta=${areaDelta.toFixed(3)}` + (firstPassKDelta !== null ? `, first-pass-k delta=${firstPassKDelta}` : "");
-  return { perK, areaDelta, firstPassKDelta, verdict, rationale };
-}
-function firstPassK(curve, threshold = 0.5) {
-  return curve.points.find((p) => p.passRate >= threshold)?.k ?? null;
-}
-function makeRng2(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 bootstrapMeanCi(xs, resamples, confidence, rng) {
-  if (xs.length < 2) return { low: xs[0] ?? 0, high: xs[0] ?? 0 };
-  const samples = new Array(resamples);
-  for (let b = 0; b < resamples; b++) {
-    let sum = 0;
-    for (let i = 0; i < xs.length; i++) sum += xs[Math.floor(rng() * xs.length)];
-    samples[b] = sum / xs.length;
-  }
-  samples.sort((a, b) => a - b);
-  const alpha = 1 - confidence;
-  return {
-    low: samples[Math.floor(alpha / 2 * resamples)],
-    high: samples[Math.min(resamples - 1, Math.ceil((1 - alpha / 2) * resamples) - 1)]
-  };
-}
-
-// src/rl/exporters.ts
-async function toDpoRows(triples, lookups) {
-  const out = [];
-  for (const t of triples) {
-    const [prompt, chosen, rejected] = await Promise.all([
-      Promise.resolve(lookups.promptOf(t.chosenRunId)),
-      Promise.resolve(lookups.completionOf(t.chosenRunId)),
-      Promise.resolve(lookups.completionOf(t.rejectedRunId))
-    ]);
-    out.push({
-      prompt,
-      chosen,
-      rejected,
-      margin: t.marginScore,
-      meta: {
-        scenarioId: t.scenarioId,
-        chosenVariantId: t.chosenVariantId,
-        rejectedVariantId: t.rejectedVariantId,
-        chosenRunId: t.chosenRunId,
-        rejectedRunId: t.rejectedRunId,
-        chosenModel: t.meta.chosenModel,
-        rejectedModel: t.meta.rejectedModel
-      }
-    });
-  }
-  return out;
-}
-function toDpoJsonl(rows) {
-  return rows.map((r) => JSON.stringify(r)).join("\n") + (rows.length > 0 ? "\n" : "");
-}
-async function toGrpoRows(runs, lookups) {
-  const rewardOf = lookups.rewardOf ?? defaultReward;
-  const grouped = /* @__PURE__ */ new Map();
-  for (const r of runs) {
-    const sid = r.scenarioId ?? r.experimentId;
-    const arr = grouped.get(sid) ?? [];
-    arr.push(r);
-    grouped.set(sid, arr);
-  }
-  const rows = [];
-  for (const [scenarioId, group] of grouped.entries()) {
-    if (group.length === 0) continue;
-    const prompt = await Promise.resolve(lookups.promptOf(group[0].runId));
-    const completions = [];
-    const rewards = [];
-    const runIds = [];
-    for (const r of group) {
-      const reward = rewardOf(r);
-      if (reward === null) continue;
-      const completion = await Promise.resolve(lookups.completionOf(r.runId));
-      completions.push(completion);
-      rewards.push(reward);
-      runIds.push(r.runId);
-    }
-    if (completions.length === 0) continue;
-    rows.push({
-      prompt,
-      completions,
-      rewards,
-      runIds,
-      meta: {
-        scenarioId,
-        n: completions.length,
-        meanReward: rewards.reduce((s, x) => s + x, 0) / rewards.length
-      }
-    });
-  }
-  return rows;
-}
-function toGrpoJsonl(rows) {
-  return rows.map((r) => JSON.stringify(r)).join("\n") + (rows.length > 0 ? "\n" : "");
-}
-async function toSftRows(runs, lookups) {
-  const include = lookups.include ?? (() => true);
-  const rows = [];
-  for (const r of runs) {
-    if (!include(r)) continue;
-    const system = lookups.systemOf?.(r);
-    const [prompt, completion] = await Promise.all([
-      Promise.resolve(lookups.promptOf(r.runId)),
-      Promise.resolve(lookups.completionOf(r.runId))
-    ]);
-    const messages = [];
-    if (system) messages.push({ role: "system", content: system });
-    messages.push({ role: "user", content: prompt });
-    messages.push({ role: "assistant", content: completion });
-    rows.push({
-      messages,
-      meta: {
-        runId: r.runId,
-        candidateId: r.candidateId,
-        scenarioId: r.scenarioId,
-        score: r.outcome.holdoutScore ?? r.outcome.searchScore,
-        model: r.model
-      }
-    });
-  }
-  return rows;
-}
-function toSftJsonl(rows) {
-  return rows.map((r) => JSON.stringify(r)).join("\n") + (rows.length > 0 ? "\n" : "");
-}
-async function toPrmRows(triples, lookups) {
-  const rows = [];
-  for (const t of triples) {
-    const prompt = await Promise.resolve(lookups.promptOf(t.prefixRunId));
-    const prefixSpanIds = lookups.prefixOf ? await Promise.resolve(lookups.prefixOf(t.prefixRunId, t.prefixStepIndex)) : [];
-    const prefixStepText = [];
-    for (const spanId of prefixSpanIds) {
-      prefixStepText.push(await Promise.resolve(lookups.stepTextOf(t.prefixRunId, spanId)));
-    }
-    const chosenStep = await Promise.resolve(lookups.stepTextOf(t.prefixRunId, t.chosenSpanId));
-    const rejectedStep = await Promise.resolve(lookups.stepTextOf(t.rejectedRunId, t.rejectedSpanId));
-    rows.push({
-      prompt,
-      prefixSpanIds,
-      prefixStepText,
-      chosenStep,
-      rejectedStep,
-      chosenReward: t.chosenReward,
-      rejectedReward: t.rejectedReward,
-      marginScore: t.marginScore,
-      meta: {
-        prefixRunId: t.prefixRunId,
-        rejectedRunId: t.rejectedRunId,
-        prefixStepIndex: t.prefixStepIndex
-      }
-    });
-  }
-  return rows;
-}
-function toPrmJsonl(rows) {
-  return rows.map((r) => JSON.stringify(r)).join("\n") + (rows.length > 0 ? "\n" : "");
-}
-function stepRewardsToJsonl(stepRewards) {
-  const rows = stepRewards.map((s) => ({
-    runId: s.runId,
-    spanId: s.spanId,
-    stepIndex: s.stepIndex,
-    reward: s.reward,
-    determinism: s.determinism,
-    weight: s.weight ?? 1
-  }));
-  return rows.map((r) => JSON.stringify(r)).join("\n") + (rows.length > 0 ? "\n" : "");
-}
-function defaultReward(run) {
-  const v = run.outcome.holdoutScore ?? run.outcome.searchScore;
-  return typeof v === "number" && Number.isFinite(v) ? v : null;
-}
-
-// src/rl/rl-campaign.ts
-async function runRLCampaign(opts) {
-  const campaign = await runEvalCampaign(opts);
-  const rewardSignals = extractVerifiableRewardsFromRecords(
-    campaign.runs,
-    opts.verifiableReward ?? {}
-  );
-  const preferences = extractPreferences(campaign.runs, {
-    strategy: opts.preferences?.strategy ?? "paired-by-scenario-and-seed",
-    minMargin: opts.preferences?.minMargin ?? 0.05,
-    splitTag: opts.preferences?.splitTag ?? opts.splitTag ?? "holdout",
-    rewardOf: opts.preferences?.rewardOf
-  });
-  let interimConfidence = null;
-  if (opts.report?.comparator) {
-    const comparator = opts.report.comparator;
-    const deltaSeries = collectPairedDeltaSeries(campaign.runs, comparator);
-    if (deltaSeries.some((s) => s.deltas.length > 0)) {
-      interimConfidence = evaluateInterimReleaseConfidence({
-        deltaSeries,
-        alpha: opts.sequential?.alpha,
-        bound: opts.sequential?.bound,
-        rope: opts.sequential?.rope ?? opts.report?.rope
-      });
-    }
-  }
-  const rewardHacking = detectRewardHacking({
-    runs: campaign.runs,
-    verifiableRewardOptions: opts.verifiableReward
-  });
-  let predictiveValidity = null;
-  if (opts.outcomeStore && opts.outcomeMetrics && opts.outcomeMetrics.length > 0) {
-    predictiveValidity = await rubricPredictiveValidity({
-      runs: campaign.runs,
-      outcomes: opts.outcomeStore,
-      outcomeMetrics: opts.outcomeMetrics
-    });
-  }
-  const trainerRows = {};
-  if (opts.trainerExport?.dpo) {
-    trainerRows.dpo = await toDpoRows(preferences.pairs, opts.trainerExport.dpo);
-  }
-  if (opts.trainerExport?.grpo) {
-    trainerRows.grpo = await toGrpoRows(campaign.runs, opts.trainerExport.grpo);
-  }
-  if (opts.trainerExport?.sft) {
-    trainerRows.sft = await toSftRows(campaign.runs, opts.trainerExport.sft);
-  }
-  const summary = buildSummary({ campaign, preferences, interimConfidence, rewardHacking, predictiveValidity });
-  return {
-    campaign,
-    rewardSignals,
-    preferences,
-    interimConfidence,
-    rewardHacking,
-    predictiveValidity,
-    trainerRows,
-    summary,
-    kind: "agent-eval-rl-campaign"
-  };
-}
-function collectPairedDeltaSeries(runs, comparator) {
-  const baseline = /* @__PURE__ */ new Map();
-  for (const r of runs) {
-    if (r.candidateId !== comparator) continue;
-    const sid = r.scenarioId ?? r.experimentId;
-    const score = r.outcome.holdoutScore ?? r.outcome.searchScore;
-    if (typeof score !== "number" || !Number.isFinite(score)) continue;
-    baseline.set(`${sid}::${r.seed}`, score);
-  }
-  const byCandidate = /* @__PURE__ */ new Map();
-  for (const r of runs) {
-    if (r.candidateId === comparator) continue;
-    const sid = r.scenarioId ?? r.experimentId;
-    const score = r.outcome.holdoutScore ?? r.outcome.searchScore;
-    if (typeof score !== "number" || !Number.isFinite(score)) continue;
-    const baseScore = baseline.get(`${sid}::${r.seed}`);
-    if (typeof baseScore !== "number") continue;
-    const arr = byCandidate.get(r.candidateId) ?? [];
-    arr.push(score - baseScore);
-    byCandidate.set(r.candidateId, arr);
-  }
-  return [...byCandidate.entries()].map(([candidateId, deltas]) => ({ candidateId, deltas }));
-}
-function buildSummary(args) {
-  const c = args.campaign;
-  const lines = [
-    `${c.campaignId}: ${c.runs.length} successful runs / ${c.failedRuns.length} failed (fingerprint ${c.campaignFingerprint.slice(0, 12)}\u2026)`,
-    `preferences: ${args.preferences.pairs.length} (${args.preferences.strategy}, ${args.preferences.pairsBelowMargin} below margin)`
-  ];
-  if (args.interimConfidence) {
-    lines.push(`sequential verdict: ${args.interimConfidence.recommendation.decision}` + (args.interimConfidence.recommendation.candidateId ? ` ${args.interimConfidence.recommendation.candidateId}` : ""));
-  }
-  lines.push(`reward-hacking: ${args.rewardHacking.verdict} (${args.rewardHacking.findings.length} signals checked)`);
-  if (args.predictiveValidity) {
-    const top = args.predictiveValidity.ranked[0];
-    lines.push(`top-rubric: ${top?.rubric ?? "none"} \u03C1=${(top?.spearman ?? 0).toFixed(2)} (${top?.verdict ?? "no data"})`);
-  }
-  return lines.join(" | ");
-}
-
-// src/rl/predictive-validity-researcher.ts
-var PredictiveValidityResearcher = class {
-  opts;
-  lastReport = null;
-  constructor(opts) {
-    this.opts = opts;
-  }
-  async inspectFailures(runs) {
-    const threshold = this.opts.failureThreshold ?? 0.5;
-    const failures = [];
-    const failingRuns = runs.filter((r) => {
-      const score = r.outcome.holdoutScore ?? r.outcome.searchScore;
-      return typeof score === "number" && score < threshold;
-    });
-    if (failingRuns.length === 0) return failures;
-    const grouped = /* @__PURE__ */ new Map();
-    for (const r of failingRuns) {
-      const arr = grouped.get(r.candidateId) ?? [];
-      arr.push(r);
-      grouped.set(r.candidateId, arr);
-    }
-    for (const [candidateId, group] of grouped.entries()) {
-      const meanScore = group.reduce((s, r) => {
-        const x = r.outcome.holdoutScore ?? r.outcome.searchScore ?? 0;
-        return s + x;
-      }, 0) / group.length;
-      failures.push({
-        code: `low-score-${candidateId}`,
-        description: `${candidateId} scored < ${threshold} on ${group.length} run(s) (mean ${meanScore.toFixed(3)})`,
-        evidence: {
-          runIds: group.slice(0, 8).map((r) => r.runId),
-          samples: group.length
-        }
-      });
-    }
-    return failures;
-  }
-  async proposeChange(failures) {
-    if (failures.length === 0) return [];
-    if (this.lastReport === null) {
-      return [{
-        kind: "threshold",
-        payload: { directive: "researcher.collect-more-outcomes" },
-        rationale: "predictive-validity researcher has no prior report; cannot recommend rubric reweighting until at least one report exists"
-      }];
-    }
-    const decorativeThreshold = this.opts.decorativeThreshold ?? 0.4;
-    const changes = [];
-    for (const ranking of this.lastReport.ranked) {
-      if (ranking.verdict === "load_bearing") continue;
-      if (Math.abs(ranking.spearman) >= decorativeThreshold) continue;
-      changes.push({
-        kind: "reviewer_prompt",
-        payload: { rubric: ranking.rubric, action: "down-weight", spearman: ranking.spearman, bestOutcome: ranking.bestOutcome },
-        rationale: `predictive-validity Spearman=${ranking.spearman.toFixed(3)} vs ${ranking.bestOutcome} (decorative); recommend down-weighting`,
-        expectedDelta: -Math.max(0, 0.05 - Math.abs(ranking.spearman))
-      });
-    }
-    for (const ranking of this.lastReport.ranked.slice(0, 1)) {
-      if (ranking.verdict !== "load_bearing") continue;
-      changes.push({
-        kind: "reviewer_prompt",
-        payload: { rubric: ranking.rubric, action: "up-weight", spearman: ranking.spearman, bestOutcome: ranking.bestOutcome },
-        rationale: `predictive-validity Spearman=${ranking.spearman.toFixed(3)} vs ${ranking.bestOutcome} (load-bearing); recommend up-weighting`,
-        expectedDelta: Math.max(0, Math.abs(ranking.spearman) - 0.5) * 0.1
-      });
-    }
-    return changes;
-  }
-  async applyChange(changes, baseline) {
-    return {
-      ...baseline,
-      changes: [...baseline.changes, ...changes]
-    };
-  }
-  async evaluateChange(plan) {
-    const emptyGate = {
-      promote: false,
-      candidateId: plan.proposedCandidateId,
-      baselineId: plan.baselineCandidateId,
-      evidence: {
-        productiveRuns: 0,
-        medianPairedDelta: 0,
-        pairedCI: { low: 0, high: 0 },
-        pairedPValue: 1,
-        searchScore: 0,
-        holdoutScore: 0,
-        overfitGap: 0,
-        baselineOverfitGap: 0
-      },
-      reason: "predictive-validity researcher does not execute plans; the caller is expected to run the sweep and call rubricPredictiveValidity directly with the resulting RunRecord[].",
-      rejectionCode: "few_runs"
-    };
-    return {
-      plan,
-      runs: [],
-      gateDecision: emptyGate
-    };
-  }
-  /**
-   * Run the predictive-validity check explicitly against a fresh RunRecord
-   * set. Updates the researcher's cached report so subsequent
-   * `proposeChange` calls have evidence to draw from.
-   */
-  async runValidityCheck(runs) {
-    const report = await rubricPredictiveValidity({
-      runs,
-      outcomes: this.opts.outcomes,
-      outcomeMetrics: this.opts.outcomeMetrics,
-      rubrics: this.opts.rubrics
-    });
-    if (this.opts.onReport) await this.opts.onReport(report);
-    this.lastReport = report;
-    return report;
-  }
-  /**
-   * Force-feed a predictive-validity report into the researcher state —
-   * useful when the consumer ran the report out-of-band and wants the
-   * researcher's later proposals informed by it.
-   */
-  setReport(report) {
-    this.lastReport = report;
-  }
-  getLastReport() {
-    return this.lastReport;
-  }
-};
-
-// src/rl/auto-research.ts
-async function analyzeOptimizationResult(opts) {
-  const trials = extractTrials(opts.result);
-  const runs = trialsToRunRecords(trials, opts.ctx);
-  const rewardSignals = extractVerifiableRewardsFromRecords(runs, opts.verifiableReward ?? {});
-  const preferences = extractPreferences(runs, {
-    strategy: opts.preferences?.strategy ?? "paired-by-scenario-and-seed",
-    minMargin: opts.preferences?.minMargin ?? 0.05,
-    splitTag: opts.preferences?.splitTag ?? opts.ctx.splitTag ?? "search",
-    rewardOf: opts.preferences?.rewardOf
-  });
-  let interimConfidence = null;
-  if (opts.comparator) {
-    const deltaSeries = collectPairedDeltaSeries2(runs, opts.comparator);
-    if (deltaSeries.some((s) => s.deltas.length > 0)) {
-      interimConfidence = evaluateInterimReleaseConfidence({
-        deltaSeries,
-        alpha: opts.sequential?.alpha,
-        bound: opts.sequential?.bound,
-        rope: opts.sequential?.rope
-      });
-    }
-  }
-  const rewardHacking = detectRewardHacking({
-    runs,
-    verifiableRewardOptions: opts.verifiableReward
-  });
-  let predictiveValidity = null;
-  if (opts.outcomes) {
-    predictiveValidity = await rubricPredictiveValidity({
-      runs,
-      outcomes: opts.outcomes.store,
-      outcomeMetrics: opts.outcomes.metrics
-    });
-  }
-  const trainerRows = {};
-  if (opts.trainerExport?.dpo) {
-    trainerRows.dpo = await toDpoRows(preferences.pairs, opts.trainerExport.dpo);
-  }
-  if (opts.trainerExport?.grpo) {
-    trainerRows.grpo = await toGrpoRows(runs, opts.trainerExport.grpo);
-  }
-  const summary = buildSummary2({ runs, preferences, interimConfidence, rewardHacking, predictiveValidity });
-  return {
-    runs,
-    rewardSignals,
-    preferences,
-    interimConfidence,
-    rewardHacking,
-    predictiveValidity,
-    trainerRows,
-    summary
-  };
-}
-function extractTrials(result) {
-  if ("evolution" in result) {
-    return collectFromEvolution(result.evolution);
-  }
-  return collectFromEvolution(result);
-}
-function collectFromEvolution(evolution) {
-  const trials = [];
-  for (const gen of evolution.generations) {
-    for (const t of gen.trials ?? []) trials.push(t);
-  }
-  return trials;
-}
-function collectPairedDeltaSeries2(runs, comparator) {
-  const baseline = /* @__PURE__ */ new Map();
-  for (const r of runs) {
-    if (r.candidateId !== comparator) continue;
-    const sid = r.scenarioId ?? r.experimentId;
-    const score = r.outcome.holdoutScore ?? r.outcome.searchScore;
-    if (typeof score !== "number" || !Number.isFinite(score)) continue;
-    baseline.set(`${sid}::${r.seed}`, score);
-  }
-  const byCandidate = /* @__PURE__ */ new Map();
-  for (const r of runs) {
-    if (r.candidateId === comparator) continue;
-    const sid = r.scenarioId ?? r.experimentId;
-    const score = r.outcome.holdoutScore ?? r.outcome.searchScore;
-    if (typeof score !== "number" || !Number.isFinite(score)) continue;
-    const baseScore = baseline.get(`${sid}::${r.seed}`);
-    if (typeof baseScore !== "number") continue;
-    const arr = byCandidate.get(r.candidateId) ?? [];
-    arr.push(score - baseScore);
-    byCandidate.set(r.candidateId, arr);
-  }
-  return [...byCandidate.entries()].map(([candidateId, deltas]) => ({ candidateId, deltas }));
-}
-function buildSummary2(args) {
-  const lines = [
-    `${args.runs.length} runs analysed`,
-    `${args.preferences.pairs.length} preference pairs (${args.preferences.strategy})`,
-    `reward-hacking verdict: ${args.rewardHacking.verdict}`
-  ];
-  if (args.interimConfidence) {
-    lines.push(`sequential: ${args.interimConfidence.recommendation.decision}` + (args.interimConfidence.recommendation.candidateId ? ` ${args.interimConfidence.recommendation.candidateId}` : ""));
-  }
-  if (args.predictiveValidity?.ranked[0]) {
-    const top = args.predictiveValidity.ranked[0];
-    lines.push(`top-rubric: ${top.rubric} \u03C1=${top.spearman.toFixed(2)}`);
-  }
-  return lines.join(" | ");
-}
-
-export {
-  trialToRunRecord,
-  trialsToRunRecords,
-  verificationReportToRunRecord,
-  variantAggregateToRunRecord,
-  extractVerifiableReward,
-  extractVerifiableRewardsFromRecords,
-  filterDeterministicallyRewarded,
-  extractPreferences,
-  toTRLFormat,
-  toAnthropicFormat,
-  inverseProbabilityWeighting,
-  selfNormalizedImportanceWeighting,
-  doublyRobust,
-  offPolicyEstimateAll,
-  extractStepRewards,
-  runwiseStepRewardSummary,
-  prmTrainingPairs,
-  runContaminationProbe,
-  renameVariables,
-  shuffleOrder,
-  injectIrrelevantClause,
-  fitBradleyTerry,
-  applyEloUpdate,
-  buildPairwiseFromCampaign,
-  adversarialScenarioSearch,
-  runComputeCurve,
-  bestOfN,
-  selfConsistency,
-  paretoFrontier,
-  varianceBasedCurriculum,
-  thompsonCurriculum,
-  observationsFromRunRecords,
-  detectRewardHacking,
-  runAdaptationCurve,
-  compareAdaptationCurves,
-  firstPassK,
-  toDpoRows,
-  toDpoJsonl,
-  toGrpoRows,
-  toGrpoJsonl,
-  toSftRows,
-  toSftJsonl,
-  toPrmRows,
-  toPrmJsonl,
-  stepRewardsToJsonl,
-  runRLCampaign,
-  PredictiveValidityResearcher,
-  analyzeOptimizationResult
-};
-//# sourceMappingURL=chunk-LZKIOBG2.js.map