claude-mem-lite 3.73.0 → 3.74.1

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "3.73.0",
+      "version": "3.74.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.73.0",
+  "version": "3.74.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/bash-utils.mjs

@@ -117,35 +117,128 @@ const ERROR_STOP_WORDS = new Set([
   'node', 'require', 'stack', 'trace',
 ]);
 
+const ERROR_LINE_RE = /error|fail|exception|cannot|not found|undefined|null/i;
+const ERROR_RECALL_MAX_TERMS = 6;
+
 /**
- * Extract discriminative keywords from a failed command and its error output.
- * Filters out common stop words to produce useful FTS5 search terms.
- * @param {string} cmd The command that was executed
- * @param {string} response The error output text
- * @returns {string[]|null} Array of 1-6 keywords or null if none found
+ * Split a failed command + its output into command-derived and error-derived terms.
+ * Shared by extractErrorKeywords (merged view, unchanged contract) and
+ * planErrorRecall (which needs the two classes kept apart). Dedup is deliberately
+ * ACROSS both classes, command-first, so the merged view is byte-identical to the
+ * pre-split single-Set implementation.
+ * @returns {{cmdWords: string[], errWords: string[]}}
  */
-export function extractErrorKeywords(cmd, response) {
-  const words = new Set();
-  const cmdParts = cmd.split(/[\s/\\|&;]+/).filter(w => w.length > 2 && !/^-/.test(w));
+function collectErrorTerms(cmd, response) {
+  const seen = new Set();
+  const cmdWords = [];
+  const cmdParts = String(cmd || '').split(/[\s/\\|&;]+/).filter(w => w.length > 2 && !/^-/.test(w));
   for (const w of cmdParts.slice(0, 3)) {
     const lw = w.toLowerCase();
-    if (!ERROR_STOP_WORDS.has(lw)) words.add(lw);
+    if (!ERROR_STOP_WORDS.has(lw) && !seen.has(lw)) { seen.add(lw); cmdWords.push(lw); }
   }
-  const errLines = response.split('\n').filter(l =>
-    /error|fail|exception|cannot|not found|undefined|null/i.test(l)
-  ).slice(0, 3);
+  const errWords = [];
+  // The line filter is the TRIGGER's pattern list OR'd with the prose one. Anything
+  // that made detectBashSignificance call this a hard error is, by construction, also
+  // something we will extract terms from — which closes the "trigger fired, extractor
+  // found nothing, so we queried the command's own words" class without enumerating
+  // failure shapes. ERROR_LINE_RE alone missed `npm ERR! code ENOENT` (no `error`, no
+  // `fail`, no `not found` — npm says "no such file") and `panic: assignment to entry
+  // in nil map`, while letting `panic: runtime error: …` through purely because that
+  // message happens to contain the substring `error`.
+  // Note HARD_ERROR_RE's `\n\s+at\s+\S` alternative cannot match a single line (it
+  // needs the preceding newline); that is fine — it is a stack-frame anchor, and the
+  // frames it guards are accompanied by a line the other alternatives do catch.
+  const errLines = String(response || '')
+    .split('\n')
+    .filter((l) => ERROR_LINE_RE.test(l) || HARD_ERROR_RE.test(l))
+    .slice(0, 3);
   for (const line of errLines) {
     const tokens = line.replace(/[^a-zA-Z0-9_.-]/g, ' ').split(/\s+/)
       .filter(w => w.length > 3 && !/^\d+$/.test(w));
     for (const t of tokens.slice(0, 5)) {
       const lt = t.toLowerCase();
-      if (!ERROR_STOP_WORDS.has(lt)) words.add(lt);
+      if (!ERROR_STOP_WORDS.has(lt) && !seen.has(lt)) { seen.add(lt); errWords.push(lt); }
     }
   }
-  const result = [...words].slice(0, 6);
+  return { cmdWords, errWords };
+}
+
+/**
+ * Extract discriminative keywords from a failed command and its error output.
+ * Filters out common stop words to produce useful FTS5 search terms.
+ * @param {string} cmd The command that was executed
+ * @param {string} response The error output text
+ * @returns {string[]|null} Array of 1-6 keywords or null if none found
+ */
+export function extractErrorKeywords(cmd, response) {
+  const { cmdWords, errWords } = collectErrorTerms(cmd, response);
+  const result = [...cmdWords, ...errWords].slice(0, ERROR_RECALL_MAX_TERMS);
   return result.length >= 1 ? result : null;
 }
 
+/**
+ * Decide whether the error-recall surface should fire, and with which terms (D#136).
+ *
+ * Two defects this closes, both measured against the live DB on 2026-08-22 (obs
+ * #10730 carries the readings):
+ *
+ * 1. THE SELECTION FILTER IS A SUPERSET OF THE TRIGGER. This surface fires on
+ *    detectBashSignificance's isHardError (HARD_ERROR_RE), but term extraction used to
+ *    keep only lines matching ERROR_LINE_RE — a DIFFERENT list. The two diverge:
+ *    HARD_ERROR_RE accepts `ERR!`, `enoent`, `panic`, `traceback`; ERROR_LINE_RE takes
+ *    `error|fail|exception|cannot|not found|undefined|null` as SUBSTRINGS (no word
+ *    boundaries — `AssertionError` matches on `error`). npm's own output sits in the
+ *    gap: `npm ERR! code ENOENT / npm ERR! enoent ENOENT: no such file or directory`
+ *    has no `error`, no `fail`, no `not found` (npm says "no such file"), so it cleared
+ *    the trigger and then yielded ZERO lines to extract from. The keyword set degraded
+ *    to pure command words — literally ['npm','run','build'] — and the surface searched
+ *    the COMMAND'S TOPIC instead of the failure.
+ *    The sharpest symptom was Go: `panic: assignment to entry in nil map` was silenced
+ *    while `panic: runtime error: index out of range` was not, purely because the
+ *    second message happens to contain the substring `error`. Recall depending on the
+ *    wording of a panic is the same divergence, relocated.
+ *    OR-ing HARD_ERROR_RE into the line filter closes the class BY CONSTRUCTION rather
+ *    than by enumerating shapes: whatever convinced the trigger this was a hard error
+ *    is, by definition, also something we will read terms from. (Widening ERROR_LINE_RE
+ *    ad hoc WOULD be enumeration; making it a superset of the trigger is not.)
+ *
+ * 2. COMMAND WORDS STAY IN THE QUERY — a demotion was TRIED AND REJECTED on data.
+ *    The obvious follow-up is to drop `npm` / `run` / `grep` from the query, since
+ *    they demonstrably let BM25 return release records for a missing-module failure.
+ *    Replaying five real failures against the live DB (2026-08-22) says the trade is
+ *    not one-way: error-terms-only did fix `npm run build` (it surfaced #8721
+ *    ERR_MODULE_NOT_FOUND and #8185 SOURCE_FILES, the rows that actually explain it),
+ *    but it REGRESSED two others — dropping `database` lost #8673 (plugin-mode
+ *    data-dir skew) for a failed DB open, and dropping `vitest` lost #8725 (test
+ *    fails locally) for a test failure. Command words are carrying domain anchoring,
+ *    not just noise. A demote-to-fallback variant measured byte-identical to
+ *    error-terms-only (12 rows either way): the primary query always filled its
+ *    LIMIT 3, so the fallback never ran.
+ *
+ * 3. THE RESIDUAL GATE. With (1) in place this fires rarely, but it is not dead: a
+ *    failure can still yield no usable term — empty output, or a line whose tokens are
+ *    all stop words (`Error: it failed`). There is then nothing to recall ON, and
+ *    silence beats querying the command's topic.
+ *    Read the predicate precisely: `errWords` excludes anything ALREADY taken as a
+ *    command word, because collectErrorTerms dedups across both classes with the
+ *    command filled first. So this is "no error term that is not also in the command",
+ *    not "no error term". `docker compose up -d` and `docker stack deploy` on the SAME
+ *    output decide differently for exactly that reason — the first has `compose` in the
+ *    command, the second does not. That asymmetry is inherited from the pre-split
+ *    single-Set implementation and is preserved deliberately; it is documented here
+ *    rather than silently "fixed" because changing it would change extractErrorKeywords
+ *    for every caller, which is a separate decision from this one.
+ *
+ * @param {string} cmd The command that was executed
+ * @param {string} response The error output text
+ * @returns {{terms: string[]}|null} null ⇒ do not inject
+ */
+export function planErrorRecall(cmd, response) {
+  const { cmdWords, errWords } = collectErrorTerms(cmd, response);
+  if (errWords.length === 0) return null;
+  return { terms: [...cmdWords, ...errWords].slice(0, ERROR_RECALL_MAX_TERMS) };
+}
+
 // ─── File Paths ──────────────────────────────────────────────────────────────
 
 /**

package/hook.mjs

@@ -24,7 +24,7 @@ import { readFileSync, writeFileSync, unlinkSync, readdirSync, renameSync, statS
 import { homedir } from 'os';
 import {
   truncate, inferProject, detectBashSignificance,
-  extractErrorKeywords, extractFilePaths, isRelatedToEpisode,
+  planErrorRecall, extractFilePaths, isRelatedToEpisode,
   makeEntryDesc, scrubSecrets, stripPrivate, EDIT_TOOLS, debugCatch, debugLog,
   COMPRESSED_AUTO, OBS_BM25, notLowSignalTitleClause, formatErrorRecallHints,
   MAX_HOOK_STDIN_BYTES,
@@ -473,13 +473,20 @@ function triggerErrorRecall(db, toolInput, response) {
   try {
     const project = inferProject();
 
-    // Extract error keywords
+    // Extract error keywords (D#136). The extractor's line filter is HARD_ERROR_RE —
+    // the very predicate isHardError above used — OR'd with the prose one, so anything
+    // that reaches this line is also something we can read terms from. Before that,
+    // the two lists diverged and npm's own output fell in the gap: `npm ERR! code
+    // ENOENT` has no `error`/`fail`/`not found`, so extraction yielded nothing and the
+    // query degraded to ['npm','run','build'] — the command's topic, not the failure.
+    // planErrorRecall still returns null when nothing usable survives (empty output, or
+    // only stop words), and then we stay silent rather than query the command's topic.
     const cmd = toolInput.command || '';
-    const keywords = extractErrorKeywords(cmd, response);
-    if (!keywords || keywords.length === 0) return;
+    const plan = planErrorRecall(cmd, response);
+    if (!plan) return;
 
     // FTS5 OR query for broader recall
-    const ftsQuery = keywords.map(t => `"${t.replace(/"/g, '""')}"`).join(' OR ');
+    const ftsQuery = plan.terms.map(t => `"${t.replace(/"/g, '""')}"`).join(' OR ');
     if (!ftsQuery) return;
 
     const nowR = Date.now();

package/install.mjs

@@ -1737,8 +1737,17 @@ async function doctor() {
     try { currentVersion = JSON.parse(readFileSync(join(PROJECT_DIR, 'package.json'), 'utf8')).version; } catch { /* fall through with empty version */ }
     const stale = lines.filter(l => isStaleMemProcess(l, currentVersion));
     if (stale.length > 0) {
+      // ⚠-level ONLY, deliberately not `issues++`. buildDoctorSummary's contract is
+      // "issues are ✗-level (action required); warnings are ⚠-level (informational)",
+      // and an old process is the one finding here the user cannot act on from a
+      // doctor run: auto-update bumps installed_plugins.json but cannot kill the MCP
+      // process an active session already spawned, so a correct, healthy install
+      // reports this for as long as that session lives. Counting it made `doctor`
+      // exit 1 while every line on screen was ✓ or ⚠ — it failed the v3.70.0 release
+      // `validate` job (where the "old processes" were vitest's own workers) and it
+      // reddens doctor-install-shape-e2e's "instead of going red forever" case on any
+      // dev box with a previous-version session still open.
       warn(`Old processes running${currentVersion ? ` (current: v${currentVersion})` : ''}:\n    ` + stale.join('\n    '));
-      issues++;
     } else {
       ok('No stale processes');
     }

package/npm-shrinkwrap.json

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

package/utils.mjs

@@ -16,7 +16,7 @@ export { scrubSecrets, SECRET_PATTERNS } from './secret-scrub.mjs';
 export { stripPrivate } from './lib/private-strip.mjs';
 export { truncate, typeIcon, fmtDate, fmtTime, isoWeekKey, formatErrorRecallHints, neutralizeContextDelimiters } from './format-utils.mjs';
 export { computeMinHash, estimateJaccardFromMinHash, jaccardSimilarity } from './hash-utils.mjs';
-export { detectBashSignificance, extractErrorKeywords, extractFilePaths, stripTestSuffix } from './bash-utils.mjs';
+export { detectBashSignificance, extractErrorKeywords, planErrorRecall, extractFilePaths, stripTestSuffix } from './bash-utils.mjs';
 
 // Internal imports for functions that remain in this module
 import { truncate } from './format-utils.mjs';