/**
 * Benchmark Runner — executa casos de benchmark e gera relatório comparável.
 *
 * Cada caso valida artefatos esperados + métricas de avaliação. O relatório
 * (BenchmarkReport) é salvo em .izanagi/state/benchmarks/ para comparação
 * entre versões (regression benchmarking).
 */
import type { BenchmarkCase, BenchmarkReport, BenchmarkResult } from '../types.js';
import { EvaluationEngine } from '../evaluation/engine.js';
import { type ExecutionEvidence } from './arena.js';
/**
 * Onde vivem os relatórios de benchmark, para uma raiz de ESTADO.
 *
 * Existe para que a escrita e a mensagem que a anuncia saiam do MESMO cálculo.
 * Antes eram dois: `path.join(...)` aqui e um literal `.izanagi/state/...` na
 * CLI. Num projeto inicializado a raiz de estado é `<projeto>/.agents`, então o
 * literal apontava para um diretório relativo ao `cwd` que podia existir e
 * guardar relatórios antigos.
 */
export declare function benchmarkReportsDir(stateDir: string): string;
export interface BenchmarkRunOptions {
    baseDir: string;
    suite?: string;
    /**
     * Executa os validators de cada caso (default: o do construtor, `true`).
     *
     * Antes este campo era lido por ninguém: os validators rodavam sempre, e
     * tanto o parametro do construtor quanto este eram decoracao. Desligar agora
     * desliga, e o resultado registra que rodou sem validators, porque um score
     * medido sobre menos critérios não é comparável a um medido sobre todos.
     */
    runValidators?: boolean;
    /**
     * Checagens que ESTE caminho de medição não consegue medir.
     *
     * Existe por causa do modo output: o producer daquele modo deriva o output do
     * próprio caso, então perguntar "o artefato esperado apareceu?" é circular, e
     * a resposta saía sempre "não apareceu nenhum". O comando reportava
     * `0/11 passaram` desde sempre, em toda versão, e o número dizia respeito à
     * forma do producer, não ao framework.
     *
     * Checagem declarada aqui sai da nota e aparece em `BenchmarkResult.unmeasured`.
     */
    unmeasured?: Array<'expectedArtifacts' | 'validators'>;
}
export declare class BenchmarkRunner {
    private readonly evaluator;
    private readonly runValidators;
    /**
     * @param evaluator Preservado por compatibilidade de assinatura. A nota de um
     *   caso é determinística (artefatos esperados + validators) e não passa pela
     *   `EvaluationEngine`: quem usa a engine é `izanagi eval`.
     * @param runValidators Default de `BenchmarkRunOptions.runValidators`.
     */
    constructor(evaluator?: EvaluationEngine, runValidators?: boolean);
    /**
     * Executa um único caso contra um output produzido.
     * O output pode ser: diretório (verifica arquivos), string, ou objeto.
     */
    runCase(c: BenchmarkCase, output: unknown, opts?: {
        durationMs?: number;
        tokensUsed?: number;
        execution?: ExecutionEvidence;
        /** Teto aplicado pela execução real deste caso. */
        budgetApplied?: {
            maxTokens?: number;
            maxCostUsd?: number;
        };
        /** Sobrepõe o default do runner para este caso. */
        runValidators?: boolean;
        /**
         * Diretório onde a execução real gravou. Presente, a checagem de
         * artefato é feita contra os ARQUIVOS que existem ali, e não contra as
         * chaves do objeto de output: um run é medido pelo que escreveu.
         */
        filesRoot?: string;
        /** Checagens que este caminho não mede (ver `BenchmarkRunOptions`). */
        unmeasured?: Array<'expectedArtifacts' | 'validators'>;
    }): BenchmarkResult;
    /**
     * Executa uma suíte (todos os casos de um domínio ou todos) e gera o
     * relatório completo. `producer(case)` deve retornar o output real do caso.
     */
    runSuite(cases: BenchmarkCase[], producer: (c: BenchmarkCase) => Promise<unknown> | unknown, opts: BenchmarkRunOptions): Promise<BenchmarkReport>;
    /**
     * Baselines — roda a MESMA suíte contra N producers nomeados (ex.: "izanagi"
     * vs "direct-model" vs outro agente) e devolve um relatório completo por
     * producer. Diferente de `compare()` (2 versões do MESMO producer ao longo
     * do tempo), isso responde "o Izanagi realmente melhora o resultado frente
     * à alternativa?" — a pergunta central da Arena (seção 9.2 do roadmap).
     */
    runBaselines(cases: BenchmarkCase[], producers: Record<string, (c: BenchmarkCase) => Promise<unknown> | unknown>, opts: BenchmarkRunOptions): Promise<Record<string, BenchmarkReport>>;
    /** Compara N baselines lado a lado por caso e por resumo — sem inventar "vencedor" quando os scores empatam. */
    compareBaselines(reports: Record<string, BenchmarkReport>): {
        baselines: string[];
        byCase: Array<{
            caseId: string;
            scores: Record<string, number>;
            winner: string | null;
        }>;
        ranking: Array<{
            baseline: string;
            avgScore: number;
            passed: number;
            total: number;
        }>;
    };
    /** Compara duas versões de relatório (regression benchmarking). */
    compare(prev: BenchmarkReport, curr: BenchmarkReport): Record<string, unknown>;
}
/** Lista os relatórios de benchmark já salvos em .izanagi/state/benchmarks/ (mais recente primeiro). */
export declare function listBenchmarkReports(baseDir: string): BenchmarkReport[];
//# sourceMappingURL=runner.d.ts.map