@monoes/monomindcli 1.10.29 → 1.10.30

package/.claude/helpers/intelligence.cjs

@@ -158,6 +158,9 @@ function matchScore(promptWords, entryWords) {
 }
 
 var cachedEntries = null;
+// Module-level state for feedback correlation
+var _lastContext = null;  // stores last prompt string from getContext() calls
+var _recentEdits = [];    // ring buffer of recent file edits (max 50)
 
 module.exports = {
   init: function() {
@@ -192,15 +195,31 @@ module.exports = {
       var summary = (e.entry.summary || e.entry.content || "").substring(0, 80);
       lines.push("  * (" + conf.toFixed(2) + ") " + summary);
     }
+    _lastContext = prompt; // capture for feedback() correlation
     return lines.join("\n");
   },
 
   recordEdit: function(file) {
-    // pending-insights staging removed — consolidate() was a no-op that just cleared this file
+    // Track recent edits for context relevance adjustment (ring buffer, max 50)
+    _recentEdits.push({ filePath: file, ts: Date.now() });
+    if (_recentEdits.length > 50) _recentEdits.shift();
   },
 
   feedback: function(success) {
-    // Stub: no-op in minimal version
+    // Append outcome to intelligence-outcomes.jsonl. At session-end,
+    // session-handler.cjs reads this file (30-minute window, majority-vote)
+    // to derive intelligenceFeedback for routing-feedback.jsonl.
+    try {
+      var outPath = path.join(DATA_DIR, 'intelligence-outcomes.jsonl');
+      ensureDir(DATA_DIR);
+      var entry = JSON.stringify({
+        ts: Date.now(),
+        success: success,
+        context: _lastContext ? _lastContext.substring(0, 200) : null,
+        recentEdits: _recentEdits.slice(-5).map(function(e) { return e.filePath; }),
+      });
+      fs.appendFileSync(outPath, entry + '\n', 'utf-8');
+    } catch (e) { /* non-critical — must not break session-end hook */ }
   },
 
   consolidate: function() {

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

@@ -113,7 +113,9 @@ function initializeDatabase(db) {
       metadata TEXT
     );
 
-    -- HNSW index metadata
+    -- HNSW index per-pattern mapping (unused: full index snapshots are stored in
+    -- session_state under keys hnsw_short_term/hnsw_long_term as JSON blobs.
+    -- This table exists for future per-vector indexing if needed.)
     CREATE TABLE IF NOT EXISTS hnsw_index (
       id INTEGER PRIMARY KEY,
       pattern_type TEXT NOT NULL,  -- 'short_term' or 'long_term'
@@ -168,6 +170,20 @@ function initializeDatabase(db) {
 // HNSW Index (In-Memory with SQLite persistence)
 // =============================================================================
 
+// TODO: Replace HNSWIndex with shared HnswLite from @monomind/memory once
+// API differences are resolved. Migration notes:
+//   - HnswLite constructor: (dimensions: number, m: number, efConstruction: number, metric: string)
+//     vs HNSWIndex constructor: (config: { embedding: { dimension }, hnsw: { m, efConstruction } })
+//   - HnswLite.add(id: string, vector: Float32Array): void
+//     vs HNSWIndex.add(patternId, embedding): vectorId (numeric)
+//   - HnswLite.search(query: Float32Array, k: number, threshold?): { id, score }[]
+//     vs HNSWIndex.search(queryEmbedding, k): { results: { patternId, similarity, vectorId }[], searchTimeMs }
+//   - HnswLite.remove(id: string): void (no return)
+//     vs HNSWIndex.remove(patternId): boolean
+//   - dist/hnsw-lite.js exists at packages/@monomind/memory/dist/hnsw-lite.js
+//   - Import: import { HnswLite } from '../../packages/@monomind/memory/dist/hnsw-lite.js'
+// Distance metric: HNSWIndex uses cosine similarity (1 - distance) in _searchGraph;
+//                  HnswLite defaults to cosineSimilarity — compatible. See D3 comment in hnsw-lite.ts.
 class HNSWIndex {
   constructor(config) {
     this.config = config;
@@ -565,6 +581,15 @@ class EmbeddingService {
 
 // =============================================================================
 // Learning Service
+//
+// Singleton contract (enforced by hook-handler.cjs::getLearningService()):
+//   - One LearningService instance is created per hook-handler process.
+//   - initialize() opens the SQLite DB at DB_PATH and loads HNSW indexes;
+//     it must be called exactly once after construction.
+//   - consolidate() is called at session-end to prune + promote patterns;
+//     it operates on the already-open DB — no re-initialization needed.
+//   - The constructor intentionally leaves all fields null until initialize()
+//     is called; callers must not invoke other methods before initialize().
 // =============================================================================
 
 class LearningService {
@@ -658,6 +683,9 @@ class LearningService {
     // Check if we need to prune
     this._pruneShortTerm();
 
+    // Persist index snapshot non-blocking
+    this._saveIndexes().catch(e => console.error('[LearningService] saveIndexes error:', e));
+
     return { id, action: 'created', embedding: Array.from(embedding).slice(0, 5) };
   }
 
@@ -817,21 +845,32 @@ class LearningService {
     // 2. Rebuild indexes
     await this._loadIndexes();
 
-    // 3. Remove duplicates in long-term
+    // 3. Remove duplicates in long-term (simhash-bucketed to avoid O(n²) cosine)
     const longTermPatterns = this.db.prepare('SELECT * FROM long_term_patterns').all();
+
+    // Build simhash fingerprints for all patterns
+    const fingerprints = new Map();
+    for (const p of longTermPatterns) {
+      fingerprints.set(p.id, this._simhash(p.strategy || ''));
+    }
+
+    // Near-dup detection: only compare pairs with Hamming distance < 4
     for (let i = 0; i < longTermPatterns.length; i++) {
       for (let j = i + 1; j < longTermPatterns.length; j++) {
+        const hammingDist = this._hammingDistance(
+          fingerprints.get(longTermPatterns[i].id),
+          fingerprints.get(longTermPatterns[j].id)
+        );
+        if (hammingDist >= 4) continue; // Skip dissimilar pairs (fast path)
         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++;
         }
@@ -851,10 +890,74 @@ class LearningService {
 
     this.metrics.consolidations++;
 
+    // 5. Promote eligible episodic patterns to semantic long-term memory
+    const promResult = await this.promoteEpisodic();
+    if (promResult.promoted > 0) {
+      console.log(`[Learning] Promoted ${promResult.promoted} episodic pattern(s) to semantic memory`);
+    }
+
+    // Persist updated index snapshot non-blocking
+    this._saveIndexes().catch(e => console.error('[LearningService] saveIndexes error:', e));
+
     const duration = Date.now() - startTime;
     console.log(`[Learning] Consolidation complete in ${duration}ms:`, stats);
 
-    return { ...stats, durationMs: duration };
+    return { ...stats, promoted: promResult.promoted, durationMs: duration };
+  }
+
+  // Promote short-term episodic patterns to long-term semantic memory
+  async promoteEpisodic() {
+    const threshold = CONFIG.patterns.promotionThreshold;
+    const candidates = this.db.prepare(`
+      SELECT * FROM short_term_patterns
+      WHERE usage_count >= ?
+      ORDER BY quality DESC
+    `).all(threshold);
+
+    let promoted = 0;
+    for (const pattern of candidates) {
+      try {
+        // Check if already in long-term (using source_pattern_id link)
+        const exists = this.db.prepare('SELECT id FROM long_term_patterns WHERE source_pattern_id = ? OR id = ?').get(pattern.id, `lt_${pattern.id}`);
+        if (exists) {
+          // Remove from short-term since it was already promoted
+          this.db.prepare('DELETE FROM short_term_patterns WHERE id = ?').run(pattern.id);
+          this.shortTermIndex.remove(pattern.id);
+          continue;
+        }
+
+        const now = Date.now();
+        const ltId = `lt_${pattern.id}`;
+
+        // Promote to long-term
+        this.db.prepare(`
+          INSERT OR IGNORE INTO long_term_patterns
+          (id, strategy, domain, embedding, quality, usage_count, success_count,
+           created_at, updated_at, promoted_at, source_pattern_id, metadata)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `).run(
+          ltId, pattern.strategy, pattern.domain, pattern.embedding,
+          pattern.quality, pattern.usage_count, pattern.success_count || 0,
+          pattern.created_at, now, now, pattern.id, pattern.metadata
+        );
+
+        // Add to long-term HNSW index
+        const embedding = this._bufferToFloat32Array(pattern.embedding);
+        if (embedding) this.longTermIndex.add(ltId, embedding);
+
+        // Remove from short-term
+        this.db.prepare('DELETE FROM short_term_patterns WHERE id = ?').run(pattern.id);
+        this.shortTermIndex.remove(pattern.id);
+        promoted++;
+      } catch (e) { /* skip individual failures */ }
+    }
+
+    if (promoted > 0) {
+      this.metrics.promotions += promoted;
+      this._saveIndexes().catch(e => console.error('[LearningService] saveIndexes error:', e));
+    }
+
+    return { promoted };
   }
 
   // Export learning data for session end
@@ -903,9 +1006,41 @@ class LearningService {
     };
   }
 
-  // Load indexes from database
+  // Save full HNSW index snapshots to session_state (key-value TEXT store).
+  // Using session_state (not hnsw_index) because session_state stores arbitrary blobs;
+  // hnsw_index stores per-pattern mappings and is not designed for full snapshots.
+  async _saveIndexes() {
+    try {
+      const shortTermData = JSON.stringify(this.shortTermIndex.serialize());
+      const longTermData = JSON.stringify(this.longTermIndex.serialize());
+      this.db.prepare(`
+        INSERT OR REPLACE INTO session_state (key, value, updated_at)
+        VALUES ('hnsw_short_term', ?, ?)
+      `).run(shortTermData, Date.now());
+      this.db.prepare(`
+        INSERT OR REPLACE INTO session_state (key, value, updated_at)
+        VALUES ('hnsw_long_term', ?, ?)
+      `).run(longTermData, Date.now());
+    } catch (e) {
+      console.error('[LearningService] Failed to save HNSW indexes:', e.message);
+    }
+  }
+
+  // Load indexes from database — try serialized snapshot first, fall back to rebuild
   async _loadIndexes() {
-    // Load short-term patterns
+    try {
+      const shortRow = this.db.prepare("SELECT value FROM session_state WHERE key = 'hnsw_short_term'").get();
+      const longRow = this.db.prepare("SELECT value FROM session_state WHERE key = 'hnsw_long_term'").get();
+      if (shortRow && longRow) {
+        this.shortTermIndex = HNSWIndex.deserialize(JSON.parse(shortRow.value), CONFIG);
+        this.longTermIndex = HNSWIndex.deserialize(JSON.parse(longRow.value), CONFIG);
+        return;
+      }
+    } catch (e) {
+      console.error('[LearningService] Failed to restore HNSW snapshots, rebuilding:', e.message);
+    }
+
+    // Rebuild from patterns tables (fallback)
     this.shortTermIndex = new HNSWIndex(CONFIG);
     const shortTermPatterns = this.db.prepare('SELECT id, embedding FROM short_term_patterns').all();
     for (const row of shortTermPatterns) {
@@ -915,7 +1050,6 @@ class LearningService {
       }
     }
 
-    // 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) {
@@ -959,6 +1093,30 @@ class LearningService {
     `).run(key, value, Date.now());
   }
 
+  // 32-bit simhash via bit-weighting of character bigrams
+  _simhash(text) {
+    const bits = new Int32Array(32);
+    const chars = text.toLowerCase().replace(/\s+/g, ' ');
+    for (let i = 0; i < chars.length - 1; i++) {
+      const bigram = chars.charCodeAt(i) * 31 + chars.charCodeAt(i + 1);
+      for (let b = 0; b < 32; b++) {
+        bits[b] += (bigram >> b) & 1 ? 1 : -1;
+      }
+    }
+    let hash = 0;
+    for (let b = 0; b < 32; b++) {
+      if (bits[b] > 0) hash |= (1 << b);
+    }
+    return hash >>> 0; // unsigned
+  }
+
+  _hammingDistance(a, b) {
+    let x = a ^ b;
+    let count = 0;
+    while (x) { count += x & 1; x >>>= 1; }
+    return count;
+  }
+
   // Cosine similarity helper
   _cosineSimilarity(a, b) {
     let dot = 0, normA = 0, normB = 0;

package/.claude/helpers/memory-palace.cjs

@@ -199,23 +199,83 @@ function storeVerbatim(cwd, content, meta) {
 // ── score persistence ─────────────────────────────────────────────────────────
 /**
  * _bumpScores(drawersFile, ids)
- * Rewrite drawers.jsonl with score += 1 for the given drawer ids.
+ * Appends score bumps to a sidecar .score-diffs.jsonl instead of rewriting
+ * the full drawers.jsonl on every search. Compacts when sidecar reaches 100 entries.
  * Called after search/recall so frequently-retrieved drawers rise to L1.
  */
 function _bumpScores(drawersFile, ids) {
   if (!ids || ids.length === 0) return;
-  var idSet = {};
-  ids.forEach(function(id) { idSet[id] = true; });
+  var diffPath = drawersFile.replace('.jsonl', '-score-diffs.jsonl');
+  try {
+    var entry = JSON.stringify({ ts: Date.now(), bumpIds: ids, delta: 1 });
+    fs.appendFileSync(diffPath, entry + '\n', 'utf-8');
+    _maybeCompactScoreDiffs(drawersFile, diffPath);
+  } catch (e) { /* non-fatal */ }
+}
+
+/**
+ * _maybeCompactScoreDiffs(drawersFile, diffPath)
+ * When the sidecar accumulates >= 100 entries, apply all diffs to the drawers
+ * file atomically and delete the sidecar.
+ */
+function _maybeCompactScoreDiffs(drawersFile, diffPath) {
+  var lines;
+  try {
+    lines = fs.readFileSync(diffPath, 'utf-8').split('\n').filter(Boolean);
+  } catch { return; }
+  if (lines.length < 100) return;
+  _applyScoreDiffs(drawersFile, diffPath, lines);
+}
+
+/**
+ * _applyScoreDiffs(drawersFile, diffPath, lines)
+ * Apply accumulated score diffs to drawers.jsonl atomically, then remove sidecar.
+ */
+function _applyScoreDiffs(drawersFile, diffPath, lines) {
   try {
     var drawers = readJsonl(drawersFile);
-    var changed = false;
+    var diffs = (lines || fs.readFileSync(diffPath, 'utf-8').split('\n').filter(Boolean))
+      .map(function(l) { try { return JSON.parse(l); } catch { return null; } })
+      .filter(Boolean);
+    for (var i = 0; i < diffs.length; i++) {
+      var diff = diffs[i];
+      var delta = diff.delta || 1;
+      (diff.bumpIds || []).forEach(function(id) {
+        var d = drawers.find(function(x) { return x.id === id; });
+        if (d) d.score = (d.score || 1.0) + delta;
+      });
+    }
+    var tmpPath = drawersFile + '.tmp';
+    fs.writeFileSync(tmpPath, drawers.map(function(d) { return JSON.stringify(d); }).join('\n') + '\n', 'utf-8');
+    fs.renameSync(tmpPath, drawersFile);
+    try { fs.unlinkSync(diffPath); } catch {}
+  } catch (e) { /* non-fatal — leave sidecar intact for next attempt */ }
+}
+
+/**
+ * _getEffectiveDrawers(drawersFile)
+ * Read drawers.jsonl and apply any pending score diffs from the sidecar,
+ * returning the merged result without compacting. Used by wakeUp/recall/search
+ * to get accurate scores without triggering a full compact.
+ */
+function _getEffectiveDrawers(drawersFile) {
+  var drawers = readJsonl(drawersFile);
+  var diffPath = drawersFile.replace('.jsonl', '-score-diffs.jsonl');
+  try {
+    var lines = fs.readFileSync(diffPath, 'utf-8').split('\n').filter(Boolean);
+    var diffs = lines.map(function(l) { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
+    // Build score bump totals per id
+    var bumps = {};
+    diffs.forEach(function(diff) {
+      (diff.bumpIds || []).forEach(function(id) {
+        bumps[id] = (bumps[id] || 0) + (diff.delta || 1);
+      });
+    });
     drawers.forEach(function(d) {
-      if (idSet[d.id]) { d.score = (d.score || 1.0) + 1; changed = true; }
+      if (bumps[d.id]) d.score = (d.score || 1.0) + bumps[d.id];
     });
-    if (changed) {
-      fs.writeFileSync(drawersFile, drawers.map(function(d) { return JSON.stringify(d); }).join('\n') + '\n', 'utf-8');
-    }
-  } catch (e) { /* non-fatal */ }
+  } catch { /* sidecar absent — use raw drawers */ }
+  return drawers;
 }
 
 // ── search (L3 deep) ──────────────────────────────────────────────────────────
@@ -229,7 +289,7 @@ function search(cwd, query, opts) {
   var limit       = opts.limit || 5;
   var pDir        = palaceDir(cwd);
   var drawersFile = path.join(pDir, 'drawers.jsonl');
-  var drawers     = readJsonl(drawersFile);
+  var drawers     = _getEffectiveDrawers(drawersFile);
 
   if (opts.wing) drawers = drawers.filter(function(d) { return d.wing === opts.wing; });
   if (opts.room) drawers = drawers.filter(function(d) { return d.room === opts.room; });
@@ -273,7 +333,7 @@ function recall(cwd, opts) {
   opts = opts || {};
   var limit       = opts.limit || 10;
   var drawersFile = path.join(palaceDir(cwd), 'drawers.jsonl');
-  var drawers     = readJsonl(drawersFile);
+  var drawers     = _getEffectiveDrawers(drawersFile);
   if (opts.wing) drawers = drawers.filter(function(d) { return d.wing === opts.wing; });
   if (opts.room) drawers = drawers.filter(function(d) { return d.room === opts.room; });
   var top = drawers
@@ -363,7 +423,7 @@ function wakeUp(cwd) {
   var drawersFile = path.join(pDir, 'drawers.jsonl');
   if (fs.existsSync(drawersFile)) {
     try {
-      var drawers = readJsonl(drawersFile);
+      var drawers = _getEffectiveDrawers(drawersFile);
       var cutoff  = Date.now() - L1_DAYS * 24 * 60 * 60 * 1000;
       var recent  = drawers.filter(function(d) {
         return d.ts && new Date(d.ts).getTime() > cutoff;

package/.claude/helpers/router.cjs

@@ -395,6 +395,73 @@ async function routeTaskSemantic(task) {
   return keywordResult;
 }
 
+// ─── Feedback weight loader ───────────────────────────────────────────────────
+// Reads .monomind/routing-feedback.jsonl to compute per-agent success-rate
+// weights. Weights are memoized with a 60-second TTL.
+//
+// Signal source: routing-feedback.jsonl entries with a non-null intelligenceFeedback
+// boolean. Derived at session-end from intelligence-outcomes.jsonl (30-minute window,
+// majority-vote). Requires MIN_FEEDBACK_SAMPLES entries per agent to activate.
+//
+// To verify: copy .monomind/test-fixtures/routing-feedback-seeded.jsonl to
+// .monomind/routing-feedback.jsonl, then call loadFeedbackWeights() in a REPL.
+
+var _feedbackWeightsCache = null;
+var _feedbackWeightsCacheTime = 0;
+var FEEDBACK_CACHE_TTL_MS = 60000;
+var MIN_FEEDBACK_SAMPLES = 10;
+
+function loadFeedbackWeights() {
+  var now = Date.now();
+  if (_feedbackWeightsCache && now - _feedbackWeightsCacheTime < FEEDBACK_CACHE_TTL_MS) {
+    return _feedbackWeightsCache;
+  }
+  var feedbackPath = path.join(process.cwd(), '.monomind', 'routing-feedback.jsonl');
+  if (!fs.existsSync(feedbackPath)) {
+    _feedbackWeightsCache = new Map();
+    _feedbackWeightsCacheTime = now;
+    return _feedbackWeightsCache;
+  }
+  var lines;
+  try {
+    lines = fs.readFileSync(feedbackPath, 'utf8').trim().split('\n').filter(Boolean);
+  } catch {
+    _feedbackWeightsCache = new Map();
+    _feedbackWeightsCacheTime = now;
+    return _feedbackWeightsCache;
+  }
+  var agentStats = {};
+  for (var i = 0; i < lines.length; i++) {
+    try {
+      var entry = JSON.parse(lines[i]);
+      var agent = entry.suggestedAgent || entry.agent;
+      if (!agent) continue;
+      if (!agentStats[agent]) agentStats[agent] = { total: 0, successTotal: 0, withSignal: 0 };
+      agentStats[agent].total++;
+      // Only count entries where intelligenceFeedback is non-null as having signal
+      var fb = entry.intelligenceFeedback;
+      if (fb !== null && fb !== undefined) {
+        agentStats[agent].withSignal++;
+        var success = fb === true || (fb && fb.success === true);
+        if (success) agentStats[agent].successTotal++;
+      }
+    } catch { /* skip malformed lines */ }
+  }
+  var weights = new Map();
+  for (var agentName in agentStats) {
+    var stats = agentStats[agentName];
+    // Only activate weight when we have enough non-null signal entries
+    if (stats.withSignal >= MIN_FEEDBACK_SAMPLES) {
+      var rate = stats.successTotal / stats.withSignal;
+      // Clamp to [0.5, 1.5]: bad agents get penalized, good agents boosted slightly
+      weights.set(agentName, Math.max(0.5, Math.min(1.5, rate * 2)));
+    }
+  }
+  _feedbackWeightsCache = weights;
+  _feedbackWeightsCacheTime = now;
+  return weights;
+}
+
 // ─── Main routing ─────────────────────────────────────────────────────────────
 function routeTask(task) {
   if (typeof task !== 'string' || !task) {
@@ -419,14 +486,19 @@ function routeTask(task) {
     };
   }
 
+  var feedbackWeights = loadFeedbackWeights();
+
   // Dev task pattern matching
   for (const [pattern, agent] of Object.entries(TASK_PATTERNS)) {
     const regex = new RegExp(pattern, 'i');
     if (regex.test(taskLower)) {
+      // Apply feedback weight to confidence (defaults to 1.0 = no change)
+      var baseConfidence = 0.8;
+      var weight = feedbackWeights.get(agent) || 1.0;
       return {
         agent,
         agentSlug: agent,
-        confidence: 0.8,
+        confidence: Math.min(1.0, baseConfidence * weight),
         reason: `Matched pattern: ${pattern}`,
         skillMatches: matchSkills(task),
         extrasMatches: [],
@@ -436,14 +508,16 @@ function routeTask(task) {
   }
 
   // Default — low confidence, show both skill and extras suggestions
+  var defaultAgent = 'coder';
+  var defaultWeight = feedbackWeights.get(defaultAgent) || 1.0;
   return {
-    agent: 'coder',
-    agentSlug: 'coder',
-    confidence: 0.5,
+    agent: defaultAgent,
+    agentSlug: defaultAgent,
+    confidence: Math.min(1.0, 0.5 * defaultWeight),
     reason: 'Default routing - no specific pattern matched',
     skillMatches: matchSkills(task),
     extrasMatches: matchExtras(task),
-    specificAgents: SPECIFIC_AGENTS_MAP['coder'] || [],
+    specificAgents: SPECIFIC_AGENTS_MAP[defaultAgent] || [],
   };
 }