/**
 * Wiring compartilhado entre a CLI (`izanagi run`) e o SDK (`izanagi.run()`).
 *
 * Existe para que as duas superfícies executem EXATAMENTE o mesmo runtime:
 * mesmo Commander, mesmo roteamento por papel, mesmo cache, mesmo estimador de
 * custo. Antes de existir, a única forma de rodar o runtime era pela CLI, e
 * qualquer integração programática teria que reimplementar essa cola (e sair
 * do ar em silêncio a cada mudança do runtime).
 *
 * Nenhuma dependência da camada CLI: quem constrói o prompt de sistema passa
 * uma função. Assim este módulo continua sendo runtime puro.
 */
import { type CommanderPlan, type ReplanFailure, type ReplanResult } from './orchestration/commander.js';
import { AgentCapabilityRegistry } from './registry/capabilities.js';
import { ModelRouter } from './model/router.js';
import { ContextResolver } from './orchestration/context-resolver.js';
import { type AgentCLIToolPolicy } from './llm/agent-cli.js';
import { ResponseCache } from './cache/response-cache.js';
import type { SemanticJudge } from './verification/engine.js';
import type { TrustTier } from './security/policy.js';
import type { AgentRole, ExecutionMode } from './contracts/task-contract.js';
import type { ExecuteCtx } from './orchestrator.js';
import type { ExecutionGraph, GraphNode, ModelSpec, RoutingContext, RoutingHints } from './types.js';
/**
 * Providers que rodam na própria máquina (usados por `--local`).
 *
 * O CLI de agente (`claude-cli`) roda local como processo, mas fala com a API
 * do provider dele: não entra aqui, senão `--local` (que existe para quem quer
 * garantir que nada sai da máquina) passaria a mentir.
 */
export declare const LOCAL_PROVIDERS: string[];
export interface PlanningInput {
    objective: string;
    mode?: ExecutionMode;
    agent?: string;
    explicitAgent?: boolean;
    skillChain?: string[];
    maxTokens?: number;
    maxCostUsd?: number;
    /** Fixa o mesmo modelo em todos os papéis. */
    model?: string;
    /** Providers realmente utilizáveis (com chave/opt-in). */
    availableProviders: string[];
    /**
     * Política de tools do executor de processo (`--agent-tools`). Entra no
     * PLANEJAMENTO porque muda o custo medido de um nó em ~3,8x, e é esse custo
     * que define o piso de orçamento. Ausente, vale o ambiente.
     */
    agentTools?: AgentCLIToolPolicy;
    /** Pula o Commander e devolve `plan: undefined` (caminho legado por categoria). */
    noCommander?: boolean;
    /**
     * Desliga a consulta à memória e o ranking de skills por tarefa no
     * planejamento (volta ao Commander puramente léxico). Serve para depurar uma
     * decisão de plano sem o histórico interferindo.
     */
    noMemory?: boolean;
    /**
     * Diretório de entrega relativo à raiz do projeto (`--output`). Presente,
     * acrescenta ao plano o nó de tool que grava o resultado do run e verifica o
     * arquivo escrito. Ausente, nenhum nó recebe permissão de escrita.
     */
    output?: string;
    /** Levanta a forma do projeto num nó de tool na cabeça do grafo (`--survey`). */
    survey?: boolean;
    /**
     * Critérios de aceite do usuário, em texto (`--acceptance`, ou
     * `IzanagiRunOptions.acceptance`). Parseados por `parseAcceptance`: prefixo
     * conhecido vira check determinístico, prosa vira critério semântico.
     *
     * Entrada recusada não é descartada em silêncio: sai em
     * `PlanningOutput.acceptanceIssues`, para quem chamou poder dizer ao usuário
     * que o critério que ele escreveu não está sendo cobrado.
     */
    acceptance?: string[];
    /**
     * Roda o comando de teste do projeto no fim do grafo (`--verify-tests`).
     * Opt-in: executa um processo do projeto com o ambiente herdado.
     */
    verifyTests?: boolean;
    /**
     * Piso de força de verificação do plano em [0,1] (`--min-quality`).
     * Declarado, o Commander compara estratégias e escolhe a mais barata que o
     * atinge. Ausente, o plano é o de sempre.
     */
    minQuality?: number;
    /**
     * Raiz do estado (`.izanagi/state`) consultado no planejamento. Default:
     * `baseDir`. Ver `OrchestratorOptions.stateDir` para o porquê da separação.
     */
    stateDir?: string;
}
/**
 * Deriva o `RoutingContext` DESTA tarefa a partir do contexto do run.
 *
 * O contexto do run era montado uma vez em `buildExecutionPlan` e usado em
 * todos os nós: `reasoningRequirement: 'medium'`, `risk: 0.2`, `tokenBudget` do
 * run inteiro e nenhum `historicalPerformance`. O `scoreModel` do router lê
 * todos esses campos — então metade dos critérios do roteamento estava
 * implementada e nunca era alimentada, e dentro de um run o modelo escolhido
 * era função só do papel.
 *
 * O que muda por nó, e por quê:
 * - `tokenBudget`: o teto de SAÍDA da tarefa (o que o nó realmente pede de
 *   janela), limitado pelo saldo do run. Com o teto do run inteiro, todo modelo
 *   de janela menor perdia 0.15 de score em toda tarefa, inclusive nas curtas.
 * - `risk`: da prioridade do contrato. Risco alto reduz o peso do custo no
 *   score, que é a decisão certa onde errar sai mais caro que a chamada.
 * - `reasoningRequirement`: do papel. `worker` é a tarefa barata por definição
 *   e não deve exigir raciocínio alto; `commander` deve.
 * - `requiresTools`: nó de tool declara isso no contrato.
 * - `historicalPerformance`: o que a memória mediu, já pronto no store.
 */
export declare function contextForNode(runContext: RoutingContext, node?: GraphNode, hints?: RoutingHints): RoutingContext;
export interface PlanningOutput {
    plan?: CommanderPlan;
    router: ModelRouter;
    routingContext: RoutingContext;
    /** Modelos do catálogo por id, para converter tokens em custo real. */
    specById: Map<string, ModelSpec>;
    capabilities: AgentCapabilityRegistry;
    routeRole: (role: AgentRole, node?: GraphNode, hints?: RoutingHints) => {
        model: string;
        provider: string;
    } | undefined;
    costOf: (modelId: string, inputTokens: number, outputTokens: number) => number;
    /**
     * Replanejamento pelo Commander, pronto para o Orchestrator. Fecha sobre o
     * mesmo registro de capacidades usado no planejamento, então o Plano B
     * escolhe agente pelo mesmo critério do Plano A.
     */
    replan: (input: {
        graph: ExecutionGraph;
        failure: ReplanFailure;
    }) => ReplanResult | null;
    /** Trust tier por agente, derivado da origem do arquivo no disco. */
    trustTierOf: (agentId: string) => TrustTier | undefined;
    /**
     * Critérios de aceite do usuário que NÃO entraram no plano, com o motivo.
     * Ausente quando todos entraram.
     */
    acceptanceIssues?: string[];
}
/**
 * Monta o plano do Commander e o roteamento por papel a partir do catálogo
 * realmente disponível no ambiente.
 */
export declare function buildExecutionPlan(baseDir: string, input: PlanningInput): PlanningOutput;
/** Superfície mínima do cliente LLM consumida pelo producer. */
export interface ProducerLLMClient {
    complete(provider: string, opts: {
        model: string;
        system?: string;
        messages: Array<{
            role: 'system' | 'user' | 'assistant';
            content: string;
        }>;
        maxTokens?: number;
        /** Cancelamento do run: o cliente combina com o próprio timeout HTTP. */
        signal?: AbortSignal;
        /**
         * Teto de custo desta chamada em USD (o que ainda cabe no run). Providers
         * que sabem recusar por conta própria usam; os demais ignoram.
         */
        maxCostUsd?: number;
        /** Política de tools do executor de processo (CLI de agente). */
        toolPolicy?: 'none' | 'read' | 'write';
    }): Promise<{
        text: string;
        tokens: number;
        model: string;
        provider: string;
        cachedTokens?: number;
        costUsd?: number;
    }>;
}
export interface ProducerOptions {
    objective: string;
    client: ProducerLLMClient;
    cache: ResponseCache;
    contextResolver: ContextResolver;
    /** Compila o system prompt do nó (a CLI usa o compilador de skills/regras). */
    buildSystemPrompt: (node: GraphNode, ctx: ExecuteCtx, minimalContext?: string) => string;
    /** Observador por nó: telemetria, log verboso, progresso. */
    onNode?: (info: {
        nodeId: string;
        role?: AgentRole;
        model: string;
        tokens: number;
        cachedTokens: number;
        fromCache: boolean;
    }) => void;
    /**
     * Política de tools do executor de processo (CLI de agente): `none` (default
     * do adapter), `read` (leitura do repositório, grounding real) ou `write`.
     * Providers HTTP ignoram. Ausente, o adapter decide pelo ambiente.
     */
    toolPolicy?: 'none' | 'read' | 'write';
}
export type NodeProducer = (node: GraphNode, ctx: ExecuteCtx) => Promise<{
    content: unknown;
    kind: string;
    tokens?: number;
    model?: string;
}>;
/**
 * Producer real: contexto mínimo, cache local, chamada ao modelo do papel.
 * Um hit de cache devolve `tokens: 0` de propósito: a chamada não aconteceu,
 * então não existe gasto a contabilizar (a economia entra na telemetria).
 */
export declare function createLLMProducer(opts: ProducerOptions): NodeProducer;
/**
 * Producer headless: sem provider configurado, simula o artefato do nó.
 *
 * A simulação sai do schema real do kind (`simulatedArtifact`), e não de uma
 * forma genérica: antes, todo artefato tipado reprovava por campo obrigatório
 * ausente e o run terminava FAIL por um motivo que não era do runtime.
 */
export declare function createHeadlessProducer(objective: string): NodeProducer;
export interface SemanticJudgeWiring {
    client: ProducerLLMClient;
    /** Roteamento do papel `worker`: julgar é a tarefa barata por definição. */
    routeRole: (role: AgentRole, node?: GraphNode, hints?: RoutingHints) => {
        model: string;
        provider: string;
    } | undefined;
    /** Teto de saída do juiz (default do `createModelJudge`). */
    maxTokens?: number;
}
/**
 * Juiz semântico default, compartilhado pela CLI e pelo SDK.
 *
 * Devolve `undefined` quando não há modelo utilizável — e isso é a resposta
 * honesta, não um erro: sem juiz, o critério semântico fica UNVERIFIED, que já
 * é o comportamento conservador correto da Verification Engine. O que não pode
 * acontecer é o critério passar a valer como aprovado.
 */
export declare function createSemanticJudge(wiring: SemanticJudgeWiring): SemanticJudge | undefined;
//# sourceMappingURL=execute.d.ts.map