/**
 * Self-play scenario evolution — agents generate adversarial scenarios
 * against each other; survivors become part of the eval corpus.
 *
 * Framework-agnostic about how scenarios are generated. Caller supplies:
 *   - `propose`: asks a "proposer" agent for candidate scenarios
 *   - `scoreAgainst`: runs a target agent against a scenario and returns
 *     its score
 *
 * A scenario *survives* if it reveals a meaningful score difference
 * between two target agents (or between a target agent and itself on
 * different runs). Survivors are promoted to a Dataset; the caller
 * decides what to do with them (hold-out, training, regression set).
 *
 * Guard rails: minimum absolute score delta to consider a scenario
 * informative; floor on absolute target score so degenerate break-all
 * scenarios (noise, gibberish) don't flood the corpus.
 */
import { Dataset } from './dataset';
export interface CandidateScenario {
    id: string;
    payload: unknown;
    /** Free-form tags (domain, generation, parent). */
    tags?: Record<string, string>;
}
export interface ScoredTarget {
    targetId: string;
    score: number;
}
export interface EvolutionRound {
    round: number;
    proposed: CandidateScenario[];
    survived: CandidateScenario[];
    rejected: Array<{
        candidate: CandidateScenario;
        reason: string;
    }>;
    scoredBreakdown: Array<{
        candidate: CandidateScenario;
        scores: ScoredTarget[];
        spread: number;
    }>;
}
export interface SelfPlayOptions {
    /** Minimum score spread across targets for a scenario to survive. Default 0.1. */
    minSpread?: number;
    /** Minimum floor score across targets — keeps degenerate break-all scenarios
     *  out. Default 0.1 (if every target scores below this, discard). */
    minAbsoluteFloor?: number;
    /** Hard cap on survivors per round. Default 50. */
    maxSurvivors?: number;
    /** Rounds to run. Default 1. Each round's survivors can be fed back into
     *  `propose` to compound. */
    rounds?: number;
    /** Seed for scenario id generation if proposer doesn't provide one. */
    seed?: number;
}
export interface SelfPlayProposer {
    propose(round: number, priorSurvivors: CandidateScenario[]): Promise<CandidateScenario[]>;
}
export interface SelfPlayScorer {
    /** Score one candidate against every target; returns parallel array. */
    scoreCandidate(candidate: CandidateScenario, targets: string[]): Promise<ScoredTarget[]>;
}
export declare function runSelfPlay(proposer: SelfPlayProposer, scorer: SelfPlayScorer, targets: string[], options?: SelfPlayOptions): Promise<{
    rounds: EvolutionRound[];
    dataset: Dataset;
}>;
//# sourceMappingURL=self-play.d.ts.map