/**
 * Izanagi Arena: as métricas que só uma execução REAL produz.
 *
 * A suíte de benchmark responde "o artefato esperado apareceu?". Isso é uma
 * medida de output. A Arena descrita na arquitetura pede mais: quanto do que
 * foi entregue está **comprovado**, quantas falhas o runtime **curou sozinho**,
 * quantas retentativas custou, e quanto se pagou por isso.
 *
 * Nada aqui é estimado. Toda métrica sai de um `OrchestrationResult` de um run
 * que aconteceu — se o run não aconteceu, o campo simplesmente não existe, e o
 * relatório diz que não existe. O Token Benchmark (`token-benchmark.ts`) mede
 * PLANO, e continua sendo outra coisa; misturar os dois números seria vender
 * teto de orçamento como consumo real.
 */
/**
 * Fundamentação dos artefatos de um run: dos caminhos que eles citaram, quantos
 * existem no projeto.
 *
 * É a única métrica da Arena que fala sobre o CONTEÚDO, e não sobre a mecânica
 * do runtime. Verificação alta com fundamentação baixa é um run que cumpriu
 * todos os critérios de schema descrevendo um projeto que não existe — e essa
 * combinação é invisível em qualquer das outras métricas.
 *
 * `rate` é `null` quando nenhum artefato citou caminho nenhum. Ausência de
 * referência não é fundamentação zero: é ausência de medida, e a Arena não
 * imprime `0%` para dizer "não sei".
 */
export interface GroundednessEvidence {
    /** Caminhos citados e conferidos. */
    references: number;
    /** Caminhos cujo lugar existe no projeto. */
    grounded: number;
    rate: number | null;
    /** Artefatos que citaram pelo menos um caminho. */
    artifactsWithReferences: number;
}
/** Evidência de UMA execução real, extraída do resultado do Orchestrator. */
export interface ExecutionEvidence {
    /** Veredito final do run. */
    status: string;
    /**
     * Run sem provider configurado: o grafo, a verificação e o healing rodaram de
     * verdade, o CONTEÚDO dos artefatos foi simulado.
     *
     * Está aqui porque muda o que o relatório pode afirmar. Verificação e
     * recuperação continuam medindo o runtime; qualquer medida sobre conteúdo
     * (artefato esperado, fundamentação) mede o simulador. Sem este campo, um
     * relatório headless e um relatório com provider real ficam indistinguíveis
     * depois de salvos.
     */
    headless?: boolean;
    /** Modo escolhido pelo Commander (ausente no caminho legado). */
    mode?: string;
    /** Tarefas com veredito de verificação. */
    verifiedTasks: number;
    totalVerifiedTasks: number;
    /** Fração de tarefas `VERIFIED` em [0,1]. `null` quando não houve verificação. */
    verificationRate: number | null;
    /** Falhas que o healing conseguiu curar / falhas totais. `null` sem falha. */
    recoveryRate: number | null;
    failures: number;
    recovered: number;
    /** Retentativas somadas sobre todos os nós (attempts além da primeira). */
    retries: number;
    healingActions: number;
    tokensUsed: number;
    costUsd: number;
    durationMs: number;
    /**
     * Chamadas de modelo: uma por TENTATIVA de nó que chama modelo.
     *
     * Contada por tentativa e não por nó porque é isso que a fatura conta: um nó
     * que precisou de três tentativas custou três chamadas. Nó de tool não entra
     * (não chama modelo) e nó reaproveitado também não (a chamada foi evitada,
     * que é exatamente o que a comparação precisa enxergar).
     */
    modelCalls: number;
    /** Agentes DISTINTOS acionados. Um agente reusado em cinco nós conta uma vez. */
    agentCalls: number;
    /**
     * Fração de nós do grafo que terminaram `succeeded`, sobre os que foram
     * executados. `skipped` fica de fora: early stopping e corte por orçamento
     * são decisões do runtime, não sucessos nem falhas.
     */
    successRate: number | null;
    /** Fundamentação dos artefatos. Ausente quando não havia projeto para conferir. */
    groundedness?: GroundednessEvidence;
}
/** Superfície mínima do resultado do Orchestrator consumida aqui. */
export interface RunLikeResult {
    status: string;
    mode?: string;
    /** Agentes distintos acionados, do Token Economy Engine. */
    agentsUsed?: number;
    /** true quando nenhum provider estava configurado (artefatos simulados). */
    headless?: boolean;
    healing: Array<{
        kind: string;
        nodeId?: string;
    }>;
    graph?: {
        nodes: Array<{
            id: string;
            status?: string;
            attempts?: number;
            kind?: string;
            metadata?: Record<string, unknown>;
        }>;
    };
    verification?: Array<{
        nodeId: string;
        result: {
            status: string;
        };
    }>;
    telemetry?: {
        estimatedCostUsd?: number;
        agentsUsed?: number;
    };
    trace: {
        durationMs: number;
        tokens?: {
            total: number;
        };
    };
    /** Artefatos produzidos, por id de tarefa. Necessário para medir fundamentação. */
    artifacts?: Record<string, {
        kind: string;
        content: unknown;
    }>;
}
/**
 * Converte o resultado de um run em evidência comparável.
 *
 * `recovered` conta o nó que FALHOU em algum momento e terminou `succeeded`:
 * é a definição operacional de "o runtime se curou". Contar ações de healing
 * como sucesso seria contar a tentativa, não o conserto.
 */
export declare function evidenceFromRun(result: RunLikeResult, workspaceDir?: string): ExecutionEvidence;
/**
 * Soma a fundamentação de todos os artefatos do run.
 *
 * Conta REFERÊNCIAS, não artefatos: um plano que cita vinte caminhos e uma ADR
 * que cita um não podem pesar igual. Artefato que não cita caminho nenhum
 * simplesmente não entra na conta — não é fundamentação zero, é ausência de
 * medida.
 */
export declare function measureGroundedness(artifacts: Record<string, {
    kind: string;
    content: unknown;
}>, workspaceDir: string): GroundednessEvidence;
export interface ExecutionSummary {
    /** Casos que trouxeram evidência de execução (os demais só têm output). */
    cases: number;
    verificationRate: number | null;
    recoveryRate: number | null;
    retries: number;
    healingActions: number;
    tokensUsed: number;
    costUsd: number;
    durationMs: number;
    /**
     * Chamadas de modelo: uma por TENTATIVA de nó que chama modelo.
     *
     * Contada por tentativa e não por nó porque é isso que a fatura conta: um nó
     * que precisou de três tentativas custou três chamadas. Nó de tool não entra
     * (não chama modelo) e nó reaproveitado também não (a chamada foi evitada,
     * que é exatamente o que a comparação precisa enxergar).
     */
    modelCalls: number;
    /** Agentes DISTINTOS acionados. Um agente reusado em cinco nós conta uma vez. */
    agentCalls: number;
    /**
     * Fração de nós do grafo que terminaram `succeeded`, sobre os que foram
     * executados. `skipped` fica de fora: early stopping e corte por orçamento
     * são decisões do runtime, não sucessos nem falhas.
     */
    successRate: number | null;
    /** Fundamentação somada. `null` quando nenhum artefato citou caminho. */
    groundedness: GroundednessEvidence | null;
}
/**
 * Agrega evidência de vários casos. Taxas são calculadas sobre os TOTAIS, não
 * como média de médias: um caso com 9 tarefas e um com 1 não podem pesar igual
 * numa taxa de verificação.
 */
export declare function aggregateExecution(evidence: ExecutionEvidence[]): ExecutionSummary | null;
/** Linha de terminal com as métricas da Arena, ou a razão de não haver nenhuma. */
export declare function formatExecutionSummary(summary: ExecutionSummary | null): string;
//# sourceMappingURL=arena.d.ts.map