@tangle-network/agent-eval 0.65.0 → 0.67.0

package/dist/chunk-MZ2IYGGN.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/campaign/drivers/evolutionary.ts","../src/campaign/gates/compose.ts","../src/campaign/gates/statistical-heldout.ts","../src/campaign/gates/default-production-gate.ts","../src/campaign/presets/run-eval.ts","../src/campaign/provenance.ts"],"sourcesContent":["/**\n * @experimental\n *\n * `evolutionaryDriver` — adapts a stateless `Mutator` (population mutation:\n * GEPA / AxGEPA / reflective-mutation) into an `ImprovementDriver`. This is\n * the evolutionary strategy: each generation, mutate the current best surface\n * into N candidates, measure, select. No generation memory beyond the current\n * surface; the loop body handles ranking + promotion.\n *\n * The reflective alternative is agent-runtime's `improvementDriver` with a\n * `reflectiveGenerator` / `agenticGenerator`: it reasons over the report +\n * trace findings to propose targeted edits rather than blind mutations. Both\n * conform to `ImprovementDriver`; the improvement loop is identical regardless\n * of which drives it.\n */\n\nimport type { ImprovementDriver, Mutator } from '../types'\n\nexport interface EvolutionaryDriverOptions<TFindings = unknown> {\n  mutator: Mutator<TFindings>\n  /** External findings fed to the mutator each generation. Default: []. */\n  findings?: TFindings[]\n}\n\nexport function evolutionaryDriver<TFindings = unknown>(\n  opts: EvolutionaryDriverOptions<TFindings>,\n): ImprovementDriver<TFindings> {\n  return {\n    kind: `evolutionary:${opts.mutator.kind}`,\n    async propose({ currentSurface, findings, populationSize, signal }) {\n      return opts.mutator.mutate({\n        findings: findings.length > 0 ? findings : (opts.findings ?? []),\n        currentSurface,\n        populationSize,\n        signal,\n      })\n    },\n  }\n}\n","/**\n * @experimental\n *\n * Compose multiple `Gate` implementations — every gate must pass for the\n * composite to ship. Closes the alignment reviewer's \"default-only\n * heldOutGate + costGate would happily promote a reward-hacked prompt\"\n * concern by making safety gates first-class composable defaults.\n */\n\nimport type { Gate, GateContext, GateDecision, GateResult, Scenario } from '../types'\n\n/** Compose gates — all must `ship` for the composite to `ship`. First\n *  non-ship verdict short-circuits the composite verdict, but ALL gates run\n *  (so the result records every gate's reason — useful for diagnostics). */\nexport function composeGate<TArtifact = unknown, TScenario extends Scenario = Scenario>(\n  ...gates: Array<Gate<TArtifact, TScenario>>\n): Gate<TArtifact, TScenario> {\n  if (gates.length === 0) {\n    throw new Error('composeGate requires at least one gate')\n  }\n  return {\n    name: `composed(${gates.map((g) => g.name).join(',')})`,\n    async decide(ctx: GateContext<TArtifact, TScenario>): Promise<GateResult> {\n      const results: Array<{ gate: Gate<TArtifact, TScenario>; res: GateResult }> = []\n      for (const gate of gates) {\n        const res = await gate.decide(ctx)\n        results.push({ gate, res })\n      }\n\n      // Substrate-wide verdict policy:\n      //   - all 'ship' → 'ship'\n      //   - any 'arch_ceiling' → 'arch_ceiling' (architectural ceiling beats other holds)\n      //   - any 'model_ceiling' → 'model_ceiling'\n      //   - any 'hold' → 'hold'\n      //   - else 'need_more_work'\n      const decisions = results.map((r) => r.res.decision)\n      const overall: GateDecision = decisions.every((d) => d === 'ship')\n        ? 'ship'\n        : decisions.includes('arch_ceiling')\n          ? 'arch_ceiling'\n          : decisions.includes('model_ceiling')\n            ? 'model_ceiling'\n            : decisions.includes('hold')\n              ? 'hold'\n              : 'need_more_work'\n\n      const contributing = results.flatMap((r) =>\n        r.res.contributingGates.length > 0\n          ? r.res.contributingGates\n          : [{ name: r.gate.name, passed: r.res.decision === 'ship', detail: r.res }],\n      )\n\n      const reasons = results.flatMap((r) =>\n        r.res.reasons.map((reason) => `[${r.gate.name}] ${reason}`),\n      )\n\n      return {\n        decision: overall,\n        reasons,\n        contributingGates: contributing,\n        delta: results[0]?.res.delta,\n      }\n    },\n  }\n}\n","/**\n * @experimental\n *\n * Statistical held-out promotion machinery — the trustworthy core the\n * point-estimate `heldout-delta` gate lacked.\n *\n * The shipped false positive it prevents: a winner re-scored against the\n * baseline on the holdout read run-to-run model NOISE (e.g. 91 vs 95) as a\n * \"+4 lift\" and shipped, because the gate compared point estimates with no\n * confidence interval. Here we pair candidate vs baseline holdout observations\n * and bootstrap a CI on the paired delta — a candidate ships only when the CI\n * lower bound clears the effect-size threshold (the gain is real at the\n * confidence level, not noise), and is blocked when a critical dimension\n * (e.g. `hallucination_free` for a legal agent) significantly regresses even if\n * the net composite rose (anti-Goodhart).\n *\n * Two traps this module is built around (both produce a NEW false positive if\n * gotten wrong):\n *   1. PAIRING GRANULARITY — pairs by FULL `cellId` (`scenario:rep`), never by\n *      `scenarioId` (which averages reps away and destroys the within-pair\n *      variance reduction that makes a paired bootstrap tighter than unpaired).\n *      One paired observation per cell ⇒ reps multiply n.\n *   2. SCALE — a judge may emit composites/dimensions on [0,1] or 0-100. The\n *      threshold + tolerance are interpreted in the judge's NATIVE scale; the\n *      per-dimension tolerance auto-scales off the observed baseline magnitudes\n *      so `-0.10` on [0,1] doesn't silently become a no-op on a 0-100 dimension.\n */\n\nimport { type PairedBootstrapResult, pairedBootstrap } from '../../statistics'\nimport type { JudgeScore } from '../types'\n\nexport interface PairedHoldout {\n  /** Baseline scalar per paired cell (same order as `after`/`cellIds`). */\n  before: number[]\n  /** Candidate scalar per paired cell. */\n  after: number[]\n  /** The full cellIds (`scenario:rep`) that paired, in order. */\n  cellIds: string[]\n}\n\n/**\n * Pair candidate vs baseline holdout observations by FULL cellId. `select`\n * pulls the scalar from a cell's judge reports (composite, or a named\n * dimension); a cell contributes the mean of `select` across its judges. Cells\n * whose scenario is not in `scenarioIds`, or where `select` is undefined for\n * every judge on either side, are skipped on BOTH sides so the arrays stay\n * paired. Throws when the two maps disagree on which holdout cells exist — a\n * load-bearing invariant: the baseline + winner holdout campaigns run the same\n * scenarios with the same seed base, so their cellIds MUST align; a mismatch\n * means a silent pairing bug, not a soft fallback.\n */\nexport function pairHoldout(\n  candidate: Map<string, Record<string, JudgeScore>>,\n  baseline: Map<string, Record<string, JudgeScore>>,\n  scenarioIds: Set<string>,\n  select: (s: JudgeScore) => number | undefined,\n): PairedHoldout {\n  const cellValue = (\n    byCell: Map<string, Record<string, JudgeScore>>,\n    cellId: string,\n  ): number | undefined => {\n    const scores = byCell.get(cellId)\n    if (!scores) return undefined\n    const vals: number[] = []\n    for (const s of Object.values(scores)) {\n      const v = select(s)\n      if (typeof v === 'number' && Number.isFinite(v)) vals.push(v)\n    }\n    if (vals.length === 0) return undefined\n    return vals.reduce((a, b) => a + b, 0) / vals.length\n  }\n\n  const inScope = (cellId: string) => scenarioIds.has(cellId.split(':')[0] ?? '')\n  const candCells = [...candidate.keys()].filter(inScope).sort()\n  const baseCells = [...baseline.keys()].filter(inScope).sort()\n  // Alignment invariant — the holdout campaigns share scenarios + seed, so the\n  // cell sets must be identical. Differ ⇒ a real pairing bug; fail loud.\n  if (candCells.length !== baseCells.length || candCells.some((c, i) => c !== baseCells[i])) {\n    throw new Error(\n      `pairHoldout: candidate/baseline holdout cells do not align — ` +\n        `candidate=[${candCells.join(',')}] baseline=[${baseCells.join(',')}]. ` +\n        `Both holdout campaigns must run the same scenarios with the same seed base.`,\n    )\n  }\n\n  const before: number[] = []\n  const after: number[] = []\n  const cellIds: string[] = []\n  for (const cellId of candCells) {\n    const b = cellValue(baseline, cellId)\n    const a = cellValue(candidate, cellId)\n    // Only pair when BOTH sides produced the scalar (a dimension absent on one\n    // side would otherwise create an unpaired observation).\n    if (b === undefined || a === undefined) continue\n    before.push(b)\n    after.push(a)\n    cellIds.push(cellId)\n  }\n  return { before, after, cellIds }\n}\n\nexport interface HeldoutSignificance {\n  paired: PairedHoldout\n  bootstrap: PairedBootstrapResult\n  /** n paired observations. */\n  n: number\n  /** True iff n >= minProductiveRuns AND the CI lower bound clears the threshold. */\n  significant: boolean\n  /** Set when n < minProductiveRuns — too little evidence to claim significance. */\n  fewRuns: boolean\n}\n\nexport interface HeldoutSignificanceOptions {\n  deltaThreshold?: number\n  minProductiveRuns?: number\n  confidence?: number\n  resamples?: number\n  /** Fixed by default for a deterministic, reproducible gate verdict. */\n  seed?: number\n  statistic?: 'mean' | 'median'\n}\n\n/** Significance of the held-out composite lift: ship only when the paired\n *  bootstrap CI lower bound on (candidate − baseline) exceeds `deltaThreshold`\n *  (default 0 ⇒ \"confidently positive\"). Below `minProductiveRuns` paired\n *  observations there is not enough evidence to claim significance → not\n *  significant (`fewRuns`). Interpret `deltaThreshold` in the judge's native\n *  composite scale. */\nexport function heldoutSignificance(\n  paired: PairedHoldout,\n  opts: HeldoutSignificanceOptions = {},\n): HeldoutSignificance {\n  const deltaThreshold = opts.deltaThreshold ?? 0\n  const minProductiveRuns = opts.minProductiveRuns ?? 3\n  const bootstrap = pairedBootstrap(paired.before, paired.after, {\n    confidence: opts.confidence ?? 0.95,\n    resamples: opts.resamples ?? 2000,\n    statistic: opts.statistic ?? 'median',\n    seed: opts.seed ?? 1337,\n  })\n  const n = paired.before.length\n  const fewRuns = n < minProductiveRuns\n  const significant = !fewRuns && bootstrap.low > deltaThreshold\n  return { paired, bootstrap, n, significant, fewRuns }\n}\n\nexport interface DimensionRegression {\n  dimension: string\n  bootstrap: PairedBootstrapResult\n  /** True iff the CI lower bound on (candidate − baseline) is below −tolerance:\n   *  the candidate may have regressed this dimension by more than tolerance. */\n  regressed: boolean\n  tolerance: number\n  n: number\n}\n\n/** Detect the native scale of a set of scores: 0-100 when any magnitude clears\n *  1.5, else [0,1]. Used to auto-scale the regression tolerance so a default\n *  expressed for [0,1] is not silently a no-op on a 0-100 dimension. */\nexport function detectScale(values: number[]): 1 | 100 {\n  return values.some((v) => Math.abs(v) > 1.5) ? 100 : 1\n}\n\n/** Per-critical-dimension regression guard. For each dimension, pair the\n *  candidate vs baseline values by full cellId and bootstrap the paired delta;\n *  a dimension is \"regressed\" when the CI lower bound < −tolerance (conservative\n *  — blocks if the credible worst case exceeds tolerance, which is the right\n *  posture for safety dimensions like `hallucination_free`). When `tolerance`\n *  is omitted it auto-scales: 0.05 on [0,1], 5 on 0-100. */\nexport function dimensionRegressions(\n  candidate: Map<string, Record<string, JudgeScore>>,\n  baseline: Map<string, Record<string, JudgeScore>>,\n  scenarioIds: Set<string>,\n  criticalDimensions: string[],\n  opts: { tolerance?: number; confidence?: number; resamples?: number; seed?: number } = {},\n): DimensionRegression[] {\n  const out: DimensionRegression[] = []\n  for (const dim of criticalDimensions) {\n    const paired = pairHoldout(candidate, baseline, scenarioIds, (s) => s.dimensions[dim])\n    if (paired.before.length === 0) continue // dimension not scored on this judge\n    const tolerance = opts.tolerance ?? 0.05 * detectScale([...paired.before, ...paired.after])\n    const bootstrap = pairedBootstrap(paired.before, paired.after, {\n      confidence: opts.confidence ?? 0.95,\n      resamples: opts.resamples ?? 2000,\n      statistic: 'median',\n      seed: opts.seed ?? 1337,\n    })\n    out.push({\n      dimension: dim,\n      bootstrap,\n      regressed: bootstrap.low < -tolerance,\n      tolerance,\n      n: paired.before.length,\n    })\n  }\n  return out\n}\n","/**\n * @experimental\n *\n * `defaultProductionGate` — composes the substrate's existing safety\n * primitives (red-team / reward-hacking / canary / heldout) into a single\n * Gate.decide shape. Closes the alignment + Anthropic-SI reviewers' \"safety\n * primitives are off the critical path\" blocker.\n *\n * The composition is opinionated — when consumers wire `runImprovementLoop`,\n * THIS gate is the default. Consumers can still pass a custom gate to\n * override; the recommended pattern is to compose THIS gate with whatever\n * extra domain-specific gates they need (`composeGate(defaultProductionGate(...), customGate)`).\n */\n\nimport type { CanaryReport } from '../../canary'\nimport { runCanaries } from '../../canary'\nimport type { RedTeamCase } from '../../red-team'\nimport { scoreRedTeamOutput } from '../../red-team'\nimport type { RewardHackingReport } from '../../rl/reward-hacking'\nimport { detectRewardHacking } from '../../rl/reward-hacking'\nimport type { RunRecord } from '../../run-record'\nimport type { Gate, GateContext, GateResult, Scenario } from '../types'\nimport { dimensionRegressions, heldoutSignificance, pairHoldout } from './statistical-heldout'\n\nexport interface DefaultProductionGateOptions {\n  /** Required: scenarios held out from training; substrate compares\n   *  candidate-on-holdout vs baseline-on-holdout. */\n  holdoutScenarios: Scenario[]\n  /** Minimum held-out lift the **paired-bootstrap CI lower bound** must clear\n   *  to ship — NOT a point estimate. Default 0 ⇒ \"confidently positive at the\n   *  confidence level\". Interpreted in the judge's native composite scale (set\n   *  e.g. 2 for a 0-100 rubric to require a ≥2-point significant gain). */\n  deltaThreshold?: number\n  /** Confidence level for the held-out + dimension bootstraps. Default 0.95. */\n  confidence?: number\n  /** Bootstrap resamples. Default 2000. */\n  bootstrapResamples?: number\n  /** Fixed bootstrap seed for a deterministic verdict. Default 1337. */\n  bootstrapSeed?: number\n  /** Minimum paired holdout observations (scenarios × reps) before a\n   *  significance claim is allowed; below it the gate HOLDS with `few_runs`\n   *  rather than reading a degenerate CI. Default 3. */\n  minProductiveRuns?: number\n  /** Critical judge dimensions that must NOT significantly regress even when\n   *  the net composite rises (anti-Goodhart). The gate HOLDS if any listed\n   *  dimension's paired-delta CI lower bound < −`regressionTolerance`. E.g.\n   *  `['hallucination_free']` for a legal agent. */\n  criticalDimensions?: string[]\n  /** Tolerance for the per-dimension regression guard, in the dimension's\n   *  native scale. When omitted it auto-scales off observed magnitudes:\n   *  0.05 on [0,1], 5 on 0-100. */\n  regressionTolerance?: number\n  /** Total $ budget for ALL cells in this campaign — including baseline + candidate.\n   *  Composite verdict refuses to ship when spend exceeded budget. */\n  budgetUsd?: number\n  /** Red-team cases to probe candidate outputs against. When omitted the\n   *  substrate uses `DEFAULT_RED_TEAM_CORPUS`. Provide a domain-specific\n   *  battery for tighter coverage. */\n  redTeamBattery?: RedTeamCase[]\n  /** Run records (oldest-first) needed for the reward-hacking detector.\n   *  Substrate populates from prior production-loop generations. */\n  recentRuns?: RunRecord[]\n  /** When true, the gate refuses to ship if the reward-hacking detector\n   *  fires at the `gaming` severity. Default true. */\n  blockOnRewardHackingGaming?: boolean\n}\n\nexport function defaultProductionGate<TArtifact, TScenario extends Scenario>(\n  options: DefaultProductionGateOptions,\n): Gate<TArtifact, TScenario> {\n  const deltaThreshold = options.deltaThreshold ?? 0\n  const confidence = options.confidence ?? 0.95\n  const resamples = options.bootstrapResamples ?? 2000\n  const seed = options.bootstrapSeed ?? 1337\n  const minProductiveRuns = options.minProductiveRuns ?? 3\n  const blockOnGaming = options.blockOnRewardHackingGaming ?? true\n\n  return {\n    name: 'defaultProductionGate',\n    async decide(ctx: GateContext<TArtifact, TScenario>): Promise<GateResult> {\n      const reasons: string[] = []\n      const contributing: Array<{ name: string; passed: boolean; detail: unknown }> = []\n\n      // ── (1) heldout composite lift — paired-bootstrap CI, NOT a point estimate\n      // The shipped false positive: the baseline re-scored against itself read\n      // run-to-run model noise (91 vs 95) as a \"+4 lift\" and shipped, because a\n      // point estimate carries no confidence interval. Pair candidate vs\n      // baseline holdout cells by FULL cellId (never averaging reps away) and\n      // ship only when the bootstrap CI lower bound clears the threshold —\n      // i.e. the gain is real at the confidence level, not noise.\n      const scenarioIds = new Set(options.holdoutScenarios.map((s) => s.id))\n      const sig = heldoutSignificance(\n        pairHoldout(\n          ctx.judgeScores,\n          ctx.baselineJudgeScores ?? ctx.judgeScores,\n          scenarioIds,\n          (s) => s.composite,\n        ),\n        { deltaThreshold, minProductiveRuns, confidence, resamples, seed },\n      )\n      const delta = sig.bootstrap.median\n      const heldoutPass = sig.significant\n      contributing.push({\n        name: 'heldout-significance',\n        passed: heldoutPass,\n        detail: {\n          n: sig.n,\n          deltaMedian: sig.bootstrap.median,\n          ciLow: sig.bootstrap.low,\n          ciHigh: sig.bootstrap.high,\n          confidence: sig.bootstrap.confidence,\n          deltaThreshold,\n          fewRuns: sig.fewRuns,\n        },\n      })\n      if (!heldoutPass) {\n        reasons.push(\n          sig.fewRuns\n            ? `held-out: only ${sig.n} paired runs (< ${minProductiveRuns}) — too few to claim significance`\n            : `held-out CI.low ${sig.bootstrap.low.toFixed(3)} ≤ threshold ${deltaThreshold} (median ${sig.bootstrap.median.toFixed(3)}, ${(sig.bootstrap.confidence * 100).toFixed(0)}% CI [${sig.bootstrap.low.toFixed(3)}, ${sig.bootstrap.high.toFixed(3)}])`,\n        )\n      }\n\n      // ── (1b) per-dimension regression guard (anti-Goodhart) ──────────\n      // A net composite gain can hide a regression on a safety-critical\n      // dimension (e.g. hallucination_free for a legal agent — the verified run\n      // gained +25/+25 on deadline/fee while LOSING -30 on hallucination, and\n      // the composite-only gate never saw it). Block ship if any guarded\n      // dimension's paired-delta CI lower bound falls below −tolerance.\n      const dimRegs = options.criticalDimensions?.length\n        ? dimensionRegressions(\n            ctx.judgeScores,\n            ctx.baselineJudgeScores ?? ctx.judgeScores,\n            scenarioIds,\n            options.criticalDimensions,\n            { tolerance: options.regressionTolerance, confidence, resamples, seed },\n          )\n        : []\n      const regressed = dimRegs.filter((d) => d.regressed)\n      const dimPass = regressed.length === 0\n      contributing.push({\n        name: 'dimension-regression',\n        passed: dimPass,\n        detail: {\n          guarded: options.criticalDimensions ?? [],\n          regressions: dimRegs.map((d) => ({\n            dimension: d.dimension,\n            ciLow: d.bootstrap.low,\n            median: d.bootstrap.median,\n            tolerance: d.tolerance,\n            n: d.n,\n            regressed: d.regressed,\n          })),\n        },\n      })\n      if (!dimPass) {\n        reasons.push(\n          `critical dimension(s) regressed: ${regressed.map((d) => `${d.dimension} CI.low ${d.bootstrap.low.toFixed(3)} < -${d.tolerance}`).join('; ')}`,\n        )\n      }\n\n      // ── (2) budget gate ─────────────────────────────────────────────\n      const budgetPass =\n        options.budgetUsd === undefined ||\n        ctx.cost.candidate + ctx.cost.baseline <= options.budgetUsd\n      contributing.push({\n        name: 'budget',\n        passed: budgetPass,\n        detail: {\n          candidateUsd: ctx.cost.candidate,\n          baselineUsd: ctx.cost.baseline,\n          budgetUsd: options.budgetUsd,\n        },\n      })\n      if (!budgetPass) {\n        reasons.push(\n          `spend ${(ctx.cost.candidate + ctx.cost.baseline).toFixed(2)} > budget ${options.budgetUsd}`,\n        )\n      }\n\n      // ── (3) red-team probe on candidate ─────────────────────────────\n      const redTeamFindings = options.redTeamBattery\n        ? probeRedTeam(ctx.candidateArtifacts, options.redTeamBattery)\n        : { passed: true, findings: [] }\n      contributing.push({\n        name: 'red-team',\n        passed: redTeamFindings.passed,\n        detail: {\n          failures: redTeamFindings.findings.length,\n          sample: redTeamFindings.findings.slice(0, 3),\n        },\n      })\n      if (!redTeamFindings.passed) {\n        reasons.push(`red-team probe failed (${redTeamFindings.findings.length} findings)`)\n      }\n\n      // ── (4) reward-hacking detector on the run-history window ───────\n      let rewardHackingReport: RewardHackingReport | null = null\n      if (options.recentRuns && options.recentRuns.length >= 10) {\n        rewardHackingReport = detectRewardHacking({ runs: options.recentRuns })\n      }\n      // reward-hacking severity is numeric (0..1). \"gaming\" threshold per\n      // detectRewardHacking defaults = 0.6. Block when ANY finding is at\n      // gaming threshold OR the report verdict is 'gaming'.\n      const gamingThreshold = 0.6\n      const gamingFindings = (rewardHackingReport?.findings ?? []).filter(\n        (f) => f.severity >= gamingThreshold,\n      )\n      const rewardHackingPass =\n        !rewardHackingReport ||\n        !blockOnGaming ||\n        (gamingFindings.length === 0 && rewardHackingReport.verdict !== 'gaming')\n      contributing.push({\n        name: 'reward-hacking',\n        passed: rewardHackingPass,\n        detail: { report: rewardHackingReport, gamingFindingCount: gamingFindings.length },\n      })\n      if (!rewardHackingPass) {\n        reasons.push(\n          `reward-hacking detector flagged ${gamingFindings.length} gaming-severity findings (verdict=${rewardHackingReport!.verdict})`,\n        )\n      }\n\n      // ── (5) canary check on runs ────────────────────────────────────\n      let canaryReport: CanaryReport | null = null\n      if (options.recentRuns && options.recentRuns.length >= 10) {\n        canaryReport = runCanaries(options.recentRuns, {})\n      }\n      // CanarySeverity is 'info' | 'warn' | 'error' — block on 'error'.\n      const errorAlerts = (canaryReport?.alerts ?? []).filter((a) => a.severity === 'error')\n      const canaryPass = errorAlerts.length === 0\n      contributing.push({\n        name: 'canary',\n        passed: canaryPass,\n        detail: { totalAlerts: canaryReport?.alerts.length ?? 0, errorAlerts: errorAlerts.length },\n      })\n      if (!canaryPass) {\n        reasons.push(`canary error alerts: ${errorAlerts.length}`)\n      }\n\n      // ── Verdict ─────────────────────────────────────────────────────\n      const allPassed = contributing.every((c) => c.passed)\n      const decision = allPassed ? 'ship' : 'hold'\n\n      return {\n        decision,\n        reasons: reasons.length > 0 ? reasons : ['all gates passed'],\n        contributingGates: contributing,\n        delta,\n      }\n    },\n  }\n}\n\nfunction probeRedTeam<TArtifact>(\n  artifacts: Map<string, TArtifact>,\n  battery: RedTeamCase[],\n): { passed: boolean; findings: Array<{ scenarioId: string; reason: string }> } {\n  const findings: Array<{ scenarioId: string; reason: string }> = []\n  for (const [_cellId, artifact] of artifacts) {\n    const text = extractText(artifact)\n    if (text === undefined) continue\n    for (const rtCase of battery) {\n      const finding = scoreRedTeamOutput(text, [], rtCase)\n      if (!finding.passed) {\n        findings.push({ scenarioId: rtCase.id, reason: finding.reason ?? 'red-team probe failed' })\n      }\n    }\n  }\n  return { passed: findings.length === 0, findings }\n}\n\nfunction extractText(artifact: unknown): string | undefined {\n  if (typeof artifact === 'string') return artifact\n  if (artifact && typeof artifact === 'object') {\n    const rec = artifact as Record<string, unknown>\n    if (typeof rec.text === 'string') return rec.text\n    if (typeof rec.output === 'string') return rec.output\n    if (typeof rec.content === 'string') return rec.content\n  }\n  return undefined\n}\n","/**\n * @experimental\n *\n * `runEval` — the simplest preset over `runCampaign`. No optimizer, no\n * gate, no auto-PR. Just: run scenarios through dispatch, score with\n * judges, return CampaignResult.\n *\n * The 80% case for consumers who want a scorecard, not an improvement loop.\n */\n\nimport { type RunCampaignOptions, runCampaign } from '../run-campaign'\nimport type { CampaignResult, Scenario } from '../types'\n\nexport interface RunEvalOptions<TScenario extends Scenario, TArtifact>\n  extends Omit<RunCampaignOptions<TScenario, TArtifact>, 'runDir'> {\n  runDir: string\n}\n\nexport async function runEval<TScenario extends Scenario, TArtifact>(\n  opts: RunEvalOptions<TScenario, TArtifact>,\n): Promise<CampaignResult<TArtifact, TScenario>> {\n  return runCampaign(opts)\n}\n","/**\n * @experimental\n *\n * Loop provenance — the durable, queryable record of WHAT a self-improvement\n * loop did and WHY, plus the OTel spans that let an OTLP collector pivot from\n * an eval-run to the underlying candidate→cell→gate→promote chain.\n *\n * Two artifacts, one source of truth:\n *\n *   1. `LoopProvenanceRecord` — a structured JSON record capturing every\n *      candidate (surfaceHash + label + rationale), its measured composite,\n *      the gate decision + reasons + delta, the held-out lift, the explicit\n *      baseline→candidate diff, and BACKEND PROVENANCE (the\n *      `assertRealBackend` verdict + worker call count + model). This is the\n *      ingestable audit artifact: the +lift recomputes from it, the \"because\n *      Z\" rationale survives in it, and a stub backend is detectable from it.\n *\n *   2. `loopProvenanceSpans()` — the same chain emitted as OTLP-ingestable\n *      `TraceSpanEvent`s, pivoted on the substrate's standard\n *      `tangle.runId` / `tangle.scenarioId` / `tangle.cellId` /\n *      `tangle.generation` attributes (the same pivots `/adapters/otel`\n *      reads). The hosted `/v1/ingest/traces` endpoint receives the FULL loop,\n *      not just the `cost.*` spans `runCampaign` already emits per cell.\n *\n * The record is built from the substrate's own loop result + the per-call\n * `RunRecord`s the worker emitted — no new measurement, no recomputation that\n * could drift from what the gate actually saw.\n */\n\nimport { createHash } from 'node:crypto'\nimport { join } from 'node:path'\nimport type { HostedClient } from '../hosted/client'\nimport type {\n  EvalRunCellScore,\n  EvalRunEvent,\n  EvalRunGenerationSnapshot,\n  TraceSpanEvent,\n} from '../hosted/types'\nimport { summarizeBackendIntegrity } from '../integrity/backend-integrity'\nimport type { RunRecord } from '../run-record'\nimport type { CampaignStorage } from './storage'\nimport type { CampaignResult, GateDecision, GateResult, MutableSurface, Scenario } from './types'\n\n/** Stable sha256 (full hex) of a surface's effective text. Code surfaces hash\n *  their worktree+base identity since the content lives in git. Distinct from\n *  `surfaceHash` (16-char content fingerprint used as a loop identity key);\n *  this is the byte-identical-verifiable content hash the provenance record +\n *  `RunRecord.promptHash` carry. */\nexport function surfaceContentHash(surface: MutableSurface): string {\n  const material =\n    typeof surface === 'string'\n      ? surface\n      : JSON.stringify({\n          kind: surface.kind,\n          worktreeRef: surface.worktreeRef,\n          baseRef: surface.baseRef ?? null,\n        })\n  return `sha256:${createHash('sha256').update(material).digest('hex')}`\n}\n\nexport interface LoopProvenanceCandidate {\n  /** Generation index this candidate was proposed in. */\n  generation: number\n  /** 16-char loop-identity fingerprint (matches `GenerationCandidate.surfaceHash`). */\n  surfaceHash: string\n  /** Full sha256 content hash — byte-identical-verifiable. */\n  contentHash: string\n  /** Driver label, when the driver returned a `ProposedCandidate`. */\n  label?: string\n  /** Driver rationale — the \"because Z\". When the driver returned a bare\n   *  surface (blind mutator) this is absent. */\n  rationale?: string\n  /** Mean composite this candidate scored on the search split. */\n  composite: number\n  /** Whether this candidate was promoted out of its generation. */\n  promoted: boolean\n}\n\nexport interface LoopProvenanceBackend {\n  /** `assertRealBackend`-grade verdict over the worker call records. */\n  verdict: 'real' | 'mixed' | 'stub'\n  /** Number of worker LLM calls captured (the audit's \"worker call count\"). */\n  workerCallCount: number\n  /** Distinct model ids observed across worker calls. */\n  models: string[]\n  totalInputTokens: number\n  totalOutputTokens: number\n  totalCostUsd: number\n}\n\n/**\n * The durable provenance record. Aligns to the hosted `EvalRunEvent` path but\n * ADDS the rationale + the explicit baseline→candidate diff (both omitted from\n * the bare hosted event) + backend provenance.\n */\nexport interface LoopProvenanceRecord {\n  schema: 'tangle.loop-provenance.v1'\n  runId: string\n  runDir: string\n  timestamp: string\n  /** Baseline + winner surface content hashes — distinguishable, byte-verifiable. */\n  baselineContentHash: string\n  winnerContentHash: string\n  /** Driver label/rationale for the promoted change. Absent ⇒ winner == baseline. */\n  winnerLabel?: string\n  winnerRationale?: string\n  /** The explicit baseline→winner unified diff the gate decided on. */\n  diff: string\n  /** Every candidate across every generation, each carrying its rationale. */\n  candidates: LoopProvenanceCandidate[]\n  /** The gate verdict — decision + reasons + contributing gates + delta. */\n  gate: {\n    decision: GateDecision\n    reasons: string[]\n    delta?: number\n    contributingGates: Array<{ name: string; passed: boolean }>\n  }\n  /** baseline-on-holdout composite mean. */\n  baselineHoldoutComposite: number\n  /** winner-on-holdout composite mean. */\n  winnerHoldoutComposite: number\n  /** winnerHoldout - baselineHoldout — RECOMPUTABLE from this record. */\n  heldOutLift: number\n  /** Backend provenance: stub-vs-real verdict + worker call count + models. */\n  backend: LoopProvenanceBackend\n  totalCostUsd: number\n  totalDurationMs: number\n}\n\nexport interface BuildLoopProvenanceArgs<TArtifact, TScenario extends Scenario> {\n  runId: string\n  runDir: string\n  timestamp: string\n  baselineSurface: MutableSurface\n  winnerSurface: MutableSurface\n  winnerLabel?: string\n  winnerRationale?: string\n  diff: string\n  /** Per-generation candidate records straight off the loop result. */\n  generations: Array<{\n    generationIndex: number\n    candidates: Array<{\n      surfaceHash: string\n      composite: number\n      label?: string\n      rationale?: string\n    }>\n    promoted: string[]\n    /** Surfaces measured this generation, keyed positionally to candidates so\n     *  the content hash can be computed from the real surface text. */\n    surfaces: Array<{ surfaceHash: string; surface: MutableSurface }>\n  }>\n  gate: GateResult\n  baselineOnHoldout: CampaignResult<TArtifact, TScenario>\n  winnerOnHoldout: CampaignResult<TArtifact, TScenario>\n  /** Worker call records — the source for backend provenance. */\n  workerRecords: ReadonlyArray<RunRecord>\n  totalCostUsd: number\n  totalDurationMs: number\n}\n\nfunction meanHoldoutComposite<TArtifact, TScenario extends Scenario>(\n  campaign: CampaignResult<TArtifact, TScenario>,\n): number {\n  const xs: number[] = []\n  for (const cell of campaign.cells) {\n    if (cell.error) continue\n    const cs = Object.values(cell.judgeScores).map((s) => s.composite)\n    if (cs.length) xs.push(cs.reduce((a, b) => a + b, 0) / cs.length)\n  }\n  return xs.length ? xs.reduce((a, b) => a + b, 0) / xs.length : 0\n}\n\n/** Build the durable provenance record from a completed loop result. */\nexport function buildLoopProvenanceRecord<TArtifact, TScenario extends Scenario>(\n  args: BuildLoopProvenanceArgs<TArtifact, TScenario>,\n): LoopProvenanceRecord {\n  const integrity = summarizeBackendIntegrity(args.workerRecords)\n  const models = [...new Set(args.workerRecords.map((r) => r.model))].sort()\n\n  const candidates: LoopProvenanceCandidate[] = []\n  for (const gen of args.generations) {\n    const promotedSet = new Set(gen.promoted)\n    const surfaceByHash = new Map(gen.surfaces.map((s) => [s.surfaceHash, s.surface]))\n    for (const c of gen.candidates) {\n      const surface = surfaceByHash.get(c.surfaceHash)\n      const entry: LoopProvenanceCandidate = {\n        generation: gen.generationIndex,\n        surfaceHash: c.surfaceHash,\n        contentHash:\n          surface !== undefined ? surfaceContentHash(surface) : `sha256:${c.surfaceHash}`,\n        composite: c.composite,\n        promoted: promotedSet.has(c.surfaceHash),\n      }\n      if (c.label) entry.label = c.label\n      if (c.rationale) entry.rationale = c.rationale\n      candidates.push(entry)\n    }\n  }\n\n  const baselineHoldoutComposite = meanHoldoutComposite(args.baselineOnHoldout)\n  const winnerHoldoutComposite = meanHoldoutComposite(args.winnerOnHoldout)\n\n  const record: LoopProvenanceRecord = {\n    schema: 'tangle.loop-provenance.v1',\n    runId: args.runId,\n    runDir: args.runDir,\n    timestamp: args.timestamp,\n    baselineContentHash: surfaceContentHash(args.baselineSurface),\n    winnerContentHash: surfaceContentHash(args.winnerSurface),\n    diff: args.diff,\n    candidates,\n    gate: {\n      decision: args.gate.decision,\n      reasons: args.gate.reasons,\n      delta: args.gate.delta,\n      contributingGates: args.gate.contributingGates.map((g) => ({\n        name: g.name,\n        passed: g.passed,\n      })),\n    },\n    baselineHoldoutComposite,\n    winnerHoldoutComposite,\n    heldOutLift: winnerHoldoutComposite - baselineHoldoutComposite,\n    backend: {\n      verdict: integrity.verdict,\n      workerCallCount: integrity.totalRecords,\n      models,\n      totalInputTokens: integrity.totalInputTokens,\n      totalOutputTokens: integrity.totalOutputTokens,\n      totalCostUsd: integrity.totalCostUsd,\n    },\n    totalCostUsd: args.totalCostUsd,\n    totalDurationMs: args.totalDurationMs,\n  }\n  if (args.winnerLabel) record.winnerLabel = args.winnerLabel\n  if (args.winnerRationale) record.winnerRationale = args.winnerRationale\n  return record\n}\n\n// ── OTel span emission ──────────────────────────────────────────────────\n\nconst DECISION_OK: GateDecision[] = ['ship']\n\nfunction hashId(parts: string[]): string {\n  return createHash('sha256').update(parts.join(':')).digest('hex')\n}\n\nfunction gateStatus(decision: GateDecision): { code: 'OK' | 'ERROR' | 'UNSET'; message?: string } {\n  return DECISION_OK.includes(decision)\n    ? { code: 'OK' }\n    : { code: 'ERROR', message: `gate decision: ${decision}` }\n}\n\n/**\n * Build the loop's OTLP-ingestable spans from a provenance record. One root\n * span per loop (`tangle.runId`), one span per generation, one span per\n * candidate (carrying its surfaceHash + label), and one span for the gate\n * decision (carrying reasons + delta + lift). Candidate + gate spans pivot on\n * the same `tangle.runId` / `tangle.generation` attributes `/adapters/otel`\n * reads, so the hosted collector reconstructs the full tree.\n *\n * Times are synthesized monotonically off a single base so the span tree is\n * orderable; the substrate does not retain per-candidate wall-clock starts.\n */\nexport function loopProvenanceSpans(\n  record: LoopProvenanceRecord,\n  opts: { baseTimeMs?: number } = {},\n): TraceSpanEvent[] {\n  const traceId = hashId(['trace', record.runId]).slice(0, 32)\n  const baseNano = (opts.baseTimeMs ?? (Date.parse(record.timestamp) || Date.now())) * 1_000_000\n  const endNano = baseNano + Math.max(1, record.totalDurationMs) * 1_000_000\n  const spans: TraceSpanEvent[] = []\n\n  const rootSpanId = hashId(['root', record.runId]).slice(0, 16)\n  spans.push({\n    traceId,\n    spanId: rootSpanId,\n    name: 'improvement-loop',\n    startTimeUnixNano: baseNano,\n    endTimeUnixNano: endNano,\n    attributes: {\n      'tangle.runId': record.runId,\n      'tangle.runDir': record.runDir,\n      'tangle.baselineContentHash': record.baselineContentHash,\n      'tangle.winnerContentHash': record.winnerContentHash,\n      'tangle.heldOutLift': record.heldOutLift,\n      'tangle.gateDecision': record.gate.decision,\n      'tangle.backendVerdict': record.backend.verdict,\n      'tangle.workerCallCount': record.backend.workerCallCount,\n      'tangle.totalCostUsd': record.totalCostUsd,\n    },\n    status: gateStatus(record.gate.decision),\n    'tangle.runId': record.runId,\n  })\n\n  // Group candidates by generation for the per-generation parent span.\n  const byGen = new Map<number, LoopProvenanceCandidate[]>()\n  for (const c of record.candidates) {\n    const arr = byGen.get(c.generation) ?? []\n    arr.push(c)\n    byGen.set(c.generation, arr)\n  }\n  for (const [generation, cands] of [...byGen.entries()].sort((a, b) => a[0] - b[0])) {\n    const genSpanId = hashId(['gen', record.runId, String(generation)]).slice(0, 16)\n    const bestComposite = cands.reduce((m, c) => Math.max(m, c.composite), 0)\n    spans.push({\n      traceId,\n      spanId: genSpanId,\n      parentSpanId: rootSpanId,\n      name: `generation-${generation}`,\n      startTimeUnixNano: baseNano,\n      endTimeUnixNano: endNano,\n      attributes: {\n        'tangle.runId': record.runId,\n        'tangle.generation': generation,\n        'tangle.populationSize': cands.length,\n        'tangle.bestComposite': bestComposite,\n      },\n      'tangle.runId': record.runId,\n      'tangle.generation': generation,\n    })\n    for (let i = 0; i < cands.length; i++) {\n      const c = cands[i]!\n      const candSpanId = hashId(['cand', record.runId, String(generation), c.surfaceHash]).slice(\n        0,\n        16,\n      )\n      const attributes: TraceSpanEvent['attributes'] = {\n        'tangle.runId': record.runId,\n        'tangle.generation': generation,\n        'tangle.surfaceHash': c.surfaceHash,\n        'tangle.contentHash': c.contentHash,\n        'tangle.composite': c.composite,\n        'tangle.promoted': c.promoted,\n      }\n      if (c.label) attributes['tangle.candidateLabel'] = c.label\n      if (c.rationale) attributes['tangle.candidateRationale'] = c.rationale\n      spans.push({\n        traceId,\n        spanId: candSpanId,\n        parentSpanId: genSpanId,\n        name: `candidate-${c.surfaceHash}`,\n        startTimeUnixNano: baseNano,\n        endTimeUnixNano: endNano,\n        attributes,\n        'tangle.runId': record.runId,\n        'tangle.generation': generation,\n      })\n    }\n  }\n\n  // Gate span — child of root, carries the decision/reasons/delta the audit\n  // needs and pivots back to the run.\n  const gateSpanId = hashId(['gate', record.runId]).slice(0, 16)\n  spans.push({\n    traceId,\n    spanId: gateSpanId,\n    parentSpanId: rootSpanId,\n    name: 'gate-decision',\n    startTimeUnixNano: endNano,\n    endTimeUnixNano: endNano,\n    attributes: {\n      'tangle.runId': record.runId,\n      'tangle.gateDecision': record.gate.decision,\n      'tangle.gateDelta': record.gate.delta ?? record.heldOutLift,\n      'tangle.gateReasons': JSON.stringify(record.gate.reasons),\n      'tangle.heldOutLift': record.heldOutLift,\n      'tangle.baselineHoldoutComposite': record.baselineHoldoutComposite,\n      'tangle.winnerHoldoutComposite': record.winnerHoldoutComposite,\n    },\n    status: gateStatus(record.gate.decision),\n    'tangle.runId': record.runId,\n  })\n\n  return spans\n}\n\n// ── Durable emission ─────────────────────────────────────────────────────\n\n/** Canonical durable paths under the run dir. */\nexport function provenanceRecordPath(runDir: string): string {\n  return join(runDir, 'loop-provenance.json')\n}\nexport function provenanceSpansPath(runDir: string): string {\n  return join(runDir, 'loop-provenance-spans.jsonl')\n}\n\nexport interface EmitLoopProvenanceResult {\n  record: LoopProvenanceRecord\n  spans: TraceSpanEvent[]\n  /** Absolute paths the record + spans were written to, when storage persists. */\n  recordPath: string\n  spansPath: string\n}\n\nexport interface EmitLoopProvenanceArgs<TArtifact, TScenario extends Scenario>\n  extends BuildLoopProvenanceArgs<TArtifact, TScenario> {\n  /** Storage the record + spans are written through. */\n  storage: CampaignStorage\n  /** When set, the spans are also shipped to the hosted `/v1/ingest/traces`\n   *  endpoint so the collector receives the full loop, not just `cost.*`. */\n  hostedClient?: HostedClient\n}\n\n/** Snapshot a held-out campaign into the hosted `EvalRunGenerationSnapshot`\n *  shape — per-cell composite + per-judge dimensions, aggregate mean, cost,\n *  duration. The dashboard renders these as the baseline → winner comparison. */\nfunction snapshotFromHoldout<TArtifact, TScenario extends Scenario>(\n  index: number,\n  surfaceHash: string,\n  surface: MutableSurface,\n  campaign: CampaignResult<TArtifact, TScenario>,\n): EvalRunGenerationSnapshot {\n  const cells: EvalRunCellScore[] = campaign.cells.map((cell) => {\n    const judgeScores = Object.values(cell.judgeScores)\n    const composite =\n      judgeScores.length === 0\n        ? 0\n        : judgeScores.reduce((s, j) => s + j.composite, 0) / judgeScores.length\n    const score: EvalRunCellScore = {\n      scenarioId: cell.scenarioId,\n      rep: cell.rep,\n      compositeMean: composite,\n      dimensions: Object.fromEntries(\n        Object.entries(cell.judgeScores).map(([name, s]) => [name, s.dimensions]),\n      ),\n    }\n    if (cell.error) score.errorMessage = cell.error\n    return score\n  })\n  const compositeMean =\n    cells.length === 0 ? 0 : cells.reduce((s, c) => s + c.compositeMean, 0) / cells.length\n  return {\n    index,\n    surfaceHash,\n    surface,\n    cells,\n    compositeMean,\n    costUsd: campaign.aggregates.totalCostUsd,\n    durationMs: campaign.durationMs,\n  }\n}\n\n/** Build the hosted `EvalRunEvent` from the loop args + record — baseline +\n *  winner snapshots, gate decision, held-out lift, cost, duration. Shipped to\n *  `/v1/ingest/eval-runs` so the run appears in the dashboard's run list (the\n *  trace spans, shipped separately, back the per-candidate drill-down). */\nfunction buildEvalRunEvent<TArtifact, TScenario extends Scenario>(\n  args: EmitLoopProvenanceArgs<TArtifact, TScenario>,\n  record: LoopProvenanceRecord,\n): EvalRunEvent {\n  return {\n    runId: args.runId,\n    runDir: args.runDir,\n    timestamp: args.timestamp,\n    status: 'finished',\n    labels: {},\n    baseline: snapshotFromHoldout(\n      0,\n      record.baselineContentHash,\n      args.baselineSurface,\n      args.baselineOnHoldout,\n    ),\n    generations: [\n      snapshotFromHoldout(1, record.winnerContentHash, args.winnerSurface, args.winnerOnHoldout),\n    ],\n    gateDecision: args.gate.decision,\n    holdoutLift: record.heldOutLift,\n    totalCostUsd: args.totalCostUsd,\n    totalDurationMs: args.totalDurationMs,\n  }\n}\n\n/**\n * Build the provenance record + OTel spans and persist them durably under the\n * run dir (and ship spans to a hosted collector when one is wired). Returns\n * both artifacts so the caller can assert on / re-derive from them.\n *\n * Fail-loud: the durable write throws on storage failure (a swallowed write is\n * exactly the \"emitted but lost\" failure this closes). The hosted span ship is\n * the one best-effort leg — its failure is logged, not thrown, so an offline\n * collector never fails the loop (the durable artifact is the source of truth).\n */\nexport async function emitLoopProvenance<TArtifact, TScenario extends Scenario>(\n  args: EmitLoopProvenanceArgs<TArtifact, TScenario>,\n): Promise<EmitLoopProvenanceResult> {\n  const record = buildLoopProvenanceRecord(args)\n  const spans = loopProvenanceSpans(record)\n\n  args.storage.ensureDir(args.runDir)\n  const recordPath = provenanceRecordPath(args.runDir)\n  const spansPath = provenanceSpansPath(args.runDir)\n  args.storage.write(recordPath, JSON.stringify(record, null, 2))\n  args.storage.write(spansPath, spans.map((s) => JSON.stringify(s)).join('\\n'))\n\n  if (args.hostedClient) {\n    // Ship BOTH streams so the run is fully visible in the dashboard: the\n    // eval-run event (→ run list + baseline/winner/gate/lift) AND the trace\n    // spans (→ per-candidate drill-down). Best-effort: an offline collector is\n    // logged, never thrown — the durable artifact above is the source of truth.\n    try {\n      await args.hostedClient.ingestEvalRun(buildEvalRunEvent(args, record))\n    } catch (err) {\n      const msg = err instanceof Error ? err.message : String(err)\n      // eslint-disable-next-line no-console -- intentional: hosted ingest is best-effort\n      console.warn(`[agent-eval] hosted eval-run ingest failed (continuing): ${msg}`)\n    }\n    try {\n      await args.hostedClient.ingestTraces(spans)\n    } catch (err) {\n      const msg = err instanceof Error ? err.message : String(err)\n      // eslint-disable-next-line no-console -- intentional: hosted span ship is best-effort\n      console.warn(`[agent-eval] provenance span ingest failed (continuing): ${msg}`)\n    }\n  }\n\n  return { record, spans, recordPath, spansPath }\n}\n"],"mappings":"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","names":[]}