/**
 * Verification Engine 2.0: evidência, não declaração.
 *
 * A pergunta que este módulo responde não é "o agente disse que terminou?" e
 * sim "existe evidência de que terminou?". Três camadas:
 *
 *   determinística : checks executados sem modelo nenhum (schema do artefato,
 *                    tamanho, presença/ausência de termos, regex, campo JSON,
 *                    existência de arquivo).
 *   evidência      : artefatos declarados como prova existem e são válidos.
 *   semântica      : juiz externo (modelo ou humano). SEM juiz configurado, o
 *                    critério fica UNKNOWN e o veredito NUNCA vira VERIFIED
 *                    só porque nada falhou.
 *
 * Essa última regra é o ponto: a ausência de verificação semântica não pode
 * ser confundida com aprovação semântica.
 */
import type { AcceptanceCriterion, DeterministicCheck, TaskContract } from '../contracts/task-contract.js';
export type VerificationStatus = 'VERIFIED' | 'UNVERIFIED' | 'FAILED';
/**
 * Fração mínima de caminhos citados que precisam existir no projeto.
 *
 * Metade, e não mais: o artefato legítimo mistura o que existe com o que ele
 * propõe criar, e um piso alto reprovaria o trabalho junto com a alucinação.
 * Abaixo de metade não é mistura — é um layout que não é o deste projeto.
 */
export declare const DEFAULT_GROUNDEDNESS_RATIO = 0.5;
/**
 * Resultado de um critério.
 *
 * A distinção que importa é entre `unknown` e `not-applicable`, e ela não é
 * cosmética:
 *
 *   unknown        : havia uma pergunta a responder e a resposta não foi
 *                    obtida (juiz semântico ausente, `file-exists` sem raiz).
 *                    NUNCA vira aprovação — é a regra que impede "ninguém
 *                    reprovou, então passou".
 *   not-applicable : a pergunta não existe para este artefato. Groundedness
 *                    num texto que não cita caminho nenhum não está sem
 *                    resposta: está respondida por vacuidade, e não há como o
 *                    artefato estar errado sobre caminhos que ele não citou.
 *
 * Tratar o segundo caso como `unknown` fazia todo artefato de prosa cair em
 * UNVERIFIED por um critério que não tinha o que medir nele — e um critério
 * que reprova por não se aplicar é um critério que ninguém vai manter ligado.
 *
 * Só um check que consegue PROVAR a inaplicabilidade devolve `not-applicable`.
 * Na dúvida, `unknown`.
 */
export interface CheckResult {
    criterionId: string;
    description: string;
    layer: 'deterministic' | 'evidence' | 'semantic';
    outcome: 'pass' | 'fail' | 'unknown' | 'not-applicable';
    message?: string;
    optional: boolean;
}
export interface EvidenceItem {
    kind: 'artifact' | 'file' | 'test';
    ref: string;
    valid: boolean;
    detail?: string;
}
export interface VerificationResult {
    status: VerificationStatus;
    /** Fração de critérios obrigatórios aprovados em [0,1]. */
    score: number;
    checks: CheckResult[];
    evidence: EvidenceItem[];
    /** Descrições dos critérios obrigatórios NÃO aprovados. */
    unmet: string[];
    reason: string;
    /** Tokens gastos pelo juiz semântico nesta verificação (0 sem juiz). */
    judgeTokens: number;
    /** Modelo que julgou, quando houve julgamento. */
    judgeModel?: string;
}
/** Veredito de um juiz semântico sobre UM critério. */
export interface JudgeVerdict {
    pass: boolean;
    message?: string;
    /**
     * O juiz não conseguiu decidir (saída ilegível, erro de rede, timeout). Vira
     * `unknown`, nunca `fail`: um juiz que não respondeu não reprova ninguém, e
     * também não aprova. É a mesma regra da ausência de juiz.
     */
    inconclusive?: boolean;
    /** Custo do julgamento, para o Budget Controller cobrar a fase de avaliação. */
    tokens?: number;
    model?: string;
}
/**
 * Juiz semântico injetável: recebe o critério e o conteúdo, devolve veredito.
 * Pode ser síncrono (heurística, humano em memória) ou assíncrono (modelo).
 */
export type SemanticJudge = (input: {
    criterion: AcceptanceCriterion;
    content: string;
    objective: string;
}) => JudgeVerdict | Promise<JudgeVerdict>;
export interface VerifyInput {
    contract: TaskContract;
    /** Conteúdo produzido pelo nó. */
    content: unknown;
    /** Artefatos do run, por nodeId (para critérios de evidência). */
    artifacts?: Map<string, {
        kind: string;
        content: unknown;
        valid: boolean;
    }>;
    /** Raiz para resolver `file-exists`. Sem baseDir, o check fica UNKNOWN. */
    baseDir?: string;
    judge?: SemanticJudge;
}
/**
 * Executa um check determinístico. `unknown` só acontece quando falta um
 * insumo do ambiente (ex.: `file-exists` sem baseDir), nunca por ambiguidade
 * de interpretação.
 */
export declare function runCheck(check: DeterministicCheck, ctx: {
    content: unknown;
    text: string;
    kind: string;
    baseDir?: string;
}): {
    outcome: 'pass' | 'fail' | 'unknown' | 'not-applicable';
    message?: string;
};
export declare class VerificationEngine {
    /**
     * Verifica um artefato contra o contrato. Determinístico exceto pela camada
     * semântica, que só roda com juiz injetado.
     */
    verify(input: VerifyInput): Promise<VerificationResult>;
    /**
     * Só `VERIFIED` conta como COMPROVADO.
     *
     * `UNVERIFIED` significa "nada falhou e nem tudo foi comprovado", e o
     * orquestrador deixa o nó seguir como `succeeded` — derrubá-lo transformaria
     * "não medi" em "está errado", e sem juiz semântico isso derrubaria todo run
     * sem provider. O que `isDone` decide é se o nó carrega a marca
     * `metadata.unverified`: aprovado sem prova precisa ser distinguível de
     * comprovado por quem lê o grafo, o trace e a conversa A2A.
     */
    static isDone(result: VerificationResult): boolean;
}
//# sourceMappingURL=engine.d.ts.map