/**
 * Token Budget 2.0 — orçamento por fase.
 *
 * planning / execution / evaluation / recovery. Impossibilita que uma tarefa
 * simples consuma recursos excessivos: cada fase tem um teto alocado do total,
 * e estourar uma fase aborta a execução (nunca loops infinitos).
 *
 * Pesos default (clássico 60/20/10/10) reproduzem o comportamento anterior de
 * maxTokens global com a adição de tetos por fase.
 */
import type { ModelTier } from '../types.js';
export type PhaseId = 'planning' | 'execution' | 'evaluation' | 'recovery';
export declare const PHASES: PhaseId[];
export type PhaseAllocation = Record<PhaseId, number>;
export interface PhaseUsage {
    phase: PhaseId;
    allocated: number;
    spent: number;
    remaining: number;
    ratio: number;
    exhausted: boolean;
}
/**
 * Pesos default por complexidade da tarefa.
 *
 * `planning` recebe uma fatia simbólica de propósito: **nenhum caminho do
 * runtime cobra tokens dessa fase**. O Commander classifica, decide o modo,
 * gera contratos e estima custo de forma determinística, sem uma chamada de
 * modelo — é o que o README chama de "planejar não gasta um token". Só
 * `execution` (1ª tentativa), `recovery` (retentativa) e `evaluation` (juiz
 * semântico) chegam a `spend()`.
 *
 * Antes desta rodada `planning` levava de 5% a 15% do teto e devolvia zero
 * gasto em todo run (medido: 0/17.550 num run real), enquanto `recovery` ficava
 * com 10% e não comportava UMA retentativa: com o executor por CLI de agente um
 * nó custa ~20.000 tokens, e a fatia de recovery de um run de 117.000 dava
 * 11.700. O resultado era healing decorativo — o runtime decidia curar, tentava
 * e morria no orçamento antes de chamar o modelo.
 *
 * A fatia simbólica não é zero porque zero transformaria qualquer cobrança
 * futura nessa fase em falha imediata; é pequena porque hoje ela não é cobrada.
 */
export declare function defaultWeights(complexity: number): PhaseAllocation;
/**
 * Menor fatia que uma fase recebe em qualquer complexidade.
 *
 * Derivada dos próprios pesos, e não escrita à mão em outro arquivo: quem
 * dimensiona um teto precisa da MESMA fração que o alocador vai aplicar, e duas
 * cópias do número divergem na primeira vez que uma delas muda.
 */
export declare function minPhaseShare(phase: PhaseId): number;
/** Teto sugerido por tier de modelo (contexto pequeno não deve estourar). */
export declare function defaultBudgetForTier(tier: ModelTier): number;
export declare class PhaseTokenBudget {
    readonly total: number;
    readonly allocation: PhaseAllocation;
    private readonly spent;
    constructor(total: number, allocation?: PhaseAllocation);
    /** Restaura gasto persistido (ex.: retomando de um checkpoint) — clampado ao teto de cada fase. */
    restore(spent: Partial<Record<PhaseId, number>>): void;
    /** Gasta tokens da fase; false quando excede o teto da fase. */
    spend(phase: PhaseId, tokens: number): boolean;
    spentIn(phase: PhaseId): number;
    remaining(phase: PhaseId): number;
    /**
     * Registra gasto que JÁ ACONTECEU, mesmo estourando a alocação da fase.
     *
     * Diferente de `spend()`, que decide SE pode gastar e recusa antes. Este
     * método é para o outro caso: o modelo já respondeu, o provider já cobrou, e
     * a única pergunta que resta é se a conta bate. Recusar-se a registrar aqui
     * não desfaz a chamada — só faz a telemetria divergir da fatura, e uma
     * telemetria que subestima o gasto é pior que nenhuma.
     *
     * Devolve `true` quando o gasto coube na alocação da fase.
     */
    record(phase: PhaseId, tokens: number): boolean;
    exhausted(phase: PhaseId): boolean;
    /** Relatório por fase (formatável em trace/verbose). */
    usage(): PhaseUsage[];
    totalSpent(): number;
    /** Resumo compacto para logs/trace. */
    summary(): Record<PhaseId, {
        spent: number;
        remaining: number;
    }>;
}
//# sourceMappingURL=budget.d.ts.map