claude-mem-lite 2.96.0 → 2.98.0

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "2.96.0",
+      "version": "2.98.0",
       "source": "./",
       "description": "Persistent long-term memory for Claude Code via MCP — captures coding decisions, bugfixes, and context across sessions. Hybrid FTS5 + TF-IDF search with episode batching. Single SQLite DB, no external services. A lighter, lower-cost alternative to claude-mem (episode batching + a smaller model; cost savings are an internal estimate, not a measured benchmark)."
     }

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "2.96.0",
+  "version": "2.98.0",
   "description": "Persistent long-term memory for Claude Code via MCP — captures coding decisions, bugfixes, and context across sessions. Hybrid FTS5 + TF-IDF search with episode batching. Single SQLite DB, no external services. A lighter, lower-cost alternative to claude-mem (episode batching + a smaller model; cost savings are an internal estimate, not a measured benchmark).",
   "author": {
     "name": "sdsrss"

package/cli/common.mjs

@@ -98,6 +98,24 @@ export function fmtDateShort(iso) {
   return iso.slice(0, 10);
 }
 
+// Integer epoch-ms time fields on the observations table that `get`/`mem_get`
+// render. Shared by the CLI (mem-cli.mjs) and the MCP server (server.mjs) so the
+// two `get` paths can't drift — pre-2.97 the MCP path printed bare ms
+// (`last_accessed_at: 1781024049720`) while the CLI showed `<ms> (<relative>)`,
+// because the formatter lived only in mem-cli.mjs.
+export const OBS_TIME_FIELDS = ['superseded_at', 'last_accessed_at'];
+
+// Pure formatter — null/undefined/non-time pass through; integer time fields
+// render as `<raw> (<relative>)` so callers get both an audit value and a
+// human/LLM-scannable hint, mirroring `recent`/`timeline`/`recall`.
+export function formatObsFieldValue(field, val) {
+  if (val === null || val === undefined) return val;
+  if (OBS_TIME_FIELDS.includes(field) && typeof val === 'number') {
+    return `${val} (${relativeTime(val)})`;
+  }
+  return val;
+}
+
 // ─── ID Token Parsing ────────────────────────────────────────────────────────
 // Re-exported from lib/id-routing.mjs so CLI and MCP (server.mjs) share a single
 // parser — parity per #8050. Keep this re-export for back-compat with the

package/hook-llm.mjs

@@ -601,7 +601,12 @@ export async function handleLLMEpisode() {
     await sleep(delayMs);
   }
 
-  const fileList = episode.files.map(f => basename(f)).join(', ') || '(multiple)';
+  // `episode.files` is normally a [] from createEpisode, but a malformed or
+  // older-format tmp file can omit it — `.map()` on undefined would throw here,
+  // before any cleanup, leaking the tmp file (which is then retried and crashes
+  // forever). Guard defensively, mirroring buildImmediateObservation's `|| []`.
+  const episodeFiles = Array.isArray(episode.files) ? episode.files : [];
+  const fileList = episodeFiles.map(f => basename(f)).join(', ') || '(multiple)';
 
   // Defense-in-depth (cso F#4): split static instructions (system) from
   // per-call data (user). Episode descriptions and file paths come from tool
@@ -622,7 +627,7 @@ search_aliases: 2-6 alternative search terms someone might use to find this memo
 JSON: {"type":"decision|bugfix|feature|refactor|discovery|change","title":"concise ≤80 char description","narrative":"what changed, why, and outcome (2-3 sentences)","concepts":["kw1","kw2"],"facts":["fact1","fact2"],"importance":1,"lesson_learned":"non-obvious insight a future session needs, or null","search_aliases":["alt query 1","alt query 2"]}
 ${SHARED_OBS_SCHEMA_TAIL}`;
     const user = `Tool: ${e.tool}
-File: ${episode.files.join(', ') || 'unknown'}
+File: ${episodeFiles.join(', ') || 'unknown'}
 Action: ${e.desc}
 Error: ${e.isError ? 'yes' : 'no'}`;
     prompt = { system, user };
@@ -743,7 +748,7 @@ ${actionList}`;
         narrative: truncate(parsed.narrative || '', 500),
         concepts: Array.isArray(parsed.concepts) ? parsed.concepts.slice(0, 10) : [],
         facts: Array.isArray(parsed.facts) ? parsed.facts.slice(0, 10) : [],
-        files: episode.files,
+        files: episodeFiles,
         filesRead: episode.filesRead || [],
         // v2.33.1: when lesson is low-signal, don't trust Haiku's importance
         // inflation. v2.54.0: extended from {change, discovery} to all types
@@ -752,7 +757,12 @@ ${actionList}`;
         // imp=2-3 even when lesson is null after retry. Keep `decision` exempt:
         // it's rare (39 obs / 94.9% hit-rate) and the retry path already gave
         // it a second chance; a no-lesson decision is still a worthwhile signal.
-        importance: isLessonLowSignal && parsed.type !== 'decision'
+        // `!retryRecovered`: when the P3 retry recovered a substantive lesson,
+        // the obs is no longer low-signal — capping it to 1 would negate the
+        // retry's entire purpose (a recovered bugfix lesson would silently drop
+        // out of --importance 2 searches and the working tier). Gate the cap on
+        // the *effective* low-signal state, not the pre-retry flag.
+        importance: isLessonLowSignal && !retryRecovered && parsed.type !== 'decision'
           ? Math.min(ruleImportance, 1)
           : Math.max(ruleImportance, clampImportance(parsed.importance)),
         lessonLearned,

package/hook-update.mjs

@@ -155,8 +155,22 @@ function isPluginMode() {
 // ── Dev Mode Detection ─────────────────────────────────────
 function isDevMode() {
   try {
-    const serverPath = join(INSTALL_DIR, 'server.mjs');
-    return existsSync(serverPath) && lstatSync(serverPath).isSymbolicLink();
+    // A dev checkout always carries a .git dir. This catches a whole-directory
+    // symlink (~/.claude-mem-lite -> /repo): lstat on server.mjs there follows the
+    // intermediate symlink and sees a regular file, so the per-file probe below
+    // would return false and auto-update would clobber the working tree.
+    if (existsSync(join(INSTALL_DIR, '.git'))) return true;
+    // Standard `install --dev` symlinks individual source files; checking several
+    // core files (not just server.mjs) survives the drift case where one file was
+    // replaced by a plain copy while the install is still symlink-provisioned —
+    // mirrors lib/doctor-drift.mjs's "any symlink ⇒ dev" detection. A copy-based
+    // real install (install.mjs non-dev) has no symlinks and no .git, so this
+    // cannot false-positive into never auto-updating.
+    for (const f of ['server.mjs', 'hook.mjs', 'cli.mjs', 'mem-cli.mjs']) {
+      const p = join(INSTALL_DIR, f);
+      if (existsSync(p) && lstatSync(p).isSymbolicLink()) return true;
+    }
+    return false;
   } catch { return false; }
 }
 

package/lib/observation-write.mjs

@@ -9,7 +9,7 @@
 // + vector writes in one db.transaction so a failure can't leave a partial row).
 
 import { getVocabulary, computeVector } from '../tfidf.mjs';
-import { debugCatch } from '../utils.mjs';
+import { debugCatch, cjkBigrams } from '../utils.mjs';
 
 // Canonical column order — must mirror the observations schema (schema.mjs).
 const OBS_COLUMNS = [
@@ -65,3 +65,20 @@ export function insertObservationVector(db, obsId, vecText) {
       .run(obsId, Buffer.from(vec.buffer), vocab.version, Date.now());
   } catch (e) { debugCatch(e, 'insertObservationVector'); }
 }
+
+/**
+ * Rebuild an observation's derived columns after a field UPDATE: the FTS `text`
+ * column (incl. CJK bigrams + search_aliases, matching the ingest paths) and the
+ * TF-IDF vector. cmdUpdate (CLI) and mem_update (MCP) previously hand-copied this
+ * block — the same drift class #8614/#8639 closed for compress/maintain. Caller
+ * owns the transaction (vector write is internally non-critical).
+ */
+export function rebuildObservationDerived(db, obsId) {
+  const row = db.prepare('SELECT title, subtitle, narrative, concepts, facts, lesson_learned, search_aliases FROM observations WHERE id = ?').get(obsId);
+  if (!row) return;
+  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, obsId);
+  insertObservationVector(db, obsId, textField);
+}

package/lib/recall-core.mjs

@@ -0,0 +1,43 @@
+// Single source of truth for file-keyed recall: the observation_files junction
+// query, LIKE-wildcard escaping, noise filtering, and the access-count bump.
+// cmdRecall (mem-cli.mjs) and mem_recall (server.mjs) previously hand-copied all
+// four — the drift class that produced the mem_get formatter drift (#8678) and
+// the maintain hand-sync drift (#8614). Renderers stay per-surface; the data
+// contract lives here.
+
+import { basename } from 'path';
+import { notLowSignalTitleClause } from '../utils.mjs';
+
+/**
+ * Recall observations linked to a file (basename or full path). Returns
+ * { filename, rows } where rows carry the column superset both surfaces render.
+ * Side effect: bumps access_count / last_accessed_at on every returned row —
+ * recall IS engagement, and the tier/decay system feeds on these counters.
+ */
+export function recallByFile(db, file, { limit = 10, includeNoise = false } = {}) {
+  const filename = basename(file);
+  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) {
+    const ph = rows.map(() => '?').join(',');
+    try {
+      db.prepare(`UPDATE observations SET access_count = COALESCE(access_count, 0) + 1, last_accessed_at = ? WHERE id IN (${ph})`)
+        .run(Date.now(), ...rows.map(r => r.id));
+    } catch { /* non-critical: FTS5 trigger may fail on corrupted index */ }
+  }
+
+  return { filename, rows };
+}

package/mem-cli.mjs

@@ -4,12 +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 { sanitizeFtsQuery, relaxFtsQueryToOr, truncate, typeIcon, inferProject, scrubSecrets, SESS_BM25, DEFAULT_DECAY_HALF_LIFE_MS } from './utils.mjs';
 import { cjkPrecisionOk } from './nlp.mjs';
 import { extractCjkLikePatterns } from './nlp.mjs';
 import { resolveProject } from './project-utils.mjs';
 import { computeTier, TIER_CASE_SQL, tierSqlParams } from './tier.mjs';
-import { getVocabulary, computeVector, _resetVocabCache } from './tfidf.mjs';
+import { _resetVocabCache } from './tfidf.mjs';
 import { autoBoostIfNeeded, reRankWithContext, markSuperseded } from './server-internals.mjs';
 import { searchObservationsHybrid, findFtsAnchor, countSearchTotal } from './search-engine.mjs';
 import { ensureRegistryDb, upsertResource } from './registry.mjs';
@@ -27,14 +27,16 @@ 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
 // router + remaining-command bodies during the incremental split. Future work:
 // move each cmdXxx into its own cli/<cmd>.mjs; mem-cli.mjs becomes pure dispatch.
-import { parseArgs, out, fail, relativeTime, fmtDateShort, parseIdToken, formatProbeHints, rejectBareStringFlags } from './cli/common.mjs';
+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 { AUTO_MERGE_THRESHOLD } from './lib/dedup-constants.mjs';
 import { countRecentHookErrors } from './lib/hook-telemetry.mjs';
 import {
@@ -493,35 +495,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({
@@ -559,24 +538,12 @@ function cmdRecall(db, args) {
 
 const OBS_FIELDS = ['id', 'type', 'title', 'subtitle', 'narrative', 'text', 'facts', 'concepts', 'lesson_learned', 'search_aliases', 'files_read', 'files_modified', 'project', 'created_at', 'memory_session_id', 'prompt_number', 'importance', 'related_ids', 'access_count', 'branch', 'superseded_at', 'superseded_by', 'last_accessed_at'];
 
-// Integer-typed time-epoch fields on the observations table that the `get`
-// command renders. Callers expect raw ms (audit) AND a relative-time hint
-// (human-scan), so formatObsFieldValue emits both. Other epoch fields like
-// `created_at_epoch` / `optimized_at` / `last_injected_at` aren't in
-// OBS_FIELDS so they don't surface via `get`.
-export const OBS_TIME_FIELDS = ['superseded_at', 'last_accessed_at'];
-
-// Pure formatter — null/undefined/non-time pass through; time fields on
-// integer values render as `<raw> (<relative>)` mirroring the convention
-// already used by `recent` / `timeline` / `recall`. Pre-2.63.0 the get
-// path printed bare ms (e.g. `last_accessed_at: 1778357330957`).
-export function formatObsFieldValue(field, val) {
-  if (val === null || val === undefined) return val;
-  if (OBS_TIME_FIELDS.includes(field) && typeof val === 'number') {
-    return `${val} (${relativeTime(val)})`;
-  }
-  return val;
-}
+// Time-field formatting moved to cli/common.mjs so the CLI `get` and the MCP
+// `mem_get` (server.mjs) share one source and can't drift (the drift bug:
+// MCP printed bare ms while CLI showed `<ms> (<relative>)`). Imported at the
+// top; re-exported here for back-compat with existing importers
+// (tests/get-time-format.test.mjs).
+export { OBS_TIME_FIELDS, formatObsFieldValue };
 
 function renderObsRows(db, ids, requestedFields) {
   const placeholders = ids.map(() => '?').join(',');
@@ -1720,28 +1687,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(', ')}`);
@@ -1797,12 +1747,15 @@ function cmdExport(db, args) {
 
   // Full round-trippable column set so `restore` rebuilds observations faithfully —
   // content + value-signals (access/cited/uncited/injection/decay) + branch + timing.
-  // Additive vs the pre-v2.90 13-col shape; existing `export | jq '.[].title'` consumers
-  // are unaffected. id + memory_session_id are informational (restore remaps id and
-  // buckets under a restore session).
+  // `search_aliases` is an FTS5-indexed column (BM25 weight 5) — dropping it on
+  // export silently lost the LLM-generated alternate query terms on restore, so a
+  // restored memory became unfindable by its aliases. Additive vs the pre-v2.90
+  // 13-col shape; existing `export | jq '.[].title'` consumers are unaffected.
+  // id + memory_session_id are informational (restore remaps id and buckets under
+  // a restore session).
   const rows = db.prepare(`
     SELECT id, memory_session_id, project, type, title, subtitle, narrative, concepts, facts,
-           files_read, files_modified, lesson_learned, importance, branch,
+           files_read, files_modified, lesson_learned, search_aliases, importance, branch,
            access_count, cited_count, uncited_streak, injection_count, decay_seen_count,
            last_accessed_at, created_at, created_at_epoch
     FROM observations WHERE ${wheres.join(' AND ')}
@@ -1863,7 +1816,7 @@ function cmdRestore(db, argv) {
 
   const dupCheck = db.prepare('SELECT id FROM observations WHERE project = ? AND title = ? AND created_at_epoch = ? LIMIT 1');
   const signalUpdate = db.prepare(`UPDATE observations SET
-      subtitle = ?, concepts = ?, facts = ?, files_read = ?, branch = COALESCE(?, branch),
+      subtitle = ?, concepts = ?, facts = ?, search_aliases = ?, files_read = ?, branch = COALESCE(?, branch),
       access_count = ?, cited_count = ?, uncited_streak = ?, injection_count = ?,
       decay_seen_count = ?, last_accessed_at = ?
     WHERE id = ?`);
@@ -1893,8 +1846,10 @@ function cmdRestore(db, argv) {
       });
       if (res.kind !== 'saved') { skipped++; continue; } // saveObservation Jaccard dedup
       // Re-apply the fields saveObservation zeros/derives so the backup is faithful.
+      // search_aliases is its own FTS5 column, so this UPDATE re-syncs the index
+      // (via the observations FTS triggers) and restored aliases stay searchable.
       signalUpdate.run(
-        r.subtitle || '', r.concepts || '', r.facts || '', r.files_read || '[]', r.branch ?? null,
+        r.subtitle || '', r.concepts || '', r.facts || '', r.search_aliases ?? null, r.files_read || '[]', r.branch ?? null,
         num(r.access_count), num(r.cited_count), num(r.uncited_streak), num(r.injection_count),
         num(r.decay_seen_count), r.last_accessed_at ?? null,
         res.id,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "2.96.0",
+  "version": "2.98.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,7 @@
     "lib/mem-override.mjs",
     "lib/save-observation.mjs",
     "lib/observation-write.mjs",
+    "lib/recall-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

package/server.mjs

@@ -5,7 +5,7 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
-import { truncate, typeIcon, sanitizeFtsQuery, relaxFtsQueryToOr, inferProject, scrubSecrets, cjkBigrams, fmtDate, debugLog, debugCatch, SESS_BM25, DEFAULT_DECAY_HALF_LIFE_MS, isPathConfined, notLowSignalTitleClause } from './utils.mjs';
+import { truncate, typeIcon, sanitizeFtsQuery, relaxFtsQueryToOr, inferProject, scrubSecrets, fmtDate, debugLog, debugCatch, SESS_BM25, DEFAULT_DECAY_HALF_LIFE_MS, isPathConfined } from './utils.mjs';
 import { extractCjkLikePatterns, cjkPrecisionOk } from './nlp.mjs';
 import { resolveProject as _resolveProjectShared } from './project-utils.mjs';
 import { ensureDb, DB_PATH, DB_DIR, REGISTRY_DB_PATH } from './schema.mjs';
@@ -20,6 +20,7 @@ import {
 } from './lib/maintain-core.mjs';
 import { effectiveQuiet, RUNTIME_DIR } from './hook-shared.mjs';
 import { computeTier, TIER_CASE_SQL, tierSqlParams } from './tier.mjs';
+import { formatObsFieldValue } from './cli/common.mjs';
 import { memSearchSchema, memRecentSchema, memTimelineSchema, memGetSchema, memDeleteSchema, memSaveSchema, memStatsSchema, memCompressSchema, memMaintainSchema, memOptimizeSchema, memUpdateSchema, memExportSchema, memRecallSchema, memFtsCheckSchema, memRegistrySchema, memBrowseSchema, memUseSchema, memDeferSchema, memDeferListSchema, memDeferDropSchema, tools as TOOL_DEFS } from './tool-schemas.mjs';
 
 // Lookup helper: all user-facing tool descriptions live in tool-schemas.mjs
@@ -31,18 +32,20 @@ function descriptionOf(name) {
   return d;
 }
 import { optimizePreview, optimizeRun } from './hook-optimize.mjs';
-import { basename, join, sep } from 'path';
+import { join, sep } from 'path';
 import { homedir } from 'os';
 import { ensureRegistryDb, upsertResource } from './registry.mjs';
 import { searchResources } from './registry-retriever.mjs';
 import { probeOtherSources as probeIdSources, parseIdToken, bucketIdTokens } from './lib/id-routing.mjs';
 import { saveObservation } from './lib/save-observation.mjs';
+import { rebuildObservationDerived } from './lib/observation-write.mjs';
+import { recallByFile } from './lib/recall-core.mjs';
 import { AUTO_MERGE_THRESHOLD } from './lib/dedup-constants.mjs';
 import {
   insertDeferred, listOpenWithOrdinal, dropDeferred,
   resolveDeferredIds, closeDeferredItems,
 } from './lib/deferred-work.mjs';
-import { getVocabulary, _resetVocabCache, computeVector } from './tfidf.mjs';
+import { _resetVocabCache } from './tfidf.mjs';
 import { createRequire } from 'module';
 
 const require = createRequire(import.meta.url);
@@ -801,8 +804,12 @@ server.registerTool(
           const val = row[f];
           if (val === null || val === undefined || val === '') continue;
           if (f === 'text' && row.narrative && typeof val === 'string' && val.startsWith(row.narrative)) continue;
+          // Shared formatter (cli/common.mjs) renders epoch-ms time fields as
+          // `<ms> (<relative>)` — parity with the CLI `get` path so an LLM reader
+          // gets a scannable hint instead of a bare millisecond integer.
+          const display = formatObsFieldValue(f, val);
           const maxLen = f === 'narrative' ? 1000 : f === 'lesson_learned' ? 500 : f === 'text' ? 500 : 200;
-          lines.push(`${f}: ${typeof val === 'string' && val.length > maxLen ? val.slice(0, maxLen) + '…' : val}`);
+          lines.push(`${f}: ${typeof display === 'string' && display.length > maxLen ? display.slice(0, maxLen) + '…' : display}`);
         }
         sections.push(lines.join('\n'));
       }
@@ -1814,28 +1821,11 @@ server.registerTool(
 
     params.push(args.id);
 
-    // Atomic: update fields + rebuild FTS text + re-vectorize
+    // Atomic: update fields + rebuild derived columns (FTS text + vector) via the
+    // shared core — single source with CLI cmdUpdate (lib/observation-write.mjs).
     db.transaction(() => {
       db.prepare(`UPDATE observations SET ${updates.join(', ')} WHERE id = ?`).run(...params);
-
-      // Rebuild FTS text field (must include CJK bigrams + search_aliases to match mem_save/hook-llm)
-      const row = db.prepare('SELECT title, subtitle, narrative, concepts, facts, lesson_learned, search_aliases FROM observations WHERE id = ?').get(args.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, args.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(args.id, Buffer.from(vec.buffer), vocab.version, Date.now());
-          }
-        }
-      } catch (e) { debugCatch(e, 'mem_update-vector'); }
+      rebuildObservationDerived(db, args.id);
     })();
 
     return { content: [{ type: 'text', text: `Updated observation #${args.id}: ${updates.map(u => u.split(' =')[0]).join(', ')}` }] };
@@ -1901,35 +1891,16 @@ server.registerTool(
     inputSchema: memRecallSchema,
   },
   safeHandler(async (args) => {
-    const filename = basename(args.file);
-    const limit = args.limit ?? 10;
-    const includeNoise = args.include_noise === true;
-
-    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.created_at, 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);
+    // Shared core with CLI cmdRecall: query + escaping + access bump (lib/recall-core.mjs)
+    const { filename, rows } = recallByFile(db, args.file, {
+      limit: args.limit ?? 10,
+      includeNoise: args.include_noise === true,
+    });
 
     if (rows.length === 0) {
       return { content: [{ type: 'text', text: `No history for "${filename}". This file hasn't been observed yet.` }] };
     }
 
-    // Update access_count for recalled observations
-    const recalledIds = rows.map(r => r.id);
-    const ph = recalledIds.map(() => '?').join(',');
-    try {
-      db.prepare(`UPDATE observations SET access_count = COALESCE(access_count, 0) + 1, last_accessed_at = ? WHERE id IN (${ph})`).run(Date.now(), ...recalledIds);
-    } catch { /* non-critical: FTS5 trigger may fail on corrupted index */ }
-
     const lines = [`History for ${filename} (${rows.length} observation${rows.length !== 1 ? 's' : ''}):\n`];
     for (const r of rows) {
       const lesson = r.lesson_learned ? `\n     Lesson: ${truncate(r.lesson_learned, 100)}` : '';

package/source-files.mjs

@@ -82,6 +82,7 @@ export const SOURCE_FILES = [
   // entry-point-reachable); missing it from the manifest would break ALL saves on
   // auto-update. Same single-source-of-truth pattern (see #8217).
   'lib/observation-write.mjs',
+  'lib/recall-core.mjs',
   // Shared "compress old low-value observations into weekly summaries" core.
   // Statically imported by mem-cli.mjs (cmdCompress), server.mjs (mem_compress),
   // and hook.mjs (handleAutoCompress) — same single-source-of-truth pattern as

package/tool-schemas.mjs

@@ -218,11 +218,15 @@ export const memMaintainSchema = {
 
 export const memUpdateSchema = {
   id: coerceInt.pipe(z.number().int().positive()).describe('Observation ID to update'),
-  title: z.string().optional().describe('New title'),
+  // CLI parity (cmdUpdate): empty/whitespace title would render as `(untitled)`
+  // in every listing — reject here like the CLI does, instead of persisting it.
+  title: z.string().refine(s => s.trim() !== '', 'title cannot be empty').optional().describe('New title'),
   narrative: z.string().optional().describe('New narrative/content'),
   type: OBS_TYPE_ENUM.optional().describe('New observation type'),
   importance: coerceInt.pipe(z.number().int().min(1).max(3)).optional().describe('New importance (1-3)'),
-  lesson_learned: z.string().optional().describe('Add or update lesson learned'),
+  // 500-char cap mirrors memSaveSchema + cmdUpdate — update was the one path
+  // that let overlong lessons leak into the DB via MCP.
+  lesson_learned: z.string().max(500).optional().describe('Add or update lesson learned'),
   concepts: z.string().optional().describe('Space-separated concept tags'),
 };