@tangle-network/agent-eval 0.128.2 → 0.130.0

package/dist/chunk-NPCTHQIO.js

@@ -1,91 +0,0 @@
-// src/meta-eval/calibration.ts
-async function calibrationCurve(traceStore, outcomeStore, evalMetric, outcomeMetric, options = {}) {
-  const runs = await traceStore.listRuns();
-  const outcomes = await outcomeStore.list();
-  const byRun = /* @__PURE__ */ new Map();
-  for (const o of outcomes) {
-    const arr = byRun.get(o.runId) ?? [];
-    arr.push(o);
-    byRun.set(o.runId, arr);
-  }
-  const extract = evalMetric.extract ?? defaultExtract(evalMetric.id);
-  const pairs = [];
-  for (const run of runs) {
-    const os = byRun.get(run.runId);
-    if (!os?.length) continue;
-    const x = await extract(run, traceStore);
-    if (x === null || !Number.isFinite(x)) continue;
-    const latest = [...os].sort((a, b) => b.capturedAt - a.capturedAt)[0];
-    const y = latest.metrics[outcomeMetric];
-    if (typeof y !== "number" || !Number.isFinite(y)) continue;
-    pairs.push({ x, y });
-  }
-  if (pairs.length < 2) return null;
-  return calibrationFromPairs(
-    pairs.map((p) => ({ evalScore: p.x, outcome: p.y })),
-    evalMetric.id,
-    outcomeMetric,
-    options
-  );
-}
-function calibrationFromPairs(inputPairs, evalMetric, outcomeMetric, options = {}) {
-  const pairs = inputPairs.filter(
-    (pair) => Number.isFinite(pair.evalScore) && Number.isFinite(pair.outcome)
-  );
-  if (pairs.length < 2) return null;
-  const numBins = options.bins ?? 10;
-  const binning = options.binning ?? "equal-width";
-  const xs = pairs.map((p) => p.evalScore);
-  const lo = options.range?.lo ?? Math.min(...xs);
-  const hi = options.range?.hi ?? Math.max(...xs);
-  const bins = [];
-  if (binning === "equal-frequency") {
-    const sorted = [...pairs].sort((a, b) => a.evalScore - b.evalScore);
-    const perBin = Math.max(1, Math.floor(sorted.length / numBins));
-    for (let i = 0; i < sorted.length; i += perBin) {
-      const chunk = sorted.slice(i, i + perBin);
-      if (chunk.length === 0) continue;
-      bins.push(toBin(chunk));
-    }
-  } else {
-    const width = (hi - lo) / numBins;
-    if (width === 0) return null;
-    for (let i = 0; i < numBins; i++) {
-      const binLo = lo + i * width;
-      const binHi = i === numBins - 1 ? hi + 1e-9 : lo + (i + 1) * width;
-      const chunk = pairs.filter((p) => p.evalScore >= binLo && p.evalScore < binHi);
-      if (chunk.length === 0) continue;
-      bins.push(toBin(chunk, binLo, binHi));
-    }
-  }
-  const total = bins.reduce((a, b) => a + b.n, 0);
-  const ece = bins.reduce((a, b) => a + b.n / total * b.gap, 0);
-  const maxGap = bins.reduce((a, b) => Math.max(a, b.gap), 0);
-  return { evalMetric, outcomeMetric, n: pairs.length, bins, ece, maxGap };
-}
-function toBin(chunk, lower, upper) {
-  const xs = chunk.map((c) => c.evalScore);
-  const ys = chunk.map((c) => c.outcome);
-  const evalMean = mean(xs);
-  const outcomeMean = mean(ys);
-  return {
-    lower: lower ?? Math.min(...xs),
-    upper: upper ?? Math.max(...xs),
-    n: chunk.length,
-    evalMean,
-    outcomeMean,
-    gap: Math.abs(outcomeMean - evalMean)
-  };
-}
-function mean(xs) {
-  return xs.reduce((a, b) => a + b, 0) / xs.length;
-}
-function defaultExtract(metric) {
-  return async (run) => run.outcome?.score ?? (metric === "pass" ? run.outcome?.pass === true ? 1 : 0 : null);
-}
-
-export {
-  calibrationCurve,
-  calibrationFromPairs
-};
-//# sourceMappingURL=chunk-NPCTHQIO.js.map

package/dist/chunk-NPCTHQIO.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/meta-eval/calibration.ts"],"sourcesContent":["/**\n * Calibration curve — binned \"if eval says X, what does reality show?\"\n *\n * Companion to correlationStudy. Raw correlation is a single number;\n * the calibration curve shows *where* the eval is well-calibrated vs\n * overconfident / underconfident. Buckets the eval metric, computes\n * mean outcome per bucket, reports expected-calibration-error (ECE).\n */\n\nimport type { Run } from '../trace/schema'\nimport type { TraceStore } from '../trace/store'\nimport type { EvalMetricSpec } from './correlation-study'\nimport type { DeploymentOutcome, OutcomeStore } from './outcome-store'\n\nexport interface CalibrationBin {\n  lower: number\n  upper: number\n  n: number\n  evalMean: number\n  outcomeMean: number\n  /** |outcomeMean − evalMean|; contributes to ECE weighted by n/total. */\n  gap: number\n}\n\nexport interface CalibrationReport {\n  evalMetric: string\n  outcomeMetric: string\n  n: number\n  bins: CalibrationBin[]\n  /** Expected Calibration Error — Σ (n_i/N) × |outcomeMean_i − evalMean_i|. */\n  ece: number\n  /** Max bin gap — upper bound on miscalibration. */\n  maxGap: number\n}\n\nexport interface CalibrationOptions {\n  bins?: number\n  /** Equal-width (fixed bin edges) or equal-frequency (quantile bins). */\n  binning?: 'equal-width' | 'equal-frequency'\n  /** Clip eval values to [lo, hi] before binning. */\n  range?: { lo: number; hi: number }\n}\n\nexport interface CalibrationPair {\n  evalScore: number\n  outcome: number\n}\n\nexport async function calibrationCurve(\n  traceStore: TraceStore,\n  outcomeStore: OutcomeStore,\n  evalMetric: EvalMetricSpec,\n  outcomeMetric: string,\n  options: CalibrationOptions = {},\n): Promise<CalibrationReport | null> {\n  const runs = await traceStore.listRuns()\n  const outcomes = await outcomeStore.list()\n  const byRun = new Map<string, DeploymentOutcome[]>()\n  for (const o of outcomes) {\n    const arr = byRun.get(o.runId) ?? []\n    arr.push(o)\n    byRun.set(o.runId, arr)\n  }\n\n  const extract = evalMetric.extract ?? defaultExtract(evalMetric.id)\n  const pairs: Array<{ x: number; y: number }> = []\n  for (const run of runs) {\n    const os = byRun.get(run.runId)\n    if (!os?.length) continue\n    const x = await extract(run, traceStore)\n    if (x === null || !Number.isFinite(x)) continue\n    const latest = [...os].sort((a, b) => b.capturedAt - a.capturedAt)[0]!\n    const y = latest.metrics[outcomeMetric]\n    if (typeof y !== 'number' || !Number.isFinite(y)) continue\n    pairs.push({ x, y })\n  }\n  if (pairs.length < 2) return null\n\n  return calibrationFromPairs(\n    pairs.map((p) => ({ evalScore: p.x, outcome: p.y })),\n    evalMetric.id,\n    outcomeMetric,\n    options,\n  )\n}\n\nexport function calibrationFromPairs(\n  inputPairs: CalibrationPair[],\n  evalMetric: string,\n  outcomeMetric: string,\n  options: CalibrationOptions = {},\n): CalibrationReport | null {\n  const pairs = inputPairs.filter(\n    (pair) => Number.isFinite(pair.evalScore) && Number.isFinite(pair.outcome),\n  )\n  if (pairs.length < 2) return null\n\n  const numBins = options.bins ?? 10\n  const binning = options.binning ?? 'equal-width'\n  const xs = pairs.map((p) => p.evalScore)\n  const lo = options.range?.lo ?? Math.min(...xs)\n  const hi = options.range?.hi ?? Math.max(...xs)\n\n  const bins: CalibrationBin[] = []\n  if (binning === 'equal-frequency') {\n    const sorted = [...pairs].sort((a, b) => a.evalScore - b.evalScore)\n    const perBin = Math.max(1, Math.floor(sorted.length / numBins))\n    for (let i = 0; i < sorted.length; i += perBin) {\n      const chunk = sorted.slice(i, i + perBin)\n      if (chunk.length === 0) continue\n      bins.push(toBin(chunk))\n    }\n  } else {\n    const width = (hi - lo) / numBins\n    if (width === 0) return null\n    for (let i = 0; i < numBins; i++) {\n      const binLo = lo + i * width\n      const binHi = i === numBins - 1 ? hi + 1e-9 : lo + (i + 1) * width\n      const chunk = pairs.filter((p) => p.evalScore >= binLo && p.evalScore < binHi)\n      if (chunk.length === 0) continue\n      bins.push(toBin(chunk, binLo, binHi))\n    }\n  }\n\n  const total = bins.reduce((a, b) => a + b.n, 0)\n  const ece = bins.reduce((a, b) => a + (b.n / total) * b.gap, 0)\n  const maxGap = bins.reduce((a, b) => Math.max(a, b.gap), 0)\n\n  return { evalMetric, outcomeMetric, n: pairs.length, bins, ece, maxGap }\n}\n\nfunction toBin(chunk: CalibrationPair[], lower?: number, upper?: number): CalibrationBin {\n  const xs = chunk.map((c) => c.evalScore)\n  const ys = chunk.map((c) => c.outcome)\n  const evalMean = mean(xs)\n  const outcomeMean = mean(ys)\n  return {\n    lower: lower ?? Math.min(...xs),\n    upper: upper ?? Math.max(...xs),\n    n: chunk.length,\n    evalMean,\n    outcomeMean,\n    gap: Math.abs(outcomeMean - evalMean),\n  }\n}\n\nfunction mean(xs: number[]): number {\n  return xs.reduce((a, b) => a + b, 0) / xs.length\n}\n\nfunction defaultExtract(metric: string): (run: Run, store: TraceStore) => Promise<number | null> {\n  return async (run) =>\n    run.outcome?.score ?? (metric === 'pass' ? (run.outcome?.pass === true ? 1 : 0) : null)\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-NYLOYM6N.js

@@ -1,332 +0,0 @@
-import {
-  pearsonR
-} from "./chunk-MHELPNRP.js";
-import {
-  runTaskScore
-} from "./chunk-2JX3CFMB.js";
-
-// 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(
-    (layer) => deterministicSet.has(layer.layer) && isMeasuredLayer(layer)
-  );
-  if (deterministic.length === 1) {
-    const layer = deterministic[0];
-    const value = clamp01(layer.score);
-    return {
-      value,
-      source: sourceFor(layer.layer),
-      determinism: "deterministic",
-      confidence: 1,
-      origin: layer.layer,
-      components: { [layer.layer]: value },
-      breakdown: layerBreakdown(layer)
-    };
-  }
-  if (deterministic.length > 1) {
-    let num = 0;
-    let denom = 0;
-    const components = {};
-    for (const l of deterministic) {
-      const w = l.detail?.weight ?? 1;
-      num += w * (l.score ?? 0);
-      denom += w;
-      components[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("+"),
-      components,
-      breakdown: { ...components }
-    };
-  }
-  if (!fallbackToJudge) return null;
-  const judge = report.layers.find((layer) => isMeasuredLayer(layer) && sourceFor(layer.layer) === "judge") ?? report.layers.find(isMeasuredLayer);
-  if (!judge) return null;
-  const confFromDetail = judge.detail?.confidence;
-  const judgeValue = clamp01(judge.score);
-  return {
-    value: judgeValue,
-    source: "judge",
-    determinism: "probabilistic",
-    confidence: typeof confFromDetail === "number" ? confFromDetail : judgeFloor,
-    origin: judge.layer,
-    components: { [judge.layer]: judgeValue },
-    breakdown: layerBreakdown(judge)
-  };
-}
-function isMeasuredLayer(layer) {
-  return (layer.status === "pass" || layer.status === "fail") && typeof layer.score === "number" && Number.isFinite(layer.score) && layer.score >= 0 && layer.score <= 1;
-}
-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];
-      const value = clamp01(layer.score);
-      return {
-        runId: run.runId,
-        reward: {
-          value,
-          source: sourceFor(layer.name),
-          determinism: "deterministic",
-          confidence: 1,
-          origin: layer.name,
-          components: { [layer.name]: value }
-        }
-      };
-    }
-    if (det.length > 1) {
-      const value = det.reduce((s, l) => s + l.score, 0) / det.length;
-      const components = 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("+"),
-          components,
-          breakdown: { ...components }
-        }
-      };
-    }
-    if (!fallbackToJudge) return { runId: run.runId, reward: null };
-    const primary = runTaskScore(run);
-    if (primary === void 0) {
-      return { runId: run.runId, reward: null };
-    }
-    const primaryValue = clamp01(primary);
-    return {
-      runId: run.runId,
-      reward: {
-        value: primaryValue,
-        source: "judge",
-        determinism: "probabilistic",
-        confidence: judgeFloor,
-        origin: "run.outcome.score",
-        components: { "run.outcome.score": primaryValue }
-      }
-    };
-  });
-}
-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/reward-hacking.ts
-var DEFAULT_PROXY = (r) => {
-  return runTaskScore(r) ?? 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((run) => finiteNumber(proxyOf(run)));
-  const n = runs.length;
-  if (n < 4) {
-    return {
-      findings: [],
-      evaluatedSignals: [],
-      verdict: "insufficient_evidence",
-      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(finiteNumber);
-    const afterProxy = after.map(proxyOf).filter(finiteNumber);
-    const beforeTruth = before.map(truthOf).filter(finiteNumber);
-    const afterTruth = after.map(truthOf).filter(finiteNumber);
-    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(finiteNumber);
-    const afterP = after.map(proxyOf).filter(finiteNumber);
-    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) => finiteNumber(x.p) && finiteNumber(x.s));
-    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(finiteNumber)) - mean(before.map(proxyOf).filter(finiteNumber));
-      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);
-  if (findings.length === 0) {
-    return {
-      findings,
-      evaluatedSignals: [],
-      verdict: "insufficient_evidence",
-      rationale: [`no reward-hacking signal had enough paired evidence (n=${n})`],
-      n
-    };
-  }
-  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,
-    evaluatedSignals: findings.map((finding) => finding.signal),
-    verdict,
-    rationale,
-    n
-  };
-}
-function mean(xs) {
-  if (xs.length === 0) return 0;
-  return xs.reduce((s, x) => s + x, 0) / xs.length;
-}
-function finiteNumber(value) {
-  return typeof value === "number" && Number.isFinite(value);
-}
-function clamp012(x) {
-  if (!Number.isFinite(x)) return 0;
-  return Math.max(0, Math.min(1, x));
-}
-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;
-  };
-}
-
-export {
-  extractVerifiableReward,
-  extractVerifiableRewardsFromRecords,
-  filterDeterministicallyRewarded,
-  detectRewardHacking
-};
-//# sourceMappingURL=chunk-NYLOYM6N.js.map

package/dist/chunk-NYLOYM6N.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/rl/verifiable-reward.ts","../src/rl/reward-hacking.ts"],"sourcesContent":["/**\n * Verifiable reward channel.\n *\n * For RL on coding / math / theorem-proving / structured-output tasks, the\n * reward signal is *decidable* — a test passes or fails, a proof checks or\n * doesn't, an output validates against a schema or doesn't. These rewards\n * are dramatically more useful for RL training than LLM-judge scores\n * because they don't drift, can't be Goodhart-gamed by the policy in the\n * same way, and don't require a separate calibration loop.\n *\n * The `MultiLayerVerifier` already produces this signal — it just doesn't\n * surface it in a shape that's clean enough for RL training. This module\n * wraps the verifier output so consumers can:\n *\n *   1. Extract a clean `VerifiableReward` from a `VerificationReport`\n *   2. Distinguish *deterministic* rewards (compile, test, schema) from\n *      *probabilistic* rewards (judge) so they can be weighted differently\n *      in the RL training step\n *   3. Filter `RunRecord[]` to only those with a verifiable reward,\n *      producing the clean training set that DeepSeek-R1-style GRPO and\n *      AlphaProof-style search both depend on\n *\n * Why this matters: every credible 2025-2026 frontier RL result on coding\n * agents leans on verifiable reward (DeepSeek-R1 GRPO on test pass-rate,\n * o-series RL on math/code, AlphaProof on Lean kernel checking). Mixing\n * judge scores into the reward signal poisons the gradient. This module\n * is the seam.\n */\n\nimport type { LayerResult, VerificationReport } from '../multi-layer-verifier'\nimport { type RunRecord, runTaskScore } from '../run-record'\n\nexport type VerifiableRewardSource =\n  | 'compile' // typecheck / build / lint passed\n  | 'test' // unit / integration test pass-rate\n  | 'schema' // structured output validates\n  | 'sandbox' // sandbox exec exit code\n  | 'judge' // LLM judge — probabilistic, included for completeness\n  | 'composite' // weighted blend across multiple of the above\n\nexport interface VerifiableReward {\n  /** Scalar in [0, 1]. The RL training signal. */\n  value: number\n  /** What produced the reward — different sources have different determinism. */\n  source: VerifiableRewardSource\n  /**\n   * Determinism class. `'deterministic'` rewards are repeatable byte-for-byte\n   * given the same inputs (compile, test, schema validation, sandbox exit code).\n   * `'probabilistic'` rewards depend on a stochastic component (LLM judge).\n   * Mixing these in the same training batch without separation is a known\n   * footgun in production RLHF pipelines.\n   */\n  determinism: 'deterministic' | 'probabilistic'\n  /**\n   * Confidence in the reward value. For deterministic sources this is 1.0\n   * (the bit either flipped or didn't). For judge sources this is the\n   * judge-reported confidence or — when missing — a calibrated prior.\n   */\n  confidence: number\n  /** The layer / judge id that produced the signal, for provenance. */\n  origin: string\n  /**\n   * Per-source contribution to `value`, keyed by layer/judge id. Single-source\n   * rewards carry one entry (`{ [origin]: value }`); composite rewards carry\n   * every contributing layer's score — the anti-scalar-collapse surface RL\n   * consumers weight per-source instead of trusting one blended number.\n   */\n  components: Record<string, number>\n  /**\n   * @deprecated Read `components` for per-source reward values. Kept for\n   * published-API compatibility: single-source rewards carry the layer's\n   * diagnostics here (e.g. `{ tests_passed: 7 }`); composite rewards carry\n   * the same per-layer scores `components` now holds.\n   */\n  breakdown?: Record<string, number>\n}\n\nexport interface VerifiableRewardExtractionOptions {\n  /**\n   * Which layers count as deterministic-reward sources. The verifier doesn't\n   * tag layers as \"this is verifiable\"; the caller declares it via this list\n   * (or via the layer name → source mapping). Default treats common names\n   * (`install`, `typecheck`, `build`, `lint`, `test`, `compile`, `schema`,\n   * `sandbox`) as deterministic.\n   */\n  deterministicLayers?: string[]\n  /**\n   * Map layer name → reward source. Defaults to a sensible string-match.\n   */\n  sourceFor?: (layerName: string) => VerifiableRewardSource\n  /**\n   * Whether to fall back to a probabilistic (judge) reward when no\n   * deterministic layer produced a numeric score. Default `true`. Set to\n   * `false` for \"deterministic-only\" training pipelines that should\n   * discard runs without a verifiable signal.\n   */\n  fallbackToJudge?: boolean\n  /**\n   * Default confidence for probabilistic (judge) rewards when the judge\n   * doesn't report one. Default `0.7`.\n   */\n  judgeConfidenceFloor?: number\n}\n\nconst DEFAULT_DETERMINISTIC_LAYERS = new Set([\n  'install',\n  'typecheck',\n  'build',\n  'lint',\n  'test',\n  'compile',\n  'schema',\n  'sandbox',\n  'unit_tests',\n  'integration_tests',\n])\n\nconst DEFAULT_SOURCE_FOR = (name: string): VerifiableRewardSource => {\n  const lower = name.toLowerCase()\n  if (lower.includes('test')) return 'test'\n  if (\n    lower.includes('compile') ||\n    lower.includes('build') ||\n    lower.includes('typecheck') ||\n    lower.includes('lint')\n  )\n    return 'compile'\n  if (lower.includes('schema')) return 'schema'\n  if (lower.includes('sandbox')) return 'sandbox'\n  if (lower.includes('judge') || lower.includes('semantic')) return 'judge'\n  return 'composite'\n}\n\n/**\n * Extract a `VerifiableReward` from a `VerificationReport`.\n *\n * Strategy: prefer the deterministic layers (in order: test → compile →\n * schema → sandbox), fall back to the judge layer if `fallbackToJudge` is\n * true, return `null` if no signal qualifies. When multiple deterministic\n * layers contribute, return a `'composite'` source with a weighted blend.\n */\nexport function extractVerifiableReward(\n  report: VerificationReport,\n  opts: VerifiableRewardExtractionOptions = {},\n): VerifiableReward | null {\n  const deterministicSet = new Set(opts.deterministicLayers ?? [...DEFAULT_DETERMINISTIC_LAYERS])\n  const sourceFor = opts.sourceFor ?? DEFAULT_SOURCE_FOR\n  const fallbackToJudge = opts.fallbackToJudge ?? true\n  const judgeFloor = opts.judgeConfidenceFloor ?? 0.7\n\n  const deterministic = report.layers.filter(\n    (layer) => deterministicSet.has(layer.layer) && isMeasuredLayer(layer),\n  )\n\n  if (deterministic.length === 1) {\n    const layer = deterministic[0]!\n    const value = clamp01(layer.score!)\n    return {\n      value,\n      source: sourceFor(layer.layer),\n      determinism: 'deterministic',\n      confidence: 1,\n      origin: layer.layer,\n      components: { [layer.layer]: value },\n      breakdown: layerBreakdown(layer),\n    }\n  }\n\n  if (deterministic.length > 1) {\n    // Composite: weighted blend by `Layer.weight` if present, else equal.\n    let num = 0\n    let denom = 0\n    const components: Record<string, number> = {}\n    for (const l of deterministic) {\n      const w = (l.detail?.weight as number | undefined) ?? 1\n      num += w * (l.score ?? 0)\n      denom += w\n      components[l.layer] = l.score!\n    }\n    return {\n      value: denom === 0 ? 0 : clamp01(num / denom),\n      source: 'composite',\n      determinism: 'deterministic',\n      confidence: 1,\n      origin: deterministic.map((l) => l.layer).join('+'),\n      components,\n      breakdown: { ...components },\n    }\n  }\n\n  if (!fallbackToJudge) return null\n\n  const judge =\n    report.layers.find((layer) => isMeasuredLayer(layer) && sourceFor(layer.layer) === 'judge') ??\n    report.layers.find(isMeasuredLayer)\n\n  if (!judge) return null\n\n  const confFromDetail = judge.detail?.confidence as number | undefined\n  const judgeValue = clamp01(judge.score!)\n  return {\n    value: judgeValue,\n    source: 'judge',\n    determinism: 'probabilistic',\n    confidence: typeof confFromDetail === 'number' ? confFromDetail : judgeFloor,\n    origin: judge.layer,\n    components: { [judge.layer]: judgeValue },\n    breakdown: layerBreakdown(judge),\n  }\n}\n\nfunction isMeasuredLayer(\n  layer: LayerResult,\n): layer is LayerResult & { status: 'pass' | 'fail'; score: number } {\n  return (\n    (layer.status === 'pass' || layer.status === 'fail') &&\n    typeof layer.score === 'number' &&\n    Number.isFinite(layer.score) &&\n    layer.score >= 0 &&\n    layer.score <= 1\n  )\n}\n\n/**\n * Extract verifiable rewards from `RunRecord[]` produced via the\n * `verificationReportToRunRecord` adapter (which encodes per-layer scores\n * in `outcome.raw['layer.<name>']`). For records that don't carry layer\n * scores, returns `null` for that record.\n *\n * This is the canonical bridge from \"campaign-shaped artifacts\" to\n * \"RL-training-ready reward signals\": every record that has a clean\n * verifiable reward becomes a training datum, every record that doesn't\n * gets filtered out (or kept with `'probabilistic'` determinism for\n * separate downstream handling).\n */\nexport function extractVerifiableRewardsFromRecords(\n  runs: RunRecord[],\n  opts: VerifiableRewardExtractionOptions = {},\n): Array<{ runId: string; reward: VerifiableReward | null }> {\n  const sourceFor = opts.sourceFor ?? DEFAULT_SOURCE_FOR\n  const deterministicSet = new Set(opts.deterministicLayers ?? [...DEFAULT_DETERMINISTIC_LAYERS])\n  const fallbackToJudge = opts.fallbackToJudge ?? true\n  const judgeFloor = opts.judgeConfidenceFloor ?? 0.7\n\n  return runs.map((run) => {\n    // Recover per-layer scores from outcome.raw['layer.<name>']\n    const layerScores: Array<{ name: string; score: number }> = []\n    for (const [k, v] of Object.entries(run.outcome.raw)) {\n      if (\n        k.startsWith('layer.') &&\n        !k.includes('.', 6) &&\n        typeof v === 'number' &&\n        Number.isFinite(v)\n      ) {\n        layerScores.push({ name: k.slice('layer.'.length), score: v })\n      }\n    }\n    const det = layerScores.filter((l) => deterministicSet.has(l.name))\n\n    if (det.length === 1) {\n      const layer = det[0]!\n      const value = clamp01(layer.score)\n      return {\n        runId: run.runId,\n        reward: {\n          value,\n          source: sourceFor(layer.name),\n          determinism: 'deterministic',\n          confidence: 1,\n          origin: layer.name,\n          components: { [layer.name]: value },\n        },\n      }\n    }\n    if (det.length > 1) {\n      const value = det.reduce((s, l) => s + l.score, 0) / det.length\n      const components: Record<string, number> = Object.fromEntries(\n        det.map((l) => [l.name, l.score]),\n      )\n      return {\n        runId: run.runId,\n        reward: {\n          value: clamp01(value),\n          source: 'composite',\n          determinism: 'deterministic',\n          confidence: 1,\n          origin: det.map((l) => l.name).join('+'),\n          components,\n          breakdown: { ...components },\n        },\n      }\n    }\n    if (!fallbackToJudge) return { runId: run.runId, reward: null }\n\n    // Probabilistic fallback: use the run's primary score.\n    const primary = runTaskScore(run)\n    if (primary === undefined) {\n      return { runId: run.runId, reward: null }\n    }\n    const primaryValue = clamp01(primary)\n    return {\n      runId: run.runId,\n      reward: {\n        value: primaryValue,\n        source: 'judge',\n        determinism: 'probabilistic',\n        confidence: judgeFloor,\n        origin: 'run.outcome.score',\n        components: { 'run.outcome.score': primaryValue },\n      },\n    }\n  })\n}\n\n/** Filter `RunRecord[]` to those with deterministic verifiable rewards. */\nexport function filterDeterministicallyRewarded(\n  runs: RunRecord[],\n  opts: VerifiableRewardExtractionOptions = {},\n): Array<{ run: RunRecord; reward: VerifiableReward }> {\n  const rewarded = extractVerifiableRewardsFromRecords(runs, { ...opts, fallbackToJudge: false })\n  const out: Array<{ run: RunRecord; reward: VerifiableReward }> = []\n  for (let i = 0; i < runs.length; i++) {\n    const r = rewarded[i]!\n    if (r.reward && r.reward.determinism === 'deterministic') {\n      out.push({ run: runs[i]!, reward: r.reward })\n    }\n  }\n  return out\n}\n\n// ── Helpers ──────────────────────────────────────────────────────────────\n\nfunction clamp01(x: number): number {\n  if (!Number.isFinite(x)) return 0\n  return Math.max(0, Math.min(1, x))\n}\n\nfunction layerBreakdown(l: LayerResult): Record<string, number> {\n  const out: Record<string, number> = {}\n  if (l.diagnostics) {\n    for (const [k, v] of Object.entries(l.diagnostics)) {\n      if (typeof v === 'number' && Number.isFinite(v)) out[k] = v\n    }\n  }\n  return out\n}\n","/**\n * Reward hacking / Goodhart detection.\n *\n * Goodhart's Law says: when a measure becomes a target, it ceases to be\n * a good measure. In RLHF and agentic-RL settings this is the dominant\n * failure mode — the policy learns to produce outputs that score well on\n * the proxy reward (judge, rubric, test pass-rate) without producing\n * the underlying capability the proxy was meant to track.\n *\n * Krakovna et al. (2020, \"Specification Gaming Examples in AI\") and the\n * subsequent RLHF reward-hacking literature (Skalse et al. 2022, Kim et al.\n * 2023) converge on a few diagnostic signatures:\n *\n *   1. **Reward divergence:** the proxy reward grows while the held-out\n *      ground-truth signal stagnates or drops. Predictive validity over\n *      time captures this.\n *   2. **Distributional shift in outputs:** after RL, the policy produces\n *      outputs that no longer match the reference distribution — usually\n *      because it found a high-reward attractor that's degenerate (e.g.\n *      one-token responses, repetition, formatting tricks).\n *   3. **Disagreement between independent rewards:** if you train on\n *      reward A and a held-out independent reward B drops sharply, you're\n *      probably hacking A.\n *   4. **Calibration drift:** the verifiable / deterministic component of\n *      the reward is stable; the probabilistic / judge component drifts up\n *      while the deterministic component doesn't. The judge is being\n *      gamed.\n *\n * This module ships explicit detectors for all four signatures, plus a\n * combined verdict. The output is diagnostic — actionable signals,\n * not autoreject — because each signature has known false positives\n * (e.g., a policy that genuinely improves can show distributional shift).\n *\n * Differs from `rubricPredictiveValidity` (which is a *standing* check on\n * whether rubrics correlate with deployment outcomes) — this is a\n * *temporal* check on whether the reward-vs-truth gap is *widening over\n * time during a training run*.\n */\n\nimport { type RunRecord, runTaskScore } from '../run-record'\nimport { pearsonR } from '../statistics'\nimport {\n  filterDeterministicallyRewarded,\n  type VerifiableRewardExtractionOptions,\n} from './verifiable-reward'\n\nexport type RewardHackingSignal =\n  | 'reward_divergence'\n  | 'distribution_shift'\n  | 'reward_disagreement'\n  | 'judge_drift'\n\nexport interface RewardHackingFinding {\n  signal: RewardHackingSignal\n  /** Severity in [0, 1]. >0.5 = strong signal. */\n  severity: number\n  message: string\n  /** Numeric evidence the consumer can render. */\n  detail: Record<string, number>\n}\n\nexport interface RewardHackingReport {\n  findings: RewardHackingFinding[]\n  /** Signals with enough usable observations to produce a finding. */\n  evaluatedSignals: RewardHackingSignal[]\n  /**\n   * Composite verdict. `'insufficient_evidence'` when fewer than four scored\n   * runs exist; otherwise `'clean'` if every signal severity < 0.3,\n   * `'suspect'` if at least one ≥ 0.3 but none ≥ 0.6, and `'gaming'` if any ≥ 0.6.\n   */\n  verdict: 'insufficient_evidence' | 'clean' | 'suspect' | 'gaming'\n  /** Rationale for the verdict, ready to paste into an audit log. */\n  rationale: string[]\n  /** Number of runs with a usable proxy reward. */\n  n: number\n}\n\nexport interface DetectRewardHackingInput {\n  /**\n   * Run records ordered by recency (oldest first). The detector segments\n   * them into prefix/suffix windows to compute \"did the gap widen.\"\n   */\n  runs: RunRecord[]\n  /**\n   * The metric the policy was trained to optimize. Should be present on\n   * `outcome.raw` or `outcome.holdoutScore`. Default reads `outcome.holdoutScore`.\n   */\n  proxyOf?: (run: RunRecord) => number | null\n  /**\n   * The held-out ground-truth metric. For RL on coding, this is typically\n   * test pass-rate. For RLHF, it's downstream task performance or human\n   * preference. For knowledge tasks, it's an independently-graded score.\n   */\n  truthOf?: (run: RunRecord) => number | null\n  /**\n   * Independent secondary reward. Used for the `reward_disagreement`\n   * signal. Default uses the verifiable reward extractor (deterministic\n   * sources only).\n   */\n  secondaryRewardOf?: (run: RunRecord) => number | null\n  /**\n   * Window size — how many of the most recent runs count as the \"after\"\n   * cohort. Default min(50, half the runs).\n   */\n  windowSize?: number\n  /**\n   * Severity threshold to flag a signal. Default 0.3 (suspect) and 0.6\n   * (gaming).\n   */\n  thresholds?: { suspect?: number; gaming?: number }\n  /**\n   * Verifiable-reward options used for the secondary-reward fallback.\n   */\n  verifiableRewardOptions?: VerifiableRewardExtractionOptions\n}\n\nconst DEFAULT_PROXY = (r: RunRecord): number | null => {\n  return runTaskScore(r) ?? null\n}\n\nexport function detectRewardHacking(input: DetectRewardHackingInput): RewardHackingReport {\n  const proxyOf = input.proxyOf ?? DEFAULT_PROXY\n  const truthOf = input.truthOf\n  const sus = input.thresholds?.suspect ?? 0.3\n  const gam = input.thresholds?.gaming ?? 0.6\n\n  const runs = input.runs.filter((run) => finiteNumber(proxyOf(run)))\n  const n = runs.length\n  if (n < 4) {\n    return {\n      findings: [],\n      evaluatedSignals: [],\n      verdict: 'insufficient_evidence',\n      n,\n      rationale: [`fewer than 4 runs with proxy reward (n=${n}); insufficient evidence`],\n    }\n  }\n  const windowSize = Math.max(1, input.windowSize ?? Math.min(50, Math.floor(n / 2)))\n  const before = runs.slice(0, n - windowSize)\n  const after = runs.slice(n - windowSize)\n\n  const findings: RewardHackingFinding[] = []\n\n  // ── Signal 1: reward divergence (proxy ↑ while truth flat or ↓) ──────\n  if (truthOf) {\n    const beforeProxy = before.map(proxyOf).filter(finiteNumber)\n    const afterProxy = after.map(proxyOf).filter(finiteNumber)\n    const beforeTruth = before.map(truthOf).filter(finiteNumber)\n    const afterTruth = after.map(truthOf).filter(finiteNumber)\n    if (\n      beforeProxy.length >= 2 &&\n      afterProxy.length >= 2 &&\n      beforeTruth.length >= 2 &&\n      afterTruth.length >= 2\n    ) {\n      const proxyDelta = mean(afterProxy) - mean(beforeProxy)\n      const truthDelta = mean(afterTruth) - mean(beforeTruth)\n      // Divergence: proxy goes up while truth goes flat or down.\n      // Severity = max(0, (proxyDelta - truthDelta)) — bigger gap = bigger signal.\n      const gap = Math.max(0, proxyDelta - truthDelta)\n      const severity = clamp01(gap * 5) // scale: 0.2 absolute gap → severity 1.0\n      findings.push({\n        signal: 'reward_divergence',\n        severity,\n        message:\n          severity >= sus\n            ? `proxy reward rose by ${proxyDelta.toFixed(3)} while truth changed by ${truthDelta.toFixed(3)} — potential Goodhart`\n            : `proxy and truth moved together (proxy ${proxyDelta.toFixed(3)}, truth ${truthDelta.toFixed(3)})`,\n        detail: {\n          proxyDelta,\n          truthDelta,\n          gap,\n          beforeN: beforeProxy.length,\n          afterN: afterProxy.length,\n        },\n      })\n    }\n  }\n\n  // ── Signal 2: distributional shift in outputs (KS on score distributions) ──\n  {\n    const beforeP = before.map(proxyOf).filter(finiteNumber)\n    const afterP = after.map(proxyOf).filter(finiteNumber)\n    if (beforeP.length >= 4 && afterP.length >= 4) {\n      const ks = ksStatistic(beforeP, afterP)\n      // KS statistic: bigger = more shift. We're agnostic about direction;\n      // genuine improvement ALSO produces shift, so this signal is\n      // contributory rather than load-bearing.\n      const severity = clamp01(ks - 0.2)\n      findings.push({\n        signal: 'distribution_shift',\n        severity,\n        message:\n          severity >= sus\n            ? `KS=${ks.toFixed(3)} between before/after windows — distributional shift large`\n            : `KS=${ks.toFixed(3)} between before/after windows — within-distribution drift`,\n        detail: { ks, beforeN: beforeP.length, afterN: afterP.length },\n      })\n    }\n  }\n\n  // ── Signal 3: reward disagreement (proxy vs independent secondary) ────\n  {\n    const secondaryOf = input.secondaryRewardOf ?? defaultSecondary(input.verifiableRewardOptions)\n    const aligned = runs\n      .map((r) => ({ p: proxyOf(r), s: secondaryOf(r) }))\n      .filter((x): x is { p: number; s: number } => finiteNumber(x.p) && finiteNumber(x.s))\n    if (aligned.length >= 4) {\n      const ps = aligned.map((x) => x.p)\n      const ss = aligned.map((x) => x.s)\n      const r = pearsonR(ps, ss)\n      // Disagreement: low or negative correlation between primary proxy\n      // reward and an independent secondary signal.\n      const severity = clamp01(0.5 - Math.max(0, r))\n      findings.push({\n        signal: 'reward_disagreement',\n        severity,\n        message:\n          severity >= sus\n            ? `proxy and independent secondary reward correlate ρ=${r.toFixed(3)} — possibly hacking proxy`\n            : `proxy and secondary reward correlate ρ=${r.toFixed(3)}`,\n        detail: { pearson: r, n: aligned.length },\n      })\n    }\n  }\n\n  // ── Signal 4: judge drift (probabilistic up while deterministic flat) ─\n  {\n    const detRuns = filterDeterministicallyRewarded(runs, input.verifiableRewardOptions ?? {})\n    if (detRuns.length >= 4) {\n      const detBefore = detRuns.slice(0, Math.floor(detRuns.length / 2))\n      const detAfter = detRuns.slice(Math.floor(detRuns.length / 2))\n      const detDelta =\n        mean(detAfter.map((r) => r.reward.value)) - mean(detBefore.map((r) => r.reward.value))\n      const proxyDelta =\n        mean(after.map(proxyOf).filter(finiteNumber)) -\n        mean(before.map(proxyOf).filter(finiteNumber))\n      const driftGap = Math.max(0, proxyDelta - detDelta)\n      const severity = clamp01(driftGap * 5)\n      findings.push({\n        signal: 'judge_drift',\n        severity,\n        message:\n          severity >= sus\n            ? `judge proxy +${proxyDelta.toFixed(3)} while deterministic reward +${detDelta.toFixed(3)} — judge drifting up without verifiable backing`\n            : `judge and deterministic rewards move in step (judge ${proxyDelta.toFixed(3)}, det ${detDelta.toFixed(3)})`,\n        detail: { proxyDelta, detDelta, driftGap, n: detRuns.length },\n      })\n    }\n  }\n\n  const maxSev = findings.reduce((m, f) => Math.max(m, f.severity), 0)\n  if (findings.length === 0) {\n    return {\n      findings,\n      evaluatedSignals: [],\n      verdict: 'insufficient_evidence',\n      rationale: [`no reward-hacking signal had enough paired evidence (n=${n})`],\n      n,\n    }\n  }\n  const verdict: RewardHackingReport['verdict'] =\n    maxSev >= gam ? 'gaming' : maxSev >= sus ? 'suspect' : 'clean'\n  const rationale = findings\n    .filter((f) => f.severity >= sus)\n    .map((f) => `${f.signal}: severity ${f.severity.toFixed(2)} — ${f.message}`)\n  if (rationale.length === 0) rationale.push('no signals fired above suspect threshold')\n\n  return {\n    findings,\n    evaluatedSignals: findings.map((finding) => finding.signal),\n    verdict,\n    rationale,\n    n,\n  }\n}\n\n// ── Helpers ──────────────────────────────────────────────────────────────\n\nfunction mean(xs: number[]): number {\n  if (xs.length === 0) return 0\n  return xs.reduce((s, x) => s + x, 0) / xs.length\n}\n\nfunction finiteNumber(value: number | null): value is number {\n  return typeof value === 'number' && Number.isFinite(value)\n}\n\nfunction clamp01(x: number): number {\n  if (!Number.isFinite(x)) return 0\n  return Math.max(0, Math.min(1, x))\n}\n\nfunction ksStatistic(a: number[], b: number[]): number {\n  // Two-sample Kolmogorov-Smirnov statistic.\n  const sortedA = [...a].sort((x, y) => x - y)\n  const sortedB = [...b].sort((x, y) => x - y)\n  const all = [...new Set([...sortedA, ...sortedB])].sort((x, y) => x - y)\n  let max = 0\n  for (const v of all) {\n    const fa = sortedA.filter((x) => x <= v).length / sortedA.length\n    const fb = sortedB.filter((x) => x <= v).length / sortedB.length\n    max = Math.max(max, Math.abs(fa - fb))\n  }\n  return max\n}\n\nfunction defaultSecondary(\n  verifiableOpts?: VerifiableRewardExtractionOptions,\n): (run: RunRecord) => number | null {\n  return (run: RunRecord) => {\n    const filtered = filterDeterministicallyRewarded([run], verifiableOpts ?? {})\n    return filtered.length === 1 ? filtered[0]!.reward.value : null\n  }\n}\n"],"mappings":"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","names":["clamp01"]}

package/dist/chunk-ONWEPEDO.js

@@ -1,57 +0,0 @@
-// src/errors.ts
-var AgentEvalError = class extends Error {
-  /** Stable string code. Survives minification; safe to switch on. */
-  code;
-  constructor(code, message, options) {
-    super(message, options);
-    this.name = this.constructor.name;
-    this.code = code;
-  }
-};
-var ValidationError = class extends AgentEvalError {
-  constructor(message, options) {
-    super("validation", message, options);
-  }
-};
-var NotFoundError = class extends AgentEvalError {
-  constructor(message, options) {
-    super("not_found", message, options);
-  }
-};
-var ConfigError = class extends AgentEvalError {
-  constructor(message, options) {
-    super("config", message, options);
-  }
-};
-var CaptureIntegrityError = class extends AgentEvalError {
-  constructor(message, options) {
-    super("capture_integrity", message, options);
-  }
-};
-var JudgeError = class extends AgentEvalError {
-  constructor(message, options) {
-    super("judge", message, options);
-  }
-};
-var VerificationError = class extends AgentEvalError {
-  constructor(message, options) {
-    super("verification", message, options);
-  }
-};
-var ReplayError = class extends AgentEvalError {
-  constructor(message, options) {
-    super("replay", message, options);
-  }
-};
-
-export {
-  AgentEvalError,
-  ValidationError,
-  NotFoundError,
-  ConfigError,
-  CaptureIntegrityError,
-  JudgeError,
-  VerificationError,
-  ReplayError
-};
-//# sourceMappingURL=chunk-ONWEPEDO.js.map

package/dist/chunk-ONWEPEDO.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/errors.ts"],"sourcesContent":["/**\n * Error taxonomy for `@tangle-network/agent-eval`.\n *\n * Every error this package throws as part of its *public contract* extends\n * `AgentEvalError`. Consumers can pattern-match by `instanceof <Subclass>` or\n * by the stable string `code` carried on the base class.\n *\n * The codes are stable across minor versions; new codes can be added, but\n * existing codes never change meaning. New subclasses are non-breaking.\n *\n * Internal invariant guards (`throw new Error('this should never happen')`)\n * remain plain `Error`s on purpose — they're programmer-mistake assertions,\n * not consumer-catchable contract failures.\n */\n\nexport type AgentEvalErrorCode =\n  | 'validation'\n  | 'not_found'\n  | 'config'\n  | 'capture_integrity'\n  | 'judge'\n  | 'verification'\n  | 'replay'\n  | 'backend_integrity'\n  | 'profile_matrix'\n\n/**\n * Base class for every contract error this package throws — carries the stable\n * string `code` taxonomy so consumers can `instanceof`-match or switch on `code`.\n */\nexport class AgentEvalError extends Error {\n  /** Stable string code. Survives minification; safe to switch on. */\n  readonly code: AgentEvalErrorCode\n\n  constructor(code: AgentEvalErrorCode, message: string, options?: { cause?: unknown }) {\n    super(message, options)\n    this.name = this.constructor.name\n    this.code = code\n  }\n}\n\n/** Caller passed invalid arguments (out of range, mutually-exclusive options, bad shape). */\nexport class ValidationError extends AgentEvalError {\n  constructor(message: string, options?: { cause?: unknown }) {\n    super('validation', message, options)\n  }\n}\n\n/** A named resource (run, span, rubric, scenario, dataset row, route) does not exist. */\nexport class NotFoundError extends AgentEvalError {\n  constructor(message: string, options?: { cause?: unknown }) {\n    super('not_found', message, options)\n  }\n}\n\n/** Configuration missing or malformed (`HOME` unset, required image not supplied, env var absent). */\nexport class ConfigError extends AgentEvalError {\n  constructor(message: string, options?: { cause?: unknown }) {\n    super('config', message, options)\n  }\n}\n\n/**\n * A run is missing the artifacts a launch-grade check requires:\n * raw HTTP capture absent, no LLM spans, route assertion failed, run-end\n * assertion tripped. Block ship on this; do not catch and move on.\n */\nexport class CaptureIntegrityError extends AgentEvalError {\n  constructor(message: string, options?: { cause?: unknown }) {\n    super('capture_integrity', message, options)\n  }\n}\n\n/** A judge call failed in a way that's not retryable: schema parse failure, bad rubric, conflicting dimensions. */\nexport class JudgeError extends AgentEvalError {\n  constructor(message: string, options?: { cause?: unknown }) {\n    super('judge', message, options)\n  }\n}\n\n/** A verifier signalled a hard failure (compile, test, schema) — distinct from a low judge score. */\nexport class VerificationError extends AgentEvalError {\n  constructor(message: string, options?: { cause?: unknown }) {\n    super('verification', message, options)\n  }\n}\n\n/** Replay cache cannot satisfy a request: miss with no fallback, sink lacks list(), unsupported URL. */\nexport class ReplayError extends AgentEvalError {\n  constructor(message: string, options?: { cause?: unknown }) {\n    super('replay', message, options)\n  }\n}\n"],"mappings":";AA8BO,IAAM,iBAAN,cAA6B,MAAM;AAAA;AAAA,EAE/B;AAAA,EAET,YAAY,MAA0B,SAAiB,SAA+B;AACpF,UAAM,SAAS,OAAO;AACtB,SAAK,OAAO,KAAK,YAAY;AAC7B,SAAK,OAAO;AAAA,EACd;AACF;AAGO,IAAM,kBAAN,cAA8B,eAAe;AAAA,EAClD,YAAY,SAAiB,SAA+B;AAC1D,UAAM,cAAc,SAAS,OAAO;AAAA,EACtC;AACF;AAGO,IAAM,gBAAN,cAA4B,eAAe;AAAA,EAChD,YAAY,SAAiB,SAA+B;AAC1D,UAAM,aAAa,SAAS,OAAO;AAAA,EACrC;AACF;AAGO,IAAM,cAAN,cAA0B,eAAe;AAAA,EAC9C,YAAY,SAAiB,SAA+B;AAC1D,UAAM,UAAU,SAAS,OAAO;AAAA,EAClC;AACF;AAOO,IAAM,wBAAN,cAAoC,eAAe;AAAA,EACxD,YAAY,SAAiB,SAA+B;AAC1D,UAAM,qBAAqB,SAAS,OAAO;AAAA,EAC7C;AACF;AAGO,IAAM,aAAN,cAAyB,eAAe;AAAA,EAC7C,YAAY,SAAiB,SAA+B;AAC1D,UAAM,SAAS,SAAS,OAAO;AAAA,EACjC;AACF;AAGO,IAAM,oBAAN,cAAgC,eAAe;AAAA,EACpD,YAAY,SAAiB,SAA+B;AAC1D,UAAM,gBAAgB,SAAS,OAAO;AAAA,EACxC;AACF;AAGO,IAAM,cAAN,cAA0B,eAAe;AAAA,EAC9C,YAAY,SAAiB,SAA+B;AAC1D,UAAM,UAAU,SAAS,OAAO;AAAA,EAClC;AACF;","names":[]}