claude-mem-lite 3.73.0 → 3.74.0

package/.claude-plugin/marketplace.json

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

@@ -117,35 +117,97 @@ 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 = [];
+  const errLines = String(response || '').split('\n').filter(l => ERROR_LINE_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. NO ERROR SIGNAL ⇒ NO INJECTION. This surface fires on detectBashSignificance's
+ *    isHardError, and that gate's HARD_ERROR_RE is NOT in sync with ERROR_LINE_RE
+ *    here: HARD_ERROR_RE accepts `ERR!`, `enoent` and `traceback`, while ERROR_LINE_RE
+ *    only matches the whole word `error`. So npm's own failure output clears the
+ *    trigger and then yields ZERO error lines — `npm ERR! code ENOENT / npm ERR!
+ *    enoent ENOENT: no such file or directory` contains no `error`, no `fail`, and no
+ *    `not found` (it says "no such file"). The keyword set then degraded to pure
+ *    command words — literally ['npm','run','build'] — and the surface searched the
+ *    COMMAND'S TOPIC instead of the failure. Same for a Python traceback whose head
+ *    lines carry `Traceback (most recent call last):` and a bare `File "x.py"`.
+ *    Both are among the most common failures a session produces.
+ *    With no error term there is nothing to recall ON, so the honest answer is
+ *    silence rather than a topic match. Widening ERROR_LINE_RE is NOT the fix —
+ *    enumeration always misses one more shape, and this gate is correct for every
+ *    shape it misses. (Verified: a `grep` killed by seccomp does NOT reach here at
+ *    all — isHardError is false for it — so that shape is not evidence for this gate.)
+ *
+ * 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. Net: gate only, selection unchanged.
+ *
+ * @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. planErrorRecall (D#136) returns null when the output
+    // carried NO error-signal token. isHardError above and that check do NOT use the
+    // same pattern list: HARD_ERROR_RE accepts `ERR!`/`enoent`/`traceback`, while the
+    // line filter wants the whole word `error`. npm's own failure text clears the
+    // former and yields zero lines to the latter, so `npm run build` failing on
+    // ENOENT used to query ['npm','run','build'] — the command's topic, not the
+    // failure. Silence is the honest answer there.
+    // The term list itself is unchanged when the gate passes (rationale at the seam).
     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.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "claude-mem-lite",
-      "version": "3.73.0",
+      "version": "3.74.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.73.0",
+  "version": "3.74.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/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';