/**
 * Agent Capability Registry: responde "quem sabe fazer isso?" sem que o
 * Commander precise conhecer agente por agente num prompt gigante.
 *
 * Antes deste módulo a lista de agentes era um array literal dentro do
 * orchestrator (`agentIds()`), que ficava desatualizado a cada agente novo e
 * ignorava agentes do projeto do usuário. Aqui a lista vem do disco: cada
 * `agents/<slug>-agent.json` declara capacidades, skills, custo e modelo.
 *
 * Determinístico por construção: descoberta = leitura de diretório, seleção =
 * scoring do CandidateScorer já existente. Nenhuma chamada de modelo.
 */
import type { AgentRole } from '../contracts/task-contract.js';
import type { TrustTier } from '../security/policy.js';
import { type Domain } from '../orchestration/domains.js';
export interface AgentCapability {
    id: string;
    name: string;
    purpose: string;
    capabilities: string[];
    skills: string[];
    chains: Record<string, string[]>;
    /** Teto declarado de tokens do agente (proxy de custo). */
    tokenBudget: number;
    /** Classe de custo derivada do tokenBudget: agentes caros só entram quando o papel justifica. */
    costClass: 'low' | 'medium' | 'high';
    /** Papel natural do agente na hierarquia. */
    role: AgentRole;
    /** Kinds de artefato que o agente costuma produzir (derivado das chains/capacidades). */
    outputs: string[];
    /**
     * Domínios técnicos cobertos pelo agente, detectados sobre a mesma tabela
     * bilíngue usada pelo Commander para classificar o objetivo. É o que faz um
     * agente descrito em inglês ("Clean Architecture") casar com um objetivo
     * escrito em português ("arquitetura limpa").
     */
    domains: Domain[];
    /**
     * Confiança de origem, derivada do diretório de onde o agente foi lido.
     * É o que a `PolicyEngine` usa para negar permissão destrutiva a agente que
     * não veio do framework. Derivar do caminho é deliberado: um agente não pode
     * declarar o próprio trust tier no JSON dele.
     */
    trustTier: TrustTier;
    /**
     * Tier de modelo declarado pelo agente (`"sonnet"` / `"opus"` nos 22 core).
     *
     * É uma PREFERÊNCIA, não um id de catálogo, e não é o que roteia: o modelo
     * sai do papel via `ModelRouter.routeForRole`. Existe aqui para que o
     * Commander possa perguntar "este agente pede modelo forte?" sem abrir o
     * arquivo — o campo estava no disco em 22/22 agentes e era descartado no
     * parse.
     */
    modelHint?: string;
    /**
     * Permissões que o agente DECLARA precisar, em prosa
     * (`"ler agents/"`, `"escrever skills/ (draft em staging...)"`).
     *
     * Nome explícito porque a distinção é de segurança: isto NÃO é a concessão
     * de permissão do runtime. O que autoriza uma tool é
     * `TaskContract.permissions` no formato `fs:read`/`fs:write`/`shell`,
     * conferido pela `PolicyEngine` contra o trust tier da ORIGEM do arquivo.
     * Um agente não se autoriza declarando o que quer.
     */
    declaredPermissions: string[];
    /**
     * Métodos de verificação declarados pelo agente: quais métricas da
     * Evaluation Engine se aplicam ao que ele produz e a nota mínima que ele
     * mesmo estabelece.
     */
    evaluation?: {
        metrics: string[];
        minScore?: number;
    };
    file: string;
}
export interface CapabilityMatch {
    agent: AgentCapability;
    score: number;
    reasons: string[];
}
export declare class AgentCapabilityRegistry {
    private readonly opts;
    private cache;
    constructor(opts: {
        baseDir: string;
        extraDirs?: string[];
        includeGenerated?: boolean;
    });
    /** Diretórios varridos, em ordem de precedência (projeto do usuário primeiro). */
    private dirs;
    /** Todos os agentes descobertos. Primeira declaração de um id vence. */
    list(): AgentCapability[];
    private parse;
    get(id: string): AgentCapability | undefined;
    ids(): string[];
    /**
     * Capability matching: ranqueia agentes capazes de atender a um objetivo.
     * `role` restringe ao nível hierárquico (não gasta um commander numa
     * extração); `exclude` remove agentes já descartados por falha.
     */
    findCapable(objective: string, opts?: {
        role?: AgentRole;
        limit?: number;
        exclude?: string[];
    }): CapabilityMatch[];
    /** Melhor agente para um objetivo, ou null quando nada casa. */
    bestFor(objective: string, opts?: {
        role?: AgentRole;
        exclude?: string[];
    }): AgentCapability | null;
    /** Chain de skills declarada pelo agente para uma categoria, com fallback estável. */
    chainFor(agentId: string, category: string): string[];
    /** Invalida o cache (útil depois que a Agent Factory gera um agente novo). */
    refresh(): void;
}
//# sourceMappingURL=capabilities.d.ts.map