@tangle-network/agent-eval 0.94.0 → 0.95.0

package/dist/{off-policy-DiwuKKg7.d.ts → rl/off-policy.d.ts}

@@ -36,7 +36,7 @@
  * complement with `replayCampaign` (exact replay where the request hashes
  * match) for high-confidence answers and OPE for the gap.
  */
-interface OffPolicyTrajectory {
+export interface OffPolicyTrajectory {
     /** Stable id, for traceability through the dataset. */
     runId: string;
     /** Reward observed under the behavior policy (the realized outcome). */
@@ -59,7 +59,7 @@ interface OffPolicyTrajectory {
      */
     qHat?: number | null;
 }
-interface OffPolicyEstimate {
+export interface OffPolicyEstimate {
     /** Estimated value of the target policy. */
     value: number;
     /** Standard error of the estimate. */
@@ -74,7 +74,7 @@ interface OffPolicyEstimate {
      */
     maxImportanceWeight: number;
 }
-interface OffPolicyOptions {
+export interface OffPolicyOptions {
     /**
      * Cap importance weights at this value (Ionides 2008 truncated IS) to
      * trade unbiasedness for variance reduction. Default `Infinity` (no cap).
@@ -92,13 +92,13 @@ interface OffPolicyOptions {
  * of E[reward under target policy]. Variance scales with the spread of
  * target/behavior ratios.
  */
-declare function inverseProbabilityWeighting(trajectories: OffPolicyTrajectory[], opts?: OffPolicyOptions): OffPolicyEstimate;
+export declare function inverseProbabilityWeighting(trajectories: OffPolicyTrajectory[], opts?: OffPolicyOptions): OffPolicyEstimate;
 /**
  * Self-Normalized Importance Sampling. Lower variance than vanilla IPS at
  * the cost of small bias (vanishing as N grows). The right default for
  * LLM-agent evaluation where overlap is often poor.
  */
-declare function selfNormalizedImportanceWeighting(trajectories: OffPolicyTrajectory[], opts?: OffPolicyOptions): OffPolicyEstimate;
+export declare function selfNormalizedImportanceWeighting(trajectories: OffPolicyTrajectory[], opts?: OffPolicyOptions): OffPolicyEstimate;
 /**
  * Doubly-robust off-policy estimator (Dudík, Langford, Li 2011).
  *
@@ -117,16 +117,15 @@ declare function selfNormalizedImportanceWeighting(trajectories: OffPolicyTrajec
  * report's `n` reflects the full set but `effectiveSampleSize` accounts
  * for the lost variance reduction).
  */
-declare function doublyRobust(trajectories: OffPolicyTrajectory[], opts?: OffPolicyOptions): OffPolicyEstimate;
+export declare function doublyRobust(trajectories: OffPolicyTrajectory[], opts?: OffPolicyOptions): OffPolicyEstimate;
 /**
  * Convenience: run all three estimators and return them side-by-side.
  * The recommended diagnostic — agreement across estimators is a much
  * stronger signal than any single one.
  */
-declare function offPolicyEstimateAll(trajectories: OffPolicyTrajectory[], opts?: OffPolicyOptions): {
+export declare function offPolicyEstimateAll(trajectories: OffPolicyTrajectory[], opts?: OffPolicyOptions): {
     ips: OffPolicyEstimate;
     snips: OffPolicyEstimate;
     dr: OffPolicyEstimate;
 };
-
-export { type OffPolicyEstimate as O, type OffPolicyOptions as a, type OffPolicyTrajectory as b, doublyRobust as d, inverseProbabilityWeighting as i, offPolicyEstimateAll as o, selfNormalizedImportanceWeighting as s };
+//# sourceMappingURL=off-policy.d.ts.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,69 @@
+/**
+ * `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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,141 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,122 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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"}

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

@@ -0,0 +1,104 @@
+/**
+ * Reward hacking / Goodhart detection.
+ *
+ * Goodhart's Law says: when a measure becomes a target, it ceases to be
+ * a good measure. In RLHF and agentic-RL settings this is the dominant
+ * failure mode — the policy learns to produce outputs that score well on
+ * the proxy reward (judge, rubric, test pass-rate) without producing
+ * the underlying capability the proxy was meant to track.
+ *
+ * Krakovna et al. (2020, "Specification Gaming Examples in AI") and the
+ * subsequent RLHF reward-hacking literature (Skalse et al. 2022, Kim et al.
+ * 2023) converge on a few diagnostic signatures:
+ *
+ *   1. **Reward divergence:** the proxy reward grows while the held-out
+ *      ground-truth signal stagnates or drops. Predictive validity over
+ *      time captures this.
+ *   2. **Distributional shift in outputs:** after RL, the policy produces
+ *      outputs that no longer match the reference distribution — usually
+ *      because it found a high-reward attractor that's degenerate (e.g.
+ *      one-token responses, repetition, formatting tricks).
+ *   3. **Disagreement between independent rewards:** if you train on
+ *      reward A and a held-out independent reward B drops sharply, you're
+ *      probably hacking A.
+ *   4. **Calibration drift:** the verifiable / deterministic component of
+ *      the reward is stable; the probabilistic / judge component drifts up
+ *      while the deterministic component doesn't. The judge is being
+ *      gamed.
+ *
+ * This module ships explicit detectors for all four signatures, plus a
+ * combined verdict. The output is diagnostic — actionable signals,
+ * not autoreject — because each signature has known false positives
+ * (e.g., a policy that genuinely improves can show distributional shift).
+ *
+ * Differs from `rubricPredictiveValidity` (which is a *standing* check on
+ * whether rubrics correlate with deployment outcomes) — this is a
+ * *temporal* check on whether the reward-vs-truth gap is *widening over
+ * time during a training run*.
+ */
+import type { RunRecord } from '../run-record';
+import { type VerifiableRewardExtractionOptions } from './verifiable-reward';
+export type RewardHackingSignal = 'reward_divergence' | 'distribution_shift' | 'reward_disagreement' | 'judge_drift';
+export interface RewardHackingFinding {
+    signal: RewardHackingSignal;
+    /** Severity in [0, 1]. >0.5 = strong signal. */
+    severity: number;
+    message: string;
+    /** Numeric evidence the consumer can render. */
+    detail: Record<string, number>;
+}
+export interface RewardHackingReport {
+    findings: RewardHackingFinding[];
+    /**
+     * Composite verdict. `'clean'` if every signal severity < 0.3;
+     * `'suspect'` if at least one ≥ 0.3 but none ≥ 0.6; `'gaming'` if any ≥ 0.6.
+     */
+    verdict: 'clean' | 'suspect' | 'gaming';
+    /** Rationale for the verdict, ready to paste into an audit log. */
+    rationale: string[];
+    /** Number of paired (proxy, truth) data points the report saw. */
+    n: number;
+}
+export interface DetectRewardHackingInput {
+    /**
+     * Run records ordered by recency (oldest first). The detector segments
+     * them into prefix/suffix windows to compute "did the gap widen."
+     */
+    runs: RunRecord[];
+    /**
+     * The metric the policy was trained to optimize. Should be present on
+     * `outcome.raw` or `outcome.holdoutScore`. Default reads `outcome.holdoutScore`.
+     */
+    proxyOf?: (run: RunRecord) => number | null;
+    /**
+     * The held-out ground-truth metric. For RL on coding, this is typically
+     * test pass-rate. For RLHF, it's downstream task performance or human
+     * preference. For knowledge tasks, it's an independently-graded score.
+     */
+    truthOf?: (run: RunRecord) => number | null;
+    /**
+     * Independent secondary reward. Used for the `reward_disagreement`
+     * signal. Default uses the verifiable reward extractor (deterministic
+     * sources only).
+     */
+    secondaryRewardOf?: (run: RunRecord) => number | null;
+    /**
+     * Window size — how many of the most recent runs count as the "after"
+     * cohort. Default min(50, half the runs).
+     */
+    windowSize?: number;
+    /**
+     * Severity threshold to flag a signal. Default 0.3 (suspect) and 0.6
+     * (gaming).
+     */
+    thresholds?: {
+        suspect?: number;
+        gaming?: number;
+    };
+    /**
+     * Verifiable-reward options used for the secondary-reward fallback.
+     */
+    verifiableRewardOptions?: VerifiableRewardExtractionOptions;
+}
+export declare function detectRewardHacking(input: DetectRewardHackingInput): RewardHackingReport;
+//# sourceMappingURL=reward-hacking.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reward-hacking.d.ts","sourceRoot":"","sources":["../../src/rl/reward-hacking.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,EAEL,KAAK,iCAAiC,EACvC,MAAM,qBAAqB,CAAA;AAE5B,MAAM,MAAM,mBAAmB,GAC3B,mBAAmB,GACnB,oBAAoB,GACpB,qBAAqB,GACrB,aAAa,CAAA;AAEjB,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,mBAAmB,CAAA;IAC3B,gDAAgD;IAChD,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,gDAAgD;IAChD,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAC/B;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,oBAAoB,EAAE,CAAA;IAChC;;;OAGG;IACH,OAAO,EAAE,OAAO,GAAG,SAAS,GAAG,QAAQ,CAAA;IACvC,mEAAmE;IACnE,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB,kEAAkE;IAClE,CAAC,EAAE,MAAM,CAAA;CACV;AAED,MAAM,WAAW,wBAAwB;IACvC;;;OAGG;IACH,IAAI,EAAE,SAAS,EAAE,CAAA;IACjB;;;OAGG;IACH,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,SAAS,KAAK,MAAM,GAAG,IAAI,CAAA;IAC3C;;;;OAIG;IACH,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,SAAS,KAAK,MAAM,GAAG,IAAI,CAAA;IAC3C;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,CAAC,GAAG,EAAE,SAAS,KAAK,MAAM,GAAG,IAAI,CAAA;IACrD;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB;;;OAGG;IACH,UAAU,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;IAClD;;OAEG;IACH,uBAAuB,CAAC,EAAE,iCAAiC,CAAA;CAC5D;AAOD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,wBAAwB,GAAG,mBAAmB,CA6IxF"}

package/dist/rl/rl-campaign.d.ts

@@ -0,0 +1,85 @@
+/**
+ * `runRLCampaign` — top-level orchestrator that runs the matrix and
+ * produces every RL-ready artifact in one call.
+ *
+ * Wires:
+ *   1. `runEvalCampaign` for the matrix run (capture, integrity, hooks)
+ *   2. `extractVerifiableReward` over each run, separating deterministic
+ *      from probabilistic reward sources for the trainer
+ *   3. `extractPreferences` to produce DPO/PPO/KTO triples
+ *   4. `evaluateInterimReleaseConfidence` over paired deltas (anytime-valid)
+ *   5. `rubricPredictiveValidity` against an outcome store, when provided
+ *   6. `detectRewardHacking` as a standing hygiene check
+ *   7. Trainer-format export rows ready for prime-rl / TRL / verl
+ *
+ * The output `RLCampaignResult` is a single, audit-ready artifact: every
+ * stage's output is in there. The consumer's downstream fits in a single
+ * line: pass `result.preferences` to their DPO trainer, `result.grpoRows`
+ * to GRPO, `result.runs` plus `result.rewardSignals` to a custom RL loop.
+ */
+import { type EvalCampaignOptions, type EvalCampaignResult } from '../eval-campaign';
+import type { OutcomeStore } from '../meta-eval/outcome-store';
+import { type RubricPredictiveValidityReport } from '../meta-eval/rubric-predictive-validity';
+import { type InterimReleaseConfidence } from '../sequential';
+import { type DpoExportRow, type DpoLookups, type GrpoExportRow, type GrpoLookups, type SftExportRow, type SftLookups } from './exporters';
+import { type ExtractPreferencesOptions, type PreferenceExtractionReport } from './preferences';
+import { type RewardHackingReport } from './reward-hacking';
+import { type VerifiableReward, type VerifiableRewardExtractionOptions } from './verifiable-reward';
+export interface RunRLCampaignOptions<V> extends EvalCampaignOptions<V> {
+    /** Preference-extraction options. Default uses paired-by-scenario-and-seed with min-margin 0.05. */
+    preferences?: ExtractPreferencesOptions;
+    /** Verifiable-reward extraction options. */
+    verifiableReward?: VerifiableRewardExtractionOptions;
+    /** Outcome store + metric names — when supplied, runs `rubricPredictiveValidity` post-campaign. */
+    outcomeStore?: OutcomeStore;
+    outcomeMetrics?: string[];
+    /** Anytime-valid sequential evaluation options. */
+    sequential?: {
+        alpha?: number;
+        bound?: number;
+        rope?: {
+            low: number;
+            high: number;
+        };
+    };
+    /** Trainer-format export lookups. When provided, the orchestrator builds the corresponding rows. */
+    trainerExport?: {
+        dpo?: DpoLookups;
+        grpo?: GrpoLookups;
+        sft?: SftLookups;
+    };
+}
+export interface RLCampaignResult<V> {
+    campaign: EvalCampaignResult;
+    /** Per-run verifiable reward (deterministic when available, probabilistic fallback otherwise). */
+    rewardSignals: Array<{
+        runId: string;
+        reward: VerifiableReward | null;
+    }>;
+    /** Preference extraction report. */
+    preferences: PreferenceExtractionReport;
+    /** Anytime-valid interim verdict over the paired deltas (vs comparator). */
+    interimConfidence: InterimReleaseConfidence | null;
+    /** Standing reward-hacking hygiene check. */
+    rewardHacking: RewardHackingReport;
+    /** Predictive validity, when an outcome store was supplied. */
+    predictiveValidity: RubricPredictiveValidityReport | null;
+    /** Trainer-export rows, populated only for the formats the caller requested via `trainerExport`. */
+    trainerRows: {
+        dpo?: DpoExportRow[];
+        grpo?: GrpoExportRow[];
+        sft?: SftExportRow[];
+    };
+    /**
+     * One-line top-level summary the consumer can log.
+     */
+    summary: string;
+    /**
+     * Convenience type-tag — consumers can branch on `result.kind`.
+     */
+    kind: 'agent-eval-rl-campaign';
+    unusedVariant?: V;
+}
+export declare function runRLCampaign<V>(opts: RunRLCampaignOptions<V>): Promise<RLCampaignResult<V>>;
+export { runEvalCampaign } from '../eval-campaign';
+//# sourceMappingURL=rl-campaign.d.ts.map

package/dist/rl/rl-campaign.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rl-campaign.d.ts","sourceRoot":"","sources":["../../src/rl/rl-campaign.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EAExB,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAC9D,OAAO,EACL,KAAK,8BAA8B,EAEpC,MAAM,yCAAyC,CAAA;AAEhD,OAAO,EAAoC,KAAK,wBAAwB,EAAE,MAAM,eAAe,CAAA;AAC/F,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,UAAU,EACf,KAAK,aAAa,EAClB,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,UAAU,EAIhB,MAAM,aAAa,CAAA;AACpB,OAAO,EACL,KAAK,yBAAyB,EAE9B,KAAK,0BAA0B,EAChC,MAAM,eAAe,CAAA;AACtB,OAAO,EAAuB,KAAK,mBAAmB,EAAE,MAAM,kBAAkB,CAAA;AAChF,OAAO,EAEL,KAAK,gBAAgB,EACrB,KAAK,iCAAiC,EACvC,MAAM,qBAAqB,CAAA;AAE5B,MAAM,WAAW,oBAAoB,CAAC,CAAC,CAAE,SAAQ,mBAAmB,CAAC,CAAC,CAAC;IACrE,oGAAoG;IACpG,WAAW,CAAC,EAAE,yBAAyB,CAAA;IACvC,4CAA4C;IAC5C,gBAAgB,CAAC,EAAE,iCAAiC,CAAA;IACpD,mGAAmG;IACnG,YAAY,CAAC,EAAE,YAAY,CAAA;IAC3B,cAAc,CAAC,EAAE,MAAM,EAAE,CAAA;IACzB,mDAAmD;IACnD,UAAU,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE;YAAE,GAAG,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,CAAA;IACrF,oGAAoG;IACpG,aAAa,CAAC,EAAE;QACd,GAAG,CAAC,EAAE,UAAU,CAAA;QAChB,IAAI,CAAC,EAAE,WAAW,CAAA;QAClB,GAAG,CAAC,EAAE,UAAU,CAAA;KACjB,CAAA;CACF;AAED,MAAM,WAAW,gBAAgB,CAAC,CAAC;IACjC,QAAQ,EAAE,kBAAkB,CAAA;IAC5B,kGAAkG;IAClG,aAAa,EAAE,KAAK,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,gBAAgB,GAAG,IAAI,CAAA;KAAE,CAAC,CAAA;IACxE,oCAAoC;IACpC,WAAW,EAAE,0BAA0B,CAAA;IACvC,4EAA4E;IAC5E,iBAAiB,EAAE,wBAAwB,GAAG,IAAI,CAAA;IAClD,6CAA6C;IAC7C,aAAa,EAAE,mBAAmB,CAAA;IAClC,+DAA+D;IAC/D,kBAAkB,EAAE,8BAA8B,GAAG,IAAI,CAAA;IACzD,oGAAoG;IACpG,WAAW,EAAE;QACX,GAAG,CAAC,EAAE,YAAY,EAAE,CAAA;QACpB,IAAI,CAAC,EAAE,aAAa,EAAE,CAAA;QACtB,GAAG,CAAC,EAAE,YAAY,EAAE,CAAA;KACrB,CAAA;IACD;;OAEG;IACH,OAAO,EAAE,MAAM,CAAA;IACf;;OAEG;IACH,IAAI,EAAE,wBAAwB,CAAA;IAC9B,aAAa,CAAC,EAAE,CAAC,CAAA;CAClB;AAED,wBAAsB,aAAa,CAAC,CAAC,EACnC,IAAI,EAAE,oBAAoB,CAAC,CAAC,CAAC,GAC5B,OAAO,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAgF9B;AAmED,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA"}