/**
 * Ruflo capability brain.
 *
 * This module is deliberately data-only: it describes the complete MCP surface
 * without importing the MCP registry. The registry injects its live tool list
 * into guidance-tools after registration, which avoids a circular dependency
 * and prevents documentation from being mistaken for runtime availability.
 */
export type CapabilityMaturity = 'stable' | 'experimental' | 'compatibility';
export type CapabilityAuthority = 'advisory' | 'capability-plane' | 'control-plane';
export type CapabilityRisk = 'read-only' | 'reversible' | 'privileged';
export type AvailabilityState = boolean | 'unknown';
export type CapabilityRiskFlag = 'read' | 'local-write' | 'memory-poisoning' | 'process-exec' | 'network' | 'credential-pii' | 'spend' | 'concurrency' | 'destructive' | 'approval' | 'promotion';
export interface CapabilityToolMetadata {
    name: string;
    description?: string;
    category?: string;
    tags?: string[];
    version?: string;
}
export interface CapabilityHealth {
    /** Present in this running MCP server's registry. */
    registered: boolean;
    /** Requires an operator/provider configuration check. */
    configured: AvailabilityState;
    /** Requires a non-mutating dependency probe. */
    reachable: AvailabilityState;
    /** Requires a service-specific health check. */
    healthy: AvailabilityState;
    /** Requires a policy evaluation for the current subject and action. */
    authorized: AvailabilityState;
}
export interface CapabilityDomainDefinition {
    id: string;
    name: string;
    description: string;
    prefixes: string[];
    exactTools?: string[];
    taskSignals: string[];
    commands: string[];
    skills: string[];
    agents: string[];
    maturity: CapabilityMaturity;
    authority: CapabilityAuthority;
    risk: CapabilityRisk;
    optionalRuntime?: boolean;
    packageOwners?: string[];
    pluginOwners?: string[];
    availabilityMode?: 'always-local' | 'conditional-registration' | 'registered-degraded' | 'configured-remote' | 'policy-filtered';
    /**
     * Conservative union of effects possible anywhere in this domain.
     * Individual tool descriptors may narrow or expand this reviewed profile.
     */
    riskFlags?: CapabilityRiskFlag[];
    loopPhases?: Array<'discover' | 'recall' | 'authorize-claim' | 'route-plan' | 'branch-propose' | 'execute' | 'validate-critique' | 'commit-validated' | 'observe' | 'publish'>;
    useWhen: string;
    verifyBeforeUse: string[];
}
export interface CapabilityDomain extends CapabilityDomainDefinition {
    packageOwners: string[];
    pluginOwners: string[];
    availabilityMode: NonNullable<CapabilityDomainDefinition['availabilityMode']>;
    riskFlags: NonNullable<CapabilityDomainDefinition['riskFlags']>;
    loopPhases: NonNullable<CapabilityDomainDefinition['loopPhases']>;
    tools: Array<CapabilityToolMetadata & {
        domain: string;
        packageOwner: string;
        pluginOwner?: string;
        availabilityMode: NonNullable<CapabilityDomainDefinition['availabilityMode']>;
        authority: CapabilityAuthority;
        risk: CapabilityRisk;
        riskFlags: NonNullable<CapabilityDomainDefinition['riskFlags']>;
        loopPhases: NonNullable<CapabilityDomainDefinition['loopPhases']>;
    }>;
    health: CapabilityHealth;
}
export interface CapabilityBrain {
    schemaVersion: 'ruflo.capability-brain/v1';
    generatedAt: string;
    truthModel: {
        catalogued: string;
        registered: string;
        configured: string;
        reachable: string;
        healthy: string;
        authorized: string;
    };
    domains: CapabilityDomain[];
    cliCommands: string[];
    implementationLoop: ImplementationLoopStep[];
    coverage: {
        registeredToolCount: number;
        classifiedToolCount: number;
        coveragePercent: number;
        fallbackClassifiedTools: string[];
        duplicateToolNames: string[];
    };
}
/** Top-level commands from the CLI command loader. Kept as a checked manifest. */
export declare const RUFLO_CLI_COMMANDS: readonly ["init", "start", "status", "task", "session", "agent", "swarm", "memory", "mcp", "config", "migrate", "hooks", "workflow", "hive-mind", "process", "daemon", "version", "neural", "security", "performance", "providers", "plugins", "deployment", "claims", "policy", "embeddings", "completions", "doctor", "verify", "analyze", "route", "progress", "issues", "update", "ruvector", "benchmark", "guidance", "appliance", "appliance-advanced", "transfer-store", "cleanup", "autopilot", "gaia-bench", "metaharness", "eject", "funnel", "settings", "auth", "proxy", "advisor", "spinner", "announcements"];
export interface ImplementationLoopStep {
    id: string;
    name: string;
    purpose: string;
    preferredTools: string[];
    requiredEvidence: string;
    mutation: 'none' | 'workspace' | 'external';
}
export declare const IMPLEMENTATION_LOOP: readonly ImplementationLoopStep[];
/**
 * Domain order is significant: narrow/specialized matches precede broad
 * compatibility prefixes. Every registered tool is eventually classified by
 * the final runtime-services domain, but fallback classifications are reported.
 */
export declare const CAPABILITY_DOMAINS: readonly CapabilityDomainDefinition[];
export declare function classifyCapabilityTool(tool: CapabilityToolMetadata): CapabilityDomainDefinition;
export declare function buildCapabilityBrain(registeredTools: readonly CapabilityToolMetadata[], now?: Date): CapabilityBrain;
export interface CapabilityRecommendation {
    task: string;
    domains: Array<{
        id: string;
        name: string;
        score: number;
        registeredTools: string[];
        health: CapabilityHealth;
        authority: CapabilityAuthority;
        risk: CapabilityRisk;
        verifyBeforeUse: string[];
    }>;
    implementationLoop: ImplementationLoopStep[];
    guardrails: string[];
}
export declare function recommendCapabilities(brain: CapabilityBrain, task: string): CapabilityRecommendation;
//# sourceMappingURL=capability-brain.d.ts.map