/**
 * Sub-orquestração: uma tarefa que descobre, executando, que é maior do que o
 * planejamento previu.
 *
 * O Commander decompõe ANTES de executar, e para a maioria dos objetivos isso
 * basta. O caso que ele não cobre é o da tarefa cuja decomposição depende de
 * algo que só se sabe depois de olhar: "auditar a segurança deste sistema" só
 * revela quantas frentes existem quando o sistema é examinado.
 *
 * A resposta aqui NÃO é deixar agentes se decomporem à vontade — isso é a
 * colmeia que a arquitetura proíbe, com custo exponencial. É um pedido
 * explícito, validado, com teto de profundidade, teto de largura e orçamento
 * herdado do nó pai. Um nó que pede decomposição não ganha orçamento novo:
 * ele divide o que já tinha.
 */
import type { ExecutionGraph, GraphNode } from '../types.js';
import { type DecomposedTask } from './commander.js';
/** Profundidade máxima de sub-orquestração. 0 = o grafo do run. */
export declare const DEFAULT_MAX_ORCHESTRATION_DEPTH = 2;
/** Sub-tarefas por decomposição. Mais que isto não é decompor, é replanejar. */
export declare const MAX_SUBTASKS = 5;
/**
 * Piso de tokens por sub-tarefa. Abaixo disto a chamada é gasta sem produzir
 * nada utilizável, e o subgrafo fica mais caro que a tarefa que ele dividiu.
 */
export declare const MIN_SUBTASK_TOKENS = 512;
export interface DecompositionRequest {
    /** Por que a tarefa não cabe numa entrega só. Entra no trace. */
    reason: string;
    tasks: DecomposedTask[];
}
/**
 * Extrai um pedido de decomposição da saída de um nó. Nunca lança: saída sem
 * pedido devolve `null`, e o nó segue como entrega normal.
 *
 * Tolerante ao embrulho (prosa, cerca de código) pelo mesmo motivo da crítica:
 * o formato é pedido no prompt, mas o parsing não pode depender de obediência.
 */
export declare function parseDecomposition(content: unknown): DecompositionRequest | null;
export interface SubgraphBuild {
    graph: ExecutionGraph;
    /** Ids das sub-tarefas, na ordem em que entram no grafo. */
    taskIds: string[];
    /** Problemas que impediram a construção. Vazio = subgrafo utilizável. */
    issues: string[];
}
/**
 * Constrói o subgrafo de um nó pai.
 *
 * Regras que não são negociáveis aqui, porque cada uma delas é a diferença
 * entre sub-orquestração e explosão combinatória:
 *
 *  - ids das sub-tarefas são PREFIXADOS pelo nó pai, então não colidem com o
 *    grafo de cima nem com o subgrafo de um irmão;
 *  - o orçamento de tokens do pai é DIVIDIDO entre as sub-tarefas, nunca
 *    multiplicado: decompor não é motivo para gastar mais;
 *  - o contrato de cada sub-tarefa herda restrições e política de verificação
 *    do pai, então o filho não afrouxa o que o pai prometeu;
 *  - sub-tarefa não é decomponível: a profundidade seguinte se resolve pelo
 *    teto, não pela boa vontade do agente.
 */
export declare function buildSubgraph(parent: GraphNode, request: DecompositionRequest, opts: {
    depth: number;
    maxDepth: number;
}): SubgraphBuild;
/**
 * Agrega os artefatos das sub-tarefas no artefato do nó pai.
 *
 * Concatenação rotulada, não síntese: sintetizar exigiria outra chamada de
 * modelo, e o pai já gastou a dele pedindo a decomposição. Quem quiser síntese
 * declara um nó de agregação no plano.
 */
export declare function aggregateSubgraph(parentId: string, taskIds: string[], artifacts: Map<string, {
    kind: string;
    content: unknown;
    valid: boolean;
}>): {
    content: string;
    produced: number;
    missing: string[];
};
//# sourceMappingURL=subgraph.d.ts.map