monomind 1.6.0 → 1.6.1

package/.claude/helpers/learning-service.mjs

@@ -1,1144 +0,0 @@
-#!/usr/bin/env node
-/**
- * Monomind V1 - Persistent Learning Service
- *
- * Connects ReasoningBank to AgentDB with HNSW indexing and ONNX embeddings.
- *
- * Features:
- * - Persistent pattern storage via AgentDB
- * - HNSW indexing for 150x-12,500x faster search
- * - ONNX embeddings via agentic-flow@alpha
- * - Session-level pattern loading and consolidation
- * - Short-term → Long-term pattern promotion
- *
- * Performance Targets:
- * - Pattern search: <1ms (HNSW)
- * - Embedding generation: <10ms (ONNX)
- * - Pattern storage: <5ms
- */
-
-import { createRequire } from 'module';
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-import { execSync, spawn } from 'child_process';
-import Database from 'better-sqlite3';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const PROJECT_ROOT = join(__dirname, '../..');
-const DATA_DIR = join(PROJECT_ROOT, '.monomind/learning');
-const DB_PATH = join(DATA_DIR, 'patterns.db');
-const METRICS_PATH = join(DATA_DIR, 'learning-metrics.json');
-
-// Ensure data directory exists
-if (!existsSync(DATA_DIR)) {
-  mkdirSync(DATA_DIR, { recursive: true });
-}
-
-// =============================================================================
-// Configuration
-// =============================================================================
-
-const CONFIG = {
-  // HNSW parameters
-  hnsw: {
-    M: 16,                    // Max connections per layer
-    efConstruction: 200,      // Construction time accuracy
-    efSearch: 100,            // Search time accuracy
-    metric: 'cosine',         // Distance metric
-  },
-
-  // Pattern management
-  patterns: {
-    shortTermMaxAge: 24 * 60 * 60 * 1000,  // 24 hours
-    promotionThreshold: 3,    // Uses before promotion to long-term
-    qualityThreshold: 0.6,    // Min quality for storage
-    maxShortTerm: 500,        // Max short-term patterns
-    maxLongTerm: 2000,        // Max long-term patterns
-    dedupThreshold: 0.95,     // Similarity for dedup
-  },
-
-  // Embedding
-  embedding: {
-    dimension: 384,           // MiniLM-L6 dimension
-    model: 'all-MiniLM-L6-v2', // ONNX model
-    batchSize: 32,            // Batch size for embedding
-  },
-
-  // Consolidation
-  consolidation: {
-    interval: 30 * 60 * 1000, // 30 minutes
-    pruneAge: 30 * 24 * 60 * 60 * 1000, // 30 days
-    minUsageForKeep: 2,       // Min uses to keep old pattern
-  },
-};
-
-// =============================================================================
-// Database Schema
-// =============================================================================
-
-function initializeDatabase(db) {
-  db.exec(`
-    -- Short-term patterns (session-level)
-    CREATE TABLE IF NOT EXISTS short_term_patterns (
-      id TEXT PRIMARY KEY,
-      strategy TEXT NOT NULL,
-      domain TEXT DEFAULT 'general',
-      embedding BLOB NOT NULL,
-      quality REAL DEFAULT 0.5,
-      usage_count INTEGER DEFAULT 0,
-      success_count INTEGER DEFAULT 0,
-      created_at INTEGER NOT NULL,
-      updated_at INTEGER NOT NULL,
-      session_id TEXT,
-      trajectory_id TEXT,
-      metadata TEXT
-    );
-
-    -- Long-term patterns (promoted from short-term)
-    CREATE TABLE IF NOT EXISTS long_term_patterns (
-      id TEXT PRIMARY KEY,
-      strategy TEXT NOT NULL,
-      domain TEXT DEFAULT 'general',
-      embedding BLOB NOT NULL,
-      quality REAL DEFAULT 0.5,
-      usage_count INTEGER DEFAULT 0,
-      success_count INTEGER DEFAULT 0,
-      created_at INTEGER NOT NULL,
-      updated_at INTEGER NOT NULL,
-      promoted_at INTEGER,
-      source_pattern_id TEXT,
-      quality_history TEXT,
-      metadata TEXT
-    );
-
-    -- HNSW index metadata
-    CREATE TABLE IF NOT EXISTS hnsw_index (
-      id INTEGER PRIMARY KEY,
-      pattern_type TEXT NOT NULL,  -- 'short_term' or 'long_term'
-      pattern_id TEXT NOT NULL,
-      vector_id INTEGER NOT NULL,
-      created_at INTEGER NOT NULL,
-      UNIQUE(pattern_type, pattern_id)
-    );
-
-    -- Learning trajectories
-    CREATE TABLE IF NOT EXISTS trajectories (
-      id TEXT PRIMARY KEY,
-      session_id TEXT NOT NULL,
-      domain TEXT DEFAULT 'general',
-      steps TEXT NOT NULL,
-      quality_score REAL,
-      verdict TEXT,
-      started_at INTEGER NOT NULL,
-      ended_at INTEGER,
-      distilled_pattern_id TEXT
-    );
-
-    -- Learning metrics
-    CREATE TABLE IF NOT EXISTS learning_metrics (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      timestamp INTEGER NOT NULL,
-      metric_type TEXT NOT NULL,
-      metric_name TEXT NOT NULL,
-      metric_value REAL NOT NULL,
-      metadata TEXT
-    );
-
-    -- Session state
-    CREATE TABLE IF NOT EXISTS session_state (
-      key TEXT PRIMARY KEY,
-      value TEXT NOT NULL,
-      updated_at INTEGER NOT NULL
-    );
-
-    -- Create indexes
-    CREATE INDEX IF NOT EXISTS idx_short_term_domain ON short_term_patterns(domain);
-    CREATE INDEX IF NOT EXISTS idx_short_term_quality ON short_term_patterns(quality DESC);
-    CREATE INDEX IF NOT EXISTS idx_short_term_usage ON short_term_patterns(usage_count DESC);
-    CREATE INDEX IF NOT EXISTS idx_long_term_domain ON long_term_patterns(domain);
-    CREATE INDEX IF NOT EXISTS idx_long_term_quality ON long_term_patterns(quality DESC);
-    CREATE INDEX IF NOT EXISTS idx_trajectories_session ON trajectories(session_id);
-    CREATE INDEX IF NOT EXISTS idx_metrics_type ON learning_metrics(metric_type, timestamp);
-  `);
-}
-
-// =============================================================================
-// HNSW Index (In-Memory with SQLite persistence)
-// =============================================================================
-
-class HNSWIndex {
-  constructor(config) {
-    this.config = config;
-    this.vectors = new Map();      // id -> Float32Array
-    this.idToVector = new Map();   // patternId -> vectorId
-    this.vectorToId = new Map();   // vectorId -> patternId
-    this.nextVectorId = 0;
-    this.dimension = config.embedding.dimension;
-
-    // Graph structure for HNSW
-    this.layers = [];              // Multi-layer graph
-    this.entryPoint = null;
-    this.maxLevel = 0;
-  }
-
-  // Add vector to index
-  add(patternId, embedding) {
-    const vectorId = this.nextVectorId++;
-    const vector = embedding instanceof Float32Array
-      ? embedding
-      : new Float32Array(embedding);
-
-    this.vectors.set(vectorId, vector);
-    this.idToVector.set(patternId, vectorId);
-    this.vectorToId.set(vectorId, patternId);
-
-    // Simple HNSW insertion (simplified for performance)
-    this._insertIntoGraph(vectorId, vector);
-
-    return vectorId;
-  }
-
-  // Search for k nearest neighbors
-  search(queryEmbedding, k = 5) {
-    const query = queryEmbedding instanceof Float32Array
-      ? queryEmbedding
-      : new Float32Array(queryEmbedding);
-
-    if (this.vectors.size === 0) return { results: [], searchTimeMs: 0 };
-
-    const startTime = performance.now();
-
-    // HNSW search with early termination
-    const candidates = this._searchGraph(query, k * 2);
-
-    // Sort by similarity and take top k
-    const results = candidates
-      .map(({ vectorId, distance }) => ({
-        patternId: this.vectorToId.get(vectorId),
-        similarity: 1 - distance,
-        vectorId,
-      }))
-      .sort((a, b) => b.similarity - a.similarity)
-      .slice(0, k);
-
-    const searchTime = performance.now() - startTime;
-
-    return { results, searchTimeMs: searchTime };
-  }
-
-  // Remove vector from index
-  remove(patternId) {
-    const vectorId = this.idToVector.get(patternId);
-    if (vectorId === undefined) return false;
-
-    this.vectors.delete(vectorId);
-    this.idToVector.delete(patternId);
-    this.vectorToId.delete(vectorId);
-    this._removeFromGraph(vectorId);
-
-    return true;
-  }
-
-  // Get index size
-  size() {
-    return this.vectors.size;
-  }
-
-  // Cosine similarity
-  _cosineSimilarity(a, b) {
-    let dot = 0, normA = 0, normB = 0;
-    for (let i = 0; i < a.length; i++) {
-      dot += a[i] * b[i];
-      normA += a[i] * a[i];
-      normB += b[i] * b[i];
-    }
-    const denom = Math.sqrt(normA) * Math.sqrt(normB);
-    return denom > 0 ? dot / denom : 0;
-  }
-
-  // Cosine distance
-  _cosineDistance(a, b) {
-    return 1 - this._cosineSimilarity(a, b);
-  }
-
-  // Insert into graph (simplified HNSW)
-  _insertIntoGraph(vectorId, vector) {
-    if (this.entryPoint === null) {
-      this.entryPoint = vectorId;
-      this.layers.push(new Map([[vectorId, new Set()]]));
-      return;
-    }
-
-    // For simplicity, use single-layer graph with neighbor limit
-    if (this.layers.length === 0) {
-      this.layers.push(new Map());
-    }
-
-    const layer = this.layers[0];
-    layer.set(vectorId, new Set());
-
-    // Find M nearest neighbors and connect
-    const neighbors = this._findNearest(vector, this.config.hnsw.M);
-    for (const { vectorId: neighborId } of neighbors) {
-      layer.get(vectorId).add(neighborId);
-      layer.get(neighborId)?.add(vectorId);
-
-      // Prune if too many connections
-      if (layer.get(neighborId)?.size > this.config.hnsw.M * 2) {
-        this._pruneConnections(neighborId);
-      }
-    }
-  }
-
-  // Search graph for nearest neighbors
-  _searchGraph(query, k) {
-    if (this.vectors.size <= k) {
-      // Brute force for small index
-      return Array.from(this.vectors.entries())
-        .map(([vectorId, vector]) => ({
-          vectorId,
-          distance: this._cosineDistance(query, vector),
-        }))
-        .sort((a, b) => a.distance - b.distance);
-    }
-
-    // Greedy search from entry point
-    const visited = new Set();
-    const candidates = new Map();
-    const results = [];
-
-    let current = this.entryPoint;
-    let currentDist = this._cosineDistance(query, this.vectors.get(current));
-
-    candidates.set(current, currentDist);
-    results.push({ vectorId: current, distance: currentDist });
-
-    const layer = this.layers[0];
-    let improved = true;
-    let iterations = 0;
-    const maxIterations = this.config.hnsw.efSearch;
-
-    while (improved && iterations < maxIterations) {
-      improved = false;
-      iterations++;
-
-      // Get best unvisited candidate
-      let bestCandidate = null;
-      let bestDist = Infinity;
-
-      for (const [id, dist] of candidates) {
-        if (!visited.has(id) && dist < bestDist) {
-          bestDist = dist;
-          bestCandidate = id;
-        }
-      }
-
-      if (bestCandidate === null) break;
-
-      visited.add(bestCandidate);
-      const neighbors = layer.get(bestCandidate) || new Set();
-
-      for (const neighborId of neighbors) {
-        if (visited.has(neighborId)) continue;
-
-        const neighborVector = this.vectors.get(neighborId);
-        if (!neighborVector) continue;
-
-        const dist = this._cosineDistance(query, neighborVector);
-
-        if (!candidates.has(neighborId) || candidates.get(neighborId) > dist) {
-          candidates.set(neighborId, dist);
-          results.push({ vectorId: neighborId, distance: dist });
-          improved = true;
-        }
-      }
-    }
-
-    return results.sort((a, b) => a.distance - b.distance).slice(0, k);
-  }
-
-  // Find k nearest by brute force
-  _findNearest(query, k) {
-    return Array.from(this.vectors.entries())
-      .map(([vectorId, vector]) => ({
-        vectorId,
-        distance: this._cosineDistance(query, vector),
-      }))
-      .sort((a, b) => a.distance - b.distance)
-      .slice(0, k);
-  }
-
-  // Prune excess connections
-  _pruneConnections(vectorId) {
-    const layer = this.layers[0];
-    const connections = layer.get(vectorId);
-    if (!connections || connections.size <= this.config.hnsw.M) return;
-
-    const vector = this.vectors.get(vectorId);
-    const scored = Array.from(connections)
-      .map(neighborId => ({
-        neighborId,
-        distance: this._cosineDistance(vector, this.vectors.get(neighborId)),
-      }))
-      .sort((a, b) => a.distance - b.distance);
-
-    // Keep only M nearest
-    const toRemove = scored.slice(this.config.hnsw.M);
-    for (const { neighborId } of toRemove) {
-      connections.delete(neighborId);
-      layer.get(neighborId)?.delete(vectorId);
-    }
-  }
-
-  // Remove from graph
-  _removeFromGraph(vectorId) {
-    const layer = this.layers[0];
-    const connections = layer.get(vectorId);
-
-    if (connections) {
-      for (const neighborId of connections) {
-        layer.get(neighborId)?.delete(vectorId);
-      }
-    }
-
-    layer.delete(vectorId);
-
-    if (this.entryPoint === vectorId) {
-      this.entryPoint = layer.size > 0 ? layer.keys().next().value : null;
-    }
-  }
-
-  // Serialize index for persistence
-  serialize() {
-    return {
-      vectors: Array.from(this.vectors.entries()).map(([id, vec]) => [id, Array.from(vec)]),
-      idToVector: Array.from(this.idToVector.entries()),
-      vectorToId: Array.from(this.vectorToId.entries()),
-      nextVectorId: this.nextVectorId,
-      entryPoint: this.entryPoint,
-      layers: this.layers.map(layer =>
-        Array.from(layer.entries()).map(([k, v]) => [k, Array.from(v)])
-      ),
-    };
-  }
-
-  // Deserialize index
-  static deserialize(data, config) {
-    const index = new HNSWIndex(config);
-
-    if (!data) return index;
-
-    index.vectors = new Map(data.vectors?.map(([id, vec]) => [id, new Float32Array(vec)]) || []);
-    index.idToVector = new Map(data.idToVector || []);
-    index.vectorToId = new Map(data.vectorToId || []);
-    index.nextVectorId = data.nextVectorId || 0;
-    index.entryPoint = data.entryPoint;
-    index.layers = (data.layers || []).map(layer =>
-      new Map(layer.map(([k, v]) => [k, new Set(v)]))
-    );
-
-    return index;
-  }
-}
-
-// =============================================================================
-// Embedding Service (ONNX via agentic-flow@alpha OptimizedEmbedder)
-// =============================================================================
-
-class EmbeddingService {
-  constructor(config) {
-    this.config = config;
-    this.initialized = false;
-    this.embedder = null;
-    this.embeddingCache = new Map();
-    this.cacheMaxSize = 1000;
-  }
-
-  async initialize() {
-    if (this.initialized) return;
-
-    try {
-      // Dynamically import agentic-flow OptimizedEmbedder
-      const agenticFlowPath = join(PROJECT_ROOT, 'node_modules/agentic-flow/dist/embeddings/optimized-embedder.js');
-
-      if (existsSync(agenticFlowPath)) {
-        const { getOptimizedEmbedder } = await import(agenticFlowPath);
-        this.embedder = getOptimizedEmbedder({
-          modelId: 'all-MiniLM-L6-v2',
-          dimension: this.config.embedding.dimension,
-          cacheSize: 256,
-          autoDownload: false,  // Model should already be downloaded
-        });
-
-        await this.embedder.init();
-        this.useAgenticFlow = true;
-        console.log('[Embedding] Initialized: agentic-flow OptimizedEmbedder (ONNX)');
-      } else {
-        this.useAgenticFlow = false;
-        console.log('[Embedding] agentic-flow not found, using fallback hash embeddings');
-      }
-
-      this.initialized = true;
-    } catch (e) {
-      this.useAgenticFlow = false;
-      this.initialized = true;
-      console.log(`[Embedding] Using fallback hash-based embeddings: ${e.message}`);
-    }
-  }
-
-  async embed(text) {
-    if (!this.initialized) await this.initialize();
-
-    // Check cache
-    const cacheKey = text.slice(0, 200);
-    if (this.embeddingCache.has(cacheKey)) {
-      return this.embeddingCache.get(cacheKey);
-    }
-
-    let embedding;
-
-    if (this.useAgenticFlow && this.embedder) {
-      try {
-        // Use agentic-flow OptimizedEmbedder
-        embedding = await this.embedder.embed(text.slice(0, 500));
-      } catch (e) {
-        console.log(`[Embedding] ONNX failed, using fallback: ${e.message}`);
-        embedding = this._fallbackEmbed(text);
-      }
-    } else {
-      embedding = this._fallbackEmbed(text);
-    }
-
-    // Cache result
-    if (this.embeddingCache.size >= this.cacheMaxSize) {
-      const firstKey = this.embeddingCache.keys().next().value;
-      this.embeddingCache.delete(firstKey);
-    }
-    this.embeddingCache.set(cacheKey, embedding);
-
-    return embedding;
-  }
-
-  async embedBatch(texts) {
-    if (this.useAgenticFlow && this.embedder) {
-      try {
-        return await this.embedder.embedBatch(texts.map(t => t.slice(0, 500)));
-      } catch (e) {
-        // Fallback to sequential
-        return Promise.all(texts.map(t => this.embed(t)));
-      }
-    }
-    return Promise.all(texts.map(t => this.embed(t)));
-  }
-
-  // Fallback: deterministic hash-based embedding
-  _fallbackEmbed(text) {
-    const embedding = new Float32Array(this.config.embedding.dimension);
-    const normalized = text.toLowerCase().trim();
-
-    // Create deterministic embedding from text
-    for (let i = 0; i < embedding.length; i++) {
-      let hash = 0;
-      for (let j = 0; j < normalized.length; j++) {
-        hash = ((hash << 5) - hash + normalized.charCodeAt(j) * (i + 1)) | 0;
-      }
-      embedding[i] = (Math.sin(hash) + 1) / 2;
-    }
-
-    // Normalize
-    let norm = 0;
-    for (let i = 0; i < embedding.length; i++) {
-      norm += embedding[i] * embedding[i];
-    }
-    norm = Math.sqrt(norm);
-    if (norm > 0) {
-      for (let i = 0; i < embedding.length; i++) {
-        embedding[i] /= norm;
-      }
-    }
-
-    return embedding;
-  }
-}
-
-// =============================================================================
-// Learning Service
-// =============================================================================
-
-class LearningService {
-  constructor() {
-    this.db = null;
-    this.shortTermIndex = null;
-    this.longTermIndex = null;
-    this.embeddingService = null;
-    this.sessionId = null;
-    this.metrics = {
-      patternsStored: 0,
-      patternsRetrieved: 0,
-      searchTimeTotal: 0,
-      searchCount: 0,
-      promotions: 0,
-      consolidations: 0,
-    };
-  }
-
-  async initialize(sessionId = null) {
-    this.sessionId = sessionId || `session_${Date.now()}`;
-
-    // Initialize database
-    this.db = new Database(DB_PATH);
-    initializeDatabase(this.db);
-
-    // Initialize embedding service
-    this.embeddingService = new EmbeddingService(CONFIG);
-    await this.embeddingService.initialize();
-
-    // Initialize HNSW indexes
-    this.shortTermIndex = new HNSWIndex(CONFIG);
-    this.longTermIndex = new HNSWIndex(CONFIG);
-
-    // Load existing patterns into indexes
-    await this._loadIndexes();
-
-    // Record session start
-    this._setState('current_session', this.sessionId);
-    this._setState('session_start', Date.now().toString());
-
-    console.log(`[Learning] Initialized session ${this.sessionId}`);
-    console.log(`[Learning] Short-term patterns: ${this.shortTermIndex.size()}`);
-    console.log(`[Learning] Long-term patterns: ${this.longTermIndex.size()}`);
-
-    return {
-      sessionId: this.sessionId,
-      shortTermPatterns: this.shortTermIndex.size(),
-      longTermPatterns: this.longTermIndex.size(),
-    };
-  }
-
-  // Store a new pattern
-  async storePattern(strategy, domain = 'general', metadata = {}) {
-    const now = Date.now();
-    const id = `pat_${now}_${Math.random().toString(36).slice(2, 9)}`;
-
-    // Generate embedding
-    const embedding = await this.embeddingService.embed(strategy);
-
-    // Check for duplicates
-    const { results } = this.shortTermIndex.search(embedding, 1);
-    if (results.length > 0 && results[0].similarity > CONFIG.patterns.dedupThreshold) {
-      // Update existing pattern instead
-      const existingId = results[0].patternId;
-      this._updatePatternUsage(existingId, 'short_term');
-      return { id: existingId, action: 'updated', similarity: results[0].similarity };
-    }
-
-    // Store in database
-    const stmt = this.db.prepare(`
-      INSERT INTO short_term_patterns
-      (id, strategy, domain, embedding, quality, usage_count, created_at, updated_at, session_id, metadata)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `);
-
-    stmt.run(
-      id, strategy, domain,
-      Buffer.from(embedding.buffer),
-      metadata.quality || 0.5,
-      1, now, now,
-      this.sessionId,
-      JSON.stringify(metadata)
-    );
-
-    // Add to HNSW index
-    this.shortTermIndex.add(id, embedding);
-
-    this.metrics.patternsStored++;
-
-    // Check if we need to prune
-    this._pruneShortTerm();
-
-    return { id, action: 'created', embedding: Array.from(embedding).slice(0, 5) };
-  }
-
-  // Search for similar patterns
-  async searchPatterns(query, k = 5, includeShortTerm = true) {
-    const embedding = typeof query === 'string'
-      ? await this.embeddingService.embed(query)
-      : query;
-
-    const results = [];
-
-    // Search long-term first (higher quality)
-    const longTermResults = this.longTermIndex.search(embedding, k);
-    results.push(...longTermResults.results.map(r => ({ ...r, type: 'long_term' })));
-
-    // Search short-term if needed
-    if (includeShortTerm) {
-      const shortTermResults = this.shortTermIndex.search(embedding, k);
-      results.push(...shortTermResults.results.map(r => ({ ...r, type: 'short_term' })));
-    }
-
-    // Sort by similarity and dedupe
-    results.sort((a, b) => b.similarity - a.similarity);
-    const seen = new Set();
-    const deduped = results.filter(r => {
-      if (seen.has(r.patternId)) return false;
-      seen.add(r.patternId);
-      return true;
-    }).slice(0, k);
-
-    // Get full pattern data
-    const patterns = deduped.map(r => {
-      const table = r.type === 'long_term' ? 'long_term_patterns' : 'short_term_patterns';
-      const row = this.db.prepare(`SELECT * FROM ${table} WHERE id = ?`).get(r.patternId);
-      return {
-        ...r,
-        strategy: row?.strategy,
-        domain: row?.domain,
-        quality: row?.quality,
-        usageCount: row?.usage_count,
-      };
-    });
-
-    this.metrics.patternsRetrieved += patterns.length;
-    this.metrics.searchCount++;
-    this.metrics.searchTimeTotal += longTermResults.searchTimeMs;
-
-    return {
-      patterns,
-      searchTimeMs: longTermResults.searchTimeMs,
-      totalLongTerm: this.longTermIndex.size(),
-      totalShortTerm: this.shortTermIndex.size(),
-    };
-  }
-
-  // Record pattern usage (for promotion)
-  recordPatternUsage(patternId, success = true) {
-    // Try short-term first
-    let updated = this._updatePatternUsage(patternId, 'short_term', success);
-    if (!updated) {
-      updated = this._updatePatternUsage(patternId, 'long_term', success);
-    }
-
-    // Check for promotion
-    if (updated) {
-      this._checkPromotion(patternId);
-    }
-
-    return updated;
-  }
-
-  // Promote patterns from short-term to long-term
-  _checkPromotion(patternId) {
-    const row = this.db.prepare(`
-      SELECT * FROM short_term_patterns WHERE id = ?
-    `).get(patternId);
-
-    if (!row) return false;
-
-    // Check promotion criteria
-    const shouldPromote =
-      row.usage_count >= CONFIG.patterns.promotionThreshold &&
-      row.quality >= CONFIG.patterns.qualityThreshold;
-
-    if (!shouldPromote) return false;
-
-    const now = Date.now();
-
-    // Insert into long-term
-    this.db.prepare(`
-      INSERT INTO long_term_patterns
-      (id, strategy, domain, embedding, quality, usage_count, success_count,
-       created_at, updated_at, promoted_at, source_pattern_id, quality_history, metadata)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(
-      `lt_${patternId}`,
-      row.strategy,
-      row.domain,
-      row.embedding,
-      row.quality,
-      row.usage_count,
-      row.success_count,
-      row.created_at,
-      now,
-      now,
-      patternId,
-      JSON.stringify([row.quality]),
-      row.metadata
-    );
-
-    // Add to long-term index
-    this.longTermIndex.add(`lt_${patternId}`, this._bufferToFloat32Array(row.embedding));
-
-    // Remove from short-term
-    this.db.prepare('DELETE FROM short_term_patterns WHERE id = ?').run(patternId);
-    this.shortTermIndex.remove(patternId);
-
-    this.metrics.promotions++;
-    console.log(`[Learning] Promoted pattern ${patternId} to long-term`);
-
-    return true;
-  }
-
-  // Update pattern usage
-  _updatePatternUsage(patternId, table, success = true) {
-    const tableName = table === 'long_term' ? 'long_term_patterns' : 'short_term_patterns';
-
-    const result = this.db.prepare(`
-      UPDATE ${tableName}
-      SET usage_count = usage_count + 1,
-          success_count = success_count + ?,
-          quality = (quality * usage_count + ?) / (usage_count + 1),
-          updated_at = ?
-      WHERE id = ?
-    `).run(success ? 1 : 0, success ? 1.0 : 0.0, Date.now(), patternId);
-
-    return result.changes > 0;
-  }
-
-  // Consolidate patterns (dedup, prune, merge)
-  async consolidate() {
-    const startTime = Date.now();
-    const stats = {
-      duplicatesRemoved: 0,
-      patternsProned: 0,
-      patternsMerged: 0,
-    };
-
-    // 1. Remove old short-term patterns
-    const oldThreshold = Date.now() - CONFIG.patterns.shortTermMaxAge;
-    const pruned = this.db.prepare(`
-      DELETE FROM short_term_patterns
-      WHERE created_at < ? AND usage_count < ?
-    `).run(oldThreshold, CONFIG.patterns.promotionThreshold);
-    stats.patternsProned = pruned.changes;
-
-    // 2. Rebuild indexes
-    await this._loadIndexes();
-
-    // 3. Remove duplicates in long-term
-    const longTermPatterns = this.db.prepare('SELECT * FROM long_term_patterns').all();
-    for (let i = 0; i < longTermPatterns.length; i++) {
-      for (let j = i + 1; j < longTermPatterns.length; j++) {
-        const sim = this._cosineSimilarity(
-          this._bufferToFloat32Array(longTermPatterns[i].embedding),
-          this._bufferToFloat32Array(longTermPatterns[j].embedding)
-        );
-
-        if (sim > CONFIG.patterns.dedupThreshold) {
-          // Keep the higher quality one
-          const toRemove = longTermPatterns[i].quality >= longTermPatterns[j].quality
-            ? longTermPatterns[j].id
-            : longTermPatterns[i].id;
-
-          this.db.prepare('DELETE FROM long_term_patterns WHERE id = ?').run(toRemove);
-          stats.duplicatesRemoved++;
-        }
-      }
-    }
-
-    // 4. Prune old long-term patterns
-    const pruneAge = Date.now() - CONFIG.consolidation.pruneAge;
-    const oldPruned = this.db.prepare(`
-      DELETE FROM long_term_patterns
-      WHERE updated_at < ? AND usage_count < ?
-    `).run(pruneAge, CONFIG.consolidation.minUsageForKeep);
-    stats.patternsProned += oldPruned.changes;
-
-    // Rebuild indexes after changes
-    await this._loadIndexes();
-
-    this.metrics.consolidations++;
-
-    const duration = Date.now() - startTime;
-    console.log(`[Learning] Consolidation complete in ${duration}ms:`, stats);
-
-    return { ...stats, durationMs: duration };
-  }
-
-  // Export learning data for session end
-  async exportSession() {
-    const sessionPatterns = this.db.prepare(`
-      SELECT * FROM short_term_patterns WHERE session_id = ?
-    `).all(this.sessionId);
-
-    const trajectories = this.db.prepare(`
-      SELECT * FROM trajectories WHERE session_id = ?
-    `).all(this.sessionId);
-
-    return {
-      sessionId: this.sessionId,
-      patterns: sessionPatterns.length,
-      trajectories: trajectories.length,
-      metrics: this.metrics,
-      shortTermTotal: this.shortTermIndex.size(),
-      longTermTotal: this.longTermIndex.size(),
-    };
-  }
-
-  // Get learning statistics
-  getStats() {
-    const shortTermCount = this.db.prepare('SELECT COUNT(*) as count FROM short_term_patterns').get().count;
-    const longTermCount = this.db.prepare('SELECT COUNT(*) as count FROM long_term_patterns').get().count;
-    const trajectoryCount = this.db.prepare('SELECT COUNT(*) as count FROM trajectories').get().count;
-
-    const avgQuality = this.db.prepare(`
-      SELECT AVG(quality) as avg FROM (
-        SELECT quality FROM short_term_patterns
-        UNION ALL
-        SELECT quality FROM long_term_patterns
-      )
-    `).get().avg || 0;
-
-    return {
-      shortTermPatterns: shortTermCount,
-      longTermPatterns: longTermCount,
-      trajectories: trajectoryCount,
-      avgQuality,
-      avgSearchTimeMs: this.metrics.searchCount > 0
-        ? this.metrics.searchTimeTotal / this.metrics.searchCount
-        : 0,
-      ...this.metrics,
-    };
-  }
-
-  // Load indexes from database
-  async _loadIndexes() {
-    // Load short-term patterns
-    this.shortTermIndex = new HNSWIndex(CONFIG);
-    const shortTermPatterns = this.db.prepare('SELECT id, embedding FROM short_term_patterns').all();
-    for (const row of shortTermPatterns) {
-      const embedding = this._bufferToFloat32Array(row.embedding);
-      if (embedding) {
-        this.shortTermIndex.add(row.id, embedding);
-      }
-    }
-
-    // Load long-term patterns
-    this.longTermIndex = new HNSWIndex(CONFIG);
-    const longTermPatterns = this.db.prepare('SELECT id, embedding FROM long_term_patterns').all();
-    for (const row of longTermPatterns) {
-      const embedding = this._bufferToFloat32Array(row.embedding);
-      if (embedding) {
-        this.longTermIndex.add(row.id, embedding);
-      }
-    }
-  }
-
-  // Prune short-term patterns if over limit
-  _pruneShortTerm() {
-    const count = this.db.prepare('SELECT COUNT(*) as count FROM short_term_patterns').get().count;
-
-    if (count <= CONFIG.patterns.maxShortTerm) return;
-
-    // Remove lowest quality patterns
-    const toRemove = count - CONFIG.patterns.maxShortTerm;
-    const ids = this.db.prepare(`
-      SELECT id FROM short_term_patterns
-      ORDER BY quality ASC, usage_count ASC
-      LIMIT ?
-    `).all(toRemove).map(r => r.id);
-
-    for (const id of ids) {
-      this.db.prepare('DELETE FROM short_term_patterns WHERE id = ?').run(id);
-      this.shortTermIndex.remove(id);
-    }
-  }
-
-  // Get/set state
-  _getState(key) {
-    const row = this.db.prepare('SELECT value FROM session_state WHERE key = ?').get(key);
-    return row?.value;
-  }
-
-  _setState(key, value) {
-    this.db.prepare(`
-      INSERT OR REPLACE INTO session_state (key, value, updated_at)
-      VALUES (?, ?, ?)
-    `).run(key, value, Date.now());
-  }
-
-  // Cosine similarity helper
-  _cosineSimilarity(a, b) {
-    let dot = 0, normA = 0, normB = 0;
-    for (let i = 0; i < a.length; i++) {
-      dot += a[i] * b[i];
-      normA += a[i] * a[i];
-      normB += b[i] * b[i];
-    }
-    const denom = Math.sqrt(normA) * Math.sqrt(normB);
-    return denom > 0 ? dot / denom : 0;
-  }
-
-  // Close database
-  close() {
-    if (this.db) {
-      this.db.close();
-      this.db = null;
-    }
-  }
-
-  // Helper: Safely convert SQLite Buffer to Float32Array
-  // Handles byte alignment issues that cause "byte length should be multiple of 4"
-  _bufferToFloat32Array(buffer) {
-    if (!buffer) return null;
-
-    // If it's already a Float32Array, return it
-    if (buffer instanceof Float32Array) return buffer;
-
-    // Get the expected number of floats based on embedding dimension
-    const numFloats = this.config?.embedding?.dimension || CONFIG.embedding.dimension;
-    const expectedBytes = numFloats * 4;
-
-    // Create a properly aligned Uint8Array copy
-    const uint8 = new Uint8Array(expectedBytes);
-    const sourceLength = Math.min(buffer.length, expectedBytes);
-
-    // Copy bytes from Buffer to Uint8Array
-    for (let i = 0; i < sourceLength; i++) {
-      uint8[i] = buffer[i];
-    }
-
-    // Create Float32Array from the aligned buffer
-    return new Float32Array(uint8.buffer);
-  }
-}
-
-// =============================================================================
-// CLI Interface
-// =============================================================================
-
-async function main() {
-  const command = process.argv[2] || 'help';
-  const service = new LearningService();
-
-  try {
-    switch (command) {
-      case 'init':
-      case 'start': {
-        const sessionId = process.argv[3];
-        const result = await service.initialize(sessionId);
-        console.log(JSON.stringify(result, null, 2));
-        break;
-      }
-
-      case 'store': {
-        await service.initialize();
-        const strategy = process.argv[3];
-        const domain = process.argv[4] || 'general';
-        if (!strategy) {
-          console.error('Usage: learning-service.mjs store <strategy> [domain]');
-          process.exit(1);
-        }
-        const result = await service.storePattern(strategy, domain);
-        console.log(JSON.stringify(result, null, 2));
-        break;
-      }
-
-      case 'search': {
-        await service.initialize();
-        const query = process.argv[3];
-        const k = parseInt(process.argv[4]) || 5;
-        if (!query) {
-          console.error('Usage: learning-service.mjs search <query> [k]');
-          process.exit(1);
-        }
-        const result = await service.searchPatterns(query, k);
-        console.log(JSON.stringify(result, null, 2));
-        break;
-      }
-
-      case 'consolidate': {
-        await service.initialize();
-        const result = await service.consolidate();
-        console.log(JSON.stringify(result, null, 2));
-        break;
-      }
-
-      case 'export': {
-        await service.initialize();
-        const result = await service.exportSession();
-        console.log(JSON.stringify(result, null, 2));
-        break;
-      }
-
-      case 'stats': {
-        await service.initialize();
-        const stats = service.getStats();
-        console.log(JSON.stringify(stats, null, 2));
-        break;
-      }
-
-      case 'benchmark': {
-        await service.initialize();
-
-        console.log('[Benchmark] Starting HNSW performance test...');
-
-        // Store test patterns
-        const testPatterns = [
-          'Implement authentication with JWT tokens',
-          'Fix memory leak in event handler',
-          'Optimize database query performance',
-          'Add unit tests for user service',
-          'Refactor component to use hooks',
-        ];
-
-        for (const strategy of testPatterns) {
-          await service.storePattern(strategy, 'code');
-        }
-
-        // Benchmark search
-        const searchTimes = [];
-        for (let i = 0; i < 100; i++) {
-          const start = performance.now();
-          await service.searchPatterns('implement authentication', 3);
-          searchTimes.push(performance.now() - start);
-        }
-
-        const avgSearch = searchTimes.reduce((a, b) => a + b) / searchTimes.length;
-        const p95Search = searchTimes.sort((a, b) => a - b)[Math.floor(searchTimes.length * 0.95)];
-
-        console.log(JSON.stringify({
-          avgSearchMs: avgSearch.toFixed(3),
-          p95SearchMs: p95Search.toFixed(3),
-          totalPatterns: service.getStats().shortTermPatterns + service.getStats().longTermPatterns,
-          hnswActive: true,
-          searchImprovementEstimate: `${Math.round(50 / Math.max(avgSearch, 0.1))}x`,
-        }, null, 2));
-        break;
-      }
-
-      case 'help':
-      default:
-        console.log(`
-Monomind V1 Learning Service
-
-Usage: learning-service.mjs <command> [args]
-
-Commands:
-  init [sessionId]         Initialize learning service
-  store <strategy> [domain] Store a new pattern
-  search <query> [k]        Search for similar patterns
-  consolidate              Consolidate and prune patterns
-  export                   Export session learning data
-  stats                    Get learning statistics
-  benchmark                Run HNSW performance benchmark
-  help                     Show this help message
-        `);
-    }
-  } finally {
-    service.close();
-  }
-}
-
-// Export for programmatic use
-export { LearningService, HNSWIndex, EmbeddingService, CONFIG };
-
-// Run CLI if executed directly
-if (process.argv[1] === fileURLToPath(import.meta.url)) {
-  main().catch(e => {
-    console.error('Error:', e.message);
-    process.exit(1);
-  });
-}