/**
 * Gold scenarios for teacher→student distillation. The TEACHER is an
 * expensive workflow (e.g. the 70-agent skill audit) whose verdicts are
 * frozen as gold labels; the STUDENT is a cheap single-shot analyst whose
 * prompt GEPA optimizes toward reproducing those labels.
 *
 * A `GoldScenario` is a `Scenario` (the substrate's input contract) carrying
 * an OPAQUE `input` (what the student sees) and an OPAQUE `label` (the gold
 * verdict the student's output is scored against). Both are typed `unknown`
 * here: this module is domain-agnostic — it distills ANY analyst against ANY
 * gold JSONL. The agreement comparator (see `agreement-judge.ts`) is what
 * knows the label's shape.
 *
 * Loading + splitting are DETERMINISTIC and LLM-free: the gold set is the
 * fixed ground truth, never regenerated here.
 */
import type { Scenario } from '../types';
/** A held gold record: opaque student-input + opaque gold-label, carried as a
 *  substrate `Scenario` so it flows through `runCampaign` unchanged. */
export interface GoldScenario<TInput = unknown, TLabel = unknown> extends Scenario {
    kind: 'gold';
    /** What the student analyst is shown (rendered into its user prompt). */
    input: TInput;
    /** The teacher's gold verdict — the target the student's output is scored
     *  against by the agreement judge. NEVER shown to the student. */
    label: TLabel;
}
/** Read a gold JSONL (one `{scenarioId|id, input, label, split?}` per line) into
 *  `GoldScenario[]`. Deterministic, no LLM. Blank lines are skipped; a line
 *  missing an id, `input`, or `label` throws (a silent skip would corrupt the
 *  split silently — fail loud on a malformed gold set). */
export declare function loadGoldScenarios<TInput = unknown, TLabel = unknown>(jsonlPath: string): GoldScenario<TInput, TLabel>[];
/** Parse gold JSONL text directly (no fs). Exported so tests + in-memory
 *  callers exercise the same parse path as {@link loadGoldScenarios}. */
export declare function parseGoldJsonl<TInput = unknown, TLabel = unknown>(text: string, sourceLabel?: string): GoldScenario<TInput, TLabel>[];
export interface SplitGoldOptions {
    /** Every Nth scenario (0-based index) goes to the TEST/holdout split; the
     *  rest train. Default 4 ⇒ a 25% holdout. Ignored for any scenario that
     *  carries an explicit `split:` tag (that is honored verbatim). */
    testEveryNth?: number;
}
export interface GoldSplit<TInput, TLabel> {
    /** Training scenarios — the optimization pool the proposer searches over. */
    train: GoldScenario<TInput, TLabel>[];
    /** Held-out scenarios — kept OUT of training; scored only at the gate. */
    test: GoldScenario<TInput, TLabel>[];
}
/** Deterministic train/test split. A scenario tagged `split:train|test` is
 *  routed by that tag; the rest fall to a modulo split (`index % testEveryNth
 *  === 0 ⇒ test`). Pure — same input always yields the same split, so a gold
 *  set's holdout is stable across runs (a shuffled split would let a lucky
 *  seed flatter the gate). */
export declare function splitGold<TInput, TLabel>(scenarios: GoldScenario<TInput, TLabel>[], options?: SplitGoldOptions): GoldSplit<TInput, TLabel>;
//# sourceMappingURL=gold-scenarios.d.ts.map