/**
 * Decision Journal — registro estruturado das decisões do runtime, para
 * responder "por que o Izanagi escolheu isso?" sem depender de reconstruir
 * chain-of-thought. Cada decisão guarda a opção escolhida, as alternativas
 * REALMENTE consideradas (com score), a razão e a confiança — não apenas
 * o resultado final.
 *
 * Complementa memory/store.ts (que guarda `learnings` textuais livres) e
 * observability/tracer.ts (que guarda spans do tipo 'decision' como log de
 * execução) com um índice pesquisável e estruturado, específico para
 * decisões de roteamento/seleção.
 */
export interface DecisionAlternative {
    option: string;
    score?: number;
    reason?: string;
}
/**
 * O que aconteceu com o run que esta decisão ajudou a produzir.
 *
 * Carimbado no FIM do run, sobre as decisões já gravadas. Sem isto o journal
 * registra escolhas e nunca as consequências delas, e uma escolha sem
 * consequência conhecida não ensina nada: é log, não memória.
 */
export interface DecisionOutcome {
    /** Veredito do run (`PASS`, `FAIL`, `HUMAN_REQUIRED`...). */
    status: string;
    score: number;
    /** Tarefas com verificação `VERIFIED` sobre o total verificado, quando houve. */
    verified?: {
        passed: number;
        total: number;
    };
    recordedAt: string;
}
export interface Decision {
    id: string;
    /** Tipo da decisão — ex.: 'model-routing', 'agent-routing', 'skill-routing'. */
    kind: string;
    chosen: string;
    alternatives: DecisionAlternative[];
    reason: string;
    /** Confiança na decisão [0,1] — quanto a escolhida se destacou das alternativas. */
    confidence: number;
    runId?: string;
    agent?: string;
    relatedArtifacts?: string[];
    createdAt: string;
    /**
     * Objetivo do run, para recuperação SELETIVA por semelhança.
     *
     * Sem ele o journal só é pesquisável por tipo, escolha e razão — nenhum dos
     * três diz para QUE problema a escolha foi feita, que é a única pergunta que
     * torna uma decisão passada relevante para uma decisão presente.
     */
    objective?: string;
    /** Resultado do run. Ausente enquanto o run não terminou. */
    outcome?: DecisionOutcome;
}
export declare class DecisionJournal {
    private readonly file;
    private decisions;
    constructor(opts: {
        baseDir: string;
    });
    private load;
    save(): void;
    /**
     * Registra uma decisão. `confidence`, quando omitida, é derivada da
     * distância entre a opção escolhida e a melhor alternativa concorrente
     * (decisão "óbvia" → confiança alta; decisão apertada → confiança baixa).
     */
    record(input: Omit<Decision, 'id' | 'createdAt' | 'confidence'> & {
        confidence?: number;
    }): Decision;
    list(limit?: number): Decision[];
    forRun(runId: string): Decision[];
    /** Busca textual simples por tipo, escolhida ou razão. */
    search(query: string): Decision[];
    /**
     * Carimba o resultado do run nas decisões que ele produziu.
     *
     * Chamado uma vez, no fim. Decisão gravada em run anterior não é tocada, e
     * decisão que já tem resultado não é reescrita: o journal registra o que
     * aconteceu, não o que se pensa agora sobre o que aconteceu.
     */
    recordOutcome(runId: string, outcome: Omit<DecisionOutcome, 'recordedAt'>): number;
    /**
     * Decisões de runs ANTERIORES sobre objetivos semelhantes, e só as que já
     * têm resultado conhecido.
     *
     * Recuperação seletiva, no mesmo espírito de `findRelevantFailures`: nunca o
     * journal inteiro, nunca injetado no contexto de um modelo. O que volta daqui
     * alimenta uma decisão DETERMINÍSTICA do Commander, e é por isso que a
     * relevância pode ser léxica: o consumidor não é um modelo interpretando
     * texto, é um filtro comparando nomes de agente.
     *
     * Decisão sem resultado fica de fora porque não ensina nada: saber que uma
     * escolha foi feita, sem saber no que deu, é o log que o journal já era.
     */
    findRelevant(objective: string, opts?: {
        kind?: string;
        limit?: number;
        excludeRunId?: string;
    }): Array<Decision & {
        relevance: number;
    }>;
}
//# sourceMappingURL=decisions.d.ts.map