/**
 * Medição de memória e compressão de contexto.
 *
 * Existe por causa de duas ideias que ficaram paradas no handoff com a mesma
 * condição: **medir antes de trocar**.
 *
 *   1. Índice de memória em SQLite FTS5. O Izanagi busca por varredura textual
 *      sobre arquivos markdown. Trocar isso por FTS5 acrescenta uma dependência
 *      nativa a um framework que hoje tem uma dependência de runtime. Só se
 *      paga se a busca atual for de fato o gargalo.
 *   2. Compressão neural de contexto (LLMLingua-2). O `ContextResolver` já
 *      comprime de forma determinística e auditável. Só se paga se essa
 *      compressão for insuficiente.
 *
 * Este módulo não decide nada: ele produz os números que permitem decidir. E é
 * honesto sobre o que mede — latência local sobre um corpus sintético, não
 * qualidade de recuperação semântica, que exigiria um conjunto anotado.
 */
import type { MemoryStore } from '../memory/store.js';
import type { TaskContract } from '../contracts/task-contract.js';
export interface SearchMeasurement {
    queries: number;
    /** Entradas de memória varridas por consulta. */
    entriesScanned: number;
    /** Chars totais varridos por consulta (o que uma indexação evitaria). */
    charsScanned: number;
    /**
     * Chars que a busca ALCANÇA de fato. Se for menor que `charsScanned`, existe
     * memória invisível para a busca — e aí o problema é recall, não latência.
     */
    charsReachable: number;
    p50Ms: number;
    p95Ms: number;
    maxMs: number;
    /** Consultas que devolveram ao menos um resultado. */
    hits: number;
    /**
     * Veredito determinístico sobre o gargalo, com o limiar explícito. Não é
     * opinião: é a regra escrita uma vez, aplicada ao número medido.
     */
    verdict: string;
}
/** Acima disto, a busca linear começa a pesar num loop de planejamento. */
export declare const SEARCH_P95_BUDGET_MS = 25;
/**
 * Mede a busca textual da memória. `queries` deve conter termos que existem no
 * corpus e termos que não existem: medir só acerto esconde o custo do caminho
 * em que a varredura vai até o fim sem achar nada — que é o caso comum.
 */
export declare function measureMemorySearch(memory: MemoryStore, queries: string[]): SearchMeasurement;
export interface CompressionMeasurement {
    artifacts: number;
    /** Chars que seriam enviados sem o Context Resolver. */
    fullChars: number;
    /** Chars efetivamente enviados. */
    sentChars: number;
    /** `sentChars / fullChars` em [0,1]. Menor é mais compressão. */
    ratio: number;
    /** Quantos artefatos couberam inteiros (sem corte). */
    intact: number;
    verdict: string;
}
/**
 * Razão de compressão abaixo da qual a compressão determinística já resolve.
 * Acima disso, o contexto está passando quase inteiro e um compressor
 * semântico teria o que fazer.
 */
export declare const COMPRESSION_TARGET_RATIO = 0.35;
/**
 * Mede a compressão determinística do `ContextResolver` sobre um conjunto de
 * artefatos. O que NÃO mede: se o que sobrou é o que importava. Isso é uma
 * pergunta de qualidade, não de tamanho, e exigiria gabarito anotado — a
 * ausência dessa medida é justamente por que a decisão sobre compressão neural
 * continua em aberto.
 */
export declare function measureContextCompression(contract: TaskContract, artifacts: Array<{
    nodeId: string;
    content: string;
}>): CompressionMeasurement;
/**
 * Corpus sintético de memória, para medir busca num projeto que ainda não
 * acumulou histórico. Medir sobre memória vazia produz "0.07ms" e uma
 * conclusão sem valor — o que se quer saber é como a busca se comporta no
 * volume em que ela passaria a doer.
 *
 * Grava os arquivos markdown que o `MemoryStore` lê, no layout real
 * (`.agents/memoria/*.md`), para que a medição exercite o mesmo caminho de
 * código da busca de verdade.
 */
export declare function writeSyntheticMemory(baseDir: string, opts: {
    entriesPerFile: number;
    charsPerEntry: number;
}): number;
/** Corpus sintético reprodutível para a medição de compressão. */
export declare function syntheticArtifacts(count: number, charsEach: number): Array<{
    nodeId: string;
    content: string;
}>;
/** Verifica que o resumo preserva começo e fim, que é a promessa do resolver. */
export declare function summaryKeepsEnds(content: string, maxChars: number): boolean;
//# sourceMappingURL=memory-benchmark.d.ts.map