claude-mem-lite 2.9.2 → 2.9.4

package/.claude-plugin/marketplace.json

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

package/README.md

@@ -121,7 +121,7 @@ The original sends **everything to the LLM and hopes it filters well**. claude-m
 /plugin install claude-mem-lite
 ```
 
-The plugin system handles everything: hooks, MCP server, and dependency installation (via Setup hook). Dependencies are installed automatically on first run.
+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.
 
 ### Method 2: npx (one-liner)
 
@@ -375,6 +375,8 @@ node install.mjs uninstall            # Remove (keep data)
 node install.mjs uninstall --purge    # Remove and delete all data
 node install.mjs status               # Show current status
 node install.mjs doctor               # Diagnose issues
+node install.mjs cleanup-hooks        # Remove only stale claude-mem-lite hooks from settings.json
+node install.mjs update               # Force-check for updates and install them (direct install / npx mode)
 
 # npx install:
 npx claude-mem-lite                   # Install / reinstall
@@ -382,13 +384,18 @@ npx claude-mem-lite uninstall         # Remove (keep data)
 npx claude-mem-lite doctor            # Diagnose issues
 ```
 
+Notes:
+- Plugin mode only reports available updates; it does not self-update plugin files.
+- Direct install / npx mode keeps auto-update enabled and uses staged replacement with rollback on install failure.
+- If you disabled the plugin but still have old mem hooks in `~/.claude/settings.json`, run `node install.mjs cleanup-hooks`.
+
 ### doctor
 
 Checks Node.js version, dependencies, server/hook files, database integrity, FTS5 indexes, and stale processes.
 
 ### status
 
-Shows MCP registration, hook configuration, and database stats (observation/session counts).
+Shows MCP registration, hook configuration, plugin disabled state, and database stats (observation/session counts).
 
 ## Uninstall
 

package/README.zh-CN.md

@@ -121,7 +121,7 @@
 /plugin install claude-mem-lite
 ```
 
-插件系统会处理一切：钩子、MCP 服务器和依赖安装（通过 Setup 钩子）。依赖会在首次运行时自动安装。
+插件模式会管理自己的运行时与钩子。SessionStart 时它现在只会**检查并提示**新版本，不会直接覆盖插件目录中的文件。插件模式请通过 Claude 的插件更新流程完成升级。
 
 ### 方式二：npx（一行命令）
 
@@ -375,6 +375,8 @@ node install.mjs uninstall            # 移除（保留数据）
 node install.mjs uninstall --purge    # 移除并删除所有数据
 node install.mjs status               # 显示当前状态
 node install.mjs doctor               # 诊断问题
+node install.mjs cleanup-hooks        # 只清理 settings.json 中残留的 claude-mem-lite hooks
+node install.mjs update               # 强制检查并安装更新（direct install / npx 模式）
 
 # npx 安装：
 npx claude-mem-lite                   # 安装 / 重新安装
@@ -382,13 +384,18 @@ npx claude-mem-lite uninstall         # 移除（保留数据）
 npx claude-mem-lite doctor            # 诊断问题
 ```
 
+说明：
+- 插件模式只提示可用更新，不会自更新插件文件。
+- direct install / npx 模式保留自动更新，并使用 staged replacement；若依赖安装失败会回滚。
+- 如果你禁用了插件，但 `~/.claude/settings.json` 里还有旧的 mem hooks，可运行 `node install.mjs cleanup-hooks`。
+
 ### doctor
 
 检查 Node.js 版本、依赖、服务器/钩子文件、数据库完整性、FTS5 索引和残留进程。
 
 ### status
 
-显示 MCP 注册状态、钩子配置和数据库统计（观察/会话数量）。
+显示 MCP 注册状态、钩子配置、插件禁用状态和数据库统计（观察/会话数量）。
 
 ## 卸载
 

package/cli.mjs

@@ -1,2 +1,4 @@
 #!/usr/bin/env node
-import './install.mjs';
+import { main } from './install.mjs';
+
+await main(process.argv.slice(2));

package/dispatch.mjs

@@ -840,8 +840,11 @@ function passesConfidenceGate(results, signals) {
     const top1 = Math.abs(results[0].composite_score ?? results[0].relevance ?? 0);
     const top2 = Math.abs(results[1].composite_score ?? results[1].relevance ?? 0);
     // After keyword re-ranking, #1 may have lower raw BM25 than #2.
-    // The keyword match provides additional confidence, so skip the gap check.
-    const wasReRanked = signals?.rawKeywords?.length > 0 && top1 < top2;
+    // Only skip gap check if #1 was actually promoted by a keyword match
+    // (not just any rawKeywords present with incidentally inverted scores).
+    const top1Tags = (results[0].intent_tags || '').toLowerCase();
+    const top1MatchesKw = signals?.rawKeywords?.some(kw => top1Tags.includes(kw));
+    const wasReRanked = top1MatchesKw && top1 < top2;
     if (!wasReRanked && top1 > 0) {
       const gapRatio = (top1 - top2) / top1;
       if (gapRatio < 0.2) {
@@ -1007,8 +1010,8 @@ function decideTier(resource, signals) {
     else signalBoost += 0.1;
   }
   if (signals?.rawKeywords?.length > 0) {
-    const tags = (resource.intent_tags || '').toLowerCase();
-    if (signals.rawKeywords.some(kw => tags.includes(kw))) signalBoost += 0.2;
+    const tagArr = (resource.intent_tags || '').toLowerCase().split(/[\s,]+/);
+    if (signals.rawKeywords.some(kw => tagArr.includes(kw))) signalBoost += 0.2;
   }
 
   const confidence = Math.min(1.0, normalized + patternBoost * 0.3 + signalBoost);

package/hook-update.mjs

@@ -3,8 +3,8 @@
 // Skips in dev mode (symlinked installs). Silent on network failure.
 
 import { execSync } from 'node:child_process';
-import { readFileSync, writeFileSync, copyFileSync, readdirSync, existsSync, lstatSync, mkdirSync, rmSync } from 'node:fs';
-import { join } from 'node:path';
+import { readFileSync, writeFileSync, copyFileSync, readdirSync, existsSync, lstatSync, mkdirSync, rmSync, renameSync } from 'node:fs';
+import { join, dirname } from 'node:path';
 import { tmpdir } from 'node:os';
 import { DB_DIR } from './schema.mjs';
 import { debugCatch, debugLog } from './utils.mjs';
@@ -16,17 +16,29 @@ const STATE_FILE = join(INSTALL_DIR, 'runtime', 'update-state.json');
 const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;       // 24 hours
 const FETCH_TIMEOUT_MS = 3000;                         // 3s network timeout
 const RATE_LIMIT_INTERVAL_MS = 6 * 60 * 60 * 1000;   // 6h if rate-limited
+const NPM_INSTALL_CMD = 'npm install --omit=dev --no-audit --no-fund';
 
 // ── Main Entry ─────────────────────────────────────────────
-export async function checkForUpdate() {
+export async function checkForUpdate(options = {}) {
   try {
+    const pluginMode = isPluginMode();
+    const force = Boolean(options.force);
+    const allowInstall = options.allowInstall ?? !pluginMode;
+
     if (isDevMode() || process.env.CLAUDE_MEM_SKIP_UPDATE) return null;
 
     const state = readState();
-    if (!shouldCheck(state)) {
+    if (!force && !shouldCheck(state)) {
       // Return cached update info if previously detected
       if (state.updateAvailable && state.latestVersion) {
-        return { updateAvailable: true, from: state.installedVersion, to: state.latestVersion };
+        return {
+          updateAvailable: true,
+          updated: false,
+          from: state.installedVersion,
+          to: state.latestVersion,
+          installDeferred: pluginMode || !allowInstall,
+          pluginMode,
+        };
       }
       return null;
     }
@@ -42,7 +54,8 @@ export async function checkForUpdate() {
 
     if (hasUpdate) {
       debugLog('DEBUG', 'hook-update', `Update available: ${currentVersion} → ${latest.version}`);
-      const success = await downloadAndInstall(latest.tarballUrl);
+      const canInstall = !pluginMode && Boolean(allowInstall);
+      const success = canInstall ? await downloadAndInstall(latest.tarballUrl) : false;
       const newState = {
         lastCheck: new Date().toISOString(),
         installedVersion: success ? latest.version : currentVersion,
@@ -58,6 +71,8 @@ export async function checkForUpdate() {
         updated: success,
         from: currentVersion,
         to: latest.version,
+        installDeferred: !canInstall,
+        pluginMode,
       };
     }
 
@@ -76,6 +91,10 @@ export async function checkForUpdate() {
   }
 }
 
+function isPluginMode() {
+  return Boolean(process.env.CLAUDE_PLUGIN_ROOT);
+}
+
 // ── Dev Mode Detection ─────────────────────────────────────
 function isDevMode() {
   try {
@@ -172,12 +191,13 @@ const SOURCE_FILES = [
   'server.mjs', 'server-internals.mjs', 'tool-schemas.mjs',
   'hook.mjs', 'hook-shared.mjs', 'hook-llm.mjs', 'hook-memory.mjs',
   'hook-semaphore.mjs', 'hook-episode.mjs', 'hook-context.mjs', 'hook-handoff.mjs', 'hook-update.mjs',
-  'haiku-client.mjs', 'utils.mjs', 'schema.mjs', 'package.json', 'skill.md',
+  'haiku-client.mjs', 'utils.mjs', 'schema.mjs', 'package.json', 'package-lock.json', 'skill.md',
   'registry.mjs', 'registry-scanner.mjs', 'registry-indexer.mjs',
   'registry-retriever.mjs', 'resource-discovery.mjs',
-  'dispatch.mjs', 'dispatch-inject.mjs', 'dispatch-feedback.mjs', 'dispatch-workflow.mjs',
+  'dispatch.mjs', 'dispatch-inject.mjs', 'dispatch-feedback.mjs', 'dispatch-patterns.mjs', 'dispatch-workflow.mjs',
   'install.mjs',
 ];
+const SWITCHABLE_PATHS = [...SOURCE_FILES, 'scripts', 'registry', 'node_modules'];
 
 // ── Download & Install ─────────────────────────────────────
 // Direct file copy instead of running old install.mjs (avoids symlink overwrite in dev)
@@ -197,53 +217,113 @@ async function downloadAndInstall(tarballUrl) {
       { timeout: 30000, stdio: 'pipe' }
     );
 
-    // Direct copy: overwrite source files in INSTALL_DIR
-    // Safer than running old install.mjs which may not respect CLAUDE_MEM_DIR
-    let copied = 0;
-    for (const f of SOURCE_FILES) {
-      const src = join(tmpDir, f);
-      const dest = join(INSTALL_DIR, f);
-      if (existsSync(src)) {
-        copyFileSync(src, dest);
-        copied++;
-      }
-    }
+    return installExtractedRelease(tmpDir);
+  } catch (err) {
+    debugCatch(err, 'downloadAndInstall');
+    return false;
+  } finally {
+    try { rmSync(tmpDir, { recursive: true, force: true }); } catch {}
+  }
+}
+
+export function installExtractedRelease(sourceDir, targetDir = INSTALL_DIR) {
+  const ts = `${Date.now()}-${process.pid}`;
+  const stagingDir = join(targetDir, `.update-staging-${ts}`);
+  const backupDir = join(targetDir, `.update-backup-${ts}`);
+  const backedUp = [];
+  const installed = [];
+
+  try {
+    mkdirSync(stagingDir, { recursive: true });
+    mkdirSync(backupDir, { recursive: true });
+
+    copyReleaseIntoStaging(sourceDir, stagingDir);
+    execSync(NPM_INSTALL_CMD, {
+      cwd: stagingDir,
+      timeout: 60000,
+      stdio: 'pipe',
+    });
+
+    for (const relPath of SWITCHABLE_PATHS) {
+      const stagedPath = join(stagingDir, relPath);
+      if (!existsSync(stagedPath)) continue;
+
+      const targetPath = join(targetDir, relPath);
+      const backupPath = join(backupDir, relPath);
 
-    // Copy scripts/ directory if present
-    const srcScripts = join(tmpDir, 'scripts');
-    if (existsSync(srcScripts)) {
-      const destScripts = join(INSTALL_DIR, 'scripts');
-      mkdirSync(destScripts, { recursive: true });
-      for (const f of readdirSync(srcScripts)) {
-        copyFileSync(join(srcScripts, f), join(destScripts, f));
+      mkdirSync(dirname(targetPath), { recursive: true });
+      mkdirSync(dirname(backupPath), { recursive: true });
+
+      if (existsSync(targetPath)) {
+        renameSync(targetPath, backupPath);
+        backedUp.push(relPath);
       }
+
+      renameSync(stagedPath, targetPath);
+      installed.push(relPath);
     }
 
-    // Run npm install for dependencies (skip if node_modules is a symlink = dev mode)
-    const nmPath = join(INSTALL_DIR, 'node_modules');
-    if (!existsSync(nmPath) || !lstatSync(nmPath).isSymbolicLink()) {
+    rmSync(stagingDir, { recursive: true, force: true });
+    rmSync(backupDir, { recursive: true, force: true });
+    debugLog('DEBUG', 'hook-update', `Auto-update: switched ${installed.length} paths`);
+    return true;
+  } catch (err) {
+    debugCatch(err, 'installExtractedRelease');
+
+    for (const relPath of installed.reverse()) {
+      try { rmSync(join(targetDir, relPath), { recursive: true, force: true }); } catch {}
+    }
+    for (const relPath of backedUp.reverse()) {
+      const backupPath = join(backupDir, relPath);
+      const targetPath = join(targetDir, relPath);
       try {
-        execSync('npm install --omit=dev', {
-          cwd: INSTALL_DIR,
-          timeout: 60000,
-          stdio: 'pipe',
-        });
-      } catch (err) {
-        debugCatch(err, 'downloadAndInstall-npm');
-        // Non-fatal: old node_modules may still work
+        if (existsSync(backupPath)) {
+          mkdirSync(dirname(targetPath), { recursive: true });
+          renameSync(backupPath, targetPath);
+        }
+      } catch (restoreErr) {
+        debugCatch(restoreErr, `installExtractedRelease-restore-${relPath}`);
       }
     }
 
-    debugLog('DEBUG', 'hook-update', `Auto-update: ${copied} files copied`);
-    return true;
-  } catch (err) {
-    debugCatch(err, 'downloadAndInstall');
+    try { rmSync(stagingDir, { recursive: true, force: true }); } catch {}
+    try { rmSync(backupDir, { recursive: true, force: true }); } catch {}
     return false;
-  } finally {
-    try { rmSync(tmpDir, { recursive: true, force: true }); } catch {}
   }
 }
 
+function copyReleaseIntoStaging(sourceDir, stagingDir) {
+  let copied = 0;
+
+  for (const f of SOURCE_FILES) {
+    const src = join(sourceDir, f);
+    const dest = join(stagingDir, f);
+    if (!existsSync(src)) continue;
+    mkdirSync(dirname(dest), { recursive: true });
+    copyFileSync(src, dest);
+    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));
+    }
+  }
+
+  const stagedScripts = join(stagingDir, 'scripts');
+  if (existsSync(stagedScripts)) {
+    for (const sf of readdirSync(stagedScripts).filter(n => n.endsWith('.sh'))) {
+      try { execSync(`chmod +x "${join(stagedScripts, sf)}"`, { stdio: 'pipe' }); } catch {}
+    }
+  }
+
+  debugLog('DEBUG', 'hook-update', `Auto-update staged ${copied} source files`);
+}
+
 // ── State Persistence ──────────────────────────────────────
 function readState() {
   try {

package/hook.mjs

@@ -7,6 +7,7 @@
 import { randomUUID } from 'crypto';
 import { join, basename } from 'path';
 import { readFileSync, writeFileSync, unlinkSync, readdirSync, renameSync, statSync } from 'fs';
+import { homedir } from 'os';
 import {
   truncate, typeIcon, inferProject, detectBashSignificance,
   extractErrorKeywords, extractFilePaths, isRelatedToEpisode,
@@ -40,6 +41,22 @@ import { checkForUpdate } from './hook-update.mjs';
 // Background workers (llm-episode, llm-summary, resource-scan) are exempt — they're ours
 const event = process.argv[2];
 const BG_EVENTS = new Set(['llm-episode', 'llm-summary', 'resource-scan']);
+
+// Respect Claude Code plugin disable state even when legacy settings.json hooks remain.
+// install.mjs writes direct hooks into ~/.claude/settings.json, so disabling the plugin
+// in Claude UI does not automatically remove them. Exit early to make disable actually work.
+const PLUGIN_KEY = 'claude-mem-lite@sdsrss';
+function isPluginExplicitlyDisabled() {
+  try {
+    const settingsPath = join(homedir(), '.claude', 'settings.json');
+    const settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+    return settings.enabledPlugins?.[PLUGIN_KEY] === false;
+  } catch {
+    return false;
+  }
+}
+
+if (event && isPluginExplicitlyDisabled()) process.exit(0);
 if (process.env.CLAUDE_MEM_HOOK_RUNNING && !BG_EVENTS.has(event)) process.exit(0);
 
 // Crash-safe: flush episode buffer on unexpected termination to prevent data loss
@@ -820,7 +837,10 @@ async function handleSessionStart() {
       if (updateResult?.updated) {
         process.stdout.write(`\n🔄 claude-mem-lite: v${updateResult.from} → v${updateResult.to} updated\n`);
       } else if (updateResult?.updateAvailable) {
-        process.stdout.write(`\n📦 claude-mem-lite: v${updateResult.to} available (current: v${updateResult.from})\n`);
+        const hint = updateResult.installDeferred
+          ? ' — plugin mode only checks for updates; reinstall/update the plugin to apply it'
+          : '';
+        process.stdout.write(`\n📦 claude-mem-lite: v${updateResult.to} available (current: v${updateResult.from})${hint}\n`);
       }
     } catch (e) { debugCatch(e, 'session-start-update'); }
 

package/install.mjs

@@ -22,6 +22,8 @@ const INSTALL_DIR = DATA_DIR;
 const SERVER_PATH = join(INSTALL_DIR, 'server.mjs');
 const HOOK_PATH = join(INSTALL_DIR, 'hook.mjs');
 const MARKETPLACE_KEY = 'sdsrss';
+const PLUGIN_KEY = `claude-mem-lite@${MARKETPLACE_KEY}`;
+const NPM_INSTALL_CMD = 'npm install --omit=dev --no-audit --no-fund';
 
 // ─── Curated Resource Metadata ───────────────────────────────────────────────
 // Replaces generic name-echo fallback with FTS5-optimized metadata per resource.
@@ -2033,8 +2035,8 @@ function registerVirtualResources(rdb) {
   return count;
 }
 
-const cmd = process.argv[2];
-const flags = new Set(process.argv.slice(3));
+let cmd = process.argv[2];
+let flags = new Set(process.argv.slice(3));
 
 function log(msg) { console.log(`  ${msg}`); }
 function ok(msg) { console.log(`  ✓ ${msg}`); }
@@ -2063,7 +2065,7 @@ async function install() {
     'server.mjs', 'server-internals.mjs', 'tool-schemas.mjs',
     'hook.mjs', 'hook-shared.mjs', 'hook-llm.mjs', 'hook-memory.mjs',
     'hook-semaphore.mjs', 'hook-episode.mjs', 'hook-context.mjs', 'hook-handoff.mjs', 'hook-update.mjs',
-    'haiku-client.mjs', 'utils.mjs', 'schema.mjs', 'package.json', 'skill.md',
+    'haiku-client.mjs', 'utils.mjs', 'schema.mjs', 'package.json', 'package-lock.json', 'skill.md',
     'registry.mjs', 'registry-scanner.mjs', 'registry-indexer.mjs',
     'registry-retriever.mjs', 'resource-discovery.mjs',
     'dispatch.mjs', 'dispatch-inject.mjs', 'dispatch-feedback.mjs', 'dispatch-patterns.mjs', 'dispatch-workflow.mjs',
@@ -2120,17 +2122,15 @@ async function install() {
   // 2. npm install (skip for --dev: node_modules is symlinked)
   if (IS_DEV) {
     ok('Dependencies: using dev dir (symlinked)');
-  } else if (!existsSync(join(INSTALL_DIR, 'node_modules'))) {
-    log('Installing dependencies...');
+  } else {
+    log('Ensuring dependencies installed...');
     try {
-      execSync('npm install --omit=dev', { cwd: INSTALL_DIR, stdio: 'pipe' });
+      execSync(NPM_INSTALL_CMD, { cwd: INSTALL_DIR, stdio: 'pipe' });
       ok('Dependencies installed');
     } catch (e) {
       fail('npm install failed: ' + e.message);
       process.exit(1);
     }
-  } else {
-    ok('Dependencies already installed');
   }
 
   // 3. Register MCP server
@@ -2187,6 +2187,9 @@ async function install() {
   // 4. Configure hooks (merge: preserve user's existing hooks, replace ours)
   log('Configuring hooks...');
   const settings = readSettings();
+  if (clearPluginDisabledMarkerForDirectInstall(settings)) {
+    ok('Cleared stale disabled plugin flag so install.mjs-managed hooks can run');
+  }
   settings.hooks = settings.hooks || {};
 
   const PREFILTER_PATH = join(INSTALL_DIR, 'scripts', 'post-tool-use.sh');
@@ -2543,74 +2546,72 @@ async function uninstall() {
 
   // 2. Remove hooks from settings.json (match both npx and git-clone install paths)
   const settings = readSettings();
-  if (settings.hooks) {
-    for (const [event, configs] of Object.entries(settings.hooks)) {
-      if (!Array.isArray(configs)) continue;
-      settings.hooks[event] = configs.filter(cfg => !isMemHook(cfg));
-      if (settings.hooks[event].length === 0) delete settings.hooks[event];
+  cleanupMemHooksFromSettings(settings);
+
+  // 3. Clean plugin registry entries conservatively (avoid deleting other plugins
+  // from the same marketplace publisher)
+  const pluginsDir = join(homedir(), '.claude', 'plugins');
+  const installedPath = join(pluginsDir, 'installed_plugins.json');
+  let canRemoveMarketplaceArtifacts;
+  try {
+    const installed = JSON.parse(readFileSync(installedPath, 'utf8'));
+    const plugins = getInstalledPluginEntries(installed);
+    let cleaned = false;
+    if (PLUGIN_KEY in plugins) {
+      delete plugins[PLUGIN_KEY];
+      cleaned = true;
     }
-    if (Object.keys(settings.hooks).length === 0) delete settings.hooks;
+    canRemoveMarketplaceArtifacts = !hasOtherMarketplacePlugins(installed);
+    if (cleaned) {
+      writeFileSync(installedPath, JSON.stringify(installed, null, 2) + '\n');
+      ok('Removed from installed_plugins.json');
+    }
+  } catch {
+    // Conservative default: if registry shape is unknown, preserve marketplace cache.
+    canRemoveMarketplaceArtifacts = false;
   }
 
-  // 3. Clean plugin system entries from settings.json
-  const pluginKey = `claude-mem-lite@${MARKETPLACE_KEY}`;
+  // 4. Clean plugin system entries from settings.json
   const marketplaceKey = MARKETPLACE_KEY;
   if (settings.enabledPlugins) {
-    delete settings.enabledPlugins[pluginKey];
+    delete settings.enabledPlugins[PLUGIN_KEY];
   }
-  if (settings.extraKnownMarketplaces) {
+  if (settings.extraKnownMarketplaces && canRemoveMarketplaceArtifacts) {
     delete settings.extraKnownMarketplaces[marketplaceKey];
   }
   writeSettings(settings);
   ok('Hooks and plugin settings cleaned');
 
-  // 4. Clean plugin system registry files
-  const pluginsDir = join(homedir(), '.claude', 'plugins');
-
-  // 4a. Remove marketplace directory
+  // 5. Clean plugin system registry files (only if no other marketplace plugins remain)
   const marketplaceDir = join(pluginsDir, 'marketplaces', marketplaceKey);
-  if (existsSync(marketplaceDir)) {
+  if (canRemoveMarketplaceArtifacts && existsSync(marketplaceDir)) {
     rmSync(marketplaceDir, { recursive: true, force: true });
     ok('Marketplace directory removed');
   }
 
-  // 4b. Remove cache directory
+  // 5b. Remove cache directory
   const cacheDir = join(pluginsDir, 'cache', marketplaceKey);
-  if (existsSync(cacheDir)) {
+  if (canRemoveMarketplaceArtifacts && existsSync(cacheDir)) {
     rmSync(cacheDir, { recursive: true, force: true });
     ok('Plugin cache removed');
   }
 
-  // 4c. Clean known_marketplaces.json
+  // 5c. Clean known_marketplaces.json
   const knownPath = join(pluginsDir, 'known_marketplaces.json');
   try {
     const known = JSON.parse(readFileSync(knownPath, 'utf8'));
-    if (marketplaceKey in known) {
+    if (canRemoveMarketplaceArtifacts && marketplaceKey in known) {
       delete known[marketplaceKey];
       writeFileSync(knownPath, JSON.stringify(known, null, 2) + '\n');
       ok('Removed from known_marketplaces.json');
     }
   } catch { /* file may not exist */ }
 
-  // 4d. Clean installed_plugins.json
-  const installedPath = join(pluginsDir, 'installed_plugins.json');
-  try {
-    const installed = JSON.parse(readFileSync(installedPath, 'utf8'));
-    const plugins = installed.plugins || installed;
-    let cleaned = false;
-    for (const key of Object.keys(plugins)) {
-      if (key.includes('claude-mem-lite') || key.includes('sdsrss')) {
-        delete plugins[key];
-        cleaned = true;
-      }
-    }
-    if (cleaned) {
-      writeFileSync(installedPath, JSON.stringify(installed, null, 2) + '\n');
-      ok('Removed from installed_plugins.json');
-    }
-  } catch { /* file may not exist */ }
+  if (!canRemoveMarketplaceArtifacts && (existsSync(marketplaceDir) || existsSync(cacheDir))) {
+    log('Marketplace cache preserved (other plugins may still depend on sdsrss marketplace)');
+  }
 
-  // 5. Purge data if requested
+  // 6. Purge data if requested
   if (flags.has('--purge')) {
     const expectedPurgePath = join(homedir(), '.claude-mem-lite');
     if (existsSync(DATA_DIR) && DATA_DIR === expectedPurgePath) {
@@ -2626,6 +2627,24 @@ async function uninstall() {
   console.log('\n  Done!\n');
 }
 
+// ─── Cleanup Hooks ───────────────────────────────────────────────────────────
+
+async function cleanupHooks() {
+  console.log('\nclaude-mem-lite cleanup-hooks\n');
+
+  const settings = readSettings();
+  const removed = cleanupMemHooksFromSettings(settings);
+
+  if (removed > 0) {
+    writeSettings(settings);
+    ok(`Removed ${removed} claude-mem-lite hook configuration${removed === 1 ? '' : 's'} from settings.json`);
+  } else {
+    ok('No claude-mem-lite hooks found in settings.json');
+  }
+
+  console.log('');
+}
+
 // ─── Status ─────────────────────────────────────────────────────────────────
 
 async function status() {
@@ -2645,11 +2664,24 @@ async function status() {
 
   // Hooks
   const settings = readSettings();
-  const hasHooks = settings.hooks && Object.values(settings.hooks).some(configs =>
-    configs.some(cfg => cfg.hooks?.some(h => h.command?.includes('hook.mjs')))
-  );
-  if (hasHooks) {
+  const hasHooks = hasMemHooksConfigured(settings);
+  const pluginDisabled = isPluginExplicitlyDisabled(settings);
+  const pluginEnabled = settings.enabledPlugins?.[PLUGIN_KEY] === true;
+
+  if (pluginEnabled) {
+    ok('Plugin: enabled in settings');
+  } else if (pluginDisabled) {
+    warn('Plugin: disabled in settings');
+  } else {
+    warn('Plugin: not present in enabledPlugins');
+  }
+
+  if (hasHooks && pluginDisabled) {
+    warn('Hooks: still configured in settings.json while plugin is disabled (runtime ignores them; run cleanup-hooks or uninstall to clean up)');
+  } else if (hasHooks) {
     ok('Hooks: configured');
+  } else if (pluginDisabled) {
+    ok('Hooks: not configured');
   } else {
     fail('Hooks: not configured');
   }
@@ -2727,6 +2759,21 @@ async function doctor() {
     issues++;
   }
 
+  // Plugin/hook lifecycle state
+  const settings = readSettings();
+  const hasHooks = hasMemHooksConfigured(settings);
+  const pluginDisabled = isPluginExplicitlyDisabled(settings);
+  if (pluginDisabled && hasHooks) {
+    fail('Plugin lifecycle: plugin is disabled but claude-mem-lite hooks still remain in settings.json');
+    issues++;
+  } else if (pluginDisabled) {
+    ok('Plugin lifecycle: disabled cleanly (no active mem hooks)');
+  } else if (hasHooks) {
+    ok('Plugin lifecycle: hooks active');
+  } else {
+    warn('Plugin lifecycle: hooks not configured');
+  }
+
   // Database
   if (existsSync(DB_PATH)) {
     try {
@@ -2799,6 +2846,50 @@ function isMemHook(cfg) {
   });
 }
 
+function hasMemHooksConfigured(settings) {
+  if (!settings?.hooks) return false;
+  return Object.values(settings.hooks).some(configs =>
+    Array.isArray(configs) && configs.some(cfg => isMemHook(cfg))
+  );
+}
+
+export function clearPluginDisabledMarkerForDirectInstall(settings) {
+  if (settings?.enabledPlugins?.[PLUGIN_KEY] !== false) return false;
+  delete settings.enabledPlugins[PLUGIN_KEY];
+  if (Object.keys(settings.enabledPlugins).length === 0) delete settings.enabledPlugins;
+  return true;
+}
+
+function cleanupMemHooksFromSettings(settings) {
+  if (!settings?.hooks) return 0;
+
+  let removed = 0;
+  for (const [event, configs] of Object.entries(settings.hooks)) {
+    if (!Array.isArray(configs)) continue;
+    const kept = configs.filter(cfg => !isMemHook(cfg));
+    removed += configs.length - kept.length;
+    if (kept.length > 0) settings.hooks[event] = kept;
+    else delete settings.hooks[event];
+  }
+
+  if (Object.keys(settings.hooks).length === 0) delete settings.hooks;
+  return removed;
+}
+
+function isPluginExplicitlyDisabled(settings) {
+  return settings?.enabledPlugins?.[PLUGIN_KEY] === false;
+}
+
+function getInstalledPluginEntries(installed) {
+  if (installed?.plugins && typeof installed.plugins === 'object') return installed.plugins;
+  return installed && typeof installed === 'object' ? installed : {};
+}
+
+export function hasOtherMarketplacePlugins(installed, marketplaceKey = MARKETPLACE_KEY, pluginKey = PLUGIN_KEY) {
+  const plugins = getInstalledPluginEntries(installed);
+  return Object.keys(plugins).some(key => key !== pluginKey && key.endsWith(`@${marketplaceKey}`));
+}
+
 function readSettings() {
   try {
     return JSON.parse(readFileSync(SETTINGS_PATH, 'utf8'));
@@ -2823,10 +2914,12 @@ async function manualUpdate() {
   // Force check by importing hook-update (bypasses throttle for manual use)
   const { checkForUpdate, getCurrentVersion } = await import('./hook-update.mjs');
   log('Checking for updates...');
-  const result = await checkForUpdate();
+  const result = await checkForUpdate({ force: true, allowInstall: true });
 
   if (result?.updated) {
     ok(`Updated: v${result.from} → v${result.to}`);
+  } else if (result?.updateAvailable && result?.installDeferred) {
+    warn(`v${result.to} available — plugin mode only checks for updates, reinstall/update the plugin to apply it`);
   } else if (result?.updateAvailable) {
     warn(`v${result.to} available but install failed — try: node install.mjs install`);
   } else {
@@ -2881,31 +2974,38 @@ function syncVersions() {
 
 // ─── Main ───────────────────────────────────────────────────────────────────
 
-switch (cmd) {
-  case 'install':
-    await install();
-    break;
-  case 'uninstall':
-    await uninstall();
-    break;
-  case 'status':
-    await status();
-    break;
-  case 'doctor':
-    await doctor();
-    break;
-  case 'update':
-    await manualUpdate();
-    break;
-  case 'release':
-    syncVersions();
-    break;
-  default:
-    if (IS_NPX) {
-      // npx claude-mem-lite (no args) → auto install
+export async function main(argv = process.argv.slice(2)) {
+  cmd = argv[0];
+  flags = new Set(argv.slice(1));
+
+  switch (cmd) {
+    case 'install':
       await install();
-    } else {
-      console.log(`
+      break;
+    case 'uninstall':
+      await uninstall();
+      break;
+    case 'status':
+      await status();
+      break;
+    case 'doctor':
+      await doctor();
+      break;
+    case 'cleanup-hooks':
+      await cleanupHooks();
+      break;
+    case 'update':
+      await manualUpdate();
+      break;
+    case 'release':
+      syncVersions();
+      break;
+    default:
+      if (IS_NPX) {
+        // npx claude-mem-lite (no args) → auto install
+        await install();
+      } else {
+        console.log(`
 claude-mem-lite — Lightweight memory system for Claude Code
 
 Usage:
@@ -2915,10 +3015,15 @@ Usage:
   node install.mjs uninstall --purge  Remove and delete all data
   node install.mjs status             Show current status
   node install.mjs doctor             Diagnose issues
+  node install.mjs cleanup-hooks      Remove only claude-mem-lite hooks from settings.json
   node install.mjs update             Check for and install updates
   node install.mjs release            Sync version to plugin.json + marketplace.json
 
   npx claude-mem-lite                 Install via npx (one-liner)
 `);
-    }
+      }
+  }
 }
+
+const IS_MAIN = process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (IS_MAIN) await main();

package/package.json

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