@tangle-network/agent-eval 0.95.0 → 0.95.1

package/dist/rl/active-curriculum.d.ts

@@ -1,110 +0,0 @@
-/**
- * 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.
- */
-import type { RunRecord } from '../run-record';
-export 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;
-}
-export 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;
-}
-export 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."
- */
-export declare function varianceBasedCurriculum(observations: CellObservation[], candidateCells: Array<{
-    variantId: string;
-    scenarioId: string;
-}>, opts: VarianceCurriculumOptions): CurriculumAllocation[];
-export 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.
- */
-export declare function thompsonCurriculum(observations: CellObservation[], candidateCells: Array<{
-    variantId: string;
-    scenarioId: string;
-}>, opts: ThompsonCurriculumOptions): CurriculumAllocation[];
-/** Convenience: extract `CellObservation[]` directly from `RunRecord[]`. */
-export declare function observationsFromRunRecords(runs: RunRecord[], opts?: {
-    passThreshold?: number;
-    useHoldout?: boolean;
-}): CellObservation[];
-//# sourceMappingURL=active-curriculum.d.ts.map

package/dist/rl/active-curriculum.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"active-curriculum.d.ts","sourceRoot":"","sources":["../../src/rl/active-curriculum.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAE9C,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,CAAA;IACjB,UAAU,EAAE,MAAM,CAAA;IAClB,gCAAgC;IAChC,KAAK,EAAE,MAAM,CAAA;IACb,6EAA6E;IAC7E,IAAI,CAAC,EAAE,OAAO,CAAA;CACf;AAED,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,MAAM,CAAA;IACjB,UAAU,EAAE,MAAM,CAAA;IAClB,oDAAoD;IACpD,KAAK,EAAE,MAAM,CAAA;IACb,mDAAmD;IACnD,MAAM,EAAE,MAAM,CAAA;CACf;AAED,MAAM,WAAW,yBAAyB;IACxC,+CAA+C;IAC/C,MAAM,EAAE,MAAM,CAAA;IACd;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,YAAY,EAAE,eAAe,EAAE,EAC/B,cAAc,EAAE,KAAK,CAAC;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC,EAChE,IAAI,EAAE,yBAAyB,GAC9B,oBAAoB,EAAE,CAkDxB;AAED,MAAM,WAAW,yBAAyB;IACxC,MAAM,EAAE,MAAM,CAAA;IACd;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B,sDAAsD;IACtD,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,8DAA8D;IAC9D,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAChC,YAAY,EAAE,eAAe,EAAE,EAC/B,cAAc,EAAE,KAAK,CAAC;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC,EAChE,IAAI,EAAE,yBAAyB,GAC9B,oBAAoB,EAAE,CAmDxB;AAED,4EAA4E;AAC5E,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,SAAS,EAAE,EACjB,IAAI,GAAE;IAAE,aAAa,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,OAAO,CAAA;CAAO,GAC1D,eAAe,EAAE,CAkBnB"}

package/dist/rl/adaptation-eval.d.ts

@@ -1,109 +0,0 @@
-/**
- * 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.
- */
-export 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>;
-}
-export 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;
-}
-export 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;
-    }>;
-}
-export 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;
-}
-export declare function runAdaptationCurve<S extends {
-    scenarioId?: string;
-}>(opts: RunAdaptationCurveOptions<S>): Promise<AdaptationCurve>;
-export 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).
- */
-export 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. */
-export declare function firstPassK(curve: AdaptationCurve, threshold?: number): number | null;
-//# sourceMappingURL=adaptation-eval.d.ts.map

package/dist/rl/adaptation-eval.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"adaptation-eval.d.ts","sourceRoot":"","sources":["../../src/rl/adaptation-eval.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,MAAM,WAAW,gBAAgB,CAAC,CAAC;IACjC;;;;OAIG;IACH,GAAG,CAAC,IAAI,EAAE;QAAE,QAAQ,EAAE,CAAC,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;CACpE;AAED,MAAM,WAAW,yBAAyB,CAAC,CAAC;IAC1C,SAAS,EAAE,CAAC,EAAE,CAAA;IACd,qEAAqE;IACrE,EAAE,CAAC,EAAE,MAAM,EAAE,CAAA;IACb,8CAA8C;IAC9C,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,gBAAgB,CAAC,CAAC,CAAC,CAAA;IAC3B,mEAAmE;IACnE,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB;AAED,MAAM,WAAW,eAAe;IAC9B,CAAC,EAAE,MAAM,CAAA;IACT,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;IAChB,GAAG,EAAE,MAAM,CAAA;IACX,CAAC,EAAE,MAAM,CAAA;IACT,oCAAoC;IACpC,WAAW,EAAE,KAAK,CAAC;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAC7F;AAED,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,eAAe,EAAE,CAAA;IACzB;;;OAGG;IACH,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB;;;;OAIG;IACH,cAAc,EAAE,MAAM,CAAA;CACvB;AAED,wBAAsB,kBAAkB,CAAC,CAAC,SAAS;IAAE,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,EACxE,IAAI,EAAE,yBAAyB,CAAC,CAAC,CAAC,GACjC,OAAO,CAAC,eAAe,CAAC,CAwD1B;AAED,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,KAAK,CAAC;QACV,CAAC,EAAE,MAAM,CAAA;QACT,SAAS,EAAE,MAAM,CAAA;QACjB,IAAI,EAAE,MAAM,CAAA;QACZ,KAAK,EAAE,MAAM,CAAA;QACb,IAAI,EAAE,MAAM,CAAA;QACZ,KAAK,EAAE,MAAM,CAAA;KACd,CAAC,CAAA;IACF,SAAS,EAAE,MAAM,CAAA;IACjB,eAAe,EAAE,MAAM,GAAG,IAAI,CAAA;IAC9B,oDAAoD;IACpD,OAAO,EAAE,UAAU,GAAG,UAAU,GAAG,SAAS,CAAA;IAC5C,kCAAkC;IAClC,SAAS,EAAE,MAAM,CAAA;CAClB;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,CAAC,EAAE,eAAe,EAClB,CAAC,EAAE,eAAe,EAClB,IAAI,GAAE;IAAE,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAO,GAC7E,mBAAmB,CA2CrB;AAED,uFAAuF;AACvF,wBAAgB,UAAU,CAAC,KAAK,EAAE,eAAe,EAAE,SAAS,SAAM,GAAG,MAAM,GAAG,IAAI,CAEjF"}

package/dist/rl/adversarial.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"adversarial.d.ts","sourceRoot":"","sources":["../../src/rl/adversarial.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,MAAM,WAAW,mBAAmB,CAAC,CAAC;IACpC,+DAA+D;IAC/D,EAAE,EAAE,MAAM,CAAA;IACV,2EAA2E;IAC3E,UAAU,EAAE,MAAM,CAAA;IAClB,yEAAyE;IACzE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,QAAQ,EAAE,CAAC,CAAA;IACX,kEAAkE;IAClE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IACpB,6DAA6D;IAC7D,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAA;CAChC;AAED,MAAM,WAAW,mBAAmB,CAAC,CAAC;IACpC,EAAE,EAAE,MAAM,CAAA;IACV;;;OAGG;IACH,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,GAAG,EAAE,MAAM,MAAM,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAA;CACzD;AAED,MAAM,WAAW,wBAAwB,CAAC,CAAC;IACzC,uEAAuE;IACvE,KAAK,EAAE,CAAC,EAAE,CAAA;IACV,oCAAoC;IACpC,gBAAgB,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAA;IAClC,2BAA2B;IAC3B,SAAS,EAAE,mBAAmB,CAAC,CAAC,CAAC,EAAE,CAAA;IACnC;;;OAGG;IACH,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,CAAC,MAAM,CAAC,CAAA;IAClC;;;OAGG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,4CAA4C;IAC5C,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,gDAAgD;IAChD,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B,0DAA0D;IAC1D,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,iDAAiD;IACjD,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED,MAAM,WAAW,uBAAuB,CAAC,CAAC;IACxC,SAAS,EAAE,mBAAmB,CAAC,CAAC,CAAC,EAAE,CAAA;IACnC,qDAAqD;IACrD,QAAQ,EAAE,mBAAmB,CAAC,CAAC,CAAC,EAAE,CAAA;IAClC,6BAA6B;IAC7B,YAAY,EAAE,KAAK,CAAC;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;IAC/F,0CAA0C;IAC1C,UAAU,EAAE,MAAM,CAAA;CACnB;AAED,wBAAsB,yBAAyB,CAAC,CAAC,EAC/C,IAAI,EAAE,wBAAwB,CAAC,CAAC,CAAC,GAChC,OAAO,CAAC,uBAAuB,CAAC,CAAC,CAAC,CAAC,CA2ErC"}

package/dist/rl/compute-curves.d.ts

@@ -1,127 +0,0 @@
-/**
- * Test-time compute scaling curves.
- *
- * The test-time-compute frontier paper (Snell et al. 2024) and the
- * subsequent o1-style scaling work both show that LLM-agent capability
- * is a function of the compute budget at inference, not just of the
- * training run. The right way to characterize a candidate is therefore
- * a *curve* — score at compute budgets {1×, 4×, 16×, …} — not a single
- * point.
- *
- * This module ships:
- *
- *   1. The compute-curve harness — `runComputeCurve(runner, budgets)` —
- *      that evaluates one candidate at a sequence of compute budgets
- *      and returns the (compute, score) curve.
- *   2. A best-of-N evaluator — `bestOfN(runner, n, scoreFn)` — the
- *      simplest test-time-compute scaling primitive: sample N
- *      independent rollouts, return the best.
- *   3. A self-consistency evaluator — `selfConsistency(runner, n)` —
- *      the majority-vote variant of best-of-N for tasks with a small
- *      categorical answer space.
- *   4. Pareto-frontier extraction over multiple candidates — given
- *      (candidate, compute, score) tuples, return the set of
- *      candidate-compute combinations that aren't dominated.
- *
- * Caveat: "compute" here is the caller's notion of a compute unit. For
- * agent eval that's typically wall-time × parallelism, or token budget,
- * or LLM-call count. We accept whatever the caller provides; the curve
- * is on whatever axis they pick.
- */
-export interface ComputeCurveBudget {
-    /** Identifier — for the report. Common: '1x', '4x', '16x'. */
-    id: string;
-    /** Numeric value on the chosen axis (tokens, calls, USD, ms — caller picks). */
-    cost: number;
-    /** Free-form metadata (the caller can carry per-budget config). */
-    meta?: Record<string, unknown>;
-}
-export interface ComputeCurvePoint {
-    budgetId: string;
-    cost: number;
-    score: number;
-    /** Number of underlying samples used at this budget. */
-    samples: number;
-    /** Optional spread / variance information. */
-    std?: number;
-    /** Any extra metrics the runner returned. */
-    metrics?: Record<string, number>;
-}
-export interface ComputeCurve {
-    candidateId: string;
-    points: ComputeCurvePoint[];
-    /** Rough exponent fit: score ≈ a + b * log(cost). Useful for "how steep is the curve?" */
-    logSlope: number | null;
-    /** Best (highest-score) point on the curve. */
-    best: ComputeCurvePoint;
-}
-export interface RunComputeCurveOptions {
-    candidateId: string;
-    budgets: ComputeCurveBudget[];
-    /**
-     * Run the candidate at one budget. Returns the realized score plus
-     * optional spread + extra metrics.
-     */
-    runAtBudget: (budget: ComputeCurveBudget) => Promise<{
-        score: number;
-        samples: number;
-        std?: number;
-        metrics?: Record<string, number>;
-    }>;
-}
-export declare function runComputeCurve(opts: RunComputeCurveOptions): Promise<ComputeCurve>;
-export interface ComputeBestOfNOptions<O> {
-    /** Number of independent samples to draw. */
-    n: number;
-    /** Sampler — produces one rollout. */
-    sample: (sampleIdx: number) => Promise<O>;
-    /** Score one rollout. */
-    scoreFn: (rollout: O) => Promise<number> | number;
-}
-export interface ComputeBestOfNResult<O> {
-    best: O;
-    bestScore: number;
-    scores: number[];
-    meanScore: number;
-    /** Index of the best rollout, for diagnostics. */
-    bestIndex: number;
-}
-/** The simplest test-time scaling primitive. */
-export declare function bestOfN<O>(opts: ComputeBestOfNOptions<O>): Promise<ComputeBestOfNResult<O>>;
-export interface SelfConsistencyOptions<O> {
-    n: number;
-    sample: (sampleIdx: number) => Promise<O>;
-    /** Extract the canonical answer key (string) from a rollout. */
-    answerKey: (rollout: O) => string;
-}
-export interface SelfConsistencyResult<O> {
-    /** Modal answer (the majority vote). */
-    answer: string;
-    /** Fraction of samples voting for the modal answer in [0, 1]. */
-    agreement: number;
-    /** Histogram of all answers. */
-    histogram: Record<string, number>;
-    /** A representative rollout that voted for the modal answer. */
-    representative: O;
-    /** All rollouts. */
-    rollouts: O[];
-}
-/**
- * Self-consistency / majority-vote test-time scaling. For tasks with a
- * small categorical answer space (math problems, multiple choice).
- */
-export declare function selfConsistency<O>(opts: SelfConsistencyOptions<O>): Promise<SelfConsistencyResult<O>>;
-/**
- * Pareto frontier over (candidate, compute, score) tuples. A point is on
- * the frontier iff no other point dominates it in both score (higher
- * better) and cost (lower better). Returns the frontier sorted ascending
- * by cost.
- */
-export interface ParetoPointInput {
-    candidateId: string;
-    budgetId: string;
-    cost: number;
-    score: number;
-}
-export declare function paretoFrontier(points: ParetoPointInput[]): ParetoPointInput[];
-//# sourceMappingURL=compute-curves.d.ts.map

package/dist/rl/compute-curves.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"compute-curves.d.ts","sourceRoot":"","sources":["../../src/rl/compute-curves.ts"],"names":[],"mappings":"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"}

package/dist/rl/contamination.d.ts

@@ -1,117 +0,0 @@
-/**
- * Contamination probe — held-out perturbation tests.
- *
- * The bug class: once a benchmark scenario set is published, models train
- * on it, and your scores become invalid. SWE-Bench-Verified, GPQA, and
- * MMLU-Pro all exist because their predecessors got contaminated within
- * months. The right defense is to keep a held-out *perturbed* version of
- * every scenario — same task, slightly different surface — and check
- * whether scores diverge significantly. Genuine capability transfers; rote
- * memorization doesn't.
- *
- * This module ships the probe contract:
- *
- *   1. A `ScenarioPerturbation` strategy type — function that produces a
- *      perturbed scenario from an original.
- *   2. `runContaminationProbe({ originals, perturbed, scoreFn })` — runs
- *      both halves and reports per-scenario score divergence + a global
- *      contamination verdict via paired Wilcoxon.
- *   3. Several stock perturbations: `renameVariables`, `shuffleOrder`,
- *      `paraphrasePrompt`, `injectIrrelevantClause`. Each preserves the
- *      task's structural difficulty while breaking surface memorization.
- *
- * The verdict is conservative: if the perturbed-vs-original score
- * difference is statistically significant (BH-adjusted p < 0.05) AND
- * the median drop is > 5 percentage points, we flag *contamination
- * suspected*. False positives are possible (the perturbation might
- * actually be harder); the default is to flag for review, not to
- * autoreject.
- */
-export type ScenarioPerturbationKind = 'rename_variables' | 'shuffle_order' | 'paraphrase' | 'inject_irrelevant_clause' | 'custom';
-export interface ScenarioPerturbation<S> {
-    kind: ScenarioPerturbationKind;
-    /** Apply to one scenario, return its perturbed sibling. */
-    apply: (scenario: S) => Promise<S> | S;
-    /** Optional id — for the report. */
-    id?: string;
-}
-export interface ContaminationProbeInput<S> {
-    /** Identity of every scenario. The probe's `runFingerprint` keys on these. */
-    scenarioId: (s: S) => string;
-    /** Original scenarios. */
-    originals: S[];
-    /**
-     * Either pre-computed perturbations (one per original, same order) OR a
-     * `perturbation` strategy that synthesizes them on the fly.
-     */
-    perturbed?: S[];
-    perturbation?: ScenarioPerturbation<S>;
-    /**
-     * Run the policy/agent against one scenario and return a scalar score
-     * in [0, 1]. The probe doesn't care what the policy is — that's the
-     * caller's contract.
-     */
-    scoreFn: (s: S) => Promise<number>;
-}
-export interface ContaminationProbeOptions {
-    /** Drop scores below this from the probe; treats partial failures separately. Default 0. */
-    scoreFloor?: number;
-    /**
-     * BH-FDR threshold for declaring contamination on each per-scenario
-     * delta. Default 0.05.
-     */
-    fdr?: number;
-    /**
-     * Minimum median per-scenario drop to flag global contamination. Default
-     * 0.05 (5 percentage points). Smaller drops may be noise.
-     */
-    minMedianDrop?: number;
-}
-export interface ContaminationProbeReport {
-    perScenario: Array<{
-        scenarioId: string;
-        originalScore: number;
-        perturbedScore: number;
-        delta: number;
-        /** Per-scenario q-value (single-test BH for a single scenario). Mainly for display. */
-        qValue: number;
-    }>;
-    /** Wilcoxon paired-test on the deltas. */
-    pairedTest: {
-        w: number;
-        p: number;
-    };
-    medianDelta: number;
-    meanDelta: number;
-    contaminationSuspected: boolean;
-    reason: string;
-    /** Number of scenarios processed. */
-    n: number;
-}
-export declare function runContaminationProbe<S>(input: ContaminationProbeInput<S>, opts?: ContaminationProbeOptions): Promise<ContaminationProbeReport>;
-/**
- * Identifier-rename perturbation for code/text scenarios. Replaces every
- * occurrence of the listed identifiers with synthesized aliases. Use when
- * the scenario's structural difficulty is independent of variable names
- * (e.g. SWE-Bench-style coding tasks).
- */
-export declare function renameVariables<S extends {
-    prompt: string;
-}>(identifiers: string[], rename?: (name: string, idx: number) => string): ScenarioPerturbation<S>;
-/**
- * Order-shuffle perturbation. Reshuffles a list-shaped section of the
- * prompt (for QA scenarios that present options A/B/C/D — answer depends
- * on the option labels, not order). Caller provides the section extractor.
- */
-export declare function shuffleOrder<S extends {
-    prompt: string;
-}>(shuffleSection: (prompt: string, rng: () => number) => string, seed: number): ScenarioPerturbation<S>;
-/**
- * Inject-irrelevant-clause perturbation. Adds a benign sentence that
- * shouldn't change the answer. Tests for "did the model just memorize
- * the input string."
- */
-export declare function injectIrrelevantClause<S extends {
-    prompt: string;
-}>(clause: string, position?: 'prefix' | 'suffix'): ScenarioPerturbation<S>;
-//# sourceMappingURL=contamination.d.ts.map

package/dist/rl/contamination.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"contamination.d.ts","sourceRoot":"","sources":["../../src/rl/contamination.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAKH,MAAM,MAAM,wBAAwB,GAChC,kBAAkB,GAClB,eAAe,GACf,YAAY,GACZ,0BAA0B,GAC1B,QAAQ,CAAA;AAEZ,MAAM,WAAW,oBAAoB,CAAC,CAAC;IACrC,IAAI,EAAE,wBAAwB,CAAA;IAC9B,2DAA2D;IAC3D,KAAK,EAAE,CAAC,QAAQ,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAA;IACtC,oCAAoC;IACpC,EAAE,CAAC,EAAE,MAAM,CAAA;CACZ;AAED,MAAM,WAAW,uBAAuB,CAAC,CAAC;IACxC,8EAA8E;IAC9E,UAAU,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAA;IAC5B,0BAA0B;IAC1B,SAAS,EAAE,CAAC,EAAE,CAAA;IACd;;;OAGG;IACH,SAAS,CAAC,EAAE,CAAC,EAAE,CAAA;IACf,YAAY,CAAC,EAAE,oBAAoB,CAAC,CAAC,CAAC,CAAA;IACtC;;;;OAIG;IACH,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,CAAC,MAAM,CAAC,CAAA;CACnC;AAED,MAAM,WAAW,yBAAyB;IACxC,4FAA4F;IAC5F,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB;;;OAGG;IACH,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB;AAED,MAAM,WAAW,wBAAwB;IACvC,WAAW,EAAE,KAAK,CAAC;QACjB,UAAU,EAAE,MAAM,CAAA;QAClB,aAAa,EAAE,MAAM,CAAA;QACrB,cAAc,EAAE,MAAM,CAAA;QACtB,KAAK,EAAE,MAAM,CAAA;QACb,uFAAuF;QACvF,MAAM,EAAE,MAAM,CAAA;KACf,CAAC,CAAA;IACF,0CAA0C;IAC1C,UAAU,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;IACpC,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE,MAAM,CAAA;IACjB,sBAAsB,EAAE,OAAO,CAAA;IAC/B,MAAM,EAAE,MAAM,CAAA;IACd,qCAAqC;IACrC,CAAC,EAAE,MAAM,CAAA;CACV;AAED,wBAAsB,qBAAqB,CAAC,CAAC,EAC3C,KAAK,EAAE,uBAAuB,CAAC,CAAC,CAAC,EACjC,IAAI,GAAE,yBAA8B,GACnC,OAAO,CAAC,wBAAwB,CAAC,CAgFnC;AAID;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,EAC1D,WAAW,EAAE,MAAM,EAAE,EACrB,MAAM,GAAE,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,MAAyD,GAC/F,oBAAoB,CAAC,CAAC,CAAC,CAazB;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,EACvD,cAAc,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,MAAM,KAAK,MAAM,EAC7D,IAAI,EAAE,MAAM,GACX,oBAAoB,CAAC,CAAC,CAAC,CAgBzB;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,SAAS;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,EACjE,MAAM,EAAE,MAAM,EACd,QAAQ,GAAE,QAAQ,GAAG,QAAmB,GACvC,oBAAoB,CAAC,CAAC,CAAC,CASzB"}

package/dist/rl/corpus.d.ts

@@ -1,55 +0,0 @@
-/**
- * RL corpus — the durable, append-only accumulation of graded RunRecords that
- * every eval run deposits BY DEFAULT.
- *
- * The dataset is the free exhaust of the normal eval process: we run evals
- * constantly to get an agent production-ready, and those runs already produce
- * graded trajectories. Instead of writing them to an ephemeral run dir and
- * throwing them away, `appendToCorpus` accumulates them into a durable corpus;
- * `buildDatasetFromCorpus` later harvests the whole corpus into a publishable
- * bundle. No separate data-collection campaign — the data accrues from work we
- * do anyway. This is the "best things for free by our process" layer.
- *
- * Trajectory text rides on the record as top-level `prompt` / `completion`
- * (what the eval harnesses capture; the RunRecord validator ignores the extra
- * keys). The harvest reads them directly — no trace store round-trip needed.
- */
-import type { RunRecord } from '../run-record';
-import { type RlDatasetBundle, type RlDatasetConfig } from './dataset';
-/** A corpus record is a RunRecord carrying the trajectory text the harness
- *  captured. `prompt`/`completion` are top-level (the validator ignores extras). */
-export type CorpusRecord = RunRecord & {
-    prompt?: string;
-    completion?: string;
-};
-export interface CorpusAppendResult {
-    appended: number;
-    /** Skipped because a record with the same runId was already in the corpus
-     *  (idempotent appends — NOT re-run collapsing; re-runs get fresh runIds). */
-    skipped: number;
-    total: number;
-}
-/**
- * Append graded records to the corpus (append-only JSONL). Deduplicates by
- * `runId` against what's already on disk so re-running the same harness is
- * idempotent. Creates the file and parent dir. This is the call every eval
- * harness makes by default after producing its records.
- */
-export declare function appendToCorpus(records: CorpusRecord[], corpusPath: string): CorpusAppendResult;
-/** Read the full corpus. Returns [] if the corpus does not exist yet. */
-export declare function readCorpus(corpusPath: string): CorpusRecord[];
-export interface HarvestOptions {
-    /** Keep only records scoring >= this (rejection-sampling for SFT). */
-    minScore?: number;
-    /** Keep only these splits (e.g. ['holdout'] for an eval-only dataset). */
-    splits?: RunRecord['splitTag'][];
-}
-/**
- * Harvest the accumulated corpus into a publishable RL dataset bundle. Reads
- * trajectory text from each record's top-level `prompt`/`completion`; records
- * missing either are excluded (a graded score with no trajectory can't train).
- * Optionally filters by score / split. Throws (via buildRlDataset) if nothing
- * survives — an empty dataset must never be published.
- */
-export declare function buildDatasetFromCorpus(corpusPath: string, config: RlDatasetConfig, opts?: HarvestOptions): Promise<RlDatasetBundle>;
-//# sourceMappingURL=corpus.d.ts.map

package/dist/rl/corpus.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"corpus.d.ts","sourceRoot":"","sources":["../../src/rl/corpus.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,EAAkB,KAAK,eAAe,EAAE,KAAK,eAAe,EAAE,MAAM,WAAW,CAAA;AAEtF;oFACoF;AACpF,MAAM,MAAM,YAAY,GAAG,SAAS,GAAG;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA;AAE/E,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,MAAM,CAAA;IAChB;kFAC8E;IAC9E,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;CACd;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,UAAU,EAAE,MAAM,GAAG,kBAAkB,CAkB9F;AAED,yEAAyE;AACzE,wBAAgB,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,YAAY,EAAE,CAO7D;AAOD,MAAM,WAAW,cAAc;IAC7B,sEAAsE;IACtE,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,0EAA0E;IAC1E,MAAM,CAAC,EAAE,SAAS,CAAC,UAAU,CAAC,EAAE,CAAA;CACjC;AAED;;;;;;GAMG;AACH,wBAAsB,sBAAsB,CAC1C,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,eAAe,EACvB,IAAI,GAAE,cAAmB,GACxB,OAAO,CAAC,eAAe,CAAC,CAe1B"}

package/dist/rl/corpus.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=corpus.test.d.ts.map

package/dist/rl/corpus.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"corpus.test.d.ts","sourceRoot":"","sources":["../../src/rl/corpus.test.ts"],"names":[],"mappings":""}

package/dist/rl/dataset.d.ts

@@ -1,102 +0,0 @@
-/**
- * RL dataset packaging + datasheet — the publishable, sellable bundle.
- *
- * The format exporters (`toGrpoRows` / `toSftRows` / `toDpoRows`) already
- * produce trainer-ready shapes (prime-rl GRPO, TRL DPO, conversational SFT).
- * What turns that into a dataset someone can PUBLISH or BUY is the provenance
- * + a datasheet: which models produced it, which prompt/agent versions, how the
- * reward was derived (deterministic verifiable vs probabilistic judge — the
- * credibility axis a buyer checks first), the split discipline, the reward
- * distribution, the quality gates, the license, and the intended/out-of-scope
- * uses. This module computes those facts from the `RunRecord[]` and renders a
- * "Datasheet for Datasets" (Gebru et al. 2018) card alongside the format files.
- *
- * It composes the existing `rl/exporters` — it does not reimplement any trainer
- * format. The renderers token-identity step (DeepSeek/Kimi/Qwen tokenization
- * with per-token loss masks) is a downstream Python stage that consumes the
- * `messages`/`completions` this bundle emits.
- */
-import type { RunRecord, RunSplitTag } from '../run-record';
-import { type DpoLookups, type GrpoLookups, type SftLookups } from './exporters';
-import type { PreferenceTriple } from './preferences';
-export type RewardKind = 'deterministic' | 'probabilistic' | 'mixed';
-export type DatasetFormat = 'grpo' | 'sft' | 'dpo';
-/** Caller-declared context — the qualitative half of the datasheet that can't
- *  be computed from records. */
-export interface RlDatasetConfig {
-    name: string;
-    version: string;
-    /** Product/task domain, e.g. 'legal-m&a', 'tax-1040'. */
-    domain: string;
-    /** SPDX id or a named commercial license. Required — an unlicensed dataset
-     *  cannot be published or sold. */
-    license: string;
-    /** How the reward was produced. `kind: 'deterministic'` (a test/schema/XPath
-     *  decided it) is the credibility signal; 'probabilistic' = LLM-judge. */
-    reward: {
-        kind: RewardKind;
-        source: string;
-        description: string;
-    };
-    intendedUse: string;
-    outOfScope: string;
-    limitations: string;
-    /** ISO timestamp — passed in (the substrate forbids Date.now()). */
-    createdAtIso: string;
-    /** Default: ['grpo', 'sft']. */
-    formats?: DatasetFormat[];
-    /** Quality gates already run, recorded on the card for the buyer. */
-    qualityGates?: {
-        contaminationProbe?: 'passed' | 'failed' | 'not-run';
-        dedup?: boolean;
-        verifiableRewardFilter?: boolean;
-    };
-}
-export interface RewardStats {
-    n: number;
-    mean: number;
-    median: number;
-    min: number;
-    max: number;
-    std: number;
-}
-export interface RlDatasetStats {
-    records: number;
-    /** Record count per split — a publishable dataset must declare its holdout. */
-    splits: Record<RunSplitTag, number>;
-    reward: RewardStats;
-    /** Distinct snapshot-pinned models that produced the trajectories. */
-    models: string[];
-    /** Distinct effective-prompt hashes (the agent profile/prompt versions). */
-    promptHashes: string[];
-    commitShas: string[];
-    totalTokens: {
-        input: number;
-        output: number;
-    };
-    totalCostUsd: number;
-}
-export interface RlDatasetManifest extends RlDatasetConfig {
-    formats: DatasetFormat[];
-    rowCounts: Partial<Record<DatasetFormat, number>>;
-    stats: RlDatasetStats;
-}
-export interface RlDatasetBundle {
-    manifest: RlDatasetManifest;
-    /** Relative filename -> contents. Write these to a directory to publish. */
-    files: Record<string, string>;
-}
-/**
- * Package graded `RunRecord[]` into a publishable RL dataset bundle: the
- * trainer-format JSONL files + a manifest + a datasheet. DPO requires
- * pre-extracted preference triples (pass `preferences`); GRPO/SFT derive from
- * the records directly via the supplied lookups. Throws on an empty corpus —
- * an empty dataset must never be published.
- */
-export declare function buildRlDataset(records: RunRecord[], lookups: GrpoLookups & SftLookups, config: RlDatasetConfig, preferences?: {
-    triples: PreferenceTriple[];
-    lookups: DpoLookups;
-}): Promise<RlDatasetBundle>;
-/** Render the "Datasheet for Datasets" card — the artifact a buyer reads. */
-export declare function datasheetToMarkdown(m: RlDatasetManifest): string;
-//# sourceMappingURL=dataset.d.ts.map