import type { TaskProfile } from './types.js';
export declare const CAPABILITY_KINDS: readonly ["skill", "mcp_tool"];
export type CapabilityKind = (typeof CAPABILITY_KINDS)[number];
export declare const MAX_CAPABILITY_DESCRIPTION_CHARS = 2000;
export declare const MAX_RAW_CAPABILITY_DESCRIPTION_CHARS = 64000;
export declare const MAX_CAPABILITY_NAME_CHARS = 300;
export declare const MAX_CAPABILITY_ITEMS = 200;
export declare const MAX_RAW_CAPABILITY_CATALOG_CODE_POINTS = 512000;
export interface CapabilityDescriptor {
    kind: CapabilityKind;
    name: string;
    description?: string;
}
export type CapabilityCatalogAvailability = 'known-empty' | 'known-nonempty' | 'unknown';
export interface CapabilityCatalogDiagnostics {
    received: number;
    accepted: number;
    truncated: number;
    dropped: number;
}
export interface NormalizedCapabilityCatalog {
    availability: CapabilityCatalogAvailability;
    skills: CapabilityDescriptor[];
    tools: CapabilityDescriptor[];
    diagnostics: CapabilityCatalogDiagnostics;
    budgetExceeded: boolean;
}
export interface CapabilityWarning {
    code: 'CAPABILITY_CATALOG_COMPACTED' | 'CAPABILITY_CATALOG_ITEMS_DROPPED' | 'CAPABILITY_CATALOG_BUDGET_EXCEEDED' | 'CAPABILITY_CATALOG_UNAVAILABLE';
    message: string;
}
export interface CapabilityRecommendation {
    kind: CapabilityKind;
    name: string;
    availability: 'available' | 'missing' | 'unknown';
    reason: string;
    source: 'akinator_policy' | 'catalog_similarity';
    required?: boolean;
}
export interface CapabilityResolution {
    availability: CapabilityCatalogAvailability;
    catalogProvided: boolean;
    availableSkillCount: number | null;
    diagnostics: CapabilityCatalogDiagnostics;
    warnings: CapabilityWarning[];
    recommendations: CapabilityRecommendation[];
}
export declare const MEMORY_REASONING_SKILL_NAME = "memory-reasoning";
/** Missing memory-reasoning withholds actionable memory but never blocks the task itself. */
export declare function hasBlockingRequiredCapability(resolution: Pick<CapabilityResolution, 'recommendations'>): boolean;
export declare function shouldWithholdMemoryContext(resolution: Pick<CapabilityResolution, 'recommendations'>): boolean;
export type MemoryUseSignal = 'none' | 'actionable';
export type MemoryReasoningCapabilityAvailability = 'available' | 'missing' | 'unknown';
export type MemoryWithheldReason = 'memory_reasoning_missing' | 'memory_reasoning_unknown';
export interface MemoryPolicy {
    memoryReasoningRequired: boolean;
    contextWithheld: boolean;
    withheldReason: MemoryWithheldReason | null;
    deliveryEmpty?: true;
    storedEntryCount?: number;
}
export interface MemoryDeliveryObservation {
    contextItemCount: number | null;
    storedEntryCount: number;
}
export declare function hasActionableMemorySelection(items: ReadonlyArray<{
    selectionReasons: ReadonlyArray<string>;
}>): boolean;
export declare function deriveMemoryUseSignal(input: {
    deliveryId: string | null;
    items: ReadonlyArray<{
        selectionReasons: ReadonlyArray<string>;
    }>;
} | null): MemoryUseSignal;
export declare function memoryReasoningRequired(profile: Pick<TaskProfile, 'taskType'>, memoryUse: MemoryUseSignal): boolean;
export declare function deriveMemoryPolicy(profile: Pick<TaskProfile, 'taskType'>, memoryUse: MemoryUseSignal, capabilities: unknown, delivery?: MemoryDeliveryObservation): MemoryPolicy;
export declare function boundedCodePointLength(value: string, limit: number): number;
export declare function truncateCodePoints(value: string, max: number): string;
export declare function compactCapabilityDescription(value: string): {
    description: string;
    truncated: boolean;
};
export declare function normalizeCapabilityCatalog(input: unknown): NormalizedCapabilityCatalog;
export declare function memoryReasoningCapabilityAvailability(capabilities: unknown): MemoryReasoningCapabilityAvailability;
export declare function resolveCapabilities(input: {
    task: string;
    profile: TaskProfile;
    recommendedTags: string[];
    capabilities?: unknown;
    memoryUse: MemoryUseSignal;
}): CapabilityResolution;
//# sourceMappingURL=capabilities.d.ts.map