claude-mem-lite 3.70.1 → 3.71.0

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "3.70.1",
+      "version": "3.71.0",
       "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.1",
+  "version": "3.71.0",
   "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/hook.mjs

@@ -48,7 +48,7 @@ import { handleLLMEpisode, handleLLMSummary, saveObservation, buildImmediateObse
 import { scrubRecord } from './lib/scrub-record.mjs';
 import { formatHookError } from './lib/native-binding-hint.mjs';
 import { recordHookError } from './lib/hook-telemetry.mjs';
-import { queueHookContext, flushHookStdout } from './lib/hook-stdout.mjs';
+import { queueHookContext, queueHookSystemMessage, flushHookStdout } from './lib/hook-stdout.mjs';
 import { selectCompressionCandidates, groupByProjectWeek, compressGroup } from './lib/compress-core.mjs';
 import { cleanupBroken, decayAndMarkIdle, boostAccessed, selectFuzzyDedupeIds, hardDeleteCandidateCount, purgeStale, recoverOrphanedChildren, recoverBuriedLessons, sweepDeferredWorkOrphans } from './lib/maintain-core.mjs';
 import { snapshotDb } from './lib/db-backup.mjs';
@@ -1549,7 +1549,12 @@ async function handleSessionStart() {
     let updateCheckDue = false;
     try {
       const banner = getCachedUpdateBanner();
-      if (banner) stdoutParts.push(String(banner).trim());
+      // The human channel, not additionalContext: "vX available" is a notice for the
+      // USER. Folding it into additionalContext under suppressOutput:true kept its
+      // content and lost its audience. Claude Code renders a command hook's top-level
+      // systemMessage as its own hook_system_message, independent of the context
+      // block — see lib/hook-stdout.mjs for the bundle evidence.
+      if (banner) queueHookSystemMessage(String(banner));
       updateCheckDue = isUpdateCheckDue();
     } catch (e) { debugCatch(e, 'session-start-update'); }
 

package/lib/binding-probe.mjs

@@ -51,6 +51,29 @@ export function isNativeBindingError(err) {
   return NATIVE_BINDING_PATTERNS.some((re) => re.test(msg));
 }
 
+/**
+ * Render a binding error as ONE line without losing the diagnosis.
+ *
+ * Every surface used to do `String(err).split('\n')[0]`, which is exactly wrong for
+ * the ABI-mismatch family this subsystem exists to detect. Node's message puts the
+ * filename on line 0 and the `NODE_MODULE_VERSION 127 … requires 137` on lines 2-3,
+ * so first-line truncation printed a bare path and dropped the only part that says
+ * what is wrong. (The comment in probeBindingInFreshProcess below called that string
+ * "the highest-value line doctor prints"; for a stale binding it carried no diagnosis
+ * at all.) Collapsing whitespace keeps both the path and the numbers while staying
+ * safe for a JSON envelope, a JSONL log record and a one-line hook receipt.
+ *
+ * @param {unknown} err Error, string, or anything thrown.
+ * @param {number} [max] Hard cap; a probe must not be able to flood a receipt.
+ * @returns {string}
+ */
+export function flattenBindingError(err, max = 240) {
+  const raw = err instanceof Error ? err.message : err;
+  const s = String(raw ?? '').replace(/\s+/g, ' ').trim();
+  if (!s) return 'unknown';
+  return s.length > max ? `${s.slice(0, max - 1)}…` : s;
+}
+
 /**
  * Probe better-sqlite3's native binding by importing it from `installDir`'s
  * node_modules and opening an in-memory DB. Returns {ok, error?}.

package/lib/hook-stdout.mjs

@@ -26,15 +26,17 @@
 
 let parts = [];
 let queuedEvent = null;
+let systemParts = [];
 
 /**
  * Queue a contribution to this process's single stdout envelope.
  *
  * @param {string} hookEventName Event name for hookSpecificOutput.
  * @param {string} text additionalContext contribution; empty/blank is ignored.
+ * @param {{warn?: (msg: string) => void}} [deps]
  * @returns {void}
  */
-export function queueHookContext(hookEventName, text) {
+export function queueHookContext(hookEventName, text, deps = {}) {
   if (!hookEventName) return;
   const body = String(text ?? '').trim();
   if (!body) return;
@@ -42,11 +44,46 @@ export function queueHookContext(hookEventName, text) {
   // hookSpecificOutput.hookEventName does not match the event it dispatched.
   // In practice one process serves one event; keep the first and drop the
   // stragglers rather than emit an envelope the host rejects outright.
-  if (queuedEvent && queuedEvent !== hookEventName) return;
+  //
+  // The drop is NOISY on purpose. It is unreachable today (all call sites are
+  // event-consistent), but flushEpisode's hookEventName DEFAULTS to 'PostToolUse',
+  // so a future caller that omits the argument would both mis-tag its receipt and
+  // have it swallowed without a trace. Silently vanishing work is this repo's
+  // most-repeated defect class; stderr is safe here because the host never parses it
+  // as the envelope.
+  if (queuedEvent && queuedEvent !== hookEventName) {
+    const warn = deps.warn || ((m) => { try { process.stderr.write(m); } catch { /* never block on a warning */ } });
+    warn(`[claude-mem-lite] hook-stdout: dropped a ${hookEventName} contribution — this process `
+      + `already queued ${queuedEvent}, and one envelope carries exactly one hookEventName. `
+      + 'This is a wiring bug: the contribution is lost.\n');
+    return;
+  }
   queuedEvent = hookEventName;
   parts.push(body);
 }
 
+/**
+ * Queue a line for the HUMAN, not the model.
+ *
+ * Claude Code renders a command hook's top-level `systemMessage` as its own
+ * `hook_system_message` conversation message, independently of
+ * `hookSpecificOutput.additionalContext` — verified in the 2.1.234 bundle
+ * (`if (G.systemMessage) { … yield { message: yc({ type: "hook_system_message", … }) } }`)
+ * and documented there as "Display a message to the user (all hooks)". One envelope
+ * can therefore carry context for the model AND a notice for the user.
+ *
+ * Needed because v3.70.0's merge folded the update banner into additionalContext with
+ * `suppressOutput: true`, which kept its content and lost its audience.
+ *
+ * @param {string} text Notice for the user; empty/blank is ignored.
+ * @returns {void}
+ */
+export function queueHookSystemMessage(text) {
+  const body = String(text ?? '').trim();
+  if (!body) return;
+  systemParts.push(body);
+}
+
 /**
  * Write the queued contributions as one envelope. Idempotent: a second call
  * with nothing queued writes nothing, so calling it from both the dispatcher
@@ -56,18 +93,25 @@ export function queueHookContext(hookEventName, text) {
  * @returns {boolean} true when an envelope was written.
  */
 export function flushHookStdout(deps = {}) {
-  if (!queuedEvent || parts.length === 0) return false;
+  const hasContext = queuedEvent && parts.length > 0;
+  const hasSystem = systemParts.length > 0;
+  if (!hasContext && !hasSystem) return false;
   const write = deps.write || ((s) => process.stdout.write(s));
-  const payload = JSON.stringify({
-    suppressOutput: true,
-    hookSpecificOutput: {
+  const envelope = { suppressOutput: true };
+  if (hasSystem) envelope.systemMessage = systemParts.join('\n');
+  // Omitted entirely when there is no model-facing context: Stop's schema REJECTS a
+  // hookSpecificOutput block, and an envelope carrying only a user notice must not
+  // invent an event name to hang one on.
+  if (hasContext) {
+    envelope.hookSpecificOutput = {
       hookEventName: queuedEvent,
       additionalContext: parts.join('\n\n'),
-    },
-  }) + '\n';
+    };
+  }
   parts = [];
   queuedEvent = null;
-  write(payload);
+  systemParts = [];
+  write(JSON.stringify(envelope) + '\n');
   return true;
 }
 
@@ -75,9 +119,10 @@ export function flushHookStdout(deps = {}) {
 export function resetHookStdout() {
   parts = [];
   queuedEvent = null;
+  systemParts = [];
 }
 
 /** Test seam: what is queued right now. */
 export function peekHookStdout() {
-  return { hookEventName: queuedEvent, parts: [...parts] };
+  return { hookEventName: queuedEvent, parts: [...parts], systemParts: [...systemParts] };
 }

package/lib/install-shape.mjs

@@ -34,7 +34,7 @@ import { existsSync, readdirSync, realpathSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 
-import { probeBindingInFreshProcess, NATIVE_BINDING_REBUILD_CMD } from './binding-probe.mjs';
+import { probeBindingInFreshProcess, NATIVE_BINDING_REBUILD_CMD, flattenBindingError } from './binding-probe.mjs';
 
 // Module-private: nothing outside needs these, and a new unused export is a
 // review signal against the knip baseline recorded in CLAUDE.md.
@@ -216,7 +216,10 @@ export function probeRuntimeRoots(roots, deps = {}) {
     // 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];
+    // NOT `.split('\n')[0]`: Node puts the filename on line 0 and the
+    // `NODE_MODULE_VERSION 127 … requires 137` on lines 2-3, so first-line truncation
+    // showed a bare path for the one fault family this check exists for.
+    const error = flattenBindingError(r.error);
     return ownDeps
       ? { label, root, ok: false, error, repair: `cd ${root} && ${NATIVE_BINDING_REBUILD_CMD}` }
       : {

package/lib/native-binding-hint.mjs

@@ -24,7 +24,7 @@
 import { join } from 'node:path';
 import { readFileSync, writeFileSync, mkdirSync, renameSync, unlinkSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
-import { isNativeBindingError } from './binding-probe.mjs';
+import { isNativeBindingError, flattenBindingError } from './binding-probe.mjs';
 
 export const NATIVE_BINDING_HINT_COOLDOWN_MS = 6 * 60 * 60 * 1000; // 6h
 const MARKER_NAME = 'native-binding-hint-last';
@@ -136,7 +136,7 @@ export function recordNativeBindingBreakage(runtimeDir, { reason = '', event = '
     const tmp = `${marker}.tmp-${process.pid}`;
     // First line only: the ABI error is multi-line and the marker is read by the
     // launcher (pure node:, no parser beyond JSON.parse) and by `doctor`.
-    writeFileSync(tmp, JSON.stringify({ reason: String(reason).split('\n')[0], event, ts: now }));
+    writeFileSync(tmp, JSON.stringify({ reason: flattenBindingError(reason), event, ts: now }));
     renameSync(tmp, marker);
   } catch { /* best-effort */ }
 }

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "claude-mem-lite",
-  "version": "3.70.1",
+  "version": "3.71.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "claude-mem-lite",
-      "version": "3.70.1",
+      "version": "3.71.0",
       "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.1",
+  "version": "3.71.0",
   "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",

package/scripts/binding-probe-cli.mjs

@@ -32,6 +32,15 @@ const ROOT = process.env.PROBE_ROOT || join(dirname(fileURLToPath(import.meta.ur
 // broken flag, and a helperless broken tree is repaired by the hook-launcher
 // path instead. Out of process like every other probe here — loading a stale
 // .node caches a dead module handle for the rest of THIS process.
+// Output-identical twin of lib/binding-probe.mjs::flattenBindingError, kept here
+// because bareProbe runs when lib/ could not be imported. Same 240 cap, same
+// ellipsis, same 'unknown' floor — asserted for parity by the tests.
+function flattenLocal(err, max = 240) {
+  const s = String(err ?? '').replace(/\s+/g, ' ').trim();
+  if (!s) return 'unknown';
+  return s.length > max ? `${s.slice(0, max - 1)}…` : s;
+}
+
 function bareProbe(root) {
   const script =
     'try {'
@@ -42,10 +51,30 @@ function bareProbe(root) {
   const r = spawnSync(process.execPath, ['-e', script], { stdio: 'pipe', timeout: 8000 });
   if (!r.error && r.status === 0) return true;
   // Say WHY. The inline predecessor printed the cause here; dropping it left the
-  // user with setup.sh's generic "binding unusable" and nothing to act on.
-  const why = String(r.stdout || '').trim().split('\n')[0]
-    || (r.error && r.error.message)
-    || `probe exited ${r.status ?? `on signal ${r.signal}`}`;
+  // user with setup.sh's generic "binding unusable" and nothing to act on. Flattened
+  // rather than first-lined: Node's ABI message puts the filename on line 0 and the
+  // NODE_MODULE_VERSION pair on lines 2-3, so `.split('\n')[0]` said WHERE but never
+  // WHY — for the exact fault this probe exists to find.
+  //
+  // Flattening is inlined, NOT lib/binding-probe.mjs::flattenBindingError, because
+  // this function is the fallback for a tree where lib/ failed to import — `helpers`
+  // is still null on every path that reaches here.
+  //
+  // The twin must stay byte-identical in OUTPUT, and it did not: the first draft
+  // capped with a bare `.slice(0, 240)` while the shared helper appends an ellipsis,
+  // so they already disagreed at the one boundary the duplication exists to protect.
+  // A comment is not a guard, and this repo's hand-maintained twins have drifted
+  // before. tests/binding-error-diagnosis.test.mjs now drives THIS path in a
+  // lib/-less tree and asserts parity with the shared helper.
+  // Order matters: flattenLocal floors to the string 'unknown', which is truthy, so
+  // `flattenLocal(x) || fallback` would make the fallbacks unreachable and swallow a
+  // spawn error or an exit code whenever the child printed nothing. Pick the source
+  // FIRST, then flatten it.
+  const printed = String(r.stdout || '').trim();
+  const spawnErr = r.error && r.error.message;
+  const why = printed ? flattenLocal(printed)
+    : spawnErr ? flattenLocal(spawnErr)
+      : `probe exited ${r.status ?? `on signal ${r.signal}`}`;
   process.stderr.write(`[claude-mem-lite] binding probe: ${why}\n`);
   return false;
 }
@@ -82,9 +111,9 @@ try {
 }
 const release = helpers.acquireLock(lockPath);
 if (!release) {
-  const firstLine = String(first.error).split('\n')[0];
   process.stderr.write(
-    `[claude-mem-lite] binding probe: ${firstLine} (another install/repair in flight — deferring heal)\n`,
+    `[claude-mem-lite] binding probe: ${helpers.flattenBindingError(first.error)} `
+    + '(another install/repair in flight — deferring heal)\n',
   );
   process.exit(1);
 }

package/scripts/launch.mjs

@@ -20,9 +20,32 @@ if (!existsSync(join(ROOT, 'node_modules', 'better-sqlite3'))) {
     });
     process.stderr.write('[claude-mem-lite] Dependencies installed\n');
   } catch (e) {
-    // Plugin-cache / multi-user / disk-full installs can fail here. Without this
-    // catch the user sees a Node stack trace; with it they get an actionable line.
-    const detail = e.message?.split('\n')[0] || e.code || 'unknown error';
+    // Plugin-cache / multi-user / disk-full installs can fail here, and this is not a
+    // rare path: Claude Code materializes each new plugin-cache version WITHOUT
+    // node_modules, so the guard above opens on the first MCP launch after every
+    // plugin update. Without this catch the user sees a Node stack trace.
+    //
+    // `.split('\n')[0]` is CORRECT here, unlike the four binding-error sites fixed in
+    // v3.70.2, and the difference is the `stdio` above: stderr is **inherit**, so
+    // npm's own diagnosis (`npm error code EROFS`, `path …`, `rofs EROFS: read-only
+    // file system …`) has already streamed straight to the user's terminal by the time
+    // we get here — verified by running this file against an unwritable ROOT. With
+    // stderr inherited, execSync's `e.message` holds only "Command failed: <cmd>";
+    // there is no captured diagnosis to lose. Do NOT "fix" this by piping stderr to
+    // recover it: piping is what made a compiling better-sqlite3 look hung under the
+    // 5-min bash timeout (bug audit 2026-05), which is why stderr is inherited.
+    //
+    // A pre-tag review measured `e.message` under `stdio: 'pipe'`, where stderr IS
+    // folded into the message, and concluded this line drops the diagnosis. It does
+    // not — the stdio differs. Recorded here because the same wrong conclusion is
+    // easy to reach from the code alone.
+    //
+    // `e.status` not `e.code`: execSync failures carry the exit status on `status`,
+    // so the old `|| e.code` rung was dead.
+    const detail = e?.message?.split('\n')[0]
+      || (e?.status != null ? `npm exited ${e.status}` : '')
+      || (e?.signal ? `npm killed by ${e.signal}` : '')
+      || 'unknown error';
     process.stderr.write(`[claude-mem-lite] npm install failed in ${ROOT} — ${detail}\n`);
     process.stderr.write(`[claude-mem-lite] Likely cause: read-only directory, disk full, or network blocked.\n`);
     process.stderr.write(`[claude-mem-lite] Repair: cd "${ROOT}" && npm install --omit=dev\n`);