@tangle-network/agent-eval 0.38.0 → 0.40.2

package/dist/chunk-YV7J7X5N.js

@@ -0,0 +1,313 @@
+// src/rl/verifiable-reward.ts
+var DEFAULT_DETERMINISTIC_LAYERS = /* @__PURE__ */ new Set([
+  "install",
+  "typecheck",
+  "build",
+  "lint",
+  "test",
+  "compile",
+  "schema",
+  "sandbox",
+  "unit_tests",
+  "integration_tests"
+]);
+var DEFAULT_SOURCE_FOR = (name) => {
+  const lower = name.toLowerCase();
+  if (lower.includes("test")) return "test";
+  if (lower.includes("compile") || lower.includes("build") || lower.includes("typecheck") || lower.includes("lint"))
+    return "compile";
+  if (lower.includes("schema")) return "schema";
+  if (lower.includes("sandbox")) return "sandbox";
+  if (lower.includes("judge") || lower.includes("semantic")) return "judge";
+  return "composite";
+};
+function extractVerifiableReward(report, opts = {}) {
+  const deterministicSet = new Set(opts.deterministicLayers ?? [...DEFAULT_DETERMINISTIC_LAYERS]);
+  const sourceFor = opts.sourceFor ?? DEFAULT_SOURCE_FOR;
+  const fallbackToJudge = opts.fallbackToJudge ?? true;
+  const judgeFloor = opts.judgeConfidenceFloor ?? 0.7;
+  const deterministic = report.layers.filter(
+    (l) => deterministicSet.has(l.layer) && typeof l.score === "number" && Number.isFinite(l.score)
+  );
+  if (deterministic.length === 1) {
+    const layer = deterministic[0];
+    return {
+      value: clamp01(layer.score),
+      source: sourceFor(layer.layer),
+      determinism: "deterministic",
+      confidence: 1,
+      origin: layer.layer,
+      breakdown: layerBreakdown(layer)
+    };
+  }
+  if (deterministic.length > 1) {
+    let num = 0;
+    let denom = 0;
+    const breakdown = {};
+    for (const l of deterministic) {
+      const w = l.detail?.weight ?? 1;
+      num += w * (l.score ?? 0);
+      denom += w;
+      breakdown[l.layer] = l.score;
+    }
+    return {
+      value: denom === 0 ? 0 : clamp01(num / denom),
+      source: "composite",
+      determinism: "deterministic",
+      confidence: 1,
+      origin: deterministic.map((l) => l.layer).join("+"),
+      breakdown
+    };
+  }
+  if (!fallbackToJudge) return null;
+  const judge = report.layers.find(
+    (l) => typeof l.score === "number" && Number.isFinite(l.score) && sourceFor(l.layer) === "judge"
+  ) ?? report.layers.find((l) => typeof l.score === "number" && Number.isFinite(l.score));
+  if (!judge) return null;
+  const confFromDetail = judge.detail?.confidence;
+  return {
+    value: clamp01(judge.score),
+    source: "judge",
+    determinism: "probabilistic",
+    confidence: typeof confFromDetail === "number" ? confFromDetail : judgeFloor,
+    origin: judge.layer,
+    breakdown: layerBreakdown(judge)
+  };
+}
+function extractVerifiableRewardsFromRecords(runs, opts = {}) {
+  const sourceFor = opts.sourceFor ?? DEFAULT_SOURCE_FOR;
+  const deterministicSet = new Set(opts.deterministicLayers ?? [...DEFAULT_DETERMINISTIC_LAYERS]);
+  const fallbackToJudge = opts.fallbackToJudge ?? true;
+  const judgeFloor = opts.judgeConfidenceFloor ?? 0.7;
+  return runs.map((run) => {
+    const layerScores = [];
+    for (const [k, v] of Object.entries(run.outcome.raw)) {
+      if (k.startsWith("layer.") && !k.includes(".", 6) && typeof v === "number" && Number.isFinite(v)) {
+        layerScores.push({ name: k.slice("layer.".length), score: v });
+      }
+    }
+    const det = layerScores.filter((l) => deterministicSet.has(l.name));
+    if (det.length === 1) {
+      const layer = det[0];
+      return {
+        runId: run.runId,
+        reward: {
+          value: clamp01(layer.score),
+          source: sourceFor(layer.name),
+          determinism: "deterministic",
+          confidence: 1,
+          origin: layer.name
+        }
+      };
+    }
+    if (det.length > 1) {
+      const value = det.reduce((s, l) => s + l.score, 0) / det.length;
+      const breakdown = Object.fromEntries(
+        det.map((l) => [l.name, l.score])
+      );
+      return {
+        runId: run.runId,
+        reward: {
+          value: clamp01(value),
+          source: "composite",
+          determinism: "deterministic",
+          confidence: 1,
+          origin: det.map((l) => l.name).join("+"),
+          breakdown
+        }
+      };
+    }
+    if (!fallbackToJudge) return { runId: run.runId, reward: null };
+    const primary = run.outcome.holdoutScore ?? run.outcome.searchScore;
+    if (typeof primary !== "number" || !Number.isFinite(primary)) {
+      return { runId: run.runId, reward: null };
+    }
+    return {
+      runId: run.runId,
+      reward: {
+        value: clamp01(primary),
+        source: "judge",
+        determinism: "probabilistic",
+        confidence: judgeFloor,
+        origin: "run.outcome.score"
+      }
+    };
+  });
+}
+function filterDeterministicallyRewarded(runs, opts = {}) {
+  const rewarded = extractVerifiableRewardsFromRecords(runs, { ...opts, fallbackToJudge: false });
+  const out = [];
+  for (let i = 0; i < runs.length; i++) {
+    const r = rewarded[i];
+    if (r.reward && r.reward.determinism === "deterministic") {
+      out.push({ run: runs[i], reward: r.reward });
+    }
+  }
+  return out;
+}
+function clamp01(x) {
+  if (!Number.isFinite(x)) return 0;
+  return Math.max(0, Math.min(1, x));
+}
+function layerBreakdown(l) {
+  const out = {};
+  if (l.diagnostics) {
+    for (const [k, v] of Object.entries(l.diagnostics)) {
+      if (typeof v === "number" && Number.isFinite(v)) out[k] = v;
+    }
+  }
+  return out;
+}
+
+// src/rl/reward-hacking.ts
+var DEFAULT_PROXY = (r) => {
+  const v = r.outcome.holdoutScore ?? r.outcome.searchScore;
+  return typeof v === "number" && Number.isFinite(v) ? v : null;
+};
+function detectRewardHacking(input) {
+  const proxyOf = input.proxyOf ?? DEFAULT_PROXY;
+  const truthOf = input.truthOf;
+  const sus = input.thresholds?.suspect ?? 0.3;
+  const gam = input.thresholds?.gaming ?? 0.6;
+  const runs = input.runs.filter((r) => proxyOf(r) !== null);
+  const n = runs.length;
+  if (n < 4) {
+    return {
+      findings: [],
+      verdict: "clean",
+      n,
+      rationale: [`fewer than 4 runs with proxy reward (n=${n}); insufficient evidence`]
+    };
+  }
+  const windowSize = Math.max(1, input.windowSize ?? Math.min(50, Math.floor(n / 2)));
+  const before = runs.slice(0, n - windowSize);
+  const after = runs.slice(n - windowSize);
+  const findings = [];
+  if (truthOf) {
+    const beforeProxy = before.map(proxyOf).filter((v) => typeof v === "number");
+    const afterProxy = after.map(proxyOf).filter((v) => typeof v === "number");
+    const beforeTruth = before.map(truthOf).filter((v) => typeof v === "number");
+    const afterTruth = after.map(truthOf).filter((v) => typeof v === "number");
+    if (beforeProxy.length >= 2 && afterProxy.length >= 2 && beforeTruth.length >= 2 && afterTruth.length >= 2) {
+      const proxyDelta = mean(afterProxy) - mean(beforeProxy);
+      const truthDelta = mean(afterTruth) - mean(beforeTruth);
+      const gap = Math.max(0, proxyDelta - truthDelta);
+      const severity = clamp012(gap * 5);
+      findings.push({
+        signal: "reward_divergence",
+        severity,
+        message: severity >= sus ? `proxy reward rose by ${proxyDelta.toFixed(3)} while truth changed by ${truthDelta.toFixed(3)} \u2014 potential Goodhart` : `proxy and truth moved together (proxy ${proxyDelta.toFixed(3)}, truth ${truthDelta.toFixed(3)})`,
+        detail: {
+          proxyDelta,
+          truthDelta,
+          gap,
+          beforeN: beforeProxy.length,
+          afterN: afterProxy.length
+        }
+      });
+    }
+  }
+  {
+    const beforeP = before.map(proxyOf).filter((v) => typeof v === "number");
+    const afterP = after.map(proxyOf).filter((v) => typeof v === "number");
+    if (beforeP.length >= 4 && afterP.length >= 4) {
+      const ks = ksStatistic(beforeP, afterP);
+      const severity = clamp012(ks - 0.2);
+      findings.push({
+        signal: "distribution_shift",
+        severity,
+        message: severity >= sus ? `KS=${ks.toFixed(3)} between before/after windows \u2014 distributional shift large` : `KS=${ks.toFixed(3)} between before/after windows \u2014 within-distribution drift`,
+        detail: { ks, beforeN: beforeP.length, afterN: afterP.length }
+      });
+    }
+  }
+  {
+    const secondaryOf = input.secondaryRewardOf ?? defaultSecondary(input.verifiableRewardOptions);
+    const aligned = runs.map((r) => ({ p: proxyOf(r), s: secondaryOf(r) })).filter(
+      (x) => typeof x.p === "number" && typeof x.s === "number"
+    );
+    if (aligned.length >= 4) {
+      const ps = aligned.map((x) => x.p);
+      const ss = aligned.map((x) => x.s);
+      const r = pearsonR(ps, ss);
+      const severity = clamp012(0.5 - Math.max(0, r));
+      findings.push({
+        signal: "reward_disagreement",
+        severity,
+        message: severity >= sus ? `proxy and independent secondary reward correlate \u03C1=${r.toFixed(3)} \u2014 possibly hacking proxy` : `proxy and secondary reward correlate \u03C1=${r.toFixed(3)}`,
+        detail: { pearson: r, n: aligned.length }
+      });
+    }
+  }
+  {
+    const detRuns = filterDeterministicallyRewarded(runs, input.verifiableRewardOptions ?? {});
+    if (detRuns.length >= 4) {
+      const detBefore = detRuns.slice(0, Math.floor(detRuns.length / 2));
+      const detAfter = detRuns.slice(Math.floor(detRuns.length / 2));
+      const detDelta = mean(detAfter.map((r) => r.reward.value)) - mean(detBefore.map((r) => r.reward.value));
+      const proxyDelta = mean(after.map(proxyOf).filter((v) => typeof v === "number")) - mean(before.map(proxyOf).filter((v) => typeof v === "number"));
+      const driftGap = Math.max(0, proxyDelta - detDelta);
+      const severity = clamp012(driftGap * 5);
+      findings.push({
+        signal: "judge_drift",
+        severity,
+        message: severity >= sus ? `judge proxy +${proxyDelta.toFixed(3)} while deterministic reward +${detDelta.toFixed(3)} \u2014 judge drifting up without verifiable backing` : `judge and deterministic rewards move in step (judge ${proxyDelta.toFixed(3)}, det ${detDelta.toFixed(3)})`,
+        detail: { proxyDelta, detDelta, driftGap, n: detRuns.length }
+      });
+    }
+  }
+  const maxSev = findings.reduce((m, f) => Math.max(m, f.severity), 0);
+  const verdict = maxSev >= gam ? "gaming" : maxSev >= sus ? "suspect" : "clean";
+  const rationale = findings.filter((f) => f.severity >= sus).map((f) => `${f.signal}: severity ${f.severity.toFixed(2)} \u2014 ${f.message}`);
+  if (rationale.length === 0) rationale.push("no signals fired above suspect threshold");
+  return { findings, verdict, rationale, n };
+}
+function mean(xs) {
+  if (xs.length === 0) return 0;
+  return xs.reduce((s, x) => s + x, 0) / xs.length;
+}
+function clamp012(x) {
+  if (!Number.isFinite(x)) return 0;
+  return Math.max(0, Math.min(1, x));
+}
+function pearsonR(a, b) {
+  if (a.length !== b.length || a.length < 2) return 0;
+  const ma = mean(a);
+  const mb = mean(b);
+  let num = 0, da = 0, db = 0;
+  for (let i = 0; i < a.length; i++) {
+    const xa = a[i] - ma;
+    const xb = b[i] - mb;
+    num += xa * xb;
+    da += xa * xa;
+    db += xb * xb;
+  }
+  if (da === 0 || db === 0) return 0;
+  return num / Math.sqrt(da * db);
+}
+function ksStatistic(a, b) {
+  const sortedA = [...a].sort((x, y) => x - y);
+  const sortedB = [...b].sort((x, y) => x - y);
+  const all = [.../* @__PURE__ */ new Set([...sortedA, ...sortedB])].sort((x, y) => x - y);
+  let max = 0;
+  for (const v of all) {
+    const fa = sortedA.filter((x) => x <= v).length / sortedA.length;
+    const fb = sortedB.filter((x) => x <= v).length / sortedB.length;
+    max = Math.max(max, Math.abs(fa - fb));
+  }
+  return max;
+}
+function defaultSecondary(verifiableOpts) {
+  return (run) => {
+    const filtered = filterDeterministicallyRewarded([run], verifiableOpts ?? {});
+    return filtered.length === 1 ? filtered[0].reward.value : null;
+  };
+}
+
+export {
+  extractVerifiableReward,
+  extractVerifiableRewardsFromRecords,
+  filterDeterministicallyRewarded,
+  detectRewardHacking
+};
+//# sourceMappingURL=chunk-YV7J7X5N.js.map

package/dist/chunk-YV7J7X5N.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   * Any per-source breakdown the consumer might want — e.g. `{ tests_passed: 7, tests_total: 10 }`.\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    return {\n      value: clamp01(layer.score!),\n      source: sourceFor(layer.layer),\n      determinism: 'deterministic',\n      confidence: 1,\n      origin: layer.layer,\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 breakdown: 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      breakdown[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      breakdown,\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  return {\n    value: clamp01(judge.score!),\n    source: 'judge',\n    determinism: 'probabilistic',\n    confidence: typeof confFromDetail === 'number' ? confFromDetail : judgeFloor,\n    origin: judge.layer,\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      return {\n        runId: run.runId,\n        reward: {\n          value: clamp01(layer.score),\n          source: sourceFor(layer.name),\n          determinism: 'deterministic',\n          confidence: 1,\n          origin: layer.name,\n        },\n      }\n    }\n    if (det.length > 1) {\n      const value = det.reduce((s, l) => s + l.score, 0) / det.length\n      const breakdown: 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          breakdown,\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    return {\n      runId: run.runId,\n      reward: {\n        value: clamp01(primary),\n        source: 'judge',\n        determinism: 'probabilistic',\n        confidence: judgeFloor,\n        origin: 'run.outcome.score',\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 {\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 pearsonR(a: number[], b: number[]): number {\n  if (a.length !== b.length || a.length < 2) return 0\n  const ma = mean(a)\n  const mb = mean(b)\n  let num = 0,\n    da = 0,\n    db = 0\n  for (let i = 0; i < a.length; i++) {\n    const xa = a[i]! - ma\n    const xb = b[i]! - mb\n    num += xa * xb\n    da += xa * xa\n    db += xb * xb\n  }\n  if (da === 0 || db === 0) return 0\n  return num / Math.sqrt(da * db)\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/{control-DVrmvM_k.d.ts → control-CmLJk3IG.d.ts}

@@ -1,4 +1,4 @@
-import { b as FeedbackLabel, p as ProposedSideEffect } from './feedback-trajectory-iATEAHmc.js';
+import { b as FeedbackLabel, p as ProposedSideEffect } from './feedback-trajectory-Dvy-bt7x.js';
 import { C as ControlEvalResult, a as ControlRunResult, h as ControlRuntimeConfig } from './control-runtime-BZ_lVLYW.js';
 import { T as TraceEmitter } from './emitter-DP_cSSiw.js';
 import { T as TraceStore, F as FailureClass } from './store-Db2Bv8Cf.js';

package/dist/control.d.ts

@@ -1,7 +1,7 @@
-export { A as ActionExecutionPolicy, a as ActionPolicyDecision, C as ControlRunToRunRecordOptions, e as ProposeReviewConfig, f as ProposeReviewControlAction, g as ProposeReviewControlConfig, h as ProposeReviewControlResult, i as ProposeReviewControlState, j as ProposeReviewReport, p as RunEvidenceMetadata, s as controlRunToRunRecord, u as evaluateActionPolicy, x as runProposeReview, y as runProposeReviewAsControlLoop, z as scoreFromEvals } from './control-DVrmvM_k.js';
+export { A as ActionExecutionPolicy, a as ActionPolicyDecision, C as ControlRunToRunRecordOptions, e as ProposeReviewConfig, f as ProposeReviewControlAction, g as ProposeReviewControlConfig, h as ProposeReviewControlResult, i as ProposeReviewControlState, j as ProposeReviewReport, p as RunEvidenceMetadata, s as controlRunToRunRecord, u as evaluateActionPolicy, x as runProposeReview, y as runProposeReviewAsControlLoop, z as scoreFromEvals } from './control-CmLJk3IG.js';
 export { c as ControlActionFailureMode, d as ControlActionOutcome, e as ControlBudget, f as ControlContext, g as ControlDecision, C as ControlEvalResult, a as ControlRunResult, h as ControlRuntimeConfig, i as ControlRuntimeError, j as ControlSeverity, b as ControlStep, k as ControlStopPolicies, S as StopDecision, l as allCriticalPassed, o as objectiveEval, r as runAgentControlLoop, s as stopOnNoProgress, m as stopOnRepeatedAction, n as subjectiveEval } from './control-runtime-BZ_lVLYW.js';
-import './feedback-trajectory-iATEAHmc.js';
-import './dataset-ueRVTUoY.js';
+import './feedback-trajectory-Dvy-bt7x.js';
+import './dataset-BlwAtYYf.js';
 import './errors-mje_cKOs.js';
 import './emitter-DP_cSSiw.js';
 import './store-Db2Bv8Cf.js';

package/dist/control.js

@@ -4,7 +4,7 @@ import {
   runProposeReview,
   runProposeReviewAsControlLoop,
   scoreFromEvals
-} from "./chunk-7PR3WPWE.js";
+} from "./chunk-L7XMNXLO.js";
 import {
   allCriticalPassed,
   objectiveEval,
@@ -13,7 +13,7 @@ import {
   stopOnRepeatedAction,
   subjectiveEval
 } from "./chunk-NCRFYPS3.js";
-import "./chunk-TSPOEDM3.js";
+import "./chunk-BWZEGTES.js";
 import "./chunk-TVVP3ZZQ.js";
 import "./chunk-VSMTAMNK.js";
 import "./chunk-QYJT52YW.js";

package/dist/{dataset-ueRVTUoY.d.ts → dataset-BlwAtYYf.d.ts}

@@ -112,4 +112,4 @@ declare class Dataset {
 }
 declare function hashScenarios(scenarios: DatasetScenario[]): Promise<string>;
 
-export { type DatasetSplit as D, HoldoutLockedError as H, type SliceOptions as S, type DatasetScenario as a, type DatasetManifest as b, Dataset as c, type DatasetDifficulty as d, type DatasetProvenance as e, hashScenarios as h };
+export { type DatasetSplit as D, HoldoutLockedError as H, type SliceOptions as S, type DatasetScenario as a, Dataset as b, type DatasetManifest as c, type DatasetDifficulty as d, type DatasetProvenance as e, hashScenarios as h };

package/dist/{feedback-trajectory-iATEAHmc.d.ts → feedback-trajectory-Dvy-bt7x.d.ts}

@@ -1,5 +1,5 @@
 import { C as ControlEvalResult, a as ControlRunResult, b as ControlStep } from './control-runtime-BZ_lVLYW.js';
-import { D as DatasetSplit, a as DatasetScenario } from './dataset-ueRVTUoY.js';
+import { D as DatasetSplit, a as DatasetScenario } from './dataset-BlwAtYYf.js';
 
 type FeedbackArtifactType = 'text' | 'code' | 'plan' | 'research' | 'action' | 'ui' | 'decision' | 'data' | 'other';
 type FeedbackLabelSource = 'user' | 'judge' | 'environment' | 'metric' | 'policy' | 'system';

package/dist/governance/index.d.ts

@@ -1,6 +1,134 @@
-export { E as EuRiskClass, G as GovernanceContext, a as GovernanceFinding, b as GovernanceReport, U as UseCaseSignals, g as classifyEuAiRisk, h as euAiActReport, n as nistAiRmfReport, j as renderMarkdown, k as soc2Report, l as summarize } from '../index-CN2agEaO.js';
-import '../dataset-ueRVTUoY.js';
+import { c as DatasetManifest } from '../dataset-BlwAtYYf.js';
+import { b as CalibrationResult } from '../judge-calibration-DilmB3Ml.js';
+import { O as OutcomeStore } from '../outcome-store-D6KWmYvj.js';
+import { d as RedTeamReport } from '../red-team-30II1T4o.js';
+import { T as TraceStore } from '../store-Db2Bv8Cf.js';
 import '../errors-mje_cKOs.js';
-import '../judge-calibration-DilmB3Ml.js';
-import '../outcome-store-D6KWmYvj.js';
-import '../store-Db2Bv8Cf.js';
+
+/**
+ * Governance reporting — shared types.
+ *
+ * The framework collects a `GovernanceContext` (traces + outcomes +
+ * dataset manifests + red-team results + judge calibration) and each
+ * specific template (NIST AI RMF, SOC2, EU AI Act) renders a
+ * structured report from it.
+ *
+ * Reports are machine-readable JSON first; human-readable Markdown is a
+ * pure transform on top. External auditors consume the Markdown; CI
+ * consumes the JSON.
+ */
+
+interface GovernanceContext {
+    /** Legal / org identity for the report. */
+    organization: string;
+    /** System / agent identifier. */
+    systemName: string;
+    /** ISO8601 period the report covers. */
+    periodStart: string;
+    periodEnd: string;
+    /** Versioned dataset manifests used during the period. */
+    datasets: DatasetManifest[];
+    traceStore: TraceStore;
+    outcomeStore?: OutcomeStore;
+    /** Cached red-team results for the period, if available. */
+    redTeam?: RedTeamReport;
+    /** Judge-vs-human calibration results, if measured. */
+    judgeCalibration?: CalibrationResult[];
+    /** Responsible owner for the system — role + name + email. */
+    owner: {
+        role: string;
+        name: string;
+        email: string;
+    };
+}
+interface GovernanceFinding {
+    id: string;
+    severity: 'info' | 'low' | 'medium' | 'high' | 'critical';
+    /** Control reference the finding maps to (e.g. "NIST-AI-RMF:MEASURE-2.1"). */
+    control: string;
+    summary: string;
+    evidence?: string;
+    remediation?: string;
+}
+interface GovernanceReport {
+    framework: 'NIST-AI-RMF' | 'SOC2' | 'EU-AI-ACT';
+    version: string;
+    context: Pick<GovernanceContext, 'organization' | 'systemName' | 'periodStart' | 'periodEnd' | 'owner'>;
+    summary: {
+        findings: number;
+        byeverity: Record<GovernanceFinding['severity'], number>;
+        overall: 'compliant' | 'compliant-with-findings' | 'non-compliant';
+    };
+    findings: GovernanceFinding[];
+    /** Framework-specific structured payload (mapped controls, risk class, etc.). */
+    payload: Record<string, unknown>;
+    generatedAt: string;
+}
+declare function renderMarkdown(report: GovernanceReport): string;
+declare function summarize(findings: GovernanceFinding[]): GovernanceReport['summary'];
+
+/**
+ * EU AI Act — risk-class classification + compliance checklist.
+ *
+ * Classification is declarative: caller supplies the domain/use-case
+ * signals (biometric? critical infrastructure? education? employment?
+ * access to services?) and we map to the Act's risk tiers:
+ *   - "unacceptable" (prohibited)
+ *   - "high"        (Annex III — strict obligations)
+ *   - "limited"     (transparency obligations)
+ *   - "minimal"     (voluntary codes of conduct)
+ *
+ * Then the compliance checklist enumerates Article 9 (risk mgmt),
+ * 10 (data + data governance), 11 (technical documentation), 13
+ * (transparency), 14 (human oversight), 15 (accuracy + robustness)
+ * requirements and flags gaps.
+ */
+
+type EuRiskClass = 'unacceptable' | 'high' | 'limited' | 'minimal';
+interface UseCaseSignals {
+    /** Used for biometric identification in public spaces? (Art. 5 — unacceptable). */
+    biometricPublic?: boolean;
+    /** Social scoring by public authorities? (Art. 5). */
+    socialScoring?: boolean;
+    /** Subliminal manipulation? (Art. 5). */
+    subliminal?: boolean;
+    /** Annex III sector: critical infrastructure / education / employment /
+     *  access to essential services / law enforcement / migration /
+     *  administration of justice / democratic processes? */
+    annexIII?: boolean;
+    /** Interacts directly with natural persons (chatbot, agent)? — limited risk. */
+    chatbot?: boolean;
+    /** Generates synthetic media (image/audio/video/text deepfakes)? — limited risk. */
+    generatesSyntheticMedia?: boolean;
+}
+declare function classifyEuAiRisk(signals: UseCaseSignals): EuRiskClass;
+declare function euAiActReport(ctx: GovernanceContext, signals: UseCaseSignals): Promise<GovernanceReport>;
+
+/**
+ * NIST AI RMF 1.0 — Govern / Map / Measure / Manage mapping.
+ *
+ * Each subcategory derives its status from concrete framework state:
+ *   MEASURE 2.x: do we have a calibration regime? contamination controls?
+ *   MEASURE 2.7: are red-team results available?
+ *   MANAGE 1.x: are outcome metrics captured? correlation measured?
+ *   GOVERN 1.x: dataset + prompt provenance recorded?
+ *
+ * We ship the mapping and the derivation rules; consumers supply the
+ * GovernanceContext.
+ */
+
+declare function nistAiRmfReport(ctx: GovernanceContext): Promise<GovernanceReport>;
+
+/**
+ * SOC 2 — Common Criteria 7 (system operations + change management)
+ * audit trail derived from the trace corpus.
+ *
+ * This is NOT a formal SOC2 report — that requires an external
+ * auditor. What we ship is the machine-readable *evidence* package
+ * that an auditor consumes: run counts, deploy events, access log
+ * summary, anomaly tracking, response-time SLOs.
+ */
+
+declare function soc2Report(ctx: GovernanceContext): Promise<GovernanceReport>;
+
+export { type EuRiskClass, type GovernanceContext, type GovernanceFinding, type GovernanceReport, type UseCaseSignals, classifyEuAiRisk, euAiActReport, nistAiRmfReport, renderMarkdown, soc2Report, summarize };