claude-mem-lite 2.38.0 → 2.39.1

package/.claude-plugin/marketplace.json

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

package/hook-context.mjs

@@ -369,7 +369,7 @@ export function buildSessionContextLines(db, project, now = new Date(), currentC
     }
     if (prevClearHandoff.unfinished) {
       const pendingSummary = extractUnfinishedSummary(prevClearHandoff.unfinished);
-      if (pendingSummary) handoffLines.push(`- Unfinished: ${truncate(pendingSummary, 200)}`);
+      if (pendingSummary) handoffLines.push(`- Recent activity: ${truncate(pendingSummary, 200)}`);
     }
     if (prevClearHandoff.key_files) {
       try {

package/hook-handoff.mjs

@@ -2,7 +2,7 @@
 // Extracted for testability — hook.mjs has module-level side effects
 
 import { basename } from 'path';
-import { truncate, extractMatchKeywords, tokenizeHandoff, isSpecificTerm, LOW_SIGNAL_TITLE } from './utils.mjs';
+import { truncate, extractMatchKeywords, tokenizeHandoff, isSpecificTerm, LOW_SIGNAL_TITLE, EDIT_TOOLS } from './utils.mjs';
 import {
   HANDOFF_EXPIRY_CLEAR, HANDOFF_EXPIRY_EXIT, HANDOFF_ANCHOR_MAX_AGE,
   HANDOFF_MATCH_THRESHOLD, CONTINUE_KEYWORDS,
@@ -55,12 +55,16 @@ export function buildAndSaveHandoff(db, sessionId, project, type, episodeSnapsho
     ORDER BY created_at_epoch DESC LIMIT 15
   `).all(sessionId);
 
-  // 3. Unfinished — episode snapshot + full session edit history from narratives
+  // 3. Recent activity — episode snapshot + full session edit history from narratives.
+  // Keep only entries that represent in-flight work (file edits) or outright failures
+  // (errors). Successful Bash commands flag isSignificant=true via bash-utils when they
+  // match git/test/build/deploy patterns, but a succeeded `git push` is COMPLETED, not
+  // pending — including it surfaced release-pipeline commands as "Unfinished" on resume.
   let unfinished = '';
   if (episodeSnapshot?.entries) {
     const seenDescs = new Set();
     const pendingDescs = episodeSnapshot.entries
-      .filter(e => e.isSignificant || e.isError)
+      .filter(e => e.isError || EDIT_TOOLS.has(e.tool))
       .map(e => e.desc)
       .filter(d => { if (seenDescs.has(d)) return false; seenDescs.add(d); return true; });
     if (pendingDescs.length > 0) unfinished = pendingDescs.join('; ');
@@ -340,10 +344,13 @@ export function renderHandoffInjection(db, project, currentCcSessionId = null) {
     lines.push('## Completed', ...handoff.completed.split('\n').map(l => `- ${l}`), '');
   }
   if (handoff.unfinished) {
-    // Extract only the pending-work portion (before narrative history separator)
+    // Extract only the pending-work portion (before narrative history separator).
+    // Header: "Recent activity" rather than "Unfinished" — the list mixes in-flight
+    // edits with surfaced errors, and calling a completed edit "unfinished" is a
+    // completeness claim the episode buffer can't support.
     const pending = extractUnfinishedSummary(handoff.unfinished);
     if (pending) {
-      lines.push('## Unfinished', ...pending.split('; ').map(l => `- ${l}`), '');
+      lines.push('## Recent activity', ...pending.split('; ').map(l => `- ${l}`), '');
     }
   }
   if (handoff.key_files) {

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.1",
   "description": "Lightweight persistent memory system for Claude Code",
   "type": "module",
   "engines": {