claude-mem-lite 2.46.0 → 2.48.0

package/.claude-plugin/marketplace.json

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

package/hook-context.mjs

@@ -2,13 +2,13 @@
 // Handles adaptive time windows, token-budgeted selection, and legacy CLAUDE.md cleanup.
 
 import { basename, join } from 'path';
-import { readFileSync, writeFileSync, renameSync, unlinkSync } from 'fs';
+import { existsSync, readFileSync, writeFileSync, renameSync, unlinkSync } from 'fs';
 import {
-  estimateTokens, truncate, typeIcon, fmtTime,
+  estimateTokens, truncate, typeIcon, fmtTime, inferProject,
   debugLog, debugCatch,
   DECAY_HALF_LIFE_BY_TYPE, DEFAULT_DECAY_HALF_LIFE_MS, notLowSignalTitleClause,
 } from './utils.mjs';
-import { STALE_SESSION_MS, FALLBACK_OBS_WINDOW_MS, effectiveQuiet } from './hook-shared.mjs';
+import { STALE_SESSION_MS, FALLBACK_OBS_WINDOW_MS, RUNTIME_DIR, effectiveQuiet } from './hook-shared.mjs';
 import { extractUnfinishedSummary } from './hook-handoff.mjs';
 
 /**
@@ -176,9 +176,26 @@ export function selectWithTokenBudget(db, project, budget = 2000) {
  * at the seam. Uses atomic tmp+rename write.
  */
 export function cleanupClaudeMdLegacyBlock() {
+  // v2.48 P2-4: idempotent marker. First run (whether it finds a block or not,
+  // whether CLAUDE.md exists or not) drops a project-scoped marker in RUNTIME_DIR.
+  // Subsequent SessionStarts short-circuit here — no CLAUDE.md stat, no regex scan.
+  // Recovery path if a user manually re-adds a legacy block: delete the marker
+  // file (`~/.claude-mem-lite/runtime/.legacy-claude-md-cleaned-<project>`) and
+  // the next SessionStart will sweep again.
+  const markerPath = join(RUNTIME_DIR, `.legacy-claude-md-cleaned-${inferProject()}`);
+  if (existsSync(markerPath)) return;
+
   const claudeMdPath = join(inferProjectDir(), 'CLAUDE.md');
   let content;
-  try { content = readFileSync(claudeMdPath, 'utf8'); } catch { return; }
+  try { content = readFileSync(claudeMdPath, 'utf8'); } catch {
+    // CLAUDE.md missing — still drop the marker so we don't re-stat every session
+    try { writeFileSync(markerPath, String(Date.now())); } catch {}
+    return;
+  }
+
+  // Helper: drop the marker regardless of exit path (found / not found / write failed).
+  // Kept inline so the early-return sites below stay readable.
+  const dropMarker = () => { try { writeFileSync(markerPath, String(Date.now())); } catch {} };
 
   const startTag = '<claude-mem-context>';
   const endTag = '</claude-mem-context>';
@@ -187,7 +204,10 @@ export function cleanupClaudeMdLegacyBlock() {
   // (e.g. inside a code block in architecture notes) are not accidentally swept.
   const startIdx = content.lastIndexOf(startTag);
   const endIdx = content.lastIndexOf(endTag);
-  if (startIdx === -1 || endIdx === -1 || startIdx >= endIdx) return;
+  if (startIdx === -1 || endIdx === -1 || startIdx >= endIdx) {
+    dropMarker();
+    return;
+  }
 
   // Extend forward to swallow a trailing newline so we don't leave a stranded blank line.
   let removeEnd = endIdx + endTag.length;
@@ -213,15 +233,17 @@ export function cleanupClaudeMdLegacyBlock() {
   // Collapse any ≥3 consecutive newlines to two, then ensure exactly one trailing newline.
   const normalized = cleaned.replace(/\n{3,}/g, '\n\n').replace(/\s*$/, '\n');
 
-  if (normalized === content) return;
+  if (normalized === content) { dropMarker(); return; }
 
   const tmp = claudeMdPath + '.mem-tmp';
   try {
     writeFileSync(tmp, normalized);
     renameSync(tmp, claudeMdPath);
+    dropMarker();
   } catch (e) {
     try { unlinkSync(tmp); } catch {}
     debugLog('ERROR', 'cleanupClaudeMdLegacyBlock', `CLAUDE.md write failed: ${e.message}`);
+    // Intentionally do NOT drop the marker on write failure — retry next session.
   }
 }
 

package/hook-llm.mjs

@@ -16,7 +16,7 @@ import {
   sessionFile, getSessionId, openDb, callLLM, sleep,
 } from './hook-shared.mjs';
 import { EVENT_TYPES, saveEvent } from './lib/activity.mjs';
-import { isNoiseObservation } from './lib/low-signal-patterns.mjs';
+import { isNoiseObservation, capNoiseImportance } from './lib/low-signal-patterns.mjs';
 
 // T9: memdir-incompatible types live in the `events` table, not `observations`.
 // Set lookup is O(1) — authoritative source is lib/activity.mjs::EVENT_TYPES.
@@ -78,6 +78,16 @@ export function saveObservation(obs, projectOverride, sessionIdOverride, externa
       return null;
     }
 
+    // v2.47 P0-3: importance cap for LOW_SIGNAL titles that kept the drop gate
+    // open via importance>=2 but carry no lesson/facts signal. 341 rows in live
+    // DB had imp=3 under these conditions (99.4% noise). Cap to 1 so they
+    // enter the 7-day accelerated auto-compress window in hook.mjs.
+    const capped = capNoiseImportance(obs);
+    if (capped !== (obs.importance ?? 1)) {
+      debugLog('saveObservation', `capped imp ${obs.importance}→${capped}: ${truncate(obs.title || '', 60)}`);
+      obs.importance = capped;
+    }
+
     // Three-tier dedup — returns null (not throw) for dedup hits
     // Tier 1 (fast): 5-min Jaccard on titles
     const fiveMinAgo = now.getTime() - DEDUP_WINDOW_MS;

package/hook.mjs

@@ -648,6 +648,29 @@ async function handleSessionStart() {
       if (compressed.changes > 0) {
         debugLog('DEBUG', 'session-start', `auto-compressed ${compressed.changes} old observations`);
       }
+
+      // v2.47 P0-3: accelerated compress for LOW_SIGNAL + no-signal noise.
+      // 7-day window instead of 30. The write-side capNoiseImportance forces
+      // imp=1 on these already; this just shrinks the GC latency so the
+      // projected 32.5% corpus reduction materializes within a week on live
+      // DBs instead of bleeding into the 30-day tier.
+      const noiseCompressAge = Date.now() - 7 * 86400000;
+      const noiseCompressed = db.prepare(`
+        UPDATE observations SET compressed_into = ${COMPRESSED_AUTO}
+        WHERE COALESCE(compressed_into, 0) = 0
+          AND importance = 1
+          AND (lesson_learned IS NULL OR lesson_learned = '' OR lesson_learned = 'none')
+          AND (facts IS NULL OR facts = '' OR facts = '[]')
+          AND (
+            title LIKE 'Modified %' OR title LIKE 'Worked on %'
+            OR title LIKE 'Reviewed %' OR title LIKE 'Error%'
+          )
+          AND created_at_epoch < ?
+          AND project = ?
+      `).run(noiseCompressAge, project);
+      if (noiseCompressed.changes > 0) {
+        debugLog('DEBUG', 'session-start', `auto-compressed ${noiseCompressed.changes} LOW_SIGNAL noise (7d window)`);
+      }
     })();
 
     // Auto-maintain: cleanup + decay + boost + purge, gated to once per 24h

package/install.mjs

@@ -289,6 +289,17 @@ async function install() {
     const manifestSrc = join(PROJECT_DIR, 'registry', 'preinstalled.json');
     if (existsSync(manifestSrc)) copyFileSync(manifestSrc, join(registryDir, 'preinstalled.json'));
     ok('Source files copied to ~/.claude-mem-lite/');
+
+    // v2.48 P1-4: prune stale top-level .mjs + 0-byte .db files left behind by
+    // prior upgrades (e.g. dispatch.mjs removed in v2.20.0, zero-byte mem.db /
+    // memory.db / registry.db from pre-consolidation installs). Subdirs +
+    // symlinks + non-empty DBs are always preserved.
+    try {
+      const pruned = pruneStaleInstallFiles(DATA_DIR, SOURCE_FILES);
+      if (pruned.length > 0) {
+        ok(`Pruned ${pruned.length} stale file(s): ${pruned.map(p => p.split('/').pop()).join(', ')}`);
+      }
+    } catch (e) { /* prune is best-effort — never block install */ void e; }
   }
 
   // 2. npm install (skip for --dev: node_modules is symlinked)
@@ -1295,6 +1306,57 @@ function hasMemHooksConfigured(settings) {
   );
 }
 
+/**
+ * v2.48 P1-4: prune top-level stale files left behind by removed-module upgrades.
+ *
+ * Strict whitelist: only removes files under `dataDir` (no recursion) that match
+ *   - `*.mjs` whose basename is NOT in SOURCE_FILES (comparing against both the
+ *     bare entry and any `subdir/basename` entry flattened to its basename — the
+ *     prune intentionally skips subdir files; see below)
+ *   - 0-byte `.db` files that are NOT in the protected-db allow-list
+ *
+ * Protections (never touched):
+ *   - subdirectories (managed/, runtime/, scripts/, lib/, cli/, commands/, server/, node_modules/, .claude-plugin/, registry/, etc.)
+ *   - non-empty `.db` files — real data risk, always preserved
+ *   - WAL/SHM (`*-wal`, `*-shm`) transients
+ *   - files not ending in `.mjs` or `.db`
+ *   - the two canonical DBs (`claude-mem-lite.db`, `resource-registry.db`) even when 0-byte (fresh-install transient state)
+ *
+ * @param {string} dataDir Absolute path, typically `~/.claude-mem-lite`
+ * @param {string[]} sourceFiles SOURCE_FILES manifest
+ * @returns {string[]} Absolute paths of files that were deleted (ordered by readdir)
+ */
+export function pruneStaleInstallFiles(dataDir, sourceFiles) {
+  if (!existsSync(dataDir)) return [];
+  // Flatten manifest to just top-level basenames. SOURCE_FILES contains entries
+  // like 'lib/activity.mjs' — those belong to a subdir and prune never touches
+  // subdirs anyway. For top-level entries ('server.mjs'), basename === entry.
+  const topLevelAllowed = new Set(
+    sourceFiles
+      .filter(f => !f.includes('/'))
+      .map(f => f)
+  );
+  const PROTECTED_DBS = new Set(['claude-mem-lite.db', 'resource-registry.db']);
+  const removed = [];
+  let entries;
+  try { entries = readdirSync(dataDir); } catch { return removed; }
+  for (const name of entries) {
+    const full = join(dataDir, name);
+    let st;
+    try { st = lstatSync(full); } catch { continue; }
+    // Skip directories and symlinks (dev mode uses symlinks; treat as intentional).
+    if (!st.isFile()) continue;
+    if (name.endsWith('.mjs') && !topLevelAllowed.has(name)) {
+      try { unlinkSync(full); removed.push(full); } catch { /* best-effort */ }
+      continue;
+    }
+    if (name.endsWith('.db') && !PROTECTED_DBS.has(name) && st.size === 0) {
+      try { unlinkSync(full); removed.push(full); } catch { /* best-effort */ }
+    }
+  }
+  return removed;
+}
+
 export function clearPluginDisabledMarkerForDirectInstall(settings) {
   if (settings?.enabledPlugins?.[PLUGIN_KEY] !== false) return false;
   delete settings.enabledPlugins[PLUGIN_KEY];

package/lib/low-signal-patterns.mjs

@@ -113,6 +113,40 @@ function _isLikelyToolOutputPassthrough(narrative) {
  * @param {object} [env=process.env] Environment (injected for testability)
  * @returns {boolean} true = noise, caller should drop
  */
+/**
+ * v2.47 P0-3: Importance cap for LOW_SIGNAL titles that slipped through with
+ * inflated importance. Complements isNoiseObservation — that one drops rows
+ * entirely when narrative is also thin; this one keeps the row (useful for
+ * session history) but demotes the importance so injection ranking and
+ * auto-compress treat it as the noise it is.
+ *
+ * Production baseline (2026-04-24, projects--mem DB, 3789 obs):
+ *   LOW_SIGNAL title + importance=3 → 341 rows; only 1 had lesson, 1 had facts
+ *   LOW_SIGNAL title + importance=2 → 80 rows;  only 5 had lesson, 6 had facts
+ * 99%+ of those were Haiku-inflated noise. Cap forces imp=1 and the 7-day
+ * accelerated auto-compress in hook.mjs GCs them.
+ *
+ * Preserves importance when ANY real signal exists:
+ *   - lesson_learned (or camelCase lessonLearned) set and not 'none'
+ *   - facts array has >=1 non-empty string
+ * Non-LOW_SIGNAL titles are never capped (substantive prose is trusted).
+ *
+ * @param {object} obs { title, facts, importance, lesson_learned|lessonLearned }
+ * @returns {number} Capped importance (1 if LOW_SIGNAL+no-signal, else original)
+ */
+export function capNoiseImportance(obs) {
+  const original = obs?.importance ?? 1;
+  const title = (obs && obs.title) || '';
+  if (!_LOW_SIG_RE.test(title)) return original;
+  const lesson = obs.lessonLearned ?? obs.lesson_learned;
+  if (lesson && String(lesson).trim() && String(lesson).trim().toLowerCase() !== 'none') return original;
+  if (Array.isArray(obs.facts) &&
+      obs.facts.filter(f => typeof f === 'string' && f.trim().length > 0).length >= 1) {
+    return original;
+  }
+  return original > 1 ? 1 : original;
+}
+
 export function isNoiseObservation(obs, env = process.env) {
   if (env && env.CLAUDE_MEM_KEEP_LOW_SIGNAL === '1') return false;
   const title = (obs && obs.title) || '';

package/package.json

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

package/schema.mjs

@@ -21,7 +21,12 @@ export const REGISTRY_DB_PATH = join(DB_DIR, 'resource-registry.db');
 // FTS delete+reinsert cycles and amplified SQLITE_CORRUPT_VTAB blast radius
 // (project_non_obvious.md). Migration drops the old triggers once and lets
 // ensureFTS recreate them with the scoped form.
-export const CURRENT_SCHEMA_VERSION = 27;
+//
+// v28 (v2.47): observation_vectors orphan + stale-vocab cleanup. Live DBs had
+// 2839/6429 (44%) orphaned rows (historic deletes during FK-OFF migrations)
+// and 3282/6429 (51%) stale-vocab rows (rebuildVocabulary never pruned old
+// versions before v2.47). Idempotent one-shot DELETE on ensureDb.
+export const CURRENT_SCHEMA_VERSION = 28;
 
 const CORE_SCHEMA = `
   CREATE TABLE IF NOT EXISTS sdk_sessions (
@@ -402,6 +407,17 @@ export function initSchema(db) {
 
   db.exec(`CREATE INDEX IF NOT EXISTS idx_obs_vectors_version ON observation_vectors(vocab_version)`);
 
+  // v28 (v2.47) P0-1: one-shot cleanup of orphaned observation_vectors.
+  // Live DBs accumulated 44% orphans even with ON DELETE CASCADE because
+  // early migrations ran with `foreign_keys=OFF` and deletes skipped cascade.
+  // Idempotent (NOT IN is empty on a clean DB), runs once per ensureDb().
+  try {
+    db.prepare(`
+      DELETE FROM observation_vectors
+      WHERE observation_id NOT IN (SELECT id FROM observations)
+    `).run();
+  } catch { /* non-critical — table-missing path handled by earlier CREATE */ }
+
   // Persisted vocabulary for stable TF-IDF vector indexing
   db.exec(`
     CREATE TABLE IF NOT EXISTS vocab_state (

package/scoring-sql.mjs

@@ -70,12 +70,17 @@ export const TYPE_QUALITY_CASE = `(
  *   - injection_count: bumped ONLY on UserPromptSubmit / hook-memory auto-inject
  *   - access_count: bumped on citation (c039352 P4), explicit recall, get, timeline
  *
- * Empirical thresholds (see docs/p0-injection-noise-baseline.txt, 53 transcripts):
- *   • High-noise legitimate use (#5597 29/10=2.9x): kept at 1.0× (below tier-1)
- *   • Moderate noise (#4352 44/9=4.89x): drops to 0.5× (tier-1 hit)
- *   • Pure noise (#4046 14/0=inf): drops to 0.5× (tier-1; count≥10 gate protects
- *     cold-start obs with legitimately no cites yet)
- *   • Entrenched noise (≥20 inject, ≥5× ratio): drops to 0.2× (tier-2)
+ * Empirical thresholds (v2.47 recalibration — 2026-04-24 live projects--mem,
+ * 3789 obs, baseline 10/20 never fired because max injection_count=9):
+ *   • Legitimate heavy use (#5588 9/10=0.9, #7549 7/13=0.54): ratio≤3 ⇒ 1.0×
+ *   • Early noise candidate (#3518 6/1=6.0): inj≥4 AND ratio>3 ⇒ 0.5× (tier-1)
+ *   • Entrenched noise (inj≥8 AND ratio>5): 0.2× (tier-2)
+ *
+ * Old thresholds (v26→v2.46, inj≥10/≥20) were chosen as theoretical upper bounds
+ * before injection_count accumulated 2 months of data — live distribution shows
+ * 100% of rows stayed under 10 inject events. The recalibrated gates bite the
+ * moderate-noise tier (first real data band) while still sparing ratio-clean
+ * heavy-use rows (ratio gate is the primary precision signal).
  *
  * Applied as: BM25 × time_decay × TYPE_QUALITY × (0.5 + 0.5·importance) × NOISE_PENALTY
  * Note: multiplicative so ORDER BY relevance ASC (negative scores) still works —
@@ -88,10 +93,10 @@ export function noisePenaltyClause(alias = 'o') {
   const a = alias ? `${alias}.` : '';
   return `(
     CASE
-      WHEN COALESCE(${a}injection_count, 0) >= 20
+      WHEN COALESCE(${a}injection_count, 0) >= 8
         AND COALESCE(${a}injection_count, 0) > COALESCE(${a}access_count, 0) * 5
         THEN 0.2
-      WHEN COALESCE(${a}injection_count, 0) >= 10
+      WHEN COALESCE(${a}injection_count, 0) >= 4
         AND COALESCE(${a}injection_count, 0) > COALESCE(${a}access_count, 0) * 3
         THEN 0.5
       ELSE 1.0

package/tfidf.mjs

@@ -252,6 +252,13 @@ export function rebuildVocabulary(db) {
     for (const [term, entry] of vocab.terms) {
       insertStmt.run(term, entry.index, entry.idf, vocab.version, now);
     }
+    // v2.47 P0-1: drop observation_vectors from earlier vocab versions.
+    // Without this, rebuildVocabulary compounded the stale set on every call
+    // (live DB measured 3282/6429 = 51% stale). vectorSearch filters by
+    // vocab_version at query time, so stale rows were dead storage.
+    try {
+      db.prepare('DELETE FROM observation_vectors WHERE vocab_version != ?').run(vocab.version);
+    } catch { /* table missing on legacy DBs — non-critical */ }
   })();
 
   _vocabCache = vocab;