memtrace 0.3.51 → 0.3.53

package/lib/claude-integration.js

@@ -213,9 +213,32 @@ function applySettingsHooks(settings, hooksDir) {
 }
 
 /**
- * Merge our hook into an existing hooks array. If a memtrace-managed
- * entry already exists in any of the matchers, we update it in place
- * (keep the surrounding matcher block) instead of duplicating.
+ * Merge our hook into an existing hooks array — strictly idempotent.
+ *
+ * Earlier versions only deduped by the `_managed_by` / `_hook_kind`
+ * marker fields and only inspected the first block that matched. Two
+ * gaps fell out of that:
+ *
+ *   1. Some Claude Code workflows (and external settings.json linters)
+ *      round-trip the file and strip underscore-prefixed keys they
+ *      don't recognise. With the markers gone, our dedup matched
+ *      nothing and every `memtrace install` appended a fresh block —
+ *      we've seen real users end up with 9× duplicates and a
+ *      noticeable per-prompt slowdown.
+ *
+ *   2. Even when markers survived, the function only ever reached
+ *      into the *first* matching block. Pre-existing duplicates in
+ *      other blocks were never cleaned up, just left to compound.
+ *
+ * The new contract: regardless of how settings.json got into its
+ * current shape, this function leaves it with exactly one of our
+ * hooks installed under exactly one block. Running it 100 times
+ * produces the same result as running it once — and self-heals
+ * existing duplication on the way through.
+ *
+ * Match strategy: a hook is "ours" if it has the managed markers
+ * intact OR its command path matches one we generate. The
+ * command-path match is what catches stripped-marker pollution.
  *
  * @param {Array} existing
  * @param {object} ourEntry  shape `{ matcher?, hooks: [...] }`
@@ -223,33 +246,40 @@ function applySettingsHooks(settings, hooksDir) {
  * @returns {Array}
  */
 function mergeHookList(existing, ourEntry, ourHook) {
-    const out = existing.map((block) => ({ ...block }));
-    let foundManagedBlock = -1;
-    for (let i = 0; i < out.length; i++) {
-        const block = out[i];
-        if (!block.hooks) continue;
-        const hasOurs = block.hooks.some(
-            (h) => h && h._managed_by === HOOK_MANAGED_TAG && h._hook_kind === ourHook._hook_kind,
+    const isOurs = (h) =>
+        !!h && (
+            (h._managed_by === HOOK_MANAGED_TAG && h._hook_kind === ourHook._hook_kind) ||
+            (typeof h.command === "string" && h.command === ourHook.command)
         );
-        if (hasOurs) {
-            foundManagedBlock = i;
-            break;
+
+    // Phase 1: walk every block, strip every "ours" hook, drop blocks
+    // left empty by the strip. This sweep is what self-heals an
+    // already-polluted settings.json instead of leaving prior copies
+    // alongside the fresh one.
+    const cleaned = [];
+    for (const block of existing) {
+        if (!block || !Array.isArray(block.hooks)) {
+            cleaned.push(block);
+            continue;
         }
+        const remainingHooks = block.hooks.filter((h) => !isOurs(h));
+        if (remainingHooks.length === 0) {
+            // Block existed only to host our hook — drop it entirely so
+            // we don't leave behind an empty `{ matcher: '…', hooks: [] }`
+            // skeleton for Claude Code to ignore on every read.
+            continue;
+        }
+        cleaned.push({ ...block, hooks: remainingHooks });
     }
-    if (foundManagedBlock === -1) {
-        // Add our block as a new entry.
-        out.push(ourEntry);
-        return out;
-    }
-    // Replace just our hook entries inside the existing block, keep
-    // any user-added hooks in the same matcher untouched.
-    const block = { ...out[foundManagedBlock] };
-    block.hooks = block.hooks.filter(
-        (h) => !(h && h._managed_by === HOOK_MANAGED_TAG && h._hook_kind === ourHook._hook_kind),
-    );
-    block.hooks.push(ourHook);
-    out[foundManagedBlock] = block;
-    return out;
+
+    // Phase 2: re-insert exactly once as a fresh block. We deliberately
+    // do NOT merge into an existing block (even one with the same matcher)
+    // because Claude Code semantics treat each block independently anyway,
+    // and keeping our hook in its own block makes the install / uninstall
+    // boundary explicit. Phase 1 has already removed every prior copy of
+    // ours, so this single append yields exactly one of us in the output.
+    cleaned.push(ourEntry);
+    return cleaned;
 }
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memtrace",
-  "version": "0.3.51",
+  "version": "0.3.53",
   "description": "Code intelligence graph — MCP server + AI agent skills + visualization UI",
   "keywords": [
     "mcp",
@@ -39,9 +39,9 @@
     "fs-extra": "^11.0.0"
   },
   "optionalDependencies": {
-    "@memtrace/darwin-arm64": "0.3.51",
-    "@memtrace/linux-x64": "0.3.51",
-    "@memtrace/win32-x64": "0.3.51"
+    "@memtrace/darwin-arm64": "0.3.53",
+    "@memtrace/linux-x64": "0.3.53",
+    "@memtrace/win32-x64": "0.3.53"
   },
   "engines": {
     "node": ">=18"