claude-mem-lite 3.70.0 → 3.70.1

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "3.70.0",
+      "version": "3.70.1",
       "source": "./",
       "description": "Persistent long-term memory for Claude Code via MCP — captures coding decisions, bugfixes, and context across sessions. Hybrid FTS5 + TF-IDF search with episode batching. Single SQLite DB, no external services. A lighter, lower-cost alternative to claude-mem (episode batching + a smaller model; cost savings are an internal estimate, not a measured benchmark)."
     }

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "3.70.0",
+  "version": "3.70.1",
   "description": "Persistent long-term memory for Claude Code via MCP — captures coding decisions, bugfixes, and context across sessions. Hybrid FTS5 + TF-IDF search with episode batching. Single SQLite DB, no external services. A lighter, lower-cost alternative to claude-mem (episode batching + a smaller model; cost savings are an internal estimate, not a measured benchmark).",
   "author": {
     "name": "sdsrss"

package/lib/install-shape.mjs

@@ -116,7 +116,7 @@ export function listPluginCacheVersions(opts = {}) {
  * twice would double every failure message for a single fault.
  *
  * @param {{home?: string, projectDir?: string, installDir?: string, marketplace?: string, plugin?: string, pluginRoot?: string}} opts
- * @returns {{managed: boolean, pluginVersions: Array<{version: string, root: string}>, activePluginVersion: {version: string, root: string}|null, runtimeRoots: Array<{label: string, root: string, depsMissing?: boolean}>}}
+ * @returns {{managed: boolean, pluginVersions: Array<{version: string, root: string}>, activePluginVersion: {version: string, root: string}|null, runtimeRoots: Array<{label: string, root: string, ownDeps: boolean}>}}
  */
 export function detectInstallShape({
   home = homedir(), projectDir, installDir, marketplace, plugin,
@@ -137,31 +137,43 @@ export function detectInstallShape({
     || null;
 
   const runtimeRoots = [];
-  const byBinding = new Map();
+  const byKey = new Map();
   const add = (label, root, { certified = false } = {}) => {
     if (!root) return;
     const bs3 = join(root, 'node_modules', 'better-sqlite3');
-    if (!existsSync(bs3)) {
-      // A dir that merely lacks deps is not a runtime root — but one this function
-      // just CERTIFIED as a code home is. Its hooks and MCP server load from it and
-      // throw ERR_MODULE_NOT_FOUND on every fire, and that error is not in
-      // NATIVE_BINDING_PATTERNS, so nothing else records it either. Dropping it
-      // turned a pre-v3.70 exit 1 into exit 0 (pre-tag review, SHOULD-FIX 1).
-      if (certified && existsSync(root)) runtimeRoots.push({ label, root, depsMissing: true });
-      return;
+    const ownDeps = existsSync(bs3);
+    // A dir that merely lacks deps is not a runtime root — but one this function
+    // just CERTIFIED as a code home is, because that is where hooks and the MCP
+    // server load from. Dropping it turned a pre-v3.70 exit 1 into exit 0.
+    //
+    // It is added as a probe TARGET, not pre-judged broken. v3.70.0 pre-judged it,
+    // which over-corrected into a false red: Node resolves a specifier up the
+    // directory tree, so a code home nested under an ancestor that owns a working
+    // better-sqlite3 loads perfectly well. Measured on that build — ground-truth
+    // probe {ok:true} against a verdict of "absent, every hook throws". Owning the
+    // tree is not the question; being able to LOAD is, and only a probe answers it.
+    if (!ownDeps && !(certified && existsSync(root))) return;
+
+    // Dedup on the binding's realpath when there is one (scripts/setup.sh symlinks a
+    // plugin cache's node_modules at the managed dir's, so two homes routinely share
+    // one tree and one probe answers for both). With no own tree there is no binding
+    // path to key on, so key on the root itself.
+    let key = root;
+    if (ownDeps) {
+      key = bs3;
+      try { key = realpathSync(bs3); } catch { /* unresolvable → key on the literal path */ }
+    } else {
+      try { key = realpathSync(root); } catch { /* ditto */ }
     }
-    let key = bs3;
-    try { key = realpathSync(bs3); } catch { /* unresolvable → dedupe on the literal path */ }
-    const existing = byBinding.get(key);
+    const existing = byKey.get(key);
     if (existing) {
-      // Same tree reached through a second home. One probe still answers for
-      // both, but the label has to say so — otherwise a plugin user reading
-      // "managed install is broken" has no way to know their plugin shares it.
+      // The label has to name both homes — otherwise a plugin user reading
+      // "managed install is broken" has no way to know their plugin shares that tree.
       existing.label += `, ${label}`;
       return;
     }
-    const entry = { label, root };
-    byBinding.set(key, entry);
+    const entry = { label, root, ownDeps };
+    byKey.set(key, entry);
     runtimeRoots.push(entry);
   };
 
@@ -192,27 +204,31 @@ function resolvesSame(a, b) {
  */
 export function probeRuntimeRoots(roots, deps = {}) {
   const probe = deps.probe || ((root) => probeBindingInFreshProcess(root));
-  return roots.map(({ label, root, depsMissing }) => {
-    // Nothing to dlopen: the tree is absent, not stale. Say so and prescribe an
-    // install — `npm rebuild` on a missing package exits 0 and heals nothing.
-    if (depsMissing) {
-      return {
+  return roots.map(({ label, root, ownDeps = true }) => {
+    // EVERY root is probed, including one with no tree of its own: the probe uses
+    // Node's real resolution chain, so it is the only thing that knows whether an
+    // ancestor node_modules is carrying this install. Pre-judging an unowned tree
+    // broken is what made v3.70.0 report "absent — every hook throws" about a root
+    // that loaded fine.
+    const r = probe(root);
+    if (r.ok) return { label, root, ok: true };
+    // The repair depends on WHICH failure it is. `npm rebuild` on a package that is
+    // not installed exits 0 and heals nothing, so an unowned tree that also cannot
+    // resolve from an ancestor needs an install; a present-but-unloadable tree needs
+    // the rebuild.
+    const error = String(r.error || 'unknown').split('\n')[0];
+    return ownDeps
+      ? { label, root, ok: false, error, repair: `cd ${root} && ${NATIVE_BINDING_REBUILD_CMD}` }
+      : {
         label,
         root,
         ok: false,
-        error: 'node_modules/better-sqlite3 is absent — every hook and the MCP server '
-          + 'that load this install throw ERR_MODULE_NOT_FOUND',
+        // Say only what is known. The probe may have reached an ANCESTOR
+        // node_modules and failed there — an earlier draft of this line asserted
+        // "none resolvable from a parent directory" and was caught printing that
+        // next to a probe error naming the parent tree it had just loaded from.
+        error: `${error} — and this install owns no node_modules/better-sqlite3, so there is nothing here to rebuild`,
         repair: `cd ${root} && npm install --omit=dev`,
       };
-    }
-    const r = probe(root);
-    if (r.ok) return { label, root, ok: true };
-    return {
-      label,
-      root,
-      ok: false,
-      error: String(r.error || 'unknown').split('\n')[0],
-      repair: `cd ${root} && ${NATIVE_BINDING_REBUILD_CMD}`,
-    };
   });
 }

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "claude-mem-lite",
-  "version": "3.70.0",
+  "version": "3.70.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "claude-mem-lite",
-      "version": "3.70.0",
+      "version": "3.70.1",
       "dependencies": {
         "@modelcontextprotocol/sdk": "^1.26.0",
         "better-sqlite3": "^12.6.2",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "3.70.0",
+  "version": "3.70.1",
   "description": "Persistent long-term memory for Claude Code via MCP — captures coding decisions, bugfixes, and context across sessions. Hybrid FTS5 + TF-IDF search with episode batching. Single SQLite DB, no external services. A lighter, lower-cost alternative to claude-mem (episode batching + a smaller model; cost savings are an internal estimate, not a measured benchmark).",
   "type": "module",
   "packageManager": "npm@10.9.2",