claude-mem-lite 2.24.2 → 2.26.0

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "2.24.2",
+      "version": "2.26.0",
       "source": "./",
       "description": "Lightweight persistent memory system for Claude Code — FTS5 search, episode batching, error-triggered recall"
     }

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "2.24.2",
+  "version": "2.26.0",
   "description": "Lightweight persistent memory system for Claude Code — FTS5 search, episode batching, error-triggered recall",
   "author": {
     "name": "sdsrss"

package/cli.mjs

@@ -21,6 +21,21 @@ if (cmd === '--version' || cmd === '-v') {
   await main(process.argv.slice(2));
 } else {
   process.stderr.write(`[mem] Unknown command: "${cmd}"\n`);
-  process.stderr.write('[mem] Run "claude-mem-lite help" for CLI commands or "claude-mem-lite install" for setup\n');
+  // Suggest closest command by edit distance
+  const allCmds = [...CLI_COMMANDS, ...INSTALL_COMMANDS];
+  let best = null, bestDist = Infinity;
+  for (const c of allCmds) {
+    const a = cmd.toLowerCase(), b = c;
+    const m = a.length, n = b.length;
+    if (Math.abs(m - n) > 2) continue;
+    const d = Array.from({ length: m + 1 }, (_, i) => Array.from({ length: n + 1 }, (_, j) => i === 0 ? j : j === 0 ? i : 0));
+    for (let i = 1; i <= m; i++) for (let j = 1; j <= n; j++) d[i][j] = Math.min(d[i-1][j] + 1, d[i][j-1] + 1, d[i-1][j-1] + (a[i-1] !== b[j-1] ? 1 : 0));
+    if (d[m][n] < bestDist) { bestDist = d[m][n]; best = c; }
+  }
+  if (best && bestDist <= 2) {
+    process.stderr.write(`[mem] Did you mean: ${best}?\n`);
+  } else {
+    process.stderr.write('[mem] Run "claude-mem-lite help" for CLI commands or "claude-mem-lite install" for setup\n');
+  }
   process.exitCode = 1;
 }

package/hook-episode.mjs

@@ -133,7 +133,6 @@ export function createEpisode(sessionId, project) {
     files: [],
     entries: [],
     filesRead: [],
-    fileHistoryShown: [],
   };
 }
 

package/hook-llm.mjs

@@ -63,7 +63,7 @@ export function saveObservation(obs, projectOverride, sessionIdOverride, externa
     // "Error in X", "Modified X" titles are low-specificity → use longer dedup window
     // 7-day exact match prevents cross-day accumulation of "Modified package.json" noise;
     // 3-day Jaccard catches near-duplicates without blocking legitimately new observations
-    const LOW_SIGNAL = /^(Error (while working|in)|Modified |Worked on |Reviewed \d+ files:)/;
+    const LOW_SIGNAL = /^(Error (while working|in)|Error: |Modified |Worked on |Reviewed \d+ files:|# |node |npm |npx |\(no description\)|\(error\)$)/;
     if (obs.title && LOW_SIGNAL.test(obs.title)) {
       const sevenDaysAgo = now.getTime() - 7 * 86400000;
       const threeDaysAgo = now.getTime() - 3 * 86400000;
@@ -264,9 +264,10 @@ export function buildDegradedTitle(episode) {
     if (hasEdit) return `Modified ${names}${suffix}`;
     return `Worked on ${names}${suffix}`;
   }
-  // No files: strip raw JSON output from Bash descriptions
+  // No files: strip raw output (JSON, arrays, long tails) from Bash descriptions
   const desc = episode.entries[0]?.desc || '(no description)';
-  return desc.replace(/ → (?:ERROR: )?\{.*$/, hasError ? ' (error)' : '');
+  return desc.replace(/ → (?:ERROR: )?[\[{].*$/, hasError ? ' (error)' : '')
+    .replace(/ → .*---EXIT:\d+$/, hasError ? ' (error)' : '');
 }
 
 /**
@@ -300,7 +301,7 @@ export function buildImmediateObservation(episode) {
   const ruleImportance = computeRuleImportance(episode);
   // Low-signal degraded titles ("Error in...", "Modified...") should not inflate importance.
   // Cap at 1 unless rule-based signals indicate genuine importance (error-in-test → 3, config → 2).
-  const LOW_SIGNAL = /^(Error (while working|in)|Modified |Worked on |Reviewed \d+ files:)/;
+  const LOW_SIGNAL = /^(Error (while working|in)|Error: |Modified |Worked on |Reviewed \d+ files:|# |node |npm |npx |\(no description\)|\(error\)$)/;
   const isLowSignal = LOW_SIGNAL.test(title);
   let importance;
   if (isReviewPattern) {

package/hook.mjs

@@ -28,7 +28,7 @@ import {
   spawnBackground,
 } from './hook-shared.mjs';
 import { handleLLMEpisode, handleLLMSummary, saveObservation, buildImmediateObservation } from './hook-llm.mjs';
-import { searchRelevantMemories, recallForFile } from './hook-memory.mjs';
+import { searchRelevantMemories } from './hook-memory.mjs';
 import { buildAndSaveHandoff, detectContinuationIntent, renderHandoffInjection, extractUnfinishedSummary } from './hook-handoff.mjs';
 import { checkForUpdate } from './hook-update.mjs';
 import { SKIP_TOOLS, SKIP_PREFIXES } from './skip-tools.mjs';
@@ -225,28 +225,7 @@ async function handlePostToolUse() {
     episode.lastAt = Date.now();
     addFileToEpisode(episode, files);
 
-    // Proactive file history: show past observations for files being edited
-    // Uses recallForFile for importance>=2 with lesson context
-    if (EDIT_TOOLS.has(tool_name) && files.length > 0) {
-      const d = getDb();
-      if (d) {
-        for (const f of files) {
-          if (episode.fileHistoryShown?.includes(f)) continue;
-          try {
-            const recalled = recallForFile(d, f, project);
-            if (recalled.length > 0) {
-              const hints = recalled.map(r => {
-                const lesson = r.lesson_learned ? ` | ${r.lesson_learned}` : '';
-                return `  #${r.id} [${r.type}] ${truncate(r.title, 60)}${lesson}`;
-              }).join('\n');
-              process.stdout.write(`[claude-mem-lite] History for ${basename(f)}:\n${hints}\n`);
-            }
-          } catch (e) { debugCatch(e, 'fileHistory'); }
-          if (!episode.fileHistoryShown) episode.fileHistoryShown = [];
-          episode.fileHistoryShown.push(f);
-        }
-      }
-    }
+    // File history injection moved to PreToolUse hook (scripts/pre-tool-recall.js)
 
     writeEpisode(episode);
 
@@ -466,7 +445,7 @@ async function handleSessionStart() {
       }
     })();
 
-    // Auto-purge: delete stale observations daily (COMPRESSED_PENDING_PURGE, 7-day retention)
+    // Auto-maintain: cleanup + decay + boost + purge, gated to once per 24h
     const maintainFile = join(RUNTIME_DIR, 'last-auto-maintain.json');
     let shouldMaintain = true;
     try {
@@ -475,13 +454,69 @@ async function handleSessionStart() {
     } catch {}
     if (shouldMaintain) {
       try {
+        const STALE_AGE = Date.now() - 30 * 86400000;
+        const OP_CAP = 500;
+
+        // Purge FIRST: delete entries already marked pending-purge from previous cycles (7-day retention)
+        // Must run before decay/idle-mark to avoid same-cycle delete of newly-marked entries
         const purged = db.prepare(`
           DELETE FROM observations WHERE compressed_into = ${COMPRESSED_PENDING_PURGE}
             AND created_at_epoch < ?
         `).run(Date.now() - 7 * 86400000);
-        if (purged.changes > 0) {
-          debugLog('DEBUG', 'session-start', `auto-purged ${purged.changes} stale observations`);
-        }
+        if (purged.changes > 0) debugLog('DEBUG', 'auto-maintain', `purged ${purged.changes} stale observations`);
+
+        // Cleanup: remove broken observations (no title AND no narrative)
+        const cleaned = db.prepare(`
+          DELETE FROM observations WHERE id IN (
+            SELECT id FROM observations
+            WHERE COALESCE(compressed_into, 0) = 0
+              AND (title IS NULL OR title = '') AND (narrative IS NULL OR narrative = '')
+            LIMIT ${OP_CAP}
+          )
+        `).run();
+        if (cleaned.changes > 0) debugLog('DEBUG', 'auto-maintain', `cleaned ${cleaned.changes} broken observations`);
+
+        // Decay: reduce importance of old, never-accessed observations
+        const decayed = db.prepare(`
+          UPDATE observations SET importance = MAX(1, COALESCE(importance, 1) - 1)
+          WHERE id IN (
+            SELECT id FROM observations
+            WHERE COALESCE(compressed_into, 0) = 0
+              AND COALESCE(importance, 1) > 1
+              AND COALESCE(access_count, 0) = 0
+              AND created_at_epoch < ?
+            LIMIT ${OP_CAP}
+          )
+        `).run(STALE_AGE);
+        if (decayed.changes > 0) debugLog('DEBUG', 'auto-maintain', `decayed ${decayed.changes} stale observations`);
+
+        // Mark idle: importance=1, never-accessed, old → pending-purge (will be purged next cycle)
+        const idleMarked = db.prepare(`
+          UPDATE observations SET compressed_into = ${COMPRESSED_PENDING_PURGE}
+          WHERE id IN (
+            SELECT id FROM observations
+            WHERE COALESCE(compressed_into, 0) = 0
+              AND COALESCE(importance, 1) = 1
+              AND COALESCE(access_count, 0) = 0
+              AND created_at_epoch < ?
+            LIMIT ${OP_CAP}
+          )
+        `).run(STALE_AGE);
+        if (idleMarked.changes > 0) debugLog('DEBUG', 'auto-maintain', `marked ${idleMarked.changes} idle as pending-purge`);
+
+        // Boost: increase importance of frequently-accessed observations
+        const boosted = db.prepare(`
+          UPDATE observations SET importance = MIN(3, COALESCE(importance, 1) + 1)
+          WHERE id IN (
+            SELECT id FROM observations
+            WHERE COALESCE(compressed_into, 0) = 0
+              AND COALESCE(access_count, 0) > 3
+              AND COALESCE(importance, 1) < 3
+            LIMIT ${OP_CAP}
+          )
+        `).run();
+        if (boosted.changes > 0) debugLog('DEBUG', 'auto-maintain', `boosted ${boosted.changes} frequently-accessed observations`);
+
         // Mark maintenance as done (24h gate) — even though compression runs in background
         writeFileSync(maintainFile, JSON.stringify({ epoch: Date.now() }));
         // Weekly summary grouping runs in background to avoid blocking SessionStart
@@ -650,23 +685,50 @@ async function handleSessionStart() {
     const summaryLines = buildSummaryLines(latestSummary);
 
     // Key context: top high-importance observations for CLAUDE.md persistence
+    // Split into "File Lessons" (actionable, has lesson + file) and "Key Context" (informational)
     const keyObs = db.prepare(`
-      SELECT id, type, title, lesson_learned FROM observations
-      WHERE project = ? AND COALESCE(compressed_into, 0) = 0
-        AND COALESCE(importance, 1) >= 2
-      ORDER BY created_at_epoch DESC LIMIT 5
+      SELECT o.id, o.type, o.title, o.lesson_learned, o.files_modified FROM observations o
+      WHERE o.project = ? AND COALESCE(o.compressed_into, 0) = 0
+        AND o.superseded_at IS NULL
+        AND COALESCE(o.importance, 1) >= 2
+      ORDER BY o.created_at_epoch DESC LIMIT 10
     `).all(project);
+
     if (keyObs.length > 0) {
-      summaryLines.push('### Key Context');
+      const fileLessons = [];
+      const keyContext = [];
+
       for (const o of keyObs) {
-        // Strip raw JSON output from degraded Bash-style titles
         const clean = (o.title || '(untitled)')
           .replace(/ → (?:ERROR: )?\{".*$/, '')
           .replace(/ → (?:ERROR: )?\{[^}]*\.{3}$/, '');
-        const lesson = o.lesson_learned ? ` — ${truncate(o.lesson_learned, 60)}` : '';
-        summaryLines.push(`- [${o.type || 'discovery'}] ${truncate(clean, 80)} (#${o.id})${lesson}`);
+        const hasLesson = o.lesson_learned && o.lesson_learned.trim();
+        const hasFiles = o.files_modified && o.files_modified !== '[]';
+
+        if (hasLesson && hasFiles) {
+          try {
+            const files = JSON.parse(o.files_modified);
+            const fname = basename(Array.isArray(files) && files.length > 0 ? files[0] : '');
+            if (fname) {
+              fileLessons.push(`- ${fname}: ${truncate(o.lesson_learned, 100)} (#${o.id})`);
+              continue;
+            }
+          } catch {}
+        }
+        const lesson = hasLesson ? ` — ${truncate(o.lesson_learned, 60)}` : '';
+        keyContext.push(`- [${o.type || 'discovery'}] ${truncate(clean, 80)} (#${o.id})${lesson}`);
+      }
+
+      if (fileLessons.length > 0) {
+        summaryLines.push('### File Lessons');
+        summaryLines.push(...fileLessons.slice(0, 5));
+        summaryLines.push('');
+      }
+      if (keyContext.length > 0) {
+        summaryLines.push('### Key Context');
+        summaryLines.push(...keyContext.slice(0, 5));
+        summaryLines.push('');
       }
-      summaryLines.push('');
     } else if (!latestSummary) {
       // Fallback: no summary AND no key observations — show recent activity
       const recentObs = (observations.length >= 3 ? observations : fallbackObs).slice(0, 3);

package/hooks/hooks.json

@@ -18,6 +18,18 @@
         ]
       }
     ],
+    "PreToolUse": [
+      {
+        "matcher": "Edit|Write|NotebookEdit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/pre-tool-recall.js\"",
+            "timeout": 3
+          }
+        ]
+      }
+    ],
     "PostToolUse": [
       {
         "matcher": "*",

package/install.mjs

@@ -452,20 +452,25 @@ async function install() {
     ]
   };
 
+  const memPreToolUse = {
+    matcher: 'Edit|Write|NotebookEdit',
+    hooks: [
+      {
+        type: 'command',
+        command: `node "${join(SCRIPTS_PATH, 'pre-tool-recall.js')}"`,
+        timeout: 3
+      }
+    ]
+  };
+
   // Filter out existing mem hooks, then append fresh ones
-  for (const [event, config] of [['PostToolUse', memPostToolUse], ['SessionStart', memSessionStart], ['Stop', memStop], ['UserPromptSubmit', memUserPrompt]]) {
+  for (const [event, config] of [['PreToolUse', memPreToolUse], ['PostToolUse', memPostToolUse], ['SessionStart', memSessionStart], ['Stop', memStop], ['UserPromptSubmit', memUserPrompt]]) {
     const existing = Array.isArray(settings.hooks[event]) ? settings.hooks[event].filter(cfg => !isMemHook(cfg)) : [];
     settings.hooks[event] = [...existing, config];
   }
 
-  // Clean up stale PreToolUse hook from previous versions
-  if (Array.isArray(settings.hooks.PreToolUse)) {
-    settings.hooks.PreToolUse = settings.hooks.PreToolUse.filter(cfg => !isMemHook(cfg));
-    if (settings.hooks.PreToolUse.length === 0) delete settings.hooks.PreToolUse;
-  }
-
   writeSettings(settings);
-  ok('Hooks configured (PostToolUse, SessionStart, Stop, UserPromptSubmit)');
+  ok('Hooks configured (PreToolUse, PostToolUse, SessionStart, Stop, UserPromptSubmit)');
 
   // 5. Migrate from old ~/.claude-mem/ if needed
   if (existsSync(join(OLD_DATA_DIR, 'claude-mem.db')) && !existsSync(DB_PATH) && !existsSync(join(DATA_DIR, 'claude-mem.db'))) {

package/mem-cli.mjs

@@ -82,8 +82,14 @@ function cmdSearch(db, args) {
     return;
   }
 
-  const limit = Math.max(1, parseInt(flags.limit, 10) || 20);
+  const rawLimit = flags.limit !== undefined ? parseInt(flags.limit, 10) : NaN;
+  const limit = Number.isInteger(rawLimit) ? Math.max(1, rawLimit) : 20;
   const type = flags.type || null;
+  const validObsTypes = new Set(['decision', 'bugfix', 'feature', 'refactor', 'discovery', 'change']);
+  if (type && !validObsTypes.has(type)) {
+    fail(`[mem] Invalid --type "${type}". Valid: ${[...validObsTypes].join(', ')}`);
+    return;
+  }
   const source = flags.source || null; // observations|sessions|prompts (null = all)
   const project = flags.project ? resolveProject(db, flags.project) : null;
   const dateFrom = flags.from ? new Date(flags.from).getTime() : null;
@@ -91,10 +97,18 @@ function cmdSearch(db, args) {
   if (dateTo && flags.to && /^\d{4}-\d{2}-\d{2}$/.test(flags.to)) dateTo += 86400000 - 1;
   if (flags.from && isNaN(dateFrom)) { fail(`[mem] Invalid --from date: "${flags.from}". Use YYYY-MM-DD or ISO 8601.`); return; }
   if (flags.to && isNaN(dateTo)) { fail(`[mem] Invalid --to date: "${flags.to}". Use YYYY-MM-DD or ISO 8601.`); return; }
-  const minImportance = flags.importance ? parseInt(flags.importance, 10) : null;
+  const minImportance = flags.importance !== undefined ? parseInt(flags.importance, 10) : null;
+  if (minImportance !== null && (isNaN(minImportance) || minImportance < 1 || minImportance > 3)) {
+    fail(`[mem] Invalid --importance "${flags.importance}". Must be 1, 2, or 3.`);
+    return;
+  }
   const branch = flags.branch || null;
   const offset = Math.max(0, parseInt(flags.offset, 10) || 0);
   const tier = flags.tier || null;
+  if (tier && !['working', 'active', 'archive'].includes(tier)) {
+    fail(`[mem] Invalid --tier "${tier}". Use: working, active, archive`);
+    return;
+  }
   const sort = flags.sort || 'relevance';
   if (!['relevance', 'time', 'importance'].includes(sort)) {
     fail(`[mem] Invalid --sort "${sort}". Use: relevance, time, importance`);
@@ -305,7 +319,8 @@ function cmdSearch(db, args) {
   }
 
   const showTime = sort === 'time';
-  out(`[mem] ${paged.length} result${paged.length !== 1 ? 's' : ''} for "${query}":`);
+  const hasMixed = paged.some(r => r._source === 'session' || r._source === 'prompt');
+  out(`[mem] ${paged.length} result${paged.length !== 1 ? 's' : ''} for "${query}":${hasMixed ? ' (# observation, S# session, P# prompt)' : ''}`);
   for (const r of paged) {
     const timeStr = showTime && r.created_at_epoch ? ` (${relativeTime(r.created_at_epoch)})` : '';
     if (r._source === 'session') {
@@ -464,7 +479,8 @@ function cmdRecall(db, args) {
   }
 
   const filename = basename(file);
-  const limit = Math.max(1, parseInt(flags.limit, 10) || 10);
+  const rawLimit = flags.limit !== undefined ? parseInt(flags.limit, 10) : NaN;
+  const limit = Number.isInteger(rawLimit) ? Math.max(1, rawLimit) : 10;
 
   // Search via observation_files junction table for indexed filename lookups
   const escaped = filename.replace(/%/g, '\\%').replace(/_/g, '\\_');
@@ -549,7 +565,19 @@ function cmdGet(db, args) {
 
   // Default: observations (aligned with MCP mem_get)
   const OBS_FIELDS = ['id', 'type', 'title', 'subtitle', 'narrative', 'text', 'facts', 'concepts', 'lesson_learned', 'search_aliases', 'files_read', 'files_modified', 'project', 'created_at', 'memory_session_id', 'prompt_number', 'importance', 'related_ids', 'access_count', 'branch', 'superseded_at', 'superseded_by', 'last_accessed_at'];
-  const requestedFields = flags.fields ? flags.fields.split(',').map(s => s.trim()).filter(f => OBS_FIELDS.includes(f)) : null;
+  let requestedFields = null;
+  if (flags.fields) {
+    const allRequested = flags.fields.split(',').map(s => s.trim());
+    const invalid = allRequested.filter(f => !OBS_FIELDS.includes(f));
+    if (invalid.length > 0) {
+      process.stderr.write(`[mem] Unknown field(s): ${invalid.join(', ')}. Valid: ${OBS_FIELDS.join(', ')}\n`);
+    }
+    requestedFields = allRequested.filter(f => OBS_FIELDS.includes(f));
+    if (requestedFields.length === 0) {
+      fail('[mem] No valid fields specified');
+      return;
+    }
+  }
 
   // Update access_count + auto-boost (aligned with MCP mem_get)
   db.prepare(`UPDATE observations SET access_count = COALESCE(access_count, 0) + 1, last_accessed_at = ? WHERE id IN (${placeholders})`).run(Date.now(), ...ids);
@@ -616,6 +644,9 @@ function cmdTimeline(db, args) {
 
   // No anchor: show most recent observations (aligned with MCP mem_timeline fallback)
   if (!anchorId || isNaN(anchorId)) {
+    if (queryStr) {
+      process.stderr.write(`[mem] No anchor found for "${queryStr}", showing recent timeline\n`);
+    }
     const compressedFilter = 'COALESCE(compressed_into, 0) = 0';
     const projectFilter = project ? `WHERE ${compressedFilter} AND project = ?` : `WHERE ${compressedFilter}`;
     const fallbackParams = project ? [project, before + after + 1] : [before + after + 1];
@@ -952,7 +983,8 @@ function cmdBrowse(db, args) {
     fail(`[mem] Invalid tier: "${tierFilter}". Use: working, active, or archive`);
     return;
   }
-  const limit = Math.max(1, parseInt(flags.limit, 10) || (tierFilter ? 20 : 5));
+  const rawLimit = flags.limit !== undefined ? parseInt(flags.limit, 10) : NaN;
+  const limit = Number.isInteger(rawLimit) ? Math.max(1, rawLimit) : (tierFilter ? 20 : 5);
   const now = Date.now();
 
   const ctx = {
@@ -1185,7 +1217,8 @@ function cmdExport(db, args) {
     wheres.push('created_at_epoch <= ?'); params.push(epoch);
   }
 
-  const limit = Math.min(Math.max(1, parseInt(flags.limit, 10) || 200), 1000);
+  const rawLimit = flags.limit !== undefined ? parseInt(flags.limit, 10) : NaN;
+  const limit = Math.min(Number.isInteger(rawLimit) ? Math.max(1, rawLimit) : 200, 1000);
   const format = flags.format || 'json';
   if (!['json', 'jsonl'].includes(format)) {
     fail(`[mem] Invalid format "${format}". Use: json or jsonl`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "2.24.2",
+  "version": "2.26.0",
   "description": "Lightweight persistent memory system for Claude Code",
   "type": "module",
   "engines": {
@@ -72,6 +72,7 @@
     "scripts/setup.sh",
     "scripts/post-tool-use.sh",
     "scripts/user-prompt-search.js",
+    "scripts/pre-tool-recall.js",
     "scripts/prompt-search-utils.mjs",
     ".mcp.json",
     ".claude-plugin/plugin.json",

package/scripts/pre-tool-recall.js

@@ -0,0 +1,126 @@
+#!/usr/bin/env node
+// claude-mem-lite: PreToolUse file recall — injects lessons before Edit/Write
+// Lightweight standalone (~30ms): only imports better-sqlite3, fs, path, os
+// Safety: readonly DB, exit 0 always, 3s timeout
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { basename, join } from 'path';
+import { homedir } from 'os';
+
+const DB_PATH = join(homedir(), '.claude-mem-lite', 'claude-mem-lite.db');
+const RUNTIME_DIR = join(homedir(), '.claude-mem-lite', 'runtime');
+const COOLDOWN_PATH = join(RUNTIME_DIR, 'pre-recall-cooldown.json');
+const COOLDOWN_MS = 5 * 60 * 1000; // 5 minutes
+const STALE_MS = 10 * 60 * 1000;   // 10 minutes cleanup threshold
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+function inferProject() {
+  const dir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+  const base = basename(dir);
+  const parent = basename(join(dir, '..'));
+  let project = (parent && parent !== '.' && parent !== '/')
+    ? `${parent}--${base}` : base;
+  project = project.replace(/[^a-zA-Z0-9_.-]/g, '-') || 'unknown';
+  return project;
+}
+
+function readCooldown() {
+  try { return JSON.parse(readFileSync(COOLDOWN_PATH, 'utf8')); } catch { return {}; }
+}
+
+function writeCooldown(data) {
+  try {
+    mkdirSync(RUNTIME_DIR, { recursive: true });
+    // Clean stale entries
+    const now = Date.now();
+    const cleaned = {};
+    for (const [k, v] of Object.entries(data)) {
+      if (now - v < STALE_MS) cleaned[k] = v;
+    }
+    writeFileSync(COOLDOWN_PATH, JSON.stringify(cleaned));
+  } catch { /* silent */ }
+}
+
+// ─── Main ───────────────────────────────────────────────────────────────────
+
+try {
+  // Skip if recursive hook
+  if (process.env.CLAUDE_MEM_HOOK_RUNNING) process.exit(0);
+
+  // Skip if DB doesn't exist
+  if (!existsSync(DB_PATH)) process.exit(0);
+
+  // Read stdin
+  let input = '';
+  for await (const chunk of process.stdin) input += chunk;
+
+  // Parse event
+  let filePath;
+  try {
+    const event = JSON.parse(input);
+    filePath = event.tool_input?.file_path;
+  } catch { process.exit(0); }
+
+  if (!filePath) process.exit(0);
+
+  // Cooldown check (full path as key)
+  const cooldown = readCooldown();
+  const now = Date.now();
+  if (cooldown[filePath] && (now - cooldown[filePath]) < COOLDOWN_MS) {
+    process.exit(0);
+  }
+
+  // Open DB readonly
+  const Database = (await import('better-sqlite3')).default;
+  let db;
+  try {
+    db = new Database(DB_PATH, { readonly: true });
+    db.pragma('busy_timeout = 1000');
+  } catch { process.exit(0); }
+
+  try {
+    const project = inferProject();
+    const fname = basename(filePath);
+    // Escape LIKE wildcards
+    const escaped = fname.replace(/%/g, '\\%').replace(/_/g, '\\_');
+    const likePattern = `%${escaped}`;
+    // 60-day lookback to avoid surfacing ancient observations
+    const cutoff = Date.now() - 60 * 86400000;
+
+    const rows = db.prepare(`
+      SELECT DISTINCT o.id, o.type, o.title, o.lesson_learned
+      FROM observations o
+      JOIN observation_files of2 ON of2.obs_id = o.id
+      WHERE o.project = ?
+        AND o.importance >= 2
+        AND o.lesson_learned IS NOT NULL
+        AND o.lesson_learned != ''
+        AND COALESCE(o.compressed_into, 0) = 0
+        AND o.superseded_at IS NULL
+        AND o.created_at_epoch > ?
+        AND (of2.filename = ? OR of2.filename LIKE ? ESCAPE '\\')
+      ORDER BY o.created_at_epoch DESC
+      LIMIT 2
+    `).all(project, cutoff, filePath, likePattern);
+
+    if (rows.length > 0) {
+      console.log(`[mem] Lessons for ${fname}:`);
+      for (const r of rows) {
+        const lesson = r.lesson_learned.length > 120
+          ? r.lesson_learned.slice(0, 117) + '...'
+          : r.lesson_learned;
+        console.log(`  #${r.id} [${r.type}] ${lesson}`);
+      }
+      // Update cooldown
+      cooldown[filePath] = now;
+      writeCooldown(cooldown);
+    }
+  } catch {
+    // Silent failure — never block editing
+  } finally {
+    try { db.close(); } catch {}
+  }
+} catch {
+  // Top-level catch — exit 0 no matter what
+}

package/server.mjs

@@ -488,7 +488,8 @@ function formatSearchOutput(paginatedResults, args, ftsQuery, totalCount, isCros
   const countLabel = isCrossSource && totalCount > paginatedResults.length
     ? `${paginatedResults.length} of ${totalCount}`
     : `${paginatedResults.length}`;
-  lines.push(`Found ${countLabel} result(s)${args.query ? ` for "${args.query}"` : ''}:\n`);
+  const hasMixed = paginatedResults.some(r => r.source === 'session' || r.source === 'prompt');
+  lines.push(`Found ${countLabel} result(s)${args.query ? ` for "${args.query}"` : ''}:${hasMixed ? ' (# observation, S# session, P# prompt)' : ''}\n`);
 
   for (const r of paginatedResults) {
     if (r.source === 'obs') {