/**
 * Context Resolver: monta o contexto MÍNIMO de uma tarefa.
 *
 * Regra da arquitetura: nunca enviar todo o histórico para todos os agentes.
 * O nó recebe o objetivo, as restrições, e os artefatos dos quais ele
 * realmente depende, resumidos e referenciados por id, e não o transcript
 * inteiro do run.
 *
 * Isto corrige também uma lacuna real do runtime anterior: os nós NÃO recebiam
 * as saídas dos predecessores. O nó `implementation` do template fullstack
 * dependia de `architecture`, `database-design` e `security-review`, mas o
 * prompt compilado só continha a tarefa original. Resultado: o grafo tinha
 * dependências topológicas sem transferência de informação.
 */
import type { TaskContract } from '../contracts/task-contract.js';
/** Um artefato disponível no run corrente. */
export interface AvailableArtifact {
    nodeId: string;
    kind: string;
    content: unknown;
    valid: boolean;
    /** Id do registro no ArtifactRegistry (`runId:nodeId`), quando registrado. */
    ref?: string;
}
export interface UpstreamContext {
    nodeId: string;
    kind: string;
    ref?: string;
    /** Resumo determinístico do conteúdo, dentro do orçamento de chars. */
    summary: string;
    /** true quando o conteúdo foi cortado (o resto fica acessível pela referência). */
    truncated: boolean;
    valid: boolean;
}
export interface ResolvedContext {
    objective: string;
    constraints: string[];
    expectedOutput: TaskContract['expectedOutput'];
    acceptance: string[];
    upstream: UpstreamContext[];
    /** Chars efetivamente gastos com upstream (telemetria de economia). */
    upstreamChars: number;
    /** Chars que teriam sido gastos enviando os artefatos inteiros. */
    upstreamCharsFull: number;
    /**
     * Correções vindas de uma crítica bloqueante. Quando presente, este contexto
     * é uma RETENTATIVA dirigida: o nó recebe o que precisa consertar e a própria
     * entrega anterior, não os insumos do grafo outra vez.
     */
    correction?: string;
    /** A tarefa pode pedir decomposição em vez de entregar (ver `subgraph.ts`). */
    decomposable?: boolean;
    /**
     * Conhecimento do projeto relevante a ESTA tarefa, vindo da memória
     * semântica/episódica (`MemoryStore.search`).
     *
     * A busca da memória existia e, dentro de um run, ninguém a chamava: só a
     * CLI e o benchmark. A única recuperação durante a execução era padrão de
     * falha. Aqui ela entra por tarefa e com teto próprio — o oposto de injetar
     * a memória inteira, que é o que a arquitetura proíbe.
     */
    knowledge?: Array<{
        title: string;
        excerpt: string;
    }>;
}
export interface ResolveContextOptions {
    /** Correção estruturada (saída de `formatCorrection`) a aplicar nesta rodada. */
    correction?: string;
    /** Habilita o protocolo de decomposição no prompt desta tarefa. */
    decomposable?: boolean;
}
export interface ResolveOptions {
    /** Teto de chars por artefato upstream. */
    maxCharsPerArtifact?: number;
    /** Teto total de chars de upstream no contexto. */
    maxTotalChars?: number;
    /**
     * Busca na memória do projeto, injetada por quem monta o runtime
     * (`MemoryStore.search`). Ausente: o contexto é o de sempre.
     *
     * Recebe a consulta e o limite; devolve título e trecho. O Resolver não
     * conhece o `MemoryStore` de propósito — a interface estreita é o que
     * permite um teste passar uma função literal, e o que impede este módulo de
     * virar dependente do formato de armazenamento da memória.
     */
    knowledge?: (query: string, limit: number) => Array<{
        title: string;
        content: string;
    }>;
    /** Teto de chars do bloco de conhecimento. */
    maxKnowledgeChars?: number;
}
/**
 * Corta preservando o começo e o fim: o começo carrega a estrutura (títulos,
 * decisões) e o fim costuma carregar a conclusão. Cortar só o começo perderia
 * o veredito; cortar só o fim perderia o enquadramento.
 */
export declare function summarizeArtifact(content: unknown, maxChars: number): {
    summary: string;
    truncated: boolean;
    fullLength: number;
};
export declare class ContextResolver {
    private readonly opts;
    constructor(opts?: ResolveOptions);
    /**
     * Contexto de um contrato: só os artefatos declarados em `inputs`
     * (ou `dependencies`), nessa ordem, dentro do orçamento de chars.
     */
    resolve(contract: TaskContract, available: Map<string, AvailableArtifact>, opts?: ResolveContextOptions): ResolvedContext;
    /**
     * Conhecimento relevante à tarefa, dentro do teto.
     *
     * Nunca lança: memória ilegível não pode derrubar a execução de um nó. Sem
     * busca injetada, devolve vazio e o contexto é exatamente o de antes.
     */
    private lookupKnowledge;
    /** Renderiza o contexto resolvido como bloco de prompt (parte volátil). */
    render(ctx: ResolvedContext): string;
}
//# sourceMappingURL=context-resolver.d.ts.map