@tangle-network/agent-eval 0.95.0 → 0.95.1

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

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

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

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

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

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

package/dist/rl/exporters.d.ts

@@ -1,141 +0,0 @@
-/**
- * Trainer-format exporters.
- *
- * agent-eval produces canonical artifacts (`RunRecord[]`, `PreferenceTriple[]`,
- * `StepReward[]`, `PrmTrainingTriple[]`). RL training pipelines consume
- * different shapes — Hugging Face TRL, Prime Intellect's prime-rl, OpenAI
- * fine-tuning, Anthropic finetuning, OpenRLHF, verl. Each has its own
- * JSONL conventions. Rather than ship N adapters, this module ships the
- * canonical formats most production pipelines accept and ergonomic helpers
- * for the rest.
- *
- * Shapes:
- *   - **DPO / IPO / KTO** — `{prompt, chosen, rejected}` JSONL. Consumed
- *     by HuggingFace TRL, prime-rl's offline DPO, OpenRLHF.
- *   - **GRPO offline** — `{prompt, completions[], rewards[]}` JSONL.
- *     Consumed by prime-rl GRPO, verl, OpenRLHF.
- *   - **SFT** — `{messages[]}` JSONL with chosen completion as the final
- *     assistant turn. Consumed by HF SFT trainers, OpenAI fine-tuning,
- *     Anthropic finetuning.
- *   - **PRM** — `{prompt, prefix_steps[], chosen_step, rejected_step}` JSONL.
- *     Consumed by Lightman-style PRM trainers and prime-rl's PRM mode.
- *
- * Why ship this in agent-eval rather than a separate adapter package: the
- * canonical artifacts (`RunRecord[]`, `PreferenceTriple[]`, etc.) are
- * agent-eval's contract; without first-party exporters consumers reverse-
- * engineer the mapping every release. The exporters codify it.
- *
- * The exporters take callbacks for any field that isn't on the canonical
- * artifact (specifically: prompt + completion text, since the package
- * stores only their hashes by design — full text is the consumer's
- * trace store / raw event log).
- */
-import type { RunRecord } from '../run-record';
-import type { PreferenceTriple } from './preferences';
-import type { PrmTrainingTriple, StepReward } from './process-reward';
-export interface DpoLookups {
-    /** Resolve the prompt text for a run (typically from a trace store / raw event sink). */
-    promptOf: (runId: string) => string | Promise<string>;
-    /** Resolve the assistant completion text for a run. */
-    completionOf: (runId: string) => string | Promise<string>;
-}
-export interface DpoExportRow {
-    prompt: string;
-    chosen: string;
-    rejected: string;
-    /** Carried-through margin. Some KTO / IPO variants use this. */
-    margin?: number;
-    /** Free-form metadata for downstream filtering / sharding. */
-    meta?: Record<string, unknown>;
-}
-/**
- * Convert preference triples to TRL-compatible DPO rows. The shape
- * `{prompt, chosen, rejected}` is the canonical HuggingFace DPODataset
- * entry; every major DPO trainer accepts it.
- */
-export declare function toDpoRows(triples: PreferenceTriple[], lookups: DpoLookups): Promise<DpoExportRow[]>;
-/** Serialize DPO rows as JSONL. One line per row. */
-export declare function toDpoJsonl(rows: DpoExportRow[]): string;
-export interface GrpoLookups {
-    promptOf: (runId: string) => string | Promise<string>;
-    completionOf: (runId: string) => string | Promise<string>;
-    /** Optional: derive a custom reward from the run. Defaults to score. */
-    rewardOf?: (run: RunRecord) => number | null;
-}
-export interface GrpoExportRow {
-    prompt: string;
-    completions: string[];
-    rewards: number[];
-    /** runIds in the same order as `completions[]` for traceability. */
-    runIds: string[];
-    meta?: Record<string, unknown>;
-}
-/**
- * Convert RunRecord[] grouped by `(scenarioId)` into GRPO offline rows —
- * one row per scenario, with one completion per run on that scenario.
- *
- * GRPO (Shao et al. 2024 / DeepSeek-R1) trains on relative advantages
- * within a group of completions for the same prompt; this is the
- * canonical input format.
- */
-export declare function toGrpoRows(runs: RunRecord[], lookups: GrpoLookups): Promise<GrpoExportRow[]>;
-export declare function toGrpoJsonl(rows: GrpoExportRow[]): string;
-export interface SftLookups {
-    promptOf: (runId: string) => string | Promise<string>;
-    completionOf: (runId: string) => string | Promise<string>;
-    /** Optional system message. Default omits. */
-    systemOf?: (run: RunRecord) => string | null | undefined;
-    /** Filter — return false to skip the run (e.g., low score, failed cases). */
-    include?: (run: RunRecord) => boolean;
-}
-export interface SftExportRow {
-    messages: Array<{
-        role: 'system' | 'user' | 'assistant';
-        content: string;
-    }>;
-    meta?: Record<string, unknown>;
-}
-/**
- * Convert RunRecord[] into Hugging Face / OpenAI / Anthropic-style
- * conversational SFT rows. By default every record becomes one row;
- * pass `include` to filter (e.g., keep only `score >= 0.8` for
- * rejection-sampling SFT).
- */
-export declare function toSftRows(runs: RunRecord[], lookups: SftLookups): Promise<SftExportRow[]>;
-export declare function toSftJsonl(rows: SftExportRow[]): string;
-export interface PrmLookups {
-    /** Resolve the prompt text for a run. */
-    promptOf: (runId: string) => string | Promise<string>;
-    /** Resolve the trajectory step text for a (runId, spanId) pair. */
-    stepTextOf: (runId: string, spanId: string) => string | Promise<string>;
-    /** Optional: sequence of prefix span ids leading up to the divergence. */
-    prefixOf?: (runId: string, prefixStepIndex: number) => string[] | Promise<string[]>;
-}
-export interface PrmExportRow {
-    prompt: string;
-    /** Span ids for the steps before divergence — caller resolves text via `stepTextOf`. */
-    prefixSpanIds: string[];
-    prefixStepText: string[];
-    chosenStep: string;
-    rejectedStep: string;
-    chosenReward: number;
-    rejectedReward: number;
-    marginScore: number;
-    meta?: Record<string, unknown>;
-}
-/**
- * Convert PRM training triples to JSONL rows. Caller's `stepTextOf`
- * callback resolves span text from the consumer's trace store.
- */
-export declare function toPrmRows(triples: PrmTrainingTriple[], lookups: PrmLookups): Promise<PrmExportRow[]>;
-export declare function toPrmJsonl(rows: PrmExportRow[]): string;
-export interface StepRewardJsonlRow {
-    runId: string;
-    spanId: string;
-    stepIndex: number;
-    reward: number;
-    determinism: 'deterministic' | 'probabilistic';
-    weight: number;
-}
-export declare function stepRewardsToJsonl(stepRewards: StepReward[]): string;
-//# sourceMappingURL=exporters.d.ts.map

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

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

package/dist/rl/index.d.ts

@@ -1,49 +0,0 @@
-/**
- * RL/data bridge.
- *
- * This subpath groups everything that turns eval output into training signal:
- * stable adapters/rewards, dataset packaging, trainer-format exporters,
- * process rewards, and closed-loop campaign research. Keeping it off the root
- * import path makes the default API smaller without hiding useful capability.
- */
-/** Advanced budget allocation across (variant, scenario) cells. */
-export * from './active-curriculum';
-/** Advanced adaptation eval — does the policy actually learn from feedback? */
-export * from './adaptation-eval';
-/** Advanced scenario search for inputs the policy fails on. */
-export * from './adversarial';
-/** @stable Compute curves: best-of-N, self-consistency, Pareto frontier across budgets. */
-export * from './compute-curves';
-/** @stable Held-out perturbation probes for benchmark contamination (paired Wilcoxon). */
-export * from './contamination';
-/** @stable Durable corpus: every eval run appends graded trajectories by default; harvest → buildRlDataset (datasets for free). */
-export * from './corpus';
-/** @stable Publishable/sellable dataset bundle: format exporters + provenance + a Datasheet-for-Datasets card. */
-export * from './dataset';
-/** Trainer-format exporters (HuggingFace datasets, JSONL, parquet). */
-export * from './exporters';
-/** @stable Off-policy value estimation: IPS, SNIPS, doubly-robust. */
-export * from './off-policy';
-/** Researcher that re-weights rubrics by deployment outcome correlation. */
-export * from './predictive-validity-researcher';
-/** @stable (chosen, rejected) preference triples for DPO / KTO / PPO. */
-export * from './preferences';
-/** Step-level rewards and process-reward training pairs. */
-export * from './process-reward';
-/** Reward-hacking signatures: reward divergence, distribution shift, judge drift. */
-export * from './reward-hacking';
-/** Closed-loop campaign runner: eval → preferences → mutate → re-eval. */
-export * from './rl-campaign';
-/** @stable Canonical `RunRecord` adapters: trials → records, verification reports → records. */
-export * from './run-record-adapters';
-/** Simulator fidelity between simulated and production RunRecords. */
-export * from './sim-fidelity';
-/** @stable Bradley-Terry MLE + online Elo for pairwise tournament ratings. */
-export * from './tournament';
-/** @stable Verifiable reward extraction (compile / test / schema) with judge-noise filtering. */
-export * from './verifiable-reward';
-/** @stable In-memory + filesystem stores for deployment outcomes;
- *  consumed by `predictive-validity-researcher` to calibrate the gate
- *  against observed downstream metrics, not just held-out judge scores. */
-export { type DeploymentOutcome, FileSystemOutcomeStore, type FileSystemOutcomeStoreOptions, InMemoryOutcomeStore, type OutcomeStore, } from '../meta-eval/outcome-store';
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/rl/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,mEAAmE;AACnE,cAAc,qBAAqB,CAAA;AACnC,+EAA+E;AAC/E,cAAc,mBAAmB,CAAA;AACjC,+DAA+D;AAC/D,cAAc,eAAe,CAAA;AAC7B,2FAA2F;AAC3F,cAAc,kBAAkB,CAAA;AAChC,0FAA0F;AAC1F,cAAc,iBAAiB,CAAA;AAC/B,mIAAmI;AACnI,cAAc,UAAU,CAAA;AACxB,kHAAkH;AAClH,cAAc,WAAW,CAAA;AACzB,uEAAuE;AACvE,cAAc,aAAa,CAAA;AAC3B,sEAAsE;AACtE,cAAc,cAAc,CAAA;AAC5B,4EAA4E;AAC5E,cAAc,kCAAkC,CAAA;AAChD,yEAAyE;AACzE,cAAc,eAAe,CAAA;AAC7B,4DAA4D;AAC5D,cAAc,kBAAkB,CAAA;AAChC,qFAAqF;AACrF,cAAc,kBAAkB,CAAA;AAChC,0EAA0E;AAC1E,cAAc,eAAe,CAAA;AAC7B,gGAAgG;AAChG,cAAc,uBAAuB,CAAA;AACrC,sEAAsE;AACtE,cAAc,gBAAgB,CAAA;AAC9B,8EAA8E;AAC9E,cAAc,cAAc,CAAA;AAC5B,iGAAiG;AACjG,cAAc,qBAAqB,CAAA;AAQnC;;2EAE2E;AAC3E,OAAO,EACL,KAAK,iBAAiB,EACtB,sBAAsB,EACtB,KAAK,6BAA6B,EAClC,oBAAoB,EACpB,KAAK,YAAY,GAClB,MAAM,4BAA4B,CAAA"}

package/dist/rl/off-policy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"off-policy.d.ts","sourceRoot":"","sources":["../../src/rl/off-policy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAIH,MAAM,WAAW,mBAAmB;IAClC,uDAAuD;IACvD,KAAK,EAAE,MAAM,CAAA;IACb,wEAAwE;IACxE,MAAM,EAAE,MAAM,CAAA;IACd;;;;OAIG;IACH,YAAY,EAAE,MAAM,CAAA;IACpB;;;;OAIG;IACH,UAAU,EAAE,MAAM,CAAA;IAClB;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CACrB;AAED,MAAM,WAAW,iBAAiB;IAChC,4CAA4C;IAC5C,KAAK,EAAE,MAAM,CAAA;IACb,sCAAsC;IACtC,aAAa,EAAE,MAAM,CAAA;IACrB,6FAA6F;IAC7F,mBAAmB,EAAE,MAAM,CAAA;IAC3B,mCAAmC;IACnC,CAAC,EAAE,MAAM,CAAA;IACT;;;OAGG;IACH,mBAAmB,EAAE,MAAM,CAAA;CAC5B;AAED,MAAM,WAAW,gBAAgB;IAC/B;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,+CAA+C;IAC/C,UAAU,CAAC,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAA;CAC3C;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,CACzC,YAAY,EAAE,mBAAmB,EAAE,EACnC,IAAI,GAAE,gBAAqB,GAC1B,iBAAiB,CAqCnB;AAED;;;;GAIG;AACH,wBAAgB,iCAAiC,CAC/C,YAAY,EAAE,mBAAmB,EAAE,EACnC,IAAI,GAAE,gBAAqB,GAC1B,iBAAiB,CAkCnB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,YAAY,CAC1B,YAAY,EAAE,mBAAmB,EAAE,EACnC,IAAI,GAAE,gBAAqB,GAC1B,iBAAiB,CAuCnB;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,YAAY,EAAE,mBAAmB,EAAE,EACnC,IAAI,GAAE,gBAAqB,GAC1B;IAAE,GAAG,EAAE,iBAAiB,CAAC;IAAC,KAAK,EAAE,iBAAiB,CAAC;IAAC,EAAE,EAAE,iBAAiB,CAAA;CAAE,CAM7E"}

package/dist/rl/predictive-validity-researcher.d.ts

@@ -1,69 +0,0 @@
-/**
- * `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.
- */
-import type { OutcomeStore } from '../meta-eval/outcome-store';
-import { type RubricPredictiveValidityReport } from '../meta-eval/rubric-predictive-validity';
-import type { ExperimentPlan, ExperimentResult, FailureMode, Researcher, SteeringChange } from '../researcher';
-import type { RunRecord } from '../run-record';
-export 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[];
-    /**
-     * 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.
-     */
-    onReport?: (report: RubricPredictiveValidityReport) => void | Promise<void>;
-}
-/**
- * Concrete `Researcher` driven by `rubricPredictiveValidity`. The brain:
- * rubrics that don't predict deployment outcomes don't earn weight.
- */
-export 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>;
-    /**
-     * 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.
-     */
-    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;
-}
-//# sourceMappingURL=predictive-validity-researcher.d.ts.map

package/dist/rl/predictive-validity-researcher.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"predictive-validity-researcher.d.ts","sourceRoot":"","sources":["../../src/rl/predictive-validity-researcher.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAC9D,OAAO,EACL,KAAK,8BAA8B,EAEpC,MAAM,yCAAyC,CAAA;AAChD,OAAO,KAAK,EACV,cAAc,EACd,gBAAgB,EAChB,WAAW,EACX,UAAU,EACV,cAAc,EACf,MAAM,eAAe,CAAA;AACtB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAE9C,MAAM,WAAW,mCAAmC;IAClD,QAAQ,EAAE,YAAY,CAAA;IACtB,cAAc,EAAE,MAAM,EAAE,CAAA;IACxB,4EAA4E;IAC5E,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,yEAAyE;IACzE,mBAAmB,CAAC,EAAE,MAAM,CAAA;IAC5B,0FAA0F;IAC1F,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B,sGAAsG;IACtG,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;IAClB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,8BAA8B,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CAC5E;AAED;;;GAGG;AACH,qBAAa,4BAA6B,YAAW,UAAU;IAC7D,OAAO,CAAC,IAAI,CAAqC;IACjD,OAAO,CAAC,UAAU,CAA8C;gBAEpD,IAAI,EAAE,mCAAmC;IAI/C,eAAe,CAAC,IAAI,EAAE,SAAS,EAAE,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IAoC1D,aAAa,CAAC,QAAQ,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC;IAmDjE,WAAW,CAAC,OAAO,EAAE,cAAc,EAAE,EAAE,QAAQ,EAAE,cAAc,GAAG,OAAO,CAAC,cAAc,CAAC;IASzF,cAAc,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAgCrE;;;;OAIG;IACG,gBAAgB,CAAC,IAAI,EAAE,SAAS,EAAE,GAAG,OAAO,CAAC,8BAA8B,CAAC;IAYlF;;;;OAIG;IACH,SAAS,CAAC,MAAM,EAAE,8BAA8B,GAAG,IAAI;IAIvD,aAAa,IAAI,8BAA8B,GAAG,IAAI;CAGvD"}

package/dist/rl/preferences.d.ts

@@ -1,141 +0,0 @@
-/**
- * Preference dataset extraction — bridge from `RunRecord[]` to RL training.
- *
- * Production RLHF / DPO / KTO / SimPO pipelines need preference triples:
- * `(prompt, chosen, rejected)`. The campaign artifact already contains the
- * ingredients — every (variantId, scenarioId, seed) cell is a candidate
- * that ran the same prompt against the same scenario, scored by the same
- * judge — but turning that into a clean preference dataset requires
- * deciding *what counts as a preference*.
- *
- * This module ships three preference-extraction strategies with explicit
- * tradeoffs, plus a unified output type compatible with HuggingFace TRL,
- * Anthropic finetuning JSONL, and OpenAI fine-tuning APIs. The strategies
- * are deliberately not auto-magical — picking the wrong one corrupts the
- * gradient.
- *
- * Strategies:
- *
- *   1. **`paired-by-scenario-and-seed`** — exact-match comparisons. For
- *      each scenario × seed pair, compare every (variantA, variantB) on
- *      that exact (scenario, seed). Matches scenarios so the comparison
- *      isolates variant effects. Highest signal-to-noise; smallest
- *      dataset (only matched pairs count).
- *
- *   2. **`paired-by-scenario`** — looser matching. For each scenario,
- *      compare every (variantA, variantB) where both have ≥ 1 run on the
- *      same scenario. Aggregates across seeds to compute mean scores per
- *      (variant, scenario), then forms preferences from the means. More
- *      data, lower per-pair signal.
- *
- *   3. **`top-vs-bottom`** — coarsest. Within each scenario, the highest-
- *      scoring run is `chosen`, the lowest is `rejected`. Smallest dataset
- *      per scenario but biggest score gap per pair. Useful for early
- *      bootstrapping when you have few variants.
- *
- * The output `PreferenceTriple` is *agent-eval-canonical* but trivially
- * mappable to TRL's `DPODataset` shape (`prompt`, `chosen`, `rejected`)
- * via the `toTRLFormat` helper.
- */
-import type { RunRecord } from '../run-record';
-export type PreferenceStrategy = 'paired-by-scenario-and-seed' | 'paired-by-scenario' | 'top-vs-bottom';
-export interface PreferenceTriple {
-    /** The scenario (input) the variants were run against. */
-    scenarioId: string;
-    /** RunRecord ids on each side, for traceability. */
-    chosenRunId: string;
-    rejectedRunId: string;
-    /** Variant ids — load-bearing for the RL update. */
-    chosenVariantId: string;
-    rejectedVariantId: string;
-    /** The score gap between chosen and rejected. Larger = stronger signal. */
-    marginScore: number;
-    /**
-     * Optional `(chosen_score, rejected_score)` pair for soft-margin DPO
-     * variants. Omitted for `top-vs-bottom` runs that don't carry meaningful
-     * scalar gaps.
-     */
-    scores?: {
-        chosen: number;
-        rejected: number;
-    };
-    /** Tie-breaker — when multiple seeds match this scenario, the one used. */
-    seed?: number;
-    /**
-     * Free-form metadata propagated from the run records — e.g. original
-     * prompt-hash, model, etc. Lets the RL trainer reconstruct the prompt.
-     */
-    meta: {
-        chosenPromptHash: string;
-        rejectedPromptHash: string;
-        chosenConfigHash: string;
-        rejectedConfigHash: string;
-        chosenModel: string;
-        rejectedModel: string;
-    };
-}
-export interface ExtractPreferencesOptions {
-    strategy?: PreferenceStrategy;
-    /**
-     * Minimum score gap required to admit a pair. Pairs below this are
-     * dropped — they're noise, not signal. Default 0.05 (5% of [0,1]).
-     */
-    minMargin?: number;
-    /**
-     * Optional split tag filter — restrict to runs from one split. Default
-     * `'holdout'` (the canonical "real" signal).
-     */
-    splitTag?: RunRecord['splitTag'];
-    /**
-     * Optional reward extractor that overrides `outcome.holdoutScore` /
-     * `outcome.searchScore`. Use to drive preferences off a verifiable
-     * reward instead of the headline score.
-     */
-    rewardOf?: (run: RunRecord) => number | null;
-}
-export interface PreferenceExtractionReport {
-    pairs: PreferenceTriple[];
-    /** Number of (scenario, seed) cells inspected. */
-    cellsInspected: number;
-    /** Number of pairs filtered by `minMargin`. */
-    pairsBelowMargin: number;
-    /** Number of cells with only one variant (no comparison possible). */
-    cellsSingleton: number;
-    /** Strategy used. */
-    strategy: PreferenceStrategy;
-}
-/**
- * Convert `RunRecord[]` to preference triples for RL training.
- *
- * Returns a structured report so callers can see how much data was
- * dropped and why (low-margin pairs, singleton cells). For production
- * pipelines, you usually want to:
- *
- *   1. Run a campaign producing 5–10 variants × 50–200 scenarios × 3 seeds
- *   2. Call this with `strategy: 'paired-by-scenario-and-seed'` and a
- *      verifiable-reward extractor as `rewardOf`
- *   3. Pass `report.pairs` to `toTRLFormat` and pipe to your DPO trainer
- */
-export declare function extractPreferences(runs: RunRecord[], opts?: ExtractPreferencesOptions): PreferenceExtractionReport;
-/**
- * TRL-compatible export. TRL's `DPODataset` is `{ prompt, chosen, rejected }`
- * but the prompt isn't stored on the RunRecord — only its hash. The caller
- * passes a `promptOf(promptHash)` lookup that the TRL trainer can use.
- */
-export declare function toTRLFormat(triples: PreferenceTriple[], promptOf: (hash: string) => string): Array<{
-    prompt: string;
-    chosen: string;
-    rejected: string;
-}>;
-/**
- * Anthropic finetuning JSONL export — `{ system, user, assistant_chosen, assistant_rejected }`
- * shape. Same caveat as TRL: prompt + outputs are content the caller has
- * to map back from the run record / raw event log.
- */
-export declare function toAnthropicFormat(triples: PreferenceTriple[]): Array<{
-    scenarioId: string;
-    chosenRunId: string;
-    rejectedRunId: string;
-    margin: number;
-}>;
-//# sourceMappingURL=preferences.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"preferences.d.ts","sourceRoot":"","sources":["../../src/rl/preferences.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAE9C,MAAM,MAAM,kBAAkB,GAC1B,6BAA6B,GAC7B,oBAAoB,GACpB,eAAe,CAAA;AAEnB,MAAM,WAAW,gBAAgB;IAC/B,0DAA0D;IAC1D,UAAU,EAAE,MAAM,CAAA;IAClB,oDAAoD;IACpD,WAAW,EAAE,MAAM,CAAA;IACnB,aAAa,EAAE,MAAM,CAAA;IACrB,oDAAoD;IACpD,eAAe,EAAE,MAAM,CAAA;IACvB,iBAAiB,EAAE,MAAM,CAAA;IACzB,2EAA2E;IAC3E,WAAW,EAAE,MAAM,CAAA;IACnB;;;;OAIG;IACH,MAAM,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAA;IAC7C,2EAA2E;IAC3E,IAAI,CAAC,EAAE,MAAM,CAAA;IACb;;;OAGG;IACH,IAAI,EAAE;QACJ,gBAAgB,EAAE,MAAM,CAAA;QACxB,kBAAkB,EAAE,MAAM,CAAA;QAC1B,gBAAgB,EAAE,MAAM,CAAA;QACxB,kBAAkB,EAAE,MAAM,CAAA;QAC1B,WAAW,EAAE,MAAM,CAAA;QACnB,aAAa,EAAE,MAAM,CAAA;KACtB,CAAA;CACF;AAED,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,EAAE,kBAAkB,CAAA;IAC7B;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB;;;OAGG;IACH,QAAQ,CAAC,EAAE,SAAS,CAAC,UAAU,CAAC,CAAA;IAChC;;;;OAIG;IACH,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,SAAS,KAAK,MAAM,GAAG,IAAI,CAAA;CAC7C;AAED,MAAM,WAAW,0BAA0B;IACzC,KAAK,EAAE,gBAAgB,EAAE,CAAA;IACzB,kDAAkD;IAClD,cAAc,EAAE,MAAM,CAAA;IACtB,+CAA+C;IAC/C,gBAAgB,EAAE,MAAM,CAAA;IACxB,sEAAsE;IACtE,cAAc,EAAE,MAAM,CAAA;IACtB,qBAAqB;IACrB,QAAQ,EAAE,kBAAkB,CAAA;CAC7B;AASD;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,SAAS,EAAE,EACjB,IAAI,GAAE,yBAA8B,GACnC,0BAA0B,CAoH5B;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CACzB,OAAO,EAAE,gBAAgB,EAAE,EAC3B,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GACjC,KAAK,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CAM7D;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,gBAAgB,EAAE,GAC1B,KAAK,CAAC;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAO3F"}

package/dist/rl/process-reward.d.ts

@@ -1,122 +0,0 @@
-/**
- * Process reward extraction — step-level credit assignment from trace spans.
- *
- * RL on long-horizon agents needs *step-level* rewards, not run-level
- * ones. The classic credit-assignment problem (Sutton & Barto) requires
- * knowing which sub-decisions in a trajectory contributed to the
- * outcome. Modern systems (DeepSeek-R1, OpenAI o-series, Lightman et al.
- * "Let's Verify Step by Step" 2023) train *process reward models* (PRMs)
- * that score every step, then do RL with the PRM as the reward signal.
- *
- * This module extracts `StepReward[]` from trace spans — one per
- * meaningful step — and ships:
- *
- *   1. `extractStepRewards(store, runId, opts)` — span → step-reward
- *      conversion using configurable per-span scorers (LLM judge over the
- *      span output, deterministic checkers, or a learned PRM).
- *   2. `runwiseStepRewardSummary(stepRewards)` — aggregate the per-step
- *      signal into a credit-assignment-aware run-level score.
- *   3. `prmTrainingPairs(stepRewards, options)` — produce the
- *      `(prefix, suffix_chosen, suffix_rejected)` triples that PRM
- *      training pipelines consume.
- *
- * What we ship: the *extraction* and *aggregation* infrastructure plus
- * the data shape PRM training expects. We do NOT ship the actual PRM
- * training (gradient descent over a transformer is out of scope for a
- * TS package). The interface is the contract; downstream consumers wire
- * their preferred trainer.
- *
- * Caveat the panel will land: this is descriptive credit assignment
- * (which steps correlate with outcome), not causal credit assignment
- * (which steps caused outcome). For causal claims you need
- * counterfactual rollouts or a learned dynamics model. Future work; the
- * descriptive version is what production PRM training actually uses.
- */
-import type { Span } from '../trace/schema';
-import type { TraceStore } from '../trace/store';
-export interface StepReward {
-    /** Trace span this reward attaches to. */
-    spanId: string;
-    runId: string;
-    /** Index in the trajectory (0-based, in started-at order). */
-    stepIndex: number;
-    /** Span kind (typically 'tool', 'llm', 'judge'). */
-    kind: Span['kind'];
-    /** Span name — for the consumer's downstream filtering. */
-    name: string;
-    /** Step-level reward in [0, 1]. */
-    reward: number;
-    /**
-     * Determinism class. Mirrors the verifiable-reward distinction:
-     * deterministic = test/compile/schema check; probabilistic = LLM judge.
-     */
-    determinism: 'deterministic' | 'probabilistic';
-    /** Optional rationale / evidence — the trainer typically discards. */
-    rationale?: string;
-    /** Optional weight — how much this step contributes to credit assignment. */
-    weight?: number;
-}
-export interface StepScorer {
-    /** Span kinds this scorer applies to. */
-    appliesTo: Span['kind'][];
-    /** Returns null to skip the span; returns a `StepReward` shape (without index/runId/spanId, which are filled in). */
-    score(span: Span): Promise<Omit<StepReward, 'spanId' | 'runId' | 'stepIndex'>> | null | undefined;
-}
-export interface ExtractStepRewardsOptions {
-    /**
-     * Ordered list of scorers. Each span runs through scorers in order;
-     * the first non-null result wins. If no scorer applies, the span is
-     * skipped (not all spans are training-worthy).
-     */
-    scorers: StepScorer[];
-    /** Optional filter — return null to drop the span entirely before scoring. */
-    preFilter?: (span: Span) => boolean;
-}
-export declare function extractStepRewards(store: TraceStore, runId: string, opts: ExtractStepRewardsOptions): Promise<StepReward[]>;
-export interface RunwiseStepSummary {
-    runId: string;
-    totalSteps: number;
-    meanReward: number;
-    /** Sum-of-rewards (weighted by `weight ?? 1`). Use as the run-level proxy. */
-    sumWeightedReward: number;
-    /** Fraction of steps where reward < 0.5 — proxy for "where the policy was wrong." */
-    failureFraction: number;
-    /** Maximum drop in reward between consecutive steps — diagnoses a step where things went sideways. */
-    worstStepDelta: number;
-    worstStepIndex: number | null;
-}
-export declare function runwiseStepRewardSummary(stepRewards: StepReward[]): RunwiseStepSummary;
-export interface PrmTrainingTriple {
-    /** Prefix run-id (or composite key) — the trajectory up to step k-1. */
-    prefixRunId: string;
-    prefixStepIndex: number;
-    /** The step that came next on a high-reward trajectory. */
-    chosenSpanId: string;
-    chosenReward: number;
-    /** A step from a divergent low-reward trajectory at the same prefix length. */
-    rejectedSpanId: string;
-    rejectedReward: number;
-    /** The prefix run came from this run; the rejected step came from `rejectedRunId`. */
-    rejectedRunId: string;
-    marginScore: number;
-}
-/**
- * Build PRM training triples. The shape: pair runs that share an early
- * prefix (same scenario, same first N steps) and diverge later — at the
- * point of divergence, the high-reward run's next step is `chosen`, the
- * low-reward run's next step is `rejected`. This is the canonical PRM
- * training data shape from Lightman et al. and DeepSeek-R1 process
- * supervision.
- *
- * Implementation note: we don't have a way to detect "same prefix" in
- * the general agent setting (token-level prefixes require hashing model
- * outputs). The current heuristic groups by `(scenarioId, prefixSpanName
- * sequence)` — runs are paired when their first K span names match. For
- * production use this should be replaced with a proper trajectory-prefix
- * hash; the heuristic is good enough for early-stage scaffolding.
- */
-export declare function prmTrainingPairs(stepRewardsByRun: Map<string, StepReward[]>, opts?: {
-    minMargin?: number;
-    minPrefixLength?: number;
-}): PrmTrainingTriple[];
-//# sourceMappingURL=process-reward.d.ts.map

package/dist/rl/process-reward.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"process-reward.d.ts","sourceRoot":"","sources":["../../src/rl/process-reward.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAEhD,MAAM,WAAW,UAAU;IACzB,0CAA0C;IAC1C,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;IACb,8DAA8D;IAC9D,SAAS,EAAE,MAAM,CAAA;IACjB,oDAAoD;IACpD,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,CAAA;IAClB,2DAA2D;IAC3D,IAAI,EAAE,MAAM,CAAA;IACZ,mCAAmC;IACnC,MAAM,EAAE,MAAM,CAAA;IACd;;;OAGG;IACH,WAAW,EAAE,eAAe,GAAG,eAAe,CAAA;IAC9C,sEAAsE;IACtE,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,6EAA6E;IAC7E,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,UAAU;IACzB,yCAAyC;IACzC,SAAS,EAAE,IAAI,CAAC,MAAM,CAAC,EAAE,CAAA;IACzB,qHAAqH;IACrH,KAAK,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,UAAU,EAAE,QAAQ,GAAG,OAAO,GAAG,WAAW,CAAC,CAAC,GAAG,IAAI,GAAG,SAAS,CAAA;CAClG;AAED,MAAM,WAAW,yBAAyB;IACxC;;;;OAIG;IACH,OAAO,EAAE,UAAU,EAAE,CAAA;IACrB,8EAA8E;IAC9E,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,OAAO,CAAA;CACpC;AAED,wBAAsB,kBAAkB,CACtC,KAAK,EAAE,UAAU,EACjB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,yBAAyB,GAC9B,OAAO,CAAC,UAAU,EAAE,CAAC,CA8BvB;AAED,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,MAAM,CAAA;IACb,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,MAAM,CAAA;IAClB,8EAA8E;IAC9E,iBAAiB,EAAE,MAAM,CAAA;IACzB,qFAAqF;IACrF,eAAe,EAAE,MAAM,CAAA;IACvB,sGAAsG;IACtG,cAAc,EAAE,MAAM,CAAA;IACtB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAA;CAC9B;AAED,wBAAgB,wBAAwB,CAAC,WAAW,EAAE,UAAU,EAAE,GAAG,kBAAkB,CA6CtF;AAED,MAAM,WAAW,iBAAiB;IAChC,wEAAwE;IACxE,WAAW,EAAE,MAAM,CAAA;IACnB,eAAe,EAAE,MAAM,CAAA;IACvB,2DAA2D;IAC3D,YAAY,EAAE,MAAM,CAAA;IACpB,YAAY,EAAE,MAAM,CAAA;IACpB,+EAA+E;IAC/E,cAAc,EAAE,MAAM,CAAA;IACtB,cAAc,EAAE,MAAM,CAAA;IACtB,sFAAsF;IACtF,aAAa,EAAE,MAAM,CAAA;IACrB,WAAW,EAAE,MAAM,CAAA;CACpB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAC9B,gBAAgB,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,EAAE,CAAC,EAC3C,IAAI,GAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,eAAe,CAAC,EAAE,MAAM,CAAA;CAAO,GAC1D,iBAAiB,EAAE,CAsDrB"}