claude-mem-lite 2.28.2 → 2.30.0

package/mem-cli.mjs

@@ -4,14 +4,17 @@
 
 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';
 import { getVocabulary, computeVector, vectorSearch, rrfMerge, VECTOR_SCAN_LIMIT, rebuildVocabulary, _resetVocabCache } from './tfidf.mjs';
 import { autoBoostIfNeeded, reRankWithContext, markSuperseded, extractPRFTerms, expandQueryByConcepts } from './server-internals.mjs';
 import { ensureRegistryDb, upsertResource } from './registry.mjs';
 import { searchResources } from './registry-retriever.mjs';
-import { basename, join } from 'path';
+import { optimizePreview, optimizeRun } from './hook-optimize.mjs';
+import { buildSessionContextLines } from './hook-context.mjs';
+import { basename } from 'path';
 import { readFileSync } from 'fs';
 
 // OBS_BM25, TYPE_DECAY_CASE imported from utils.mjs
@@ -79,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;
   }
 
@@ -116,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`);
@@ -142,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
@@ -177,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);
@@ -200,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);
@@ -280,6 +287,31 @@ function cmdSearch(db, args) {
         LIMIT ? OFFSET ?
       `).all(...promptParams);
       for (const r of promptRows) results.push({ ...r, _source: 'prompt' });
+      // CJK LIKE fallback: FTS5 unicode61 can't tokenize CJK substrings in prompts
+      if (promptRows.length === 0) {
+        const cjkPatterns = extractCjkLikePatterns(query);
+        if (cjkPatterns.length > 0) {
+          const likeConds = cjkPatterns.map(() => 'p.prompt_text LIKE ?');
+          const likeParams = cjkPatterns.map(p => `%${p}%`);
+          if (project) likeParams.push(project);
+          if (dateFrom) likeParams.push(dateFrom);
+          if (dateTo) likeParams.push(dateTo);
+          likeParams.push(effectiveSource ? limit : limit, effectiveSource ? offset : 0);
+          const fallbackRows = db.prepare(`
+            SELECT p.id, p.prompt_text, p.content_session_id, p.created_at, p.created_at_epoch
+            FROM user_prompts p
+            JOIN sdk_sessions s ON p.content_session_id = s.content_session_id
+            WHERE (${likeConds.join(' OR ')})
+              AND p.prompt_text NOT LIKE '<task-notification>%'
+              ${project ? 'AND s.project = ?' : ''}
+              ${dateFrom ? 'AND p.created_at_epoch >= ?' : ''}
+              ${dateTo ? 'AND p.created_at_epoch <= ?' : ''}
+            ORDER BY p.created_at_epoch DESC
+            LIMIT ? OFFSET ?
+          `).all(...likeParams);
+          for (const r of fallbackRows) results.push({ ...r, _source: 'prompt', score: 0 });
+        }
+      }
     } catch { /* prompt FTS may not exist in older DBs */ }
   }
 
@@ -351,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;
@@ -369,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,
@@ -383,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 ')}
@@ -393,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);
 
@@ -420,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);
               }
             }
@@ -437,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);
@@ -828,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] : [];
@@ -938,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: {} };
@@ -985,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>`);
   }
 }
 
@@ -1856,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
@@ -1980,6 +2155,44 @@ async function cmdEnrich(argv) {
   }
 }
 
+async function cmdOptimize(db, args) {
+  const run = args.includes('--run');
+  const runAll = args.includes('--run-all');
+  const taskIdx = args.indexOf('--task');
+  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}${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${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) {
+    if (results.normalize.skipped) out(`  Normalize: skipped (${results.normalize.reason})`);
+    else out(`  Normalize: ${results.normalize.processed || 0} updated, ${results.normalize.groups || 0} synonym groups`);
+  }
+  if (results.clusterMerge) out(`  Cluster-merge: ${results.clusterMerge.merged || 0} merged of ${results.clusterMerge.processed || 0} clusters`);
+  if (results.smartCompress) out(`  Smart-compress: ${results.smartCompress.compressed || 0} compressed of ${results.smartCompress.processed || 0} clusters`);
+}
+
 // ─── Main Entry Point ────────────────────────────────────────────────────────
 
 export async function run(argv) {
@@ -2020,6 +2233,7 @@ export async function run(argv) {
       case 'export':    cmdExport(db, cmdArgs); break;
       case 'compress':  cmdCompress(db, cmdArgs); break;
       case 'maintain':  cmdMaintain(db, cmdArgs); break;
+      case 'optimize':  await cmdOptimize(db, cmdArgs); break;
       case 'fts-check': cmdFtsCheck(db, cmdArgs); break;
       case 'stats':     cmdStats(db, cmdArgs); break;
       case 'context':   cmdContext(db, cmdArgs); break;

package/nlp.mjs

@@ -108,6 +108,22 @@ export function extractCjkKeywords(text) {
   return found;
 }
 
+/**
+ * Extract CJK patterns suitable for SQL LIKE fallback when FTS5 fails on CJK text.
+ * Uses dictionary extraction + bigram fallback for unmatched portions.
+ * @param {string} query Raw query text
+ * @returns {string[]} CJK patterns (≥2 chars each), empty if no CJK content
+ */
+export function extractCjkLikePatterns(query) {
+  if (!query || !/[\u4e00-\u9fff\u3400-\u4dbf]{2,}/.test(query)) return [];
+  const keywords = extractCjkKeywords(query);
+  // Bigrams for unmatched CJK portions
+  let remainder = query;
+  for (const w of keywords) remainder = remainder.split(w).join(' ');
+  const bigrams = cjkBigrams(remainder).split(' ').filter(Boolean);
+  return [...new Set([...keywords, ...bigrams])];
+}
+
 // ─── FTS5 Token Formatting ──────────────────────────────────────────────────
 
 // Format a term for FTS5: quote if it contains spaces, hyphens, or special chars
@@ -166,6 +182,16 @@ export function sanitizeFtsQuery(query) {
       if (cjkWords.length > 0) {
         expandedTokens.push(...cjkWords);
         cjkExtracted = true;
+        // Preserve unmatched CJK portions as bigrams (don't silently drop them)
+        const matched = new Set(cjkWords);
+        let remainder = t;
+        for (const w of matched) remainder = remainder.split(w).join(' ');
+        const gapBigrams = cjkBigrams(remainder);
+        if (gapBigrams) {
+          for (const bg of gapBigrams.split(' ')) {
+            if (bg && !CJK_STOP_WORDS.has(bg) && !matched.has(bg)) expandedTokens.push(bg);
+          }
+        }
         continue;
       }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "2.28.2",
+  "version": "2.30.0",
   "description": "Lightweight persistent memory system for Claude Code",
   "type": "module",
   "engines": {
@@ -64,10 +64,6 @@
     "skill.md",
     "commands/mem.md",
     "commands/memory.md",
-    "commands/search.md",
-    "commands/recall.md",
-    "commands/recent.md",
-    "commands/timeline.md",
     "commands/update.md",
     "commands/tools.md",
     "hooks/hooks.json",

package/project-utils.mjs

@@ -20,12 +20,25 @@ export function resolveProject(db, name) {
 
   // Short name: prefer the canonical "parent--name" form (from inferProject())
   // which typically has far more data than manually-saved short names.
+  // 1) Exact suffix match: "mem" → "projects--mem"
   const suffixed = db.prepare(
     'SELECT project FROM observations WHERE project LIKE ? GROUP BY project ORDER BY COUNT(*) DESC LIMIT 1'
   ).get(`%--${name}`);
   if (suffixed) { _cache.set(name, suffixed.project); return suffixed.project; }
 
-  // Fallback: synthesize canonical form from current directory
+  // 2) Prefix-in-suffix match: "code-graph" → "projects--code-graph-mcp"
+  const prefixed = db.prepare(
+    'SELECT project FROM observations WHERE project LIKE ? GROUP BY project ORDER BY COUNT(*) DESC LIMIT 1'
+  ).get(`%--${name}%`);
+  if (prefixed) { _cache.set(name, prefixed.project); return prefixed.project; }
+
+  // 3) Substring match: broader fallback for partial names
+  const substr = db.prepare(
+    'SELECT project FROM observations WHERE project LIKE ? GROUP BY project ORDER BY COUNT(*) DESC LIMIT 1'
+  ).get(`%${name}%`);
+  if (substr) { _cache.set(name, substr.project); return substr.project; }
+
+  // 4) Fallback: synthesize canonical form from current directory
   const inferred = inferProject();
   if (inferred.endsWith(`--${name}`)) { _cache.set(name, inferred); return inferred; }
 

package/schema.mjs

@@ -13,7 +13,7 @@ export const DB_PATH = join(DB_DIR, 'claude-mem-lite.db');
 export const REGISTRY_DB_PATH = join(DB_DIR, 'resource-registry.db');
 
 // Increment when schema changes (tables, columns, indexes, FTS, migrations)
-export const CURRENT_SCHEMA_VERSION = 20;
+export const CURRENT_SCHEMA_VERSION = 21;
 
 const CORE_SCHEMA = `
   CREATE TABLE IF NOT EXISTS sdk_sessions (
@@ -111,6 +111,7 @@ const MIGRATIONS = [
   'ALTER TABLE observations ADD COLUMN superseded_at INTEGER DEFAULT NULL',
   'ALTER TABLE observations ADD COLUMN superseded_by INTEGER DEFAULT NULL',
   'ALTER TABLE observations ADD COLUMN last_accessed_at INTEGER DEFAULT NULL',
+  'ALTER TABLE observations ADD COLUMN optimized_at INTEGER DEFAULT NULL',
 ];
 
 /**

package/scoring-sql.mjs

@@ -41,18 +41,58 @@ export const TYPE_DECAY_CASE = `(
 )`;
 
 /**
- * Type quality multiplier — demotes noisy types (bugfix error logs)
- * and promotes high-signal types (decisions, discoveries).
+ * Type quality multiplier — promotes high-signal types (decisions, discoveries).
+ * 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.35
+    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)'
+  )`;
+}