@tangle-network/agent-eval 0.94.0 → 0.95.1

package/dist/rl.d.ts

@@ -1,26 +1,246 @@
-export { O as OffPolicyEstimate, a as OffPolicyOptions, b as OffPolicyTrajectory, d as doublyRobust, i as inverseProbabilityWeighting, o as offPolicyEstimateAll, s as selfNormalizedImportanceWeighting } from './off-policy-DiwuKKg7.js';
-import { P as PreferenceExtractionReport, D as DpoExportRow, G as GrpoExportRow, S as SftExportRow, E as ExtractPreferencesOptions, a as DpoLookups, b as GrpoLookups, c as SftLookups } from './corpus-B8A4BDR3.js';
-export { d as CorpusAppendResult, C as CorpusRecord, e as DatasetFormat, f as ExtractStepRewardsOptions, H as HarvestOptions, g as PreferenceStrategy, h as PreferenceTriple, i as PrmExportRow, j as PrmLookups, k as PrmTrainingTriple, R as RewardKind, l as RewardStats, m as RlDatasetBundle, n as RlDatasetConfig, o as RlDatasetManifest, p as RlDatasetStats, q as RunwiseStepSummary, r as StepReward, s as StepRewardJsonlRow, t as StepScorer, u as appendToCorpus, v as buildDatasetFromCorpus, w as buildRlDataset, x as datasheetToMarkdown, y as extractPreferences, z as extractStepRewards, A as prmTrainingPairs, B as readCorpus, F as runwiseStepRewardSummary, I as stepRewardsToJsonl, J as toAnthropicFormat, K as toDpoJsonl, L as toDpoRows, M as toGrpoJsonl, N as toGrpoRows, O as toPrmJsonl, Q as toPrmRows, T as toSftJsonl, U as toSftRows, V as toTRLFormat } from './corpus-B8A4BDR3.js';
-import { g as CampaignResult } from './types-BU-7W85F.js';
-import { a as RunSplitTag, R as RunRecord } from './run-record-e7vj1uZQ.js';
-import { a as VerificationReport } from './multi-layer-verifier-DUZXrPDA.js';
+import { R as RunRecord, a as RunSplitTag } from './run-record-CP2ObebC.js';
 export { A as AdversarialMutation, a as AdversarialScenario, b as AdversarialSearchOptions, c as AdversarialSearchReport, d as adversarialScenarioSearch } from './adversarial-DIVcDoI_.js';
+import { P as PreferenceExtractionReport, D as DpoExportRow, G as GrpoExportRow, S as SftExportRow, E as ExtractPreferencesOptions, a as DpoLookups, b as GrpoLookups, c as SftLookups } from './corpus-D4YW9UoJ.js';
+export { d as CorpusAppendResult, C as CorpusRecord, e as DatasetFormat, f as ExtractStepRewardsOptions, H as HarvestOptions, g as PreferenceStrategy, h as PreferenceTriple, i as PrmExportRow, j as PrmLookups, k as PrmTrainingTriple, R as RewardKind, l as RewardStats, m as RlDatasetBundle, n as RlDatasetConfig, o as RlDatasetManifest, p as RlDatasetStats, q as RunwiseStepSummary, r as StepReward, s as StepRewardJsonlRow, t as StepScorer, u as appendToCorpus, v as buildDatasetFromCorpus, w as buildRlDataset, x as datasheetToMarkdown, y as extractPreferences, z as extractStepRewards, A as prmTrainingPairs, B as readCorpus, F as runwiseStepRewardSummary, I as stepRewardsToJsonl, J as toAnthropicFormat, K as toDpoJsonl, L as toDpoRows, M as toGrpoJsonl, N as toGrpoRows, O as toPrmJsonl, Q as toPrmRows, T as toSftJsonl, U as toSftRows, V as toTRLFormat } from './corpus-D4YW9UoJ.js';
+export { O as OffPolicyEstimate, a as OffPolicyOptions, b as OffPolicyTrajectory, d as doublyRobust, i as inverseProbabilityWeighting, o as offPolicyEstimateAll, s as selfNormalizedImportanceWeighting } from './off-policy-DiwuKKg7.js';
 import { b as OutcomeStore } from './outcome-store-rnXLEqSn.js';
 export { D as DeploymentOutcome, F as FileSystemOutcomeStore, a as FileSystemOutcomeStoreOptions, I as InMemoryOutcomeStore } from './outcome-store-rnXLEqSn.js';
-import { b as RubricPredictiveValidityReport } from './rubric-predictive-validity-Cy_W-hWZ.js';
-import { R as Researcher, F as FailureMode, S as SteeringChange, E as ExperimentPlan, a as ExperimentResult, b as EvalCampaignResult, c as EvalCampaignOptions } from './researcher-B0C2_fVO.js';
-export { r as runEvalCampaign } from './researcher-B0C2_fVO.js';
+import { b as RubricPredictiveValidityReport } from './rubric-predictive-validity-C2hDKM8Z.js';
+import { R as Researcher, F as FailureMode, S as SteeringChange, E as ExperimentPlan, a as ExperimentResult, b as EvalCampaignResult, c as EvalCampaignOptions } from './researcher-Jr8ME1dZ.js';
+export { r as runEvalCampaign } from './researcher-Jr8ME1dZ.js';
+import { a as VerificationReport } from './multi-layer-verifier-DUZXrPDA.js';
 import { I as InterimReleaseConfidence } from './sequential-5iSVfzl2.js';
+import { C as CampaignResult } from './types-DQRY8ZT-.js';
+import '@tangle-network/agent-interface';
+import './errors-CzMUYo7b.js';
 import './schema-m0gsnbt3.js';
 import './store-BcFXE6LG.js';
-import './errors-CzMUYo7b.js';
-import './verdict-C9MlYujm.js';
 import './llm-client-Bj7g0rqu.js';
 import './raw-provider-sink-C46HDghv.js';
-import './summary-report-BDOFevaT.js';
+import './summary-report-CInXwsza.js';
 import './failure-cluster-DH9Flgcf.js';
 import './emitter-C2rqGH_l.js';
 import './integrity-D2t12mMw.js';
+import './verdict-C9MlYujm.js';
+
+/**
+ * Adaptive curriculum / active scenario selection.
+ *
+ * Fixed scenario sets waste sample budget on cells the policy already
+ * passes (no information left) and cells the policy never passes (no
+ * gradient available either). Active learning over scenarios fixes this
+ * by allocating the next sample budget to cells where the policy's
+ * outcome is *uncertain* — those carry the most decision-relevant signal.
+ *
+ * This module ships two complementary strategies:
+ *
+ *   1. **Variance-based** — score each (variant, scenario) cell by the
+ *      empirical variance of past observations. Allocate next-round budget
+ *      proportional to variance. Standard active-learning-by-uncertainty
+ *      heuristic; works well when the policy is non-deterministic and
+ *      cells differ in observation noise.
+ *
+ *   2. **Bandit-based (Thompson sampling)** — model each (variant,
+ *      scenario) cell as a Beta-Bernoulli arm; sample a posterior; pick
+ *      cells whose posterior mean is closest to the per-scenario decision
+ *      threshold. The right primitive when scenarios are
+ *      "pass/fail" rather than continuous, and when promotion gates fire
+ *      at a known threshold (e.g., 0.5).
+ *
+ * The output is a *next-round budget allocation* — a list of (variant,
+ * scenario, count) triples. The consumer's matrix runner consumes the
+ * allocation, runs those cells, feeds the new observations back. Loop.
+ *
+ * Out of scope (deliberate): scenario *generation* — that's the
+ * adversarial primitive's job. This module allocates over an existing
+ * scenario pool.
+ */
+
+interface CellObservation {
+    variantId: string;
+    scenarioId: string;
+    /** Observed score in [0, 1]. */
+    score: number;
+    /** For Bernoulli arms — derive from the score with a threshold if needed. */
+    pass?: boolean;
+}
+interface CurriculumAllocation {
+    variantId: string;
+    scenarioId: string;
+    /** How many additional reps to run on this cell. */
+    count: number;
+    /** Strategy-specific reason for the allocation. */
+    reason: string;
+}
+interface VarianceCurriculumOptions {
+    /** Total reps to allocate across all cells. */
+    budget: number;
+    /**
+     * Smoothing prior on variance — keeps the allocator from concentrating
+     * on a cell with one observation just because its 1-sample variance is
+     * 0. Default 0.05.
+     */
+    variancePrior?: number;
+    /**
+     * Minimum reps per cell — even when the variance estimate is low, give
+     * every cell at least this many. Default 1.
+     */
+    floorPerCell?: number;
+}
+/**
+ * Variance-proportional allocation. For each cell, estimate variance from
+ * past observations + a prior, then allocate the budget proportional to
+ * (sqrt(variance) + 1/sqrt(n)) — a classical optimal-allocation rule
+ * (Neyman 1934) that balances "explore noisy cells" with "explore
+ * under-sampled cells."
+ */
+declare function varianceBasedCurriculum(observations: CellObservation[], candidateCells: Array<{
+    variantId: string;
+    scenarioId: string;
+}>, opts: VarianceCurriculumOptions): CurriculumAllocation[];
+interface ThompsonCurriculumOptions {
+    budget: number;
+    /**
+     * The per-scenario decision threshold. Cells whose posterior mean is
+     * closest to this get the most budget — that's where the next observation
+     * has the highest information value for the gate decision. Default 0.5.
+     */
+    decisionThreshold?: number;
+    /** Beta prior parameters. Default α=β=1 (uniform). */
+    priorAlpha?: number;
+    priorBeta?: number;
+    /** Seed the Thompson sampler. Default unset (Math.random). */
+    seed?: number;
+}
+/**
+ * Thompson-sampling-style allocation for pass/fail cells. For each cell:
+ *
+ *   - Maintain Beta(α + passes, β + failures) posterior on pass-rate
+ *   - Allocation weight ∝ exp(-((sampledMean - threshold) / σ)^2):
+ *     cells whose sampled posterior straddles the decision boundary get
+ *     the most weight; cells already clearly above or below get less.
+ *
+ * This is the right primitive when promotion gates fire at a known
+ * threshold and you want to sharpen the posterior near the boundary.
+ */
+declare function thompsonCurriculum(observations: CellObservation[], candidateCells: Array<{
+    variantId: string;
+    scenarioId: string;
+}>, opts: ThompsonCurriculumOptions): CurriculumAllocation[];
+/** Convenience: extract `CellObservation[]` directly from `RunRecord[]`. */
+declare function observationsFromRunRecords(runs: RunRecord[], opts?: {
+    passThreshold?: number;
+    useHoldout?: boolean;
+}): CellObservation[];
+
+/**
+ * Sample-efficient adaptation evaluation.
+ *
+ * For foundation-model-based agents, the load-bearing capability isn't
+ * raw end-state performance — it's *how fast the agent reaches that
+ * performance from cold start*. The same model with a worse prompt that
+ * adapts in 5 demonstrations beats the same model with a better prompt
+ * that needs 50. Standard meta-learning eval (Finn et al., MAML, RL² lit)
+ * reports an *adaptation curve*: score after k=0, 1, 2, 4, 8, 16, …
+ * in-context examples or fine-tune steps.
+ *
+ * This module ships:
+ *
+ *   1. `runAdaptationCurve` — given a runner that takes k demonstrations
+ *      and returns a score, produce the (k, score) curve.
+ *   2. `compareAdaptationCurves` — paired comparison across two policies.
+ *      Returns per-k delta with bootstrap CIs and an "area-under-curve"
+ *      summary statistic.
+ *   3. `firstPassK` — for pass/fail evaluation, the minimum k at which
+ *      the policy reliably passes (≥ pass-rate threshold over reps).
+ *
+ * Use cases:
+ *   - Compare two prompt designs that have similar end-state performance
+ *     but different in-context efficiency.
+ *   - Decide between fine-tuning and prompting based on adaptation cost.
+ *   - Detect when a policy "memorizes" k=0 inputs vs. genuinely adapts.
+ */
+interface AdaptationRunner<S> {
+    /**
+     * Runs the policy on `scenario` with `k` demonstrations. Returns a
+     * scalar score in [0, 1]. The runner is responsible for any caching;
+     * the harness calls it once per (scenario, k, rep) cell.
+     */
+    run(args: {
+        scenario: S;
+        k: number;
+        rep: number;
+    }): Promise<number>;
+}
+interface RunAdaptationCurveOptions<S> {
+    scenarios: S[];
+    /** Number-of-shots to evaluate at. Default `[0, 1, 2, 4, 8, 16]`. */
+    ks?: number[];
+    /** Reps per (scenario, k) cell. Default 3. */
+    reps?: number;
+    runner: AdaptationRunner<S>;
+    /** Pass-rate threshold for `firstPassK` reporting. Default 0.5. */
+    passThreshold?: number;
+}
+interface AdaptationPoint {
+    k: number;
+    meanScore: number;
+    passRate: number;
+    std: number;
+    n: number;
+    /** Per-scenario means at this k. */
+    perScenario: Array<{
+        scenarioId: string;
+        meanScore: number;
+        passes: number;
+        total: number;
+    }>;
+}
+interface AdaptationCurve {
+    points: AdaptationPoint[];
+    /**
+     * Smallest `k` at which `passRate ≥ passThreshold`. `null` if no `k`
+     * tested reaches it.
+     */
+    firstPassK: number | null;
+    /**
+     * Area under the (k, meanScore) curve, normalized by max-k. A
+     * single-number summary of "how well does this policy adapt from
+     * cold-start to fully-conditioned." Higher = better adapter.
+     */
+    adaptationArea: number;
+}
+declare function runAdaptationCurve<S extends {
+    scenarioId?: string;
+}>(opts: RunAdaptationCurveOptions<S>): Promise<AdaptationCurve>;
+interface CompareCurvesResult {
+    perK: Array<{
+        k: number;
+        deltaMean: number;
+        aLow: number;
+        aHigh: number;
+        bLow: number;
+        bHigh: number;
+    }>;
+    areaDelta: number;
+    firstPassKDelta: number | null;
+    /** Verdict: 'a_better' | 'b_better' | 'similar'. */
+    verdict: 'a_better' | 'b_better' | 'similar';
+    /** Rationale, ready to render. */
+    rationale: string;
+}
+/**
+ * Paired comparison of two adaptation curves. Per-k deltas with 95%
+ * bootstrap CIs (constructed from each curve's `perScenario` per-k means
+ * — the bootstrap unit is the scenario, not the rep).
+ */
+declare function compareAdaptationCurves(a: AdaptationCurve, b: AdaptationCurve, opts?: {
+    confidence?: number;
+    bootstrapResamples?: number;
+    seed?: number;
+}): CompareCurvesResult;
+/** First k at which the curve's per-scenario pass rate reliably hits the threshold. */
+declare function firstPassK(curve: AdaptationCurve, threshold?: number): number | null;
 
 /**
  * Test-time compute scaling curves.
@@ -267,173 +487,70 @@ declare function injectIrrelevantClause<S extends {
 }>(clause: string, position?: 'prefix' | 'suffix'): ScenarioPerturbation<S>;
 
 /**
- * Adapters: convert measurement outputs into the canonical `RunRecord[]`
- * artifact that `replayCache`, `pairedEvalueSequence`, and
- * `rubricPredictiveValidity` consume. Two sources:
- *   - `campaignToRunRecords` — the campaign substrate's per-cell results
- *     (the modern path: `runCampaign` / `runImprovementLoop` → records).
- *   - `verificationReportToRunRecord` — a `MultiLayerVerifier` report.
+ * `PredictiveValidityResearcher` — concrete `Researcher` implementation
+ * that drives selection from outcome-anchored predictive validity.
  *
- * Adapters are thin and explicit — every mandatory `RunRecord` field comes
- * from a caller-supplied context (`commitSha`, `model`, `promptHash`,
- * `configHash`) plus the cell's runtime data. The validator still rejects
- * bare-alias model strings — the caller snapshot-pins.
+ * Each method:
+ *
+ *   - `inspectFailures(runs)` — synthesizes failure modes from the
+ *     bottom-quartile of `RunRecord`s on the configured proxy reward.
+ *   - `proposeChange(failures)` — proposes steering changes that target
+ *     the rubrics with the lowest predictive validity (decorative ones).
+ *     Either reduce their weight in the composite, or recalibrate them.
+ *   - `applyChange(changes, baseline)` — merges the proposed steering
+ *     into the experiment plan.
+ *   - `evaluateChange(plan)` — re-runs the predictive-validity check on
+ *     the post-change runs and reports the delta.
+ *
+ * The result is a closed loop: the rubric weights drift toward the ones
+ * that actually predict deployment outcomes, automatically. Pair with
+ * `runRLCampaign` for the full auto-research story.
  */
 
-interface AdapterContext {
-    /** Logical experiment id — typically the campaign or sweep identifier. */
-    experimentId: string;
-    /** Snapshot model id (e.g. `claude-sonnet-4-6@2025-04-15`). */
-    model: string;
-    /** Git SHA the harness was run from. */
-    commitSha: string;
-    /** Hash of the effective prompt sent to the model. */
-    promptHash: string;
-    /** Hash of the effective config (model, temperature, tools, judges, splits). */
-    configHash: string;
-    /** Default split tag. Default `'search'`. */
-    splitTag?: RunSplitTag;
-    /** Default cost in USD when the source doesn't record one. Default `0`. */
-    defaultCostUsd?: number;
-}
-/**
- * Convert a `CampaignResult` into canonical `RunRecord[]` — one record per
- * scored cell. The cell's mean judge composite becomes the split score; every
- * judge dimension is carried through to `outcome.raw`. A cell that errored
- * becomes a record with `failureMode: 'cell_error'` (kept, not dropped — an
- * unscored cell is signal). `candidateId` identifies the measured surface
- * (defaults to the campaign manifest hash).
- */
-declare function campaignToRunRecords(campaign: CampaignResult, ctx: AdapterContext & {
-    candidateId?: string;
-}): RunRecord[];
-/**
- * Convert a `MultiLayerVerifier` `VerificationReport` into a `RunRecord`.
- * `outcome.searchScore` (or `holdoutScore`) is `report.blendedScore`;
- * `outcome.raw` carries every layer's score + a pass indicator; `failureMode`
- * is the first failing layer's reason.
- */
-declare function verificationReportToRunRecord(report: VerificationReport, ctx: AdapterContext & {
-    candidateId: string;
-    scenarioId?: string;
-}, opts?: {
-    runId?: string;
-}): RunRecord;
-
-/**
- * Bradley-Terry / Elo tournament evaluation.
- *
- * For multi-candidate sweeps, comparing every candidate's score against
- * a fixed comparator wastes information — the comparator becomes a high-
- * variance reference and rank flips between near-tied middle-rank
- * candidates are dominated by noise. Pairwise tournaments fix this:
- * every (i, j) pair contributes a comparison to a Bradley-Terry MLE that
- * estimates each candidate's strength on a unified scale.
- *
- * For online updating (rolling campaigns where new candidates arrive
- * over time), we also ship classical Elo with configurable K-factor.
- *
- * References:
- *   - Bradley, R. A., Terry, M. E. (1952). Rank analysis of incomplete
- *     block designs. Biometrika, 39(3/4), 324–345.
- *   - Hunter, D. R. (2004). MM algorithms for generalized Bradley-Terry
- *     models. Annals of Statistics, 32(1), 384–406. (The MLE algorithm
- *     used here.)
- *   - Elo, A. E. (1978). The Rating of Chess Players, Past and Present.
- *
- * This is a useful primitive because most LLM-eval communities (Chatbot
- * Arena, AlpacaEval, ELO-style ablation) have converged on pairwise
- * tournament eval as the most sample-efficient and most rank-stable
- * method when you have many candidates.
- */
-interface PairwiseOutcome {
-    /** Winner candidate id. */
-    winner: string;
-    /** Loser candidate id. */
-    loser: string;
-    /**
-     * Optional draw flag. When true, both candidates get half-credit
-     * (Bradley-Terry handles draws as half-wins for each side).
-     */
-    draw?: boolean;
+interface PredictiveValidityResearcherOptions {
+    outcomes: OutcomeStore;
+    outcomeMetrics: string[];
+    /** Score threshold below which a run counts as a "failure." Default 0.5. */
+    failureThreshold?: number;
+    /** Spearman bucket below which a rubric is "decorative." Default 0.4. */
+    decorativeThreshold?: number;
+    /** Optional steering-namespace prefix for proposed changes. Default `'rubric_weight'`. */
+    steeringNamespace?: string;
+    /** Override the rubric set the researcher inspects. Default: every numeric `outcome.raw` key seen. */
+    rubrics?: string[];
     /**
-     * Optional weight — useful if some pairwise comparisons are stronger
-     * signals than others (e.g. a paired test with a wider score gap is
-     * a more confident comparison). Default 1.
+     * Snapshot stash hook — called with the most recent predictive-validity
+     * report. Useful when a downstream system wants to log rubric drift over
+     * time. Default no-op.
      */
-    weight?: number;
-}
-interface BradleyTerryRating {
-    candidateId: string;
-    /** Latent strength θ ≥ 0 from the BT MLE. */
-    strength: number;
-    /** Log-strength = log(θ) — interpretable on a linear scale. */
-    logStrength: number;
-    /** Number of pairwise comparisons this candidate appears in. */
-    n: number;
-    /** Win count (+ 0.5 per draw). */
-    wins: number;
-}
-interface BradleyTerryFit {
-    ratings: BradleyTerryRating[];
-    /** Iterations of the MM algorithm before convergence. */
-    iterations: number;
-    /** Final maximum |θ_new - θ_old| / θ_old. */
-    finalDelta: number;
-    converged: boolean;
-}
-/**
- * Bradley-Terry MLE via Hunter's MM algorithm.
- *
- * Iteration: θ_i^new = W_i / Σ_{j ≠ i} N_ij / (θ_i + θ_j)
- *   where W_i = wins by i (+ 0.5 per draw), N_ij = total comparisons.
- *
- * Returns log-strengths normalized so the smallest is 0 (any constant
- * offset is unobservable in BT — only differences are identified).
- */
-declare function fitBradleyTerry(outcomes: PairwiseOutcome[], opts?: {
-    tolerance?: number;
-    maxIterations?: number;
-    smoothing?: number;
-}): BradleyTerryFit;
-/**
- * Online Elo updates. Use when comparisons arrive over time and you want
- * a running rating without re-fitting the full BT MLE on every update.
- *
- * Initialize ratings to `defaultRating` (1500 by default). Each call to
- * `applyEloUpdate` mutates the map in place and returns the deltas so
- * the caller can log per-comparison rating changes.
- */
-interface EloOptions {
-    /** Default rating for unseen candidates. Default 1500. */
-    defaultRating?: number;
-    /** K-factor controls the step size. Default 32 (FIDE-ish). */
-    kFactor?: number;
+    onReport?: (report: RubricPredictiveValidityReport) => void | Promise<void>;
 }
-declare function applyEloUpdate(ratings: Map<string, number>, outcome: PairwiseOutcome, opts?: EloOptions): {
-    winnerDelta: number;
-    loserDelta: number;
-};
 /**
- * Build pairwise outcomes from the campaign artifact: for every scenario
- * shared by two candidates, the higher-scoring run wins. Useful when you
- * want a tournament view of an existing campaign without an additional
- * pairwise judge call.
+ * Concrete `Researcher` driven by `rubricPredictiveValidity`. The brain:
+ * rubrics that don't predict deployment outcomes don't earn weight.
  */
-interface BuildPairwiseFromCampaignInput {
-    runs: Array<{
-        candidateId: string;
-        /** Stable identifier for the matching unit (typically scenarioId). */
-        matchKey: string;
-        score: number;
-    }>;
+declare class PredictiveValidityResearcher implements Researcher {
+    private opts;
+    private lastReport;
+    constructor(opts: PredictiveValidityResearcherOptions);
+    inspectFailures(runs: RunRecord[]): Promise<FailureMode[]>;
+    proposeChange(failures: FailureMode[]): Promise<SteeringChange[]>;
+    applyChange(changes: SteeringChange[], baseline: ExperimentPlan): Promise<ExperimentPlan>;
+    evaluateChange(plan: ExperimentPlan): Promise<ExperimentResult>;
     /**
-     * Tied-score margin. Below this, the comparison is a draw. Default 0
-     * (no ties).
+     * Run the predictive-validity check explicitly against a fresh RunRecord
+     * set. Updates the researcher's cached report so subsequent
+     * `proposeChange` calls have evidence to draw from.
      */
-    drawMargin?: number;
+    runValidityCheck(runs: RunRecord[]): Promise<RubricPredictiveValidityReport>;
+    /**
+     * Force-feed a predictive-validity report into the researcher state —
+     * useful when the consumer ran the report out-of-band and wants the
+     * researcher's later proposals informed by it.
+     */
+    setReport(report: RubricPredictiveValidityReport): void;
+    getLastReport(): RubricPredictiveValidityReport | null;
 }
-declare function buildPairwiseFromCampaign(input: BuildPairwiseFromCampaignInput): PairwiseOutcome[];
 
 /**
  * Verifiable reward channel.
@@ -487,361 +604,76 @@ interface VerifiableReward {
     /** The layer / judge id that produced the signal, for provenance. */
     origin: string;
     /**
-     * Per-source contribution to `value`, keyed by layer/judge id. Single-source
-     * rewards carry one entry (`{ [origin]: value }`); composite rewards carry
-     * every contributing layer's score — the anti-scalar-collapse surface RL
-     * consumers weight per-source instead of trusting one blended number.
-     */
-    components: Record<string, number>;
-    /**
-     * @deprecated Read `components` for per-source reward values. Kept for
-     * published-API compatibility: single-source rewards carry the layer's
-     * diagnostics here (e.g. `{ tests_passed: 7 }`); composite rewards carry
-     * the same per-layer scores `components` now holds.
-     */
-    breakdown?: Record<string, number>;
-}
-interface VerifiableRewardExtractionOptions {
-    /**
-     * Which layers count as deterministic-reward sources. The verifier doesn't
-     * tag layers as "this is verifiable"; the caller declares it via this list
-     * (or via the layer name → source mapping). Default treats common names
-     * (`install`, `typecheck`, `build`, `lint`, `test`, `compile`, `schema`,
-     * `sandbox`) as deterministic.
-     */
-    deterministicLayers?: string[];
-    /**
-     * Map layer name → reward source. Defaults to a sensible string-match.
-     */
-    sourceFor?: (layerName: string) => VerifiableRewardSource;
-    /**
-     * Whether to fall back to a probabilistic (judge) reward when no
-     * deterministic layer produced a numeric score. Default `true`. Set to
-     * `false` for "deterministic-only" training pipelines that should
-     * discard runs without a verifiable signal.
-     */
-    fallbackToJudge?: boolean;
-    /**
-     * Default confidence for probabilistic (judge) rewards when the judge
-     * doesn't report one. Default `0.7`.
-     */
-    judgeConfidenceFloor?: number;
-}
-/**
- * Extract a `VerifiableReward` from a `VerificationReport`.
- *
- * Strategy: prefer the deterministic layers (in order: test → compile →
- * schema → sandbox), fall back to the judge layer if `fallbackToJudge` is
- * true, return `null` if no signal qualifies. When multiple deterministic
- * layers contribute, return a `'composite'` source with a weighted blend.
- */
-declare function extractVerifiableReward(report: VerificationReport, opts?: VerifiableRewardExtractionOptions): VerifiableReward | null;
-/**
- * Extract verifiable rewards from `RunRecord[]` produced via the
- * `verificationReportToRunRecord` adapter (which encodes per-layer scores
- * in `outcome.raw['layer.<name>']`). For records that don't carry layer
- * scores, returns `null` for that record.
- *
- * This is the canonical bridge from "campaign-shaped artifacts" to
- * "RL-training-ready reward signals": every record that has a clean
- * verifiable reward becomes a training datum, every record that doesn't
- * gets filtered out (or kept with `'probabilistic'` determinism for
- * separate downstream handling).
- */
-declare function extractVerifiableRewardsFromRecords(runs: RunRecord[], opts?: VerifiableRewardExtractionOptions): Array<{
-    runId: string;
-    reward: VerifiableReward | null;
-}>;
-/** Filter `RunRecord[]` to those with deterministic verifiable rewards. */
-declare function filterDeterministicallyRewarded(runs: RunRecord[], opts?: VerifiableRewardExtractionOptions): Array<{
-    run: RunRecord;
-    reward: VerifiableReward;
-}>;
-
-/**
- * Adaptive curriculum / active scenario selection.
- *
- * Fixed scenario sets waste sample budget on cells the policy already
- * passes (no information left) and cells the policy never passes (no
- * gradient available either). Active learning over scenarios fixes this
- * by allocating the next sample budget to cells where the policy's
- * outcome is *uncertain* — those carry the most decision-relevant signal.
- *
- * This module ships two complementary strategies:
- *
- *   1. **Variance-based** — score each (variant, scenario) cell by the
- *      empirical variance of past observations. Allocate next-round budget
- *      proportional to variance. Standard active-learning-by-uncertainty
- *      heuristic; works well when the policy is non-deterministic and
- *      cells differ in observation noise.
- *
- *   2. **Bandit-based (Thompson sampling)** — model each (variant,
- *      scenario) cell as a Beta-Bernoulli arm; sample a posterior; pick
- *      cells whose posterior mean is closest to the per-scenario decision
- *      threshold. The right primitive when scenarios are
- *      "pass/fail" rather than continuous, and when promotion gates fire
- *      at a known threshold (e.g., 0.5).
- *
- * The output is a *next-round budget allocation* — a list of (variant,
- * scenario, count) triples. The consumer's matrix runner consumes the
- * allocation, runs those cells, feeds the new observations back. Loop.
- *
- * Out of scope (deliberate): scenario *generation* — that's the
- * adversarial primitive's job. This module allocates over an existing
- * scenario pool.
- */
-
-interface CellObservation {
-    variantId: string;
-    scenarioId: string;
-    /** Observed score in [0, 1]. */
-    score: number;
-    /** For Bernoulli arms — derive from the score with a threshold if needed. */
-    pass?: boolean;
-}
-interface CurriculumAllocation {
-    variantId: string;
-    scenarioId: string;
-    /** How many additional reps to run on this cell. */
-    count: number;
-    /** Strategy-specific reason for the allocation. */
-    reason: string;
-}
-interface VarianceCurriculumOptions {
-    /** Total reps to allocate across all cells. */
-    budget: number;
-    /**
-     * Smoothing prior on variance — keeps the allocator from concentrating
-     * on a cell with one observation just because its 1-sample variance is
-     * 0. Default 0.05.
-     */
-    variancePrior?: number;
-    /**
-     * Minimum reps per cell — even when the variance estimate is low, give
-     * every cell at least this many. Default 1.
-     */
-    floorPerCell?: number;
-}
-/**
- * Variance-proportional allocation. For each cell, estimate variance from
- * past observations + a prior, then allocate the budget proportional to
- * (sqrt(variance) + 1/sqrt(n)) — a classical optimal-allocation rule
- * (Neyman 1934) that balances "explore noisy cells" with "explore
- * under-sampled cells."
- */
-declare function varianceBasedCurriculum(observations: CellObservation[], candidateCells: Array<{
-    variantId: string;
-    scenarioId: string;
-}>, opts: VarianceCurriculumOptions): CurriculumAllocation[];
-interface ThompsonCurriculumOptions {
-    budget: number;
-    /**
-     * The per-scenario decision threshold. Cells whose posterior mean is
-     * closest to this get the most budget — that's where the next observation
-     * has the highest information value for the gate decision. Default 0.5.
-     */
-    decisionThreshold?: number;
-    /** Beta prior parameters. Default α=β=1 (uniform). */
-    priorAlpha?: number;
-    priorBeta?: number;
-    /** Seed the Thompson sampler. Default unset (Math.random). */
-    seed?: number;
-}
-/**
- * Thompson-sampling-style allocation for pass/fail cells. For each cell:
- *
- *   - Maintain Beta(α + passes, β + failures) posterior on pass-rate
- *   - Allocation weight ∝ exp(-((sampledMean - threshold) / σ)^2):
- *     cells whose sampled posterior straddles the decision boundary get
- *     the most weight; cells already clearly above or below get less.
- *
- * This is the right primitive when promotion gates fire at a known
- * threshold and you want to sharpen the posterior near the boundary.
- */
-declare function thompsonCurriculum(observations: CellObservation[], candidateCells: Array<{
-    variantId: string;
-    scenarioId: string;
-}>, opts: ThompsonCurriculumOptions): CurriculumAllocation[];
-/** Convenience: extract `CellObservation[]` directly from `RunRecord[]`. */
-declare function observationsFromRunRecords(runs: RunRecord[], opts?: {
-    passThreshold?: number;
-    useHoldout?: boolean;
-}): CellObservation[];
-
-/**
- * Sample-efficient adaptation evaluation.
- *
- * For foundation-model-based agents, the load-bearing capability isn't
- * raw end-state performance — it's *how fast the agent reaches that
- * performance from cold start*. The same model with a worse prompt that
- * adapts in 5 demonstrations beats the same model with a better prompt
- * that needs 50. Standard meta-learning eval (Finn et al., MAML, RL² lit)
- * reports an *adaptation curve*: score after k=0, 1, 2, 4, 8, 16, …
- * in-context examples or fine-tune steps.
- *
- * This module ships:
- *
- *   1. `runAdaptationCurve` — given a runner that takes k demonstrations
- *      and returns a score, produce the (k, score) curve.
- *   2. `compareAdaptationCurves` — paired comparison across two policies.
- *      Returns per-k delta with bootstrap CIs and an "area-under-curve"
- *      summary statistic.
- *   3. `firstPassK` — for pass/fail evaluation, the minimum k at which
- *      the policy reliably passes (≥ pass-rate threshold over reps).
- *
- * Use cases:
- *   - Compare two prompt designs that have similar end-state performance
- *     but different in-context efficiency.
- *   - Decide between fine-tuning and prompting based on adaptation cost.
- *   - Detect when a policy "memorizes" k=0 inputs vs. genuinely adapts.
- */
-interface AdaptationRunner<S> {
-    /**
-     * Runs the policy on `scenario` with `k` demonstrations. Returns a
-     * scalar score in [0, 1]. The runner is responsible for any caching;
-     * the harness calls it once per (scenario, k, rep) cell.
-     */
-    run(args: {
-        scenario: S;
-        k: number;
-        rep: number;
-    }): Promise<number>;
-}
-interface RunAdaptationCurveOptions<S> {
-    scenarios: S[];
-    /** Number-of-shots to evaluate at. Default `[0, 1, 2, 4, 8, 16]`. */
-    ks?: number[];
-    /** Reps per (scenario, k) cell. Default 3. */
-    reps?: number;
-    runner: AdaptationRunner<S>;
-    /** Pass-rate threshold for `firstPassK` reporting. Default 0.5. */
-    passThreshold?: number;
-}
-interface AdaptationPoint {
-    k: number;
-    meanScore: number;
-    passRate: number;
-    std: number;
-    n: number;
-    /** Per-scenario means at this k. */
-    perScenario: Array<{
-        scenarioId: string;
-        meanScore: number;
-        passes: number;
-        total: number;
-    }>;
-}
-interface AdaptationCurve {
-    points: AdaptationPoint[];
-    /**
-     * Smallest `k` at which `passRate ≥ passThreshold`. `null` if no `k`
-     * tested reaches it.
-     */
-    firstPassK: number | null;
-    /**
-     * Area under the (k, meanScore) curve, normalized by max-k. A
-     * single-number summary of "how well does this policy adapt from
-     * cold-start to fully-conditioned." Higher = better adapter.
-     */
-    adaptationArea: number;
-}
-declare function runAdaptationCurve<S extends {
-    scenarioId?: string;
-}>(opts: RunAdaptationCurveOptions<S>): Promise<AdaptationCurve>;
-interface CompareCurvesResult {
-    perK: Array<{
-        k: number;
-        deltaMean: number;
-        aLow: number;
-        aHigh: number;
-        bLow: number;
-        bHigh: number;
-    }>;
-    areaDelta: number;
-    firstPassKDelta: number | null;
-    /** Verdict: 'a_better' | 'b_better' | 'similar'. */
-    verdict: 'a_better' | 'b_better' | 'similar';
-    /** Rationale, ready to render. */
-    rationale: string;
-}
-/**
- * Paired comparison of two adaptation curves. Per-k deltas with 95%
- * bootstrap CIs (constructed from each curve's `perScenario` per-k means
- * — the bootstrap unit is the scenario, not the rep).
- */
-declare function compareAdaptationCurves(a: AdaptationCurve, b: AdaptationCurve, opts?: {
-    confidence?: number;
-    bootstrapResamples?: number;
-    seed?: number;
-}): CompareCurvesResult;
-/** First k at which the curve's per-scenario pass rate reliably hits the threshold. */
-declare function firstPassK(curve: AdaptationCurve, threshold?: number): number | null;
-
-/**
- * `PredictiveValidityResearcher` — concrete `Researcher` implementation
- * that drives selection from outcome-anchored predictive validity.
- *
- * Each method:
- *
- *   - `inspectFailures(runs)` — synthesizes failure modes from the
- *     bottom-quartile of `RunRecord`s on the configured proxy reward.
- *   - `proposeChange(failures)` — proposes steering changes that target
- *     the rubrics with the lowest predictive validity (decorative ones).
- *     Either reduce their weight in the composite, or recalibrate them.
- *   - `applyChange(changes, baseline)` — merges the proposed steering
- *     into the experiment plan.
- *   - `evaluateChange(plan)` — re-runs the predictive-validity check on
- *     the post-change runs and reports the delta.
- *
- * The result is a closed loop: the rubric weights drift toward the ones
- * that actually predict deployment outcomes, automatically. Pair with
- * `runRLCampaign` for the full auto-research story.
- */
-
-interface PredictiveValidityResearcherOptions {
-    outcomes: OutcomeStore;
-    outcomeMetrics: string[];
-    /** Score threshold below which a run counts as a "failure." Default 0.5. */
-    failureThreshold?: number;
-    /** Spearman bucket below which a rubric is "decorative." Default 0.4. */
-    decorativeThreshold?: number;
-    /** Optional steering-namespace prefix for proposed changes. Default `'rubric_weight'`. */
-    steeringNamespace?: string;
-    /** Override the rubric set the researcher inspects. Default: every numeric `outcome.raw` key seen. */
-    rubrics?: string[];
+     * Per-source contribution to `value`, keyed by layer/judge id. Single-source
+     * rewards carry one entry (`{ [origin]: value }`); composite rewards carry
+     * every contributing layer's score — the anti-scalar-collapse surface RL
+     * consumers weight per-source instead of trusting one blended number.
+     */
+    components: Record<string, number>;
     /**
-     * Snapshot stash hook — called with the most recent predictive-validity
-     * report. Useful when a downstream system wants to log rubric drift over
-     * time. Default no-op.
+     * @deprecated Read `components` for per-source reward values. Kept for
+     * published-API compatibility: single-source rewards carry the layer's
+     * diagnostics here (e.g. `{ tests_passed: 7 }`); composite rewards carry
+     * the same per-layer scores `components` now holds.
      */
-    onReport?: (report: RubricPredictiveValidityReport) => void | Promise<void>;
+    breakdown?: Record<string, number>;
 }
-/**
- * Concrete `Researcher` driven by `rubricPredictiveValidity`. The brain:
- * rubrics that don't predict deployment outcomes don't earn weight.
- */
-declare class PredictiveValidityResearcher implements Researcher {
-    private opts;
-    private lastReport;
-    constructor(opts: PredictiveValidityResearcherOptions);
-    inspectFailures(runs: RunRecord[]): Promise<FailureMode[]>;
-    proposeChange(failures: FailureMode[]): Promise<SteeringChange[]>;
-    applyChange(changes: SteeringChange[], baseline: ExperimentPlan): Promise<ExperimentPlan>;
-    evaluateChange(plan: ExperimentPlan): Promise<ExperimentResult>;
+interface VerifiableRewardExtractionOptions {
     /**
-     * Run the predictive-validity check explicitly against a fresh RunRecord
-     * set. Updates the researcher's cached report so subsequent
-     * `proposeChange` calls have evidence to draw from.
+     * Which layers count as deterministic-reward sources. The verifier doesn't
+     * tag layers as "this is verifiable"; the caller declares it via this list
+     * (or via the layer name → source mapping). Default treats common names
+     * (`install`, `typecheck`, `build`, `lint`, `test`, `compile`, `schema`,
+     * `sandbox`) as deterministic.
      */
-    runValidityCheck(runs: RunRecord[]): Promise<RubricPredictiveValidityReport>;
+    deterministicLayers?: string[];
     /**
-     * Force-feed a predictive-validity report into the researcher state —
-     * useful when the consumer ran the report out-of-band and wants the
-     * researcher's later proposals informed by it.
+     * Map layer name → reward source. Defaults to a sensible string-match.
      */
-    setReport(report: RubricPredictiveValidityReport): void;
-    getLastReport(): RubricPredictiveValidityReport | null;
+    sourceFor?: (layerName: string) => VerifiableRewardSource;
+    /**
+     * Whether to fall back to a probabilistic (judge) reward when no
+     * deterministic layer produced a numeric score. Default `true`. Set to
+     * `false` for "deterministic-only" training pipelines that should
+     * discard runs without a verifiable signal.
+     */
+    fallbackToJudge?: boolean;
+    /**
+     * Default confidence for probabilistic (judge) rewards when the judge
+     * doesn't report one. Default `0.7`.
+     */
+    judgeConfidenceFloor?: number;
 }
+/**
+ * Extract a `VerifiableReward` from a `VerificationReport`.
+ *
+ * Strategy: prefer the deterministic layers (in order: test → compile →
+ * schema → sandbox), fall back to the judge layer if `fallbackToJudge` is
+ * true, return `null` if no signal qualifies. When multiple deterministic
+ * layers contribute, return a `'composite'` source with a weighted blend.
+ */
+declare function extractVerifiableReward(report: VerificationReport, opts?: VerifiableRewardExtractionOptions): VerifiableReward | null;
+/**
+ * Extract verifiable rewards from `RunRecord[]` produced via the
+ * `verificationReportToRunRecord` adapter (which encodes per-layer scores
+ * in `outcome.raw['layer.<name>']`). For records that don't carry layer
+ * scores, returns `null` for that record.
+ *
+ * This is the canonical bridge from "campaign-shaped artifacts" to
+ * "RL-training-ready reward signals": every record that has a clean
+ * verifiable reward becomes a training datum, every record that doesn't
+ * gets filtered out (or kept with `'probabilistic'` determinism for
+ * separate downstream handling).
+ */
+declare function extractVerifiableRewardsFromRecords(runs: RunRecord[], opts?: VerifiableRewardExtractionOptions): Array<{
+    runId: string;
+    reward: VerifiableReward | null;
+}>;
+/** Filter `RunRecord[]` to those with deterministic verifiable rewards. */
+declare function filterDeterministicallyRewarded(runs: RunRecord[], opts?: VerifiableRewardExtractionOptions): Array<{
+    run: RunRecord;
+    reward: VerifiableReward;
+}>;
 
 /**
  * Reward hacking / Goodhart detection.
@@ -1023,6 +855,60 @@ interface RLCampaignResult<V> {
 }
 declare function runRLCampaign<V>(opts: RunRLCampaignOptions<V>): Promise<RLCampaignResult<V>>;
 
+/**
+ * Adapters: convert measurement outputs into the canonical `RunRecord[]`
+ * artifact that `replayCache`, `pairedEvalueSequence`, and
+ * `rubricPredictiveValidity` consume. Two sources:
+ *   - `campaignToRunRecords` — the campaign substrate's per-cell results
+ *     (the modern path: `runCampaign` / `runImprovementLoop` → records).
+ *   - `verificationReportToRunRecord` — a `MultiLayerVerifier` report.
+ *
+ * Adapters are thin and explicit — every mandatory `RunRecord` field comes
+ * from a caller-supplied context (`commitSha`, `model`, `promptHash`,
+ * `configHash`) plus the cell's runtime data. The validator still rejects
+ * bare-alias model strings — the caller snapshot-pins.
+ */
+
+interface AdapterContext {
+    /** Logical experiment id — typically the campaign or sweep identifier. */
+    experimentId: string;
+    /** Snapshot model id (e.g. `claude-sonnet-4-6@2025-04-15`). */
+    model: string;
+    /** Git SHA the harness was run from. */
+    commitSha: string;
+    /** Hash of the effective prompt sent to the model. */
+    promptHash: string;
+    /** Hash of the effective config (model, temperature, tools, judges, splits). */
+    configHash: string;
+    /** Default split tag. Default `'search'`. */
+    splitTag?: RunSplitTag;
+    /** Default cost in USD when the source doesn't record one. Default `0`. */
+    defaultCostUsd?: number;
+}
+/**
+ * Convert a `CampaignResult` into canonical `RunRecord[]` — one record per
+ * scored cell. The cell's mean judge composite becomes the split score; every
+ * judge dimension is carried through to `outcome.raw`. A cell that errored
+ * becomes a record with `failureMode: 'cell_error'` (kept, not dropped — an
+ * unscored cell is signal). `candidateId` identifies the measured surface
+ * (defaults to the campaign manifest hash).
+ */
+declare function campaignToRunRecords(campaign: CampaignResult, ctx: AdapterContext & {
+    candidateId?: string;
+}): RunRecord[];
+/**
+ * Convert a `MultiLayerVerifier` `VerificationReport` into a `RunRecord`.
+ * `outcome.searchScore` (or `holdoutScore`) is `report.blendedScore`;
+ * `outcome.raw` carries every layer's score + a pass indicator; `failureMode`
+ * is the first failing layer's reason.
+ */
+declare function verificationReportToRunRecord(report: VerificationReport, ctx: AdapterContext & {
+    candidateId: string;
+    scenarioId?: string;
+}, opts?: {
+    runId?: string;
+}): RunRecord;
+
 /**
  * Simulator fidelity — score a user SIMULATOR's realism against real-user
  * trace distributions.
@@ -1189,4 +1075,119 @@ interface EasyModeReport {
  */
 declare function easyModeCheck(simulated: RunRecord[], production: RunRecord[], opts?: EasyModeOptions): EasyModeReport;
 
+/**
+ * Bradley-Terry / Elo tournament evaluation.
+ *
+ * For multi-candidate sweeps, comparing every candidate's score against
+ * a fixed comparator wastes information — the comparator becomes a high-
+ * variance reference and rank flips between near-tied middle-rank
+ * candidates are dominated by noise. Pairwise tournaments fix this:
+ * every (i, j) pair contributes a comparison to a Bradley-Terry MLE that
+ * estimates each candidate's strength on a unified scale.
+ *
+ * For online updating (rolling campaigns where new candidates arrive
+ * over time), we also ship classical Elo with configurable K-factor.
+ *
+ * References:
+ *   - Bradley, R. A., Terry, M. E. (1952). Rank analysis of incomplete
+ *     block designs. Biometrika, 39(3/4), 324–345.
+ *   - Hunter, D. R. (2004). MM algorithms for generalized Bradley-Terry
+ *     models. Annals of Statistics, 32(1), 384–406. (The MLE algorithm
+ *     used here.)
+ *   - Elo, A. E. (1978). The Rating of Chess Players, Past and Present.
+ *
+ * This is a useful primitive because most LLM-eval communities (Chatbot
+ * Arena, AlpacaEval, ELO-style ablation) have converged on pairwise
+ * tournament eval as the most sample-efficient and most rank-stable
+ * method when you have many candidates.
+ */
+interface PairwiseOutcome {
+    /** Winner candidate id. */
+    winner: string;
+    /** Loser candidate id. */
+    loser: string;
+    /**
+     * Optional draw flag. When true, both candidates get half-credit
+     * (Bradley-Terry handles draws as half-wins for each side).
+     */
+    draw?: boolean;
+    /**
+     * Optional weight — useful if some pairwise comparisons are stronger
+     * signals than others (e.g. a paired test with a wider score gap is
+     * a more confident comparison). Default 1.
+     */
+    weight?: number;
+}
+interface BradleyTerryRating {
+    candidateId: string;
+    /** Latent strength θ ≥ 0 from the BT MLE. */
+    strength: number;
+    /** Log-strength = log(θ) — interpretable on a linear scale. */
+    logStrength: number;
+    /** Number of pairwise comparisons this candidate appears in. */
+    n: number;
+    /** Win count (+ 0.5 per draw). */
+    wins: number;
+}
+interface BradleyTerryFit {
+    ratings: BradleyTerryRating[];
+    /** Iterations of the MM algorithm before convergence. */
+    iterations: number;
+    /** Final maximum |θ_new - θ_old| / θ_old. */
+    finalDelta: number;
+    converged: boolean;
+}
+/**
+ * Bradley-Terry MLE via Hunter's MM algorithm.
+ *
+ * Iteration: θ_i^new = W_i / Σ_{j ≠ i} N_ij / (θ_i + θ_j)
+ *   where W_i = wins by i (+ 0.5 per draw), N_ij = total comparisons.
+ *
+ * Returns log-strengths normalized so the smallest is 0 (any constant
+ * offset is unobservable in BT — only differences are identified).
+ */
+declare function fitBradleyTerry(outcomes: PairwiseOutcome[], opts?: {
+    tolerance?: number;
+    maxIterations?: number;
+    smoothing?: number;
+}): BradleyTerryFit;
+/**
+ * Online Elo updates. Use when comparisons arrive over time and you want
+ * a running rating without re-fitting the full BT MLE on every update.
+ *
+ * Initialize ratings to `defaultRating` (1500 by default). Each call to
+ * `applyEloUpdate` mutates the map in place and returns the deltas so
+ * the caller can log per-comparison rating changes.
+ */
+interface EloOptions {
+    /** Default rating for unseen candidates. Default 1500. */
+    defaultRating?: number;
+    /** K-factor controls the step size. Default 32 (FIDE-ish). */
+    kFactor?: number;
+}
+declare function applyEloUpdate(ratings: Map<string, number>, outcome: PairwiseOutcome, opts?: EloOptions): {
+    winnerDelta: number;
+    loserDelta: number;
+};
+/**
+ * Build pairwise outcomes from the campaign artifact: for every scenario
+ * shared by two candidates, the higher-scoring run wins. Useful when you
+ * want a tournament view of an existing campaign without an additional
+ * pairwise judge call.
+ */
+interface BuildPairwiseFromCampaignInput {
+    runs: Array<{
+        candidateId: string;
+        /** Stable identifier for the matching unit (typically scenarioId). */
+        matchKey: string;
+        score: number;
+    }>;
+    /**
+     * Tied-score margin. Below this, the comparison is a draw. Default 0
+     * (no ties).
+     */
+    drawMargin?: number;
+}
+declare function buildPairwiseFromCampaign(input: BuildPairwiseFromCampaignInput): PairwiseOutcome[];
+
 export { ABSENT_CATEGORY, type AdaptationCurve, type AdaptationPoint, type AdaptationRunner, type AdapterContext, type BehaviorFeatures, type BradleyTerryFit, type BradleyTerryRating, type BuildPairwiseFromCampaignInput, type CellObservation, type CompareCurvesResult, type ComputeBestOfNOptions, type ComputeBestOfNResult, type ComputeCurve, type ComputeCurveBudget, type ComputeCurvePoint, type ContaminationProbeInput, type ContaminationProbeOptions, type ContaminationProbeReport, type CurriculumAllocation, DEFAULT_MIN_N_PER_FEATURE, DEFAULT_QUANTILE_BUCKETS, type DetectRewardHackingInput, DpoExportRow, DpoLookups, type EasyModeOptions, type EasyModeReport, type EloOptions, ExtractPreferencesOptions, type FeatureDivergence, type FeatureShift, type FidelityReport, type FidelityVerdict, GrpoExportRow, GrpoLookups, OutcomeStore, type PairwiseOutcome, type ParetoPointInput, PredictiveValidityResearcher, type PredictiveValidityResearcherOptions, PreferenceExtractionReport, REPRESENTATIVE_MIN_FIDELITY, type RLCampaignResult, type RewardHackingFinding, type RewardHackingReport, type RewardHackingSignal, type RunAdaptationCurveOptions, type RunComputeCurveOptions, type RunRLCampaignOptions, type ScenarioPerturbation, type ScenarioPerturbationKind, type SelfConsistencyOptions, type SelfConsistencyResult, SftExportRow, SftLookups, type SimFidelityOptions, type ThompsonCurriculumOptions, type VarianceCurriculumOptions, type VerifiableReward, type VerifiableRewardExtractionOptions, type VerifiableRewardSource, applyEloUpdate, bestOfN, bucketLabel, buildPairwiseFromCampaign, campaignToRunRecords, compareAdaptationCurves, defaultBehaviorFeatures, detectRewardHacking, easyModeCheck, extractVerifiableReward, extractVerifiableRewardsFromRecords, filterDeterministicallyRewarded, firstPassK, fitBradleyTerry, injectIrrelevantClause, jsDivergence, observationsFromRunRecords, paretoFrontier, quantileEdges, renameVariables, runAdaptationCurve, runComputeCurve, runContaminationProbe, runRLCampaign, selfConsistency, shuffleOrder, simFidelityReport, thompsonCurriculum, varianceBasedCurriculum, verificationReportToRunRecord };