/**
 * Entrega: o run grava o que produziu, e a verificação depende da gravação.
 *
 * Até aqui um `izanagi run` terminava com os artefatos em
 * `.izanagi/state/artifacts/<runId>/` — visíveis por `izanagi explain
 * --artifacts`, invisíveis para o projeto. O trabalho existia e não era
 * entregue.
 *
 * O nó de entrega fecha isso e, de quebra, é o primeiro nó `kind: 'tool'`
 * gerado pelo PLANEJAMENTO em produção. Isso importa por um motivo de
 * verificação, não de conveniência: um critério `file-exists` sobre um arquivo
 * que ninguém escreveu é teatro — passa quando o arquivo já existia por outro
 * motivo, e falha sem dizer nada sobre o trabalho. Aqui o arquivo é escrito
 * pela `ToolRegistry`, com permissão declarada no contrato e política aplicada
 * antes, e o mesmo caminho é conferido depois. O critério passa a significar
 * "o runtime gravou isto", que é evidência.
 *
 * Menor privilégio: o contrato do nó concede `fs:write` e nada mais. Nenhum
 * outro nó do grafo recebe permissão nenhuma, então nenhum outro nó escreve.
 */
import type { GraphNode } from '../types.js';
import type { TaskContract } from '../contracts/task-contract.js';
/** Teto por artefato no documento entregue, com o corte declarado no próprio texto. */
export declare const MAX_SECTION_CHARS: number;
/**
 * Teto do documento inteiro.
 *
 * O teto por seção sozinho não limita nada: um run de nove nós podia produzir
 * um documento de mais de um megabyte, e ninguém abre isso. Quando o total
 * estoura, as seções seguintes entram como REFERÊNCIA em vez de conteúdo — o
 * leitor continua sabendo que o artefato existe e onde encontrá-lo inteiro.
 */
export declare const MAX_DOCUMENT_CHARS: number;
/** Id do nó de entrega. Fixo: `izanagi explain` e os testes referenciam por nome. */
export declare const DELIVER_NODE_ID = "deliver";
/** Id do nó de materialização. */
export declare const MATERIALIZE_NODE_ID = "materialize";
/**
 * Contrato de materialização levado ao PROMPT do agente.
 *
 * O Blueprint Engine já dizia isto — declare a árvore, escreva cada arquivo
 * completo, zero stub — mas só em `--prompt-only`, num texto para a pessoa
 * colar em outra ferramenta. Dentro do runtime o contrato não existia, e o
 * parser só reconhece o que foi combinado: pedir o formato é o que torna a
 * materialização determinística em vez de adivinhação sobre a saída.
 */
export declare const MATERIALIZATION_CONSTRAINT: string;
export interface DeliverableArtifact {
    nodeId: string;
    kind: string;
    content: unknown;
    valid: boolean;
}
export interface DeliverableInput {
    objective: string;
    runId: string;
    mode: string;
    /** Ordem do grafo. Artefato fora dela entra no fim, na ordem em que apareceu. */
    order?: string[];
    artifacts: DeliverableArtifact[];
}
/**
 * Monta o documento único do run. Determinístico: mesma entrada, mesmo texto
 * (nenhum timestamp, nenhuma ordenação por acaso de Map).
 *
 * Artefato inválido NÃO é omitido: entra marcado. Sumir com o que não passou
 * na validação deixaria a entrega mais bonita do que o run foi.
 */
export declare function buildDeliverable(input: DeliverableInput): string;
/**
 * Caminho do arquivo entregue, RELATIVO à raiz do projeto.
 *
 * Relativo de propósito: é o mesmo valor que a `ToolRegistry` resolve contra a
 * sandbox e que o check `file-exists` resolve contra a raiz. Um caminho
 * absoluto aqui faria os dois divergirem quando o processo roda com outro cwd.
 *
 * O nome sai do OBJETIVO, não do runId. O runId só existe depois que o
 * Orchestrator abre o trace, e o caminho precisa estar no contrato antes disso
 * — senão o critério `file-exists` não teria o que conferir. Como efeito
 * colateral desejado, repetir o mesmo objetivo reescreve a mesma entrega em
 * vez de acumular um arquivo por execução: entrega é produto, não log. O
 * histórico continua em `.izanagi/state/`, e o runId vai no cabeçalho do
 * documento.
 */
export declare function deliverableRelPath(outputDir: string, objective: string): string;
/**
 * Slug do objetivo. Só ASCII: acento e caractere não-latino viram problema de
 * portabilidade de nome de arquivo entre sistemas, e o objetivo completo já
 * está no título do documento.
 */
export declare function slugify(objective: string): string;
/**
 * Valida o destino ANTES de planejar. Fora da raiz do projeto o `fs.write` já
 * recusaria e o `file-exists` já reprovaria — mas descobrir isso depois de um
 * grafo inteiro executado desperdiça o run por um erro de digitação.
 */
export declare function validateOutputDir(baseDir: string, outputDir: string): {
    ok: true;
    rel: string;
} | {
    ok: false;
    error: string;
};
/**
 * Nó de materialização + contrato.
 *
 * Escreve os arquivos declarados pelos agentes num subdiretório da saída — e
 * NUNCA por cima do código do projeto. Essa é a fronteira que torna a
 * materialização defensável: o que o runtime produz fica num lugar que o
 * usuário nomeou e pode revisar, apagar ou copiar. Sobrescrever fonte exigiria
 * uma garantia que nenhuma verificação determinística consegue dar hoje.
 */
export declare function materializeNode(opts: {
    outputDir: string;
    objective: string;
    dependencies: string[];
    /** Nó cujo artefato carrega o manifesto (normalmente o de implementação). */
    manifestFrom: string;
}): {
    node: GraphNode;
    contract: TaskContract;
};
/** Diretório onde os arquivos materializados de um objetivo vão parar. */
export declare function materializeRelDir(outputDir: string, objective: string): string;
/**
 * Nó de entrega + contrato. Sem agente de propósito: quem declarou a tool foi o
 * planejamento do próprio framework, então o trust tier é `builtin` e não o
 * `community` que um nó com agente desconhecido receberia.
 */
export declare function deliverNode(opts: {
    outputDir: string;
    objective: string;
    /** Ids dos nós que precisam concluir antes da entrega (tudo que produz artefato). */
    dependencies: string[];
}): {
    node: GraphNode;
    contract: TaskContract;
};
//# sourceMappingURL=delivery.d.ts.map