claude-mem-lite 3.22.0 → 3.23.0

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "3.22.0",
+      "version": "3.23.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.22.0",
+  "version": "3.23.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

@@ -13,6 +13,16 @@ const CMD_WRAPPERS = new Set(['sudo', 'doas', 'env', 'time', 'command', 'nice',
 // git read subcommands whose output contains commit/log/match text, not failures.
 const GIT_READ_SUBCMDS = new Set(['grep', 'log', 'show', 'diff', 'blame', 'ls-files', 'cat-file', 'whatchanged', 'shortlog', 'reflog', 'status']);
 
+// Hard failure fingerprints — a real crash / thrown exception / non-zero-exit marker,
+// as opposed to output that merely CONTAINS the word "error" (search results, log
+// scans, prose). Deliberately strong/narrow: a JS stack frame (`\n   at fn (…)`),
+// panic/traceback/segfault, ENOENT/command-not-found, AssertionError, or a *named*
+// error class (TypeError:/ReferenceError:/…). Generic `Error:`/`exception` are
+// intentionally excluded — they appear too often in benign search/log output. Gates
+// the bugfix-shape save-nudge (lib/cite-back-hint.mjs) so `node cli.mjs search "error"`
+// + an edit in the same episode no longer looks like an unsaved fix.
+const HARD_ERROR_RE = /\bERR!|\bpanic\b|traceback|segfault|core dumped|\benoent\b|command not found|assertion\s?error|\n\s+at\s+\S|(?:type|reference|range|syntax|eval|uri)error:/i;
+
 // True when the command's PRIMARY operation (left of the first pipe, past any
 // env-assignments / wrapper like `sudo`/`env`/`time`) is a read/search — including
 // `git grep`/`git log`. Anchoring on the primary command (not "search verb appears
@@ -69,6 +79,10 @@ export function detectBashSignificance(input, response) {
   const hasHardErrorSignal = hasGreenTestSummary
     && /\bERR!|panic|traceback|enoent|command not found|exception|AssertionError|TypeError:|SyntaxError:/i.test(response);
   const isError = looksLikeError && !(hasGreenTestSummary && !hasHardErrorSignal);
+  // Strict subset of isError: a genuine failure fingerprint, not just the word "error"
+  // in benign output. Consumers that must avoid false positives (the bugfix-shape
+  // save-nudge) gate on this instead of isError.
+  const isHardError = isError && HARD_ERROR_RE.test(response);
   // Match actual test runner invocations, not commands that merely reference "test" as a keyword
   const isTest = /\b(npm\s+test|npm\s+run\s+test|yarn\s+test|pnpm\s+test|pnpm\s+run\s+test|bun\s+test|go\s+test|cargo\s+test)\b/i.test(cmd)
     || /\b(jest|pytest|vitest|mocha|cypress|playwright)\b/i.test(cmd);
@@ -85,7 +99,7 @@ export function detectBashSignificance(input, response) {
     || /\bgh\s+release\s+(?:create|edit|upload|delete)\b/i.test(cmd)
     || /\btwine\s+upload\b/i.test(cmd);
   return {
-    isError, isTest, isBuild, isGit, isDeploy,
+    isError, isHardError, isTest, isBuild, isGit, isDeploy,
     isSignificant: isError || isTest || isBuild || isGit || isDeploy,
   };
 }

package/hook-llm.mjs

@@ -803,9 +803,16 @@ ${actionList}`;
         // retry's entire purpose (a recovered bugfix lesson would silently drop
         // out of --importance 2 searches and the working tier). Gate the cap on
         // the *effective* low-signal state, not the pre-retry flag.
+        // v3.23: cap the FILE-PATH heuristic's contribution at 2. computeRuleImportance
+        // returns 3 for any entry touching schema./migration/prisma/.env/.key paths; via the
+        // Math.max below that force-promoted ordinary has-lesson episodes to "critical" imp=3
+        // even when Haiku judged them 1-2 (audit: auto imp=3 = 34.8%, e.g. a thin-lesson edit
+        // to schema.mjs). Haiku's OWN importance can still reach 3 (genuine judgment); only the
+        // path heuristic is capped. The isLessonLowSignal branch still floors no-lesson
+        // non-decision autos at ≤1; manual mem_save uses a different path and is unaffected.
         importance: isLessonLowSignal && !retryRecovered && parsed.type !== 'decision'
           ? Math.min(ruleImportance, 1)
-          : Math.max(ruleImportance, clampImportance(parsed.importance)),
+          : Math.max(Math.min(ruleImportance, 2), clampImportance(parsed.importance)),
         lessonLearned,
         searchAliases,
       };

package/hook.mjs

@@ -47,7 +47,7 @@ import { handleLLMEpisode, handleLLMSummary, saveObservation, buildImmediateObse
 import { scrubRecord } from './lib/scrub-record.mjs';
 import { formatHookError } from './lib/native-binding-hint.mjs';
 import { selectCompressionCandidates, groupByProjectWeek, compressGroup } from './lib/compress-core.mjs';
-import { cleanupBroken, decayAndMarkIdle, boostAccessed, selectFuzzyDedupeIds, hardDeleteCandidateCount, purgeStale } from './lib/maintain-core.mjs';
+import { cleanupBroken, decayAndMarkIdle, boostAccessed, selectFuzzyDedupeIds, hardDeleteCandidateCount, purgeStale, recoverOrphanedChildren } from './lib/maintain-core.mjs';
 import { snapshotDb } from './lib/db-backup.mjs';
 import {
   extractCitationsFromTranscript,
@@ -286,6 +286,9 @@ async function handlePostToolUse() {
     files,
     ts: Date.now(),
     isError: bashSig?.isError || false,
+    // isHardError gates the bugfix-shape save-nudge (lib/cite-back-hint.mjs): a real
+    // failure fingerprint, not just "error" appearing in search/log output.
+    isHardError: bashSig?.isHardError || false,
     isSignificant: EDIT_TOOLS.has(tool_name) ||
                    bashSig?.isSignificant || false,
     bashSig: bashSig || null,
@@ -711,6 +714,12 @@ function runSessionStartDbMutations(db, { sessionId, project, prevSessionId, now
       WHERE COALESCE(compressed_into, 0) = 0
         AND COALESCE(importance, 1) <= 1
         AND COALESCE(injection_count, 0) = 0
+        -- v3.23: never auto-hide a row that carries a real lesson. compression folds
+        -- sources into a title-only summary (lesson lost), and COMPRESSED_AUTO hides the
+        -- row from search entirely. A low-importance obs whose lesson_learned is the
+        -- distilled value must stay findable (audit: 62 lessons buried this way). The 7d
+        -- noise block below already excludes lessons; this 30d block had drifted.
+        AND (lesson_learned IS NULL OR lesson_learned = '' OR lesson_learned = 'none')
         AND created_at_epoch < ?
         AND project = ?
     `).run(autoCompressAge, project);
@@ -779,6 +788,12 @@ function runSessionStartAutoMaintain(db) {
       const cleaned = cleanupBroken(db, mctx);
       if (cleaned > 0) debugLog('DEBUG', 'auto-maintain', `cleaned ${cleaned} broken observations`);
 
+      // Self-heal legacy orphans: children whose compression keeper was hard-deleted
+      // before recoverChildrenOf existed are hidden + queue-less (unreachable). Resurface
+      // them so normal decay/GC handles them on merit. Non-destructive (un-hide only).
+      const orphansRecovered = recoverOrphanedChildren(db, mctx);
+      if (orphansRecovered > 0) debugLog('DEBUG', 'auto-maintain', `recovered ${orphansRecovered} orphaned compression children`);
+
       const { decayed, idleMarked } = decayAndMarkIdle(db, mctx);
       if (decayed > 0) debugLog('DEBUG', 'auto-maintain', `decayed ${decayed} stale observations`);
       if (idleMarked > 0) debugLog('DEBUG', 'auto-maintain', `marked ${idleMarked} idle as pending-purge`);

package/lib/cite-back-hint.mjs

@@ -68,11 +68,17 @@ export function buildCiteBackHint(episode, cooldown) {
 // the lib so all save-prompt hints share one home + the same wording rules.
 //
 // Detection (mirrors pre-v2.83 hook.mjs:194 heuristic):
-//   • has at least one entry with isError=true
+//   • has at least one entry with a HARD failure fingerprint (isHardError) — NOT just
+//     isError. `node cli.mjs search "error"`, `npx vitest` green output, or any command
+//     whose output merely MENTIONS "error"/"failed" sets isError=true but is not a fix;
+//     gating on isError nagged on non-fixes (audit: fired on a read-only session + a
+//     scratch write). isHardError requires a real crash/exception/stack (bash-utils.mjs).
 //   • has at least one entry using an edit tool
 //   • entries.length >= 3 (rules out single-typo fixes that don't need a lesson)
 // Returns null when any condition fails or when no edited files are recoverable
 // from the entry list (defensive — episodes flushed mid-tool can have empties).
+// Legacy fallback: entries written before isHardError existed lack the field, so fall
+// back to isError for them rather than silently regress the nudge to never-fire.
 const MIN_BUGFIX_ENTRIES = 3;
 const MAX_DISPLAY_FILES = 3;
 
@@ -86,7 +92,7 @@ export function buildUnsavedBugfixHint(episode) {
   const editedFiles = new Set();
   for (const e of entries) {
     if (!e) continue;
-    if (e.isError) hasError = true;
+    if (e.isHardError !== undefined ? e.isHardError : e.isError) hasError = true;
     if (EDIT_TOOLS.has(e.tool)) {
       hasEdit = true;
       for (const f of e.files || []) editedFiles.add(f);

package/lib/compress-core.mjs

@@ -40,6 +40,10 @@ export function selectCompressionCandidates(db, { cutoff, project = null, includ
     FROM observations
     WHERE COALESCE(importance, 1) <= 1
       AND COALESCE(access_count, 0) = 0
+      -- v3.23: exclude rows carrying a real lesson — folding them into a title-only
+      -- weekly summary discards the lesson (the distilled value of a lessons store).
+      -- Mirrors the hook auto-compress lesson guard so neither path buries a lesson.
+      AND (lesson_learned IS NULL OR lesson_learned = '' OR lesson_learned = 'none')
       AND created_at_epoch < ?
       ${compressedFilter}
       ${projectFilter}

package/lib/maintain-core.mjs

@@ -98,6 +98,25 @@ export function recoverChildrenOf(db, ids) {
   ).run(...ids, ...ids).changes;
 }
 
+// Resurface children orphaned by a keeper hard-deleted BEFORE recoverChildrenOf existed
+// (legacy data). recoverChildrenOf only fires at delete time for the keepers being deleted
+// in that call; rows whose keeper vanished in a past release are missed forever. A child
+// with compressed_into = <positive keeperId> whose keeper row no longer exists is hidden
+// from every COALESCE(compressed_into,0)=0 view AND sits in no maintenance queue (not
+// COMPRESSED_AUTO, not COMPRESSED_PENDING_PURGE), so nothing ever resurfaces or GCs it —
+// it leaks its full narrative out of reach. Setting compressed_into = NULL makes it live
+// again; normal decay/GC then handles it on merit. `compressed_into > 0` excludes the
+// negative sentinels (intentional states, not orphans). NON-DESTRUCTIVE: only un-hides
+// rows, never deletes — safe to run unconditionally, no snapshot needed.
+export function recoverOrphanedChildren(db, { projectFilter = '', baseParams = [] } = {}) {
+  return db.prepare(`
+    UPDATE observations SET compressed_into = NULL
+    WHERE compressed_into > 0
+      AND NOT EXISTS (SELECT 1 FROM observations k WHERE k.id = observations.compressed_into)
+      ${projectFilter}
+  `).run(...baseParams).changes;
+}
+
 export function cleanupBroken(db, { projectFilter, baseParams, opCap = OP_CAP }) {
   const doomed = db.prepare(`
     SELECT id FROM observations
@@ -133,6 +152,11 @@ export function decayAndMarkIdle(db, { projectFilter, baseParams, staleAge, opCa
         AND COALESCE(importance, 1) = 1
         AND COALESCE(access_count, 0) = 0
         AND COALESCE(injection_count, 0) = 0
+        -- v3.23: never mark a lesson-bearing row idle→pending-purge. A lesson is the
+        -- distilled value of a lessons store; auto-GC must not silently purge it (parity
+        -- with the compress lesson guards in hook.mjs + compress-core.mjs). Truly stale
+        -- lessons are removed by explicit delete, not background decay.
+        AND (lesson_learned IS NULL OR lesson_learned = '' OR lesson_learned = 'none')
         AND created_at_epoch < ?
         ${projectFilter} LIMIT ${opCap}
     )

package/mem-cli.mjs

@@ -18,6 +18,7 @@ import { selectCompressionCandidates, groupByProjectWeek, compressGroup } from '
 import { buildNotLowSignalSql } from './lib/low-signal-patterns.mjs';
 import {
   cleanupBroken, decayAndMarkIdle, boostAccessed, demotePinned, mergeDuplicates,
+  recoverOrphanedChildren,
   purgeStale, purgeStalePreview, findDuplicates, maintenanceStats, rebuildVectors, vacuum,
   recoverChildrenOf, hardDeleteCandidateCount,
   OP_CAP, STALE_AGE_MS, PINNED_INJ_THRESHOLD,
@@ -1096,9 +1097,17 @@ async function cmdStats(db, args) {
     `SELECT AVG(COALESCE(importance,1)) as v FROM observations WHERE 1=1 ${projectFilter}`
   ).get(...baseParams);
   const thirtyDaysAgo = now - 30 * 86400000;
+  // v3.23 noise-gauge de-blinding: the prior `importance = 1` predicate was
+  // structurally blind to imp=0 — decay's floor + the LLM low-signal filter push
+  // dormant rows to 0, which on a real store is ~half the live corpus. The gauge
+  // therefore reported "0.0% noise" while the store was dormant-heavy. `<= 1` makes
+  // imp=0 visible; injection_count=0 mirrors decay's NEVER-INJECTED guard so an
+  // injected-but-decayed row (pinned noise, tracked separately) is not miscounted
+  // as "never used".
   const lowVal = db.prepare(`
     SELECT COUNT(*) as c FROM observations
-    WHERE COALESCE(importance,1) = 1 AND COALESCE(access_count,0) = 0
+    WHERE COALESCE(importance,1) <= 1 AND COALESCE(access_count,0) = 0
+      AND COALESCE(injection_count,0) = 0
       AND COALESCE(compressed_into, 0) = 0
       AND created_at_epoch < ? ${projectFilter}
   `).get(thirtyDaysAgo, ...baseParams);
@@ -1197,7 +1206,7 @@ async function cmdStats(db, args) {
   out('Data Health:');
   out(`  Est. tokens: ${tokenEst.t ?? 0}`);
   out(`  Avg importance: ${(avgImp.v ?? 1).toFixed(2)}`);
-  out(`  Low-value (imp=1, never accessed, >30d): ${lowVal.c} (${(noiseRatio * 100).toFixed(1)}% noise)`);
+  out(`  Low-value (imp≤1, never used, >30d): ${lowVal.c} (${(noiseRatio * 100).toFixed(1)}% noise)`);
   out(`  Low-signal titles (Modified/Error/Worked on…): ${lowSignalTitle.c} (${(lowSignalRatio * 100).toFixed(1)}%)`);
   out(`  Compressed: ${compressedCount.c}`);
   out(`  Hook errors (last 24h): ${hookErrors24h}${hookErrors24h > 0 ? `  ← tail ${join(DB_DIR, 'runtime/hook-errors')}` : ''}`);
@@ -1944,6 +1953,10 @@ function cmdMaintain(db, args) {
     if (ops.includes('cleanup')) {
       const deleted = cleanupBroken(db, mctx);
       results.push(`Cleaned up ${deleted} broken observations${capHint(deleted)}`);
+      // Self-heal legacy orphans (keeper hard-deleted pre-recoverChildrenOf): resurface
+      // unreachable children. Non-destructive — un-hide only, no delete.
+      const orphans = recoverOrphanedChildren(db, mctx);
+      if (orphans > 0) results.push(`Recovered ${orphans} orphaned compression children`);
     }
 
     if (ops.includes('decay')) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "3.22.0",
+  "version": "3.23.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/server.mjs

@@ -17,6 +17,7 @@ import { resolveAnchorToken, formatAnchorError, resolveQueryAnchor, fetchRecentT
 import { buildSearchFtsQuery, parseDateBounds, coreRunSearchPipeline } from './lib/search-core.mjs';
 import {
   cleanupBroken, decayAndMarkIdle, boostAccessed, demotePinned, mergeDuplicates,
+  recoverOrphanedChildren,
   purgeStale, purgeStalePreview, findDuplicates, maintenanceStats, rebuildVectors, vacuum,
   recoverChildrenOf, hardDeleteCandidateCount,
   OP_CAP, STALE_AGE_MS,
@@ -863,9 +864,14 @@ server.registerTool(
     `).get(...baseParams);
 
     const thirtyDaysAgo = Date.now() - 30 * 86400000;
+    // v3.23 noise-gauge de-blinding (mirrors mem-cli cmdStats): `<= 1` makes the
+    // imp=0 dormant population visible (decay floor + LLM low-signal filter push
+    // ~half the live corpus to 0); injection_count=0 mirrors decay's NEVER-INJECTED
+    // guard so injected-but-decayed pinned noise isn't miscounted as "never used".
     const lowVal = db.prepare(`
       SELECT COUNT(*) as c FROM observations
-      WHERE COALESCE(importance,1) = 1 AND COALESCE(access_count,0) = 0
+      WHERE COALESCE(importance,1) <= 1 AND COALESCE(access_count,0) = 0
+        AND COALESCE(injection_count,0) = 0
         AND COALESCE(compressed_into, 0) = 0
         AND created_at_epoch < ? ${projectFilter}
     `).get(thirtyDaysAgo, ...baseParams);
@@ -915,7 +921,7 @@ server.registerTool(
       'Data Health:',
       `  Est. tokens: ${tokenEst.t ?? 0}`,
       `  Avg importance: ${(avgImp.v ?? 1).toFixed(2)}`,
-      `  Low-value (imp=1, never accessed, >30d): ${lowVal.c} (${(noiseRatio * 100).toFixed(1)}% noise)`,
+      `  Low-value (imp≤1, never used, >30d): ${lowVal.c} (${(noiseRatio * 100).toFixed(1)}% noise)`,
       `  Low-signal titles (Modified/Error/Worked on…): ${lowSignalTitle.c} (${(lowSignalRatio * 100).toFixed(1)}%)`,
       `  Compressed: ${compressedCount.c}`,
       ...((noiseRatio > 0.6 || lowSignalRatio > 0.3) ? ['  ⚠️ High noise ratio — consider running mem_compress / maintain'] : []),
@@ -1109,6 +1115,10 @@ server.registerTool(
         if (ops.includes('cleanup')) {
           const deleted = cleanupBroken(db, mctx);
           results.push(`Cleaned up ${deleted} broken observations` + (deleted >= OP_CAP ? ' (cap reached, re-run for more)' : ''));
+          // Self-heal legacy orphans (keeper hard-deleted pre-recoverChildrenOf):
+          // resurface unreachable children. Non-destructive — un-hide only, no delete.
+          const orphans = recoverOrphanedChildren(db, mctx);
+          if (orphans > 0) results.push(`Recovered ${orphans} orphaned compression children`);
         }
 
         if (ops.includes('decay')) {