claude-mem-lite 2.77.0 → 2.79.0

package/.claude-plugin/marketplace.json

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

package/.mcp.json

@@ -1,6 +1,6 @@
 {
   "mcpServers": {
-    "mem": {
+    "mem-lite": {
       "command": "node",
       "args": [
         "${CLAUDE_PLUGIN_ROOT}/scripts/launch.mjs"

package/README.md

@@ -138,6 +138,8 @@ The original sends **everything to the LLM and hopes it filters well**. claude-m
 
 Plugin mode manages its own hooks/runtime. On session start it only **checks and reports** new claude-mem-lite versions; it does **not** self-overwrite plugin files in place. Update plugin-mode installs through Claude's plugin workflow.
 
+> **First session per project: run `/adopt` once.** Plugin install gives you the MCP server + hooks + slash commands, but the **invited-memory sentinel** (a system-authority pointer that boosts Claude's proactive use of `mem_recall` / `mem_save`) is opt-in and project-scoped. Without it the hooks still record observations and inject context, but Claude is far less likely to call the MCP tools on its own. One-time per project: `/adopt`. Remove with `/unadopt`.
+
 ### Method 2: npx (one-liner)
 
 ```bash
@@ -159,7 +161,7 @@ Source files stay in the cloned repo. Update via `git pull && node install.mjs i
 ### What happens during installation
 
 1. **Install dependencies** -- `npm install --omit=dev` (compiles native `better-sqlite3`)
-2. **Register MCP server** -- `mem` server with 16 tools (search, recent, recall, timeline, get, save, update, stats, delete, compress, maintain, export, fts_check, browse, registry, use)
+2. **Register MCP server** -- `mem-lite` server with 16 tools (search, recent, recall, timeline, get, save, update, stats, delete, compress, maintain, export, fts_check, browse, registry, use). The pre-v2.78 generic server name `mem` is renamed to `mem-lite` for namespace hygiene; the tool names themselves (`mem_search`, `mem_recall`, ...) are unchanged.
 3. **Configure hooks** -- `PostToolUse`, `SessionStart`, `Stop`, `UserPromptSubmit` lifecycle hooks
 4. **Create data directory** -- `~/.claude-mem-lite/` (hidden) for database, runtime, and managed resource files
 5. **Auto-migrate** -- If `~/.claude-mem/` (original claude-mem) or `~/claude-mem-lite/` (pre-v0.5 unhidden) exists, migrates database and runtime files to `~/.claude-mem-lite/`, preserving the original untouched
@@ -303,7 +305,7 @@ Slash commands `/adopt` and `/unadopt` wrap the same CLI.
   in the adopted project).
 - The MCP server instructions are built once at server boot and MCP has no
   "push" protocol — the `WHEN TO USE` / `Decision rules` trim only applies
-  after Claude Code restarts and re-spawns the mem MCP server. A single
+  after Claude Code restarts and re-spawns the mem-lite MCP server. A single
   `/exit` + fresh session is enough. Same caveat applies to `unadopt`.
 
 **Safety:**
@@ -511,6 +513,14 @@ Data in `~/.claude-mem-lite/` is preserved by default. Delete manually if needed
 rm -rf ~/.claude-mem-lite/
 ```
 
+### Mixed-install residue (read this if you've used multiple install methods)
+
+`/plugin uninstall` only removes the plugin manifest — it **does not touch `~/.claude/settings.json`**. If you've ever run `claude-mem-lite install` (npx or git-clone path), hook entries pointing at `~/.claude-mem-lite/hook.mjs` were written into your user-global settings, and they keep firing after `/plugin uninstall`. If `~/.claude-mem-lite/hook.mjs` still exists they double-fire alongside the plugin; if you also ran `rm -rf ~/.claude-mem-lite/` they error every session.
+
+**The safe sequence is**: run `claude-mem-lite uninstall` first (which cleans the settings.json hooks plus the global MCP registration), then `/plugin uninstall claude-mem-lite`, then optionally `rm -rf ~/.claude-mem-lite/`.
+
+If you already uninstalled in the wrong order, `claude-mem-lite doctor` flags orphan hooks under `Orphan hooks:` with the exact cleanup command.
+
 ## Project Structure
 
 ```

package/README.zh-CN.md

@@ -146,7 +146,9 @@ node install.mjs install
 ### 安装过程
 
 1. **安装依赖** -- `npm install --omit=dev`（编译原生 `better-sqlite3`）
-2. **注册 MCP 服务器** -- `mem` 服务器，包含 15 个工具（search、recent、recall、timeline、get、save、update、stats、delete、compress、maintain、export、fts_check、browse、registry）
+2. **注册 MCP 服务器** -- `mem-lite` 服务器，包含 15 个工具（search、recent、recall、timeline、get、save、update、stats、delete、compress、maintain、export、fts_check、browse、registry）。v2.78 前服务器名为通用的 `mem`，现已改名为 `mem-lite` 避免与用户其它 `.mcp.json` 冲突；工具名（`mem_search`/`mem_recall` 等）保持不变。
+
+> **每个项目第一次使用，跑一次 `/adopt`。** Plugin 安装给你 MCP server + hooks + slash commands，但**邀请式 memory 哨兵**（一条提升 Claude 主动调用 `mem_recall` / `mem_save` 的 system-authority 指针）是按项目 opt-in 的。不跑 `/adopt` 时 hooks 仍记录观察、注入上下文，但 Claude 不太会主动调 MCP 工具。一次性、按项目：`/adopt`；撤销 `/unadopt`。
 3. **配置钩子** -- `PostToolUse`、`PreToolUse`、`SessionStart`、`Stop`、`UserPromptSubmit` 生命周期钩子
 4. **创建数据目录** -- `~/.claude-mem-lite/`（隐藏目录），存放数据库、运行时和托管资源文件
 5. **自动迁移** -- 自动检测 `~/.claude-mem/`（原版 claude-mem）或 `~/claude-mem-lite/`（v0.5 前的非隐藏目录），将数据库和运行时文件迁移到 `~/.claude-mem-lite/`，原目录保持不变
@@ -282,7 +284,7 @@ Slash 命令 `/adopt` 和 `/unadopt` 是上述 CLI 的包装。
   后缀）**下一次 SessionStart** 生效（adopt 的项目下任一新会话）。
 - MCP server instructions 是**服务启动时构建一次**，MCP 协议无 "push" 机制，
   所以 `WHEN TO USE` / `Decision rules` 两段的瘦身**只在 Claude Code 重启后**
-  才生效（mem MCP 服务被重新 spawn）。`/exit` 一次再开新会话即可。`unadopt`
+  才生效（mem-lite MCP 服务被重新 spawn）。`/exit` 一次再开新会话即可。`unadopt`
   同理。
 
 **安全性：**
@@ -474,6 +476,14 @@ npx claude-mem-lite uninstall --purge
 rm -rf ~/.claude-mem-lite/
 ```
 
+### 混装残留（用过多种安装方式的话务必看一下）
+
+`/plugin uninstall` 只删 plugin manifest，**不会动 `~/.claude/settings.json`**。如果你曾经跑过 `claude-mem-lite install`（npx 或 git-clone 路径），指向 `~/.claude-mem-lite/hook.mjs` 的 hook 条目就被写进了你的 user-global settings；`/plugin uninstall` 之后它们还在每会话触发。如果 `~/.claude-mem-lite/hook.mjs` 还在 → 与 plugin 双触发；如果你又 `rm -rf ~/.claude-mem-lite/` → 每次会话报错。
+
+**正确顺序**：先 `claude-mem-lite uninstall`（清 settings.json 的 hook + 全局 MCP 注册），再 `/plugin uninstall claude-mem-lite`，最后可选 `rm -rf ~/.claude-mem-lite/`。
+
+顺序搞错了的话，`claude-mem-lite doctor` 会在 `Orphan hooks:` 一节标出残留并给清理命令。
+
 ## 项目结构
 
 ```

package/commands/adopt.md

@@ -52,7 +52,7 @@ session. After running `adopt`:
   on the next SessionStart.
 - MCP-instructions trim (`WHEN TO USE` / `Decision rules` sections) only
   takes effect after Claude Code itself restarts (or at least re-attaches
-  the mem MCP server). If you still see the verbose MCP instructions after
+  the mem-lite MCP server). If you still see the verbose MCP instructions after
   adopt, a `/exit` + fresh session is enough.
 
 Same caveat applies in reverse for `/unadopt`.

package/hook-update.mjs

@@ -311,16 +311,23 @@ export function installExtractedRelease(sourceDir, targetDir = INSTALL_DIR) {
     rmSync(stagingDir, { recursive: true, force: true });
     rmSync(backupDir, { recursive: true, force: true });
 
-    // Post-update migration: clean stale global MCP if plugin handles it
+    // Post-update migration: clean stale global MCPs if plugin handles it.
+    // Both "mem" (legacy, pre-v2.78) and "mem-lite" (current) are purged so a
+    // user who manually ran `claude mcp add` in either era doesn't end up with
+    // duplicate global + plugin registrations after the rename.
     try {
       if (isPluginMode()) {
         const claudeJsonPath = join(homedir(), '.claude.json');
         const cfg = JSON.parse(readFileSync(claudeJsonPath, 'utf8'));
-        if (cfg.mcpServers?.mem) {
-          delete cfg.mcpServers.mem;
-          writeFileSync(claudeJsonPath, JSON.stringify(cfg, null, 2) + '\n');
-          debugLog('DEBUG', 'hook-update', 'Post-update: removed stale global MCP "mem"');
+        let changed = false;
+        for (const k of ['mem', 'mem-lite']) {
+          if (cfg.mcpServers?.[k]) {
+            delete cfg.mcpServers[k];
+            changed = true;
+            debugLog('DEBUG', 'hook-update', `Post-update: removed stale global MCP "${k}"`);
+          }
         }
+        if (changed) writeFileSync(claudeJsonPath, JSON.stringify(cfg, null, 2) + '\n');
       }
     } catch (e) { debugCatch(e, 'post-update-mcp-dedup'); }
 

package/hook.mjs

@@ -20,7 +20,7 @@
 
 import { randomUUID } from 'crypto';
 import { join } from 'path';
-import { readFileSync, writeFileSync, unlinkSync, readdirSync, renameSync, statSync } from 'fs';
+import { readFileSync, writeFileSync, unlinkSync, readdirSync, renameSync, statSync, existsSync } from 'fs';
 import { homedir } from 'os';
 import {
   truncate, inferProject, detectBashSignificance,
@@ -51,6 +51,7 @@ import {
   bumpCitationAccess,
   computeCiteRecall,
   applyCitationDecay,
+  hasMainThreadAssistantText,
 } from './lib/citation-tracker.mjs';
 import { extractTailAssistantText, extractStructuredSummary } from './lib/summary-extractor.mjs';
 import { searchRelevantMemories, formatMemoryLine } from './hook-memory.mjs';
@@ -537,9 +538,20 @@ async function handleStop() {
           try {
             const injected = extractAllInjected(transcriptPath);
             if (injected.size > 0) {
-              const citedMain = extractCitationsFromTranscript(transcriptPath, { mainOnly: true });
-              const r = applyCitationDecay(db, project, injected, citedMain, sessionId);
-              debugLog('DEBUG', 'handleStop', `citation-decay: touched=${r.touched} promoted=${r.promoted} demoted=${r.demoted}`);
+              // Text-floor gate: skip decay on tool-only Stops. Without this,
+              // a turn that ends on tool_use locks every injected obs as
+              // uncited (last_decided_session_id set), so a later turn that
+              // cites correctly can't undo the verdict. Per CLAUDE.md the
+              // contract is "NEXT time you produce user-facing text," so a
+              // session with zero main-thread text gets a free pass — the
+              // next Stop in the same session will re-evaluate.
+              if (!hasMainThreadAssistantText(transcriptPath)) {
+                debugLog('DEBUG', 'handleStop', `citation-decay: skipped (no main-thread assistant text yet, injected=${injected.size})`);
+              } else {
+                const citedMain = extractCitationsFromTranscript(transcriptPath, { mainOnly: true });
+                const r = applyCitationDecay(db, project, injected, citedMain, sessionId);
+                debugLog('DEBUG', 'handleStop', `citation-decay: touched=${r.touched} promoted=${r.promoted} demoted=${r.demoted}`);
+              }
             }
           } catch (e) { debugCatch(e, 'handleStop-citation-decay'); }
 
@@ -1103,6 +1115,33 @@ async function handleSessionStart() {
       if (citeNudge) {
         dashboardText = dashboardText ? `${citeNudge}\n${dashboardText}` : citeNudge;
       }
+      // v2.79: surface setup.sh dependency-install failure as a high-visibility
+      // line at the very top of the dashboard. setup.sh writes runtime/.deps-broken
+      // (JSON: ts/reason/root/repair) on failure and removes it on success — so
+      // a stale flag self-heals on the next clean SessionStart. Without this
+      // surface, hook degradation looks identical to "nothing happening" until
+      // the user notices missing context days later.
+      try {
+        const depsFlag = join(RUNTIME_DIR, '.deps-broken');
+        if (existsSync(depsFlag)) {
+          let detail = 'unknown';
+          let repair = '';
+          try {
+            const raw = readFileSync(depsFlag, 'utf8').trim();
+            const parsed = JSON.parse(raw);
+            detail = parsed.reason || detail;
+            repair = parsed.repair || '';
+          } catch { /* corrupt flag — surface the fact only */ }
+          const nudgeLines = [
+            '⚠️ [claude-mem-lite] Hook dependencies failed to install on the last SessionStart.',
+            `   Reason: ${detail}`,
+          ];
+          if (repair) nudgeLines.push(`   Repair: ${repair}`);
+          nudgeLines.push('   Until fixed, PreToolUse / PostToolUse / memory injection are degraded.');
+          const nudge = nudgeLines.join('\n');
+          dashboardText = dashboardText ? `${nudge}\n${dashboardText}` : nudge;
+        }
+      } catch (e) { debugCatch(e, 'session-start-deps-flag'); }
       if (dashboardText) {
         process.stdout.write(JSON.stringify({
           suppressOutput: true,

package/install.mjs

@@ -428,10 +428,12 @@ async function install() {
   }
 
   // 3. Register MCP server (skip if plugin system already handles it)
-  // Plugin MCP must stay at root .mcp.json so Claude Code registers plugin:*:mem.
-  // Duplicate mem registrations in practice come from old global install.mjs state
+  // Plugin MCP must stay at root .mcp.json so Claude Code registers plugin:*:mem-lite.
+  // Duplicate registrations in practice come from old global install.mjs state
   // (claude mcp add) or stale marketplace copies, not from the cache root itself.
-  // Global registration via `claude mcp add` creates a DUPLICATE mcp__mem__* server.
+  // Global registration via `claude mcp add` creates a DUPLICATE mcp__mem-lite__* server.
+  // The legacy generic name "mem" (pre-v2.78) is also purged so a user who installed in
+  // either era ends up with a single canonical "mem-lite" registration.
   // Detect plugin mode: installed_plugins.json has our entry → plugin handles MCP.
   const installedPluginsPath = join(homedir(), '.claude', 'plugins', 'installed_plugins.json');
   let pluginHandlesMcp = false;
@@ -442,18 +444,26 @@ async function install() {
 
   if (pluginHandlesMcp) {
     log('MCP server: plugin system handles registration (skipping global)');
-    // Clean up stale global registration if it exists (from older install.mjs versions)
-    try { execFileSync('claude', ['mcp', 'remove', '-s', 'user', 'mem'], { stdio: 'pipe' }); ok('Removed stale global MCP registration'); } catch {}
+    // Clean up stale global registrations (both legacy "mem" and current "mem-lite")
+    for (const name of ['mem', 'mem-lite']) {
+      try {
+        execFileSync('claude', ['mcp', 'remove', '-s', 'user', name], { stdio: 'pipe' });
+        ok(`Removed stale global MCP "${name}"`);
+      } catch {}
+    }
   } else {
     log('Registering MCP server...');
     try {
-      try { execFileSync('claude', ['mcp', 'remove', '-s', 'user', 'mem'], { stdio: 'pipe' }); } catch {}
-      execFileSync('claude', ['mcp', 'add', '-s', 'user', '-t', 'stdio', 'mem', '--', 'node', SERVER_PATH], { stdio: 'pipe' });
-      try { execFileSync('claude', ['mcp', 'remove', '-s', 'project', 'mem'], { stdio: 'pipe' }); } catch {}
-      ok('MCP server registered: mem');
+      // Purge legacy "mem" and any pre-existing "mem-lite" before re-registering
+      for (const name of ['mem', 'mem-lite']) {
+        try { execFileSync('claude', ['mcp', 'remove', '-s', 'user', name], { stdio: 'pipe' }); } catch {}
+        try { execFileSync('claude', ['mcp', 'remove', '-s', 'project', name], { stdio: 'pipe' }); } catch {}
+      }
+      execFileSync('claude', ['mcp', 'add', '-s', 'user', '-t', 'stdio', 'mem-lite', '--', 'node', SERVER_PATH], { stdio: 'pipe' });
+      ok('MCP server registered: mem-lite');
     } catch (e) {
       fail('MCP registration failed: ' + e.message);
-      warn('Try manually: claude mcp add -s user -t stdio mem -- node ' + SERVER_PATH);
+      warn('Try manually: claude mcp add -s user -t stdio mem-lite -- node ' + SERVER_PATH);
     }
   }
 
@@ -933,13 +943,18 @@ async function install() {
 async function uninstall() {
   console.log('\nclaude-mem-lite uninstaller\n');
 
-  // 1. Remove MCP (legacy hook-based install)
-  try {
-    execFileSync('claude', ['mcp', 'remove', '-s', 'user', 'mem'], { stdio: 'pipe' });
-    ok('MCP server removed');
-  } catch {
-    warn('MCP server not found or already removed');
+  // 1. Remove MCP (legacy hook-based install).
+  // Try both the legacy "mem" (pre-v2.78) and current "mem-lite" names so a user
+  // who installed in either era ends up clean.
+  let removedAny = false;
+  for (const name of ['mem', 'mem-lite']) {
+    try {
+      execFileSync('claude', ['mcp', 'remove', '-s', 'user', name], { stdio: 'pipe' });
+      ok(`MCP server removed: ${name}`);
+      removedAny = true;
+    } catch {}
   }
+  if (!removedAny) warn('MCP server not found or already removed');
 
   // 1b. Remove CLI symlink
   for (const binDir of [join(homedir(), '.local', 'bin'), '/usr/local/bin']) {
@@ -1068,7 +1083,11 @@ async function status() {
   // MCP
   try {
     const list = execFileSync('claude', ['mcp', 'list'], { encoding: 'utf8' });
-    const registered = list.includes('mem:') || list.includes('mem ');
+    // Accept either the current "mem-lite" registration or the legacy "mem"
+    // name (pre-v2.78) so a user mid-upgrade still sees a green status until
+    // setup.sh / install.mjs purges the legacy entry on next run.
+    const registered = list.includes('mem-lite:') || list.includes('mem-lite ')
+      || list.includes('mem:') || /\bmem\b\s/.test(list);
     push(registered ? 'ok' : 'fail', 'mcp', registered ? 'MCP server: registered' : 'MCP server: not registered', { registered });
   } catch {
     push('warn', 'mcp', 'Could not check MCP status', { registered: null });
@@ -1242,6 +1261,24 @@ async function doctor() {
     dwarn('Plugin lifecycle: hooks not configured');
   }
 
+  // Orphan hooks: settings.json entries referencing hook files that no longer
+  // exist on disk. Trips when a user runs `/plugin uninstall` and/or
+  // `rm -rf ~/.claude-mem-lite/` without first running `claude-mem-lite uninstall`
+  // (which clears the settings.json entries). The hooks keep firing and exit
+  // with require-error noise every session. README's Uninstall section warns
+  // about the right ordering; this check flags the broken state so it surfaces
+  // even when the user skipped the README.
+  const orphanPaths = collectOrphanHookPaths(settings);
+  if (orphanPaths.length > 0) {
+    fail(`Orphan hooks: ${orphanPaths.length} settings.json entr${orphanPaths.length === 1 ? 'y references a' : 'ies reference'} missing file(s)`);
+    for (const p of orphanPaths.slice(0, 5)) log(`    missing: ${p}`);
+    if (orphanPaths.length > 5) log(`    ... +${orphanPaths.length - 5} more`);
+    log(`    Repair: node ${join(PROJECT_DIR, 'install.mjs')} uninstall    # removes the dead hook entries`);
+    issues++;
+  } else if (hasHooks) {
+    ok('Orphan hooks: none (all hook targets present)');
+  }
+
   // Database
   if (existsSync(DB_PATH)) {
     try {
@@ -1464,6 +1501,48 @@ function hasMemHooksConfigured(settings) {
   );
 }
 
+/**
+ * Walk every mem-hook command in settings.json and collect any absolute file
+ * paths that don't currently exist on disk. Used by doctor() to surface
+ * post-uninstall residue ("/plugin uninstall claude-mem-lite" leaves
+ * settings.json hooks pointing at ~/.claude-mem-lite/hook.mjs; if the user
+ * then deleted that directory, every session start dispatches to a missing
+ * file).
+ *
+ * Path extraction: command strings look like:
+ *   node "/home/sds/.claude-mem-lite/hook.mjs" session-start
+ *   bash "/home/sds/.claude-mem-lite/scripts/post-tool-use.sh"
+ *   node "/home/sds/.claude-mem-lite/scripts/pre-tool-recall.js"
+ * We pick the first quoted absolute path; if there is no quoted token we fall
+ * back to the first whitespace-delimited absolute-looking token after the
+ * interpreter. ${CLAUDE_PLUGIN_ROOT}-templated commands are ignored — those
+ * are plugin-owned hooks resolved by Claude Code at runtime, not by us.
+ */
+export function collectOrphanHookPaths(settings) {
+  if (!settings?.hooks) return [];
+  const out = [];
+  for (const configs of Object.values(settings.hooks)) {
+    if (!Array.isArray(configs)) continue;
+    for (const cfg of configs) {
+      if (!isMemHook(cfg)) continue;
+      for (const h of cfg.hooks || []) {
+        const cmd = h.command || '';
+        if (cmd.includes('${CLAUDE_PLUGIN_ROOT}')) continue;
+        const quoted = cmd.match(/"([^"]+)"/);
+        let path = quoted ? quoted[1] : null;
+        if (!path) {
+          // unquoted: split on whitespace, take the first arg that looks like an absolute path
+          const parts = cmd.split(/\s+/);
+          path = parts.find(p => p.startsWith('/') && (p.endsWith('.mjs') || p.endsWith('.js') || p.endsWith('.sh'))) || null;
+        }
+        if (!path) continue;
+        if (!existsSync(path) && !out.includes(path)) out.push(path);
+      }
+    }
+  }
+  return out;
+}
+
 /**
  * v2.48 P1-4: prune top-level stale files left behind by removed-module upgrades.
  *

package/lib/citation-tracker.mjs

@@ -266,6 +266,39 @@ export function extractAllInjected(transcriptPath) {
   ]);
 }
 
+/**
+ * True iff the transcript contains at least one non-whitespace text block from
+ * a main-thread assistant turn. Gates the citation-decay loop so a tool-only
+ * Stop doesn't lock an injection as "uncited" before the model has had a
+ * chance to produce user-facing text. Per CLAUDE.md the cite contract is
+ * "NEXT time you produce user-facing text" — not "same turn." Without this
+ * gate, a turn that ends on tool_use sees applyCitationDecay run, set
+ * last_decided_session_id, and freeze the verdict at uncited even though a
+ * later turn in the same session would have cited correctly.
+ *
+ * @param {string|null|undefined} transcriptPath
+ * @returns {boolean}
+ */
+export function hasMainThreadAssistantText(transcriptPath) {
+  if (!transcriptPath || !existsSync(transcriptPath)) return false;
+  let raw;
+  try { raw = readFileSync(transcriptPath, 'utf8'); } catch { return false; }
+  for (const line of raw.split('\n')) {
+    if (!line.trim()) continue;
+    let entry;
+    try { entry = JSON.parse(line); } catch { continue; }
+    if (entry.type !== 'assistant' || !entry.message) continue;
+    if (entry.isSidechain === true) continue;
+    const content = entry.message.content;
+    if (!Array.isArray(content)) continue;
+    for (const block of content) {
+      if (block.type !== 'text' || typeof block.text !== 'string') continue;
+      if (block.text.trim().length > 0) return true;
+    }
+  }
+  return false;
+}
+
 const IMPORTANCE_CAP = 3;
 const IMPORTANCE_FLOOR = 0;
 const UNCITED_STREAK_THRESHOLD = 3;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "2.77.0",
+  "version": "2.79.0",
   "description": "Lightweight persistent memory system for Claude Code",
   "type": "module",
   "packageManager": "npm@10.9.2",

package/scripts/post-tool-use.sh

@@ -51,7 +51,7 @@ case "$tool" in
     exit 0
     ;;
   # Prefix filters
-  mem_*|mcp__mem__*|mcp__plugin_claude-mem-lite*|mcp__sequential*|mcp__plugin_context7*)
+  mem_*|mcp__mem__*|mcp__mem-lite__*|mcp__plugin_claude-mem-lite*|mcp__sequential*|mcp__plugin_context7*)
     exit 0
     ;;
 esac

package/scripts/setup.sh

@@ -69,11 +69,39 @@ mkdir -p "$DATA_DIR/runtime"
 
 # 6. Ensure native dependencies available for hooks (ESM import needs node_modules in resolution chain)
 #    Plugin cache doesn't include node_modules — symlink from data dir or npm install on first run
+#
+# Visibility contract: `npm install` failure here used to be a stderr-only log_warn,
+# invisible to the Claude session unless the operator was watching the terminal.
+# When it fails (no toolchain, blocked network, read-only FS) every hook silently
+# degrades — pre-tool-recall, post-tool-use, session-start all import better-sqlite3
+# and exit on the require() error. v2.79: write a JSON flag to runtime/.deps-broken
+# and hook.mjs SessionStart surfaces it in the Claude context as a HIGH-VISIBILITY
+# block; success branches remove the flag so a self-heal stays visible too.
+DEPS_FLAG="$DATA_DIR/runtime/.deps-broken"
+mkdir -p "$DATA_DIR/runtime" 2>/dev/null || true
+
+mark_deps_broken() {
+  local reason="$1"
+  # Embed reason + repair command so hook.mjs renders a complete error without
+  # having to re-derive them. Single-line JSON for trivial parse.
+  printf '{"ts":"%s","reason":%s,"root":%s,"repair":%s}\n' \
+    "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
+    "\"$reason\"" \
+    "\"$ROOT\"" \
+    "\"cd '$ROOT' && npm install --omit=dev\"" \
+    > "$DEPS_FLAG" 2>/dev/null || true
+}
+
+mark_deps_ok() {
+  rm -f "$DEPS_FLAG" 2>/dev/null || true
+}
+
 if [[ ! -d "$ROOT/node_modules/better-sqlite3" ]]; then
   # Fast path: symlink from data dir (instant, no network needed)
   if [[ -d "$DATA_DIR/node_modules/better-sqlite3" ]]; then
     if ln -sfn "$DATA_DIR/node_modules" "$ROOT/node_modules" 2>/dev/null; then
       log_ok "Dependencies linked from $DATA_DIR"
+      mark_deps_ok
     fi
   fi
   # Slow path: npm install (first-time only, ~10-20s for native addon)
@@ -81,35 +109,47 @@ if [[ ! -d "$ROOT/node_modules/better-sqlite3" ]]; then
     log_info "Installing dependencies (first-time setup)..."
     if (cd "$ROOT" && npm install --omit=dev --no-audit --no-fund 2>&1) >&2; then
       log_ok "Dependencies installed"
+      mark_deps_ok
     else
-      log_warn "Dependency install failed — hooks may have limited functionality"
+      log_warn "Dependency install failed — hooks may have limited functionality (flag: $DEPS_FLAG)"
+      mark_deps_broken "npm install --omit=dev failed in plugin cache root"
     fi
   fi
+else
+  # Deps already present — make sure we don't keep stale broken flag around
+  mark_deps_ok
 fi
 
-# 7. MCP cleanup: idempotently clean stale registrations from pre-2.10 direct installs.
-#    This runs on every plugin SessionStart because old global mem entries may still
+# 7. MCP cleanup: idempotently clean stale registrations from older installs.
+#    This runs on every plugin SessionStart because old global entries may still
 #    exist even after an earlier migration marker was written.
-#    Before 2.10: old direct installs left a global mem MCP alongside plugin MCP.
-#    - Global mcpServers.mem in ~/.claude.json (from old install.mjs)
-#    - Possibly stale marketplace root .mcp.json (from old git clone)
+#    - Pre-2.10: direct installs left a global "mem" MCP alongside plugin MCP.
+#    - Pre-2.78: plugin and global registrations used the generic name "mem";
+#      v2.78 renamed to "mem-lite" — any stale global "mem" must be purged so
+#      Claude Code doesn't surface duplicate (old "mem" + new "mem-lite") tool
+#      prefixes side-by-side.
 #    Root .mcp.json in the installed plugin cache is required for Claude Code to
 #    register plugin MCP; only stale global/marketplace copies should be removed.
-MCP_MIGRATION="$DATA_DIR/runtime/.mcp-dedup-v2.10.4"
+MCP_MIGRATION="$DATA_DIR/runtime/.mcp-dedup-v2.78"
 if [[ -n "${CLAUDE_PLUGIN_ROOT:-}" ]]; then
   CLAUDE_JSON="$HOME/.claude.json" node -e '
     const fs = require("fs");
     let changed = false;
-    // Remove stale global MCP registration (plugin .mcp.json handles it)
+    // Remove stale global MCP registrations (plugin .mcp.json handles it).
+    // Both "mem" (legacy, pre-v2.78) and "mem-lite" (current) are purged from
+    // user-global scope when running inside the plugin — the plugin manifest
+    // is the single source of truth.
     try {
       const p = process.env.CLAUDE_JSON;
       const d = JSON.parse(fs.readFileSync(p, "utf8"));
-      if (d.mcpServers?.mem) {
-        delete d.mcpServers.mem;
-        fs.writeFileSync(p, JSON.stringify(d, null, 2) + "\n");
-        process.stderr.write("✓ Removed stale global MCP \"mem\" (plugin handles it)\n");
-        changed = true;
+      for (const k of ["mem", "mem-lite"]) {
+        if (d.mcpServers?.[k]) {
+          delete d.mcpServers[k];
+          process.stderr.write(`✓ Removed stale global MCP "${k}" (plugin handles it)\n`);
+          changed = true;
+        }
       }
+      if (changed) fs.writeFileSync(p, JSON.stringify(d, null, 2) + "\n");
     } catch {}
     // NOTE: Do NOT touch marketplace .mcp.json — Claude Code copies it from
     // marketplace → plugin cache on updates. Clearing it causes the cache

package/server.mjs

@@ -12,7 +12,7 @@ import { ensureDb, DB_PATH, REGISTRY_DB_PATH } from './schema.mjs';
 import { reRankWithContext, markSuperseded, autoBoostIfNeeded, runIdleCleanup, buildServerInstructions } from './server-internals.mjs';
 import { searchObservationsHybrid, findFtsAnchor } from './search-engine.mjs';
 import { scrubRecord } from './lib/scrub-record.mjs';
-import { effectiveQuiet } from './hook-shared.mjs';
+import { effectiveQuiet, RUNTIME_DIR } from './hook-shared.mjs';
 import { computeTier, TIER_CASE_SQL, tierSqlParams } from './tier.mjs';
 import { memSearchSchema, memRecentSchema, memTimelineSchema, memGetSchema, memDeleteSchema, memSaveSchema, memStatsSchema, memCompressSchema, memMaintainSchema, memOptimizeSchema, memUpdateSchema, memExportSchema, memRecallSchema, memFtsCheckSchema, memRegistrySchema, memBrowseSchema, memUseSchema, memDeferSchema, memDeferListSchema, memDeferDropSchema, tools as TOOL_DEFS } from './tool-schemas.mjs';
 
@@ -43,7 +43,7 @@ const { version: PKG_VERSION } = require('./package.json');
 
 // ─── Database ───────────────────────────────────────────────────────────────
 
-import { rmSync, existsSync, readFileSync } from 'fs';
+import { rmSync, existsSync, readFileSync, appendFileSync, mkdirSync } from 'fs';
 
 let db;
 try {
@@ -127,7 +127,7 @@ if (process.env.CLAUDE_MEM_QUIET_TRACE !== '0') {
 }
 
 const server = new McpServer(
-  { name: 'claude-mem-lite', version: PKG_VERSION },
+  { name: 'mem-lite', version: PKG_VERSION },
   { instructions: buildServerInstructions(_quiet) },
 );
 
@@ -2267,5 +2267,24 @@ process.on('unhandledRejection', (err) => { debugCatch(err, 'unhandledRejection'
 
 // ─── Start Server ───────────────────────────────────────────────────────────
 
+// Spawn telemetry — appends one JSON line per process start so we can diagnose
+// dual-registration (plugin namespace + local .mcp.json could both spawn the
+// server in one Claude Code session). Two records with close timestamps and
+// the same ppid is the smoking gun. Never throws — telemetry must not block
+// startup. Disable with MEM_DISABLE_SPAWN_LOG=1.
+if (process.env.MEM_DISABLE_SPAWN_LOG !== '1') {
+  try {
+    if (!existsSync(RUNTIME_DIR)) mkdirSync(RUNTIME_DIR, { recursive: true });
+    const line = JSON.stringify({
+      ts: new Date().toISOString(),
+      pid: process.pid,
+      ppid: process.ppid,
+      argv1: process.argv[1] || '',
+      version: PKG_VERSION,
+    }) + '\n';
+    appendFileSync(join(RUNTIME_DIR, 'mcp-spawns.log'), line, { mode: 0o600 });
+  } catch { /* never block startup on telemetry failure */ }
+}
+
 const transport = new StdioServerTransport();
 await server.connect(transport);

package/skip-tools.mjs

@@ -14,7 +14,8 @@ export const SKIP_TOOLS = new Set([
 /** Prefix patterns — tools starting with these are also skipped */
 export const SKIP_PREFIXES = [
   'mem_',
-  'mcp__mem__',
+  'mcp__mem__',         // legacy global MCP name (pre-rename)
+  'mcp__mem-lite__',    // current global MCP name (post-rename v2.78+)
   'mcp__plugin_claude-mem-lite',
   'mcp__sequential',
   'mcp__plugin_context7',