claude-mem-lite 2.29.0 → 2.30.0

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "2.29.0",
+      "version": "2.30.0",
       "source": "./",
       "description": "Lightweight persistent memory system for Claude Code — FTS5 search, episode batching, error-triggered recall"
     }

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "2.29.0",
+  "version": "2.30.0",
   "description": "Lightweight persistent memory system for Claude Code — FTS5 search, episode batching, error-triggered recall",
   "author": {
     "name": "sdsrss"

package/cli.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-const CLI_COMMANDS = new Set(['search', 'recent', 'recall', 'get', 'timeline', 'save', 'stats', 'context', 'browse', 'delete', 'update', 'export', 'compress', 'maintain', 'fts-check', 'registry', 'import', 'enrich', 'help']);
+const CLI_COMMANDS = new Set(['search', 'recent', 'recall', 'get', 'timeline', 'save', 'stats', 'context', 'browse', 'delete', 'update', 'export', 'compress', 'maintain', 'optimize', 'fts-check', 'registry', 'import', 'enrich', 'help']);
 const INSTALL_COMMANDS = new Set(['install', 'uninstall', 'status', 'doctor', 'cleanup', 'cleanup-hooks', 'self-update', 'release']);
 
 const cmd = process.argv[2];

package/hook-context.mjs

@@ -1,9 +1,15 @@
 // claude-mem-lite CLAUDE.md context injection and token budgeting
-// Handles adaptive time windows, token-budgeted selection, and CLAUDE.md persistence
+// Handles adaptive time windows, token-budgeted selection, and legacy CLAUDE.md cleanup.
 
-import { join } from 'path';
+import { basename, join } from 'path';
 import { readFileSync, writeFileSync, renameSync, unlinkSync } from 'fs';
-import { estimateTokens, truncate, debugLog, debugCatch, DECAY_HALF_LIFE_BY_TYPE, DEFAULT_DECAY_HALF_LIFE_MS } from './utils.mjs';
+import {
+  estimateTokens, truncate, typeIcon, fmtTime,
+  debugLog, debugCatch,
+  DECAY_HALF_LIFE_BY_TYPE, DEFAULT_DECAY_HALF_LIFE_MS, notLowSignalTitleClause,
+} from './utils.mjs';
+import { STALE_SESSION_MS, FALLBACK_OBS_WINDOW_MS } from './hook-shared.mjs';
+import { extractUnfinishedSummary } from './hook-handoff.mjs';
 
 /**
  * Infer the project directory from environment variables or cwd.
@@ -56,11 +62,15 @@ export function selectWithTokenBudget(db, project, budget = 2000) {
   const tier2Ago = now_ms - windows.tier2;
   const tier3Ago = now_ms - windows.tier3;
 
-  // Candidate pool: tiered time windows by importance (adaptive)
+  // Candidate pool: tiered time windows by importance (adaptive).
+  // R1/R3: exclude LOW_SIGNAL degraded titles ("Modified X", "Worked on X",
+  // "Reviewed N files:", raw error logs) from the Key Context table at
+  // session start — they pollute the visible "Recent" table with noise.
   const obsPool = db.prepare(`
     SELECT id, type, title, narrative, importance, created_at_epoch, files_modified, lesson_learned
     FROM observations
     WHERE project = ? AND COALESCE(compressed_into, 0) = 0
+      AND ${notLowSignalTitleClause('')}
       AND (
         (created_at_epoch > ? AND importance >= 1)
         OR (created_at_epoch > ? AND importance >= 2)
@@ -82,9 +92,11 @@ export function selectWithTokenBudget(db, project, budget = 2000) {
   const selectedSess = [];
   let totalTokens = 0;
 
-  // Type quality multipliers — aligned with scoring-sql.mjs TYPE_QUALITY_CASE
-  // Demotes bugfix (noisy error logs) and promotes high-signal types
-  const TYPE_QUALITY = { decision: 1.5, discovery: 1.3, feature: 1.2, refactor: 1.0, change: 0.8, bugfix: 0.35 };
+  // Type quality multipliers — aligned with scoring-sql.mjs TYPE_QUALITY_CASE (R2).
+  // Weights calibrated from empirical avg access_count per type:
+  //   decision 6.05, discovery 3.32, bugfix 2.24, feature 2.04, change 0.93, refactor 0.54.
+  // Pre-R2 had bugfix=0.35 (inverted vs reality — bugfixes are 2.4× more used than changes).
+  const TYPE_QUALITY = { decision: 1.5, discovery: 1.3, bugfix: 1.1, feature: 1.0, refactor: 0.6, change: 0.5 };
 
   // Score each candidate: value = recency * type_quality * importance, cost = tokens
   // Recency uses exponential half-life (consistent with server.mjs BM25 scoring)
@@ -154,48 +166,217 @@ export function selectWithTokenBudget(db, project, budget = 2000) {
 }
 
 /**
- * Update the project's CLAUDE.md file with a context block.
- * Replaces existing <claude-mem-context> section or appends a new one.
- * Uses atomic tmp+rename write to prevent partial writes.
- * @param {string} contextBlock Markdown content to inject
+ * One-time cleanup of the legacy <claude-mem-context> block from the project's
+ * CLAUDE.md file. Pre-v2.30 the hook wrote a slim context snapshot here on every
+ * session start, causing constant git noise and stale, one-session-behind content.
+ * Context is now delivered exclusively via SessionStart hook stdout.
+ *
+ * Idempotent: if no legacy block (or no CLAUDE.md) exists, it is a no-op. Also
+ * removes the paired hint comment if present, and normalizes residual whitespace
+ * at the seam. Uses atomic tmp+rename write.
  */
-export function updateClaudeMd(contextBlock) {
+export function cleanupClaudeMdLegacyBlock() {
   const claudeMdPath = join(inferProjectDir(), 'CLAUDE.md');
-  let content = '';
-  try { content = readFileSync(claudeMdPath, 'utf8'); } catch {}
+  let content;
+  try { content = readFileSync(claudeMdPath, 'utf8'); } catch { return; }
 
   const startTag = '<claude-mem-context>';
   const endTag = '</claude-mem-context>';
-  const hintComment = '<!-- claude-mem-lite: auto-updated context. To avoid git noise, add CLAUDE.md to .gitignore -->';
-  const newSection = `${startTag}\n${contextBlock}\n${endTag}`;
 
-  // Use lastIndexOf for both tags — prevents matching documentation references
-  // to <claude-mem-context> that appear in code/markdown before the actual context block
+  // Use lastIndexOf so documentation references to the tag earlier in the file
+  // (e.g. inside a code block in architecture notes) are not accidentally swept.
   const startIdx = content.lastIndexOf(startTag);
   const endIdx = content.lastIndexOf(endTag);
+  if (startIdx === -1 || endIdx === -1 || startIdx >= endIdx) return;
 
-  if (startIdx !== -1 && endIdx !== -1 && startIdx < endIdx) {
-    // Skip write if content is unchanged — reduces git noise
-    const existingSection = content.slice(startIdx, endIdx + endTag.length);
-    if (existingSection === newSection) return;
-    // Replace from first start to last end — collapses any duplicate sections into one
-    content = content.slice(0, startIdx) + newSection + content.slice(endIdx + endTag.length);
-  } else if (content.length > 0) {
-    // Append to end — never disturb existing CLAUDE.md structure
-    const hint = content.includes(hintComment) ? '' : hintComment + '\n';
-    content = content.trimEnd() + '\n\n' + hint + newSection + '\n';
-  } else {
-    content = hintComment + '\n' + newSection + '\n';
+  // Extend forward to swallow a trailing newline so we don't leave a stranded blank line.
+  let removeEnd = endIdx + endTag.length;
+  if (content[removeEnd] === '\n') removeEnd += 1;
+
+  // Extend backward if the paired hint comment sits on the line immediately before
+  // the start tag. The hint is the exact string the old updateClaudeMd emitted.
+  let removeStart = startIdx;
+  const hintPattern = '<!-- claude-mem-lite: auto-updated context';
+  const leadingSlice = content.slice(0, startIdx);
+  const hintIdx = leadingSlice.lastIndexOf(hintPattern);
+  if (hintIdx !== -1) {
+    const between = content.slice(hintIdx, startIdx);
+    if (/^<!-- claude-mem-lite: [^\n]*-->\s*$/.test(between)) {
+      removeStart = hintIdx;
+    }
   }
 
+  // Swallow a single preceding newline to avoid leaving a blank-line gap behind.
+  if (removeStart > 0 && content[removeStart - 1] === '\n') removeStart -= 1;
+
+  const cleaned = content.slice(0, removeStart) + content.slice(removeEnd);
+  // Collapse any ≥3 consecutive newlines to two, then ensure exactly one trailing newline.
+  const normalized = cleaned.replace(/\n{3,}/g, '\n\n').replace(/\s*$/, '\n');
+
+  if (normalized === content) return;
+
   const tmp = claudeMdPath + '.mem-tmp';
   try {
-    writeFileSync(tmp, content);
+    writeFileSync(tmp, normalized);
     renameSync(tmp, claudeMdPath);
   } catch (e) {
     try { unlinkSync(tmp); } catch {}
-    debugLog('ERROR', 'updateClaudeMd', `CLAUDE.md write failed: ${e.message}`);
+    debugLog('ERROR', 'cleanupClaudeMdLegacyBlock', `CLAUDE.md write failed: ${e.message}`);
+  }
+}
+
+/**
+ * Assemble the full markdown body that goes inside the <claude-mem-context>
+ * block emitted at session start. Same shape as the inline builder hook.mjs
+ * used to compose directly; extracted so both the SessionStart hook AND the
+ * `claude-mem-lite context` CLI can read live context from the DB.
+ *
+ * Sections (in order):
+ *   1. Last Session (from session_summaries.latest)
+ *   2. File Lessons / Key Context (top importance≥2 observations)
+ *   3. Recent Activity fallback (when no summary and no key obs)
+ *   4. Working State (from latest clear handoff)
+ *   5. Recent (N) table (observations via selectWithTokenBudget + fallback)
+ *
+ * @param {import('better-sqlite3').Database} db Opened main DB
+ * @param {string} project Canonical project name (from inferProject())
+ * @param {Date} [now=new Date()] Clock reference for time windows and table header
+ * @returns {string} Joined markdown lines (without <claude-mem-context> wrappers)
+ */
+export function buildSessionContextLines(db, project, now = new Date()) {
+  // 1. Token-budgeted observation selection
+  const selected = selectWithTokenBudget(db, project, 2000);
+  const observations = selected.observations;
+
+  // 2. Fallback: recent across all projects with tiered windows (when local pool is thin)
+  let fallbackObs = [];
+  if (observations.length < 3) {
+    const fbOneDayAgo = now.getTime() - STALE_SESSION_MS;
+    const fbSevenDaysAgo = now.getTime() - FALLBACK_OBS_WINDOW_MS;
+    fallbackObs = db.prepare(`
+      SELECT id, type, title, project, created_at
+      FROM observations
+      WHERE COALESCE(compressed_into, 0) = 0
+        AND (
+          (created_at_epoch > ? AND importance >= 1)
+          OR (created_at_epoch > ? AND importance >= 2)
+        )
+      ORDER BY created_at_epoch DESC
+      LIMIT 5
+    `).all(fbOneDayAgo, fbSevenDaysAgo);
+  }
+
+  // 3. Latest session summary → base summaryLines
+  const latestSummary = db.prepare(`
+    SELECT request, completed, next_steps, remaining_items, lessons, key_decisions, created_at
+    FROM session_summaries
+    WHERE project = ?
+    ORDER BY created_at_epoch DESC
+    LIMIT 1
+  `).get(project);
+
+  const summaryLines = buildSummaryLines(latestSummary);
+
+  // 4. Key context: top high-importance observations split into File Lessons (actionable)
+  //    and Key Context (informational). Pushed into summaryLines.
+  const keyObs = db.prepare(`
+    SELECT o.id, o.type, o.title, o.lesson_learned, o.files_modified FROM observations o
+    WHERE o.project = ? AND COALESCE(o.compressed_into, 0) = 0
+      AND o.superseded_at IS NULL
+      AND COALESCE(o.importance, 1) >= 2
+    ORDER BY o.created_at_epoch DESC LIMIT 10
+  `).all(project);
+
+  if (keyObs.length > 0) {
+    const fileLessons = [];
+    const keyContext = [];
+
+    for (const o of keyObs) {
+      const clean = (o.title || '(untitled)')
+        .replace(/ → (?:ERROR: )?\{".*$/, '')
+        .replace(/ → (?:ERROR: )?\{[^}]*\.{3}$/, '');
+      const hasLesson = o.lesson_learned && o.lesson_learned.trim();
+      const hasFiles = o.files_modified && o.files_modified !== '[]';
+
+      if (hasLesson && hasFiles) {
+        try {
+          const files = JSON.parse(o.files_modified);
+          const fname = basename(Array.isArray(files) && files.length > 0 ? files[0] : '');
+          if (fname) {
+            fileLessons.push(`- ${fname}: ${truncate(o.lesson_learned, 100)} (#${o.id})`);
+            continue;
+          }
+        } catch { /* fall through to keyContext */ }
+      }
+      const lesson = hasLesson ? ` — ${truncate(o.lesson_learned, 60)}` : '';
+      keyContext.push(`- [${o.type || 'discovery'}] ${truncate(clean, 80)} (#${o.id})${lesson}`);
+    }
+
+    if (fileLessons.length > 0) {
+      summaryLines.push('### File Lessons');
+      summaryLines.push(...fileLessons.slice(0, 5));
+      summaryLines.push('');
+    }
+    if (keyContext.length > 0) {
+      summaryLines.push('### Key Context');
+      summaryLines.push(...keyContext.slice(0, 5));
+      summaryLines.push('');
+    }
+  } else if (!latestSummary) {
+    // Fallback: no summary AND no key observations — show recent activity
+    const recentObs = (observations.length >= 3 ? observations : fallbackObs).slice(0, 3);
+    if (recentObs.length > 0) {
+      summaryLines.push('### Recent Activity');
+      for (const o of recentObs) {
+        summaryLines.push(`- ${truncate(o.title || '(untitled)', 80)}`);
+      }
+      summaryLines.push('');
+    }
   }
+
+  // 5. Working state from latest /clear handoff
+  const prevClearHandoff = db.prepare(`
+    SELECT working_on, unfinished, key_files
+    FROM session_handoffs
+    WHERE project = ? AND type = 'clear'
+    ORDER BY created_at_epoch DESC LIMIT 1
+  `).get(project);
+
+  const handoffLines = [];
+  if (prevClearHandoff) {
+    handoffLines.push('### Working State (from /clear)');
+    if (prevClearHandoff.working_on) {
+      handoffLines.push(`- Working on: ${truncate(prevClearHandoff.working_on, 200)}`);
+    }
+    if (prevClearHandoff.unfinished) {
+      const pendingSummary = extractUnfinishedSummary(prevClearHandoff.unfinished);
+      if (pendingSummary) handoffLines.push(`- Unfinished: ${truncate(pendingSummary, 200)}`);
+    }
+    if (prevClearHandoff.key_files) {
+      try {
+        const files = JSON.parse(prevClearHandoff.key_files);
+        if (files.length > 0) handoffLines.push(`- Key files: ${files.map(f => basename(f)).join(', ')}`);
+      } catch { /* malformed JSON — skip */ }
+    }
+    handoffLines.push('');
+  }
+
+  // 6. Recent observations table
+  const obsLines = [];
+  const obsToShow = observations.length >= 3 ? observations : fallbackObs;
+  if (obsToShow.length > 0) {
+    const today = now.toISOString().slice(0, 10);
+    obsLines.push(`### Recent (${today})`);
+    obsLines.push('');
+    obsLines.push('| ID | Time | T | Title |');
+    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} |`);
+    }
+  }
+
+  return [...summaryLines, ...handoffLines, ...obsLines].join('\n');
 }
 
 /**

package/hook-memory.mjs

@@ -1,13 +1,15 @@
 // claude-mem-lite — Semantic Memory Injection
 // Search past observations for relevant memories to inject as context at user-prompt time.
 
-import { sanitizeFtsQuery, relaxFtsQueryToOr, debugCatch, OBS_BM25 } from './utils.mjs';
+import { sanitizeFtsQuery, relaxFtsQueryToOr, debugCatch, OBS_BM25, notLowSignalTitleClause } from './utils.mjs';
 
 const MAX_MEMORY_INJECTIONS = 3;
 const MEMORY_LOOKBACK_MS = 60 * 86400000; // 60 days
-// Aligned with TYPE_QUALITY_CASE: high-signal types > noisy types
-// Bugfix raised from 0.5→0.75 to match scoring-sql.mjs; lesson_learned boost (1.5×) stacks
-const MEMORY_TYPE_BOOST = { decision: 1.5, discovery: 1.3, feature: 1.2, refactor: 1.0, change: 0.8, bugfix: 0.75 };
+// Aligned with TYPE_QUALITY_CASE in scoring-sql.mjs (R2 rebalance).
+// Weights calibrated to empirical avg access_count:
+//   decision 6.05, discovery 3.32, bugfix 2.24, feature 2.04, change 0.93, refactor 0.54.
+// lesson_learned boost (1.5×) stacks for entries with a real takeaway.
+const MEMORY_TYPE_BOOST = { decision: 1.5, discovery: 1.3, bugfix: 1.1, feature: 1.0, refactor: 0.6, change: 0.5 };
 // 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 };
@@ -37,6 +39,9 @@ export function searchRelevantMemories(db, userPrompt, project, excludeIds = [])
     const excludeSet = new Set(excludeIds);
 
     // Phase 1: Same-project search (highest priority)
+    // R1: notLowSignalTitleClause() excludes hook-llm fallback titles
+    // ("Modified X", "Worked on X", "Reviewed N files:", raw error logs, etc.)
+    // that almost never get referenced (3.3% access rate) but compete for BM25 rank.
     const selectStmt = db.prepare(`
       SELECT o.id, o.type, o.title, o.importance, o.lesson_learned, o.project,
              ${OBS_BM25} as relevance
@@ -48,6 +53,7 @@ export function searchRelevantMemories(db, userPrompt, project, excludeIds = [])
         AND o.created_at_epoch > ?
         AND COALESCE(o.compressed_into, 0) = 0
         AND o.superseded_at IS NULL
+        AND ${notLowSignalTitleClause('o')}
       ORDER BY ${OBS_BM25}
       LIMIT 10
     `);
@@ -84,6 +90,7 @@ export function searchRelevantMemories(db, userPrompt, project, excludeIds = [])
           AND o.created_at_epoch > ?
           AND COALESCE(o.compressed_into, 0) = 0
           AND o.superseded_at IS NULL
+          AND ${notLowSignalTitleClause('o')}
         ORDER BY ${OBS_BM25}
         LIMIT 5
       `);

package/hook.mjs

@@ -5,13 +5,13 @@
 // Background workers (slow): llm-episode, llm-summary
 
 import { randomUUID } from 'crypto';
-import { join, basename } from 'path';
+import { join } from 'path';
 import { readFileSync, writeFileSync, unlinkSync, readdirSync, renameSync, statSync } from 'fs';
 import { homedir } from 'os';
 import {
-  truncate, typeIcon, inferProject, detectBashSignificance,
+  truncate, inferProject, detectBashSignificance,
   extractErrorKeywords, extractFilePaths, isRelatedToEpisode,
-  makeEntryDesc, scrubSecrets, EDIT_TOOLS, debugCatch, debugLog, fmtTime,
+  makeEntryDesc, scrubSecrets, EDIT_TOOLS, debugCatch, debugLog,
   COMPRESSED_AUTO, COMPRESSED_PENDING_PURGE, isoWeekKey, OBS_BM25,
 } from './utils.mjs';
 import {
@@ -20,10 +20,10 @@ import {
   createEpisode, addFileToEpisode,
   writePendingEntry, mergePendingEntries, episodeHasSignificantContent,
 } from './hook-episode.mjs';
-import { selectWithTokenBudget, updateClaudeMd, buildSummaryLines } from './hook-context.mjs';
+import { cleanupClaudeMdLegacyBlock, buildSessionContextLines } from './hook-context.mjs';
 import {
   RUNTIME_DIR, EPISODE_BUFFER_SIZE, EPISODE_TIME_GAP_MS,
-  SESSION_EXPIRY_MS, STALE_SESSION_MS, STALE_LOCK_MS, FALLBACK_OBS_WINDOW_MS,
+  SESSION_EXPIRY_MS, STALE_SESSION_MS, STALE_LOCK_MS,
   sessionFile, getSessionId, createSessionId, openDb,
   spawnBackground,
 } from './hook-shared.mjs';
@@ -555,7 +555,7 @@ async function handleSessionStart() {
         // Mark maintenance as done (24h gate) — even though compression runs in background
         writeFileSync(maintainFile, JSON.stringify({ epoch: Date.now() }));
         // Weekly summary grouping runs in background to avoid blocking SessionStart
-        spawnBackground('auto-compress');
+        if (!process.env.CLAUDE_MEM_SKIP_COMPRESS) spawnBackground('auto-compress');
         if (!process.env.CLAUDE_MEM_SKIP_OPTIMIZE) spawnBackground('llm-optimize');
       } catch (e) { debugCatch(e, 'auto-maintain'); }
     }
@@ -645,28 +645,6 @@ async function handleSessionStart() {
       }
     } catch {}
 
-    // Token-budgeted observation selection (replaces flat LIMIT 15)
-    const selected = selectWithTokenBudget(db, project, 2000);
-    const observations = selected.observations;
-
-    // Fallback: recent across all projects with tiered windows (M7: local variable for clarity)
-    let fallbackObs = [];
-    if (observations.length < 3) {
-      const fbOneDayAgo = Date.now() - STALE_SESSION_MS;
-      const fbSevenDaysAgo = Date.now() - FALLBACK_OBS_WINDOW_MS;
-      fallbackObs = db.prepare(`
-        SELECT id, type, title, project, created_at
-        FROM observations
-        WHERE COALESCE(compressed_into, 0) = 0
-          AND (
-            (created_at_epoch > ? AND importance >= 1)
-            OR (created_at_epoch > ? AND importance >= 2)
-          )
-        ORDER BY created_at_epoch DESC
-        LIMIT 5
-      `).all(fbOneDayAgo, fbSevenDaysAgo);
-    }
-
     // Fallback fast summary: if a recently completed session has no summary yet
     // (e.g. /exit → fast restart before Haiku finishes), build one synchronously.
     // Skipped when prevSessionId is set (already handled above).
@@ -708,114 +686,19 @@ async function handleSessionStart() {
       } catch (e) { debugCatch(e, 'session-start-exit-fast-summary'); }
     }
 
-    // Latest session summary
-    const latestSummary = db.prepare(`
-      SELECT request, completed, next_steps, remaining_items, lessons, key_decisions, created_at
-      FROM session_summaries
-      WHERE project = ?
-      ORDER BY created_at_epoch DESC
-      LIMIT 1
-    `).get(project);
-
-    // Build summary lines (shared by stdout and CLAUDE.md)
-    const summaryLines = buildSummaryLines(latestSummary);
-
-    // Key context: top high-importance observations for CLAUDE.md persistence
-    // Split into "File Lessons" (actionable, has lesson + file) and "Key Context" (informational)
-    const keyObs = db.prepare(`
-      SELECT o.id, o.type, o.title, o.lesson_learned, o.files_modified FROM observations o
-      WHERE o.project = ? AND COALESCE(o.compressed_into, 0) = 0
-        AND o.superseded_at IS NULL
-        AND COALESCE(o.importance, 1) >= 2
-      ORDER BY o.created_at_epoch DESC LIMIT 10
-    `).all(project);
-
-    if (keyObs.length > 0) {
-      const fileLessons = [];
-      const keyContext = [];
-
-      for (const o of keyObs) {
-        const clean = (o.title || '(untitled)')
-          .replace(/ → (?:ERROR: )?\{".*$/, '')
-          .replace(/ → (?:ERROR: )?\{[^}]*\.{3}$/, '');
-        const hasLesson = o.lesson_learned && o.lesson_learned.trim();
-        const hasFiles = o.files_modified && o.files_modified !== '[]';
-
-        if (hasLesson && hasFiles) {
-          try {
-            const files = JSON.parse(o.files_modified);
-            const fname = basename(Array.isArray(files) && files.length > 0 ? files[0] : '');
-            if (fname) {
-              fileLessons.push(`- ${fname}: ${truncate(o.lesson_learned, 100)} (#${o.id})`);
-              continue;
-            }
-          } catch {}
-        }
-        const lesson = hasLesson ? ` — ${truncate(o.lesson_learned, 60)}` : '';
-        keyContext.push(`- [${o.type || 'discovery'}] ${truncate(clean, 80)} (#${o.id})${lesson}`);
-      }
-
-      if (fileLessons.length > 0) {
-        summaryLines.push('### File Lessons');
-        summaryLines.push(...fileLessons.slice(0, 5));
-        summaryLines.push('');
-      }
-      if (keyContext.length > 0) {
-        summaryLines.push('### Key Context');
-        summaryLines.push(...keyContext.slice(0, 5));
-        summaryLines.push('');
-      }
-    } else if (!latestSummary) {
-      // Fallback: no summary AND no key observations — show recent activity
-      const recentObs = (observations.length >= 3 ? observations : fallbackObs).slice(0, 3);
-      if (recentObs.length > 0) {
-        summaryLines.push('### Recent Activity');
-        for (const o of recentObs) {
-          summaryLines.push(`- ${truncate(o.title || '(untitled)', 80)}`);
-        }
-        summaryLines.push('');
-      }
-    }
-
-    // Working state from /clear handoff (persisted to both stdout and CLAUDE.md)
-    const handoffLines = [];
-    if (prevClearHandoff) {
-      handoffLines.push('### Working State (from /clear)');
-      if (prevClearHandoff.working_on) handoffLines.push(`- Working on: ${truncate(prevClearHandoff.working_on, 200)}`);
-      if (prevClearHandoff.unfinished) {
-        const pendingSummary = extractUnfinishedSummary(prevClearHandoff.unfinished);
-        if (pendingSummary) handoffLines.push(`- Unfinished: ${truncate(pendingSummary, 200)}`);
-      }
-      if (prevClearHandoff.key_files) {
-        try {
-          const files = JSON.parse(prevClearHandoff.key_files);
-          if (files.length > 0) handoffLines.push(`- Key files: ${files.map(f => basename(f)).join(', ')}`);
-        } catch {}
-      }
-      handoffLines.push('');
-    }
-
-    // Build observations table (stdout only — not persisted to CLAUDE.md)
-    const obsLines = [];
-    const obsToShow = observations.length >= 3 ? observations : fallbackObs;
-    if (obsToShow.length > 0) {
-      const today = now.toISOString().slice(0, 10);
-      obsLines.push(`### Recent (${today})`);
-      obsLines.push('');
-      obsLines.push('| ID | Time | T | Title |');
-      obsLines.push('|----|------|---|-------|');
-      for (const o of obsToShow) {
-        const proj = o.project ? ` (${o.project})` : '';
-        obsLines.push(`| #${o.id} | ${fmtTime(o.created_at)} | ${typeIcon(o.type)} | ${truncate(o.title || '(untitled)', 60)}${proj} |`);
-      }
-    }
+    // Build the full context body via shared helper (also used by `mem-cli context`).
+    // Queries session_summaries, key observations, clear handoff, and the
+    // token-budgeted observation pool directly from the DB.
+    const fullContext = buildSessionContextLines(db, project, now);
 
-    // Stdout: full context (summary + handoff state + observations table)
-    const fullContext = [...summaryLines, ...handoffLines, ...obsLines].join('\n');
+    // Stdout is the sole context-delivery channel. The SessionStart hook output
+    // is injected as a <system-reminder> at session start, giving Claude the
+    // full summary + handoff state + observations table fresh from the DB.
     process.stdout.write(`<claude-mem-context>\n${fullContext}\n</claude-mem-context>\n`);
 
-    // CLAUDE.md: slim (summary + handoff state — observations already in stdout)
-    updateClaudeMd([...summaryLines, ...handoffLines].join('\n'));
+    // One-time migration: remove any stale <claude-mem-context> block left in
+    // CLAUDE.md by pre-v2.30 installs. Idempotent no-op afterwards.
+    cleanupClaudeMdLegacyBlock();
 
     // Pre-load TF-IDF vocabulary cache for this session (from DB, ~1ms)
     try { getVocabulary(db); } catch (e) { debugCatch(e, 'session-start-vocab'); }

package/mem-cli.mjs

@@ -4,7 +4,7 @@
 
 import { homedir } from 'os';
 import { ensureDb, DB_PATH, REGISTRY_DB_PATH, checkFTSIntegrity, rebuildFTS } from './schema.mjs';
-import { sanitizeFtsQuery, relaxFtsQueryToOr, truncate, typeIcon, inferProject, jaccardSimilarity, computeMinHash, estimateJaccardFromMinHash, scrubSecrets, cjkBigrams, isoWeekKey, COMPRESSED_PENDING_PURGE, OBS_BM25, SESS_BM25, TYPE_DECAY_CASE, TYPE_QUALITY_CASE, DEFAULT_DECAY_HALF_LIFE_MS, getCurrentBranch } from './utils.mjs';
+import { sanitizeFtsQuery, relaxFtsQueryToOr, truncate, typeIcon, inferProject, jaccardSimilarity, computeMinHash, estimateJaccardFromMinHash, scrubSecrets, cjkBigrams, isoWeekKey, COMPRESSED_PENDING_PURGE, OBS_BM25, SESS_BM25, TYPE_DECAY_CASE, TYPE_QUALITY_CASE, DEFAULT_DECAY_HALF_LIFE_MS, getCurrentBranch, notLowSignalTitleClause, LOW_SIGNAL_TITLE } from './utils.mjs';
 import { extractCjkLikePatterns } from './nlp.mjs';
 import { resolveProject } from './project-utils.mjs';
 import { computeTier, TIER_CASE_SQL, tierSqlParams } from './tier.mjs';
@@ -13,7 +13,8 @@ import { autoBoostIfNeeded, reRankWithContext, markSuperseded, extractPRFTerms,
 import { ensureRegistryDb, upsertResource } from './registry.mjs';
 import { searchResources } from './registry-retriever.mjs';
 import { optimizePreview, optimizeRun } from './hook-optimize.mjs';
-import { basename, join } from 'path';
+import { buildSessionContextLines } from './hook-context.mjs';
+import { basename } from 'path';
 import { readFileSync } from 'fs';
 
 // OBS_BM25, TYPE_DECAY_CASE imported from utils.mjs
@@ -81,7 +82,7 @@ function cmdSearch(db, args) {
   const { positional, flags } = parseArgs(args);
   const query = positional.join(' ');
   if (!query) {
-    fail('[mem] Usage: mem search <query> [--type TYPE] [--source SOURCE] [--limit N] [--project P] [--from DATE] [--to DATE] [--importance N] [--branch B] [--offset N] [--sort relevance|time|importance]');
+    fail('[mem] Usage: mem search <query> [--type TYPE] [--source SOURCE] [--limit N] [--project P] [--from DATE] [--to DATE] [--importance N] [--branch B] [--offset N] [--sort relevance|time|importance] [--include-noise]');
     return;
   }
 
@@ -118,6 +119,10 @@ function cmdSearch(db, args) {
     return;
   }
   const useOr = flags.or === true || flags.or === 'true';
+  // R-1: opt-in flag to surface hook-llm fallback titles ("Modified X", "Worked on X", raw
+  // error logs, etc.) which are otherwise filtered from default search. Use for auditing or
+  // when explicitly searching for a file/command that produced a degraded title.
+  const includeNoise = flags['include-noise'] === true || flags['include-noise'] === 'true';
 
   if (source && !['observations', 'sessions', 'prompts'].includes(source)) {
     fail(`[mem] Invalid --source "${source}". Use: observations, sessions, prompts`);
@@ -144,11 +149,11 @@ function cmdSearch(db, args) {
 
   // Search observations
   if (!effectiveSource || effectiveSource === 'observations') {
-    let obsRows = searchFts(db, ftsQuery, { type, project, limit, dateFrom, dateTo, minImportance, branch, offset: effectiveSource ? offset : 0 });
+    let obsRows = searchFts(db, ftsQuery, { type, project, limit, dateFrom, dateTo, minImportance, branch, includeNoise, offset: effectiveSource ? offset : 0 });
     if (obsRows.length === 0) {
       const orQuery = relaxFtsQueryToOr(ftsQuery);
       if (orQuery) {
-        try { obsRows = searchFts(db, orQuery, { type, project, limit, dateFrom, dateTo, minImportance, branch, offset: effectiveSource ? offset : 0 }); } catch {}
+        try { obsRows = searchFts(db, orQuery, { type, project, limit, dateFrom, dateTo, minImportance, branch, includeNoise, offset: effectiveSource ? offset : 0 }); } catch {}
       }
     }
     // Type-list fallback
@@ -179,7 +184,7 @@ function cmdSearch(db, args) {
       if (expanded.length > 0) {
         const expansionFts = expanded.map(c => `"${c.replace(/"/g, '""')}"`).join(' OR ');
         try {
-          const expRows = searchFts(db, expansionFts, { type, project, limit, dateFrom, dateTo, minImportance, branch, offset: 0 });
+          const expRows = searchFts(db, expansionFts, { type, project, limit, dateFrom, dateTo, minImportance, branch, includeNoise, offset: 0 });
           for (const r of expRows) {
             if (!existingIds.has(r.id)) {
               existingIds.add(r.id);
@@ -202,7 +207,7 @@ function cmdSearch(db, args) {
         if (prfTerms.length > 0) {
           const prfFts = prfTerms.map(t => `"${t.replace(/"/g, '""')}"`).join(' OR ');
           try {
-            const prfRows = searchFts(db, prfFts, { type, project, limit, dateFrom, dateTo, minImportance, branch, offset: 0 });
+            const prfRows = searchFts(db, prfFts, { type, project, limit, dateFrom, dateTo, minImportance, branch, includeNoise, offset: 0 });
             for (const r of prfRows) {
               if (!existingIds.has(r.id)) {
                 existingIds.add(r.id);
@@ -378,7 +383,7 @@ function cmdSearch(db, args) {
   }
 }
 
-function searchFts(db, ftsQuery, { type, project, limit, dateFrom, dateTo, minImportance, branch, offset }) {
+function searchFts(db, ftsQuery, { type, project, limit, dateFrom, dateTo, minImportance, branch, includeNoise, offset }) {
   const now = Date.now();
   // Current project for boost (2× when no explicit project filter)
   const currentProject = !project ? inferProject() : null;
@@ -396,12 +401,18 @@ function searchFts(db, ftsQuery, { type, project, limit, dateFrom, dateTo, minIm
   if (dateTo) { wheres.push('o.created_at_epoch <= ?'); whereParams.push(dateTo); }
   if (minImportance) { wheres.push('COALESCE(o.importance, 1) >= ?'); whereParams.push(minImportance); }
   if (branch) { wheres.push('o.branch = ?'); whereParams.push(branch); }
+  // R-1: exclude hook-llm fallback titles ("Modified X", "Worked on X", raw error logs)
+  // from default search. They compete for BM25 rank but have ~3% access rate. Mirrors the
+  // filter already applied in hook-memory.mjs, hook-context.mjs, and user-prompt-search.js.
+  // Use --include-noise to audit them.
+  if (!includeNoise) wheres.push(notLowSignalTitleClause('o'));
 
   // Param order: SELECT scoring (now, proj, proj) → WHERE (ftsQuery, filters...) → ORDER BY scoring (now, proj, proj) → LIMIT/OFFSET
   const scoreParams = [now, currentProject, currentProject];
   const params = [...scoreParams, ...whereParams, ...scoreParams, limit, offset || 0];
 
-  // Scoring aligned with server.mjs: BM25 × type-decay × type-quality × project_boost × importance × access_bonus
+  // Scoring aligned with server.mjs: BM25 × type-decay × type-quality × project_boost × importance × access_bonus × lesson-boost
+  // R-3: lesson_learned presence adds a +0.3 multiplier (empirical: +6.3pp hit-rate lift on bugfix).
   const ftsRows = db.prepare(`
     SELECT o.id, o.type, o.title, o.subtitle, o.created_at, o.created_at_epoch, o.lesson_learned,
            o.files_modified, o.importance,
@@ -410,7 +421,8 @@ function searchFts(db, ftsQuery, { type, project, limit, dateFrom, dateTo, minIm
              * ${TYPE_QUALITY_CASE}
              * (CASE WHEN ? IS NOT NULL AND o.project = ? THEN 2.0 ELSE 1.0 END)
              * (0.5 + 0.5 * COALESCE(o.importance, 1))
-             * (1.0 + 0.1 * LN(1 + COALESCE(o.access_count, 0))) as score
+             * (1.0 + 0.1 * LN(1 + COALESCE(o.access_count, 0)))
+             * (1.0 + 0.3 * (o.lesson_learned IS NOT NULL)) as score
     FROM observations_fts
     JOIN observations o ON observations_fts.rowid = o.id
     WHERE ${wheres.join(' AND ')}
@@ -420,6 +432,7 @@ function searchFts(db, ftsQuery, { type, project, limit, dateFrom, dateTo, minIm
       * (CASE WHEN ? IS NOT NULL AND o.project = ? THEN 2.0 ELSE 1.0 END)
       * (0.5 + 0.5 * COALESCE(o.importance, 1))
       * (1.0 + 0.1 * LN(1 + COALESCE(o.access_count, 0)))
+      * (1.0 + 0.3 * (o.lesson_learned IS NOT NULL))
     LIMIT ? OFFSET ?
   `).all(...params);
 
@@ -447,6 +460,9 @@ function searchFts(db, ftsQuery, { type, project, limit, dateFrom, dateTo, minIm
                 if (dateTo && obs.created_at_epoch > dateTo) continue;
                 if (minImportance && (obs.importance ?? 1) < minImportance) continue;
                 if (branch && obs.branch !== branch) continue;
+                // R-1: LOW_SIGNAL filter also applies to vector-side additions (the SQL
+                // clause only filtered the FTS5 side) so RRF can't re-admit noise.
+                if (!includeNoise && obs.title && LOW_SIGNAL_TITLE.test(obs.title)) continue;
                 rowMap.set(vr.id, obs);
               }
             }
@@ -464,6 +480,7 @@ function searchFts(db, ftsQuery, { type, project, limit, dateFrom, dateTo, minIm
               if (dateTo && obs.created_at_epoch > dateTo) return false;
               if (minImportance && (obs.importance ?? 1) < minImportance) return false;
               if (branch && obs.branch !== branch) return false;
+              if (!includeNoise && obs.title && LOW_SIGNAL_TITLE.test(obs.title)) return false;
               return true;
             })
             .slice(0, limit);
@@ -855,10 +872,153 @@ function cmdSave(db, args) {
   out(`[mem] Saved #${result.lastInsertRowid} [${type}] "${truncate(safeTitle, 80)}" (project: ${project})`);
 }
 
+// N-1: Quality-focused stats for R-2 A/B baseline.
+//
+// Shows the five numbers that will tell us whether the Haiku prompt change is
+// working: lesson_learned rate, LOW_SIGNAL title rate, per-type hit% and lesson%,
+// and current-vs-target deltas. Designed to be eyeballed once a day during the
+// A/B rollout. All metrics respect --project and --days filters.
+//
+// Targets (aspirational, not enforced):
+//   - Lesson rate ≥ 15%      (current baseline ~4.4%)
+//   - LOW_SIGNAL rate ≤ 30%  (current baseline ~49.4%)
+function renderQualityReport(db, { project, days }) {
+  const projectFilter = project ? 'AND project = ?' : '';
+  const baseParams = project ? [project] : [];
+  const now = Date.now();
+  const cutoff = now - days * 86400000;
+
+  // LOW_SIGNAL is the inverse of notLowSignalTitleClause() — inline a SUM(CASE)
+  // that flips the sign so we count titles that DO match the LOW_SIGNAL regex.
+  const lowSignalIsMatchExpr = `NOT ${notLowSignalTitleClause('')}`;
+
+  // Unresolved-bugfix detection: narrative-text proxies for "investigation in progress,
+  // never reached a fix". Heuristic — false positives possible (e.g. a real lesson noting
+  // "the bug persists in legacy clients"), but the directional signal is what we care about.
+  // R-7 micro-experiment surfaced this pollution: ~3/5 of randomly-sampled bugfix narratives
+  // explicitly ended with "root cause not yet identified".
+  const unresolvedNarrativeExpr = `(
+    LOWER(COALESCE(narrative,'')) LIKE '%not yet identified%'
+    OR LOWER(COALESCE(narrative,'')) LIKE '%not yet resolved%'
+    OR LOWER(COALESCE(narrative,'')) LIKE '%not yet fixed%'
+    OR LOWER(COALESCE(narrative,'')) LIKE '%root cause not%'
+    OR LOWER(COALESCE(narrative,'')) LIKE '%still fail%'
+    OR LOWER(COALESCE(narrative,'')) LIKE '%errors persisted%'
+    OR LOWER(COALESCE(narrative,'')) LIKE '%persisted on retry%'
+  )`;
+
+  // In-window aggregates
+  const windowRow = db.prepare(`
+    SELECT
+      COUNT(*) as total,
+      SUM(CASE WHEN lesson_learned IS NOT NULL AND lesson_learned != '' THEN 1 ELSE 0 END) as with_lesson,
+      SUM(CASE WHEN ${lowSignalIsMatchExpr} THEN 1 ELSE 0 END) as low_signal,
+      SUM(CASE WHEN type = 'bugfix' THEN 1 ELSE 0 END) as bugfix_total,
+      SUM(CASE WHEN type = 'bugfix' AND ${unresolvedNarrativeExpr} THEN 1 ELSE 0 END) as bugfix_unresolved
+    FROM observations
+    WHERE created_at_epoch >= ? ${projectFilter}
+  `).get(cutoff, ...baseParams);
+
+  // All-time aggregates (context for recent numbers)
+  const allTimeRow = db.prepare(`
+    SELECT
+      COUNT(*) as total,
+      SUM(CASE WHEN lesson_learned IS NOT NULL AND lesson_learned != '' THEN 1 ELSE 0 END) as with_lesson,
+      SUM(CASE WHEN ${lowSignalIsMatchExpr} THEN 1 ELSE 0 END) as low_signal
+    FROM observations
+    WHERE 1=1 ${projectFilter}
+  `).get(...baseParams);
+
+  // Per-type: count, hit rate (access_count > 0), lesson rate
+  const typeRows = db.prepare(`
+    SELECT
+      type,
+      COUNT(*) as total,
+      SUM(CASE WHEN COALESCE(access_count, 0) > 0 THEN 1 ELSE 0 END) as accessed,
+      SUM(CASE WHEN lesson_learned IS NOT NULL AND lesson_learned != '' THEN 1 ELSE 0 END) as with_lesson
+    FROM observations
+    WHERE created_at_epoch >= ? ${projectFilter}
+    GROUP BY type
+    ORDER BY total DESC
+  `).all(cutoff, ...baseParams);
+
+  // Top-5 most-accessed lessons (all-time, this project scope)
+  const topLessons = db.prepare(`
+    SELECT id, type, title, lesson_learned, COALESCE(access_count, 0) as ac
+    FROM observations
+    WHERE lesson_learned IS NOT NULL AND lesson_learned != ''
+      AND COALESCE(access_count, 0) > 0
+      AND COALESCE(compressed_into, 0) = 0
+      ${projectFilter}
+    ORDER BY ac DESC
+    LIMIT 5
+  `).all(...baseParams);
+
+  const pct = (n, d) => d > 0 ? (100 * n / d).toFixed(1) : '0.0';
+  const scope = project ? ` — ${project}` : '';
+  out(`[mem] Quality snapshot${scope} — window: ${days}d`);
+  out('────────────────────────────────────────────────────');
+  out(`  Writes (${days}d):     ${windowRow.total} observations`);
+
+  const lessonPct = pct(windowRow.with_lesson, windowRow.total);
+  const allLessonPct = pct(allTimeRow.with_lesson, allTimeRow.total);
+  out(`  Lesson rate:      ${windowRow.with_lesson} / ${windowRow.total} (${lessonPct}%)    [all-time: ${allTimeRow.with_lesson} / ${allTimeRow.total} = ${allLessonPct}%]`);
+
+  const noisePct = pct(windowRow.low_signal, windowRow.total);
+  const allNoisePct = pct(allTimeRow.low_signal, allTimeRow.total);
+  out(`  LOW_SIGNAL:       ${windowRow.low_signal} / ${windowRow.total} (${noisePct}%)    [all-time: ${allTimeRow.low_signal} / ${allTimeRow.total} = ${allNoisePct}%]`);
+
+  if (windowRow.bugfix_total > 0) {
+    const unresolvedPct = pct(windowRow.bugfix_unresolved, windowRow.bugfix_total);
+    out(`  Unresolved bugfix: ${windowRow.bugfix_unresolved} / ${windowRow.bugfix_total} (${unresolvedPct}%)    [investigation-only narratives — should trend ↓ with R-6 manual-save contract]`);
+  }
+  out('');
+
+  if (typeRows.length > 0) {
+    out(`  Type breakdown (${days}d):`);
+    for (const r of typeRows) {
+      const hit = pct(r.accessed, r.total);
+      const lp = pct(r.with_lesson, r.total);
+      const typeLabel = r.type.padEnd(10);
+      // padStart(5) on count so rows align up to 5-digit totals (99999).
+      out(`    ${typeLabel}${String(r.total).padStart(5)}   hit ${hit.padStart(5)}%   lesson ${lp.padStart(5)}%`);
+    }
+    out('');
+  }
+
+  if (topLessons.length > 0) {
+    out('  Top accessed lessons (all-time):');
+    for (const l of topLessons) {
+      const t = truncate(l.lesson_learned, 80);
+      out(`    #${l.id} [${l.type}] (${l.ac}x) ${t}`);
+    }
+    out('');
+  }
+
+  // R-2 watchdog — explicit targets make progress legible.
+  const lessonNum = parseFloat(lessonPct);
+  const noiseNum = parseFloat(noisePct);
+  const lessonGap = (lessonNum - 15).toFixed(1);
+  const noiseGap = (noiseNum - 30).toFixed(1);
+  const lessonStatus = lessonNum >= 15 ? '✅' : '🔴';
+  const noiseStatus = noiseNum <= 30 ? '✅' : '🔴';
+  out('  Targets (R-2 watchdog):');
+  out(`    ${lessonStatus} Lesson rate ≥ 15%    → currently ${lessonPct}%  (gap ${lessonGap >= 0 ? '+' : ''}${lessonGap}pp)`);
+  out(`    ${noiseStatus} LOW_SIGNAL  ≤ 30%    → currently ${noisePct}%  (gap ${noiseGap >= 0 ? '+' : ''}${noiseGap}pp)`);
+}
+
 function cmdStats(db, args) {
   const { flags } = parseArgs(args);
   const project = flags.project ? resolveProject(db, flags.project) : null;
   const days = parseInt(flags.days, 10) || 30;
+  // N-1: --quality routes to a separate quality-focused report (lesson rate,
+  // LOW_SIGNAL rate, per-type hit+lesson %, R-2 watchdog targets). Intended as
+  // the baseline metric dashboard for the future Haiku prompt A/B test.
+  const quality = flags.quality === true || flags.quality === 'true';
+  if (quality) {
+    renderQualityReport(db, { project, days });
+    return;
+  }
 
   const projectFilter = project ? 'AND project = ?' : '';
   const baseParams = project ? [project] : [];
@@ -965,36 +1125,22 @@ function cmdStats(db, args) {
   out(`  🔴 Working: ${tierMap.working ?? 0} | 🟡 Active: ${tierMap.active ?? 0} | 🔵 Archive: ${tierMap.archive ?? 0}`);
 }
 
-function cmdContext(_db, args) {
+function cmdContext(db, args) {
   const { flags } = parseArgs(args);
   const jsonOutput = flags.json === true || flags.json === 'true' || flags.format === 'json';
 
-  // Read the project's CLAUDE.md and extract the context block
-  const projectDir = process.env.CLAUDE_PROJECT_DIR || process.env.PWD || process.cwd();
-  const claudeMdPath = join(projectDir, 'CLAUDE.md');
-
-  let content;
-  try {
-    content = readFileSync(claudeMdPath, 'utf8');
-  } catch {
-    if (jsonOutput) { out(JSON.stringify({ error: 'No CLAUDE.md found' })); }
-    else { out(`[mem] No CLAUDE.md found at ${claudeMdPath}`); }
-    return;
-  }
-
-  const startTag = '<claude-mem-context>';
-  const endTag = '</claude-mem-context>';
-  const startIdx = content.lastIndexOf(startTag);
-  const endIdx = content.lastIndexOf(endTag);
+  // Generate context live from DB — same builder the SessionStart hook uses.
+  // Pre-v2.30 this command parsed a snapshot out of CLAUDE.md, but the hook no
+  // longer writes there; DB is now the single source of truth.
+  const project = flags.project ? resolveProject(db, flags.project) : inferProject();
+  const block = buildSessionContextLines(db, project).trim();
 
-  if (startIdx === -1 || endIdx === -1 || endIdx <= startIdx) {
-    if (jsonOutput) { out(JSON.stringify({ error: 'No context block found' })); }
-    else { out('[mem] No claude-mem-context block found in CLAUDE.md'); }
+  if (!block) {
+    if (jsonOutput) { out(JSON.stringify({ raw: '', sections: {} })); }
+    else { out(`[mem] No context yet for project "${project}"`); }
     return;
   }
 
-  const block = content.slice(startIdx + startTag.length, endIdx).trim();
-
   if (jsonOutput) {
     // Parse markdown sections into structured JSON
     const result = { raw: block, sections: {} };
@@ -1012,7 +1158,7 @@ function cmdContext(_db, args) {
     }
     out(JSON.stringify(result, null, 2));
   } else {
-    out(`[mem] Current context:\n${block}`);
+    out(`<claude-mem-context>\n${block}\n</claude-mem-context>`);
   }
 }
 
@@ -1883,6 +2029,8 @@ Commands:
   stats                 Show memory statistics
     --project P         Filter by project
     --days N            Lookback window (default 30)
+    --quality           Quality dashboard: lesson rate, LOW_SIGNAL rate, per-type
+                        hit/lesson %, top-accessed lessons, R-2 watchdog targets
 
   context               Show current CLAUDE.md context block
     --json              Output as structured JSON
@@ -2014,22 +2162,27 @@ async function cmdOptimize(db, args) {
   const tasks = taskIdx >= 0 && args[taskIdx + 1] ? [args[taskIdx + 1]] : undefined;
   const maxIdx = args.indexOf('--max');
   const maxItems = maxIdx >= 0 ? parseInt(args[maxIdx + 1], 10) || 15 : 15;
+  // R-7 micro: --scope wide targets bugfix/refactor/feature/decision with narrative but no
+  // lesson_learned (the "Haiku judged 'none'" cases). Default 'narrow' preserves old behavior.
+  const scopeIdx = args.indexOf('--scope');
+  const reenrichScope = scopeIdx >= 0 && args[scopeIdx + 1] === 'wide' ? 'wide' : 'narrow';
 
   if (!run && !runAll) {
     const preview = optimizePreview(db);
     out('[mem] 🔍 LLM Optimization Preview:');
-    out(`  Re-enrich candidates: ${preview.reenrich}`);
+    out(`  Re-enrich candidates: ${preview.reenrich}${preview.reenrichWide !== undefined && preview.reenrichWide !== null ? `  (wide scope: ${preview.reenrichWide})` : ''}`);
     out(`  Normalize: ${preview.normalizeGateOpen ? `${preview.normalize} unique concepts` : 'gate closed (7-day interval)'}`);
     out(`  Cluster-merge: ${preview.clusterMerge} clusters`);
     out(`  Smart-compress: ${preview.smartCompress} clusters`);
     out(`  Total: ${preview.total} items`);
     out('');
     out('Run with --run to execute, --run-all to bypass gates.');
+    out('For R-7 backfill: --run --task re-enrich --scope wide --max N');
     return;
   }
 
-  out('[mem] Running LLM optimization...');
-  const results = await optimizeRun(db, { tasks, maxItems, force: runAll });
+  out(`[mem] Running LLM optimization${reenrichScope === 'wide' ? ' (scope: wide)' : ''}...`);
+  const results = await optimizeRun(db, { tasks, maxItems, force: runAll, reenrichScope });
 
   if (results.reenrich) out(`  Re-enrich: ${results.reenrich.processed || 0} processed, ${results.reenrich.skipped || 0} skipped`);
   if (results.normalize) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "2.29.0",
+  "version": "2.30.0",
   "description": "Lightweight persistent memory system for Claude Code",
   "type": "module",
   "engines": {

package/scoring-sql.mjs

@@ -42,18 +42,57 @@ export const TYPE_DECAY_CASE = `(
 
 /**
  * Type quality multiplier — promotes high-signal types (decisions, discoveries).
- * Bugfix raised from 0.35→0.75: lesson_learned bugfixes are valuable during
- * active debugging; raw error logs are filtered by importance, not type penalty.
+ * Weights calibrated from empirical avg access_count per type in production data:
+ *   decision 6.05, discovery 3.32, bugfix 2.24, feature 2.04, change 0.93, refactor 0.54.
+ * The old (pre-R2) table had bugfix=0.75 < change=0.8, inverted vs reality.
  * Applied as: BM25 × time_decay × TYPE_QUALITY × project_boost × importance
  */
 export const TYPE_QUALITY_CASE = `(
   CASE o.type
     WHEN 'decision'  THEN 1.5
     WHEN 'discovery' THEN 1.3
-    WHEN 'feature'   THEN 1.2
-    WHEN 'refactor'  THEN 1.0
-    WHEN 'change'    THEN 0.8
-    WHEN 'bugfix'    THEN 0.75
+    WHEN 'bugfix'    THEN 1.1
+    WHEN 'feature'   THEN 1.0
+    WHEN 'refactor'  THEN 0.6
+    WHEN 'change'    THEN 0.5
     ELSE 1.0
   END
 )`;
+
+/**
+ * SQL WHERE clause fragment excluding LOW_SIGNAL degraded titles — the fallback
+ * titles hook-llm.mjs writes when Haiku summarization is unavailable or skipped
+ * (e.g. "Modified X", "Worked on X", "Reviewed N files:", raw "Error: ..." logs).
+ *
+ * Empirical data: 544 such entries in production, 18 ever accessed (3.3% rate).
+ * They are capped at importance=1 on write, but that alone doesn't keep them out
+ * of FTS5 injection when BM25 scores are competitive. This clause removes them
+ * from the candidate pool at the SQL level so real bugfixes/discoveries dominate.
+ *
+ * Mirrors LOW_SIGNAL_TITLE regex in utils.mjs — keep in sync.
+ *
+ * @param {string} [alias='o'] Table alias for the observations row. Use '' for unqualified.
+ * @returns {string} SQL boolean expression (already parenthesized; safe to combine with AND/OR)
+ */
+export function notLowSignalTitleClause(alias = 'o') {
+  const p = alias ? `${alias}.` : '';
+  // Bug #2 fix: replace `title != '(error)'` (exact match only) with
+  // `title NOT LIKE '%(error)'` (suffix match) so titles like
+  // "gh release list ... (error)" — produced when makeEntryDesc tags a failed
+  // tool invocation — are excluded too. The LIKE form subsumes the exact match.
+  // Keep in sync with LOW_SIGNAL_TITLE regex in utils.mjs.
+  return `(
+    ${p}title NOT LIKE 'Modified %'
+    AND ${p}title NOT LIKE 'Worked on %'
+    AND ${p}title NOT LIKE 'Reviewed % files:%'
+    AND ${p}title NOT LIKE 'Error while working%'
+    AND ${p}title NOT LIKE 'Error in %'
+    AND ${p}title NOT LIKE 'Error: %'
+    AND ${p}title NOT LIKE '# %'
+    AND ${p}title NOT LIKE 'node %'
+    AND ${p}title NOT LIKE 'npm %'
+    AND ${p}title NOT LIKE 'npx %'
+    AND ${p}title NOT LIKE '(no description)%'
+    AND ${p}title NOT LIKE '%(error)'
+  )`;
+}

package/scripts/pre-tool-recall.js

@@ -7,8 +7,10 @@ import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
 import { basename, join } from 'path';
 import { homedir } from 'os';
 
-const DB_PATH = join(homedir(), '.claude-mem-lite', 'claude-mem-lite.db');
-const RUNTIME_DIR = join(homedir(), '.claude-mem-lite', 'runtime');
+// CLAUDE_MEM_DB_PATH / CLAUDE_MEM_RUNTIME_DIR env overrides allow tests and debug tools to
+// point the hook at an isolated DB + cooldown dir without touching the user's real state.
+const DB_PATH = process.env.CLAUDE_MEM_DB_PATH || join(homedir(), '.claude-mem-lite', 'claude-mem-lite.db');
+const RUNTIME_DIR = process.env.CLAUDE_MEM_RUNTIME_DIR || join(homedir(), '.claude-mem-lite', 'runtime');
 const COOLDOWN_PATH = join(RUNTIME_DIR, 'pre-recall-cooldown.json');
 const COOLDOWN_MS = 5 * 60 * 1000; // 5 minutes
 const STALE_MS = 10 * 60 * 1000;   // 10 minutes cleanup threshold
@@ -127,10 +129,16 @@ try {
           console.log(`  #${r.id} [${r.type}] ${title}`);
         }
       }
-      // Update cooldown
-      cooldown[filePath] = now;
-      writeCooldown(cooldown);
+    } else {
+      // R-4: emit a short backfill reminder instead of staying silent.
+      // Two goals: (1) Claude sees that the system actually ran, (2) Claude is
+      // nudged to mem_save a lesson when solving a non-obvious bug. The reminder
+      // is one line to minimize per-Edit context cost.
+      console.log(`[mem] No prior lessons for ${fname} — if you solve a non-obvious bug here, run: claude-mem-lite save --type bugfix --lesson "<one-line root cause + fix>"`);
     }
+    // Cooldown applies to BOTH branches so the reminder doesn't spam every Edit.
+    cooldown[filePath] = now;
+    writeCooldown(cooldown);
   } catch {
     // Silent failure — never block editing
   } finally {

package/scripts/user-prompt-search.js

@@ -4,7 +4,7 @@
 // Lightweight: only imports schema.mjs and utils.mjs, no MCP SDK
 
 import { ensureDb, DB_DIR, REGISTRY_DB_PATH } from '../schema.mjs';
-import { sanitizeFtsQuery, relaxFtsQueryToOr, truncate, typeIcon, inferProject, OBS_BM25, TYPE_DECAY_CASE, TYPE_QUALITY_CASE, isPathConfined } from '../utils.mjs';
+import { sanitizeFtsQuery, relaxFtsQueryToOr, truncate, typeIcon, inferProject, OBS_BM25, TYPE_DECAY_CASE, TYPE_QUALITY_CASE, isPathConfined, notLowSignalTitleClause } from '../utils.mjs';
 import { writeFileSync, readFileSync, existsSync, renameSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
@@ -27,6 +27,8 @@ function searchByFts(db, queryText, project, limit, typeFilter) {
 
   const typeClause = typeFilter ? 'AND o.type = ?' : '';
   const now = Date.now();
+  // R1: notLowSignalTitleClause() excludes hook-llm degraded titles
+  // ("Modified X", "Worked on X", "Reviewed N files:", raw error logs).
   const sql = `
     SELECT o.id, o.type, o.title, o.lesson_learned,
            ${OBS_BM25}
@@ -40,6 +42,7 @@ function searchByFts(db, queryText, project, limit, typeFilter) {
       AND o.importance >= 1
       AND o.created_at_epoch > ?
       AND COALESCE(o.compressed_into, 0) = 0
+      AND ${notLowSignalTitleClause('o')}
       ${typeClause}
     ORDER BY relevance
     LIMIT ?
@@ -75,6 +78,7 @@ function searchByFile(db, files, project, limit) {
     const escaped = basename.replace(/%/g, '\\%').replace(/_/g, '\\_');
     const likePattern = `%${escaped}`;
 
+    // R1: exclude LOW_SIGNAL degraded titles from file-level recall.
     const rows = db.prepare(`
       SELECT DISTINCT o.id, o.type, o.title, o.lesson_learned
       FROM observations o
@@ -84,6 +88,7 @@ function searchByFile(db, files, project, limit) {
         AND COALESCE(o.compressed_into, 0) = 0
         AND o.created_at_epoch > ?
         AND (of2.filename = ? OR of2.filename LIKE ? ESCAPE '\\')
+        AND ${notLowSignalTitleClause('o')}
       ORDER BY o.created_at_epoch DESC
       LIMIT ?
     `).all(project, cutoff, file, likePattern, limit);
@@ -102,6 +107,9 @@ function searchByFile(db, files, project, limit) {
 
 function searchRecent(db, project, limit) {
   const cutoff = Date.now() - LOOKBACK_MS;
+  // R1: exclude LOW_SIGNAL degraded titles from "recent" recall intent
+  // (e.g. when user asks "what did I do earlier"). Unqualified alias because
+  // this query selects directly from observations with no join.
   return db.prepare(`
     SELECT id, type, title, lesson_learned
     FROM observations
@@ -109,6 +117,7 @@ function searchRecent(db, project, limit) {
       AND importance >= 1
       AND COALESCE(compressed_into, 0) = 0
       AND created_at_epoch > ?
+      AND ${notLowSignalTitleClause('')}
     ORDER BY created_at_epoch DESC
     LIMIT ?
   `).all(project, cutoff, limit);

package/server.mjs

@@ -4,7 +4,7 @@
 
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { jaccardSimilarity, truncate, typeIcon, sanitizeFtsQuery, relaxFtsQueryToOr, inferProject, computeMinHash, estimateJaccardFromMinHash, scrubSecrets, cjkBigrams, fmtDate, isoWeekKey, debugLog, debugCatch, COMPRESSED_PENDING_PURGE, OBS_BM25, SESS_BM25, TYPE_DECAY_CASE, TYPE_QUALITY_CASE, getCurrentBranch, DEFAULT_DECAY_HALF_LIFE_MS, isPathConfined } from './utils.mjs';
+import { jaccardSimilarity, truncate, typeIcon, sanitizeFtsQuery, relaxFtsQueryToOr, inferProject, computeMinHash, estimateJaccardFromMinHash, scrubSecrets, cjkBigrams, fmtDate, isoWeekKey, debugLog, debugCatch, COMPRESSED_PENDING_PURGE, OBS_BM25, SESS_BM25, TYPE_DECAY_CASE, TYPE_QUALITY_CASE, getCurrentBranch, DEFAULT_DECAY_HALF_LIFE_MS, isPathConfined, notLowSignalTitleClause, LOW_SIGNAL_TITLE } from './utils.mjs';
 import { extractCjkLikePatterns } from './nlp.mjs';
 import { resolveProject as _resolveProjectShared } from './project-utils.mjs';
 import { ensureDb, DB_PATH, REGISTRY_DB_PATH, checkFTSIntegrity, rebuildFTS } from './schema.mjs';
@@ -155,26 +155,32 @@ function safeHandler(fn) {
 
 // Score expression variants for FTS5 queries (see Scoring Model Constants above)
 // TYPE_QUALITY_CASE demotes bugfix (×0.6) and promotes decision/discovery (×1.5/1.3)
+// R-3: lesson_learned presence adds ×1.3 boost — empirical +6.3pp hit-rate lift on bugfix.
 const FULL_SCORE = `${OBS_BM25}
   * (1.0 + EXP(-0.693 * (? - MAX(o.created_at_epoch, COALESCE(o.last_accessed_at, o.created_at_epoch))) / ${TYPE_DECAY_CASE}))
   * ${TYPE_QUALITY_CASE}
   * (CASE WHEN ? IS NOT NULL AND o.project = ? THEN 2.0 ELSE 1.0 END)
   * (0.5 + 0.5 * COALESCE(o.importance, 1))
-  * (1.0 + 0.1 * LN(1 + COALESCE(o.access_count, 0)))`;
+  * (1.0 + 0.1 * LN(1 + COALESCE(o.access_count, 0)))
+  * (1.0 + 0.3 * (o.lesson_learned IS NOT NULL))`;
 
 const SIMPLE_SCORE = `${OBS_BM25}
   * (1.0 + EXP(-0.693 * (? - MAX(o.created_at_epoch, COALESCE(o.last_accessed_at, o.created_at_epoch))) / ${TYPE_DECAY_CASE}))
   * ${TYPE_QUALITY_CASE}
-  * (0.5 + 0.5 * COALESCE(o.importance, 1))`;
+  * (0.5 + 0.5 * COALESCE(o.importance, 1))
+  * (1.0 + 0.3 * (o.lesson_learned IS NOT NULL))`;
 
 /**
  * Build an FTS5 observation search query.
  * @param {'full'|'simple'} scoring - full includes project boost + access bonus
- * @param {object} opts - { multiplier, withSnippet, withOffset }
+ * @param {object} opts - { multiplier, withSnippet, withOffset, includeNoise }
+ *   includeNoise=true keeps hook-llm fallback titles ("Modified X", "Worked on X", etc.);
+ *   default false mirrors the filter already applied in hook-memory.mjs / user-prompt-search.js.
  */
-function buildObsFtsQuery(scoring, { multiplier, withSnippet, withOffset } = {}) {
+function buildObsFtsQuery(scoring, { multiplier, withSnippet, withOffset, includeNoise } = {}) {
   const scoreExpr = scoring === 'full' ? FULL_SCORE : SIMPLE_SCORE;
   const mult = multiplier ? ` * ${multiplier}` : '';
+  const lowSignalClause = includeNoise ? '' : `AND ${notLowSignalTitleClause('o')}`;
   return `
     SELECT o.id, o.type, o.title, o.subtitle, o.project, o.created_at, o.importance,
            o.files_modified,
@@ -191,6 +197,7 @@ function buildObsFtsQuery(scoring, { multiplier, withSnippet, withOffset } = {})
       AND (? IS NULL OR o.created_at_epoch <= ?)
       AND (? IS NULL OR COALESCE(o.importance, 1) >= ?)
       AND (? IS NULL OR o.branch = ?)
+      ${lowSignalClause}
     ORDER BY score
     LIMIT ?${withOffset ? ' OFFSET ?' : ''}`;
 }
@@ -225,12 +232,14 @@ function ftsRowToResult(r, { scoreMultiplier, snippet } = {}) {
 function searchObservations(ctx) {
   const { ftsQuery, args, epochFrom, epochTo, perSourceLimit, perSourceOffset, currentProject, limit } = ctx;
   const results = [];
+  // R-1: hide hook-llm fallback titles unless caller explicitly opts in via include_noise=true.
+  const includeNoise = args.include_noise === true;
 
   if (ftsQuery) {
     const now = Date.now();
     const projectBoost = args.project ? null : currentProject;
 
-    const rows = db.prepare(buildObsFtsQuery('full', { withSnippet: true, withOffset: true }))
+    const rows = db.prepare(buildObsFtsQuery('full', { withSnippet: true, withOffset: true, includeNoise }))
       .all(...buildObsFtsParams({ now, projectBoost, ftsQuery, args, epochFrom, epochTo, limit: perSourceLimit, offset: perSourceOffset }));
     for (const r of rows) results.push(ftsRowToResult(r, { snippet: true }));
 
@@ -239,7 +248,7 @@ function searchObservations(ctx) {
       const orQuery = relaxFtsQueryToOr(ftsQuery);
       if (orQuery) {
         try {
-          const orRows = db.prepare(buildObsFtsQuery('full', { multiplier: 0.5, withSnippet: true, withOffset: true }))
+          const orRows = db.prepare(buildObsFtsQuery('full', { multiplier: 0.5, withSnippet: true, withOffset: true, includeNoise }))
             .all(...buildObsFtsParams({ now, projectBoost, ftsQuery: orQuery, args, epochFrom, epochTo, limit: perSourceLimit, offset: perSourceOffset }));
           for (const r of orRows) results.push(ftsRowToResult(r, { snippet: true }));
         } catch (e) { debugCatch(e, 'searchObservations-or-fallback'); }
@@ -249,8 +258,8 @@ function searchObservations(ctx) {
     // Two-phase query expansion for sparse results (only when well below limit)
     if (rows.length > 0 && results.length < Math.ceil(limit / 2)) {
       const existingIds = new Set(results.map(r => r.id));
-      expandObsByConceptCo(ctx, now, existingIds, results);
-      expandObsByPRF(ctx, now, rows.length, existingIds, results);
+      expandObsByConceptCo(ctx, now, existingIds, results, includeNoise);
+      expandObsByPRF(ctx, now, rows.length, existingIds, results, includeNoise);
     }
 
     // Vector search + RRF hybrid merge
@@ -279,6 +288,9 @@ function searchObservations(ctx) {
                   if (epochTo !== null && obs.created_at_epoch > epochTo) continue;
                   if (args.importance && (obs.importance ?? 1) < args.importance) continue;
                   if (args.branch && obs.branch !== args.branch) continue;
+                  // R-1: parity with FTS5 WHERE — vector path must also reject LOW_SIGNAL titles
+                  // so RRF cannot re-admit what the SQL clause excluded.
+                  if (!includeNoise && obs.title && LOW_SIGNAL_TITLE.test(obs.title)) continue;
                   resultMap.set(vr.id, { source: 'obs', id: obs.id, type: obs.type, title: obs.title, subtitle: obs.subtitle, project: obs.project, date: obs.created_at, importance: obs.importance, files_modified: obs.files_modified, snippet: '' });
                 }
               }
@@ -298,6 +310,7 @@ function searchObservations(ctx) {
               if (epochTo !== null && obs.created_at_epoch > epochTo) continue;
               if (args.importance && (obs.importance ?? 1) < args.importance) continue;
               if (args.branch && obs.branch !== args.branch) continue;
+              if (!includeNoise && obs.title && LOW_SIGNAL_TITLE.test(obs.title)) continue;
               results.push({ source: 'obs', id: obs.id, type: obs.type, title: obs.title, subtitle: obs.subtitle, project: obs.project, date: obs.created_at, importance: obs.importance, files_modified: obs.files_modified, score: -vr.similarity, snippet: '' });
             }
           }
@@ -329,14 +342,14 @@ function searchObservations(ctx) {
   return results;
 }
 
-function expandObsByConceptCo(ctx, now, existingIds, results) {
+function expandObsByConceptCo(ctx, now, existingIds, results, includeNoise = false) {
   const { ftsQuery, args, epochFrom, epochTo, limit } = ctx;
   if (results.length >= Math.ceil(limit / 2)) return;
   const expanded = expandQueryByConcepts(db, ftsQuery, args.project);
   if (expanded.length === 0) return;
   const expansionFts = expanded.map(c => `"${c.replace(/"/g, '""')}"`).join(' OR ');
   try {
-    const expRows = db.prepare(buildObsFtsQuery('simple'))
+    const expRows = db.prepare(buildObsFtsQuery('simple', { includeNoise }))
       .all(...buildObsFtsParams({ now, ftsQuery: expansionFts, args, epochFrom, epochTo, limit }));
     for (const r of expRows) {
       if (!existingIds.has(r.id)) {
@@ -347,7 +360,7 @@ function expandObsByConceptCo(ctx, now, existingIds, results) {
   } catch (e) { debugLog('WARN', 'mem_search', `concept expansion error: ${e.message}`); }
 }
 
-function expandObsByPRF(ctx, now, primaryCount, existingIds, results) {
+function expandObsByPRF(ctx, now, primaryCount, existingIds, results, includeNoise = false) {
   const { ftsQuery, args, epochFrom, epochTo, limit } = ctx;
   if (primaryCount < 3) return;
   const topResults = db.prepare(`
@@ -362,7 +375,7 @@ function expandObsByPRF(ctx, now, primaryCount, existingIds, results) {
   if (prfTerms.length === 0) return;
   const prfFts = prfTerms.map(t => `"${t.replace(/"/g, '""')}"`).join(' OR ');
   try {
-    const prfRows = db.prepare(buildObsFtsQuery('simple'))
+    const prfRows = db.prepare(buildObsFtsQuery('simple', { includeNoise }))
       .all(...buildObsFtsParams({ now, ftsQuery: prfFts, args, epochFrom, epochTo, limit }));
     for (const r of prfRows) {
       if (!existingIds.has(r.id)) {

package/tool-schemas.mjs

@@ -41,6 +41,7 @@ export const memSearchSchema = {
   limit: coerceInt.pipe(z.number().int().min(1).max(100)).optional().describe('Max results (default 20)'),
   offset: coerceInt.pipe(z.number().int().min(0)).optional().describe('Offset for pagination'),
   sort: z.enum(['relevance', 'time', 'importance']).optional().describe('Sort order: relevance (default, BM25), time (newest first), importance (highest first)'),
+  include_noise: z.boolean().optional().describe('Include hook-llm fallback titles ("Modified X", "Worked on X", raw error logs) — hidden by default as they have ~3% access rate'),
 };
 
 export const memRecentSchema = {

package/utils.mjs

@@ -8,7 +8,7 @@ import { execSync } from 'child_process';
 // ─── Re-exports from extracted modules ──────────────────────────────────────
 // Backward compatibility: all consumers import from utils.mjs
 
-export { DECAY_HALF_LIFE_BY_TYPE, DEFAULT_DECAY_HALF_LIFE_MS, OBS_BM25, SESS_BM25, TYPE_DECAY_CASE, TYPE_QUALITY_CASE, OBS_FTS_COLUMNS } from './scoring-sql.mjs';
+export { DECAY_HALF_LIFE_BY_TYPE, DEFAULT_DECAY_HALF_LIFE_MS, OBS_BM25, SESS_BM25, TYPE_DECAY_CASE, TYPE_QUALITY_CASE, OBS_FTS_COLUMNS, notLowSignalTitleClause } from './scoring-sql.mjs';
 export { cjkBigrams, extractCjkSynonymTokens, extractCjkKeywords, extractCjkLikePatterns, SYNONYM_MAP, expandToken, sanitizeFtsQuery, relaxFtsQueryToOr, FTS_STOP_WORDS, CJK_COMPOUNDS } from './nlp.mjs';
 export { resolveProject, _resetProjectCache } from './project-utils.mjs';
 export { scrubSecrets, SECRET_PATTERNS } from './secret-scrub.mjs';
@@ -89,7 +89,13 @@ export function clampImportance(val) {
 export const EDIT_TOOLS = new Set(['Edit', 'Write', 'NotebookEdit']);
 
 // Low-signal degraded title patterns — shared by hook-llm.mjs (dedup + importance cap) and hook-handoff.mjs (decision filter)
-export const LOW_SIGNAL_TITLE = /^(Error (while working|in)|Error: |Modified |Worked on |Reviewed \d+ files:|# |node |npm |npx |\(no description\)|\(error\)$)/;
+// Two top-level alternatives:
+//   1. ^(prefix1|prefix2|...) — title starts with one of the hook-llm fallback prefixes
+//   2. \(error\)$              — title ends with '(error)' (Bug #2 fix: previously this was
+//      inside the prefix group with a meaningless $, so only the exact title '(error)' matched.
+//      Tool-fragment titles like 'gh release list ... (error)' leaked through.)
+// Keep in sync with notLowSignalTitleClause() in scoring-sql.mjs.
+export const LOW_SIGNAL_TITLE = /^(Error (while working|in)|Error: |Modified |Worked on |Reviewed \d+ files:|# |node |npm |npx |\(no description\))|\(error\)$/;
 
 export function computeRuleImportance(episode) {
   let importance = 1;