claude-mem-lite 2.38.0 → 2.39.0

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "2.38.0",
+      "version": "2.39.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.38.0",
+  "version": "2.39.0",
   "description": "Lightweight persistent memory system for Claude Code — FTS5 search, episode batching, error-triggered recall",
   "author": {
     "name": "sdsrss"

package/hook-memory.mjs

@@ -1,7 +1,7 @@
 // claude-mem-lite — Semantic Memory Injection
 // Search past observations for relevant memories to inject as context at user-prompt time.
 
-import { sanitizeFtsQuery, relaxFtsQueryToOr, debugCatch, OBS_BM25, notLowSignalTitleClause, noisePenaltyClause } from './utils.mjs';
+import { sanitizeFtsQuery, relaxFtsQueryToOr, debugCatch, OBS_BM25, notLowSignalTitleClause, noisePenaltyClause, tokenizeHandoff, HANDOFF_STOP_WORDS, extractCjkKeywords } from './utils.mjs';
 
 const MAX_MEMORY_INJECTIONS = 3;
 const MEMORY_LOOKBACK_MS = 60 * 86400000; // 60 days
@@ -16,6 +16,43 @@ const BM25_THRESHOLD = { TINY: 0, SMALL: 1.5, MEDIUM: 2.5, LARGE: 3.5 };
 // OR fallback max token count — queries with 3+ tokens that fail AND are likely off-topic
 const OR_FALLBACK_MAX_TOKENS = 2;
 
+// v27: term-coverage post-filter. Drops high-BM25 candidates whose visible
+// fields (title + lesson_learned) cover <N% of the query's significant terms.
+// Catches the failure mode where FTS tokenization reduces a rich query to a
+// sparse token set and rows sharing only one common word get ranked high.
+// Default 0.4 (≥40% term coverage). Env override `MEM_COVERAGE_THRESHOLD` ∈ [0,1];
+// set to 0 to disable entirely.
+const COVERAGE_MIN_QUERY_TERMS = 2;
+function getCoverageThreshold() {
+  const raw = process.env.MEM_COVERAGE_THRESHOLD;
+  if (raw === undefined || raw === '') return 0.4;
+  const n = parseFloat(raw);
+  return Number.isFinite(n) && n >= 0 && n <= 1 ? n : 0.4;
+}
+function extractQueryTerms(text) {
+  if (!text) return [];
+  const ascii = tokenizeHandoff(text).filter(t => !HANDOFF_STOP_WORDS.has(t));
+  let cjk = [];
+  try { cjk = extractCjkKeywords(text) || []; } catch { /* CJK extraction best-effort */ }
+  return [...new Set([...ascii, ...cjk.map(t => String(t).toLowerCase())])];
+}
+function candidateCoverage(row, queryTerms) {
+  if (queryTerms.length === 0) return 1.0;
+  const hay = `${row.title || ''} ${row.lesson_learned || ''}`.toLowerCase();
+  let hits = 0;
+  for (const t of queryTerms) {
+    if (/[^ -~]/.test(t)) {
+      // Non-ASCII (CJK etc): no word boundary semantics, substring match is correct.
+      if (hay.includes(t)) hits++;
+    } else {
+      // ASCII: require word-boundary match so "race" doesn't match "trace".
+      const re = new RegExp(`\\b${t.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'i');
+      if (re.test(hay)) hits++;
+    }
+  }
+  return hits / queryTerms.length;
+}
+
 const FILE_RECALL_LOOKBACK_MS = 60 * 86400000; // 60 days
 const MAX_FILE_RECALL = 2;
 
@@ -142,13 +179,27 @@ export function searchRelevantMemories(db, userPrompt, project, excludeIds = [])
     const aboveThreshold = scored.filter(r => r.score >= threshold);
     if (aboveThreshold.length === 0) return [];
 
+    // v27: term-coverage filter — drop candidates whose title+lesson_learned
+    // covers <threshold of the query's significant terms. Skipped for
+    // single-term queries (coverage signal is meaningless) and when the env
+    // override disables it.
+    let coverageFiltered = aboveThreshold;
+    const coverageThreshold = getCoverageThreshold();
+    if (coverageThreshold > 0) {
+      const queryTerms = extractQueryTerms(userPrompt);
+      if (queryTerms.length >= COVERAGE_MIN_QUERY_TERMS) {
+        coverageFiltered = aboveThreshold.filter(r => candidateCoverage(r, queryTerms) >= coverageThreshold);
+        if (coverageFiltered.length === 0) return [];
+      }
+    }
+
     // v26 P0: bump injection_count (NOT access_count) for injected rows.
     // Before v26 this was bumping access_count, which conflated auto-injection
     // with real cites/recalls/opens — polluting the noise-ratio signal the
     // penalty clause now depends on. access_count is reserved for explicit
     // access (cmdRecall/cmdGet/cmdTimeline/pre-tool-recall/citation-tracker).
     // Per-row try/catch for FTS trigger safety (project_non_obvious.md).
-    const result = aboveThreshold.slice(0, MAX_MEMORY_INJECTIONS);
+    const result = coverageFiltered.slice(0, MAX_MEMORY_INJECTIONS);
     const now = Date.now();
     const bumpStmt = db.prepare(
       'UPDATE observations SET injection_count = COALESCE(injection_count, 0) + 1, last_injected_at = ? WHERE id = ?'

package/mem-cli.mjs

@@ -783,7 +783,32 @@ function cmdTimeline(db, args) {
       anchorId = nearest.id;
       anchorNote = `(anchored to #${nearest.id}, closest obs to S#${parsed.id})`;
     } else {
-      anchorId = parsed.id;
+      // Bare integer (no prefix): try observation first. Fall back to user_prompts
+      // then session_summaries so pasted P#/S# IDs still work when the prefix is
+      // omitted — matches the prefix-aware routing used by search/probe.
+      const obsExists = db.prepare('SELECT 1 FROM observations WHERE id = ?').get(parsed.id);
+      if (obsExists) {
+        anchorId = parsed.id;
+      } else {
+        const promptRow = db.prepare('SELECT created_at_epoch FROM user_prompts WHERE id = ?').get(parsed.id);
+        const sessionRow = promptRow ? null : db.prepare('SELECT created_at_epoch FROM session_summaries WHERE id = ?').get(parsed.id);
+        const hit = promptRow ? { row: promptRow, prefix: 'P', name: 'prompt' }
+                  : sessionRow ? { row: sessionRow, prefix: 'S', name: 'session' }
+                  : null;
+        if (!hit) {
+          fail(`[mem] Observation, prompt, or session with id ${parsed.id} not found`);
+          return;
+        }
+        const proj = project;
+        const nearest = db.prepare(`
+          SELECT id FROM observations
+          WHERE COALESCE(compressed_into, 0) = 0 ${proj ? 'AND project = ?' : ''}
+          ORDER BY ABS(created_at_epoch - ?) ASC LIMIT 1
+        `).get(...(proj ? [proj, hit.row.created_at_epoch] : [hit.row.created_at_epoch]));
+        if (!nearest) { fail(`[mem] No observations near ${hit.prefix}#${parsed.id} (${hit.name})`); return; }
+        anchorId = nearest.id;
+        anchorNote = `(anchored to #${nearest.id}, closest obs to ${hit.prefix}#${parsed.id})`;
+      }
     }
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "2.38.0",
+  "version": "2.39.0",
   "description": "Lightweight persistent memory system for Claude Code",
   "type": "module",
   "engines": {