claude-mem-lite 4.0.3 → 5.0.0

package/lib/doctor-drift.mjs

@@ -103,7 +103,6 @@ export const HOOK_SCRIPT_ENTRY_POINTS = new Set([
   'user-prompt-search.js',
   'pre-tool-recall.js',
   'post-tool-recall.js',
-  'pre-skill-bridge.js',
   'pre-agent-inject.sh',
   'hook-launcher.mjs',
 ]);

package/lib/fast-summary.mjs

@@ -41,6 +41,17 @@ export const FAST_SUMMARY_LIMITS = {
 /**
  * The two reads every fast summary is built from: the session's opening prompt, and the
  * titles of its most recent observations.
+ *
+ * The observation filter is `compressed_into` ONLY, deliberately — it is NOT a half-written
+ * `liveObsFilterSql` waiting to be completed. `completed` is the session's own history, and a
+ * lesson a later save overturned still happened; dropping it here would misreport the session
+ * that did the work. This is the same ruling audit 2026-08-14 F4 made for the sibling field
+ * `session_handoffs.completed`, where the scope guard lives in
+ * `tests/audit-silent-20260814.test.mjs`. Audit R8 §11.3 proposed adding `superseded_at IS
+ * NULL` to both; both were rejected on this reasoning. The filter that DOES belong on a
+ * superseded row is the one guarding standing policy re-presented to a later session
+ * (`key_decisions`), not history.
+ *
  * @returns {{request: string, completed: string}} raw (unscrubbed, untruncated) values
  */
 export function readFastSummarySource(db, sessionId) {

package/lib/frontmatter.mjs

@@ -2,7 +2,6 @@
 //
 // Audit 2026-09-02 P1-16. There were three, and they were not all the same:
 //
-//   registry-importer.mjs      the shipped one, full
 //   scripts/index-managed.mjs  byte-identical to it apart from the `export` keyword —
 //                              30 lines, the largest duplicate block in the tree
 //   scripts/convert-commands.mjs  a SIMPLIFIED cut with no `|` / `>` block support and no
@@ -13,7 +12,7 @@
 // scripts reading the same files with different parsers produce different registry rows
 // depending on which one last ran.
 //
-// Zero dependencies on purpose — it is imported by a shipped module (registry-importer)
+// Zero dependencies on purpose — it is imported by a shipped module
 // and by two dev scripts, so it must not drag anything into either.
 
 /**

package/lib/hook-prune.mjs

@@ -0,0 +1,133 @@
+// lib/hook-prune.mjs — settings.json hook-entry classification and reconciliation.
+//
+// Extracted here because TWO faces need it and a direct import would close a cycle:
+// `install.mjs` owns hook registration, and `hook-update.mjs` (which install.mjs
+// already imports) has to reconcile after a swap. Per CLAUDE.md's rule — logic two
+// faces share moves to `lib/`, the big file keeps only wiring — rather than
+// documenting `install.mjs -> hook-update.mjs -> install.mjs` as an allowed cycle.
+//
+// Zero local imports on purpose: `hook-update.mjs` reaches this from the auto-update
+// path, which must stay cheap and must not drag install.mjs's dependency graph in.
+
+import { existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+
+/**
+ * Identify a settings hook as one of OURS (to replace on install / strip on uninstall).
+ *
+ * Must be tight: the old `hook.mjs` + event-word test matched a user's OWN generic hook
+ * (`node ~/.config/hook.mjs session-start`) and install/uninstall silently deleted it.
+ * The launcher marker (`hook-launcher.mjs`, which every Node hook routes through since
+ * v2.84) replaces that clause; the product-name substring (our install-dir / legacy-direct
+ * hooks) and the bash prefilters round out the real markers.
+ */
+export function isMemHook(cfg) {
+  // `cfg?.hooks`, not `cfg.hooks`: a null entry in a hand-edited settings.json threw a
+  // TypeError here, and hook-update.mjs swallows it — so ONE malformed entry silently
+  // cancelled the whole reconcile and the dangling hook survived. Degraded, never
+  // destructive, but the reconcile is the point. (Found by adversarial review; the same
+  // exposure predates this module in `configureHooks`, which now shares this function.)
+  if (!cfg?.hooks) return false;
+  return cfg.hooks.some((h) => {
+    const cmd = h.command || '';
+    return (
+      cmd.includes('claude-mem-lite') ||
+      cmd.includes('hook-launcher.mjs') ||
+      cmd.includes('scripts/post-tool-use.sh') ||
+      // Same reason post-tool-use.sh is named here: a bash prefilter routes through
+      // NO launcher, and the product-name clause only fires when the install dir
+      // happens to contain it — which CLAUDE_MEM_DIR can relocate. Without this line
+      // an Agent|Task hook in a relocated install survives uninstall and duplicates
+      // on reinstall (audit 2026-08-22 P2-5 added the second prefilter).
+      cmd.includes('scripts/pre-agent-inject.sh')
+    );
+  });
+}
+
+/**
+ * The launcher's ENTRY argument, resolved — or null when this command is not a
+ * launcher invocation we own.
+ *
+ * `nodeHook` writes `node "<INSTALL_DIR>/scripts/hook-launcher.mjs" scripts/<entry>.js`,
+ * and the launcher resolves that bare relative token against its own INSTALL_DIR
+ * (`hook-launcher.mjs:125`). Both halves matter for orphan detection: the quoted
+ * launcher path exists on a healthy install, so a scanner that stops at the first
+ * quoted token declares the entry healthy without ever looking at the file that
+ * actually runs. That is precisely how the `Skill` hook removal went unseen.
+ *
+ * Plugin-channel commands are excluded: `${CLAUDE_PLUGIN_ROOT}` is expanded by Claude
+ * Code, not by us, so nothing here can resolve them — and hooks/hooks.json owns them.
+ */
+export function launcherEntryPath(cmd, installDir) {
+  if (typeof cmd !== 'string' || cmd.includes('${CLAUDE_PLUGIN_ROOT}')) return null;
+  if (!cmd.includes('hook-launcher.mjs')) return null;
+  // Everything after the quoted launcher path; the entry is its first bare token.
+  const tail = cmd.split(/hook-launcher\.mjs"?\s*/)[1];
+  if (!tail) return null;
+  const entry = tail.split(/\s+/).find((t) => t && !t.startsWith('-'));
+  if (!entry) return null;
+  if (entry.startsWith('/')) return entry;
+  // Resolve against the base the LAUNCHER NAMED IN THIS COMMAND would use
+  // (`hook-launcher.mjs:36` — `join(dirname(launcherFile), '..')`), not against the
+  // caller's idea of the install dir. The two coincide in production today because both
+  // INSTALL_DIR constants are homedir-hardcoded — which is exactly why the coupling is
+  // worth removing rather than documenting: the day a caller passes a different
+  // targetDir, resolving against it deletes hooks that run fine. `installDir` stays the
+  // fallback for a command whose launcher path we could not parse.
+  const quoted = cmd.match(/"([^"]*hook-launcher\.mjs)"/);
+  const base = quoted ? dirname(dirname(quoted[1])) : installDir;
+  return join(base, entry);
+}
+
+/**
+ * Drop settings.json hook entries whose launcher target no longer exists.
+ *
+ * Auto-update only ever handled hook ADDITIONS. `configureHooks()` strips stale mem
+ * entries and rewrites every event, but its only caller is `install()`;
+ * `hook-update.mjs` swaps `scripts/` wholesale, so an upgrade that REMOVES a hook
+ * script leaves settings.json pointing at a file it just deleted. The launcher then
+ * treats each fire as a broken install: two stderr lines and the self-heal marker,
+ * for a file that is never coming back. First hit by the `PreToolUse:Skill`
+ * removal (R9 review P1-1); plugin-channel installs are unaffected because
+ * hooks/hooks.json is replaced wholesale.
+ *
+ * Narrow by construction — an entry is dropped only when it is ours (`isMemHook`),
+ * routes through our launcher, and its resolved target is absent. An entry that
+ * cannot be parsed, or whose target exists, is left exactly as found; a foreign
+ * tool's dead hook is not ours to remove.
+ *
+ * Pure: returns a new settings object plus the entry tokens removed, so the caller
+ * decides whether to write and can log what changed.
+ *
+ * @returns {{settings: object, removed: string[]}}
+ */
+export function pruneDanglingMemHooks(settings, installDir) {
+  if (!settings?.hooks) return { settings, removed: [] };
+  const removed = [];
+  const hooks = {};
+  for (const [event, configs] of Object.entries(settings.hooks)) {
+    if (!Array.isArray(configs)) {
+      hooks[event] = configs;
+      continue;
+    }
+    const kept = [];
+    for (const cfg of configs) {
+      if (!isMemHook(cfg)) {
+        kept.push(cfg);
+        continue;
+      }
+      const liveHooks = (cfg.hooks || []).filter((h) => {
+        const target = launcherEntryPath(h.command, installDir);
+        if (!target || existsSync(target)) return true;
+        // Record the token as written, not the resolved path — that is what a
+        // reader has to match against settings.json and the release manifest.
+        const tail = String(h.command).split(/hook-launcher\.mjs"?\s*/)[1] || '';
+        removed.push(tail.split(/\s+/).find((t) => t && !t.startsWith('-')) || target);
+        return false;
+      });
+      if (liveHooks.length > 0) kept.push({ ...cfg, hooks: liveHooks });
+    }
+    hooks[event] = kept;
+  }
+  return { settings: { ...settings, hooks }, removed };
+}

package/lib/hook-stdin.mjs

@@ -8,7 +8,7 @@
 //   (1.5 s / 262144 / never rejects).
 //
 //   UNBOUNDED, three copies of `for await (const chunk of process.stdin) input += chunk`:
-//   pre-tool-recall.js, pre-skill-bridge.js, post-tool-recall.js. No cap and no timeout.
+//   pre-tool-recall.js, post-tool-recall.js. No cap and no timeout.
 //   That matters most on `PreToolUse:Write`, whose `tool_input.content` is the ENTIRE file
 //   being written: writing a multi-megabyte file made pre-tool-recall buffer all of it and
 //   `JSON.parse` all of it, to read `file_path`. The only bound was the host's own 3 s

package/lib/hook-telemetry.mjs

@@ -113,7 +113,7 @@ export function recordHookError(scope, err, runtimeDir, ctx) {
     pruneOldShards(dir);
 
     // Every hook script funnels its failures through here — including the
-    // STANDALONE ones (scripts/pre-tool-recall.js, scripts/pre-skill-bridge.js)
+    // STANDALONE ones (scripts/pre-tool-recall.js, scripts/post-tool-recall.js)
     // that never import hook.mjs and so never reach its dispatch catch. That gap
     // is why the 2026-08-13 outage stayed invisible: 78 of that day's 79 entries
     // were `pre-recall:db-open`, i.e. the ONE path whose errors nothing but this

package/lib/metrics.mjs

@@ -83,8 +83,8 @@ export function timed(dbDir, event, fn, extra = {}) {
  * grows the dir unbounded. 90d keeps a full quarter for aggregate windows while
  * bounding the dir. Runs regardless of the enable flag so a user who toggles metrics
  * OFF still gets old shards cleaned. Best-effort, never throws — called from the
- * SessionStart GC sweep. The sweep itself is `lib/shard-gc.mjs`, shared with
- * registry-recommend's shadow log; this function is the metrics dir resolution.
+ * SessionStart GC sweep. The sweep itself is `lib/shard-gc.mjs`; this function is
+ * the metrics dir resolution.
  * @returns {number} shards removed
  */
 export function gcOldMetricShards(dbDir, retainDays = 90) {

package/lib/shard-gc.mjs

@@ -1,12 +1,16 @@
 // lib/shard-gc.mjs — retention sweep for daily JSONL shard directories.
 //
-// Two sinks in this tree append one `YYYY-MM-DD.jsonl` per day with no GC of their
-// own — `lib/metrics.mjs` (CLAUDE_MEM_METRICS) and `registry-recommend.mjs` (the
-// shadow log) — so a long-lived install grows both dirs unbounded. The sweep was
-// written twice, line for line, differing only in how the directory is resolved;
-// audit 2026-09-05 P2-3 found it as the largest non-intentional cross-file duplicate.
-// That is the twin-drift class CLAUDE.md names: the retention rule (90 days, the
-// `YYYY-MM-DD.jsonl` name filter) had two homes and could disagree with itself.
+// `lib/metrics.mjs` (CLAUDE_MEM_METRICS) appends one `YYYY-MM-DD.jsonl` per day with
+// no GC of its own, so a long-lived install grows that dir unbounded.
+//
+// This module exists because there used to be TWO such sinks — the second was
+// `registry-recommend.mjs`'s shadow log — and the sweep was written twice, line for
+// line, differing only in how the directory is resolved; audit 2026-09-05 P2-3 found
+// it as the largest non-intentional cross-file duplicate. That is the twin-drift class
+// CLAUDE.md names: the retention rule (90 days, the `YYYY-MM-DD.jsonl` name filter) had
+// two homes and could disagree with itself. The skill-registry subsystem was removed in
+// 2026-09 (docs/audits/20260906-145304.md), leaving one caller; the extraction stays
+// because the retention rule is worth owning in one place, not because of the caller count.
 //
 // Directory resolution stays with each caller — it is the only part that differed.