claude-mem-lite 2.53.2 → 2.55.0

package/.claude-plugin/marketplace.json

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

package/hook-llm.mjs

@@ -677,9 +677,13 @@ search_aliases: 2-6 alternative search terms someone might use to find this memo
         files: episode.files,
         filesRead: episode.filesRead || [],
         // 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')
+        // inflation. v2.54.0: extended from {change, discovery} to all types
+        // except `decision` after audit (2026-04-30) showed bugfix lesson
+        // coverage 11.2% / refactor hit-rate 18.1% — Haiku marks bugfix/refactor
+        // imp=2-3 even when lesson is null after retry. Keep `decision` exempt:
+        // it's rare (39 obs / 94.9% hit-rate) and the retry path already gave
+        // it a second chance; a no-lesson decision is still a worthwhile signal.
+        importance: isLessonLowSignal && parsed.type !== 'decision'
           ? Math.min(ruleImportance, 1)
           : Math.max(ruleImportance, clampImportance(parsed.importance)),
         lessonLearned,

package/hook-optimize.mjs

@@ -709,7 +709,14 @@ export async function handleLLMOptimize() {
   }
 
   try {
-    const results = await optimizeRun(db);
+    // v2.54.0: auto-maintain default scope is 'wide'. Narrow scope (the prior
+    // default) only matches fully-degraded rows (no concepts AND no facts AND
+    // no lesson AND no aliases) — production diagnostic 2026-04-30 found only
+    // 56 obs ever optimized after months of daily auto-maintain runs. Wide
+    // targets bugfix/refactor/feature/decision rows with substantive narrative
+    // but missing lesson_learned, which is exactly the audit's 11.2% coverage
+    // gap. CLI `mem optimize` keeps narrow as default for explicit invocations.
+    const results = await optimizeRun(db, { reenrichScope: 'wide' });
     const parts = [];
     if (results.reenrich?.processed) parts.push(`re-enriched: ${results.reenrich.processed}`);
     if (results.normalize?.processed) parts.push(`normalized: ${results.normalize.processed}`);

package/hook-update.mjs

@@ -3,12 +3,12 @@
 // Skips in dev mode (symlinked installs). Silent on network failure.
 
 import { execSync, execFileSync } from 'node:child_process';
-import { readFileSync, writeFileSync, copyFileSync, readdirSync, existsSync, lstatSync, mkdirSync, rmSync, renameSync } from 'node:fs';
+import { readFileSync, writeFileSync, copyFileSync, cpSync, readdirSync, existsSync, lstatSync, mkdirSync, rmSync, renameSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { tmpdir, homedir } from 'node:os';
 import { DB_DIR } from './schema.mjs';
 import { debugCatch, debugLog } from './utils.mjs';
-import { SOURCE_FILES } from './source-files.mjs';
+import { SOURCE_FILES, HOOK_SCRIPT_FILES } from './source-files.mjs';
 
 // ── Configuration ──────────────────────────────────────────
 const GITHUB_REPO = 'sdsrss/claude-mem-lite';
@@ -328,16 +328,30 @@ function copyReleaseIntoStaging(sourceDir, stagingDir) {
     copied++;
   }
 
-  for (const dirName of ['scripts', 'registry']) {
-    const srcDir = join(sourceDir, dirName);
-    const destDir = join(stagingDir, dirName);
-    if (!existsSync(srcDir)) continue;
-    mkdirSync(destDir, { recursive: true });
-    for (const entry of readdirSync(srcDir)) {
-      copyFileSync(join(srcDir, entry), join(destDir, entry));
+  // scripts/ is curated to HOOK_SCRIPT_FILES — settings.json hook commands
+  // resolve only to these 5 files, and plugin mode does not consume this
+  // directory at all. Pre-v2.55 used cpSync({recursive:true}) which silently
+  // shipped dev-only files (mock-claude.mjs, extract-repos.mjs, p0-forward-probe.mjs…)
+  // from the GitHub Releases tarball into every user's data dir.
+  const stagingScripts = join(stagingDir, 'scripts');
+  const sourceScripts = join(sourceDir, 'scripts');
+  if (existsSync(sourceScripts)) {
+    mkdirSync(stagingScripts, { recursive: true });
+    for (const name of HOOK_SCRIPT_FILES) {
+      const src = join(sourceScripts, name);
+      if (existsSync(src)) copyFileSync(src, join(stagingScripts, name));
     }
   }
 
+  // registry/ stays recursive — preinstalled.json is the only current entry
+  // but the directory is consumed wholesale by the registry indexer and may
+  // grow subtrees. Pre-v2.55 readdirSync+copyFileSync would EISDIR-throw on
+  // any subdir and silently roll back the entire update.
+  const sourceRegistry = join(sourceDir, 'registry');
+  if (existsSync(sourceRegistry)) {
+    cpSync(sourceRegistry, join(stagingDir, 'registry'), { recursive: true });
+  }
+
   const stagedScripts = join(stagingDir, 'scripts');
   if (existsSync(stagedScripts)) {
     for (const sf of readdirSync(stagedScripts).filter(n => n.endsWith('.sh'))) {

package/install.mjs

@@ -29,23 +29,13 @@ import { createRequire } from 'module';
 
 import { RESOURCE_METADATA } from './install-metadata.mjs';
 import { scanPluginCacheHookPollution } from './plugin-cache-guard.mjs';
-import { SOURCE_FILES } from './source-files.mjs';
+import { SOURCE_FILES, HOOK_SCRIPT_FILES } from './source-files.mjs';
 
-/**
- * Hook scripts that non-dev install must copy into ~/.claude-mem-lite/scripts/
- * to keep settings.json hook commands resolvable. Single source of truth so
- * adding a new PreToolUse/PostToolUse hook script can't drift from the install
- * copy block (which previously hand-listed only 3 of these and silently
- * dropped pre-tool-recall.js + pre-skill-bridge.js — every fresh install left
- * settings.json pointing at non-existent files).
- */
-export const HOOK_SCRIPT_FILES = [
-  'post-tool-use.sh',
-  'user-prompt-search.js',
-  'prompt-search-utils.mjs',
-  'pre-tool-recall.js',
-  'pre-skill-bridge.js',
-];
+// Re-export for backward compatibility — tests/install-hook-scripts.test.mjs
+// and any external consumers still import HOOK_SCRIPT_FILES from install.mjs.
+// The constant itself moved to source-files.mjs in v2.55 so hook-update.mjs
+// can share it without a static cycle.
+export { HOOK_SCRIPT_FILES };
 
 export function copyHookScripts(srcDir, destDir) {
   for (const name of HOOK_SCRIPT_FILES) {
@@ -349,12 +339,10 @@ async function install() {
     if (existsSync(join(PROJECT_DIR, 'registry'))) {
       symlinkSync(join(PROJECT_DIR, 'registry'), regLink);
     }
-    // Symlink commands/ directory
-    const cmdLink = join(DATA_DIR, 'commands');
-    if (existsSync(cmdLink)) try { rmSync(cmdLink, { recursive: true, force: true }); } catch {}
-    if (existsSync(join(PROJECT_DIR, 'commands'))) {
-      symlinkSync(join(PROJECT_DIR, 'commands'), cmdLink);
-    }
+    // commands/ is intentionally NOT linked: Claude Code reads slash commands
+    // from the plugin cache (~/.claude/plugins/cache/<mp>/<plugin>/<ver>/commands/)
+    // or user-level ~/.claude/commands/, never from ~/.claude-mem-lite/commands/.
+    // Pre-v2.55 maintained a symlink/copy here that had no consumers.
     ok('Symlinks created in ~/.claude-mem-lite/ → dev dir');
   } else {
     log('Installing to ~/.claude-mem-lite/...');
@@ -375,15 +363,7 @@ async function install() {
     copyHookScripts(join(PROJECT_DIR, 'scripts'), scriptsDir);
     // Ensure bash script is executable
     try { execFileSync('chmod', ['+x', join(scriptsDir, 'post-tool-use.sh')], { stdio: 'pipe' }); } catch {}
-    // Copy commands directory
-    const commandsDir = join(DATA_DIR, 'commands');
-    if (!existsSync(commandsDir)) mkdirSync(commandsDir, { recursive: true });
-    const commandsSrc = join(PROJECT_DIR, 'commands');
-    if (existsSync(commandsSrc)) {
-      for (const f of readdirSync(commandsSrc).filter(f => f.endsWith('.md'))) {
-        copyFileSync(join(commandsSrc, f), join(commandsDir, f));
-      }
-    }
+    // commands/ is intentionally NOT copied — see dev-mode branch above.
     // Copy registry manifest
     const registryDir = join(DATA_DIR, 'registry');
     if (!existsSync(registryDir)) mkdirSync(registryDir, { recursive: true });
@@ -1614,9 +1594,10 @@ function syncVersions() {
     const marketJson = JSON.parse(readFileSync(marketJsonPath, 'utf8'));
     const plugin = marketJson.plugins?.[0];
     if (plugin && plugin.version !== version) {
+      const prev = plugin.version;
       plugin.version = version;
       writeFileSync(marketJsonPath, JSON.stringify(marketJson, null, 2) + '\n');
-      ok(`marketplace.json: ${plugin.version} → ${version}`);
+      ok(`marketplace.json: ${prev} → ${version}`);
     } else if (plugin) {
       ok(`marketplace.json: already ${version}`);
     }
@@ -1624,6 +1605,27 @@ function syncVersions() {
     warn('marketplace.json not found');
   }
 
+  // Sync CLAUDE.md `**Version**: x.y.z` line — install-e2e asserts this
+  // matches package.json so omitting it here would break CI on every release.
+  const claudeMdPath = join(PROJECT_DIR, 'CLAUDE.md');
+  if (existsSync(claudeMdPath)) {
+    const orig = readFileSync(claudeMdPath, 'utf8');
+    const versionLine = /^- \*\*Version\*\*: .+$/m;
+    if (versionLine.test(orig)) {
+      const patched = orig.replace(versionLine, `- **Version**: ${version}`);
+      if (patched !== orig) {
+        writeFileSync(claudeMdPath, patched);
+        ok(`CLAUDE.md: → ${version}`);
+      } else {
+        ok(`CLAUDE.md: already ${version}`);
+      }
+    } else {
+      warn('CLAUDE.md: `**Version**:` line not found — skipped');
+    }
+  } else {
+    warn('CLAUDE.md not found');
+  }
+
   console.log('');
 }
 

package/lib/low-signal-patterns.mjs

@@ -155,19 +155,26 @@ export function isNoiseObservation(obs, env = process.env) {
   const lesson = obs.lessonLearned ?? obs.lesson_learned;
   if (lesson && String(lesson).trim() && String(lesson).trim().toLowerCase() !== 'none') return false;
 
-  if ((obs.importance ?? 1) >= 2) return false;
-
-  if (Array.isArray(obs.facts) &&
-      obs.facts.filter(f => typeof f === 'string' && f.trim().length > 0).length >= 1) {
-    return false;
-  }
+  const hasFacts = Array.isArray(obs.facts) &&
+    obs.facts.filter(f => typeof f === 'string' && f.trim().length > 0).length >= 1;
+  if (hasFacts) return false;
 
   const narrative = (obs.narrative || '').trim();
-  if (narrative.length >= 40 &&
-      !/^Error[: ]/i.test(narrative) &&
-      !_isLikelyToolOutputPassthrough(narrative)) {
-    return false;
-  }
+  const isPassthrough = _isLikelyToolOutputPassthrough(narrative);
+  const isStderrShape = /^Error[: ]/i.test(narrative);
+
+  // v2.54.0: raw tool-output passthrough is always noise regardless of importance.
+  // Rule-based importance (computeRuleImportance) can hit 2-3 from filename
+  // heuristics (test/schema/migration) even when narrative is just
+  // "cmd → ERROR: stderr" — 30d audit found 64 'Error: X' titles surviving via
+  // imp=2 escape with raw stderr narratives. Per #8152 paired-gate model: this
+  // is the drop counterpart to capNoiseImportance's demote — both must check
+  // the same passthrough signal.
+  if (isPassthrough || isStderrShape) return true;
+
+  if ((obs.importance ?? 1) >= 2) return false;
+
+  if (narrative.length >= 40) return false;
 
   return true;
 }

package/package.json

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

package/scripts/setup.sh

@@ -136,5 +136,53 @@ if [[ -n "${CLAUDE_PLUGIN_ROOT:-}" ]]; then
   fi
 fi
 
+# 9. Residue detection (plugin mode only): warn once if legacy direct-install
+#    hooks remain in ~/.claude/settings.json. A user who installed via global
+#    `claude-mem-lite install` and later switched to the marketplace plugin
+#    will run every hook twice (direct settings.json hooks AND plugin hooks)
+#    until they run `claude-mem-lite uninstall` to clear the settings.json
+#    entries. /plugin uninstall does not touch settings.json.
+RESIDUE_MARKER="$DATA_DIR/runtime/.residue-warned-v2.55"
+if [[ -n "${CLAUDE_PLUGIN_ROOT:-}" && ! -f "$RESIDUE_MARKER" ]]; then
+  SETTINGS="$HOME/.claude/settings.json"
+  if [[ -f "$SETTINGS" ]]; then
+    SETTINGS_PATH="$SETTINGS" node -e '
+      const fs = require("fs");
+      try {
+        const raw = fs.readFileSync(process.env.SETTINGS_PATH, "utf8");
+        const data = JSON.parse(raw);
+        const hooks = data.hooks || {};
+        const events = Object.keys(hooks);
+        const found = [];
+        for (const ev of events) {
+          const list = Array.isArray(hooks[ev]) ? hooks[ev] : [];
+          for (const entry of list) {
+            const inner = Array.isArray(entry?.hooks) ? entry.hooks : [];
+            for (const h of inner) {
+              const cmd = String(h?.command || "");
+              if (cmd.includes(".claude-mem-lite/") || cmd.includes("claude-mem-lite/scripts") || cmd.includes("claude-mem-lite/hook.mjs")) {
+                found.push(ev);
+                break;
+              }
+            }
+          }
+        }
+        if (found.length) {
+          process.stderr.write("\n");
+          process.stderr.write("\x1b[33m⚠\x1b[0m Legacy direct-install hooks detected in " + process.env.SETTINGS_PATH + "\n");
+          process.stderr.write("  Events with stale entries: " + [...new Set(found)].join(", ") + "\n");
+          process.stderr.write("  These will fire alongside plugin hooks (each tool call runs twice).\n");
+          process.stderr.write("  Fix: run \x1b[1mclaude-mem-lite uninstall\x1b[0m to clear settings.json,\n");
+          process.stderr.write("       then keep using the plugin install. (One-time warning.)\n\n");
+          process.exit(2);
+        }
+      } catch {}
+    ' || true
+  fi
+  # Mark the warning as shown regardless of result — silence is fine if no
+  # residue, and the warning above is one-shot per data-dir.
+  touch "$RESIDUE_MARKER"
+fi
+
 log_ok "claude-mem-lite ready"
 exit 0

package/source-files.mjs

@@ -53,3 +53,23 @@ export const SOURCE_FILES = [
   'adopt-content.mjs',
   'adopt-cli.mjs',
 ];
+
+/**
+ * Hook scripts that direct-install (non-plugin) mode must materialize under
+ * ~/.claude-mem-lite/scripts/ — settings.json hook commands resolve to these
+ * absolute paths. Plugin mode does not consume this directory (it runs scripts
+ * from ${CLAUDE_PLUGIN_ROOT} instead).
+ *
+ * Single source of truth for both install.mjs (initial install) and
+ * hook-update.mjs (auto-update): pre-v2.55 hook-update copied the entire
+ * scripts/ tree from the GitHub Releases tarball, which silently shipped
+ * dev-only files (mock-claude.mjs, extract-repos.mjs, p0-forward-probe.mjs…)
+ * to every user's data dir on the first auto-update.
+ */
+export const HOOK_SCRIPT_FILES = [
+  'post-tool-use.sh',
+  'user-prompt-search.js',
+  'prompt-search-utils.mjs',
+  'pre-tool-recall.js',
+  'pre-skill-bridge.js',
+];