claude-mem-lite 2.28.1 → 2.29.0

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "2.28.1",
+      "version": "2.29.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.28.1",
+  "version": "2.29.0",
   "description": "Lightweight persistent memory system for Claude Code — FTS5 search, episode batching, error-triggered recall",
   "author": {
     "name": "sdsrss"

package/cli.mjs

@@ -16,7 +16,19 @@ if (cmd === '--version' || cmd === '-v') {
 } else if (CLI_COMMANDS.has(cmd)) {
   const { run } = await import('./mem-cli.mjs');
   await run(process.argv.slice(2));
-} else if (!cmd || INSTALL_COMMANDS.has(cmd)) {
+} else if (!cmd) {
+  // No command: show CLI help if installed, install help if not
+  const { existsSync } = await import('fs');
+  const { join } = await import('path');
+  const dbPath = join(process.env.HOME || '', '.claude-mem-lite', 'claude-mem-lite.db');
+  if (existsSync(dbPath)) {
+    const { run } = await import('./mem-cli.mjs');
+    await run(['help']);
+  } else {
+    const { main } = await import('./install.mjs');
+    await main([]);
+  }
+} else if (INSTALL_COMMANDS.has(cmd)) {
   const { main } = await import('./install.mjs');
   await main(process.argv.slice(2));
 } else {

package/commands/mem.md

@@ -1,5 +1,6 @@
 ---
-description: "Search and manage project memory (observations, sessions, prompts). Use when: user asks about past work, wants to find a previous bugfix, check project history, save a decision, or manage stored memories"
+name: mem
+description: "Use when: querying past work, managing memories, or checking project history"
 ---
 
 # Memory

package/commands/memory.md

@@ -1,5 +1,6 @@
 ---
-description: "Save content to memory — with explicit content, instructions, or auto-summarize current session. Use when: the user asks to remember something, after solving a non-obvious problem, or to capture key session findings"
+name: memory
+description: "Use when: user asks to remember something, after solving a non-obvious problem, or to capture key session findings"
 ---
 
 # Memory Save

package/commands/tools.md

@@ -1,5 +1,6 @@
 ---
-description: "Import skills and agents from GitHub repositories into the tool resource registry. Use when: looking for a skill to solve a problem, importing tools from a repo, or managing installed tools"
+name: tools
+description: "Use when: importing skills/agents from GitHub, managing registry resources, or searching for tools to solve a problem"
 ---
 
 # Tool Import

package/commands/update.md

@@ -1,5 +1,6 @@
 ---
-description: "Auto-maintain memory and resource registry — deduplicate, merge, decay, cleanup, reindex. Use when: search results seem noisy, after bulk imports, or during periodic maintenance"
+name: update
+description: "Use when: search results seem noisy, after bulk imports, or for periodic memory/registry maintenance"
 ---
 
 # Memory & Registry Maintenance

package/haiku-client.mjs

@@ -100,6 +100,109 @@ export async function callHaikuJSON(prompt, opts) {
   return parseJsonFromLLM(result.text);
 }
 
+// ─── Model-Selectable API ────────────────────────────────────────────────────
+
+/**
+ * Call LLM with explicit model selection. Supports 'haiku' and 'sonnet'.
+ * Reuses existing API/CLI dual-mode infrastructure.
+ * Never throws — returns null on any error.
+ *
+ * @param {string} prompt The prompt text
+ * @param {'haiku'|'sonnet'} model Model to use (default: 'haiku')
+ * @param {object} [opts] Options
+ * @param {number} [opts.timeout=15000] Timeout in milliseconds
+ * @param {number} [opts.maxTokens=1000] Max tokens in response
+ * @returns {Promise<{text: string}|null>} Response or null on failure
+ */
+export async function callLLMWithModel(prompt, model = 'haiku', { timeout = 15000, maxTokens = 1000 } = {}) {
+  if (!prompt) return null;
+  const resolvedModel = MODEL_MAP[model] ? model : 'haiku';
+  const mode = detectMode();
+
+  try {
+    if (mode === 'api') {
+      return await callModelAPI(prompt, resolvedModel, { timeout, maxTokens });
+    }
+    return callModelCLI(prompt, resolvedModel, { timeout });
+  } catch (e) {
+    debugCatch(e, `callLLMWithModel:${resolvedModel}`);
+    return null;
+  }
+}
+
+/**
+ * Call LLM with model selection and parse JSON response.
+ * @param {string} prompt
+ * @param {'haiku'|'sonnet'} model
+ * @param {object} [opts]
+ * @returns {Promise<object|null>}
+ */
+export async function callModelJSON(prompt, model = 'haiku', opts) {
+  const result = await callLLMWithModel(prompt, model, opts);
+  if (!result?.text) return null;
+  return parseJsonFromLLM(result.text);
+}
+
+async function callModelAPI(prompt, model, { timeout, maxTokens }) {
+  const apiKey = process.env.ANTHROPIC_API_KEY;
+  if (!apiKey) return null;
+
+  const modelId = MODEL_MAP[model];
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeout);
+
+  try {
+    const res = await fetch('https://api.anthropic.com/v1/messages', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-api-key': apiKey,
+        'anthropic-version': '2023-06-01',
+      },
+      body: JSON.stringify({
+        model: modelId,
+        max_tokens: maxTokens,
+        messages: [{ role: 'user', content: prompt }],
+      }),
+      signal: controller.signal,
+    });
+
+    if (!res.ok) {
+      debugLog('WARN', `${model}-api`, `HTTP ${res.status}`);
+      return null;
+    }
+
+    const data = await res.json();
+    const text = data.content?.[0]?.text;
+    return text ? { text } : null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+function callModelCLI(prompt, model, { timeout }) {
+  const modelName = MODEL_MAP[model] ? model : 'haiku';
+  try {
+    const result = execFileSync(getClaudePath(), ['-p', '--model', modelName], {
+      input: prompt,
+      timeout,
+      encoding: 'utf8',
+      env: { ...process.env, CLAUDE_MEM_HOOK_RUNNING: '1' },
+      stdio: ['pipe', 'pipe', 'pipe'],
+      cwd: '/tmp',
+    });
+    const text = result.trim();
+    return text ? { text } : null;
+  } catch (e) {
+    const out = e.stdout?.toString?.()?.trim() || e.output?.[1]?.toString?.()?.trim();
+    if (out && out.startsWith('{') && out.endsWith('}')) {
+      try { JSON.parse(out); return { text: out }; } catch {}
+    }
+    debugCatch(e, `${model}-cli`);
+    return null;
+  }
+}
+
 // ─── API Mode ────────────────────────────────────────────────────────────────
 
 async function callHaikuAPI(prompt, { timeout, maxTokens }) {

package/hook-episode.mjs

@@ -107,7 +107,7 @@ export function readEpisode() {
  */
 export function writeEpisode(episode) {
   const target = episodeFile();
-  const tmp = target + '.tmp';
+  const tmp = target + `.tmp-${process.pid}`;
   const { _fileSet, ...serializable } = episode;
   writeFileSync(tmp, JSON.stringify(serializable));
   try {

package/hook-memory.mjs

@@ -6,8 +6,13 @@ import { sanitizeFtsQuery, relaxFtsQueryToOr, debugCatch, OBS_BM25 } from './uti
 const MAX_MEMORY_INJECTIONS = 3;
 const MEMORY_LOOKBACK_MS = 60 * 86400000; // 60 days
 // Aligned with TYPE_QUALITY_CASE: high-signal types > noisy types
-// Bugfix lessons are still surfaced via the separate lesson_learned boost (1.5×)
-const MEMORY_TYPE_BOOST = { decision: 1.5, discovery: 1.3, feature: 1.2, refactor: 1.0, change: 0.8, bugfix: 0.5 };
+// 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 };
+// Adaptive BM25 thresholds — scale with corpus size to filter noise.
+// Larger corpora produce more weak matches from common words.
+const BM25_THRESHOLD = { TINY: 0, SMALL: 1.5, MEDIUM: 2.5, LARGE: 3.5 };
+// OR fallback max token count — queries with 3+ tokens that fail AND are likely off-topic
+const OR_FALLBACK_MAX_TOKENS = 2;
 
 const FILE_RECALL_LOOKBACK_MS = 60 * 86400000; // 60 days
 const MAX_FILE_RECALL = 2;
@@ -47,18 +52,25 @@ export function searchRelevantMemories(db, userPrompt, project, excludeIds = [])
       LIMIT 10
     `);
     let rows = selectStmt.all(ftsQuery, project, cutoff);
+    let usedOrFallback = false;
 
-    // OR fallback when AND returns nothing
+    // OR fallback when AND returns nothing — only for short queries (specific enough).
+    // 3+ token queries that fail AND are likely off-topic; OR would match individual common words.
+    // Count original search terms (AND-separated groups), not expanded synonym tokens.
+    const queryTokenCount = ftsQuery.includes(' AND ')
+      ? ftsQuery.split(' AND ').length
+      : ftsQuery.split(/\s+/).filter(t => t && !t.startsWith('(') || !t.endsWith(')')).length;
     if (rows.length === 0) {
       const orQuery = relaxFtsQueryToOr(ftsQuery);
-      if (orQuery) {
-        try { rows = selectStmt.all(orQuery, project, cutoff); } catch {}
+      if (orQuery && queryTokenCount <= OR_FALLBACK_MAX_TOKENS) {
+        try { rows = selectStmt.all(orQuery, project, cutoff); usedOrFallback = true; } catch {}
       }
     }
 
     // Phase 2: Cross-project search for high-value decisions/discoveries
     // These are transferable insights (debugging patterns, architectural reasons, gotchas)
     let crossRows = [];
+    let crossUsedOr = false;
     try {
       const crossStmt = db.prepare(`
         SELECT o.id, o.type, o.title, o.importance, o.lesson_learned, o.project,
@@ -78,40 +90,44 @@ export function searchRelevantMemories(db, userPrompt, project, excludeIds = [])
       crossRows = crossStmt.all(ftsQuery, project, cutoff);
       if (crossRows.length === 0) {
         const orQuery = relaxFtsQueryToOr(ftsQuery);
-        if (orQuery) {
-          try { crossRows = crossStmt.all(orQuery, project, cutoff); } catch {}
+        if (orQuery && queryTokenCount <= OR_FALLBACK_MAX_TOKENS) {
+          try { crossRows = crossStmt.all(orQuery, project, cutoff); crossUsedOr = true; } catch {}
         }
       }
     } catch (e) { debugCatch(e, 'crossProjectSearch'); }
 
     // Merge and score: same-project full weight, cross-project 0.7x
-    const allRows = [...rows, ...crossRows];
+    // OR-fallback results get 0.4x penalty — they matched individual words, not the full intent
+    const allRows = [...rows.map(r => ({ ...r, _or: usedOrFallback })), ...crossRows.map(r => ({ ...r, _or: crossUsedOr }))];
     const scored = allRows
       .filter(r => !excludeSet.has(r.id))
       .map(r => {
         const crossProjectPenalty = r.project === project ? 1.0 : 0.7;
+        const orFallbackPenalty = r._or ? 0.4 : 1.0;
         return {
           ...r,
           score: Math.abs(r.relevance)
             * (MEMORY_TYPE_BOOST[r.type] || 1.0)
             * (r.lesson_learned ? 1.5 : 1.0)
             * (r.importance >= 2 ? 1.0 : 0.6)
-            * crossProjectPenalty,
+            * crossProjectPenalty
+            * orFallbackPenalty,
         };
       })
       .sort((a, b) => b.score - a.score);
 
-    // Adaptive threshold: BM25 IDF collapses when corpus has <5 observations,
-    // producing scores ~0.00001 even for exact matches. At 5+ obs, IDF provides
-    // meaningful discrimination and the calibrated 1.5 threshold works well.
+    // Adaptive threshold: scales with corpus size to filter noise.
+    // Each result must individually exceed the threshold (not just the top one).
     const obsCount = db.prepare(
       'SELECT COUNT(*) as c FROM observations WHERE project = ? AND COALESCE(compressed_into, 0) = 0',
     ).get(project)?.c || 0;
-    const threshold = obsCount < 5 ? 0 : 1.5;
-    if (scored.length === 0 || scored[0].score < threshold) return [];
+    const { TINY, SMALL, MEDIUM, LARGE } = BM25_THRESHOLD;
+    const threshold = obsCount < 5 ? TINY : obsCount < 100 ? SMALL : obsCount < 500 ? MEDIUM : LARGE;
+    const aboveThreshold = scored.filter(r => r.score >= threshold);
+    if (aboveThreshold.length === 0) return [];
 
     // Update access_count for injected memories
-    const result = scored.slice(0, MAX_MEMORY_INJECTIONS);
+    const result = aboveThreshold.slice(0, MAX_MEMORY_INJECTIONS);
     const now = Date.now();
     const updateStmt = db.prepare('UPDATE observations SET access_count = COALESCE(access_count, 0) + 1, last_accessed_at = ? WHERE id = ?');
     for (const r of result) {

package/hook-semaphore.mjs

@@ -2,7 +2,7 @@
 // Limits concurrent claude -p calls to prevent resource contention
 
 import { join } from 'path';
-import { readFileSync, writeFileSync, unlinkSync, readdirSync, openSync, closeSync, writeSync, constants as fsConstants } from 'fs';
+import { readFileSync, unlinkSync, readdirSync, openSync, closeSync, writeSync, constants as fsConstants } from 'fs';
 import { RUNTIME_DIR } from './hook-shared.mjs';
 
 export const LLM_SEM_MAX = 2;
@@ -21,7 +21,7 @@ export async function acquireLLMSlot() {
 
   while (Date.now() < deadline) {
     // Acquire-then-verify: atomically create our slot first, then check total count
-    let created = false;
+    let created;
     try {
       let fd;
       try {
@@ -33,8 +33,9 @@ export async function acquireLLMSlot() {
         if (fd !== undefined) closeSync(fd);
       }
     } catch {
-      // Slot file already exists for this PID — update timestamp
-      try { writeFileSync(slotFile, JSON.stringify({ pid: process.pid, ts: Date.now() })); created = true; } catch {}
+      // Slot file already exists for this PID — stale cleanup should have removed it;
+      // retry and let O_CREAT|O_EXCL succeed on next iteration (avoid non-atomic fallback)
+      continue;
     }
 
     if (!created) { await sleepMs(200 + Math.random() * 800); continue; }

package/hook-update.mjs

@@ -214,7 +214,7 @@ async function downloadAndInstall(tarballUrl) {
 
     // Download tarball via curl (available on all supported platforms)
     // Validate URL to prevent command injection via crafted tarball URLs
-    if (!/^https:\/\/[a-zA-Z0-9./-]+$/.test(tarballUrl)) {
+    if (!/^https:\/\/(?:api\.)?github\.com\/[a-zA-Z0-9./_-]+$/.test(tarballUrl)) {
       debugLog('WARN', 'hook-update', `Rejected suspicious tarball URL: ${tarballUrl}`);
       return false;
     }

package/hook.mjs

@@ -31,13 +31,14 @@ import { handleLLMEpisode, handleLLMSummary, saveObservation, buildImmediateObse
 import { searchRelevantMemories } from './hook-memory.mjs';
 import { buildAndSaveHandoff, detectContinuationIntent, renderHandoffInjection, extractUnfinishedSummary } from './hook-handoff.mjs';
 import { checkForUpdate } from './hook-update.mjs';
+import { handleLLMOptimize } from './hook-optimize.mjs';
 import { SKIP_TOOLS, SKIP_PREFIXES } from './skip-tools.mjs';
 import { getVocabulary } from './tfidf.mjs';
 
 // Prevent recursive hooks from background claude -p calls
 // Background workers (llm-episode, llm-summary) are exempt — they're ours
 const event = process.argv[2];
-const BG_EVENTS = new Set(['llm-episode', 'llm-summary']);
+const BG_EVENTS = new Set(['llm-episode', 'llm-summary', 'auto-compress', 'llm-optimize']);
 
 // Respect Claude Code plugin disable state even when legacy settings.json hooks remain.
 // install.mjs writes direct hooks into ~/.claude/settings.json, so disabling the plugin
@@ -122,6 +123,22 @@ function flushEpisode(episode) {
 
   if (isSignificant) {
     spawnBackground('llm-episode', flushFile);
+
+    // P3: Auto-save hint — detect error→fix pattern (error entry followed by Edit/Write)
+    // and nudge Claude to save the lesson for future recall
+    try {
+      const entries = episode.entries || [];
+      const hasError = entries.some(e => e.isError);
+      const hasEdit = entries.some(e => EDIT_TOOLS.has(e.tool));
+      if (hasError && hasEdit && entries.length >= 3) {
+        const editFiles = entries.filter(e => EDIT_TOOLS.has(e.tool)).flatMap(e => e.files || []);
+        const uniqueFiles = [...new Set(editFiles)].slice(0, 3);
+        const filesHint = uniqueFiles.length > 0 ? ` (files: ${uniqueFiles.join(', ')})` : '';
+        process.stdout.write(
+          `[mem] 💡 Error→fix pattern detected${filesHint}. Consider: mem_save(type="bugfix", lesson_learned="root cause & fix")\n`,
+        );
+      }
+    } catch { /* never block on hint */ }
   } else {
     try { unlinkSync(flushFile); } catch {}
   }
@@ -539,6 +556,7 @@ async function handleSessionStart() {
         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_OPTIMIZE) spawnBackground('llm-optimize');
       } catch (e) { debugCatch(e, 'auto-maintain'); }
     }
 
@@ -1060,6 +1078,7 @@ try {
     case 'llm-episode':      await handleLLMEpisode(); break;
     case 'llm-summary':      await handleLLMSummary(); break;
     case 'auto-compress':    handleAutoCompress(); break;
+    case 'llm-optimize':   await handleLLMOptimize(); break;
   }
 } catch (err) {
   // Always log fatal errors (ungated) with structured format

package/install.mjs

@@ -204,7 +204,7 @@ async function install() {
   const SOURCE_FILES = [
     'cli.mjs', 'server.mjs', 'server-internals.mjs', 'tool-schemas.mjs',
     'hook.mjs', 'hook-shared.mjs', 'hook-llm.mjs', 'hook-memory.mjs', 'skip-tools.mjs',
-    'hook-semaphore.mjs', 'hook-episode.mjs', 'hook-context.mjs', 'hook-handoff.mjs', 'hook-update.mjs',
+    'hook-semaphore.mjs', 'hook-episode.mjs', 'hook-context.mjs', 'hook-handoff.mjs', 'hook-update.mjs', 'hook-optimize.mjs',
     'haiku-client.mjs', 'utils.mjs', 'schema.mjs', 'package.json', 'package-lock.json', 'skill.md',
     'registry.mjs', 'registry-scanner.mjs', 'registry-indexer.mjs',
     'registry-retriever.mjs', 'resource-discovery.mjs',
@@ -529,8 +529,9 @@ async function install() {
   }
 
   // 6. Install pre-installed resources (skills + agents)
-  log('Setting up skill/agent registry...');
-  try {
+  if (process.env.CLAUDE_MEM_SKIP_REPOS) {
+    ok('Skill/agent registry: skipped (CLAUDE_MEM_SKIP_REPOS)');
+  } else try {
     const manifestPath = join(INSTALL_DIR, 'registry', 'preinstalled.json');
     if (!existsSync(manifestPath)) {
       // For git-clone mode, check PROJECT_DIR
@@ -565,7 +566,7 @@ async function install() {
         };
 
         for (const [repoUrl, entries] of repos) {
-          const repoName = repoUrl.split('/').slice(-2).join('-');
+          const repoName = repoUrl.split('/').slice(-2).join('-').replace(/[^a-zA-Z0-9._-]/g, '_');
           const clonePath = join(managedDir, 'repos', repoName);
           let repoReady = false;
 
@@ -959,12 +960,8 @@ async function status() {
 
   // CLI
   try {
-    const cliVer = execSync('claude-mem-lite --help 2>/dev/null && echo OK', { encoding: 'utf8', timeout: 5000 });
-    if (cliVer.includes('OK')) {
-      ok('CLI: claude-mem-lite command available');
-    } else {
-      warn('CLI: command not on PATH');
-    }
+    execFileSync('claude-mem-lite', ['--help'], { encoding: 'utf8', timeout: 5000, stdio: 'pipe' });
+    ok('CLI: claude-mem-lite command available');
   } catch {
     warn('CLI: command not on PATH — run install again to create symlink');
   }
@@ -1087,7 +1084,7 @@ async function doctor() {
 
   // Check for stale processes
   try {
-    const procs = execSync('pgrep -af "chroma|claude-mem.*worker" 2>/dev/null', { encoding: 'utf8' }).trim();
+    const procs = execFileSync('pgrep', ['-af', 'chroma|claude-mem.*worker'], { encoding: 'utf8', timeout: 5000, stdio: 'pipe' }).trim();
     // Filter out the pgrep process itself (matches its own pattern)
     const real = procs.split('\n').filter(l => !l.includes('pgrep'));
     if (real.length > 0) {

package/mem-cli.mjs

@@ -5,12 +5,14 @@
 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 { 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 { optimizePreview, optimizeRun } from './hook-optimize.mjs';
 import { basename, join } from 'path';
 import { readFileSync } from 'fs';
 
@@ -52,7 +54,7 @@ function out(text) {
 }
 
 function fail(text) {
-  process.stdout.write(text + '\n');
+  process.stderr.write(text + '\n');
   process.exitCode = 1;
 }
 
@@ -115,13 +117,15 @@ function cmdSearch(db, args) {
     fail(`[mem] Invalid --sort "${sort}". Use: relevance, time, importance`);
     return;
   }
+  const useOr = flags.or === true || flags.or === 'true';
 
   if (source && !['observations', 'sessions', 'prompts'].includes(source)) {
     fail(`[mem] Invalid --source "${source}". Use: observations, sessions, prompts`);
     return;
   }
 
-  const ftsQuery = sanitizeFtsQuery(query);
+  let ftsQuery = sanitizeFtsQuery(query);
+  if (ftsQuery && useOr) ftsQuery = relaxFtsQueryToOr(ftsQuery) || ftsQuery;
   if (!ftsQuery) {
     fail(`[mem] No valid search terms in "${query}"`);
     return;
@@ -278,6 +282,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 */ }
   }
 
@@ -449,7 +478,7 @@ function searchFts(db, ftsQuery, { type, project, limit, dateFrom, dateTo, minIm
 function cmdRecent(db, args) {
   const { positional, flags } = parseArgs(args);
   const rawLimit = parseInt(positional[0], 10);
-  const limit = Math.max(1, Number.isFinite(rawLimit) ? rawLimit : 10);
+  const limit = (Number.isInteger(rawLimit) && rawLimit > 0) ? rawLimit : 10;
   const project = flags.project ? resolveProject(db, flags.project) : inferProject();
 
   const params = [];
@@ -511,7 +540,9 @@ function cmdRecall(db, args) {
   // Update access_count for recalled observations (aligned with MCP mem_recall)
   const recalledIds = rows.map(r => r.id);
   const recallPh = recalledIds.map(() => '?').join(',');
-  db.prepare(`UPDATE observations SET access_count = COALESCE(access_count, 0) + 1, last_accessed_at = ? WHERE id IN (${recallPh})`).run(Date.now(), ...recalledIds);
+  try {
+    db.prepare(`UPDATE observations SET access_count = COALESCE(access_count, 0) + 1, last_accessed_at = ? WHERE id IN (${recallPh})`).run(Date.now(), ...recalledIds);
+  } catch { /* non-critical: FTS5 trigger may fail on corrupted index */ }
 
   out(`[mem] History for ${filename} (${rows.length}):`);
   for (const r of rows) {
@@ -588,8 +619,10 @@ function cmdGet(db, args) {
   }
 
   // Update access_count + auto-boost (aligned with MCP mem_get)
-  db.prepare(`UPDATE observations SET access_count = COALESCE(access_count, 0) + 1, last_accessed_at = ? WHERE id IN (${placeholders})`).run(Date.now(), ...ids);
-  autoBoostIfNeeded(db, ids);
+  try {
+    db.prepare(`UPDATE observations SET access_count = COALESCE(access_count, 0) + 1, last_accessed_at = ? WHERE id IN (${placeholders})`).run(Date.now(), ...ids);
+    autoBoostIfNeeded(db, ids);
+  } catch { /* non-critical: FTS5 trigger may fail on corrupted index */ }
 
   const rows = db.prepare(`
     SELECT * FROM observations
@@ -680,7 +713,9 @@ function cmdTimeline(db, args) {
   }
 
   // Update access_count for anchor (aligned with MCP mem_timeline)
-  db.prepare('UPDATE observations SET access_count = COALESCE(access_count, 0) + 1, last_accessed_at = ? WHERE id = ?').run(Date.now(), anchorId);
+  try {
+    db.prepare('UPDATE observations SET access_count = COALESCE(access_count, 0) + 1, last_accessed_at = ? WHERE id = ?').run(Date.now(), anchorId);
+  } catch { /* non-critical: FTS5 trigger may fail on corrupted index */ }
 
   // Get anchor epoch
   const anchorRow = db.prepare('SELECT created_at_epoch, project FROM observations WHERE id = ?').get(anchorId);
@@ -1786,6 +1821,7 @@ Commands:
     --offset N          Skip first N results (pagination)
     --tier T            Filter by tier (working|active|archive, observations only)
     --sort S            Sort: relevance (default), time, importance
+    --or                Use OR instead of AND between search terms
 
   recent [N]            Show N most recent observations (default 10)
     --project P         Filter by project
@@ -1869,7 +1905,7 @@ DB: ${DB_PATH}`);
 
 // ─── Import (GitHub) ────────────────────────────────────────────────────────
 
-async function cmdImport(db, argv) {
+async function cmdImport(argv) {
   const { positional, flags } = parseArgs(argv);
   const url = positional[0];
 
@@ -1923,7 +1959,7 @@ async function cmdImport(db, argv) {
 
 // ─── Enrich ─────────────────────────────────────────────────────────────────
 
-async function cmdEnrich(db, argv) {
+async function cmdEnrich(argv) {
   const { positional, flags } = parseArgs(argv);
   const name = positional[0];
 
@@ -1971,6 +2007,39 @@ async function cmdEnrich(db, 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;
+
+  if (!run && !runAll) {
+    const preview = optimizePreview(db);
+    out('[mem] 🔍 LLM Optimization Preview:');
+    out(`  Re-enrich candidates: ${preview.reenrich}`);
+    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.');
+    return;
+  }
+
+  out('[mem] Running LLM optimization...');
+  const results = await optimizeRun(db, { tasks, maxItems, force: runAll });
+
+  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) {
@@ -2011,13 +2080,14 @@ 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;
       case 'browse':    cmdBrowse(db, cmdArgs); break;
       case 'registry':  cmdRegistry(db, cmdArgs); break;
-      case 'import':    await cmdImport(db, cmdArgs); break;
-      case 'enrich':    await cmdEnrich(db, cmdArgs); break;
+      case 'import':    await cmdImport(cmdArgs); break;
+      case 'enrich':    await cmdEnrich(cmdArgs); break;
       default:
         out(`[mem] Unknown command: ${cmd}`);
         out('[mem] Run "claude-mem-lite help" for usage');