@ninebix/nmt-system 1.0.2 → 1.0.3

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

@@ -1,1110 +0,0 @@
-/**
- * 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