claude-mem-lite 2.33.0 → 2.33.2

package/.claude-plugin/marketplace.json

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

package/hook-handoff.mjs

@@ -16,13 +16,21 @@ import * as taskReaderModule from './lib/task-reader.mjs';
 /**
  * Build and save a handoff snapshot to session_handoffs table.
  * Called synchronously during handleStop (/exit) or handleSessionStart (/clear).
+ *
+ * Dual id: `sessionId` is the mem-internal id that user_prompts / observations
+ * were written with (handleUserPrompt uses getSessionId()) — it drives all
+ * DB lookups. `scopeSessionId` is the CC UUID from hook stdin used to scope
+ * the stored row so parallel CC sessions don't clobber each other. When
+ * `scopeSessionId` is null/undefined, `sessionId` is used for both (legacy).
+ *
  * @param {Database} db Opened main database
- * @param {string} sessionId Session being handed off
+ * @param {string} sessionId Mem-internal session id (query key)
  * @param {string} project Project identifier
  * @param {'clear'|'exit'} type Handoff type
  * @param {object|null} episodeSnapshot Episode buffer captured before flushing
+ * @param {string|null} [scopeSessionId=null] CC UUID for session_handoffs.session_id column
  */
-export function buildAndSaveHandoff(db, sessionId, project, type, episodeSnapshot) {
+export function buildAndSaveHandoff(db, sessionId, project, type, episodeSnapshot, scopeSessionId = null) {
   // 1. Working objective — from user prompts
   const prompts = db.prepare(`
     SELECT prompt_text FROM user_prompts
@@ -122,6 +130,9 @@ export function buildAndSaveHandoff(db, sessionId, project, type, episodeSnapsho
 
   // UPSERT keyed on (project, type, session_id) — parallel sessions coexist.
   // Same session re-writing its own handoff (e.g. repeated /clear) updates in place.
+  // `scopeSessionId` (CC UUID) tags the row for parallel scoping; falls back to
+  // the mem-internal `sessionId` when the caller didn't supply one (tests + legacy).
+  const storedSessionId = scopeSessionId || sessionId;
   db.prepare(`
     INSERT INTO session_handoffs (project, type, session_id, working_on, completed, unfinished, key_files, key_decisions, match_keywords, created_at_epoch, git_sha_at_handoff)
     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
@@ -135,7 +146,7 @@ export function buildAndSaveHandoff(db, sessionId, project, type, episodeSnapsho
       created_at_epoch = excluded.created_at_epoch,
       git_sha_at_handoff = excluded.git_sha_at_handoff
   `).run(
-    project, type, sessionId,
+    project, type, storedSessionId,
     truncate(workingOn, 1000),
     completed.map(c => `[${c.type}] ${c.title}`).join('\n'),
     unfinished.length > 3000 ? unfinished.slice(0, 2999) + '…' : unfinished,

package/hook-llm.mjs

@@ -559,10 +559,17 @@ search_aliases: 2-6 alternative search terms someone might use to find this memo
         return;
       }
 
-      const lessonLearned = typeof parsed.lesson_learned === 'string'
-        && parsed.lesson_learned.toLowerCase() !== 'none'
-        && parsed.lesson_learned.trim().length > 0
-        ? parsed.lesson_learned.slice(0, 500) : null;
+      // v2.33.1: expanded low-signal filter. Historical data showed Haiku
+      // returns 'none'/''/'n/a'/'null'/'-'/'todo'/'tbd' ~95% of the time —
+      // all noise with no retrieval value. Also reject lessons <12 chars
+      // (e.g. "ok", "works", "fixed it") — too short to teach a future session.
+      // When filtered, downgrade importance to 0 so rule-based fallback in
+      // hook.mjs:saveObservation writes the obs but hook queries (which all
+      // require importance >= 1) ignore it.
+      const rawLesson = typeof parsed.lesson_learned === 'string' ? parsed.lesson_learned.trim() : '';
+      const lowSignalLesson = new Set(['none', '', 'n/a', 'null', 'todo', 'tbd', 'na', '-', 'nothing', 'nil']);
+      const isLessonLowSignal = lowSignalLesson.has(rawLesson.toLowerCase()) || rawLesson.length < 12;
+      const lessonLearned = isLessonLowSignal ? null : rawLesson.slice(0, 500);
       const searchAliases = Array.isArray(parsed.search_aliases)
         ? parsed.search_aliases.slice(0, 6).join(' ')
         : null;
@@ -576,7 +583,12 @@ search_aliases: 2-6 alternative search terms someone might use to find this memo
         facts: Array.isArray(parsed.facts) ? parsed.facts.slice(0, 10) : [],
         files: episode.files,
         filesRead: episode.filesRead || [],
-        importance: Math.max(ruleImportance, clampImportance(parsed.importance)),
+        // v2.33.1: when lesson is low-signal, don't trust Haiku's importance
+        // inflation for noise-prone types. rule-based floor still applies so
+        // error-in-test (→3) / config-change (→2) keep their floor.
+        importance: isLessonLowSignal && (parsed.type === 'change' || parsed.type === 'discovery')
+          ? Math.min(ruleImportance, 1)
+          : Math.max(ruleImportance, clampImportance(parsed.importance)),
         lessonLearned,
         searchAliases,
       };

package/hook.mjs

@@ -3,6 +3,20 @@
 // Selective encoding, episodic batching, error-triggered recall
 // Hooks (fast <100ms): post-tool-use, session-start, stop
 // Background workers (slow): llm-episode, llm-summary
+//
+// ─── Session-id invariant (do not violate — see bf121aa / v2.33.2) ──────────
+// Two session identifiers coexist in this codebase:
+//   • mem-internal id: `hook-<project>-<hash>`, produced by getSessionId().
+//     handleUserPrompt writes it into user_prompts / sdk_sessions.content_session_id
+//     / observations.memory_session_id. Treat as the ONLY valid WHERE / JOIN key
+//     for those three tables.
+//   • CC UUID: `hookData.session_id` from stdin. Use ONLY for
+//     session_handoffs.session_id (parallel-session scoping, per bf121aa).
+// Mixing them silently breaks everything — UPDATE matches 0 rows, SELECT returns
+// empty, buildAndSaveHandoff early-returns, no throw. Precedent: v2.33.1 shipped
+// with the two mixed since 2026-04-12; 48 stale 'active' sessions + 0 handoffs
+// for projects--mem went unnoticed for 4 days. Keep the split or document why
+// you're changing it.
 
 import { randomUUID } from 'crypto';
 import { join } from 'path';
@@ -135,21 +149,36 @@ function flushEpisode(episode) {
   if (isSignificant) {
     spawnBackground('llm-episode', flushFile);
 
-    // P3: Auto-save hint — detect error→fix pattern (error entry followed by Edit/Write)
-    // and nudge Claude to save the lesson for future recall
+    // v2.33.1: structured flush receipt so Claude sees what mem just captured
+    // and the legacy error→fix nudge consolidates here. PostToolUse JSON with
+    // hookSpecificOutput.additionalContext reliably renders across CC variants;
+    // the old plain-text stdout write was invisible on some variants.
     try {
       const entries = episode.entries || [];
       const hasError = entries.some(e => e.isError);
       const hasEdit = entries.some(e => EDIT_TOOLS.has(e.tool));
+      const toolCounts = {};
+      for (const e of entries) toolCounts[e.tool] = (toolCounts[e.tool] || 0) + 1;
+      const toolSummary = Object.entries(toolCounts)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 3)
+        .map(([t, n]) => `${t}×${n}`)
+        .join(', ');
+      const lines = [`[mem] episode flushed: ${entries.length} entries (${toolSummary})`];
       if (hasError && hasEdit && entries.length >= 3) {
         const editFiles = entries.filter(e => EDIT_TOOLS.has(e.tool)).flatMap(e => e.files || []);
         const uniqueFiles = [...new Set(editFiles)].slice(0, 3);
-        const filesHint = uniqueFiles.length > 0 ? ` (files: ${uniqueFiles.join(', ')})` : '';
-        process.stdout.write(
-          `[mem] 💡 Error→fix pattern detected${filesHint}. Consider: mem_save(type="bugfix", lesson_learned="root cause & fix")\n`,
-        );
+        const filesHint = uniqueFiles.length > 0 ? ` (${uniqueFiles.join(', ')})` : '';
+        lines.push(`[mem] 💡 error→fix pattern${filesHint} — consider: mem_save(type="bugfix", lesson_learned="<root cause + fix>")`);
       }
-    } catch { /* never block on hint */ }
+      process.stdout.write(JSON.stringify({
+        suppressOutput: true,
+        hookSpecificOutput: {
+          hookEventName: 'PostToolUse',
+          additionalContext: lines.join('\n'),
+        },
+      }));
+    } catch { /* never block on receipt */ }
   } else {
     try { unlinkSync(flushFile); } catch {}
   }
@@ -311,9 +340,12 @@ async function handleStop() {
     }
   } catch { /* stdin unavailable — fall back to local session id */ }
 
-  // Capture session info BEFORE cleanup. Prefer CC session id (parallel-safe);
-  // fall back to file-based id for backward compat.
-  const sessionId = ccSessionId || getSessionId();
+  // Capture session info BEFORE cleanup. All DB lookups use the mem-internal id
+  // (that's what handleUserPrompt wrote into user_prompts / sdk_sessions / observations
+  // via getSessionId()). `ccSessionId` is used only to tag session_handoffs rows
+  // for parallel-session scoping — it must not be used as a query key, otherwise
+  // queries miss and UPDATE sdk_sessions becomes a no-op (v2.33.2 regression fix).
+  const sessionId = getSessionId();
   const project = inferProject();
 
   // Snapshot episode BEFORE flush for handoff extraction
@@ -366,8 +398,11 @@ async function handleStop() {
         UPDATE sdk_sessions SET status = 'completed', completed_at = ?, completed_at_epoch = ?
         WHERE content_session_id = ? AND status = 'active'
       `).run(new Date().toISOString(), Date.now(), sessionId);
-      // Save handoff snapshot for cross-session continuity
-      try { buildAndSaveHandoff(db, sessionId, project, 'exit', episodeSnapshot); }
+      // Save handoff snapshot for cross-session continuity.
+      // sessionId = mem-internal (query key); ccSessionId = CC UUID (scope key for
+      // parallel-safe row identity). Without the split, CC UUID-based queries miss
+      // user_prompts and the handoff row is silently skipped (see hook-handoff.mjs).
+      try { buildAndSaveHandoff(db, sessionId, project, 'exit', episodeSnapshot, ccSessionId || sessionId); }
       catch (e) { debugCatch(e, 'handleStop-handoff'); }
 
       // Fast summary baseline — ensures summary exists even if background LLM fails
@@ -649,12 +684,12 @@ async function handleSessionStart() {
 
     if (prevSessionId) {
       // Save handoff for cross-session continuity (/clear or /compact).
-      // Prefer CC session id (stable across /clear within same CC session, and
-      // unique across parallel sessions for the same project) so UserPromptSubmit
-      // can scope by hookData.session_id. Fall back to the mem plugin's file-based
-      // id for legacy/test paths.
-      const handoffSessionId = ccSessionId || prevSessionId;
-      try { buildAndSaveHandoff(db, handoffSessionId, prevProject || project, 'clear', episodeSnapshot); }
+      // prevSessionId is the mem-internal id — use it to look up the finished session's
+      // user_prompts / observations. ccSessionId (same CC session across /clear) scopes
+      // the stored row so UserPromptSubmit can read its own handoff back.
+      // Legacy/test paths (no stdin) fall back to prevSessionId for both.
+      const handoffScopeId = ccSessionId || prevSessionId;
+      try { buildAndSaveHandoff(db, prevSessionId, prevProject || project, 'clear', episodeSnapshot, handoffScopeId); }
       catch (e) { debugCatch(e, 'session-start-handoff'); }
 
       // Read the just-saved handoff for downstream consumers (fast summary remaining, working state).
@@ -662,7 +697,7 @@ async function handleSessionStart() {
       try {
         prevClearHandoff = db.prepare(
           'SELECT working_on, unfinished, key_files FROM session_handoffs WHERE project = ? AND type = ? AND session_id = ?'
-        ).get(prevProject || project, 'clear', handoffSessionId);
+        ).get(prevProject || project, 'clear', handoffScopeId);
       } catch {}
 
       // Generate session summary for previous session (background Haiku — richer version)

package/package.json

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

package/scripts/pre-tool-recall.js

@@ -3,7 +3,7 @@
 // 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 { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, statSync, unlinkSync } from 'fs';
 import { basename, join } from 'path';
 import { homedir } from 'os';
 
@@ -11,9 +11,20 @@ import { homedir } from 'os';
 // point the hook at an isolated DB + cooldown dir without touching the user's real state.
 const DB_PATH = process.env.CLAUDE_MEM_DB_PATH || join(homedir(), '.claude-mem-lite', 'claude-mem-lite.db');
 const RUNTIME_DIR = process.env.CLAUDE_MEM_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
+// v2.33.1: cooldown path is session-scoped so same-file-twice within one
+// session never re-injects (was: global file, 5-min window). Cross-session:
+// fresh file, fresh nudges — this is intended. No session_id → fall back to
+// legacy global path so env-less test harnesses still behave.
+const LEGACY_COOLDOWN_PATH = join(RUNTIME_DIR, 'pre-recall-cooldown.json');
+const COOLDOWN_MS = 5 * 60 * 1000; // 5 minutes (used only for legacy fallback)
+const STALE_MS = 10 * 60 * 1000;   // 10 minutes cleanup threshold for legacy file
+const SESSION_COOLDOWN_STALE_MS = 24 * 60 * 60 * 1000; // 24h — drop session cooldown files older than this
+
+function cooldownPathFor(sessionId) {
+  if (!sessionId) return LEGACY_COOLDOWN_PATH;
+  const safe = String(sessionId).replace(/[^a-zA-Z0-9_.-]/g, '-').slice(0, 64);
+  return join(RUNTIME_DIR, `pre-recall-cooldown-${safe}.json`);
+}
 
 // ─── Helpers ────────────────────────────────────────────────────────────────
 
@@ -27,20 +38,40 @@ function inferProject() {
   return project;
 }
 
-function readCooldown() {
-  try { return JSON.parse(readFileSync(COOLDOWN_PATH, 'utf8')); } catch { return {}; }
+function readCooldown(cooldownPath) {
+  try { return JSON.parse(readFileSync(cooldownPath, 'utf8')); } catch { return {}; }
 }
 
-function writeCooldown(data) {
+function writeCooldown(cooldownPath, data, isSessionScoped) {
   try {
     mkdirSync(RUNTIME_DIR, { recursive: true });
-    // Clean stale entries
+    // Legacy (no session_id): stale entries trimmed to 10m window.
+    // Session-scoped: keep all entries for the session's lifetime — same-file-twice
+    // in one session never re-injects. Old session files GC'd on next write.
+    const now = Date.now();
+    const cleaned = isSessionScoped ? data : {};
+    if (!isSessionScoped) {
+      for (const [k, v] of Object.entries(data)) {
+        if (now - v < STALE_MS) cleaned[k] = v;
+      }
+    }
+    writeFileSync(cooldownPath, JSON.stringify(cleaned));
+  } catch { /* silent */ }
+}
+
+// Best-effort GC for session cooldown files older than 24h.
+// Runs at most once per hook invocation, silent on any failure.
+function gcOldSessionCooldowns() {
+  try {
     const now = Date.now();
-    const cleaned = {};
-    for (const [k, v] of Object.entries(data)) {
-      if (now - v < STALE_MS) cleaned[k] = v;
+    for (const name of readdirSync(RUNTIME_DIR)) {
+      if (!name.startsWith('pre-recall-cooldown-') || !name.endsWith('.json')) continue;
+      try {
+        const p = join(RUNTIME_DIR, name);
+        const st = statSync(p);
+        if (now - st.mtimeMs > SESSION_COOLDOWN_STALE_MS) unlinkSync(p);
+      } catch { /* silent per-entry */ }
     }
-    writeFileSync(COOLDOWN_PATH, JSON.stringify(cleaned));
   } catch { /* silent */ }
 }
 
@@ -59,19 +90,29 @@ try {
 
   // Parse event
   let filePath;
+  let sessionId;
   try {
     const event = JSON.parse(input);
     filePath = event.tool_input?.file_path;
+    sessionId = event.session_id || null;
   } catch { process.exit(0); }
 
   if (!filePath) process.exit(0);
 
-  // Cooldown check (full path as key)
-  const cooldown = readCooldown();
+  // v2.33.1: session-scoped cooldown. Within one session, same file recalls
+  // once; cross-session, each session gets fresh nudges. Legacy 5-min global
+  // cooldown only applies when no session_id is present.
+  const cooldownPath = cooldownPathFor(sessionId);
+  const isSessionScoped = Boolean(sessionId);
+  const cooldown = readCooldown(cooldownPath);
   const now = Date.now();
-  if (cooldown[filePath] && (now - cooldown[filePath]) < COOLDOWN_MS) {
-    process.exit(0);
+  if (isSessionScoped) {
+    if (cooldown[filePath]) process.exit(0); // already recalled this file in-session
+  } else {
+    if (cooldown[filePath] && (now - cooldown[filePath]) < COOLDOWN_MS) process.exit(0);
   }
+  // Best-effort GC of old session cooldown files (cheap, once per invocation)
+  if (isSessionScoped) gcOldSessionCooldowns();
 
   // Open DB readonly
   const Database = (await import('better-sqlite3')).default;
@@ -177,7 +218,7 @@ try {
     }));
     // Cooldown applies to BOTH branches so the reminder doesn't spam every Edit.
     cooldown[filePath] = now;
-    writeCooldown(cooldown);
+    writeCooldown(cooldownPath, cooldown, isSessionScoped);
   } catch {
     // Silent failure — never block editing
   } finally {

package/scripts/user-prompt-search.js

@@ -34,6 +34,22 @@ const BM25_MIN_SCORE = Number(process.env.CLAUDE_MEM_UPS_BM25_MIN || 1e-5);
 // survive `shouldSkip` but carry too few tokens to justify an FTS lookup.
 const PROMPT_MIN_LENGTH = 15;
 
+// v2.33.1: follow-up prompts ("前面那个", "继续 X", "再看看 Y") are short by
+// nature but semantically depend on prior turns. Once a session has injected
+// memory at least once, relax gates so short follow-ups still get recall.
+// Detection: INJECTED_IDS_FILE count > 0 within DEDUP_STALE_MS window.
+const FOLLOWUP_PROMPT_MIN_LENGTH = 8;
+const FOLLOWUP_BM25_MIN_SCORE = Number(process.env.CLAUDE_MEM_UPS_BM25_MIN_FOLLOWUP || 5e-6);
+
+function isFollowUpSession() {
+  try {
+    const raw = readFileSync(INJECTED_IDS_FILE, 'utf8');
+    const { ts, count = 0 } = JSON.parse(raw);
+    if (!ts || Date.now() - ts > DEDUP_STALE_MS) return false;
+    return count > 0;
+  } catch { return false; }
+}
+
 // ─── DB Query Functions ─────────────────────────────────────────────────────
 
 function searchByFts(db, queryText, project, limit, typeFilter) {
@@ -255,7 +271,12 @@ async function main() {
   // T3 (v2.31): additional raw-length gate on top of shouldSkip's CJK-weighted
   // effective-length check. Suppresses medium-short Latin prompts ("run tests",
   // "fix bug now") that carry too few content tokens for a meaningful FTS lookup.
-  if (promptText.trim().length < PROMPT_MIN_LENGTH) return;
+  // v2.33.1: follow-up prompts in an already-active session get a lower gate —
+  // short continuations ("前面那个?", "does it work?") depend on prior context.
+  const followUp = isFollowUpSession();
+  const promptMinLen = followUp ? FOLLOWUP_PROMPT_MIN_LENGTH : PROMPT_MIN_LENGTH;
+  if (promptText.trim().length < promptMinLen) return;
+  const bm25Floor = followUp ? FOLLOWUP_BM25_MIN_SCORE : BM25_MIN_SCORE;
 
   let db;
   try {
@@ -275,7 +296,7 @@ async function main() {
     const errSig = extractErrorSignature(promptText);
     const sigRows = errSig
       ? searchByFts(db, errSig.signature, project, 2, 'bugfix').filter(r =>
-          typeof r.relevance === 'number' && Math.abs(r.relevance) >= BM25_MIN_SCORE
+          typeof r.relevance === 'number' && Math.abs(r.relevance) >= bm25Floor
         )
       : [];
 
@@ -299,7 +320,7 @@ async function main() {
       // no relevance and are always kept — file-scoped recall is presumed
       // intentional and has its own relevance signal (the file name match).
       ftsRows = ftsRows.filter(r =>
-        typeof r.relevance === 'number' && Math.abs(r.relevance) >= BM25_MIN_SCORE
+        typeof r.relevance === 'number' && Math.abs(r.relevance) >= bm25Floor
       );
 
       // Merge: FTS results first, then file results, deduplicated