/**
 * KnowledgeEvolveEngine — Two-layer knowledge distillation
 *
 * Layer 1: Agent private refinement (local Ollama, zero cost)
 *   Conversations → extract insights → distill → write back to agent memory
 *   Key: memory never grows, only gets more refined
 *
 * Layer 2: Workstation shared refinement (AgentKits cloud model, paid)
 *   Multiple agents' refined knowledge → cross-agent fusion → shared workstation layer
 *   Key: one agent learns, all agents benefit
 *
 * Core principle:
 *   - Layer 1 ALWAYS uses local Ollama (zero cost)
 *   - Layer 2 uses AgentKits/cloud model (paid, higher quality)
 *   - Agent memory = distilled experience, NOT raw conversation history
 */
export interface EvolveConfig {
    enabled: boolean;
    /** Ollama model for evolve (default: auto-detect best local model) */
    localModel?: string;
    /** Ollama base URL (default: http://localhost:11434/v1) */
    ollamaUrl?: string;
    /** Evolve after N conversations (default: 10) */
    conversationThreshold?: number;
    /** Periodic evolve interval in ms (default: 6h) */
    intervalMs?: number;
    /** Max knowledge pages per tier (default: 100) */
    maxPagesPerTier?: number;
}
export interface KnowledgePage {
    slug: string;
    content: string;
    tier: 'workstation' | 'job' | 'industry';
    source: string;
    confidence: number;
    createdAt: string;
    updatedAt: string;
    usageCount: number;
    tags: string[];
}
export interface EvolveResult {
    extracted: number;
    deduplicated: number;
    promoted: number;
    compacted: boolean;
    errors: string[];
}
export declare class KnowledgeEvolveEngine {
    private config;
    private ollamaUrl;
    private model;
    private knowledgeDir;
    private conversationCount;
    private timer;
    constructor(agentDir: string, config?: Partial<EvolveConfig>);
    /** Auto-detect best local Ollama model for evolve tasks */
    detectLocalModel(): Promise<string>;
    /** Call local Ollama model, with fallback to configured API provider */
    private callLocal;
    /** Extract knowledge from conversation messages */
    extractFromConversation(messages: Array<{
        role: string;
        content: string;
    }>): Promise<KnowledgePage[]>;
    /** Deduplicate knowledge pages within a tier */
    deduplicateInTier(tier: 'workstation' | 'job' | 'industry'): Promise<number>;
    /** Promote knowledge upward: workstation → job → industry */
    promoteKnowledge(): Promise<number>;
    /**
     * Append refined insights to MEMORY.md (project root).
     * Called after each extraction cycle so the next restart picks up new knowledge.
     */
    writeBackToMemory(insights: string[]): void;
    /** Full evolve cycle: extract → dedup → compact memory → promote */
    evolve(recentMessages?: Array<{
        role: string;
        content: string;
    }>): Promise<EvolveResult>;
    /**
     * Layer 1: Compact agent memory
     * Read MEMORY.md → distill with local model → write back refined version
     * Result: memory never grows, only gets more concentrated
     */
    compactAgentMemory(): Promise<boolean>;
    /** Called after each conversation turn */
    onConversationTurn(messages: Array<{
        role: string;
        content: string;
    }>): void;
    /** Start periodic evolve timer */
    startPeriodicEvolve(): void;
    /** Stop periodic evolve */
    stopPeriodicEvolve(): void;
    /** Get stats for all tiers */
    getStats(): {
        workstation: number;
        job: number;
        industry: number;
        lastEvolve?: string;
    };
    private savePage;
    private loadPages;
    private deletePage;
    private saveEvolveLog;
    private getLastEvolveTime;
    private slugify;
}
/**
 * AutoEvolveScheduler — integrates with runtime
 */
export declare class AutoEvolveScheduler {
    private engine;
    constructor(agentDir: string, config?: Partial<EvolveConfig>);
    start(): Promise<void>;
    stop(): void;
    getEngine(): KnowledgeEvolveEngine;
}
//# sourceMappingURL=evolve-engine.d.ts.map