@tangle-network/agent-eval 0.93.0 → 0.95.0

package/dist/reporting.js

@@ -4,7 +4,7 @@ import {
   evaluateReleaseConfidence,
   judgeReplayGate,
   renderReleaseReport
-} from "./chunk-4FBZZIYD.js";
+} from "./chunk-QTMYW64F.js";
 import {
   rubricPredictiveValidity
 } from "./chunk-YRZ4M5GS.js";
@@ -18,12 +18,12 @@ import {
   paretoChart,
   researchReport,
   summaryTable
-} from "./chunk-CY6U5S3X.js";
+} from "./chunk-URWVKRCS.js";
 import {
   benjaminiHochberg,
   pairedBootstrap,
   wilcoxonSignedRank
-} from "./chunk-LMZQ2Z4U.js";
+} from "./chunk-56GC6VYO.js";
 import "./chunk-VSMTAMNK.js";
 import "./chunk-3BFEG2F6.js";
 import "./chunk-PZ5AY32C.js";

package/dist/researcher.d.ts

@@ -0,0 +1,140 @@
+/**
+ * Researcher interface — stable hook for an external autonomous-research
+ * agent to drive the meta-loop.
+ *
+ * Implementations live downstream (typically in a private repo that
+ * runs the actual LLM). This package ships only the contract + a
+ * `NoopResearcher` so consumers can wire the surface without being
+ * forced to implement every method up front.
+ *
+ * The four methods mirror the four stages of the paper "Two Loops,
+ * Three Roles":
+ *
+ *   inspectFailures   — given the observed runs, what failure modes
+ *                       are present? (data → diagnosis)
+ *   proposeChange     — given diagnosed failure modes, what
+ *                       structural changes should we try?
+ *                       (diagnosis → plan delta)
+ *   applyChange       — fold the proposed deltas into a concrete
+ *                       experiment plan against an existing baseline.
+ *                       (plan delta → executable plan)
+ *   evaluateChange    — run the plan, return runs + the gate verdict.
+ *                       (executable plan → verdict)
+ *
+ * Composition is the discipline: a Researcher implementation MUST
+ * keep these four steps separate and inspectable. Conflating
+ * "diagnose + propose + run" into a single LLM call defeats the
+ * point of the framework — you can't audit which step lied.
+ *
+ * THIS INTERFACE IS STABLE. Breaking changes require a new module
+ * (e.g. `Researcher2`) so existing implementations keep working.
+ */
+import type { GateDecision } from './held-out-gate';
+import type { RunRecord, RunSplitTag } from './run-record';
+/** A diagnosed failure mode with the run-IDs that exhibit it. */
+export interface FailureMode {
+    /** Short machine-readable code. Must be stable across runs of the
+     *  same researcher to enable longitudinal tracking. */
+    code: string;
+    /** Human-readable description for the paper / dashboard. */
+    description: string;
+    evidence: {
+        /** Run IDs (from `RunRecord.runId`) where this failure mode was
+         *  observed. */
+        runIds: string[];
+        /** Number of run samples that informed the diagnosis. */
+        samples: number;
+    };
+}
+/** A single steering change the researcher wants to try. */
+export interface SteeringChange {
+    kind: 'reviewer_prompt' | 'skill_add' | 'skill_remove' | 'threshold' | 'budget';
+    /** Implementation-specific payload. Researcher implementations
+     *  define the schema — keep this `unknown` here to avoid coupling
+     *  the public interface to any one researcher's internal model. */
+    payload: unknown;
+    /** Why the researcher proposed this change. Goes into the audit
+     *  trail next to the failure-mode evidence. */
+    rationale: string;
+    /** Optional self-reported expected delta on the headline metric. */
+    expectedDelta?: number;
+}
+/** A single experiment plan, mapped onto the search/holdout splits. */
+export interface ExperimentPlan {
+    baselineCandidateId: string;
+    proposedCandidateId: string;
+    changes: SteeringChange[];
+    /** USD ceiling for the entire experiment. The runner must stop
+     *  before exceeding this and report a partial result. */
+    evaluationBudgetUsd: number;
+    /** Item IDs (your dataset keys) for the search vs holdout splits. */
+    splits: {
+        search: string[];
+        holdout: string[];
+    };
+}
+/** Result of running a plan: every run, plus the gate verdict. */
+export interface ExperimentResult {
+    plan: ExperimentPlan;
+    runs: RunRecord[];
+    gateDecision: GateDecision;
+}
+/**
+ * The researcher loop. Stable, four-step, inspectable.
+ *
+ *   ┌──────────┐  inspectFailures  ┌──────────┐  proposeChange ┌──────────┐
+ *   │   runs   │ ─────────────────▶│ failures │ ──────────────▶│ changes  │
+ *   └──────────┘                   └──────────┘                └────┬─────┘
+ *                                                                   │
+ *                                                                   ▼
+ *                              ┌────────────────┐  applyChange ┌────────┐
+ *                              │ ExperimentPlan │ ◀────────────│  base  │
+ *                              └────────┬───────┘              └────────┘
+ *                                       │
+ *                       evaluateChange  ▼
+ *                              ┌────────────────┐
+ *                              │ ExperimentResult│
+ *                              └────────────────┘
+ */
+export interface Researcher {
+    inspectFailures(runs: RunRecord[]): Promise<FailureMode[]>;
+    proposeChange(failures: FailureMode[]): Promise<SteeringChange[]>;
+    applyChange(changes: SteeringChange[], baseline: ExperimentPlan): Promise<ExperimentPlan>;
+    evaluateChange(plan: ExperimentPlan): Promise<ExperimentResult>;
+}
+export interface CallbackResearcherOptions {
+    inspectFailures: Researcher['inspectFailures'];
+    proposeChange: Researcher['proposeChange'];
+    applyChange: Researcher['applyChange'];
+    evaluateChange: Researcher['evaluateChange'];
+}
+/**
+ * Minimal concrete researcher for tests, scripts, and small integrations.
+ * Larger autonomous researchers can still implement `Researcher` directly.
+ */
+export declare class CallbackResearcher implements Researcher {
+    private readonly callbacks;
+    constructor(callbacks: CallbackResearcherOptions);
+    inspectFailures(runs: RunRecord[]): Promise<FailureMode[]>;
+    proposeChange(failures: FailureMode[]): Promise<SteeringChange[]>;
+    applyChange(changes: SteeringChange[], baseline: ExperimentPlan): Promise<ExperimentPlan>;
+    evaluateChange(plan: ExperimentPlan): Promise<ExperimentResult>;
+}
+/**
+ * No-op researcher — fails loud on every method. Use as a placeholder
+ * in code paths that wire the interface but don't have an implementation
+ * yet. Importantly, this does NOT silently succeed: a no-op researcher
+ * that returned empty arrays would muffle the loop's signal that
+ * nobody implemented the brain.
+ */
+export declare class NoopResearcher implements Researcher {
+    private readonly hint;
+    constructor(hint?: string);
+    inspectFailures(_runs: RunRecord[]): Promise<FailureMode[]>;
+    proposeChange(_failures: FailureMode[]): Promise<SteeringChange[]>;
+    applyChange(_changes: SteeringChange[], _baseline: ExperimentPlan): Promise<ExperimentPlan>;
+    evaluateChange(_plan: ExperimentPlan): Promise<ExperimentResult>;
+}
+/** Re-export the split alias so callers don't have to import twice. */
+export type { RunSplitTag };
+//# sourceMappingURL=researcher.d.ts.map

package/dist/researcher.d.ts.map

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

package/dist/reviewer.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Reviewer primitives — prompt builder + default ReviewFn factory.
+ *
+ * `buildReviewerPrompt` is the pure, LLM-agnostic piece: takes
+ * `ReviewerPromptInput` (user request, trace summary, verification
+ * summary, memory, optional extra context) and emits the system +
+ * user message pair. No LLM dependency — callers that want to drive
+ * their own transport get full control.
+ *
+ * `createDefaultReviewer` is the convenience factory: wires the prompt
+ * builder to `callLlmJson` with a default schema + soft-fail policy.
+ * Returns a function that maps `ReviewerPromptInput` to `ReviewerOutput`.
+ *
+ * Same pattern as `runSemanticConceptJudge` / `createSemanticConceptJudge`:
+ * low-level pure builder + high-level factory built on top.
+ */
+import { type LlmClientOptions } from './llm-client';
+export interface ReviewerMemoryEntry {
+    shot: number;
+    ts?: string;
+    observations?: string;
+    diagnosis?: string;
+    nextShotInstruction?: string;
+    shouldContinue?: boolean;
+    confidence?: number;
+}
+export interface ReviewerVerificationSummary {
+    blendedScore: number;
+    allPass: boolean;
+    failCount: number;
+    failingLayers?: string[];
+}
+export interface ReviewerPromptInput {
+    shot: number;
+    userRequest: string;
+    /**
+     * Compact trace summary — tool-call counts, errors, recent activity
+     * lines. Built by the caller from whatever trace format they have;
+     * agent-eval does not prescribe.
+     */
+    traceSummary: string;
+    verification: ReviewerVerificationSummary;
+    memory: ReviewerMemoryEntry[];
+    /**
+     * Optional extra context injected into the prompt between the trace
+     * and the verification blocks. Use for workdir file-tree snapshots,
+     * scaffold descriptions, or any environmental fact the reviewer
+     * needs to direct the next shot accurately.
+     */
+    extraContext?: string;
+    /**
+     * Optional extra section appended at the end of the prompt (e.g.
+     * leaf metadata, scenario id). Free-form — no agent-eval-shaped
+     * schema.
+     */
+    trailingContext?: string;
+}
+export interface ReviewerOutput {
+    shot: number;
+    observations: string;
+    diagnosis: string;
+    nextShotInstruction: string;
+    shouldContinue: boolean;
+    /** 0..1 self-assessed confidence in the directive. */
+    confidence: number;
+    /** LLM cost in USD if the transport reports it, else null. */
+    costUsd: number | null;
+    durationMs: number;
+    /** False when the LLM errored or returned malformed JSON; caller soft-fails to defaults. */
+    available: boolean;
+    error?: string;
+}
+export interface ReviewerSoftFailDefaults {
+    observations?: string;
+    diagnosis?: string;
+    nextShotInstruction?: string;
+    shouldContinue?: boolean;
+    confidence?: number;
+}
+export interface CreateDefaultReviewerOptions {
+    /** Model id to call. */
+    model: string;
+    /** Per-call timeout. Default 300s. */
+    timeoutMs?: number;
+    /** LlmClient transport config (baseUrl, apiKey, authHeader, etc.). */
+    llm?: LlmClientOptions;
+    /**
+     * Override the prompt builder. Default: `buildReviewerPrompt`.
+     * Consumers with different reviewer voices pass their own.
+     */
+    promptBuilder?: (input: ReviewerPromptInput) => {
+        system: string;
+        user: string;
+    };
+    /**
+     * Soft-fail values when the LLM throws or returns unparseable JSON.
+     * Matches VerticalBench's shipped policy: continue with generic
+     * instruction at confidence 0.3 so the worker keeps trying.
+     */
+    softFailDefaults?: ReviewerSoftFailDefaults;
+}
+/**
+ * Build the reviewer's system + user messages. Pure function, no LLM
+ * call. Callers that want their own transport or a different structured
+ * output can use this and skip `createDefaultReviewer` entirely.
+ */
+export declare function buildReviewerPrompt(input: ReviewerPromptInput): {
+    system: string;
+    user: string;
+};
+/**
+ * Factory: returns a function that invokes the default reviewer against
+ * an LLM and parses the structured output. Soft-fails to the provided
+ * defaults on LLM throw or JSON-parse error so the shot loop keeps
+ * moving rather than crashing.
+ */
+export declare function createDefaultReviewer(options: CreateDefaultReviewerOptions): (input: ReviewerPromptInput) => Promise<ReviewerOutput>;
+//# sourceMappingURL=reviewer.d.ts.map

package/dist/reviewer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reviewer.d.ts","sourceRoot":"","sources":["../src/reviewer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAe,KAAK,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAIjE,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAA;IACZ,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,mBAAmB,CAAC,EAAE,MAAM,CAAA;IAC5B,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED,MAAM,WAAW,2BAA2B;IAC1C,YAAY,EAAE,MAAM,CAAA;IACpB,OAAO,EAAE,OAAO,CAAA;IAChB,SAAS,EAAE,MAAM,CAAA;IACjB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAA;CACzB;AAED,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB;;;;OAIG;IACH,YAAY,EAAE,MAAM,CAAA;IACpB,YAAY,EAAE,2BAA2B,CAAA;IACzC,MAAM,EAAE,mBAAmB,EAAE,CAAA;IAC7B;;;;;OAKG;IACH,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB;;;;OAIG;IACH,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAA;IACZ,YAAY,EAAE,MAAM,CAAA;IACpB,SAAS,EAAE,MAAM,CAAA;IACjB,mBAAmB,EAAE,MAAM,CAAA;IAC3B,cAAc,EAAE,OAAO,CAAA;IACvB,sDAAsD;IACtD,UAAU,EAAE,MAAM,CAAA;IAClB,8DAA8D;IAC9D,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,UAAU,EAAE,MAAM,CAAA;IAClB,4FAA4F;IAC5F,SAAS,EAAE,OAAO,CAAA;IAClB,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED,MAAM,WAAW,wBAAwB;IACvC,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,mBAAmB,CAAC,EAAE,MAAM,CAAA;IAC5B,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED,MAAM,WAAW,4BAA4B;IAC3C,wBAAwB;IACxB,KAAK,EAAE,MAAM,CAAA;IACb,sCAAsC;IACtC,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,sEAAsE;IACtE,GAAG,CAAC,EAAE,gBAAgB,CAAA;IACtB;;;OAGG;IACH,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,mBAAmB,KAAK;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAA;IAChF;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,wBAAwB,CAAA;CAC5C;AAkCD;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,mBAAmB,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CA6ChG;AAcD;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,4BAA4B,GACpC,CAAC,KAAK,EAAE,mBAAmB,KAAK,OAAO,CAAC,cAAc,CAAC,CA0DzD"}

package/dist/reviewer.test.d.ts

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

package/dist/reviewer.test.d.ts.map

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

package/dist/reward-model-export.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Reward-model export — the productizable wrapper around PRM training
+ * data. Takes a TraceStore + PrmGrader, produces an embeddable
+ * inference scorer that customers plug into their own agent stack.
+ *
+ * Two export forms:
+ *   - `exportRewardModel(store, graders)` — serializes the (step-context,
+ *     score) corpus to a framework-agnostic payload. Customer fine-tunes
+ *     their own model; we ship the scaffolding.
+ *   - `loadScorerFromTraces(store, grader)` — a zero-deps "reward model"
+ *     that literally replays the trained rubric at inference time. Works
+ *     as a reference baseline + deterministic fallback.
+ */
+import type { PrmGradedTrace, PrmGrader } from './prm/rubric';
+import { type PrmTrainingSample } from './prm/training-export';
+import type { TraceStore } from './trace/store';
+import type { Trajectory } from './trajectory';
+export interface ExportedRewardModel {
+    /** Version of the export format. Bump when payload shape changes. */
+    version: '1.0';
+    /** Metadata about the training corpus. */
+    metadata: {
+        nTraces: number;
+        nSamples: number;
+        rubrics: string[];
+        exportedAt: string;
+        /** Mean reward across training corpus — use as sanity check at load. */
+        meanReward: number;
+    };
+    /** NDJSON training payload suitable for most fine-tuning frameworks. */
+    trainingNdjson: string;
+}
+export declare function exportRewardModel(store: TraceStore, grader: PrmGrader, runIds: string[]): Promise<ExportedRewardModel>;
+/**
+ * Zero-deps inference scorer — apply a grader to a trajectory and return
+ * its aggregate score. This is the "reward model" customers embed when
+ * they don't want (or can't) fine-tune one. Deterministic + portable.
+ */
+export interface InferenceScorer {
+    /** Score a completed trajectory. Higher is better. */
+    score(trajectory: Trajectory, store: TraceStore): Promise<number>;
+    metadata: {
+        rubrics: string[];
+        deterministic: true;
+    };
+}
+export declare function loadScorerFromGrader(grader: PrmGrader): InferenceScorer;
+/**
+ * Replay a trace corpus through a scorer — produces the canonical
+ * "what would this reward model have said about every run?" table.
+ * Callers use this to validate a trained model against the training
+ * corpus (expect high agreement; drift indicates overfitting).
+ */
+export declare function replayScorerOverCorpus(store: TraceStore, scorer: InferenceScorer, runIds: string[]): Promise<Array<{
+    runId: string;
+    score: number;
+    outcomeScore: number | null;
+}>>;
+export type { PrmGradedTrace, PrmTrainingSample };
+//# sourceMappingURL=reward-model-export.d.ts.map

package/dist/reward-model-export.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reward-model-export.d.ts","sourceRoot":"","sources":["../src/reward-model-export.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAC7D,OAAO,EAAsB,KAAK,iBAAiB,EAAY,MAAM,uBAAuB,CAAA;AAC5F,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAC/C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAG9C,MAAM,WAAW,mBAAmB;IAClC,qEAAqE;IACrE,OAAO,EAAE,KAAK,CAAA;IACd,0CAA0C;IAC1C,QAAQ,EAAE;QACR,OAAO,EAAE,MAAM,CAAA;QACf,QAAQ,EAAE,MAAM,CAAA;QAChB,OAAO,EAAE,MAAM,EAAE,CAAA;QACjB,UAAU,EAAE,MAAM,CAAA;QAClB,wEAAwE;QACxE,UAAU,EAAE,MAAM,CAAA;KACnB,CAAA;IACD,wEAAwE;IACxE,cAAc,EAAE,MAAM,CAAA;CACvB;AAED,wBAAsB,iBAAiB,CACrC,KAAK,EAAE,UAAU,EACjB,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,MAAM,EAAE,GACf,OAAO,CAAC,mBAAmB,CAAC,CAiB9B;AAED;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B,sDAAsD;IACtD,KAAK,CAAC,UAAU,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IACjE,QAAQ,EAAE;QAAE,OAAO,EAAE,MAAM,EAAE,CAAC;QAAC,aAAa,EAAE,IAAI,CAAA;KAAE,CAAA;CACrD;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,SAAS,GAAG,eAAe,CAWvE;AAED;;;;;GAKG;AACH,wBAAsB,sBAAsB,CAC1C,KAAK,EAAE,UAAU,EACjB,MAAM,EAAE,eAAe,EACvB,MAAM,EAAE,MAAM,EAAE,GACf,OAAO,CAAC,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC,CAAC,CAc/E;AAGD,YAAY,EAAE,cAAc,EAAE,iBAAiB,EAAE,CAAA"}

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

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

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

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

@@ -0,0 +1 @@
+{"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/{adversarial-DIVcDoI_.d.ts → rl/adversarial.d.ts}

@@ -22,7 +22,7 @@
  * criteria). The adversarial primitive is just the *scenario-mutation
  * meta-loop* on top of that machinery.
  */
-interface AdversarialScenario<S> {
+export interface AdversarialScenario<S> {
     /** Stable id — used for deduplication and lineage tracking. */
     id: string;
     /** Generation index — 0 for seeds, 1 for first round of mutations, etc. */
@@ -35,7 +35,7 @@ interface AdversarialScenario<S> {
     /** Strategy that produced this mutation, for diagnostics. */
     mutationStrategy: string | null;
 }
-interface AdversarialMutation<S> {
+export interface AdversarialMutation<S> {
     id: string;
     /**
      * Mutate one scenario. Return null to skip; return one or more new
@@ -43,7 +43,7 @@ interface AdversarialMutation<S> {
      */
     mutate(parent: S, rng: () => number): Promise<S[]> | S[];
 }
-interface AdversarialSearchOptions<S> {
+export interface AdversarialSearchOptions<S> {
     /** Initial scenarios — typically those the policy currently passes. */
     seeds: S[];
     /** Stable identifier extraction. */
@@ -69,7 +69,7 @@ interface AdversarialSearchOptions<S> {
     /** Seed for the deterministic RNG. Default 1. */
     seed?: number;
 }
-interface AdversarialSearchReport<S> {
+export interface AdversarialSearchReport<S> {
     scenarios: AdversarialScenario<S>[];
     /** Discovered failures sorted by score ascending. */
     failures: AdversarialScenario<S>[];
@@ -83,6 +83,5 @@ interface AdversarialSearchReport<S> {
     /** Total scoreFn invocations consumed. */
     scoreCalls: number;
 }
-declare function adversarialScenarioSearch<S>(opts: AdversarialSearchOptions<S>): Promise<AdversarialSearchReport<S>>;
-
-export { type AdversarialMutation as A, type AdversarialScenario as a, type AdversarialSearchOptions as b, type AdversarialSearchReport as c, adversarialScenarioSearch as d };
+export declare function adversarialScenarioSearch<S>(opts: AdversarialSearchOptions<S>): Promise<AdversarialSearchReport<S>>;
+//# sourceMappingURL=adversarial.d.ts.map

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

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