import { type OrchestrationResult } from '../../runtime/orchestrator.js';
import type { CompletionOptions, CompletionResult } from '../../runtime/llm/client.js';
import type { GraphNode } from '../../runtime/types.js';
import { type ExecutionMode } from '../../runtime/contracts/task-contract.js';
interface RunArgs {
    agentId?: string;
    task?: string;
    /** Só compila e salva izanagi-prompt.md — não executa (sem graph/eval/trace). */
    promptOnly: boolean;
    verbose: boolean;
    /** Desliga a fundação estática (RULES.md) e o marker CAPC — prompt idêntico ao pré-wave. */
    noCacheFoundation: boolean;
    /** Força o modo de execução (`--mode direct|assisted|orchestrated|autonomous`). */
    mode?: ExecutionMode;
    /** Teto global de tokens do run (`--budget N`). */
    budget?: number;
    /** Teto global de custo em USD (`--max-cost N`). */
    maxCost?: number;
    /**
     * Teto de tarefas em voo (`--max-concurrency N`). O SDK sempre pôde declarar
     * este teto por `budgetLimits.maxConcurrency`; a CLI não tinha por onde.
     */
    maxConcurrency?: number;
    /** Fixa o modelo de todos os papéis (`--model <id>`). */
    model?: string;
    /** Restringe a execução a providers locais (`--local`). */
    local: boolean;
    /** Liga o cache local de respostas (`--cache`). */
    cache: boolean;
    /**
     * Reaproveita artefato de run anterior quando a pergunta foi exatamente a
     * mesma (`--reuse-artifacts`). Opt-in, como `--cache`.
     */
    reuseArtifacts: boolean;
    /** Desliga o Commander e volta ao planejamento por categoria (`--no-commander`). */
    noCommander: boolean;
    /** Desliga o juiz semântico (`--no-judge`): critério semântico volta a ficar UNVERIFIED. */
    noJudge: boolean;
    /**
     * Política de tools do EXECUTOR de processo (`--agent-tools none|read|write`).
     * Não confundir com `--allow-tool`, que governa os nós de tool do grafo:
     * aqui se decide se o subprocesso do agente pode LER o repositório ou
     * ALTERAR arquivos. Ausente = `none` (nenhuma tool).
     */
    agentTools?: 'none' | 'read' | 'write';
    /** Saída única em JSON no stdout, para o agendador do SO consumir (`--json`). */
    json: boolean;
    /** Diretório onde o run grava a entrega (`--output <dir>`), relativo à raiz do projeto. */
    output?: string;
    /** Força o levantamento do projeto (`--survey`), mesmo sem manifesto reconhecido. */
    survey?: boolean;
    /** Desliga o levantamento do projeto (`--no-survey`). */
    noSurvey?: boolean;
    /** Endpoint POST avisado no fim do run (`--notify-webhook=<url>`). */
    notifyWebhook?: string;
    /**
     * Critérios de aceite do usuário (`--acceptance "..."`, repetível).
     *
     * Sem isto, todo critério do run era gerado a partir do SCHEMA do artefato:
     * o plano verificava a forma da entrega e nunca o que foi pedido.
     */
    acceptance?: string[];
    /**
     * Allowlist de tools do run (`--allow-tool fs.read --allow-tool fs.write`).
     * Existia no Orchestrator, no SDK e no caso de benchmark; a CLI não tinha por
     * onde declarar. Ausente, vale a permissão do contrato de cada nó.
     */
    allowedTools?: string[];
    /**
     * Piso de força de verificação do plano em [0,1] (`--min-quality`).
     * Declarado, o Commander escolhe a estratégia mais barata que o atinge.
     */
    minQuality?: number;
    /**
     * Roda o comando de teste do projeto no fim do run (`--verify-tests`).
     *
     * Opt-in porque executa um processo do PROJETO (o `scripts.test` do
     * manifesto, ou o runner da linguagem detectada) com o ambiente herdado: a
     * mesma confiança de digitar `npm test`, e por isso decisão de quem roda.
     */
    verifyTests: boolean;
}
export declare function parseRunArgs(args: string[]): RunArgs;
interface TaskClassification {
    category: string;
    agent: string;
}
export declare function classifyTask(desc: string): TaskClassification;
export declare function resolveChainForCategory(agent: any, category: string): string[];
/**
 * @param baseDir  Raiz dos ASSETS do framework (agentes, skills, RULES.md).
 * @param stateDir Raiz do ESTADO deste projeto (`.izanagi/state`). Default:
 *                 `baseDir`, o comportamento anterior. Ver `resolveStateRoot`.
 */
export declare function runCommand(baseDir: string, args: string[], stateDir?: string): Promise<void>;
/**
 * Superfície mínima do LLMClient consumida pelo run — permite injetar um
 * client de teste (structural typing) sem tocar no Orchestrator.
 */
export interface RuntimeLLMClient {
    configuredProviders(): string[];
    complete(provider: string, opts: CompletionOptions): Promise<CompletionResult>;
}
/**
 * Modo runtime: usa o Orchestrator do framework para construir o execution
 * graph, avaliar, curar falhas e persistir trace + aprendizados.
 *
 * Quando há API key configurada (IZANAGI_OPENAI_API_KEY, IZANAGI_ANTHROPIC_API_KEY,
 * IZANAGI_GOOGLE_API_KEY), cada nó do grafo é executado por um LLM real via
 * ModelRouter; sem chave, roda em modo headless (simulação) com aviso.
 */
export declare function runRuntime(baseDir: string, opts: {
    task: string;
    category: string;
    agentId: string;
    skillChain: string[];
    agent: any;
    verbose: boolean;
    /** Retoma um run interrompido/pausado em vez de planejar do zero (izanagi resume/approve/reject). */
    resumeRunId?: string;
    /** Desliga fundação RULES.md estática + marker CAPC (prompt pré-wave). */
    noCacheFoundation?: boolean;
    /** Client LLM injetável (testes). Default: LLMClient real lido do ambiente. */
    client?: RuntimeLLMClient;
    /** Modo forçado (`--mode`). Ausente = Commander decide pela complexidade. */
    mode?: ExecutionMode;
    /** Teto global de tokens (`--budget`). */
    budget?: number;
    /** Teto global de custo em USD (`--max-cost`). */
    maxCost?: number;
    /** Modelo fixo para todos os papéis (`--model`). */
    model?: string;
    /** Teto de tarefas em voo (`--max-concurrency`). */
    maxConcurrency?: number;
    /** Só providers locais (`--local`). */
    local?: boolean;
    /** Cache local de respostas (`--cache`). */
    cache?: boolean;
    /** Reaproveita artefato de run anterior (`--reuse-artifacts`). */
    reuseArtifacts?: boolean;
    /** Volta ao planejamento por categoria (`--no-commander`). */
    noCommander?: boolean;
    /** Desliga o juiz semântico (`--no-judge`). Sem juiz, critério semântico fica UNVERIFIED. */
    noJudge?: boolean;
    /** Silencia a saída humana: quem consome é um agendador, não uma pessoa. */
    json?: boolean;
    /** O usuário nomeou o agente explicitamente (`izanagi run architect ...`). */
    explicitAgent?: boolean;
    /** Diretório de entrega já validado contra a raiz do projeto (`--output`). */
    output?: string;
    /** Levanta a forma do projeto antes de decidir (nó de tool na cabeça do grafo). */
    survey?: boolean;
    /** Critérios de aceite do usuário, em texto (`--acceptance`). */
    acceptance?: string[];
    /** Piso de força de verificação do plano (`--min-quality`). */
    minQuality?: number;
    /** Roda o comando de teste do projeto no fim do grafo (`--verify-tests`). */
    verifyTests?: boolean;
    /** Allowlist de tools do run (`--allow-tool`). */
    allowedTools?: string[];
    /**
     * Política de tools do EXECUTOR de processo (`--agent-tools`), diferente de
     * `--allow-tool` (que governa os nós de tool do próprio grafo): aqui se
     * decide se o subprocesso do agente pode ler o repositório (`read`) ou
     * alterar arquivos (`write`). Default `none`: nenhuma tool.
     */
    agentTools?: 'none' | 'read' | 'write';
    /** Raiz do estado (`.izanagi/state`). Default: `baseDir`. */
    stateDir?: string;
}): Promise<OrchestrationResult | undefined>;
/**
 * Budget máximo (em chars) da fundação RULES.md embutida no prefixo estático.
 * 6000 chars ≈ 1500 tokens estimados (~4 chars/token) — folga sobre o piso
 * MIN_CACHEABLE_TOKENS (1024) mesmo após o corte determinístico.
 */
export declare const RULES_FOUNDATION_MAX_CHARS = 6000;
/**
 * Compila o system prompt de um nó do grafo: identidade do agente do nó,
 * regras obrigatórias, skills resolvidas (resumidas) e contrato do artefato.
 *
 * Cache-Aware Prompt Compression (CAPC): quando existe RULES.md e o prefixo
 * estático atinge MIN_CACHEABLE_TOKENS tokens estimados, o prompt vira
 * `[ESTÁTICO] + <!-- IZANAGI:DYNAMIC --> + [VOLÁTIL]`:
 *   ESTÁTICO = header genérico + regra suprema + fundação RULES.md (seções 1–2)
 *   VOLÁTIL  = nó em execução + artefato esperado + identidade + always/never
 *              + TAREFA + skills — tudo na ordem pré-wave.
 * O bloco estático fica BYTE-IDÊNTICO entre nós do mesmo run (condição para
 * o provider cachear: Anthropic via cache_control automático no client;
 * OpenAI-compatible via prefix caching). Guardas retrocompatíveis: sem
 * RULES.md OU estático abaixo do piso → formato pré-wave SEM marker.
 * flags.noCacheFoundation desliga a fundação/marker incondicionalmente.
 */
/**
 * O que o nó precisa produzir, DITO ao agente.
 *
 * O runtime já reprovava artefato fora do schema (`validateArtifact`), e o
 * prompt nunca dizia qual era o schema: a linha era "Artefato esperado deste
 * nó: `security-report` (conteúdo estruturado)", enquanto a verificação cobrava
 * `severity`, `vulnerabilities`, `remediation` e um tamanho mínimo. Medido num
 * run orchestrated real, o nó falhou nas DUAS tentativas por "4 critério(s)
 * obrigatório(s) reprovado(s)", com o agente escrevendo sobre o assunto certo
 * na única forma que ele podia adivinhar.
 *
 * Cobrar um contrato que não foi comunicado não mede o agente, mede a sorte.
 */
export declare function artifactRequirementLine(kind: string): string;
export declare function buildNodePrompt(node: GraphNode, opts: {
    task: string;
    agent: any;
    skillChain: string[];
}, baseDir: string, flags?: {
    noCacheFoundation?: boolean;
    context?: string;
}): string;
export declare function findAgentJson(agentId: string, baseDir: string): any;
export {};
//# sourceMappingURL=run.d.ts.map