/**
 * UAP Agent - Memory Enabled
 *
 * Assumptions:
 * - This agent has access to UAP memory system
 * - Memory persists between tasks, providing context
 * - Can recall previous decisions, patterns, and mistakes
 * - Memory includes: file locations, patterns, mistakes, decisions
 *
 * What this handles:
 * - Context retrieval from memory before tasks
 * - Learning from previous mistakes (stored as gotchas)
 * - Pattern recognition from past successful solutions
 * - Knowledge of project structure
 *
 * What this does NOT handle:
 * - Full semantic memory system (simulated for this benchmark)
 * - Real AI/LLM integration (this is a simulation wrapper)
 * - Multi-agent coordination (future enhancement)
 */
import { BenchmarkTask, AgentExecution } from '../benchmark.js';
interface MemoryEntry {
    id: string;
    timestamp: number;
    type: 'action' | 'observation' | 'thought' | 'error' | 'lesson';
    content: string;
    context: {
        taskId?: string;
        category?: string;
        difficulty?: string;
    };
    importance: number;
    tags: string[];
}
declare class UAPMemory {
    private shortTerm;
    private longTerm;
    private lessons;
    private readonly MAX_SHORT_TERM;
    /**
     * Query memory for relevant context
     */
    query(keywords: string[]): MemoryEntry[];
    /**
     * Store an action in memory
     */
    storeAction(content: string, context: any): void;
    /**
     * Store an observation in memory
     */
    storeObservation(content: string, context: any): void;
    /**
     * Store a lesson in memory
     */
    storeLesson(content: string, tags: string[], importance?: number): void;
    /**
     * Store an error/gotcha in memory (to avoid repeating)
     */
    storeError(error: string, context: any): void;
    /**
     * Check if memory contains specific lesson
     */
    hasLesson(key: string): boolean;
    /**
     * Get all lessons
     */
    getLessons(): MemoryEntry[];
    /**
     * Private: Store entry in appropriate memory tier
     */
    private storeEntry;
    /**
     * Private: Consolidate memory when it gets too large
     */
    private consolidateMemory;
    /**
     * Private: Generate unique ID
     */
    private generateId;
    /**
     * Get memory statistics
     */
    getStats(): {
        shortTermCount: number;
        longTermCount: number;
        lessonsCount: number;
    };
}
export declare class UAPAgent {
    private name;
    private executionCount;
    private errors;
    private memory;
    constructor(name?: string);
    /**
     * Execute a task with memory context
     */
    executeTask(task: BenchmarkTask, attempt?: number): Promise<AgentExecution>;
    /**
     * Query memory for context relevant to the task
     */
    private queryMemoryContext;
    /**
     * Get lessons relevant to the task
     */
    private getRelevantLessons;
    /**
     * Check for past mistakes to avoid
     */
    private checkForPastMistakes;
    /**
     * Execute task using memory context
     */
    private executeWithMemory;
    /**
     * Simulate agent thinking/processing time (faster than naive)
     */
    private simulateThinking;
    /**
     * Simulate successful execution
     */
    private simulateSuccess;
    /**
     * Simulate failed execution
     */
    private simulateFailure;
    /**
     * Store memory after successful execution
     */
    private storeSuccessMemory;
    /**
     * Store memory after failed execution
     */
    private storeFailureMemory;
    /**
     * Extract keywords from text
     */
    private extractKeywords;
    /**
     * Pre-populate memory with common lessons
     */
    private prepopulateMemory;
    /**
     * Get agent statistics
     */
    getStats(): {
        name: string;
        executionCount: number;
        totalErrors: number;
        recentErrors: string[];
        memoryStats: {
            shortTermCount: number;
            longTermCount: number;
            lessonsCount: number;
        };
    };
    /**
     * Reset agent and memory
     */
    reset(): void;
    /**
     * Get access to memory (for debugging)
     */
    getMemory(): UAPMemory;
}
export type { MemoryEntry };
//# sourceMappingURL=uap-agent.d.ts.map