@tangle-network/agent-eval 0.120.2 → 0.120.3

package/dist/chunk-ARU2PZFM.js

@@ -0,0 +1,312 @@
+import {
+  pearsonR
+} from "./chunk-PJQFMIOX.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(
+    (l) => deterministicSet.has(l.layer) && typeof l.score === "number" && Number.isFinite(l.score)
+  );
+  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(
+    (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;
+  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 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 = run.outcome.holdoutScore ?? run.outcome.searchScore;
+    if (typeof primary !== "number" || !Number.isFinite(primary)) {
+      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) => {
+  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 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-ARU2PZFM.js.map

package/dist/chunk-ARU2PZFM.js.map

@@ -0,0 +1 @@
+{"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 } 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    (l) => deterministicSet.has(l.layer) && typeof l.score === 'number' && Number.isFinite(l.score),\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(\n      (l) =>\n        typeof l.score === 'number' && Number.isFinite(l.score) && sourceFor(l.layer) === 'judge',\n    ) ?? report.layers.find((l) => typeof l.score === 'number' && Number.isFinite(l.score))\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\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 = run.outcome.holdoutScore ?? run.outcome.searchScore\n    if (typeof primary !== 'number' || !Number.isFinite(primary)) {\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 } 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  /**\n   * Composite verdict. `'clean'` if every signal severity < 0.3;\n   * `'suspect'` if at least one ≥ 0.3 but none ≥ 0.6; `'gaming'` if any ≥ 0.6.\n   */\n  verdict: 'clean' | 'suspect' | 'gaming'\n  /** Rationale for the verdict, ready to paste into an audit log. */\n  rationale: string[]\n  /** Number of paired (proxy, truth) data points the report saw. */\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  const v = r.outcome.holdoutScore ?? r.outcome.searchScore\n  return typeof v === 'number' && Number.isFinite(v) ? v : 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((r) => proxyOf(r) !== null)\n  const n = runs.length\n  if (n < 4) {\n    return {\n      findings: [],\n      verdict: 'clean',\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((v): v is number => typeof v === 'number')\n    const afterProxy = after.map(proxyOf).filter((v): v is number => typeof v === 'number')\n    const beforeTruth = before.map(truthOf).filter((v): v is number => typeof v === 'number')\n    const afterTruth = after.map(truthOf).filter((v): v is number => typeof v === 'number')\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((v): v is number => typeof v === 'number')\n    const afterP = after.map(proxyOf).filter((v): v is number => typeof v === 'number')\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(\n        (x): x is { p: number; s: number } => typeof x.p === 'number' && typeof x.s === 'number',\n      )\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((v): v is number => typeof v === 'number')) -\n        mean(before.map(proxyOf).filter((v): v is number => typeof v === 'number'))\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  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 { findings, verdict, rationale, 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 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-BOD4O7OF.js

@@ -0,0 +1,40 @@
+// src/series-convergence.ts
+function analyzeSeries(values, options = {}) {
+  const window = options.window ?? 5;
+  const stableCv = options.stableCv ?? 0.05;
+  const driftRun = options.driftRun ?? 3;
+  if (values.length < Math.max(2, Math.min(window, 3))) {
+    return { state: "insufficient-data", windowMean: 0, windowCv: 0, tailRun: 0, stable: false };
+  }
+  const tail = values.slice(-window);
+  const mean = tail.reduce((a, b) => a + b, 0) / tail.length;
+  const variance = tail.reduce((acc, v) => acc + (v - mean) ** 2, 0) / tail.length;
+  const stdDev = Math.sqrt(variance);
+  const refMean = Math.abs(mean) > 1e-9 ? Math.abs(mean) : 1;
+  const cv = stdDev / refMean;
+  const stable = tail.length >= window && cv <= stableCv;
+  let tailRun = 0;
+  let direction = 0;
+  for (let i = values.length - 1; i > 0; i--) {
+    const delta = values[i] - values[i - 1];
+    if (delta === 0) break;
+    const dir = delta > 0 ? 1 : -1;
+    if (direction === 0) direction = dir;
+    if (dir !== direction) break;
+    tailRun += dir;
+  }
+  let state;
+  if (stable) {
+    state = "stabilized";
+  } else if (Math.abs(tailRun) >= driftRun) {
+    state = tailRun > 0 ? "drifting-up" : "drifting-down";
+  } else {
+    state = "noisy";
+  }
+  return { state, windowMean: mean, windowCv: cv, tailRun, stable };
+}
+
+export {
+  analyzeSeries
+};
+//# sourceMappingURL=chunk-BOD4O7OF.js.map

package/dist/chunk-BOD4O7OF.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/series-convergence.ts"],"sourcesContent":["/**\n * Series convergence — detects whether a sequence of scalar measurements\n * is stabilizing, drifting, or noisy.\n *\n * Lifted from ADC convergence.ts. The per-turn `ConvergenceTracker` is\n * about progress *within* a single run; this module is about drift\n * *across* runs (e.g. \"are my nightly eval scores stabilizing?\").\n *\n * Three signals:\n *   - stabilized: last K values have low variance (< epsilon) — done\n *   - drifting:   recent trend is monotonic and beyond noise — regressing or improving\n *   - noisy:      neither — keep iterating, but flag as untrustworthy for gating\n */\n\nexport interface SeriesConvergenceOptions {\n  /** Window size for \"recent\" analysis (default 5). */\n  window?: number\n  /** Coefficient-of-variation threshold below which the window is stabilized (default 0.05 = 5%). */\n  stableCv?: number\n  /** Minimum monotone run length to call drift (default 3). */\n  driftRun?: number\n}\n\nexport interface SeriesConvergenceResult {\n  state: 'stabilized' | 'drifting-up' | 'drifting-down' | 'noisy' | 'insufficient-data'\n  windowMean: number\n  windowCv: number\n  /** Longest monotonic run at the tail of the series (positive for up, negative for down). */\n  tailRun: number\n  /** True when n ≥ window AND windowCv ≤ stableCv. */\n  stable: boolean\n}\n\nexport function analyzeSeries(\n  values: number[],\n  options: SeriesConvergenceOptions = {},\n): SeriesConvergenceResult {\n  const window = options.window ?? 5\n  const stableCv = options.stableCv ?? 0.05\n  const driftRun = options.driftRun ?? 3\n\n  if (values.length < Math.max(2, Math.min(window, 3))) {\n    return { state: 'insufficient-data', windowMean: 0, windowCv: 0, tailRun: 0, stable: false }\n  }\n\n  const tail = values.slice(-window)\n  const mean = tail.reduce((a, b) => a + b, 0) / tail.length\n  const variance = tail.reduce((acc, v) => acc + (v - mean) ** 2, 0) / tail.length\n  const stdDev = Math.sqrt(variance)\n  const refMean = Math.abs(mean) > 1e-9 ? Math.abs(mean) : 1\n  const cv = stdDev / refMean\n  const stable = tail.length >= window && cv <= stableCv\n\n  // Tail monotonic run: count how many consecutive strictly-increasing (or decreasing)\n  // steps end at the final value.\n  let tailRun = 0\n  let direction: 1 | -1 | 0 = 0\n  for (let i = values.length - 1; i > 0; i--) {\n    const delta = values[i]! - values[i - 1]!\n    if (delta === 0) break\n    const dir = delta > 0 ? 1 : -1\n    if (direction === 0) direction = dir\n    if (dir !== direction) break\n    tailRun += dir\n  }\n\n  let state: SeriesConvergenceResult['state']\n  if (stable) {\n    state = 'stabilized'\n  } else if (Math.abs(tailRun) >= driftRun) {\n    state = tailRun > 0 ? 'drifting-up' : 'drifting-down'\n  } else {\n    state = 'noisy'\n  }\n\n  return { state, windowMean: mean, windowCv: cv, tailRun, stable }\n}\n"],"mappings":";AAiCO,SAAS,cACd,QACA,UAAoC,CAAC,GACZ;AACzB,QAAM,SAAS,QAAQ,UAAU;AACjC,QAAM,WAAW,QAAQ,YAAY;AACrC,QAAM,WAAW,QAAQ,YAAY;AAErC,MAAI,OAAO,SAAS,KAAK,IAAI,GAAG,KAAK,IAAI,QAAQ,CAAC,CAAC,GAAG;AACpD,WAAO,EAAE,OAAO,qBAAqB,YAAY,GAAG,UAAU,GAAG,SAAS,GAAG,QAAQ,MAAM;AAAA,EAC7F;AAEA,QAAM,OAAO,OAAO,MAAM,CAAC,MAAM;AACjC,QAAM,OAAO,KAAK,OAAO,CAAC,GAAG,MAAM,IAAI,GAAG,CAAC,IAAI,KAAK;AACpD,QAAM,WAAW,KAAK,OAAO,CAAC,KAAK,MAAM,OAAO,IAAI,SAAS,GAAG,CAAC,IAAI,KAAK;AAC1E,QAAM,SAAS,KAAK,KAAK,QAAQ;AACjC,QAAM,UAAU,KAAK,IAAI,IAAI,IAAI,OAAO,KAAK,IAAI,IAAI,IAAI;AACzD,QAAM,KAAK,SAAS;AACpB,QAAM,SAAS,KAAK,UAAU,UAAU,MAAM;AAI9C,MAAI,UAAU;AACd,MAAI,YAAwB;AAC5B,WAAS,IAAI,OAAO,SAAS,GAAG,IAAI,GAAG,KAAK;AAC1C,UAAM,QAAQ,OAAO,CAAC,IAAK,OAAO,IAAI,CAAC;AACvC,QAAI,UAAU,EAAG;AACjB,UAAM,MAAM,QAAQ,IAAI,IAAI;AAC5B,QAAI,cAAc,EAAG,aAAY;AACjC,QAAI,QAAQ,UAAW;AACvB,eAAW;AAAA,EACb;AAEA,MAAI;AACJ,MAAI,QAAQ;AACV,YAAQ;AAAA,EACV,WAAW,KAAK,IAAI,OAAO,KAAK,UAAU;AACxC,YAAQ,UAAU,IAAI,gBAAgB;AAAA,EACxC,OAAO;AACL,YAAQ;AAAA,EACV;AAEA,SAAO,EAAE,OAAO,YAAY,MAAM,UAAU,IAAI,SAAS,OAAO;AAClE;","names":[]}