claude-mem-lite 2.97.0 → 2.99.0

package/mem-cli.mjs

@@ -4,14 +4,12 @@
 
 import { homedir } from 'os';
 import { ensureDb, DB_PATH, DB_DIR, REGISTRY_DB_PATH } from './schema.mjs';
-import { sanitizeFtsQuery, relaxFtsQueryToOr, truncate, typeIcon, inferProject, scrubSecrets, cjkBigrams, SESS_BM25, DEFAULT_DECAY_HALF_LIFE_MS, notLowSignalTitleClause } from './utils.mjs';
-import { cjkPrecisionOk } from './nlp.mjs';
-import { extractCjkLikePatterns } from './nlp.mjs';
+import { truncate, typeIcon, inferProject, scrubSecrets } from './utils.mjs';
 import { resolveProject } from './project-utils.mjs';
-import { computeTier, TIER_CASE_SQL, tierSqlParams } from './tier.mjs';
-import { getVocabulary, computeVector, _resetVocabCache } from './tfidf.mjs';
+import { TIER_CASE_SQL, tierSqlParams } from './tier.mjs';
+import { _resetVocabCache } from './tfidf.mjs';
 import { autoBoostIfNeeded, reRankWithContext, markSuperseded } from './server-internals.mjs';
-import { searchObservationsHybrid, findFtsAnchor, countSearchTotal } from './search-engine.mjs';
+import { searchObservationsHybrid, countSearchTotal } from './search-engine.mjs';
 import { ensureRegistryDb, upsertResource } from './registry.mjs';
 import { searchResources } from './registry-retriever.mjs';
 import { selectCompressionCandidates, groupByProjectWeek, compressGroup } from './lib/compress-core.mjs';
@@ -27,7 +25,7 @@ import { cmdAdopt, cmdUnadopt } from './adopt-cli.mjs';
 import { parseIntFlag, isNumericToken } from './lib/cli-flags.mjs';
 import { auditMemdir, memdirPath } from './memdir.mjs';
 import { probeOtherSources as probeIdSources, bucketIdTokens } from './lib/id-routing.mjs';
-import { basename, join, sep } from 'path';
+import { join, sep } from 'path';
 import { readFileSync, existsSync, readdirSync } from 'fs';
 
 // v2.41: shared CLI helpers extracted to cli/common.mjs. Keep this file as the
@@ -35,6 +33,10 @@ import { readFileSync, existsSync, readdirSync } from 'fs';
 // move each cmdXxx into its own cli/<cmd>.mjs; mem-cli.mjs becomes pure dispatch.
 import { parseArgs, out, fail, relativeTime, fmtDateShort, parseIdToken, formatProbeHints, rejectBareStringFlags, OBS_TIME_FIELDS, formatObsFieldValue } from './cli/common.mjs';
 import { saveObservation } from './lib/save-observation.mjs';
+import { rebuildObservationDerived } from './lib/observation-write.mjs';
+import { recallByFile } from './lib/recall-core.mjs';
+import { resolveAnchorToken, formatAnchorError, resolveQueryAnchor, fetchRecentTimeline, fetchTimelineWindow } from './lib/timeline-core.mjs';
+import { buildSearchFtsQuery, parseDateBounds, computePerSourceWindow, effectiveObsFtsQuery, searchSessionsFts, searchPromptsFts, normalizeCrossSourceScores, applyUserSort, applyTierFilter } from './lib/search-core.mjs';
 import { AUTO_MERGE_THRESHOLD } from './lib/dedup-constants.mjs';
 import { countRecentHookErrors } from './lib/hook-telemetry.mjs';
 import {
@@ -61,11 +63,9 @@ function cmdSearch(db, args) {
   }
   const source = flags.source || null; // observations|sessions|prompts (null = all)
   const project = flags.project ? resolveProject(db, flags.project) : null;
-  const dateFrom = flags.from ? new Date(flags.from).getTime() : null;
-  let dateTo = flags.to ? new Date(flags.to).getTime() : null;
-  if (dateTo && flags.to && /^\d{4}-\d{2}-\d{2}$/.test(flags.to)) dateTo += 86400000 - 1;
-  if (flags.from && isNaN(dateFrom)) { fail(`[mem] Invalid --from date: "${flags.from}". Use YYYY-MM-DD or ISO 8601.`); return; }
-  if (flags.to && isNaN(dateTo)) { fail(`[mem] Invalid --to date: "${flags.to}". Use YYYY-MM-DD or ISO 8601.`); return; }
+  const bounds = parseDateBounds(flags.from, flags.to);
+  if (!bounds.ok) { fail(`[mem] Invalid --${bounds.bad} date: "${bounds.value}". Use YYYY-MM-DD or ISO 8601.`); return; }
+  const { epochFrom: dateFrom, epochTo: dateTo } = bounds;
   // Inverted range silently returns 0 rows; warn so users see the cause, don't error
   // (a deliberate "search for nothing in this window" is not malformed input).
   if (dateFrom !== null && dateTo !== null && dateFrom > dateTo) {
@@ -104,8 +104,7 @@ function cmdSearch(db, args) {
     return;
   }
 
-  let ftsQuery = sanitizeFtsQuery(query);
-  if (ftsQuery && useOr) ftsQuery = relaxFtsQueryToOr(ftsQuery) || ftsQuery;
+  const ftsQuery = buildSearchFtsQuery(query, { or: useOr });
   if (!ftsQuery) {
     fail(`[mem] No valid search terms in "${query}"`);
     return;
@@ -124,17 +123,12 @@ function cmdSearch(db, args) {
   const effectiveSource = source || ((type || tier || minImportance || branch) ? 'observations' : null);
 
   // Cross-source mode: each source needs more candidates than the final limit
-  // so the post-merge sort has room to pick the best from each (paired-path with
-  // server.mjs:377 — without this, obs gets systematically squeezed out by sessions).
+  // so the post-merge sort has room to pick the best from each (shared sizing
+  // with mem_search — without this, obs gets systematically squeezed out by
+  // sessions). Over-fetch from offset 0; --offset applies ONCE at the final
+  // slice below (see computePerSourceWindow for the #8217/#8638 rationale).
   const isCrossSourceMode = !effectiveSource;
-  // Over-fetch from offset 0 and apply --offset ONCE at the final slice (below) in
-  // ALL modes — mirrors server.mjs. Pushing OFFSET into the obs hybrid path was
-  // unreliable: its AND→OR fallback / vector / concept-cooccurrence stages re-add
-  // rows the SQL OFFSET already skipped, so engine-side paging dropped (or
-  // duplicated) rows on the --type/--tier/--importance/--branch path (a page that
-  // MCP returned came back empty).
-  const perSourceLimit = Math.max(limit * 3, offset + limit + 10);
-  const perSourceOffset = 0;
+  const { perSourceLimit, perSourceOffset } = computePerSourceWindow(limit, offset);
 
   const results = [];
   // Tracks whether AND returned 0 and OR recovered non-empty. Mirrors server.mjs
@@ -166,107 +160,31 @@ function cmdSearch(db, args) {
 
     // Tier post-filter — applied to ALL obs results from the engine.
     if (tier) {
-      const obsInResults = results.filter(r => r._source === 'obs');
-      if (obsInResults.length > 0) {
-        const obsIds = obsInResults.map(r => r.id);
-        const ph = obsIds.map(() => '?').join(',');
-        const fullRows = db.prepare(
-          `SELECT id, compressed_into, superseded_at, memory_session_id, project, importance, last_accessed_at, created_at_epoch, type FROM observations WHERE id IN (${ph})`
-        ).all(...obsIds);
-        const rowMap = new Map(fullRows.map(r => [r.id, r]));
-        const tierCtx = { now: Date.now(), currentProject: project || inferProject(), currentSessionId: '' };
-        const allowedIds = new Set();
-        for (const [id, full] of rowMap) {
-          if (computeTier(full, tierCtx) === tier) allowedIds.add(id);
-        }
-        for (let i = results.length - 1; i >= 0; i--) {
-          if (results[i]._source === 'obs' && !allowedIds.has(results[i].id)) results.splice(i, 1);
-        }
-      }
+      const filtered = applyTierFilter(db, results, { tier, sourceKey: '_source', currentProject: project || inferProject() });
+      results.length = 0;
+      results.push(...filtered);
     }
   }
 
-  // Search sessions (aligned with MCP mem_search)
+  // Search sessions (shared engine with MCP mem_search — lib/search-core.mjs)
   if (!effectiveSource || effectiveSource === 'sessions') {
-    const now = Date.now();
-    const sessionProjectBoost = project ? null : inferProject();
-    const sessWheres = ['session_summaries_fts MATCH ?'];
-    const sessParams = [now, sessionProjectBoost, sessionProjectBoost, ftsQuery];
-    if (project) { sessWheres.push('s.project = ?'); sessParams.push(project); }
-    if (dateFrom) { sessWheres.push('s.created_at_epoch >= ?'); sessParams.push(dateFrom); }
-    if (dateTo) { sessWheres.push('s.created_at_epoch <= ?'); sessParams.push(dateTo); }
-    sessParams.push(perSourceLimit, perSourceOffset);
     try {
-      const sessRows = db.prepare(`
-        SELECT s.id, s.request, s.completed, s.project, s.created_at, s.created_at_epoch,
-               ${SESS_BM25}
-                 * (1.0 + EXP(-0.693 * (? - s.created_at_epoch) / ${DEFAULT_DECAY_HALF_LIFE_MS}.0))
-                 * (CASE WHEN ? IS NOT NULL AND s.project = ? THEN 2.0 ELSE 1.0 END) as score
-        FROM session_summaries_fts
-        JOIN session_summaries s ON session_summaries_fts.rowid = s.id
-        WHERE ${sessWheres.join(' AND ')}
-        ORDER BY score
-        LIMIT ? OFFSET ?
-      `).all(...sessParams);
+      const sessRows = searchSessionsFts(db, {
+        ftsQuery, project, projectBoost: project ? null : inferProject(),
+        epochFrom: dateFrom, epochTo: dateTo, perSourceLimit, perSourceOffset,
+      });
       for (const r of sessRows) results.push({ ...r, _source: 'session' });
     } catch { /* session FTS may not exist in older DBs */ }
   }
 
-  // Search prompts (aligned with MCP mem_search)
+  // Search prompts (shared engine incl. CJK precision gate + LIKE fallback)
   if (!effectiveSource || effectiveSource === 'prompts') {
-    const promptWheres = ['user_prompts_fts MATCH ?', "p.prompt_text NOT LIKE '<task-notification>%'"];
-    const promptParams = [ftsQuery];
-    if (project) { promptWheres.push('s.project = ?'); promptParams.push(project); }
-    if (dateFrom) { promptWheres.push('p.created_at_epoch >= ?'); promptParams.push(dateFrom); }
-    if (dateTo) { promptWheres.push('p.created_at_epoch <= ?'); promptParams.push(dateTo); }
-    promptParams.push(perSourceLimit, perSourceOffset);
     try {
-      const promptRows = db.prepare(`
-        SELECT p.id, p.prompt_text, p.content_session_id, p.created_at, p.created_at_epoch,
-               bm25(user_prompts_fts, 1) as score
-        FROM user_prompts_fts
-        JOIN user_prompts p ON user_prompts_fts.rowid = p.id
-        JOIN sdk_sessions s ON p.content_session_id = s.content_session_id
-        WHERE ${promptWheres.join(' AND ')}
-        ORDER BY score
-        LIMIT ? OFFSET ?
-      `).all(...promptParams);
-      // CJK precision filter (read-path parity with server.mjs): unicode61
-      // degrades bigram queries to single-char AND, letting common-char
-      // Chinese prose leak through. Drop rows that miss < 20% of query
-      // bigrams/keywords as contiguous substrings.
-      const keptPromptRows = promptRows.filter(r => cjkPrecisionOk(query, r.prompt_text));
-      for (const r of keptPromptRows) results.push({ ...r, _source: 'prompt' });
-      // CJK LIKE fallback: FTS5 unicode61 can't tokenize CJK substrings in prompts
-      if (keptPromptRows.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(perSourceLimit, perSourceOffset);
-          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);
-          // CJK precision filter applies here too: the LIKE fallback is just
-          // OR'd substring bigrams; without the precision gate it re-admits
-          // the same common-char noise the FTS path dropped (this was the
-          // actual leak source — FTS returned 0, fallback filled 20).
-          const keptFallback = fallbackRows.filter(r => cjkPrecisionOk(query, r.prompt_text));
-          for (const r of keptFallback) results.push({ ...r, _source: 'prompt', score: 0 });
-        }
-      }
+      const promptRows = searchPromptsFts(db, {
+        query, ftsQuery, project,
+        epochFrom: dateFrom, epochTo: dateTo, perSourceLimit, perSourceOffset,
+      });
+      for (const r of promptRows) results.push({ ...r, _source: 'prompt' });
     } catch { /* prompt FTS may not exist in older DBs */ }
   }
 
@@ -279,18 +197,11 @@ function cmdSearch(db, args) {
     return;
   }
 
-  // Cross-source score normalization (paired-path with server.mjs:428).
+  // Cross-source score normalization (shared with mem_search).
   // ftsQuery gate prevents normalization when scores are all 0 (no-FTS path).
   const isCrossSource = isCrossSourceMode;
   if (isCrossSource && results.length > 0 && ftsQuery) {
-    for (const src of ['obs', 'session', 'prompt']) {
-      const srcResults = results.filter(r => r._source === src && r.score !== null && r.score !== undefined);
-      if (srcResults.length < 2) continue;
-      const maxAbs = Math.max(...srcResults.map(r => Math.abs(r.score)));
-      if (maxAbs > 0) {
-        for (const r of srcResults) r.score = r.score / maxAbs;
-      }
-    }
+    normalizeCrossSourceScores(results, '_source');
     results.sort((a, b) => (a.score ?? 0) - (b.score ?? 0));
   }
 
@@ -304,13 +215,8 @@ function cmdSearch(db, args) {
     if (isCrossSource) results.sort((a, b) => (a.score ?? 0) - (b.score ?? 0));
   }
 
-  // Apply user-requested sort (after relevance scoring)
-  if (sort === 'time') {
-    results.sort((a, b) => (b.created_at_epoch ?? 0) - (a.created_at_epoch ?? 0));
-  } else if (sort === 'importance') {
-    results.sort((a, b) => (b.importance ?? 1) - (a.importance ?? 1) || (b.created_at_epoch ?? 0) - (a.created_at_epoch ?? 0));
-  }
-  // else 'relevance' keeps BM25 score order (already sorted)
+  // Apply user-requested sort (after relevance scoring; shared with mem_search)
+  applyUserSort(results, sort);
 
   // Trim to limit with offset. The engine always received perSourceOffset=0 and
   // over-fetched (see above), so the merged+reranked `results` start at row 0 and
@@ -324,7 +230,7 @@ function cmdSearch(db, args) {
   const trueTotal = countSearchTotal(db, {
     effectiveSource,
     ftsQuery,
-    obsFtsQuery: orFallbackFired ? (relaxFtsQueryToOr(ftsQuery) || ftsQuery) : ftsQuery,
+    obsFtsQuery: effectiveObsFtsQuery(ftsQuery, orFallbackFired),
     args: { project: project || null, obs_type: type || null, importance: minImportance || null, branch: branch || null },
     project: project || null,
     epochFrom: dateFrom,
@@ -493,35 +399,12 @@ function cmdRecall(db, args) {
     return;
   }
 
-  const filename = basename(file);
   const limit = parseIntFlag(flags.limit, { name: '--limit', defaultValue: 10, max: 1000 });
   const includeNoise = flags['include-noise'] === true || flags['include-noise'] === 'true';
   const jsonOutput = flags.json === true || flags.json === 'true';
 
-  // Search via observation_files junction table for indexed filename lookups
-  const escaped = filename.replace(/%/g, '\\%').replace(/_/g, '\\_');
-  const likePattern = `%${escaped}`;
-  const noiseClause = includeNoise ? '' : `AND ${notLowSignalTitleClause('o')}`;
-  const rows = db.prepare(`
-    SELECT DISTINCT o.id, o.type, o.title, o.lesson_learned, o.importance,
-                    o.created_at, o.created_at_epoch, o.project
-    FROM observations o
-    JOIN observation_files of2 ON of2.obs_id = o.id
-    WHERE COALESCE(o.compressed_into, 0) = 0
-      AND (of2.filename = ? OR of2.filename LIKE ? ESCAPE '\\')
-      ${noiseClause}
-    ORDER BY o.created_at_epoch DESC
-    LIMIT ?
-  `).all(filename, likePattern, limit);
-
-  if (rows.length > 0) {
-    // Update access_count for recalled observations (aligned with MCP mem_recall)
-    const recalledIds = rows.map(r => r.id);
-    const recallPh = recalledIds.map(() => '?').join(',');
-    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 */ }
-  }
+  // Shared core with MCP mem_recall: query + escaping + access bump (lib/recall-core.mjs)
+  const { filename, rows } = recallByFile(db, file, { limit, includeNoise });
 
   if (jsonOutput) {
     out(JSON.stringify({
@@ -734,113 +617,39 @@ function cmdTimeline(db, args) {
   });
 
   // Parse --anchor, accepting P#/S#/# prefix so callers can paste search-result IDs verbatim.
-  // For prompt/session anchors, resolve to the nearest-in-time observation so timeline semantics
-  // (before/after observations) still apply.
+  // Resolution ladder (prompt/session → nearest obs, compressed re-anchor, bare-int
+  // fallback) is shared with MCP mem_timeline via lib/timeline-core.mjs.
   let anchorId = null;
   let anchorNote = null; // hint line for output when anchor was resolved via conversion
   if (flags.anchor !== undefined && flags.anchor !== true) {
-    const parsed = parseIdToken(flags.anchor);
-    if (!parsed) {
-      fail(`[mem] Invalid --anchor "${flags.anchor}". Expected N, #N, P#N, or S#N.`);
+    const resolved = resolveAnchorToken(db, flags.anchor, { project });
+    if (!resolved.ok) {
+      fail(formatAnchorError(resolved.error, 'cli'));
       return;
     }
-    if (parsed.source === 'prompt') {
-      const row = db.prepare('SELECT created_at_epoch FROM user_prompts WHERE id = ?').get(parsed.id);
-      if (!row) { fail(`[mem] Prompt P#${parsed.id} not found`); return; }
-      const proj = project;
-      const nearest = db.prepare(`
-        SELECT id FROM observations
-        WHERE COALESCE(compressed_into, 0) = 0 ${proj ? 'AND project = ?' : ''}
-        ORDER BY ABS(created_at_epoch - ?) ASC LIMIT 1
-      `).get(...(proj ? [proj, row.created_at_epoch] : [row.created_at_epoch]));
-      if (!nearest) { fail(`[mem] No observations near P#${parsed.id}`); return; }
-      anchorId = nearest.id;
-      anchorNote = `(anchored to #${nearest.id}, closest obs to P#${parsed.id})`;
-    } else if (parsed.source === 'session') {
-      const row = db.prepare('SELECT created_at_epoch FROM session_summaries WHERE id = ?').get(parsed.id);
-      if (!row) { fail(`[mem] Session S#${parsed.id} not found`); return; }
-      const proj = project;
-      const nearest = db.prepare(`
-        SELECT id FROM observations
-        WHERE COALESCE(compressed_into, 0) = 0 ${proj ? 'AND project = ?' : ''}
-        ORDER BY ABS(created_at_epoch - ?) ASC LIMIT 1
-      `).get(...(proj ? [proj, row.created_at_epoch] : [row.created_at_epoch]));
-      if (!nearest) { fail(`[mem] No observations near S#${parsed.id}`); return; }
-      anchorId = nearest.id;
-      anchorNote = `(anchored to #${nearest.id}, closest obs to S#${parsed.id})`;
-    } else {
-      // Bare integer (no prefix): try observation first. Fall back to user_prompts
-      // then session_summaries so pasted P#/S# IDs still work when the prefix is
-      // omitted — matches the prefix-aware routing used by search/probe.
-      const obsRow = db.prepare('SELECT compressed_into FROM observations WHERE id = ?').get(parsed.id);
-      if (obsRow) {
-        const ci = obsRow.compressed_into;
-        if (ci && ci > 0) {
-          // Compressed into a live parent: re-anchor so the window doesn't silently
-          // straddle a dead record. Negative sentinels (-1 dropped, -2 pending purge)
-          // have no canonical parent — surface an explicit error instead.
-          anchorId = ci;
-          anchorNote = `(anchored to #${ci}, #${parsed.id} was compressed into it)`;
-        } else if (ci && ci < 0) {
-          fail(`[mem] Observation #${parsed.id} was compressed and pruned; no canonical anchor available`);
-          return;
-        } else {
-          anchorId = parsed.id;
-        }
-      } else {
-        const promptRow = db.prepare('SELECT created_at_epoch FROM user_prompts WHERE id = ?').get(parsed.id);
-        const sessionRow = promptRow ? null : db.prepare('SELECT created_at_epoch FROM session_summaries WHERE id = ?').get(parsed.id);
-        const hit = promptRow ? { row: promptRow, prefix: 'P', name: 'prompt' }
-                  : sessionRow ? { row: sessionRow, prefix: 'S', name: 'session' }
-                  : null;
-        if (!hit) {
-          fail(`[mem] Observation, prompt, or session with id ${parsed.id} not found`);
-          return;
-        }
-        const proj = project;
-        const nearest = db.prepare(`
-          SELECT id FROM observations
-          WHERE COALESCE(compressed_into, 0) = 0 ${proj ? 'AND project = ?' : ''}
-          ORDER BY ABS(created_at_epoch - ?) ASC LIMIT 1
-        `).get(...(proj ? [proj, hit.row.created_at_epoch] : [hit.row.created_at_epoch]));
-        if (!nearest) { fail(`[mem] No observations near ${hit.prefix}#${parsed.id} (${hit.name})`); return; }
-        anchorId = nearest.id;
-        anchorNote = `(anchored to #${nearest.id}, closest obs to ${hit.prefix}#${parsed.id})`;
-      }
-    }
+    anchorId = resolved.anchorId;
+    anchorNote = resolved.anchorNote;
   }
 
   // Support query-based anchor: `timeline --query "search terms"` or positional.
-  // Routes through shared findFtsAnchor (paired-path with MCP mem_timeline)
-  // so AND→OR fallback semantics match `search` — without this, queries like
-  // "ep-flush leak" miss rows whose title is "ep-flush ... leaked" that
-  // search would otherwise find via OR relaxation.
+  // Shared with MCP so AND→OR fallback semantics match `search` — without this,
+  // queries like "ep-flush leak" miss rows whose title is "ep-flush ... leaked"
+  // that search would otherwise find via OR relaxation.
   const queryStr = flags.query || positional.join(' ');
   if ((!anchorId || isNaN(anchorId)) && queryStr) {
-    const ftsQuery = sanitizeFtsQuery(queryStr);
-    const found = findFtsAnchor(db, { ftsQuery, project: project ?? null });
+    const found = resolveQueryAnchor(db, queryStr, { project: project ?? null });
     if (found) {
-      anchorId = found.id;
-      if (found.relaxed && !anchorNote) {
-        anchorNote = `(query "${queryStr}" relaxed AND→OR — no row matched all terms)`;
-      }
+      anchorId = found.anchorId;
+      if (found.anchorNote && !anchorNote) anchorNote = found.anchorNote;
     }
   }
 
-  // No anchor: show most recent observations (aligned with MCP mem_timeline fallback)
+  // No anchor: show most recent observations (shared fallback with MCP mem_timeline)
   if (!anchorId || isNaN(anchorId)) {
     if (queryStr) {
       process.stderr.write(`[mem] No anchor found for "${queryStr}", showing recent timeline\n`);
     }
-    const compressedFilter = 'COALESCE(compressed_into, 0) = 0';
-    const projectFilter = project ? `WHERE ${compressedFilter} AND project = ?` : `WHERE ${compressedFilter}`;
-    const fallbackParams = project ? [project, before + after + 1] : [before + after + 1];
-    const rows = db.prepare(`
-      SELECT id, type, title, subtitle, created_at, created_at_epoch
-      FROM observations ${projectFilter}
-      ORDER BY created_at_epoch DESC
-      LIMIT ?
-    `).all(...fallbackParams);
+    const rows = fetchRecentTimeline(db, { project, limit: before + after + 1 });
 
     if (jsonOutput) {
       out(JSON.stringify({
@@ -868,58 +677,25 @@ function cmdTimeline(db, args) {
     return;
   }
 
-  // Update access_count for anchor (aligned with MCP mem_timeline)
-  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);
-  if (!anchorRow) {
+  // Window fetch (access-count bump + project auto-scope) shared with MCP.
+  const win = fetchTimelineWindow(db, anchorId, { before, after, project });
+  if (!win) {
     fail(`[mem] Observation #${anchorId} not found`);
     return;
   }
-
-  // Auto-scope to anchor's project when --project not explicitly given: users asking
-  // "what happened around #N" expect same-project context, not cross-project time-bleed.
-  const effectiveProject = project || anchorRow.project;
-  const projectFilter = effectiveProject ? 'AND project = ?' : '';
-  const baseParams = effectiveProject ? [effectiveProject] : [];
-
-  // Before anchor
-  const beforeRows = db.prepare(`
-    SELECT id, type, title, subtitle, created_at, created_at_epoch
-    FROM observations
-    WHERE created_at_epoch < ? AND COALESCE(compressed_into, 0) = 0 AND superseded_at IS NULL ${projectFilter}
-    ORDER BY created_at_epoch DESC
-    LIMIT ?
-  `).all(anchorRow.created_at_epoch, ...baseParams, before);
-
-  // After anchor
-  const afterRows = db.prepare(`
-    SELECT id, type, title, subtitle, created_at, created_at_epoch
-    FROM observations
-    WHERE created_at_epoch > ? AND COALESCE(compressed_into, 0) = 0 AND superseded_at IS NULL ${projectFilter}
-    ORDER BY created_at_epoch ASC
-    LIMIT ?
-  `).all(anchorRow.created_at_epoch, ...baseParams, after);
-
-  // Anchor itself
-  const anchor = db.prepare(
-    'SELECT id, type, title, subtitle, created_at, created_at_epoch FROM observations WHERE id = ?'
-  ).get(anchorId);
+  const { anchor, beforeRows, afterRows } = win;
 
   if (jsonOutput) {
     out(JSON.stringify({
       anchor: toRow(anchor),
       anchor_note: anchorNote,
-      before: beforeRows.reverse().map(toRow),
+      before: beforeRows.map(toRow),
       after: afterRows.map(toRow),
     }));
     return;
   }
 
-  const all = [...beforeRows.reverse(), anchor, ...afterRows];
+  const all = [...beforeRows, anchor, ...afterRows];
 
   out(`[mem] Timeline around #${anchorId}${anchorNote ? ' ' + anchorNote : ''}:`);
   for (const r of all) {
@@ -1708,28 +1484,11 @@ function cmdUpdate(db, args) {
 
   params.push(id);
 
-  // Atomic: update fields + rebuild FTS text + re-vectorize (aligned with MCP mem_update)
+  // Atomic: update fields + rebuild derived columns (FTS text + vector) via the
+  // shared core — single source with MCP mem_update (lib/observation-write.mjs).
   db.transaction(() => {
     db.prepare(`UPDATE observations SET ${updates.join(', ')} WHERE id = ?`).run(...params);
-
-    // Rebuild FTS text field
-    const row = db.prepare('SELECT title, subtitle, narrative, concepts, facts, lesson_learned, search_aliases FROM observations WHERE id = ?').get(id);
-    const base = [row.title, row.subtitle, row.narrative, row.concepts, row.facts, row.lesson_learned, row.search_aliases].filter(Boolean).join(' ');
-    const bigrams = cjkBigrams((row.title || '') + ' ' + (row.narrative || ''));
-    const textField = bigrams ? base + ' ' + bigrams : base;
-    db.prepare('UPDATE observations SET text = ? WHERE id = ?').run(textField, id);
-
-    // Re-vectorize (non-critical — catch to avoid rollback)
-    try {
-      const vocab = getVocabulary(db);
-      if (vocab) {
-        const vec = computeVector(textField, vocab);
-        if (vec) {
-          db.prepare('INSERT OR REPLACE INTO observation_vectors (observation_id, vector, vocab_version, created_at_epoch) VALUES (?, ?, ?, ?)')
-            .run(id, Buffer.from(vec.buffer), vocab.version, Date.now());
-        }
-      }
-    } catch { /* non-critical */ }
+    rebuildObservationDerived(db, id);
   })();
 
   out(`[mem] Updated #${id}: ${updates.map(u => u.split(' =')[0]).join(', ')}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "2.97.0",
+  "version": "2.99.0",
   "description": "Persistent long-term memory for Claude Code via MCP — captures coding decisions, bugfixes, and context across sessions. Hybrid FTS5 + TF-IDF search with episode batching. Single SQLite DB, no external services. A lighter, lower-cost alternative to claude-mem (episode batching + a smaller model; cost savings are an internal estimate, not a measured benchmark).",
   "type": "module",
   "packageManager": "npm@10.9.2",
@@ -68,6 +68,9 @@
     "lib/mem-override.mjs",
     "lib/save-observation.mjs",
     "lib/observation-write.mjs",
+    "lib/recall-core.mjs",
+    "lib/timeline-core.mjs",
+    "lib/search-core.mjs",
     "lib/compress-core.mjs",
     "lib/maintain-core.mjs",
     "lib/dedup-constants.mjs",

package/scripts/pre-tool-recall.js

@@ -29,6 +29,15 @@ const CROSS_HOOK_DEDUP_MS = 5 * 60 * 1000;
 // legacy global path so env-less test harnesses still behave.
 const LEGACY_COOLDOWN_PATH = join(RUNTIME_DIR, 'pre-recall-cooldown.json');
 const COOLDOWN_MS = 5 * 60 * 1000; // 5 minutes (used only for legacy fallback)
+// v2.98 salience forcing-function (#8651: verified injection only moved
+// bug-reintroduction 100%→50% — the agent sees lessons and ignores them; the
+// bottleneck is ACTING). Default ON: Edit/Write lesson blocks end with an ack
+// directive, and Read→Edit re-surfaces the Read-time lesson IDs as a one-line
+// ack nudge at the actual action point. CLAUDE_MEM_SALIENCE=legacy (or 0)
+// restores the pre-v2.98 passive behavior.
+const SALIENCE_LEGACY = process.env.CLAUDE_MEM_SALIENCE === 'legacy'
+  || process.env.CLAUDE_MEM_SALIENCE === '0';
+const ACK_DIRECTIVE = "apply each lesson to this edit or rule it out — state '#NN applied' or '#NN n/a — <reason>' in your next user-facing message.";
 const STALE_MS = 10 * 60 * 1000;   // 10 minutes cleanup threshold for legacy file
 // Stale-cooldown GC moved to hook.mjs::handleSessionStart — running it on every
 // Edit cost 15-30 disk stats per call. SessionStart fires once at session boot,
@@ -183,7 +192,35 @@ try {
   const cooldown = readCooldown(cooldownPath);
   const now = Date.now();
   if (isSessionScoped) {
-    if (cooldown[filePath]) process.exit(0); // already recalled this file in-session
+    const entry = cooldown[filePath];
+    if (entry) {
+      // v2.98 salience: the old full-dedup meant a Read-injected lesson left the
+      // actual Edit with ZERO context at the action point — the most likely spot
+      // for #8651's "saw it, ignored it". When this Edit/Write follows a
+      // Read-mode injection that surfaced lessons, emit a one-line ack nudge
+      // naming the IDs (no lesson bodies — token cost stays minimal), then mark
+      // the entry handled so the next Edit is silent again. Entries without a
+      // mode field (pre-v2.98) are treated as already handled.
+      const seenIds = (typeof entry === 'object' && Array.isArray(entry.lessonIds))
+        ? entry.lessonIds : [];
+      const wasReadMode = typeof entry === 'object' && entry.mode === 'read';
+      if (!isRead && wasReadMode && seenIds.length > 0 && !SALIENCE_LEGACY) {
+        const idList = seenIds.map(id => `#${id}`).join(', ');
+        process.stdout.write(JSON.stringify({
+          suppressOutput: true,
+          hookSpecificOutput: {
+            hookEventName: 'PreToolUse',
+            additionalContext: [
+              '[mem] PreToolUse recall — system-injected context, continue your planned action:',
+              `[mem] ⚠ Lessons ${idList} were shown when you Read ${basename(filePath)} — ${ACK_DIRECTIVE}`,
+            ].join('\n'),
+          },
+        }));
+        cooldown[filePath] = { ...entry, mode: 'edit' };
+        writeCooldown(cooldownPath, cooldown, isSessionScoped);
+      }
+      process.exit(0); // already recalled this file in-session
+    }
   } else {
     const ts = entryTimestamp(cooldown[filePath]);
     if (ts && (now - ts) < COOLDOWN_MS) process.exit(0);
@@ -329,6 +366,14 @@ try {
           lines.push(`  #${r.id} [${r.type}] ${title}`);
         }
       }
+      // v2.98 salience: Edit/Write is the action point — close the block with an
+      // explicit ack directive instead of leaving the lessons as passive FYI
+      // (#8651: passive framing was ignored ~half the time even when on-topic).
+      // Read keeps the quiet form; its forcing-function fires at the later Edit
+      // via the Read→Edit ack nudge above.
+      if (!isRead && !SALIENCE_LEGACY) {
+        lines.push(`[mem] ⚠ Before this edit: ${ACK_DIRECTIVE}`);
+      }
     } else if (!isRead && process.env.CLAUDE_MEM_PRETOOL_NUDGE === '1') {
       // R-4: Edit/Write empty → short backfill reminder. OPT-IN (default off) as
       // of the cross-project audit: this "no prior lessons, remember to /lesson"
@@ -360,7 +405,10 @@ try {
     // v2.81: record the emitted lesson IDs so flushEpisode (hook.mjs) can
     // build the PostToolUse cite-back hint when the user actually edits the
     // file. Empty array on no-lesson branches keeps the schema uniform.
-    cooldown[filePath] = { ts: now, lessonIds: allRows.map(r => r.id) };
+    // v2.98: mode records WHERE the injection happened so the Read→Edit ack
+    // nudge can distinguish "lessons seen passively at Read" from "already
+    // surfaced at an action point".
+    cooldown[filePath] = { ts: now, lessonIds: allRows.map(r => r.id), mode: isRead ? 'read' : 'edit' };
     writeCooldown(cooldownPath, cooldown, isSessionScoped);
     // A3 (v2.83): merge our newly-emitted IDs into the cross-hook injected
     // file so the next UPS prompt skips them too. Always write, even on