claude-mem-lite 2.37.0 → 2.39.0

package/.claude-plugin/marketplace.json

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

package/hook-memory.mjs

@@ -1,7 +1,7 @@
 // claude-mem-lite — Semantic Memory Injection
 // Search past observations for relevant memories to inject as context at user-prompt time.
 
-import { sanitizeFtsQuery, relaxFtsQueryToOr, debugCatch, OBS_BM25, notLowSignalTitleClause, noisePenaltyClause } from './utils.mjs';
+import { sanitizeFtsQuery, relaxFtsQueryToOr, debugCatch, OBS_BM25, notLowSignalTitleClause, noisePenaltyClause, tokenizeHandoff, HANDOFF_STOP_WORDS, extractCjkKeywords } from './utils.mjs';
 
 const MAX_MEMORY_INJECTIONS = 3;
 const MEMORY_LOOKBACK_MS = 60 * 86400000; // 60 days
@@ -16,6 +16,43 @@ 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;
 
+// v27: term-coverage post-filter. Drops high-BM25 candidates whose visible
+// fields (title + lesson_learned) cover <N% of the query's significant terms.
+// Catches the failure mode where FTS tokenization reduces a rich query to a
+// sparse token set and rows sharing only one common word get ranked high.
+// Default 0.4 (≥40% term coverage). Env override `MEM_COVERAGE_THRESHOLD` ∈ [0,1];
+// set to 0 to disable entirely.
+const COVERAGE_MIN_QUERY_TERMS = 2;
+function getCoverageThreshold() {
+  const raw = process.env.MEM_COVERAGE_THRESHOLD;
+  if (raw === undefined || raw === '') return 0.4;
+  const n = parseFloat(raw);
+  return Number.isFinite(n) && n >= 0 && n <= 1 ? n : 0.4;
+}
+function extractQueryTerms(text) {
+  if (!text) return [];
+  const ascii = tokenizeHandoff(text).filter(t => !HANDOFF_STOP_WORDS.has(t));
+  let cjk = [];
+  try { cjk = extractCjkKeywords(text) || []; } catch { /* CJK extraction best-effort */ }
+  return [...new Set([...ascii, ...cjk.map(t => String(t).toLowerCase())])];
+}
+function candidateCoverage(row, queryTerms) {
+  if (queryTerms.length === 0) return 1.0;
+  const hay = `${row.title || ''} ${row.lesson_learned || ''}`.toLowerCase();
+  let hits = 0;
+  for (const t of queryTerms) {
+    if (/[^ -~]/.test(t)) {
+      // Non-ASCII (CJK etc): no word boundary semantics, substring match is correct.
+      if (hay.includes(t)) hits++;
+    } else {
+      // ASCII: require word-boundary match so "race" doesn't match "trace".
+      const re = new RegExp(`\\b${t.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'i');
+      if (re.test(hay)) hits++;
+    }
+  }
+  return hits / queryTerms.length;
+}
+
 const FILE_RECALL_LOOKBACK_MS = 60 * 86400000; // 60 days
 const MAX_FILE_RECALL = 2;
 
@@ -142,13 +179,27 @@ export function searchRelevantMemories(db, userPrompt, project, excludeIds = [])
     const aboveThreshold = scored.filter(r => r.score >= threshold);
     if (aboveThreshold.length === 0) return [];
 
+    // v27: term-coverage filter — drop candidates whose title+lesson_learned
+    // covers <threshold of the query's significant terms. Skipped for
+    // single-term queries (coverage signal is meaningless) and when the env
+    // override disables it.
+    let coverageFiltered = aboveThreshold;
+    const coverageThreshold = getCoverageThreshold();
+    if (coverageThreshold > 0) {
+      const queryTerms = extractQueryTerms(userPrompt);
+      if (queryTerms.length >= COVERAGE_MIN_QUERY_TERMS) {
+        coverageFiltered = aboveThreshold.filter(r => candidateCoverage(r, queryTerms) >= coverageThreshold);
+        if (coverageFiltered.length === 0) return [];
+      }
+    }
+
     // v26 P0: bump injection_count (NOT access_count) for injected rows.
     // Before v26 this was bumping access_count, which conflated auto-injection
     // with real cites/recalls/opens — polluting the noise-ratio signal the
     // penalty clause now depends on. access_count is reserved for explicit
     // access (cmdRecall/cmdGet/cmdTimeline/pre-tool-recall/citation-tracker).
     // Per-row try/catch for FTS trigger safety (project_non_obvious.md).
-    const result = aboveThreshold.slice(0, MAX_MEMORY_INJECTIONS);
+    const result = coverageFiltered.slice(0, MAX_MEMORY_INJECTIONS);
     const now = Date.now();
     const bumpStmt = db.prepare(
       'UPDATE observations SET injection_count = COALESCE(injection_count, 0) + 1, last_injected_at = ? WHERE id = ?'

package/lib/id-routing.mjs

@@ -0,0 +1,37 @@
+// Shared probe for "ID-not-found-in-requested-source" hints.
+// Used by CLI cmdGet (mem-cli.mjs) and MCP mem_get (server.mjs) so both
+// produce consistent redirect hints — if the probe schema drifts, both
+// paths update together.
+//
+// The formatter stays per-call-site because CLI and MCP surface format
+// differently (stderr vs response text); only the SQL layer is shared.
+
+/**
+ * Probe the observations / session_summaries / user_prompts tables for any
+ * of the given numeric IDs, excluding the sources the caller already queried.
+ *
+ * @param {import('better-sqlite3').Database} db
+ * @param {number[]} ids Numeric IDs to probe (non-negative ints).
+ * @param {Set<'obs'|'session'|'prompt'>} excludeSrcs Sources to skip.
+ * @returns {{obs:number[], session:number[], prompt:number[]}}
+ */
+export function probeOtherSources(db, ids, excludeSrcs) {
+  const result = { obs: [], session: [], prompt: [] };
+  if (!ids || ids.length === 0) return result;
+  const placeholders = ids.map(() => '?').join(',');
+  try {
+    if (!excludeSrcs.has('obs')) {
+      const hits = db.prepare(`SELECT id FROM observations WHERE id IN (${placeholders})`).all(...ids);
+      result.obs = hits.map(r => r.id);
+    }
+    if (!excludeSrcs.has('session')) {
+      const hits = db.prepare(`SELECT id FROM session_summaries WHERE id IN (${placeholders})`).all(...ids);
+      result.session = hits.map(r => r.id);
+    }
+    if (!excludeSrcs.has('prompt')) {
+      const hits = db.prepare(`SELECT id FROM user_prompts WHERE id IN (${placeholders})`).all(...ids);
+      result.prompt = hits.map(r => r.id);
+    }
+  } catch { /* best-effort hint; never block the caller */ }
+  return result;
+}

package/mem-cli.mjs

@@ -15,6 +15,7 @@ import { searchResources } from './registry-retriever.mjs';
 import { optimizePreview, optimizeRun } from './hook-optimize.mjs';
 import { buildSessionContextLines } from './hook-context.mjs';
 import { cmdAdopt, cmdUnadopt } from './adopt-cli.mjs';
+import { probeOtherSources as probeIdSources } from './lib/id-routing.mjs';
 import { basename } from 'path';
 import { readFileSync } from 'fs';
 
@@ -77,6 +78,30 @@ function fmtDateShort(iso) {
   return iso.slice(0, 10); // YYYY-MM-DD
 }
 
+// Parse an ID token from a command positional argument.
+// Accepts: `123`, `#123`, `P#123` / `p123` (prompt), `S#123` / `s123` (session).
+// Returns { source: 'obs'|'session'|'prompt'|null, id: number } or null if unparseable.
+// source===null means no explicit prefix — caller picks default (typically 'obs').
+function parseIdToken(raw) {
+  const m = /^([PpSs]?)#?(\d+)$/.exec(String(raw).trim());
+  if (!m) return null;
+  const p = m[1].toUpperCase();
+  const id = parseInt(m[2], 10);
+  if (!Number.isFinite(id) || id <= 0) return null;
+  const source = p === 'P' ? 'prompt' : p === 'S' ? 'session' : null;
+  return { source, id };
+}
+
+// Format the shared `probeIdSources` output as CLI hint strings.
+// Example: ["#5419 (obs)", "P#5417 (prompt)"] — callers join with "; ".
+function formatProbeHints(probe) {
+  const hints = [];
+  if (probe.obs.length > 0)     hints.push(`#${probe.obs.join(', #')} (obs)`);
+  if (probe.session.length > 0) hints.push(`S#${probe.session.join(', S#')} (session)`);
+  if (probe.prompt.length > 0)  hints.push(`P#${probe.prompt.join(', P#')} (prompt)`);
+  return hints;
+}
+
 // ─── Commands ────────────────────────────────────────────────────────────────
 
 function cmdSearch(db, args) {
@@ -571,57 +596,107 @@ 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'];
+
+function renderObsRows(db, ids, requestedFields) {
+  const placeholders = ids.map(() => '?').join(',');
+  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 WHERE id IN (${placeholders}) ORDER BY created_at_epoch ASC`).all(...ids);
+  if (rows.length === 0) return null;
+  const fields = requestedFields || OBS_FIELDS;
+  const parts = [];
+  for (const r of rows) {
+    const lines = [`#${r.id} [${r.type}] ${fmtDateShort(r.created_at)}`];
+    for (const f of fields) {
+      if (f === 'id' || f === 'type' || f === 'created_at') continue;
+      const val = r[f];
+      if (val === null || val === undefined || val === '') continue;
+      if (f === 'text' && r.narrative && typeof val === 'string' && val.startsWith(r.narrative)) continue;
+      const maxLen = f === 'narrative' ? 1000 : f === 'lesson_learned' ? 500 : f === 'text' ? 500 : 200;
+      const display = typeof val === 'string' && val.length > maxLen ? val.slice(0, maxLen) + '…' : val;
+      lines.push(`${f}: ${display}`);
+    }
+    parts.push(lines.join('\n'));
+  }
+  return { text: parts.join('\n\n'), count: rows.length };
+}
+
+function renderSessionRows(db, ids) {
+  const placeholders = ids.map(() => '?').join(',');
+  const rows = db.prepare(`SELECT * FROM session_summaries WHERE id IN (${placeholders}) ORDER BY created_at_epoch ASC`).all(...ids);
+  if (rows.length === 0) return null;
+  const parts = [];
+  for (const r of rows) {
+    const lines = [`S#${r.id} ${fmtDateShort(r.created_at)}`];
+    if (r.request) lines.push(`Request: ${r.request}`);
+    if (r.completed) lines.push(`Completed: ${r.completed}`);
+    if (r.investigated) lines.push(`Investigated: ${r.investigated}`);
+    if (r.learned) lines.push(`Learned: ${r.learned}`);
+    if (r.next_steps) lines.push(`Next steps: ${r.next_steps}`);
+    if (r.project) lines.push(`Project: ${r.project}`);
+    parts.push(lines.join('\n'));
+  }
+  return { text: parts.join('\n\n'), count: rows.length };
+}
+
+function renderPromptRows(db, ids) {
+  const placeholders = ids.map(() => '?').join(',');
+  const rows = db.prepare(`SELECT * FROM user_prompts WHERE id IN (${placeholders}) ORDER BY created_at_epoch ASC`).all(...ids);
+  if (rows.length === 0) return null;
+  const parts = [];
+  for (const r of rows) {
+    const lines = [`P#${r.id} ${fmtDateShort(r.created_at)}`];
+    if (r.prompt_text) lines.push(`Text: ${r.prompt_text}`);
+    if (r.content_session_id) lines.push(`Session: ${r.content_session_id}`);
+    parts.push(lines.join('\n'));
+  }
+  return { text: parts.join('\n\n'), count: rows.length };
+}
+
 function cmdGet(db, args) {
   const { positional, flags } = parseArgs(args);
   const idStr = positional.join(',');
   if (!idStr) {
-    fail('[mem] Usage: mem get <id1,id2,...> [--source obs|session|prompt] [--fields f1,f2,...]');
+    fail('[mem] Usage: mem get <id1,id2,...> [--source obs|session|prompt] [--fields f1,f2,...]\n' +
+         '        IDs accept prefix from search output: #123 (obs), P#123 (prompt), S#123 (session).');
     return;
   }
 
-  const ids = idStr.split(',').map(s => parseInt(s.trim(), 10)).filter(n => !isNaN(n));
-  if (ids.length === 0) {
+  const tokens = idStr.split(',').map(s => s.trim()).filter(Boolean);
+  const unparseable = [];
+  const parsed = [];
+  for (const t of tokens) {
+    const p = parseIdToken(t);
+    if (p) parsed.push(p);
+    else unparseable.push(t);
+  }
+  if (unparseable.length > 0) {
+    process.stderr.write(`[mem] Ignoring unparseable ID token(s): ${unparseable.join(', ')}\n`);
+  }
+  if (parsed.length === 0) {
     fail('[mem] No valid IDs provided');
     return;
   }
 
-  const source = flags.source || 'obs';
-  const placeholders = ids.map(() => '?').join(',');
-
-  if (source === 'session') {
-    const rows = db.prepare(`SELECT * FROM session_summaries WHERE id IN (${placeholders}) ORDER BY created_at_epoch ASC`).all(...ids);
-    if (rows.length === 0) { fail('[mem] No sessions found for given IDs'); return; }
-    const parts = [];
-    for (const r of rows) {
-      const lines = [`S#${r.id} ${fmtDateShort(r.created_at)}`];
-      if (r.request) lines.push(`Request: ${r.request}`);
-      if (r.completed) lines.push(`Completed: ${r.completed}`);
-      if (r.investigated) lines.push(`Investigated: ${r.investigated}`);
-      if (r.learned) lines.push(`Learned: ${r.learned}`);
-      if (r.next_steps) lines.push(`Next steps: ${r.next_steps}`);
-      if (r.project) lines.push(`Project: ${r.project}`);
-      parts.push(lines.join('\n'));
-    }
-    out(parts.join('\n\n'));
+  // Explicit --source overrides any prefix; otherwise each token's prefix routes individually.
+  const explicit = flags.source;
+  const validSources = new Set(['obs', 'session', 'prompt']);
+  if (explicit && !validSources.has(explicit)) {
+    fail(`[mem] Invalid --source "${explicit}". Use: obs, session, prompt`);
     return;
   }
 
-  if (source === 'prompt') {
-    const rows = db.prepare(`SELECT * FROM user_prompts WHERE id IN (${placeholders}) ORDER BY created_at_epoch ASC`).all(...ids);
-    if (rows.length === 0) { fail('[mem] No prompts found for given IDs'); return; }
-    const parts = [];
-    for (const r of rows) {
-      const lines = [`P#${r.id} ${fmtDateShort(r.created_at)}`];
-      if (r.prompt_text) lines.push(`Text: ${r.prompt_text}`);
-      if (r.content_session_id) lines.push(`Session: ${r.content_session_id}`);
-      parts.push(lines.join('\n'));
-    }
-    out(parts.join('\n\n'));
-    return;
+  const bySrc = { obs: [], session: [], prompt: [] };
+  for (const p of parsed) {
+    const src = explicit || p.source || 'obs';
+    bySrc[src].push(p.id);
   }
 
-  // Default: observations (aligned with MCP mem_get)
-  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'];
+  // Validate --fields against obs schema (only meaningful for obs rows).
   let requestedFields = null;
   if (flags.fields) {
     const allRequested = flags.fields.split(',').map(s => s.trim());
@@ -636,50 +711,107 @@ function cmdGet(db, args) {
     }
   }
 
-  // Update access_count + auto-boost (aligned with MCP mem_get)
-  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
-    WHERE id IN (${placeholders})
-    ORDER BY created_at_epoch ASC
-  `).all(...ids);
-
-  if (rows.length === 0) {
-    fail('[mem] No observations found for given IDs');
-    return;
+  const sections = [];
+  let totalFound = 0;
+  if (bySrc.obs.length > 0) {
+    const s = renderObsRows(db, bySrc.obs, requestedFields);
+    if (s) { sections.push(s.text); totalFound += s.count; }
+  }
+  if (bySrc.session.length > 0) {
+    const s = renderSessionRows(db, bySrc.session);
+    if (s) { sections.push(s.text); totalFound += s.count; }
+  }
+  if (bySrc.prompt.length > 0) {
+    const s = renderPromptRows(db, bySrc.prompt);
+    if (s) { sections.push(s.text); totalFound += s.count; }
   }
 
-  const fields = requestedFields || OBS_FIELDS;
-  const parts = [];
-  for (const r of rows) {
-    const lines = [`#${r.id} [${r.type}] ${fmtDateShort(r.created_at)}`];
-    for (const f of fields) {
-      if (f === 'id' || f === 'type' || f === 'created_at') continue; // already in header
-      const val = r[f];
-      if (val === null || val === undefined || val === '') continue;
-      // Skip 'text' field when it duplicates narrative (aligned with MCP mem_get)
-      if (f === 'text' && r.narrative && typeof val === 'string' && val.startsWith(r.narrative)) continue;
-      const maxLen = f === 'narrative' ? 1000 : f === 'lesson_learned' ? 500 : f === 'text' ? 500 : 200;
-      const display = typeof val === 'string' && val.length > maxLen ? val.slice(0, maxLen) + '…' : val;
-      lines.push(`${f}: ${display}`);
-    }
-    parts.push(lines.join('\n'));
+  if (totalFound === 0) {
+    // Probe the OTHER sources so the caller can retry with the right prefix.
+    const queried = new Set(Object.entries(bySrc).filter(([, v]) => v.length > 0).map(([k]) => k));
+    const allIds = parsed.map(p => p.id);
+    const probe = probeIdSources(db, allIds, queried);
+    const hits = formatProbeHints(probe);
+    const hint = hits.length > 0 ? ` Try: ${hits.join('; ')}.` : '';
+    const queriedList = [...queried].join(', ');
+    fail(`[mem] No records found in source(s) [${queriedList}] for the given ID(s).${hint}`);
+    return;
   }
 
-  out(parts.join('\n\n'));
+  out(sections.join('\n\n'));
 }
 
 function cmdTimeline(db, args) {
   const { positional, flags } = parseArgs(args);
-  let anchorId = parseInt(flags.anchor, 10);
   const before = parseInt(flags.before, 10) || 5;
   const after = parseInt(flags.after, 10) || 5;
   const project = flags.project ? resolveProject(db, flags.project) : null;
 
+  // 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.
+  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.`);
+      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 obsExists = db.prepare('SELECT 1 FROM observations WHERE id = ?').get(parsed.id);
+      if (obsExists) {
+        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})`;
+      }
+    }
+  }
+
   // Support query-based anchor: `timeline --query "search terms"` or positional
   // Uses recency-weighted BM25 + project filter (aligned with MCP mem_timeline)
   const queryStr = flags.query || positional.join(' ');
@@ -773,7 +905,7 @@ function cmdTimeline(db, args) {
 
   const all = [...beforeRows.reverse(), anchor, ...afterRows];
 
-  out(`[mem] Timeline around #${anchorId}:`);
+  out(`[mem] Timeline around #${anchorId}${anchorNote ? ' ' + anchorNote : ''}:`);
   for (const r of all) {
     const marker = r.id === anchorId ? ' <--' : '';
     const time = relativeTime(r.created_at_epoch);
@@ -1162,7 +1294,19 @@ function cmdDelete(db, args) {
     return;
   }
 
-  const ids = idStr.split(',').map(s => parseInt(s.trim(), 10)).filter(n => !isNaN(n));
+  // delete operates on observations only. Reject P#/S# explicitly so callers aren't
+  // surprised by silent NaN filtering when they paste search-output IDs.
+  const tokens = idStr.split(',').map(s => s.trim()).filter(Boolean);
+  const nonObs = tokens.filter(t => /^[PpSs]#?\d+$/.test(t));
+  if (nonObs.length > 0) {
+    fail(`[mem] delete only works on observations. Rejected: ${nonObs.join(', ')}. ` +
+         `Prompts and sessions are append-only — inspect with \`mem get P#N --source prompt\` / \`--source session\`.`);
+    return;
+  }
+  const ids = tokens.map(t => {
+    const p = parseIdToken(t);
+    return p && p.source === null ? p.id : NaN;
+  }).filter(n => !isNaN(n));
   if (ids.length === 0) {
     fail('[mem] No valid IDs provided');
     return;
@@ -1215,7 +1359,14 @@ function cmdDelete(db, args) {
 
 function cmdUpdate(db, args) {
   const { positional, flags } = parseArgs(args);
-  const id = parseInt(positional[0], 10);
+  const raw = positional[0];
+  if (raw && /^[PpSs]#?\d+$/.test(String(raw).trim())) {
+    fail(`[mem] update only works on observations. Rejected: ${raw}. ` +
+         `Prompts and sessions are append-only.`);
+    return;
+  }
+  const parsed = raw ? parseIdToken(raw) : null;
+  const id = parsed && parsed.source === null ? parsed.id : parseInt(raw, 10);
   if (!id || isNaN(id)) {
     fail('[mem] Usage: mem update <id> [--title T] [--type T] [--importance N] [--lesson T] [--narrative T] [--concepts T]');
     return;
@@ -1919,11 +2070,14 @@ Commands:
     --limit N           Max results (default 10)
 
   get <id1,id2,...>     Get full details by ID
-    --source S          Record type: obs (default), session, prompt
-    --fields f1,f2,...  Select specific fields to return
+    IDs accept search-output prefixes: #123 (obs), P#123 (prompt), S#123 (session).
+    Bare N defaults to obs. Mixed prefixes in one call route each token correctly.
+    --source S          Force record type (obs|session|prompt); overrides prefixes.
+    --fields f1,f2,...  Select specific fields to return (observations only).
 
   timeline              Show observations around an anchor (shows recent if no anchor)
-    --anchor ID         Center on this observation ID
+    --anchor ID         Center on this ID. Accepts N, #N, P#N, or S#N — P#/S# anchors
+                        resolve to the nearest-in-time observation in the same project.
     --query "text"      Find anchor by FTS5 search
     --before N          Show N before anchor (default 5)
     --after N           Show N after anchor (default 5)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "2.37.0",
+  "version": "2.39.0",
   "description": "Lightweight persistent memory system for Claude Code",
   "type": "module",
   "engines": {
@@ -51,6 +51,7 @@
     "lib/stats-quality.mjs",
     "lib/low-signal-patterns.mjs",
     "lib/citation-tracker.mjs",
+    "lib/id-routing.mjs",
     "registry.mjs",
     "registry-retriever.mjs",
     "registry-indexer.mjs",

package/server.mjs

@@ -27,6 +27,7 @@ import { basename, join } from 'path';
 import { homedir } from 'os';
 import { ensureRegistryDb, upsertResource } from './registry.mjs';
 import { searchResources } from './registry-retriever.mjs';
+import { probeOtherSources as probeIdSources } from './lib/id-routing.mjs';
 import { getVocabulary, rebuildVocabulary, _resetVocabCache, computeVector, vectorSearch, rrfMerge } from './tfidf.mjs';
 import { createRequire } from 'module';
 
@@ -898,17 +899,14 @@ server.registerTool(
     }
 
     if (rows.length === 0) {
-      // P2-7: for source=session/prompt, check whether the IDs exist as observations so the
-      // caller can switch source instead of chasing a phantom miss.
-      let hint = '';
-      if (source === 'session' || source === 'prompt') {
-        try {
-          const obsHits = db.prepare(`SELECT id FROM observations WHERE id IN (${placeholders})`).all(...args.ids);
-          if (obsHits.length > 0) {
-            hint = ` These ID(s) exist as observations: ${obsHits.map(r => r.id).join(', ')}. Try source='obs'.`;
-          }
-        } catch { /* best-effort hint */ }
-      }
+      // Symmetric probe via shared lib/id-routing.mjs so CLI cmdGet and MCP mem_get
+      // stay aligned if a table's ID semantics change.
+      const probe = probeIdSources(db, args.ids, new Set([source]));
+      const hints = [];
+      if (probe.obs.length > 0)     hints.push(`#${probe.obs.join(', #')} (obs — use source='obs')`);
+      if (probe.session.length > 0) hints.push(`S#${probe.session.join(', S#')} (session — use source='session')`);
+      if (probe.prompt.length > 0)  hints.push(`P#${probe.prompt.join(', P#')} (prompt — use source='prompt')`);
+      const hint = hints.length > 0 ? ` Try: ${hints.join('; ')}.` : '';
       const msg = `No ${sourceLabel} found for given IDs.${hint}`;
       return { content: [{ type: 'text', text: fieldsNote ? `${msg}\n\n${fieldsNote}` : msg }] };
     }

package/source-files.mjs

@@ -38,6 +38,7 @@ export const SOURCE_FILES = [
   'lib/stats-quality.mjs',
   'lib/low-signal-patterns.mjs',
   'lib/citation-tracker.mjs',
+  'lib/id-routing.mjs',
   // v2.32 invited-memory: memdir primitives + adopt/unadopt CLI
   'memdir.mjs',
   'adopt-content.mjs',

package/tool-schemas.mjs

@@ -275,7 +275,9 @@ export const tools = [
       '  - A mem_search hit looks relevant and you need the supporting detail\n' +
       '  - For session (S#) or prompt (P#) hits, pass source="session" or "prompt"\n' +
       '\n' +
-      'Equivalent CLI: claude-mem-lite get <id>[,<id>,...]',
+      'On miss, response includes "Try: …" hint listing other sources the ID lives in.\n' +
+      '\n' +
+      'Equivalent CLI: claude-mem-lite get <id>[,<id>,...] — accepts P#/S#/# prefix.',
     inputSchema: memGetSchema,
   },
   {