@ninebix/nmt-system 1.0.0

package/dist/services/four-stage-learning.js

@@ -0,0 +1,1110 @@
+/**
+ * Four-Stage Learning System
+ *
+ * Based on Probabilistic Ontology Framework:
+ * Stage 1: Extract Meaningful - 유의미 추출
+ * Stage 2: Learn Patterns - 패턴 학습
+ * Stage 3: Learn Process - 과정 학습 (AI reasoning process)
+ * Stage 4: Learn Outcomes - 결과 학습
+ *
+ * Extended with:
+ * - EventEmitter for real-time progress updates
+ * - Streaming session support
+ * - Auto-persistence
+ *
+ * @module services/four-stage-learning
+ */
+import { EventEmitter } from 'events';
+import { cosineSimilarity } from '../utils/similarity.js';
+import { generateUUID } from '../utils/uuid.js';
+import { TextEmbeddingService } from './text-embedding.js';
+/**
+ * Four-Stage Learning System
+ *
+ * Implements the complete learning loop based on probabilistic ontology:
+ * 1. **Extract Meaningful (유의미 추출)**: Identify important content segments
+ * 2. **Learn Patterns (패턴 학습)**: Discover recurring patterns from extracts
+ * 3. **Learn Process (과정 학습)**: Capture AI reasoning chains
+ * 4. **Learn Outcomes (결과 학습)**: Record and reinforce successful paths
+ *
+ * @example
+ * ```typescript
+ * const learning = new FourStageLearningSystem({
+ *   neuronStore: store,
+ *   graphManager: graph
+ * });
+ *
+ * // Start a learning session
+ * const session = learning.startSession();
+ *
+ * // Stage 1: Extract meaningful content
+ * const extracts = await learning.extractMeaningful(neuronId, content);
+ *
+ * // Stage 2: Learn patterns from extracts
+ * const patterns = await learning.learnPatterns(extracts.map(e => e.id));
+ *
+ * // Stage 3: Learn the reasoning process
+ * const process = await learning.learnProcess('search', processSteps);
+ *
+ * // Stage 4: Record outcome
+ * const outcome = await learning.learnOutcome(
+ *   process.id, inputId, outputId, true, 0.9
+ * );
+ *
+ * // End session and get metrics
+ * const finalSession = learning.endSession();
+ * console.log(`Patterns discovered: ${finalSession.metrics.patternsDiscovered}`);
+ * ```
+ *
+ * @see {@link MeaningfulExtract} for extract structure
+ * @see {@link LearnedPattern} for pattern structure
+ * @see {@link LearnedProcess} for process structure
+ */
+export class FourStageLearningSystem extends EventEmitter {
+    store;
+    graphManager;
+    importanceThreshold;
+    patternMinInstances;
+    processLearningEnabled;
+    // Real embedding service
+    embeddingService;
+    useRealEmbeddings;
+    // Storage for learned components
+    extracts = new Map();
+    patterns = new Map();
+    processes = new Map();
+    outcomes = new Map();
+    // Current learning session
+    currentSession = null;
+    // Auto-persistence
+    autoPersistStore = null;
+    autoPersistInterval = null;
+    autoPersistEnabled = false;
+    constructor(options) {
+        super();
+        this.store = options.neuronStore;
+        this.graphManager = options.graphManager;
+        this.importanceThreshold = options.importanceThreshold ?? 0.3;
+        this.patternMinInstances = options.patternMinInstances ?? 3;
+        this.processLearningEnabled = options.enableProcessLearning ?? true;
+        this.useRealEmbeddings = options.useRealEmbeddings ?? true;
+        // Initialize embedding service
+        this.embeddingService = new TextEmbeddingService(options.embeddingConfig ?? {
+            type: 'local'
+        });
+        this.setMaxListeners(50);
+    }
+    /**
+     * Start a new learning session.
+     *
+     * A session tracks all learning activities (extracts, patterns,
+     * processes, outcomes) and provides metrics upon completion.
+     *
+     * @returns The new LearningSession object
+     *
+     * @example
+     * ```typescript
+     * const session = learning.startSession();
+     * // ... perform learning activities ...
+     * const endedSession = learning.endSession();
+     * ```
+     */
+    startSession() {
+        this.currentSession = {
+            id: generateUUID(),
+            startedAt: new Date().toISOString(),
+            stages: {
+                extract: [],
+                patterns: [],
+                processes: [],
+                outcomes: []
+            },
+            metrics: {
+                totalExtracts: 0,
+                patternsDiscovered: 0,
+                processesLearned: 0,
+                outcomeSuccess: 0
+            }
+        };
+        this.emit('session:start', this.currentSession);
+        return this.currentSession;
+    }
+    /**
+     * Emit a progress event
+     */
+    emitProgress(stage, current, total, message, data) {
+        if (!this.currentSession)
+            return;
+        const event = {
+            sessionId: this.currentSession.id,
+            stage,
+            current,
+            total,
+            percentage: total > 0 ? (current / total) * 100 : 0,
+            message,
+            data,
+        };
+        this.emit('progress', event);
+    }
+    /**
+     * End current learning session
+     */
+    endSession() {
+        if (!this.currentSession)
+            return null;
+        this.currentSession.endedAt = new Date().toISOString();
+        // Calculate final metrics
+        this.currentSession.metrics = {
+            totalExtracts: this.currentSession.stages.extract.length,
+            patternsDiscovered: this.currentSession.stages.patterns.length,
+            processesLearned: this.currentSession.stages.processes.length,
+            outcomeSuccess: this.calculateSuccessRate(this.currentSession.stages.outcomes)
+        };
+        const session = this.currentSession;
+        this.currentSession = null;
+        this.emit('session:end', session);
+        // Auto-persist if enabled
+        if (this.autoPersistEnabled) {
+            this.persistNow().catch(err => {
+                this.emit('error', { error: err });
+            });
+        }
+        return session;
+    }
+    // ==================== Stage 1: Extract Meaningful ====================
+    /**
+     * Stage 1: Extract meaningful content from a neuron.
+     *
+     * Segments content into semantic units and evaluates importance.
+     * Only segments exceeding the importance threshold are extracted.
+     * Categories include: causal, conditional, procedural, definitional, general.
+     *
+     * @param neuronId - Source neuron ID
+     * @param content - Text content to extract meaningful segments from
+     * @returns Array of meaningful extracts with embeddings and keywords
+     *
+     * @example
+     * ```typescript
+     * const extracts = await learning.extractMeaningful(
+     *   'neuron-1',
+     *   'TypeScript is a typed superset of JavaScript. Because it adds static typing, it helps catch errors at compile time.'
+     * );
+     * // May return:
+     * // [{ category: 'definitional', content: 'TypeScript is...' },
+     * //  { category: 'causal', content: 'Because it adds...' }]
+     * ```
+     */
+    async extractMeaningful(neuronId, content) {
+        const neuron = await this.store.getNeuron(neuronId);
+        if (!neuron)
+            return [];
+        const extracts = [];
+        // Segment content into meaningful units
+        const segments = this.segmentContent(content);
+        const total = segments.length;
+        this.emitProgress('extract', 0, total, 'Starting extraction...');
+        for (let i = 0; i < segments.length; i++) {
+            const segment = segments[i];
+            // Calculate importance
+            const importance = this.calculateImportance(segment, neuron);
+            if (importance >= this.importanceThreshold) {
+                const extract = {
+                    id: generateUUID(),
+                    content: segment.text,
+                    embedding: await this.generateSegmentEmbedding(segment.text, neuron.embedding),
+                    importance,
+                    category: segment.category,
+                    sourceNeuronId: neuronId,
+                    extractedAt: new Date().toISOString(),
+                    keywords: this.extractKeywords(segment.text)
+                };
+                this.extracts.set(extract.id, extract);
+                extracts.push(extract);
+                this.emit('extract', extract);
+                if (this.currentSession) {
+                    this.currentSession.stages.extract.push(extract);
+                }
+            }
+            this.emitProgress('extract', i + 1, total, `Processed segment ${i + 1}/${total}`);
+        }
+        return extracts;
+    }
+    // ==================== Stage 2: Learn Patterns ====================
+    /**
+     * Stage 2: Learn patterns from extracts.
+     *
+     * Clusters similar extracts and identifies recurring patterns.
+     * Existing patterns are updated with new instances; new patterns
+     * are created when clusters don't match existing ones.
+     *
+     * @param extractIds - Array of MeaningfulExtract IDs to analyze
+     * @returns Array of learned or updated patterns
+     *
+     * @example
+     * ```typescript
+     * const patterns = await learning.learnPatterns([
+     *   'extract-1', 'extract-2', 'extract-3'
+     * ]);
+     *
+     * for (const pattern of patterns) {
+     *   console.log(`${pattern.name}: ${pattern.instances.length} instances`);
+     *   console.log(`Confidence: ${(pattern.confidence * 100).toFixed(1)}%`);
+     * }
+     * ```
+     */
+    async learnPatterns(extractIds) {
+        const extracts = extractIds
+            .map(id => this.extracts.get(id))
+            .filter((e) => e !== undefined);
+        if (extracts.length < this.patternMinInstances) {
+            return [];
+        }
+        this.emitProgress('patterns', 0, 1, 'Clustering extracts...');
+        // Cluster extracts by similarity
+        const clusters = this.clusterExtracts(extracts);
+        const newPatterns = [];
+        const total = clusters.length;
+        for (let i = 0; i < clusters.length; i++) {
+            const cluster = clusters[i];
+            if (cluster.length < this.patternMinInstances)
+                continue;
+            // Check if pattern already exists
+            const existingPattern = this.findSimilarPattern(cluster);
+            if (existingPattern) {
+                // Update existing pattern
+                existingPattern.instances.push(...cluster.map(e => e.id));
+                existingPattern.frequency = existingPattern.instances.length;
+                existingPattern.lastSeenAt = new Date().toISOString();
+                existingPattern.centroid = this.calculateCentroid(cluster.map(e => e.embedding));
+                newPatterns.push(existingPattern);
+                this.emit('pattern', existingPattern);
+            }
+            else {
+                // Create new pattern
+                const pattern = {
+                    id: generateUUID(),
+                    name: this.generatePatternName(cluster),
+                    description: this.generatePatternDescription(cluster),
+                    instances: cluster.map(e => e.id),
+                    centroid: this.calculateCentroid(cluster.map(e => e.embedding)),
+                    frequency: cluster.length,
+                    confidence: this.calculatePatternConfidence(cluster),
+                    createdAt: new Date().toISOString(),
+                    lastSeenAt: new Date().toISOString()
+                };
+                this.patterns.set(pattern.id, pattern);
+                newPatterns.push(pattern);
+                this.emit('pattern', pattern);
+                if (this.currentSession) {
+                    this.currentSession.stages.patterns.push(pattern);
+                }
+            }
+            this.emitProgress('patterns', i + 1, total, `Analyzed cluster ${i + 1}/${total}`);
+        }
+        return newPatterns;
+    }
+    // ==================== Stage 3: Learn Process ====================
+    /**
+     * Stage 3: Learn reasoning process from execution trace.
+     *
+     * Captures the AI's reasoning chain as a reusable process template.
+     * Similar processes are merged to increase confidence; new task
+     * types create new process templates.
+     *
+     * @param taskType - Type of task (e.g., 'search', 'create', 'explain')
+     * @param steps - Array of ProcessStep objects from execution
+     * @param inputPatternId - Optional ID of triggering pattern
+     * @returns The learned or updated process, or null if disabled/empty
+     *
+     * @example
+     * ```typescript
+     * const process = await learning.learnProcess('explain', [
+     *   { stepNumber: 1, action: 'analyze', input: 'question', output: 'concepts', reasoning: '...', duration: 100, success: true },
+     *   { stepNumber: 2, action: 'synthesize', input: 'concepts', output: 'explanation', reasoning: '...', duration: 200, success: true }
+     * ]);
+     *
+     * if (process) {
+     *   console.log(`Success rate: ${(process.successRate * 100).toFixed(0)}%`);
+     * }
+     * ```
+     */
+    async learnProcess(taskType, steps, inputPatternId) {
+        if (!this.processLearningEnabled)
+            return null;
+        if (steps.length === 0)
+            return null;
+        // Check if similar process exists
+        const existingProcess = this.findSimilarProcess(taskType, steps);
+        if (existingProcess) {
+            // Update existing process
+            existingProcess.totalExecutions++;
+            existingProcess.successRate = this.updateSuccessRate(existingProcess, steps.every(s => s.success));
+            existingProcess.averageDuration = this.updateAverageDuration(existingProcess, steps.reduce((sum, s) => sum + s.duration, 0));
+            existingProcess.updatedAt = new Date().toISOString();
+            return existingProcess;
+        }
+        // Create new process
+        const process = {
+            id: generateUUID(),
+            name: `${taskType}_process_${Date.now()}`,
+            taskType,
+            steps: this.normalizeSteps(steps),
+            inputPattern: inputPatternId ?? generateUUID(),
+            successRate: steps.every(s => s.success) ? 1.0 : 0.0,
+            totalExecutions: 1,
+            averageDuration: steps.reduce((sum, s) => sum + s.duration, 0),
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString()
+        };
+        this.processes.set(process.id, process);
+        if (this.currentSession) {
+            this.currentSession.stages.processes.push(process);
+        }
+        return process;
+    }
+    // ==================== Stage 4: Learn Outcomes ====================
+    /**
+     * Stage 4: Learn from outcomes.
+     *
+     * Records the result of a process execution and reinforces
+     * successful paths in the neuron graph. This creates a feedback
+     * loop for continuous improvement.
+     *
+     * @param processId - ID of the executed process
+     * @param inputNeuronId - Input neuron that triggered the process
+     * @param outputNeuronId - Output neuron (if any) produced
+     * @param success - Whether the outcome was successful
+     * @param quality - Quality score (0-1)
+     * @param feedback - Optional textual feedback
+     * @returns The recorded OutcomeRecord
+     *
+     * @example
+     * ```typescript
+     * const outcome = await learning.learnOutcome(
+     *   'process-1',
+     *   'input-neuron',
+     *   'output-neuron',
+     *   true,
+     *   0.95,
+     *   'Excellent response'
+     * );
+     * ```
+     */
+    async learnOutcome(processId, inputNeuronId, outputNeuronId, success, quality, feedback) {
+        const outcome = {
+            id: generateUUID(),
+            processId,
+            inputNeuronId,
+            outputNeuronId,
+            success,
+            quality,
+            feedback,
+            timestamp: new Date().toISOString()
+        };
+        this.outcomes.set(outcome.id, outcome);
+        // Update process success rate
+        const process = this.processes.get(processId);
+        if (process) {
+            process.successRate = this.updateSuccessRate(process, success);
+            process.updatedAt = new Date().toISOString();
+        }
+        // If successful, strengthen connections
+        if (success && outputNeuronId) {
+            await this.reinforceSuccessfulPath(inputNeuronId, outputNeuronId);
+        }
+        if (this.currentSession) {
+            this.currentSession.stages.outcomes.push(outcome);
+        }
+        return outcome;
+    }
+    // ==================== Full Learning Loop ====================
+    /**
+     * Execute full 4-stage learning loop.
+     *
+     * Convenience method that runs all four stages sequentially:
+     * extract → patterns → process → outcome. Use this for
+     * complete interaction learning with a single call.
+     *
+     * @param inputNeuronId - ID of the input neuron
+     * @param inputContent - Input text content
+     * @param processSteps - Reasoning steps taken
+     * @param outputNeuronId - Optional output neuron ID
+     * @param outputContent - Optional output text content
+     * @param success - Optional success indicator
+     * @param quality - Optional quality score (0-1)
+     * @returns Complete learning results from all four stages
+     *
+     * @example
+     * ```typescript
+     * const result = await learning.learnFromInteraction(
+     *   inputNeuronId,
+     *   'How do I sort an array?',
+     *   [{ action: 'search', ... }, { action: 'explain', ... }],
+     *   outputNeuronId,
+     *   'Here is how to sort...',
+     *   true,
+     *   0.9
+     * );
+     *
+     * console.log(`Extracts: ${result.extracts.length}`);
+     * console.log(`Patterns: ${result.patterns.length}`);
+     * ```
+     */
+    async learnFromInteraction(inputNeuronId, inputContent, processSteps, outputNeuronId, outputContent, success, quality) {
+        // Stage 1: Extract meaningful from input
+        const inputExtracts = await this.extractMeaningful(inputNeuronId, inputContent);
+        // Stage 1b: Extract from output if available
+        let outputExtracts = [];
+        if (outputNeuronId && outputContent) {
+            outputExtracts = await this.extractMeaningful(outputNeuronId, outputContent);
+        }
+        const allExtracts = [...inputExtracts, ...outputExtracts];
+        // Stage 2: Learn patterns
+        const patterns = await this.learnPatterns(allExtracts.map(e => e.id));
+        // Stage 3: Learn process
+        const process = await this.learnProcess(this.inferTaskType(inputContent), processSteps, patterns[0]?.id);
+        // Stage 4: Learn outcome
+        let outcome = null;
+        if (process && success !== undefined) {
+            outcome = await this.learnOutcome(process.id, inputNeuronId, outputNeuronId, success, quality ?? (success ? 0.8 : 0.2));
+        }
+        return {
+            extracts: allExtracts,
+            patterns,
+            process,
+            outcome
+        };
+    }
+    // ==================== Query Methods ====================
+    /**
+     * Get patterns relevant to a query
+     */
+    async findRelevantPatterns(queryEmbedding, topK = 5) {
+        const scored = Array.from(this.patterns.values())
+            .map(pattern => ({
+            pattern,
+            score: cosineSimilarity(queryEmbedding, pattern.centroid)
+        }))
+            .sort((a, b) => b.score - a.score);
+        return scored.slice(0, topK).map(s => s.pattern);
+    }
+    /**
+     * Get process for a task type
+     */
+    getProcessForTask(taskType) {
+        for (const process of this.processes.values()) {
+            if (process.taskType === taskType && process.successRate > 0.7) {
+                return process;
+            }
+        }
+        return null;
+    }
+    /**
+     * Get learning statistics
+     */
+    getStats() {
+        let totalConfidence = 0;
+        for (const pattern of this.patterns.values()) {
+            totalConfidence += pattern.confidence;
+        }
+        let totalSuccess = 0;
+        for (const process of this.processes.values()) {
+            totalSuccess += process.successRate;
+        }
+        return {
+            extracts: this.extracts.size,
+            patterns: this.patterns.size,
+            processes: this.processes.size,
+            outcomes: this.outcomes.size,
+            averagePatternConfidence: this.patterns.size > 0
+                ? totalConfidence / this.patterns.size
+                : 0,
+            averageProcessSuccess: this.processes.size > 0
+                ? totalSuccess / this.processes.size
+                : 0
+        };
+    }
+    // ==================== Private Methods ====================
+    segmentContent(content) {
+        // Split by sentences and meaningful boundaries
+        const segments = [];
+        // Split by paragraphs first
+        const paragraphs = content.split(/\n\n+/);
+        for (const para of paragraphs) {
+            // Split by sentences
+            const sentences = para.split(/(?<=[.!?。！？])\s+/);
+            for (const sentence of sentences) {
+                if (sentence.trim().length < 10)
+                    continue;
+                segments.push({
+                    text: sentence.trim(),
+                    category: this.categorizeSegment(sentence)
+                });
+            }
+        }
+        return segments;
+    }
+    categorizeSegment(text) {
+        const lower = text.toLowerCase();
+        if (/\b(because|therefore|thus|hence|so)\b/.test(lower) ||
+            /때문에|따라서|그러므로/.test(text)) {
+            return 'causal';
+        }
+        if (/\b(if|when|unless|condition)\b/.test(lower) ||
+            /만약|조건|경우/.test(text)) {
+            return 'conditional';
+        }
+        if (/\b(how to|steps|process|method)\b/.test(lower) ||
+            /방법|절차|과정/.test(text)) {
+            return 'procedural';
+        }
+        if (/\b(is|are|was|were|definition)\b/.test(lower) ||
+            /은|는|이다|정의/.test(text)) {
+            return 'definitional';
+        }
+        return 'general';
+    }
+    calculateImportance(segment, neuron) {
+        let importance = 0.5;
+        // Category bonus
+        const categoryWeights = {
+            'causal': 0.3,
+            'procedural': 0.25,
+            'conditional': 0.2,
+            'definitional': 0.15,
+            'general': 0
+        };
+        importance += categoryWeights[segment.category] ?? 0;
+        // Length bonus (longer usually more informative, up to a point)
+        const wordCount = segment.text.split(/\s+/).length;
+        importance += Math.min(0.2, wordCount / 100);
+        // Access count bonus from source neuron
+        importance += Math.min(0.1, neuron.metadata.accessCount / 100);
+        return Math.min(1, importance);
+    }
+    /**
+     * Generate semantic embedding for a text segment.
+     *
+     * Uses the TextEmbeddingService with multiple strategies:
+     * 1. TF-IDF weighted word vectors
+     * 2. Character n-gram hashing
+     * 3. Positional encoding
+     * 4. Semantic category detection
+     * 5. Context blending with base embedding
+     *
+     * Falls back to simple hash-based embedding if disabled.
+     */
+    async generateSegmentEmbedding(segmentText, baseEmbedding) {
+        // Use real embedding service if enabled
+        if (this.useRealEmbeddings) {
+            try {
+                const response = await this.embeddingService.embed({
+                    text: segmentText,
+                    contextEmbedding: baseEmbedding
+                });
+                // Blend with context for coherence
+                const blended = new Float32Array(baseEmbedding.length);
+                for (let i = 0; i < blended.length; i++) {
+                    // 80% from embedding service, 20% context
+                    blended[i] = response.embedding[i] * 0.8 + baseEmbedding[i] * 0.2;
+                }
+                // Normalize
+                let norm = 0;
+                for (let i = 0; i < blended.length; i++) {
+                    norm += blended[i] * blended[i];
+                }
+                norm = Math.sqrt(norm);
+                if (norm > 0) {
+                    for (let i = 0; i < blended.length; i++) {
+                        blended[i] /= norm;
+                    }
+                }
+                return blended;
+            }
+            catch (error) {
+                // Fallback to hash-based embedding on error
+                this.emit('error', {
+                    error: error,
+                    stage: 'extract'
+                });
+            }
+        }
+        // Fallback: hash-based embedding
+        const embedding = new Float32Array(baseEmbedding.length);
+        let hash = 0;
+        for (let i = 0; i < segmentText.length; i++) {
+            hash = ((hash << 5) - hash) + segmentText.charCodeAt(i);
+            hash |= 0;
+        }
+        for (let i = 0; i < embedding.length; i++) {
+            // Mix base embedding with text-derived values
+            embedding[i] = baseEmbedding[i] * 0.7 +
+                (((hash >> (i % 32)) & 0xFF) / 255 - 0.5) * 0.3;
+        }
+        // Normalize
+        let norm = 0;
+        for (let i = 0; i < embedding.length; i++) {
+            norm += embedding[i] * embedding[i];
+        }
+        norm = Math.sqrt(norm);
+        for (let i = 0; i < embedding.length; i++) {
+            embedding[i] /= norm;
+        }
+        return embedding;
+    }
+    /**
+     * Update embedding service vocabulary from corpus
+     */
+    updateEmbeddingVocabulary(documents) {
+        this.embeddingService.updateVocabulary(documents);
+    }
+    /**
+     * Get embedding service statistics
+     */
+    getEmbeddingStats() {
+        return this.embeddingService.getStats();
+    }
+    /**
+     * Configure embedding provider (for API-based embeddings)
+     */
+    configureEmbeddingProvider(config) {
+        this.embeddingService = new TextEmbeddingService(config);
+    }
+    extractKeywords(text) {
+        const words = text
+            .toLowerCase()
+            .replace(/[^\w\s가-힣]/g, '')
+            .split(/\s+/)
+            .filter(w => w.length > 2);
+        const stopwords = new Set([
+            'the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been',
+            '이', '가', '은', '는', '을', '를', '의', '에', '에서'
+        ]);
+        return words.filter(w => !stopwords.has(w)).slice(0, 10);
+    }
+    clusterExtracts(extracts) {
+        // Simple greedy clustering by similarity
+        const clusters = [];
+        const assigned = new Set();
+        for (const extract of extracts) {
+            if (assigned.has(extract.id))
+                continue;
+            const cluster = [extract];
+            assigned.add(extract.id);
+            for (const other of extracts) {
+                if (assigned.has(other.id))
+                    continue;
+                const similarity = cosineSimilarity(extract.embedding, other.embedding);
+                if (similarity > 0.7) {
+                    cluster.push(other);
+                    assigned.add(other.id);
+                }
+            }
+            clusters.push(cluster);
+        }
+        return clusters;
+    }
+    findSimilarPattern(cluster) {
+        const centroid = this.calculateCentroid(cluster.map(e => e.embedding));
+        for (const pattern of this.patterns.values()) {
+            const similarity = cosineSimilarity(centroid, pattern.centroid);
+            if (similarity > 0.85) {
+                return pattern;
+            }
+        }
+        return null;
+    }
+    calculateCentroid(embeddings) {
+        if (embeddings.length === 0) {
+            return new Float32Array(384);
+        }
+        const centroid = new Float32Array(embeddings[0].length);
+        for (const embedding of embeddings) {
+            for (let i = 0; i < centroid.length; i++) {
+                centroid[i] += embedding[i];
+            }
+        }
+        for (let i = 0; i < centroid.length; i++) {
+            centroid[i] /= embeddings.length;
+        }
+        return centroid;
+    }
+    generatePatternName(cluster) {
+        // Use most frequent keywords
+        const keywordCounts = new Map();
+        for (const extract of cluster) {
+            for (const keyword of extract.keywords) {
+                keywordCounts.set(keyword, (keywordCounts.get(keyword) ?? 0) + 1);
+            }
+        }
+        const topKeywords = Array.from(keywordCounts.entries())
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 3)
+            .map(([k]) => k);
+        return topKeywords.join('_') || 'unnamed_pattern';
+    }
+    generatePatternDescription(cluster) {
+        const categories = [...new Set(cluster.map(e => e.category))];
+        return `Pattern from ${cluster.length} instances, categories: ${categories.join(', ')}`;
+    }
+    calculatePatternConfidence(cluster) {
+        if (cluster.length < this.patternMinInstances)
+            return 0;
+        // Higher confidence with more instances and higher importance
+        const avgImportance = cluster.reduce((sum, e) => sum + e.importance, 0) / cluster.length;
+        const sizeBonus = Math.min(0.3, cluster.length / 20);
+        return Math.min(1, avgImportance * 0.7 + sizeBonus);
+    }
+    findSimilarProcess(taskType, steps) {
+        for (const process of this.processes.values()) {
+            if (process.taskType !== taskType)
+                continue;
+            // Compare step structure
+            if (Math.abs(process.steps.length - steps.length) <= 2) {
+                const actionMatch = this.compareStepActions(process.steps, steps);
+                if (actionMatch > 0.7) {
+                    return process;
+                }
+            }
+        }
+        return null;
+    }
+    compareStepActions(stepsA, stepsB) {
+        const actionsA = new Set(stepsA.map(s => s.action.toLowerCase()));
+        const actionsB = new Set(stepsB.map(s => s.action.toLowerCase()));
+        const intersection = new Set([...actionsA].filter(x => actionsB.has(x)));
+        const union = new Set([...actionsA, ...actionsB]);
+        return intersection.size / union.size;
+    }
+    normalizeSteps(steps) {
+        return steps.map((step, index) => ({
+            ...step,
+            stepNumber: index + 1
+        }));
+    }
+    updateSuccessRate(process, success) {
+        const totalSuccess = process.successRate * process.totalExecutions + (success ? 1 : 0);
+        return totalSuccess / (process.totalExecutions + 1);
+    }
+    updateAverageDuration(process, duration) {
+        const totalDuration = process.averageDuration * process.totalExecutions + duration;
+        return totalDuration / (process.totalExecutions + 1);
+    }
+    async reinforceSuccessfulPath(inputId, outputId) {
+        // Strengthen connection between input and output
+        const existingConnection = await this.graphManager.getConnection(inputId, outputId);
+        if (existingConnection) {
+            await this.graphManager.strengthenSynapse(existingConnection.id, 0.05);
+        }
+        else {
+            // Create new connection
+            await this.graphManager.connect(inputId, outputId, 'CAUSAL', 0.5, true);
+        }
+    }
+    inferTaskType(content) {
+        const lower = content.toLowerCase();
+        if (/search|find|look|검색|찾/.test(lower))
+            return 'search';
+        if (/create|make|build|생성|만들/.test(lower))
+            return 'create';
+        if (/fix|debug|repair|수정|고치/.test(lower))
+            return 'fix';
+        if (/explain|describe|설명/.test(lower))
+            return 'explain';
+        if (/analyze|분석/.test(lower))
+            return 'analyze';
+        return 'general';
+    }
+    calculateSuccessRate(outcomes) {
+        if (outcomes.length === 0)
+            return 0;
+        const successes = outcomes.filter(o => o.success).length;
+        return successes / outcomes.length;
+    }
+    // ==================== Streaming Methods ====================
+    /**
+     * Stream a learning session with real-time progress updates
+     *
+     * Yields progress events as the learning progresses through all stages.
+     *
+     * @param inputNeuronId - Input neuron ID
+     * @param inputContent - Input content to learn from
+     * @param processSteps - Optional reasoning steps
+     * @yields LearningProgressEvent for each stage
+     *
+     * @example
+     * ```typescript
+     * for await (const progress of learning.streamSession(neuronId, content)) {
+     *   console.log(`${progress.stage}: ${progress.percentage.toFixed(0)}%`);
+     * }
+     * ```
+     */
+    async *streamSession(inputNeuronId, inputContent, processSteps) {
+        // Start session
+        const session = this.startSession();
+        const createProgress = (stage, current, total, message) => ({
+            sessionId: session.id,
+            stage,
+            current,
+            total,
+            percentage: total > 0 ? (current / total) * 100 : 0,
+            message,
+        });
+        try {
+            // Stage 1: Extract
+            yield createProgress('extract', 0, 100, 'Starting extraction...');
+            const extracts = await this.extractMeaningful(inputNeuronId, inputContent);
+            yield createProgress('extract', 100, 100, `Extracted ${extracts.length} meaningful segments`);
+            // Stage 2: Patterns
+            yield createProgress('patterns', 0, 100, 'Learning patterns...');
+            const patterns = await this.learnPatterns(extracts.map(e => e.id));
+            yield createProgress('patterns', 100, 100, `Discovered ${patterns.length} patterns`);
+            // Stage 3: Process (if steps provided)
+            if (processSteps && processSteps.length > 0) {
+                yield createProgress('process', 0, 100, 'Learning process...');
+                const process = await this.learnProcess(this.inferTaskType(inputContent), processSteps, patterns[0]?.id);
+                yield createProgress('process', 100, 100, process ? 'Process learned' : 'Process skipped');
+            }
+            // Stage 4: Outcomes (recorded separately)
+            yield createProgress('outcomes', 0, 100, 'Finalizing...');
+            // End session
+            this.endSession();
+            yield createProgress('outcomes', 100, 100, 'Session complete');
+        }
+        catch (error) {
+            this.emit('error', {
+                sessionId: session.id,
+                error: error,
+            });
+            throw error;
+        }
+    }
+    /**
+     * Get current session ID if any
+     */
+    getCurrentSessionId() {
+        return this.currentSession?.id ?? null;
+    }
+    /**
+     * Check if a session is active
+     */
+    hasActiveSession() {
+        return this.currentSession !== null;
+    }
+    // ==================== Auto-Persistence Methods ====================
+    /**
+     * Enable auto-persistence
+     *
+     * @param store - ProbabilisticStore to persist to
+     * @param intervalMs - Interval between auto-saves (default: 60000 = 1 minute)
+     *
+     * @example
+     * ```typescript
+     * learning.enableAutoPersist(store, 30000); // Save every 30 seconds
+     * ```
+     */
+    enableAutoPersist(store, intervalMs = 60000) {
+        this.autoPersistStore = store;
+        this.autoPersistEnabled = true;
+        // Clear existing interval if any
+        if (this.autoPersistInterval) {
+            clearInterval(this.autoPersistInterval);
+        }
+        // Start auto-persist interval
+        this.autoPersistInterval = setInterval(() => {
+            this.persistNow().catch(err => {
+                this.emit('error', { error: err });
+            });
+        }, intervalMs);
+    }
+    /**
+     * Disable auto-persistence
+     */
+    disableAutoPersist() {
+        this.autoPersistEnabled = false;
+        if (this.autoPersistInterval) {
+            clearInterval(this.autoPersistInterval);
+            this.autoPersistInterval = null;
+        }
+    }
+    /**
+     * Persist current state immediately
+     */
+    async persistNow() {
+        if (!this.autoPersistStore) {
+            throw new Error('Auto-persist store not configured');
+        }
+        const data = this.serialize();
+        await this.autoPersistStore.saveLearning(data);
+    }
+    /**
+     * Load state from persistent store
+     */
+    async loadFromStore(store) {
+        const data = await store.loadLearning();
+        if (data) {
+            this.load(data);
+            return true;
+        }
+        return false;
+    }
+    // ==================== Persistence Methods ====================
+    /**
+     * Serialize learning system state for persistence.
+     *
+     * Converts all extracts, patterns, processes, outcomes, and
+     * the current session to a JSON-serializable format.
+     *
+     * @returns Serialized state object for storage
+     * @see {@link load} for restoring state
+     */
+    serialize() {
+        return {
+            extracts: Array.from(this.extracts.entries()).map(([id, extract]) => ({
+                ...extract,
+                embedding: Array.from(extract.embedding)
+            })),
+            patterns: Array.from(this.patterns.entries()).map(([id, pattern]) => ({
+                ...pattern,
+                centroid: Array.from(pattern.centroid)
+            })),
+            processes: Array.from(this.processes.entries()),
+            outcomes: Array.from(this.outcomes.entries()),
+            currentSession: this.currentSession ? {
+                ...this.currentSession,
+                stages: {
+                    extract: this.currentSession.stages.extract.map(e => ({
+                        ...e,
+                        embedding: Array.from(e.embedding)
+                    })),
+                    patterns: this.currentSession.stages.patterns.map(p => ({
+                        ...p,
+                        centroid: Array.from(p.centroid)
+                    })),
+                    processes: this.currentSession.stages.processes,
+                    outcomes: this.currentSession.stages.outcomes
+                }
+            } : null
+        };
+    }
+    /**
+     * Load learning system state from serialized data.
+     *
+     * Restores all extracts, patterns, processes, outcomes, and
+     * session state. Embeddings/centroids are converted to Float32Array.
+     *
+     * @param data - Previously serialized learning system state
+     * @see {@link serialize} for creating serialized state
+     */
+    load(data) {
+        // Restore extracts with Float32Array embeddings
+        this.extracts.clear();
+        for (const extractData of data.extracts ?? []) {
+            const item = extractData;
+            const entry = Array.isArray(item) ? item : [item.id, item];
+            const id = entry[0];
+            const extract = entry[1];
+            this.extracts.set(id, {
+                ...extract,
+                embedding: extract.embedding instanceof Float32Array
+                    ? extract.embedding
+                    : new Float32Array(extract.embedding)
+            });
+        }
+        // Restore patterns with Float32Array centroids
+        this.patterns.clear();
+        for (const patternData of data.patterns ?? []) {
+            const item = patternData;
+            const entry = Array.isArray(item) ? item : [item.id, item];
+            const id = entry[0];
+            const pattern = entry[1];
+            this.patterns.set(id, {
+                ...pattern,
+                centroid: pattern.centroid instanceof Float32Array
+                    ? pattern.centroid
+                    : new Float32Array(pattern.centroid)
+            });
+        }
+        // Restore processes
+        this.processes.clear();
+        for (const processData of data.processes ?? []) {
+            const item = processData;
+            const entry = Array.isArray(item) ? item : [item.id, item];
+            const id = entry[0];
+            const process = entry[1];
+            this.processes.set(id, process);
+        }
+        // Restore outcomes
+        this.outcomes.clear();
+        for (const outcomeData of data.outcomes ?? []) {
+            const item = outcomeData;
+            const entry = Array.isArray(item) ? item : [item.id, item];
+            const id = entry[0];
+            const outcome = entry[1];
+            this.outcomes.set(id, outcome);
+        }
+        // Restore current session if exists
+        if (data.currentSession) {
+            this.currentSession = {
+                ...data.currentSession,
+                stages: {
+                    extract: (data.currentSession.stages?.extract ?? []).map((e) => ({
+                        ...e,
+                        embedding: e.embedding instanceof Float32Array
+                            ? e.embedding
+                            : new Float32Array(e.embedding)
+                    })),
+                    patterns: (data.currentSession.stages?.patterns ?? []).map((p) => ({
+                        ...p,
+                        centroid: p.centroid instanceof Float32Array
+                            ? p.centroid
+                            : new Float32Array(p.centroid)
+                    })),
+                    processes: data.currentSession.stages?.processes ?? [],
+                    outcomes: data.currentSession.stages?.outcomes ?? []
+                }
+            };
+        }
+    }
+    // ==================== Cleanup Methods ====================
+    /**
+     * Dispose of all resources held by the learning system.
+     *
+     * Call this when the learning system is no longer needed to:
+     * - Stop auto-persistence intervals
+     * - Remove all event listeners
+     * - Clear all stored data
+     *
+     * After calling dispose(), the instance should not be used again.
+     *
+     * @example
+     * ```typescript
+     * const learning = new FourStageLearningSystem(options);
+     * // ... use the learning system ...
+     *
+     * // Clean up when done
+     * learning.dispose();
+     * ```
+     */
+    dispose() {
+        // Stop auto-persistence
+        this.disableAutoPersist();
+        this.autoPersistStore = null;
+        // Remove all event listeners
+        this.removeAllListeners();
+        // Clear all data
+        this.extracts.clear();
+        this.patterns.clear();
+        this.processes.clear();
+        this.outcomes.clear();
+        // End current session if any
+        this.currentSession = null;
+    }
+}
+/**
+ * Create a FourStageLearningSystem instance
+ */
+export function createFourStageLearningSystem(options) {
+    return new FourStageLearningSystem(options);
+}
+//# sourceMappingURL=four-stage-learning.js.map