@tangle-network/agent-eval 0.21.0 → 0.23.0

package/dist/chunk-LZKIOBG2.js

@@ -0,0 +1,2026 @@
+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