claude-mem-lite 3.15.0 → 3.16.1

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "3.15.0",
+      "version": "3.16.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.15.0",
+  "version": "3.16.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/claudemd.mjs

@@ -200,7 +200,18 @@ export function removeManaged(cwd, slug) {
       if (blockAtStart) raw = raw.replace(/^\s+/, '');
       action = 'removed';
     }
-    if (action === 'removed') atomicWrite(p, raw);
+    if (action === 'removed') {
+      // When the managed block was the ENTIRE file (adopt created CLAUDE.md
+      // because none existed), removing it leaves nothing but whitespace.
+      // Delete the now-empty file rather than writing a 0-byte CLAUDE.md, so
+      // unadopt fully restores the pre-adopt state — mirrors the emptied-.claude/
+      // cleanup below ("unadopt leaves no trace").
+      if (raw.trim() === '') {
+        try { unlinkSync(p); } catch { atomicWrite(p, raw); }
+      } else {
+        atomicWrite(p, raw);
+      }
+    }
   }
   const dp = detailDocPath(cwd, slug);
   if (existsSync(dp)) try { unlinkSync(dp); } catch { /* best-effort */ }

package/format-utils.mjs

@@ -61,6 +61,11 @@ export function fmtDate(iso) {
 export function fmtTime(iso) {
   if (!iso) return '';
   const d = new Date(iso);
+  // Guard against an unparseable timestamp (e.g. corrupt/imported created_at):
+  // a bare new Date('garbage') yields Invalid Date → getUTCHours() is NaN →
+  // "NaN:NaN" leaking into the SessionStart Recent table. Degrade to '' like the
+  // falsy-input case above.
+  if (Number.isNaN(d.getTime())) return '';
   return `${String(d.getUTCHours()).padStart(2, '0')}:${String(d.getUTCMinutes()).padStart(2, '0')}`;
 }
 

package/hook-context.mjs

@@ -27,6 +27,15 @@ function inferProjectDir() {
  * @param {string} project Project name to check velocity for
  * @returns {{tier1: number, tier2: number, tier3: number, sessWindow: number}} Time window durations in ms
  */
+// Sanitize a string for a GitHub-flavored-markdown table cell: a literal `|`
+// in a title (e.g. "grep | sort | uniq") would otherwise open phantom columns
+// and corrupt the <claude-mem-context> Recent table the model+user see every
+// SessionStart. Escape pipes and collapse any CR/LF/tab to a space so one obs
+// stays one row/cell.
+function mdCell(s) {
+  return String(s ?? '').replace(/[\r\n\t]+/g, ' ').replace(/\|/g, '\\|');
+}
+
 export function computeAdaptiveWindows(db, project) {
   const sevenDaysAgo = Date.now() - 7 * 86400000;
   const row = db.prepare(`
@@ -446,7 +455,7 @@ export function buildSessionContextLines(db, project, now = new Date(), currentC
     obsLines.push('|----|------|---|-------|');
     for (const o of obsToShow) {
       const proj = o.project && o.project !== project ? ` (${o.project})` : '';
-      obsLines.push(`| #${o.id} | ${fmtTime(o.created_at)} | ${typeIcon(o.type)} | ${truncate(o.title || '(untitled)', 60)}${proj} |`);
+      obsLines.push(`| #${o.id} | ${fmtTime(o.created_at)} | ${typeIcon(o.type)} | ${mdCell(truncate(o.title || '(untitled)', 60) + proj)} |`);
     }
   }
 

package/hook-memory.mjs

@@ -16,8 +16,23 @@ const MEMORY_TYPE_BOOST = { decision: 1.5, discovery: 1.3, bugfix: 1.1, feature:
 // Adaptive BM25 thresholds — scale with corpus size to filter noise.
 // Larger corpora produce more weak matches from common words.
 const BM25_THRESHOLD = { TINY: 0, SMALL: 1.5, MEDIUM: 2.5, LARGE: 3.5 };
-// OR fallback max token count — queries with 3+ tokens that fail AND are likely off-topic
-const OR_FALLBACK_MAX_TOKENS = 2;
+// OR fallback max token count — when an AND query returns nothing, retry as OR
+// only if the query has at most this many significant terms. Natural-language
+// user prompts ("how did we fix the parser null deref bug?") almost always
+// exceed this after synonym expansion, so the old hard 2 silently denied them
+// the OR rescue and the UPS injection path returned 0 results for real prompts
+// (semantic-keyed recall measured at 26%, #8255; 0/11 on a realistic NL corpus).
+// Precision for OR results is already enforced downstream by three independent
+// gates — the 0.4x OR penalty, the adaptive BM25 threshold, and the 40%
+// term-coverage filter (v27) — so the token gate is a redundant, overly-strict
+// fourth guard predating term-coverage. Default raised to 8 (covers typical NL
+// prompts); env override `MEM_OR_FALLBACK_MAX_TOKENS` ∈ [0, 50], invalid → 8.
+function getOrFallbackMaxTokens() {
+  const raw = process.env.MEM_OR_FALLBACK_MAX_TOKENS;
+  if (raw === undefined || raw === '') return 8;
+  const n = parseInt(raw, 10);
+  return Number.isInteger(n) && n >= 0 && n <= 50 ? n : 8;
+}
 
 // v27: term-coverage post-filter. Drops high-BM25 candidates whose visible
 // fields (title + lesson_learned) cover <N% of the query's significant terms.
@@ -215,9 +230,10 @@ export function searchRelevantMemories(db, userPrompt, project, excludeIds = [])
     // unconditionally; mirror that here. Noise is contained downstream (0.4x OR
     // penalty + BM25 threshold + term-coverage filter). queryIsCjkDominant (not
     // mere CJK presence) is the gate — see its definition at the function top.
+    const orFallbackMaxTokens = getOrFallbackMaxTokens();
     if (rows.length === 0) {
       const orQuery = relaxFtsQueryToOr(ftsQuery);
-      if (orQuery && (queryIsCjkDominant || queryTokenCount <= OR_FALLBACK_MAX_TOKENS)) {
+      if (orQuery && (queryIsCjkDominant || queryTokenCount <= orFallbackMaxTokens)) {
         try { rows = selectStmt.all(orQuery, project, cutoff); usedOrFallback = true; } catch {}
       }
     }
@@ -248,7 +264,7 @@ export function searchRelevantMemories(db, userPrompt, project, excludeIds = [])
       crossRows = crossStmt.all(ftsQuery, project, cutoff);
       if (crossRows.length === 0) {
         const orQuery = relaxFtsQueryToOr(ftsQuery);
-        if (orQuery && (queryIsCjkDominant || queryTokenCount <= OR_FALLBACK_MAX_TOKENS)) {
+        if (orQuery && (queryIsCjkDominant || queryTokenCount <= orFallbackMaxTokens)) {
           try { crossRows = crossStmt.all(orQuery, project, cutoff); crossUsedOr = true; } catch {}
         }
       }

package/hook-optimize.mjs

@@ -203,10 +203,22 @@ search_aliases: 2-6 alternative search terms (include CJK if applicable).`;
 const NORMALIZE_GATE_FILE = join(RUNTIME_DIR, 'last-normalize.json');
 const NORMALIZE_INTERVAL_MS = 7 * 86400000; // 7 days
 
+// Pure gate decision (no IO) — exported for testing. Fail-OPEN on a
+// malformed-but-valid-JSON gate: a missing/non-numeric `epoch` makes
+// `now - epoch` NaN, and `NaN >= INTERVAL` is false — which would PERMANENTLY
+// block normalize with no recovery, contradicting the catch-branch's fail-open
+// intent (a corrupt file that fails JSON.parse already returns true). A future
+// epoch (clock skew / NTP correction) is equally suspect → run.
+export function _normalizeGateOpen(last, now) {
+  const epoch = last?.epoch;
+  if (typeof epoch !== 'number' || !Number.isFinite(epoch) || epoch > now) return true;
+  return now - epoch >= NORMALIZE_INTERVAL_MS;
+}
+
 export function shouldRunNormalize() {
   try {
     const last = JSON.parse(readFileSync(NORMALIZE_GATE_FILE, 'utf8'));
-    return Date.now() - last.epoch >= NORMALIZE_INTERVAL_MS;
+    return _normalizeGateOpen(last, Date.now());
   } catch {
     return true;
   }

package/mem-cli.mjs

@@ -1636,12 +1636,26 @@ function cmdRestore(db, argv) {
   const trimmed = raw.trim();
   if (!trimmed) { out('[mem] Empty file — nothing to restore.'); return; }
   let rows;
-  try {
-    rows = trimmed[0] === '['
-      ? JSON.parse(trimmed)
-      : trimmed.split('\n').filter(l => l.trim()).map(l => JSON.parse(l));
-  } catch (e) { fail(`[mem] "${file}" is not valid export JSON/JSONL: ${e.message}`); return; }
-  if (!Array.isArray(rows) || rows.length === 0) { out('[mem] No observations in file.'); return; }
+  let parseFailures = 0;
+  if (trimmed[0] === '[') {
+    // Whole-array JSON is a single document — partial parse is impossible, so
+    // a syntax error rejects the file (unchanged behavior).
+    try { rows = JSON.parse(trimmed); }
+    catch (e) { fail(`[mem] "${file}" is not valid export JSON/JSONL: ${e.message}`); return; }
+  } else {
+    // JSONL: tolerate per-line syntax errors so one corrupt line in a large
+    // backup doesn't discard every valid row. Parse failures fold into the
+    // malformed tally below (the loop already skips valid-JSON-but-wrong-shape
+    // rows the same way) — a backup tool must recover what it can.
+    rows = [];
+    for (const line of trimmed.split('\n')) {
+      if (!line.trim()) continue;
+      try { rows.push(JSON.parse(line)); }
+      catch { parseFailures++; }
+    }
+  }
+  if (!Array.isArray(rows) || (rows.length === 0 && parseFailures === 0)) { out('[mem] No observations in file.'); return; }
+  if (rows.length === 0) { fail(`[mem] "${file}": all ${parseFailures} line(s) failed to parse as JSONL.`); return; }
 
   const projOverride = flags.project ? resolveProject(db, flags.project) : null;
   const dryRun = flags['dry-run'] === true || flags['dry-run'] === 'true';
@@ -1693,7 +1707,12 @@ function cmdRestore(db, argv) {
       if (process.env.CLAUDE_MEM_DEBUG) process.stderr.write(`[mem] restore row failed: ${e.message}\n`);
     }
   }
-  out(`[mem] Restore${dryRun ? ' (dry-run)' : ''}: ${restored} restored, ${skipped} duplicate(s) skipped, ${malformed} malformed/failed from ${rows.length} row(s).`);
+  // Fold JSONL per-line syntax failures into the malformed tally and the
+  // denominator so the report reflects every non-blank input line, not just the
+  // ones that parsed.
+  const totalMalformed = malformed + parseFailures;
+  const totalLines = rows.length + parseFailures;
+  out(`[mem] Restore${dryRun ? ' (dry-run)' : ''}: ${restored} restored, ${skipped} duplicate(s) skipped, ${totalMalformed} malformed/failed from ${totalLines} row(s).`);
 }
 
 // ─── Compress ────────────────────────────────────────────────────────────────

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "3.15.0",
+  "version": "3.16.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",