claude-mem-lite 2.9.7 → 2.10.0

package/.claude-plugin/marketplace.json

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

package/dispatch.mjs

@@ -899,28 +899,45 @@ function passesConfidenceGate(results, signals) {
 
 // ─── Auto-loaded Skill Filter ────────────────────────────────────────────────
 
+// Plugin-namespaced skills with high adoption rates deserve proactive recommendations
+// even though they're listed in system-reminder. The listing alone doesn't guarantee
+// Claude invokes them at the right moment — a contextual nudge at the right time
+// is more effective than a static list.
+const AUTOLOADED_MIN_ADOPTIONS = 3;    // Must have been adopted at least N times total
+const AUTOLOADED_MIN_ADOPT_RATE = 0.08; // Minimum adoption rate to keep recommending
+
 /**
- * Filter out skills that are auto-loaded via plugin hooks (listed in system-reminder).
- * These skills don't need dispatch recommendations because the plugin's own hooks
- * already surface them to Claude at the right moment.
+ * Filter auto-loaded skills with adoption-aware logic.
+ *
+ * Plugin-namespaced skills (e.g. "superpowers:systematic-debugging") are listed
+ * in system-reminder, so Claude already knows about them. However, blanket filtering
+ * removes high-value skills that users actually adopt when recommended contextually.
+ *
+ * Strategy: filter auto-loaded skills that have poor adoption history (recommend fatigue),
+ * but keep those that users actually adopt — the contextual timing adds real value.
  *
- * User-installed standalone skills (non-namespaced invocation_name like "build-error-resolver")
- * are KEPT — users may not remember to invoke them at the right time, so contextual
- * recommendations still add value (installed skills have 11.5% adoption vs 6.1% community).
+ * User-installed standalone skills (non-namespaced like "build-error-resolver")
+ * are always KEPT — contextual recommendations still add value.
  *
  * @param {object[]} results FTS5 results
- * @returns {object[]} Filtered results — community + standalone installed skills
+ * @returns {object[]} Filtered results
  */
 function filterAutoLoadedSkills(results) {
   return results.filter(r => {
     if (r.type !== 'skill') return true;
     const inv = (r.invocation_name || '').trim();
     if (inv === '') return true; // Community resource — always recommend
-    // Plugin-namespaced skills (e.g. "superpowers:systematic-debugging") are auto-loaded
-    // via the plugin's own hooks in system-reminder — dispatch recommendation is redundant
-    if (inv.includes(':')) return false;
-    // Standalone installed skills (e.g. "build-error-resolver") — keep for contextual recommendations
-    return true;
+    // Standalone installed skills (e.g. "build-error-resolver") — keep
+    if (!inv.includes(':')) return true;
+    // Plugin-namespaced: adoption-aware filter
+    // Cold start: keep if never recommended (no data to judge yet)
+    const recs = r.recommend_count || 0;
+    if (recs < 5) return true;
+    // Keep if adoption rate is healthy
+    const adopts = r.adopt_count || 0;
+    if (adopts >= AUTOLOADED_MIN_ADOPTIONS && (adopts + 1) / (recs + 2) >= AUTOLOADED_MIN_ADOPT_RATE) return true;
+    // Poor adoption history — suppress proactive recommendation
+    return false;
   });
 }
 

package/hook-update.mjs

@@ -5,7 +5,7 @@
 import { execSync, execFileSync } from 'node:child_process';
 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 { tmpdir, homedir } from 'node:os';
 import { DB_DIR } from './schema.mjs';
 import { debugCatch, debugLog } from './utils.mjs';
 
@@ -270,6 +270,20 @@ 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
+    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"');
+        }
+      }
+    } catch (e) { debugCatch(e, 'post-update-mcp-dedup'); }
+
     debugLog('DEBUG', 'hook-update', `Auto-update: switched ${installed.length} paths`);
     return true;
   } catch (err) {

package/install.mjs

@@ -236,37 +236,57 @@ async function install() {
     }
   }
 
-  // 3. Register MCP server
-  log('Registering MCP server...');
+  // 3. Register MCP server (skip if plugin system already handles it)
+  // Plugin system registers MCP from .claude-plugin/.mcp.json → mcp__plugin_claude-mem-lite_mem__*
+  // Global registration via `claude mcp add` creates a DUPLICATE mcp__mem__* server.
+  // Detect plugin mode: installed_plugins.json has our entry → plugin handles MCP.
+  const installedPluginsPath = join(homedir(), '.claude', 'plugins', 'installed_plugins.json');
+  let pluginHandlesMcp = false;
   try {
-    // Remove existing first (ignore errors)
-    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' });
-    // Remove project-level registration that shadows global (from .mcp.json)
-    try { execFileSync('claude', ['mcp', 'remove', '-s', 'project', 'mem'], { stdio: 'pipe' }); } catch {}
-    ok('MCP server registered: mem');
-  } catch (e) {
-    fail('MCP registration failed: ' + e.message);
-    warn('Try manually: claude mcp add -s user -t stdio mem -- node ' + SERVER_PATH);
+    const installed = JSON.parse(readFileSync(installedPluginsPath, 'utf8'));
+    pluginHandlesMcp = !!installed?.plugins?.[PLUGIN_KEY]?.length;
+  } catch { /* not installed via plugin system */ }
+
+  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 {}
+  } 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');
+    } catch (e) {
+      fail('MCP registration failed: ' + e.message);
+      warn('Try manually: claude mcp add -s user -t stdio mem -- node ' + SERVER_PATH);
+    }
   }
 
   // 3b. Deduplicate: if marketplace plugin also registers MCP + hooks,
   // clear them to prevent double execution. install.mjs hooks (in settings.json)
   // point to ~/.claude-mem-lite/ (latest code in dev mode via symlinks),
   // while plugin hooks use ${CLAUDE_PLUGIN_ROOT} (potentially stale marketplace copy).
+  //
+  // MCP dedup: Claude Code loads .mcp.json from BOTH marketplace root (generic scan)
+  // and cache dir (plugin system). Root-level .mcp.json → duplicate mcp__mem__*.
+  // Fix: .mcp.json moved to .claude-plugin/ (plugin installer reads from there,
+  // generic scanner only scans root). Clear any stale root copy here.
   const pluginDir = join(homedir(), '.claude', 'plugins', 'marketplaces', MARKETPLACE_KEY);
-  const pluginMcpPath = join(pluginDir, '.mcp.json');
   const pluginHooksPath = join(pluginDir, 'hooks', 'hooks.json');
 
   if (existsSync(pluginDir)) {
-    // Clear plugin MCP to prevent duplicate "mem" server
+    // Clear root-level .mcp.json if it exists (stale from older git versions).
+    // .mcp.json is now in .claude-plugin/ to avoid generic scanner duplicate.
+    const rootMcpPath = join(pluginDir, '.mcp.json');
     try {
-      if (existsSync(pluginMcpPath)) {
-        const pluginMcp = JSON.parse(readFileSync(pluginMcpPath, 'utf8'));
+      if (existsSync(rootMcpPath)) {
+        const pluginMcp = JSON.parse(readFileSync(rootMcpPath, 'utf8'));
         if (pluginMcp.mcpServers?.mem) {
           delete pluginMcp.mcpServers.mem;
-          writeFileSync(pluginMcpPath, JSON.stringify(pluginMcp, null, 2) + '\n');
-          ok('Marketplace plugin: MCP cleared (prevents duplicate)');
+          writeFileSync(rootMcpPath, JSON.stringify(pluginMcp, null, 2) + '\n');
+          ok('Marketplace plugin: root .mcp.json cleared (moved to .claude-plugin/)');
         }
       }
     } catch (e) { warn(`Marketplace MCP dedup: ${e.message}`); }

package/package.json

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

package/scripts/setup.sh

@@ -85,5 +85,49 @@ if [[ ! -d "$ROOT/node_modules/better-sqlite3" ]]; then
   fi
 fi
 
+# 7. One-time MCP migration: clean stale registrations from pre-2.10 versions.
+#    Only runs once per version — skips if marker file exists.
+#    Before 2.10: .mcp.json at repo root caused duplicate MCP servers.
+#    - Global mcpServers.mem in ~/.claude.json (from old install.mjs)
+#    - Marketplace root .mcp.json (from old git clone)
+#    Now: .mcp.json in .claude-plugin/ → plugin system handles MCP exclusively.
+MCP_MIGRATION="$DATA_DIR/runtime/.mcp-dedup-v2.10"
+if [[ ! -f "$MCP_MIGRATION" && -n "${CLAUDE_PLUGIN_ROOT:-}" ]]; then
+  CLAUDE_JSON="$HOME/.claude.json" ROOT="$ROOT" node -e '
+    const fs = require("fs");
+    let changed = false;
+    // 1. Remove stale global MCP registration
+    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;
+      }
+    } catch {}
+    // 2. Remove stale marketplace root .mcp.json
+    try {
+      const root = process.env.ROOT;
+      if (root.includes("/plugins/cache/")) {
+        const key = root.split("/plugins/cache/")[1].split("/")[0];
+        const mktMcp = require("path").join(require("os").homedir(), ".claude/plugins/marketplaces", key, ".mcp.json");
+        if (fs.existsSync(mktMcp)) {
+          const m = JSON.parse(fs.readFileSync(mktMcp, "utf8"));
+          if (m.mcpServers?.mem) {
+            delete m.mcpServers.mem;
+            fs.writeFileSync(mktMcp, JSON.stringify(m, null, 2) + "\n");
+            process.stderr.write("✓ Cleared marketplace root .mcp.json (moved to .claude-plugin/)\n");
+            changed = true;
+          }
+        }
+      }
+    } catch {}
+    if (!changed) process.stderr.write("✓ MCP migration: already clean\n");
+  ' 2>&2 || true
+  touch "$MCP_MIGRATION"
+fi
+
 log_ok "claude-mem-lite ready"
 exit 0

package/server.mjs

@@ -9,6 +9,7 @@ import { ensureDb, DB_PATH, REGISTRY_DB_PATH } from './schema.mjs';
 import { reRankWithContext, markSuperseded, extractPRFTerms, expandQueryByConcepts, autoBoostIfNeeded, runIdleCleanup } from './server-internals.mjs';
 import { memSearchSchema, memTimelineSchema, memGetSchema, memDeleteSchema, memSaveSchema, memStatsSchema, memCompressSchema, memMaintainSchema, memRegistrySchema } from './tool-schemas.mjs';
 import { ensureRegistryDb, upsertResource } from './registry.mjs';
+import { searchResources } from './registry-retriever.mjs';
 import { createRequire } from 'module';
 
 const require = createRequire(import.meta.url);
@@ -123,6 +124,13 @@ const server = new McpServer(
       'SEARCH WORKFLOW: mem_search → mem_timeline(anchor=ID) for surrounding context → mem_get(ids=[...]) for full details.',
       'Search tips: use short keywords (2-3 words), not full sentences. Filter with obs_type when relevant.',
       '',
+      'SKILL/AGENT DISCOVERY (mem_registry):',
+      '- When your installed skills/agents don\'t cover the current workflow → mem_registry(action="search", query="<what you need>")',
+      '- When the user asks for a capability you lack → search the registry first',
+      '- When starting complex multi-step work → check if specialized agents exist: mem_registry(action="search", query="<task domain>", type="agent")',
+      '- Filter by type: type="skill" for workflow skills, type="agent" for specialized agents',
+      '- Say: "Searching mem for [purpose]..." when using this feature',
+      '',
       'MAINTENANCE: mem_compress consolidates old observations. mem_maintain runs dedup/cleanup/reindex.',
     ].join('\n'),
   },
@@ -1201,7 +1209,7 @@ server.registerTool(
 server.registerTool(
   'mem_registry',
   {
-    description: 'Manage tool resource registry: list resources, view stats, import/remove tools, reindex FTS5.',
+    description: 'Manage tool resource registry: search for skills/agents by need, list resources, view stats, import/remove tools, reindex FTS5.',
     inputSchema: memRegistrySchema,
   },
   safeHandler(async (args) => {
@@ -1212,6 +1220,26 @@ server.registerTool(
 
     const action = args.action;
 
+    if (action === 'search') {
+      if (!args.query) {
+        return { content: [{ type: 'text', text: 'search requires a query parameter' }], isError: true };
+      }
+      const results = searchResources(rdb, args.query, {
+        type: args.type || undefined,
+        limit: 5,
+      });
+      if (results.length === 0) {
+        return { content: [{ type: 'text', text: `No matching resources for: "${args.query}"` }] };
+      }
+      const lines = results.map(r => {
+        const howToUse = r.type === 'skill'
+          ? (r.invocation_name ? `Skill tool: skill="${r.invocation_name}"` : `Community skill: ${r.name}`)
+          : `Agent tool: subagent_type="${r.name}"`;
+        return `${r.type === 'skill' ? 'S' : 'A'} **${r.name}** — ${truncate(r.capability_summary || '', 80)}\n  Use: ${howToUse}`;
+      });
+      return { content: [{ type: 'text', text: `Found ${results.length} resource(s) for "${args.query}":\n\n${lines.join('\n\n')}` }] };
+    }
+
     if (action === 'list') {
       const typeFilter = args.type;
       const where = typeFilter ? 'WHERE type = ? AND status = ?' : 'WHERE status = ?';
@@ -1287,7 +1315,7 @@ server.registerTool(
       return { content: [{ type: 'text', text: `FTS5 reindexed. ${count.c} active resources.` }] };
     }
 
-    return { content: [{ type: 'text', text: `Unknown action: ${action}. Valid: list, stats, import, remove, reindex` }], isError: true };
+    return { content: [{ type: 'text', text: `Unknown action: ${action}. Valid: search, list, stats, import, remove, reindex` }], isError: true };
   })
 );
 

package/tool-schemas.mjs

@@ -92,8 +92,9 @@ export const memMaintainSchema = {
 };
 
 export const memRegistrySchema = {
-  action: z.enum(['list', 'stats', 'import', 'remove', 'reindex']).describe('Registry operation'),
-  type: z.enum(['skill', 'agent']).optional().describe('Filter by resource type (for list)'),
+  action: z.enum(['list', 'stats', 'search', 'import', 'remove', 'reindex']).describe('Registry operation'),
+  query: z.string().optional().describe('Search query — keywords describing what you need (for search)'),
+  type: z.enum(['skill', 'agent']).optional().describe('Filter by resource type (for list/search)'),
   name: z.string().optional().describe('Resource name (for import/remove)'),
   resource_type: z.enum(['skill', 'agent']).optional().describe('Resource type (for import/remove)'),
   source: z.enum(['preinstalled', 'user']).optional().describe('Source (for import, default: user)'),