/**
 * Advanced RLM Features
 * Implements additional techniques from the RLM paper (arXiv:2512.24601)
 *
 * Features:
 * 1. Parallel Sub-Agent Execution - Run multiple llm_query calls concurrently
 * 2. Adaptive Compression - Dynamically adjust based on context usage
 * 3. Context Rot Detection - Detect and recover from context degradation
 * 4. Selective Attention - Dynamic context filtering based on relevance
 * 5. Iterative Refinement - Multi-pass analysis for quality improvement
 */
import type { MemoryEntry } from './context-manager.js';
/** Configuration for parallel execution */
export interface ParallelExecutionConfig {
    /** Maximum concurrent sub-LLM calls */
    maxConcurrent: number;
    /** Timeout per individual call (ms) */
    callTimeout: number;
    /** Whether to fail fast on first error */
    failFast: boolean;
    /** Retry count for failed calls */
    retryCount: number;
}
/** Result from a parallel batch execution */
export interface ParallelBatchResult {
    /** Results indexed by query ID */
    results: Map<string, string>;
    /** Errors indexed by query ID */
    errors: Map<string, Error>;
    /** Total execution time */
    totalTimeMs: number;
    /** Individual timing per query */
    timings: Map<string, number>;
}
/** Default parallel execution config */
declare const DEFAULT_PARALLEL_CONFIG: ParallelExecutionConfig;
/**
 * Parallel Sub-Agent Executor
 * Manages concurrent execution of sub-LLM queries
 */
export declare class ParallelExecutor {
    private config;
    constructor(config?: Partial<ParallelExecutionConfig>);
    /**
     * Execute multiple queries in parallel with concurrency control
     */
    executeBatch(queries: Array<{
        id: string;
        query: string;
    }>, executor: (query: string) => Promise<string>): Promise<ParallelBatchResult>;
    /**
     * Execute with retry logic
     */
    private executeWithRetry;
    /**
     * Get optimal batch size based on query complexity
     */
    static getOptimalBatchSize(queries: string[], maxTokensPerBatch?: number): number;
}
/** Context usage metrics */
export interface ContextUsageMetrics {
    /** Estimated tokens used */
    tokensUsed: number;
    /** Maximum tokens available */
    maxTokens: number;
    /** Usage percentage (0-100) */
    usagePercent: number;
    /** Memory bank size */
    memoryBankSize: number;
    /** Compressed turns count */
    compressedTurnsCount: number;
}
/** Adaptive compression configuration */
export interface AdaptiveCompressionConfig {
    /** Target context usage percentage (0-100) */
    targetUsagePercent: number;
    /** Usage threshold to trigger aggressive compression */
    aggressiveThreshold: number;
    /** Usage threshold to trigger emergency compression */
    emergencyThreshold: number;
    /** Minimum result length even under emergency compression */
    minResultLength: number;
}
/** Default adaptive compression config */
declare const DEFAULT_ADAPTIVE_CONFIG: AdaptiveCompressionConfig;
/**
 * Adaptive Compression Manager
 * Dynamically adjusts compression based on context usage
 */
export declare class AdaptiveCompressor {
    private config;
    private maxContextTokens;
    private currentUsage;
    constructor(maxContextTokens?: number, // Default for Gemini 1.5 Flash
    config?: Partial<AdaptiveCompressionConfig>);
    /**
     * Update current context usage
     */
    updateUsage(estimatedTokens: number): void;
    /**
     * Get current context metrics
     */
    getMetrics(): ContextUsageMetrics;
    /**
     * Get adaptive compression level based on current usage
     */
    getCompressionLevel(): 'none' | 'normal' | 'aggressive' | 'emergency';
    /**
     * Get dynamic max result length based on compression level
     */
    getMaxResultLength(baseLength: number): number;
    /**
     * Compress content adaptively based on current context usage
     */
    compressAdaptively(content: string, baseMaxLength: number): string;
    /**
     * Estimate tokens from text (rough approximation)
     */
    static estimateTokens(text: string): number;
}
/** Context rot indicators */
export interface ContextRotIndicators {
    /** Whether context rot is detected */
    detected: boolean;
    /** Confidence level (0-100) */
    confidence: number;
    /** Specific indicators found */
    indicators: string[];
    /** Recommended action */
    recommendation: 'none' | 'inject_memory' | 'summarize' | 'restart';
}
/** Patterns indicating context rot */
declare const CONTEXT_ROT_PATTERNS: RegExp[];
/** Patterns indicating good context retention */
declare const CONTEXT_RETENTION_PATTERNS: RegExp[];
/**
 * Context Rot Detector
 * Monitors for signs of context degradation
 */
export declare class ContextRotDetector {
    private recentResponses;
    private maxHistory;
    private memoryReferenceCount;
    private rotIndicatorCount;
    /**
     * Analyze a response for context rot indicators
     */
    analyzeResponse(response: string): ContextRotIndicators;
    /**
     * Generate a memory injection prompt to combat context rot
     */
    generateMemoryInjection(memoryBank: MemoryEntry[]): string;
    /**
     * Reset the detector state
     */
    reset(): void;
    /**
     * Get detection statistics
     */
    getStats(): {
        rotIndicators: number;
        memoryReferences: number;
        ratio: number;
    };
}
/** Attention weights for different content types */
export interface AttentionWeights {
    /** Weight for file analysis results */
    fileAnalysis: number;
    /** Weight for architecture patterns */
    patterns: number;
    /** Weight for dependencies */
    dependencies: number;
    /** Weight for issues/errors */
    issues: number;
    /** Weight for summaries */
    summaries: number;
}
/** Default attention weights */
declare const DEFAULT_ATTENTION_WEIGHTS: AttentionWeights;
/**
 * Selective Attention Manager
 * Dynamically filters and prioritizes context based on relevance
 */
export declare class SelectiveAttention {
    private weights;
    private queryContext;
    constructor(weights?: Partial<AttentionWeights>);
    /**
     * Set the current query context for relevance scoring
     */
    setQueryContext(query: string): void;
    /**
     * Adjust weights based on query type
     */
    adjustWeightsForQuery(query: string): void;
    /**
     * Score a memory entry based on current attention weights and query relevance
     */
    scoreMemory(memory: MemoryEntry): number;
    /**
     * Get weight for a memory type
     */
    private getTypeWeight;
    /**
     * Calculate relevance of content to current query
     */
    private calculateRelevance;
    /**
     * Filter and sort memories by attention score
     */
    filterByAttention(memories: MemoryEntry[], maxCount: number): MemoryEntry[];
    /**
     * Build an attention-weighted context summary
     */
    buildAttentionContext(memories: MemoryEntry[], maxTokens: number): string;
    /**
     * Reset weights to defaults
     */
    resetWeights(): void;
}
/** Refinement pass configuration */
export interface RefinementConfig {
    /** Maximum refinement passes */
    maxPasses: number;
    /** Quality threshold to stop refinement (0-100) */
    qualityThreshold: number;
    /** Minimum improvement required to continue (percentage) */
    minImprovement: number;
    /** Enable self-critique */
    enableSelfCritique: boolean;
}
/** Result of a refinement pass */
export interface RefinementPassResult {
    /** Pass number */
    pass: number;
    /** Quality score for this pass */
    qualityScore: number;
    /** Improvements made */
    improvements: string[];
    /** Issues found */
    issuesFound: string[];
    /** Whether refinement should continue */
    shouldContinue: boolean;
}
/** Default refinement config */
declare const DEFAULT_REFINEMENT_CONFIG: RefinementConfig;
/**
 * Iterative Refinement Manager
 * Manages multi-pass analysis for quality improvement
 */
export declare class IterativeRefiner {
    private config;
    private passHistory;
    constructor(config?: Partial<RefinementConfig>);
    /**
     * Evaluate the quality of an analysis result
     */
    evaluateQuality(result: string, query: string): number;
    /**
     * Generate a self-critique prompt
     */
    generateCritiquePrompt(result: string, query: string): string;
    /**
     * Generate a refinement prompt based on critique
     */
    generateRefinementPrompt(originalResult: string, critique: string, query: string): string;
    /**
     * Determine if refinement should continue
     */
    shouldContinueRefinement(currentScore: number, previousScore: number | null): {
        shouldContinue: boolean;
        reason: string;
    };
    /**
     * Record a refinement pass
     */
    recordPass(qualityScore: number, improvements: string[], issuesFound: string[]): RefinementPassResult;
    /**
     * Get refinement history
     */
    getHistory(): RefinementPassResult[];
    /**
     * Get overall improvement
     */
    getOverallImprovement(): number;
    /**
     * Reset for new analysis
     */
    reset(): void;
}
export { DEFAULT_PARALLEL_CONFIG, DEFAULT_ADAPTIVE_CONFIG, DEFAULT_REFINEMENT_CONFIG, DEFAULT_ATTENTION_WEIGHTS, CONTEXT_ROT_PATTERNS, CONTEXT_RETENTION_PATTERNS, };
//# sourceMappingURL=advanced-features.d.ts.map