/**
 * SDK programático do Izanagi: `izanagi.run({ objective })`.
 *
 * Mesma engine da CLI (`runtime/execute.ts`), sem nada impresso no terminal.
 * Quem integra o Izanagi num serviço, num job ou noutro agente usa esta
 * superfície; a CLI é apenas a versão interativa dela.
 *
 * Observabilidade: o handle devolvido é uma Promise que também aceita
 * assinatura de eventos do run em tempo real.
 *
 *   const run = izanagi.run({ objective: 'auditar a API de login' });
 *   run.on('task:start', (e) => console.log(e.data));
 *   const result = await run;
 */
import { type ProducerLLMClient } from './runtime/execute.js';
import type { ExecutionMode } from './runtime/contracts/task-contract.js';
import type { IzanagiEvent, IzanagiEventName } from './runtime/observability/events.js';
import type { CommanderPlan } from './runtime/orchestration/commander.js';
import type { TokenTelemetry } from './runtime/token/execution-budget.js';
import type { EvaluationReport, HealingAction, RunTrace } from './runtime/types.js';
import type { VerificationResult } from './runtime/verification/engine.js';
export interface IzanagiRunOptions {
    /** O que precisa ser resolvido. */
    objective: string;
    /** Raiz de onde os ASSETS do framework são lidos: agentes e skills (default: diretório atual). */
    baseDir?: string;
    /**
     * Projeto de TRABALHO: o que o survey lê, onde a entrega grava, e a raiz
     * contra a qual `output` é validado. Default: `baseDir`.
     *
     * Separado porque `baseDir` responde outra pergunta ("de onde leio agentes e
     * skills?"). Rodando de dentro do projeto as duas coincidem, que é o caso
     * comum e o motivo de terem sido a mesma coisa até aqui; um chamador que lê
     * assets de uma instalação do framework e trabalha em outro diretório
     * gravaria a entrega dentro da instalação.
     */
    workspaceDir?: string;
    mode?: ExecutionMode;
    budget?: {
        maxTokens?: number;
        maxCost?: number;
        maxTimeMs?: number;
        maxToolCalls?: number;
        maxAgents?: number;
        maxRetries?: number;
    };
    /** Fixa o mesmo modelo em todos os papéis. */
    model?: string;
    /**
     * Allowlist de ids de tool para o run inteiro. Ausente: vale o que o contrato
     * de cada tarefa autoriza. Lista vazia proíbe toda tool (é declaração, não
     * ausência).
     */
    allowedTools?: string[];
    /**
     * Critérios de aceite do OBJETIVO, em texto. Cada linha vira um critério do
     * contrato das tarefas terminais de produto:
     *
     * - prosa (`"o endpoint aceita ?page e ?limit"`) vira critério SEMÂNTICO, que
     *   precisa de juiz e sem juiz fica `UNVERIFIED` (não medido, não reprovado);
     * - com prefixo conhecido (`"contains: paginação"`, `"file-exists: docs/api.md"`,
     *   `"matches: limit=\\d+"`, `"not-contains: TODO"`, `"min-size: 500"`,
     *   `"json-field: total"`, `"references-exist"`) vira critério
     *   DETERMINÍSTICO, decidido sem modelo.
     *
     * Sem isto, todo critério do run era derivado do SCHEMA do artefato: o plano
     * verificava a forma da entrega, nunca o que foi pedido.
     */
    acceptance?: string[];
    /**
     * Roda o comando de teste do projeto no fim do grafo, como um nó de tool com
     * permissão `shell`, e a métrica `testResults` da avaliação passa a vir do
     * EXIT CODE em vez de um artefato que um agente escreveu.
     *
     * Opt-in: executa um processo do projeto (o `scripts.test` do manifesto, ou
     * o runner da linguagem detectada) com o ambiente herdado. Nenhum campo de
     * entrada carrega um comando — o binário sai de uma allowlist do runtime e o
     * que ele roda é o que o dono do projeto configurou.
     */
    verifyTests?: boolean;
    /**
     * Piso de força de VERIFICAÇÃO do plano, em [0,1].
     *
     * Declarado, o Commander compara os modos possíveis e escolhe o mais barato
     * que ainda atinge o piso, registrando a comparação no plano
     * (`plan.candidates`) e nas decisões. Ausente, nada muda.
     *
     * O piso é sobre EVIDÊNCIA (quantos critérios obrigatórios por tarefa,
     * política estrita, revisão independente), não sobre a qualidade da entrega:
     * um plano com mais critérios não produz trabalho melhor, produz mais prova
     * sobre o trabalho.
     */
    minQuality?: number;
    /**
     * Cancelamento cooperativo do run. Abortar interrompe o grafo no próximo
     * batch e cancela a requisição em voo; o checkpoint do último batch
     * concluído fica em disco, e `izanagi resume <run-id>` retoma dali.
     *
     * Cancelar não é falhar por bug: o run termina `FAIL` com a falha declarando
     * o cancelamento, e o `Healer` a trata como não-recuperável (curar seria
     * desobedecer quem cancelou).
     */
    signal?: AbortSignal;
    /** Só providers locais (Ollama / LM Studio / endpoint próprio). */
    local?: boolean;
    /**
     * Política de tools do executor de processo (CLI de agente já autenticado):
     * `none` (default, nenhuma tool), `read` (leitura do repositório) ou `write`
     * (leitura + escrita de arquivo). Providers HTTP ignoram.
     */
    agentTools?: 'none' | 'read' | 'write';
    /** Cache local de respostas. */
    cache?: boolean;
    /**
     * Reaproveita artefato de run ANTERIOR quando a pergunta foi exatamente a
     * mesma: mesmo contrato, mesmos insumos a montante (por checksum), mesmo
     * estado de projeto declarado, dentro do prazo.
     *
     * Opt-in, como o cache de resposta, e pelo mesmo motivo: reuso é a
     * otimização que, quando erra, erra em silêncio. O artefato reaproveitado
     * passa pela verificação inteira — o que se economiza é a chamada, não a
     * prova. Nó de tool nunca é reaproveitado: reusar um "escreveu" significa
     * não escrever.
     */
    reuseArtifacts?: boolean;
    /** Agente explícito; sem isso o Capability Registry escolhe. */
    agent?: string;
    skillChain?: string[];
    /** Planejamento legado por categoria, sem Commander. */
    noCommander?: boolean;
    /**
     * Desliga o juiz semântico (default: ligado quando há provider). Sem juiz,
     * critério de aceite semântico fica UNVERIFIED em vez de aprovado.
     */
    noJudge?: boolean;
    /** Client LLM alternativo (testes, proxy, gateway próprio). */
    client?: ProducerLLMClient & {
        configuredProviders(): string[];
    };
    /**
     * Diretório onde o run grava a entrega, relativo a `baseDir`. Presente, o
     * plano ganha um nó de tool que escreve o resultado e verifica o arquivo
     * escrito — a única permissão de escrita concedida no grafo inteiro. Fora da
     * raiz do projeto, `run()` rejeita antes de planejar.
     */
    output?: string;
    /**
     * Lê o projeto antes de decidir: um nó de tool determinístico na cabeça do
     * grafo levanta stack, manifestos e árvore, e o resultado entra no contexto
     * mínimo das tarefas raiz. Default: ligado quando `baseDir` tem manifesto
     * reconhecido. `false` desliga.
     */
    survey?: boolean;
    /**
     * Raiz do estado (`.izanagi/state`: trace, artefatos, memória, checkpoints).
     * Default: `baseDir`. Separado porque `baseDir` também é a raiz de onde os
     * assets do framework são lidos, e as duas respostas divergem num projeto
     * sem `.agents/` — ver `resolveStateRoot` no installer.
     */
    stateDir?: string;
}
export interface IzanagiRunResult {
    runId: string;
    /** Caminho absoluto do arquivo entregue, quando `output` foi pedido e a gravação passou. */
    deliveredTo?: string;
    /**
     * `HUMAN_REQUIRED`: o run esgotou um teto DECLARADO (tentativas, tempo,
     * tokens ou custo) e parou por isso. Não é `FAIL` por bug e não é `BLOCKED`
     * (que é retomável por aprovação): a decisão seguinte é sobre o teto.
     */
    status: 'PASS' | 'PASS_WITH_WARNINGS' | 'FAIL' | 'BLOCKED' | 'HUMAN_REQUIRED' | 'UNKNOWN';
    score: number;
    mode?: ExecutionMode;
    /** Plano do Commander (ausente com `noCommander`). */
    plan?: CommanderPlan;
    /** Artefatos produzidos, por id de tarefa. */
    artifacts: Record<string, {
        kind: string;
        content: unknown;
        valid: boolean;
    }>;
    telemetry?: TokenTelemetry;
    verification?: Array<{
        nodeId: string;
        result: VerificationResult;
    }>;
    evaluation?: EvaluationReport;
    healing: HealingAction[];
    trace: RunTrace;
    traceFile: string;
    /** Execução pausada aguardando decisão humana. */
    pendingApproval?: {
        nodeId: string;
        context?: string;
    };
    /** true quando nenhum provider estava configurado (artefatos simulados). */
    headless: boolean;
}
/** Aliases amigáveis para os eventos internos do runtime. */
declare const EVENT_ALIASES: Record<string, IzanagiEventName>;
export type IzanagiEventSelector = IzanagiEventName | keyof typeof EVENT_ALIASES | '*';
export interface IzanagiRunHandle extends Promise<IzanagiRunResult> {
    /** Assina um evento do run. Devolve a função de cancelamento. */
    on(event: IzanagiEventSelector, handler: (event: IzanagiEvent) => void): () => void;
}
/**
 * Executa um objetivo de ponta a ponta: Commander decide o modo, o grafo roda
 * com roteamento por papel, os artefatos são verificados contra os critérios
 * de aceite e a telemetria de custo volta junto do resultado.
 */
export declare function run(options: IzanagiRunOptions): IzanagiRunHandle;
/**
 * Só planeja: devolve modo, contratos e estimativa de custo sem executar nada
 * nem gastar token. Útil para mostrar ao usuário o que vai acontecer (e quanto
 * vai custar) antes de autorizar.
 */
export declare function plan(options: Pick<IzanagiRunOptions, 'objective' | 'baseDir' | 'mode' | 'model' | 'agent' | 'skillChain' | 'budget' | 'local' | 'client' | 'acceptance' | 'agentTools'>): CommanderPlan | undefined;
export declare const izanagi: {
    run: typeof run;
    plan: typeof plan;
};
export default izanagi;
//# sourceMappingURL=sdk.d.ts.map