@monoes/monomindcli 1.11.14 → 1.13.0

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

@@ -0,0 +1,461 @@
+'use strict';
+/**
+ * memory-palace.cjs — MemPalace-inspired cross-session memory for Monomind
+ *
+ * Architecture (Wing → Room → Hall namespace hierarchy):
+ *   Drawers   verbatim 800-char chunks with 100-char overlap  → drawers.jsonl
+ *   Closets   regex topic-pointer index (no AI calls)          → closets.jsonl
+ *   KG        temporal knowledge graph (SQLite-free triples)   → kg.json
+ *
+ * Memory stack:
+ *   L0  identity     identity.md — static, user-maintained
+ *   L1  essential    top-scored recent drawers → injected on session-restore
+ *   L2  on-demand    recall(wing, room) — explicit namespace pull
+ *   L3  deep search  search(query)      — Okapi BM25 across all drawers
+ *
+ * Wire points in hook-handler.cjs:
+ *   session-restore  → wakeUp(CWD)         injects L0 + L1 into session context
+ *   post-task        → storeVerbatim(...)   files the verbatim task chunks
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// ── constants ─────────────────────────────────────────────────────────────────
+const DRAWER_SIZE = 800;   // chars per verbatim chunk
+const OVERLAP     = 100;   // overlap between consecutive chunks
+const L1_LIMIT    = 5;     // max drawers surfaced in essential story
+const L1_DAYS     = 30;    // look-back window for L1 drawers (days)
+const BM25_K1     = 1.5;   // term-frequency saturation
+const BM25_B      = 0.75;  // length normalisation
+
+// ── filesystem helpers ────────────────────────────────────────────────────────
+function palaceDir(cwd) {
+  return path.join(cwd, '.monomind', 'palace');
+}
+
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+function readJsonl(filePath) {
+  if (!fs.existsSync(filePath)) return [];
+  try {
+    return fs.readFileSync(filePath, 'utf-8')
+      .split('\n')
+      .filter(Boolean)
+      .map(function(line) { return JSON.parse(line); });
+  } catch (e) {
+    return [];
+  }
+}
+
+function appendJsonl(filePath, record) {
+  fs.appendFileSync(filePath, JSON.stringify(record) + '\n', 'utf-8');
+}
+
+function readJson(filePath, fallback) {
+  if (!fs.existsSync(filePath)) return fallback;
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+  } catch (e) {
+    return fallback;
+  }
+}
+
+function writeJson(filePath, data) {
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf-8');
+}
+
+function uid() {
+  return Date.now().toString(36) + Math.random().toString(36).slice(2, 7);
+}
+
+// ── Okapi BM25 ────────────────────────────────────────────────────────────────
+function tokenize(text) {
+  return (text || '').toLowerCase().replace(/[^a-z0-9\s]/g, ' ').split(/\s+/).filter(Boolean);
+}
+
+/**
+ * bm25(query, docs) → [{ id, score }, …] sorted descending
+ * docs: array of { id, text }
+ */
+function bm25(query, docs) {
+  if (!docs || docs.length === 0) return [];
+  var qTerms = tokenize(query);
+  if (qTerms.length === 0) return docs.map(function(d) { return { id: d.id, score: 0 }; });
+
+  // Pre-tokenize every document
+  var tokenized = docs.map(function(d) {
+    return { id: d.id, tokens: tokenize(d.text || '') };
+  });
+  var N    = tokenized.length;
+  var avgdl = tokenized.reduce(function(s, d) { return s + d.tokens.length; }, 0) / (N || 1);
+
+  // Document frequency per term
+  var df = {};
+  tokenized.forEach(function(d) {
+    var seen = {};
+    d.tokens.forEach(function(t) { seen[t] = true; });
+    Object.keys(seen).forEach(function(t) { df[t] = (df[t] || 0) + 1; });
+  });
+
+  // Score each document
+  return tokenized.map(function(d) {
+    var tf = {};
+    d.tokens.forEach(function(t) { tf[t] = (tf[t] || 0) + 1; });
+    var dl    = d.tokens.length;
+    var score = 0;
+    qTerms.forEach(function(term) {
+      var f = tf[term] || 0;
+      if (f === 0) return;
+      var dfTerm = df[term] || 0;
+      var idf    = Math.log((N - dfTerm + 0.5) / (dfTerm + 0.5) + 1);
+      score += idf * (f * (BM25_K1 + 1)) / (f + BM25_K1 * (1 - BM25_B + BM25_B * dl / avgdl));
+    });
+    return { id: d.id, score: score };
+  }).sort(function(a, b) { return b.score - a.score; });
+}
+
+// ── closet extraction (no AI, regex only) ─────────────────────────────────────
+/**
+ * buildClosets(content, drawerId) → [closet record, …]
+ * Extracts: section headers, action phrases, proper nouns, quoted passages.
+ */
+function buildClosets(content, drawerId) {
+  var results = [];
+  var ts = new Date().toISOString();
+  var m;
+
+  // Section headers (Markdown)
+  var headerRe = /^#{1,3}\s+(.+)$/gm;
+  while ((m = headerRe.exec(content)) !== null) {
+    results.push({ drawerId: drawerId, term: m[1].trim(), type: 'header', ts: ts });
+  }
+
+  // Action phrases: "verb Object"
+  var actionRe = /\b(built|fixed|added|implemented|created|removed|updated|refactored|deployed|configured|enabled|disabled|migrated|merged|published|released|optimized|rewrote|designed|analyzed|reviewed)\s+([A-Za-z][A-Za-z0-9_/.-]{1,50})/g;
+  while ((m = actionRe.exec(content)) !== null) {
+    results.push({ drawerId: drawerId, term: m[1] + ' ' + m[2], type: 'action', ts: ts });
+  }
+
+  // Proper nouns: consecutive Title Case words
+  var properRe = /\b([A-Z][a-z]+(?:\s+[A-Z][a-z]+)+)\b/g;
+  var properSeen = {};
+  while ((m = properRe.exec(content)) !== null) {
+    if (!properSeen[m[1]]) {
+      properSeen[m[1]] = true;
+      results.push({ drawerId: drawerId, term: m[1], type: 'proper', ts: ts });
+    }
+  }
+
+  // Quoted passages (3–60 chars)
+  var quotedRe = /"([^"]{3,60})"|`([^`]{3,60})`/g;
+  while ((m = quotedRe.exec(content)) !== null) {
+    var phrase = (m[1] || m[2]).trim();
+    results.push({ drawerId: drawerId, term: phrase, type: 'quoted', ts: ts });
+  }
+
+  return results;
+}
+
+// ── storeVerbatim ─────────────────────────────────────────────────────────────
+/**
+ * storeVerbatim(cwd, content, { wing, room, hall })
+ * Chunks content into DRAWER_SIZE-char segments (with OVERLAP), stores each
+ * as a drawer and extracts closet topics from each chunk.
+ */
+function storeVerbatim(cwd, content, meta) {
+  if (!content || typeof content !== 'string' || content.trim().length < 20) return;
+  var pDir = palaceDir(cwd);
+  ensureDir(pDir);
+
+  var wing = (meta && meta.wing) || 'general';
+  var room = (meta && meta.room) || 'default';
+  var hall = (meta && meta.hall) || '';
+  var ts   = new Date().toISOString();
+
+  var drawersFile = path.join(pDir, 'drawers.jsonl');
+  var closetsFile = path.join(pDir, 'closets.jsonl');
+
+  var step = DRAWER_SIZE - OVERLAP;
+  var i = 0;
+  while (i < content.length) {
+    var chunk = content.slice(i, i + DRAWER_SIZE);
+    if (chunk.trim().length >= 20) {
+      var id     = uid();
+      var drawer = { id: id, content: chunk, wing: wing, room: room, hall: hall, score: 1.0, ts: ts };
+      appendJsonl(drawersFile, drawer);
+      var closets = buildClosets(chunk, id);
+      closets.forEach(function(c) { appendJsonl(closetsFile, c); });
+    }
+    if (i + DRAWER_SIZE >= content.length) break;
+    i += step;
+  }
+}
+
+// ── score persistence ─────────────────────────────────────────────────────────
+/**
+ * _bumpScores(drawersFile, 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 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 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 (bumps[d.id]) d.score = (d.score || 1.0) + bumps[d.id];
+    });
+  } catch { /* sidecar absent — use raw drawers */ }
+  return drawers;
+}
+
+// ── search (L3 deep) ──────────────────────────────────────────────────────────
+/**
+ * search(cwd, query, { wing, room, limit }) → drawer[]
+ * BM25 across all drawers + closet-topic boost, filtered by wing/room.
+ * Bumps score on retrieved drawers so L1 surfaces actually-used content.
+ */
+function search(cwd, query, opts) {
+  opts = opts || {};
+  var limit       = opts.limit || 5;
+  var pDir        = palaceDir(cwd);
+  var drawersFile = path.join(pDir, 'drawers.jsonl');
+  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; });
+  if (drawers.length === 0) return [];
+
+  // BM25 baseline
+  var docs   = drawers.map(function(d) { return { id: d.id, text: d.content }; });
+  var ranked = bm25(query, docs);
+
+  // Closet boost: drawers whose topic terms match query words get +0.5
+  try {
+    var closets     = readJsonl(path.join(pDir, 'closets.jsonl'));
+    var qWords      = tokenize(query);
+    var closetBoost = {};
+    closets.forEach(function(c) {
+      var termWords = tokenize(c.term);
+      var hit = termWords.some(function(w) { return qWords.indexOf(w) !== -1; });
+      if (hit) closetBoost[c.drawerId] = (closetBoost[c.drawerId] || 0) + 0.5;
+    });
+    if (Object.keys(closetBoost).length > 0) {
+      ranked.forEach(function(r) { r.score += (closetBoost[r.id] || 0); });
+      ranked.sort(function(a, b) { return b.score - a.score; });
+    }
+  } catch (e) { /* non-fatal */ }
+
+  var topIds = ranked.slice(0, limit).map(function(r) { return r.id; });
+  _bumpScores(drawersFile, topIds);
+
+  var drawerMap = {};
+  drawers.forEach(function(d) { drawerMap[d.id] = d; });
+  return topIds.map(function(id) { return drawerMap[id]; }).filter(Boolean);
+}
+
+// ── recall (L2 on-demand) ─────────────────────────────────────────────────────
+/**
+ * recall(cwd, { wing, room, limit }) → drawer[]
+ * Returns drawers matching the namespace, sorted by score desc.
+ * Bumps score on returned drawers.
+ */
+function recall(cwd, opts) {
+  opts = opts || {};
+  var limit       = opts.limit || 10;
+  var drawersFile = path.join(palaceDir(cwd), 'drawers.jsonl');
+  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
+    .sort(function(a, b) { return (b.score || 0) - (a.score || 0); })
+    .slice(0, limit);
+  _bumpScores(drawersFile, top.map(function(d) { return d.id; }));
+  return top;
+}
+
+// ── knowledge graph ───────────────────────────────────────────────────────────
+/**
+ * kgAdd(cwd, subject, predicate, object, validFrom, confidence, sourceId)
+ * Appends a temporal triple. validFrom defaults to now; valid_to = null (open).
+ */
+function kgAdd(cwd, subject, predicate, object, validFrom, confidence, sourceId) {
+  var pDir = palaceDir(cwd);
+  ensureDir(pDir);
+  var kgFile = path.join(pDir, 'kg.json');
+  var kg     = readJson(kgFile, []);
+  kg.push({
+    id:         uid(),
+    subject:    String(subject),
+    predicate:  String(predicate),
+    object:     String(object),
+    valid_from: validFrom || new Date().toISOString(),
+    valid_to:   null,
+    confidence: typeof confidence === 'number' ? confidence : 1.0,
+    source_id:  sourceId || null,
+    created_at: new Date().toISOString(),
+  });
+  writeJson(kgFile, kg);
+}
+
+/**
+ * kgQuery(cwd, entity, asOf) → triple[]
+ * Triples where subject = entity, valid at the given time (defaults to now).
+ */
+function kgQuery(cwd, entity, asOf) {
+  var kgFile = path.join(palaceDir(cwd), 'kg.json');
+  var kg     = readJson(kgFile, []);
+  var t      = asOf ? new Date(asOf).getTime() : Date.now();
+  return kg.filter(function(triple) {
+    if (triple.subject !== entity) return false;
+    var from = triple.valid_from ? new Date(triple.valid_from).getTime() : 0;
+    var to   = triple.valid_to   ? new Date(triple.valid_to).getTime()   : Infinity;
+    return t >= from && t <= to;
+  });
+}
+
+/**
+ * kgTimeline(cwd, entity) → triple[] (chronological)
+ * Full history of facts about entity, sorted by valid_from.
+ */
+function kgTimeline(cwd, entity) {
+  var kgFile = path.join(palaceDir(cwd), 'kg.json');
+  var kg     = readJson(kgFile, []);
+  return kg
+    .filter(function(t) { return t.subject === entity; })
+    .sort(function(a, b) {
+      return new Date(a.valid_from).getTime() - new Date(b.valid_from).getTime();
+    });
+}
+
+// ── wakeUp (L0 + L1 injection) ───────────────────────────────────────────────
+/**
+ * wakeUp(cwd) → string
+ * Loads L0 identity context + generates L1 essential story from top-scored
+ * recent drawers. Returns a string for console.log injection into session.
+ */
+function wakeUp(cwd) {
+  var pDir  = palaceDir(cwd);
+  var lines = [];
+
+  // L0 — identity.md (user-maintained, static)
+  var identityFile = path.join(pDir, 'identity.md');
+  if (fs.existsSync(identityFile)) {
+    try {
+      var identity = fs.readFileSync(identityFile, 'utf-8').trim();
+      if (identity) {
+        lines.push('[MEMORY_PALACE_L0] Identity:');
+        lines.push(identity);
+      }
+    } catch (e) { /* non-fatal */ }
+  }
+
+  // L1 — essential story: top-scored drawers from last L1_DAYS days
+  var drawersFile = path.join(pDir, 'drawers.jsonl');
+  if (fs.existsSync(drawersFile)) {
+    try {
+      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;
+      });
+      var top = recent
+        .sort(function(a, b) { return (b.score || 0) - (a.score || 0); })
+        .slice(0, L1_LIMIT);
+
+      if (top.length > 0) {
+        lines.push('[MEMORY_PALACE_L1] Essential story (' + top.length + ' drawer' + (top.length !== 1 ? 's' : '') + '):');
+        top.forEach(function(d) {
+          var ns      = (d.wing || '?') + '/' + (d.room || '?') + (d.hall ? '/' + d.hall : '');
+          var dateStr = d.ts ? d.ts.slice(0, 10) : '?';
+          var snippet = (d.content || '').slice(0, 300).replace(/\n/g, ' ');
+          lines.push('[' + ns + ' ' + dateStr + '] ' + snippet);
+        });
+      }
+    } catch (e) { /* non-fatal */ }
+  }
+
+  return lines.join('\n');
+}
+
+// ── exports ───────────────────────────────────────────────────────────────────
+module.exports = {
+  wakeUp,
+  storeVerbatim,
+  buildClosets,
+  search,
+  recall,
+  bm25,
+  kgAdd,
+  kgQuery,
+  kgTimeline,
+};

package/.claude/helpers/memory.cjs

@@ -1,43 +1,153 @@
 'use strict';
 /**
  * Memory context bridge for hook-handler.cjs
- * Bridges to the CLI memory subsystem via file-based storage fallback.
- * Used by handlers to retrieve relevant context and store outcomes.
+ * Also usable as a CLI script: node memory.cjs [get|set|delete|clear|keys] [args...]
+ *
+ * CLI data path: $CLAUDE_PROJECT_DIR/.monomind/data/memory.json  (or process.cwd())
+ * Module API:    store(key, value, namespace), retrieve(query, namespace)
  */
 
 const path = require('path');
 const fs = require('fs');
 
 const CWD = process.env.CLAUDE_PROJECT_DIR || process.cwd();
-const MEMORY_DIR = path.join(CWD, '.monomind', 'memory');
-const MEMORY_INDEX = path.join(MEMORY_DIR, 'hook-memory.json');
 
-function ensureDir() {
-  try { fs.mkdirSync(MEMORY_DIR, { recursive: true }); } catch (_) {}
+// ── CLI storage (flat JSON key→value map) ─────────────────────────────────────
+
+const DATA_DIR = path.join(CWD, '.monomind', 'data');
+const MEMORY_FILE = path.join(DATA_DIR, 'memory.json');
+
+function ensureDataDir() {
+  try { fs.mkdirSync(DATA_DIR, { recursive: true }); } catch (_) {}
+}
+
+function loadMemory() {
+  try {
+    if (!fs.existsSync(MEMORY_FILE)) return {};
+    var st = fs.statSync(MEMORY_FILE);
+    if (st.size > 10 * 1024 * 1024) return {};
+    return JSON.parse(fs.readFileSync(MEMORY_FILE, 'utf-8'));
+  } catch (_) {
+    return {};
+  }
+}
+
+function saveMemory(data) {
+  ensureDataDir();
+  try {
+    fs.writeFileSync(MEMORY_FILE, JSON.stringify(data, null, 2), 'utf-8');
+  } catch (_) {}
+}
+
+// ── CLI commands ──────────────────────────────────────────────────────────────
+
+function cmdGet(key) {
+  var data = loadMemory();
+  if (!key) {
+    // Return all non-internal keys
+    var out = {};
+    for (var k in data) {
+      if (!k.startsWith('_')) out[k] = data[k];
+    }
+    process.stdout.write(JSON.stringify(out) + '\n');
+    return;
+  }
+  if (Object.prototype.hasOwnProperty.call(data, key)) {
+    process.stdout.write(JSON.stringify(data[key]) + '\n');
+  } else {
+    process.stdout.write('undefined\n');
+  }
+  process.exit(0);
+}
+
+function cmdSet(key, value) {
+  if (!key) {
+    process.stderr.write('Key required\n');
+    process.exit(1);
+  }
+  var data = loadMemory();
+  data[key] = value;
+  data._updated = new Date().toISOString();
+  saveMemory(data);
+  process.stdout.write('Set: ' + key + '\n');
+  process.exit(0);
+}
+
+function cmdDelete(key) {
+  if (!key) {
+    process.stderr.write('Key required\n');
+    process.exit(1);
+  }
+  var data = loadMemory();
+  delete data[key];
+  data._updated = new Date().toISOString();
+  saveMemory(data);
+  process.stdout.write('Deleted: ' + key + '\n');
+  process.exit(0);
+}
+
+function cmdClear() {
+  saveMemory({});
+  process.stdout.write('Memory cleared\n');
+  process.exit(0);
+}
+
+function cmdKeys() {
+  var data = loadMemory();
+  var keys = Object.keys(data).filter(function(k) { return !k.startsWith('_'); });
+  if (keys.length > 0) {
+    process.stdout.write(keys.join('\n') + '\n');
+  } else {
+    process.stdout.write('');
+  }
+  process.exit(0);
+}
+
+function cmdUsage() {
+  process.stdout.write(
+    'Usage: memory.cjs [get|set|delete|clear|keys] [key] [value...]\n' +
+    '  get [key]         — get a key or all keys\n' +
+    '  set <key> <value> — set a key\n' +
+    '  delete <key>      — delete a key\n' +
+    '  clear             — clear all keys\n' +
+    '  keys              — list all user-defined keys\n'
+  );
+  process.exit(0);
+}
+
+// ── Module API (for hook-handler.cjs require()) ───────────────────────────────
+
+const HOOK_MEMORY_DIR = path.join(CWD, '.monomind', 'memory');
+const HOOK_MEMORY_INDEX = path.join(HOOK_MEMORY_DIR, 'hook-memory.json');
+var MAX_INDEX_SIZE = 50 * 1024 * 1024;
+
+function ensureHookDir() {
+  try { fs.mkdirSync(HOOK_MEMORY_DIR, { recursive: true }); } catch (_) {}
 }
 
 function loadIndex() {
   try {
-    if (!fs.existsSync(MEMORY_INDEX)) return [];
-    return JSON.parse(fs.readFileSync(MEMORY_INDEX, 'utf-8'));
+    if (!fs.existsSync(HOOK_MEMORY_INDEX)) return [];
+    var st = fs.statSync(HOOK_MEMORY_INDEX);
+    if (st.size > MAX_INDEX_SIZE) return [];
+    return JSON.parse(fs.readFileSync(HOOK_MEMORY_INDEX, 'utf-8'));
   } catch (_) {
     return [];
   }
 }
 
 function saveIndex(entries) {
-  ensureDir();
+  ensureHookDir();
   try {
-    // Keep most recent 500 entries
     var trimmed = entries.slice(-500);
-    fs.writeFileSync(MEMORY_INDEX, JSON.stringify(trimmed, null, 2), 'utf-8');
+    fs.writeFileSync(HOOK_MEMORY_INDEX, JSON.stringify(trimmed, null, 2), 'utf-8');
   } catch (_) {}
 }
 
 function store(key, value, namespace) {
   var entries = loadIndex();
-  var ns = namespace || 'default';
-  // Remove existing entry with same key+namespace
+  var ns = String(namespace || 'default').slice(0, 128);
+  key = String(key || '').slice(0, 512);
   entries = entries.filter(function(e) { return !(e.key === key && e.namespace === ns); });
   entries.push({ key: key, value: value, namespace: ns, storedAt: new Date().toISOString() });
   saveIndex(entries);
@@ -48,7 +158,6 @@ function retrieve(query, namespace) {
   var ns = namespace || null;
   if (ns) entries = entries.filter(function(e) { return e.namespace === ns; });
   if (!query) return entries.slice(-10);
-  // Simple keyword search
   var q = String(query).toLowerCase();
   var scored = entries.map(function(e) {
     var text = (e.key + ' ' + JSON.stringify(e.value || '')).toLowerCase();
@@ -66,4 +175,19 @@ function retrieve(query, namespace) {
     .map(function(s) { return s.entry; });
 }
 
+// ── Entry point: run CLI when spawned directly ────────────────────────────────
+
+if (require.main === module) {
+  var args = process.argv.slice(2);
+  var cmd = args[0];
+  switch (cmd) {
+    case 'get':    cmdGet(args[1]); break;
+    case 'set':    cmdSet(args[1], args.slice(2).join(' ')); break;
+    case 'delete': cmdDelete(args[1]); break;
+    case 'clear':  cmdClear(); break;
+    case 'keys':   cmdKeys(); break;
+    default:       cmdUsage(); break;
+  }
+}
+
 module.exports = { store, retrieve };