claude-mem-lite 2.42.0 → 2.44.0

package/.claude-plugin/marketplace.json

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

package/install.mjs

@@ -1205,7 +1205,7 @@ async function doctor() {
     if (r.drift) {
       const names = r.details.join(', ');
       const suffix = r.plainCount > r.details.length ? ` +${r.plainCount - r.details.length} more` : '';
-      warn(`Dev drift: ${r.plainCount} non-symlink file(s) in dev install: ${names}${suffix} (re-run: node install.mjs install --dev)`);
+      warn(`Dev drift: ${r.plainCount} non-symlink file(s) in dev install: ${names}${suffix} (re-run: node ${join(PROJECT_DIR, 'install.mjs')} install --dev)`);
       issues++;
     } else if (r.devMode) {
       ok(`Dev drift: clean (${r.symlinkCount} symlinks, 0 plain)`);

package/lib/id-routing.mjs

@@ -25,6 +25,35 @@ export function parseIdToken(raw) {
   return { source, id };
 }
 
+/**
+ * Group mixed ID tokens by source. Accepts bare ints, `#N`, `P#N`, `S#N`,
+ * and raw strings — the same shapes parseIdToken handles. Used by CLI
+ * cmdGet and MCP mem_get so both paths route paste-from-search tokens
+ * consistently (closes the #8127 parity gap).
+ *
+ * An explicit source override (from `--source` or `args.source`) wins over
+ * per-token prefixes. Un-prefixed tokens fall back to `defaultSource`.
+ *
+ * @param {Array<string|number>} tokens Mixed input — order preserved within each bucket.
+ * @param {{explicit?: 'obs'|'session'|'prompt'|null, defaultSource?: 'obs'|'session'|'prompt'}} opts
+ * @returns {{bySrc: {obs:number[], session:number[], prompt:number[]}, invalid: string[]}}
+ */
+export function bucketIdTokens(tokens, { explicit = null, defaultSource = 'obs' } = {}) {
+  const bySrc = { obs: [], session: [], prompt: [] };
+  const invalid = [];
+  for (const raw of tokens) {
+    if (typeof raw === 'number' && Number.isFinite(raw) && raw > 0) {
+      bySrc[explicit || defaultSource].push(raw);
+      continue;
+    }
+    const p = parseIdToken(raw);
+    if (!p) { invalid.push(String(raw)); continue; }
+    const src = explicit || p.source || defaultSource;
+    bySrc[src].push(p.id);
+  }
+  return { bySrc, invalid };
+}
+
 /**
  * Probe the observations / session_summaries / user_prompts tables for any
  * of the given numeric IDs, excluding the sources the caller already queried.

package/mem-cli.mjs

@@ -15,7 +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 { probeOtherSources as probeIdSources, bucketIdTokens } from './lib/id-routing.mjs';
 import { basename } from 'path';
 import { readFileSync } from 'fs';
 
@@ -484,23 +484,26 @@ function cmdRecall(db, args) {
   const { positional, flags } = parseArgs(args);
   const file = positional.join(' ');
   if (!file) {
-    fail('[mem] Usage: mem recall <file>');
+    fail('[mem] Usage: mem recall <file> [--limit N] [--include-noise]');
     return;
   }
 
   const filename = basename(file);
   const rawLimit = flags.limit !== undefined ? parseInt(flags.limit, 10) : NaN;
   const limit = Number.isInteger(rawLimit) ? Math.max(1, rawLimit) : 10;
+  const includeNoise = flags['include-noise'] === true || flags['include-noise'] === '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.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);
@@ -597,20 +600,6 @@ function cmdGet(db, args) {
   }
 
   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;
-  }
 
   // Explicit --source overrides any prefix; otherwise each token's prefix routes individually.
   const explicit = flags.source;
@@ -620,10 +609,14 @@ function cmdGet(db, args) {
     return;
   }
 
-  const bySrc = { obs: [], session: [], prompt: [] };
-  for (const p of parsed) {
-    const src = explicit || p.source || 'obs';
-    bySrc[src].push(p.id);
+  // Shared bucketing with MCP mem_get — single source of truth for P#/S#/# routing (#8050).
+  const { bySrc, invalid: unparseable } = bucketIdTokens(tokens, { explicit, defaultSource: 'obs' });
+  if (unparseable.length > 0) {
+    process.stderr.write(`[mem] Ignoring unparseable ID token(s): ${unparseable.join(', ')}\n`);
+  }
+  if (bySrc.obs.length + bySrc.session.length + bySrc.prompt.length === 0) {
+    fail('[mem] No valid IDs provided');
+    return;
   }
 
   // Validate --fields against obs schema (only meaningful for obs rows).
@@ -659,7 +652,7 @@ function cmdGet(db, args) {
   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 allIds = [...bySrc.obs, ...bySrc.session, ...bySrc.prompt];
     const probe = probeIdSources(db, allIds, queried);
     const hits = formatProbeHints(probe);
     const hint = hits.length > 0 ? ` Try: ${hits.join('; ')}.` : '';
@@ -716,9 +709,21 @@ function cmdTimeline(db, args) {
       // 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;
+      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);
@@ -1970,6 +1975,7 @@ Commands:
 
   recall <file>         Show observations related to a file
     --limit N           Max results (default 10)
+    --include-noise     Include hook-llm fallback titles ("Modified X", raw error logs)
 
   get <id1,id2,...>     Get full details by ID
     IDs accept search-output prefixes: #123 (obs), P#123 (prompt), S#123 (session).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "2.42.0",
+  "version": "2.44.0",
   "description": "Lightweight persistent memory system for Claude Code",
   "type": "module",
   "engines": {

package/scripts/prompt-search-utils.mjs

@@ -9,6 +9,19 @@ const CONFIRM_RE = /^(y(es)?|no?|ok|done|go|sure|lgtm|thanks?|ty|继续|确认|
 const SLASH_CMD_RE = /^\//;
 const PURE_OP_RE = /^(git\s+(commit|push|merge)|npm\s+(publish|deploy))\b/i;
 
+// v2.43.x: pure continuation directives — "keep going on what you were doing"
+// with no new topic. Long enough to evade CONFIRM_RE / length gate but
+// semantically empty for memory-recall purposes; injecting [mem] context
+// here reads like a turn boundary and can prematurely end the model's
+// in-flight tool chain. Conservative match: must be SOLELY the directive,
+// not directive + new instruction (those keep getting injection).
+const CONTINUATION_RE = /^(继续|接着|继续做|接着做|继续干|继续做下一步|接着做下一步|别停|不要停|next|continue|go\s*on|keep\s+going|carry\s+on|proceed|more(?:\s+please)?)\s*[?？!！。.，,]*\s*$/i;
+
+// v2.43.x: meta-pause questions — user is asking the model to reflect on
+// its own pause/stop, then continue. No new topic = no useful memory hit;
+// injection just adds reminder noise on top of an already-reflective turn.
+const META_PAUSE_RE = /(怎么停|为什么停|为何停|你怎么停|工作停下来|刚才停|why\s+(?:did\s+you\s+)?(?:stop|pause|halt))/i;
+
 /**
  * CJK-weighted effective length. CJK characters (CJK Unified Ideographs
  * main + extension A) carry ~3x the semantic token density of Latin
@@ -30,6 +43,8 @@ export function shouldSkip(text) {
   if (CONFIRM_RE.test(trimmed)) return true;
   if (SLASH_CMD_RE.test(trimmed)) return true;
   if (PURE_OP_RE.test(trimmed)) return true;
+  if (CONTINUATION_RE.test(trimmed)) return true;
+  if (META_PAUSE_RE.test(trimmed)) return true;
   return false;
 }
 

package/scripts/user-prompt-search.js

@@ -66,6 +66,34 @@ const FOLLOWUP_BM25_MIN_SCORE = Number(process.env.CLAUDE_MEM_UPS_BM25_MIN_FOLLO
 // gate exists to drop.
 const TOP_REL_FLOOR = Number(process.env.CLAUDE_MEM_UPS_TOP_MIN || 50);
 
+// v2.43.x: OR-fallback raw BM25 magnitude floor. The composite TOP_REL_FLOOR
+// above gates on `bm25 × importance × type_quality × decay × noise_penalty`.
+// For importance=3 bugfix obs, those multipliers compound to ~6×, so a modest
+// BM25 of -17..-22 can clear a composite floor of 50 via inflation alone.
+// When the FTS query relaxes to OR (AND returned 0), a single strongly-
+// matching stem on a big multi-topic prompt leaks through — observed
+// failure mode: broad Chinese prompts surfacing unrelated importance=3
+// bugfix obs whose concepts share exactly one stem with the prompt.
+//
+// Empirical OR-mode distribution (11-prompt probe, 2026-04-23):
+//   real signal      top-|bm25_raw| ≥ 41
+//   broad/meta noise top-|bm25_raw| ≤ 22
+//   below threshold  top-|bm25_raw| < 12
+// Default 30 sits in the clean 22→41 gap. AND mode bypasses this gate —
+// AND's all-stems-must-match constraint is already a precision signal,
+// and there are legitimate AND hits (GOOD-narrow probe: bm25_raw=19.3,
+// rel=81) that we must not drop.
+//
+// CLAUDE_MEM_UPS_TOP_MIN=0 disables this too: on small test corpora (1–2
+// seeded obs) absolute BM25 magnitudes collapse to near-zero (observed
+// |bm25|≈4e-6) because FTS5 IDF normalization needs a real document
+// distribution. The existing TOP_REL_FLOOR knob already encodes the
+// "seed-mode: kill absolute floors" semantic for integration tests, so
+// we piggy-back on it rather than introducing a second override env.
+const OR_TOP_BM25_FLOOR = TOP_REL_FLOOR === 0
+  ? 0
+  : Number(process.env.CLAUDE_MEM_UPS_OR_BM25_MIN || 30);
+
 function isFollowUpSession() {
   try {
     const raw = readFileSync(INJECTED_IDS_FILE, 'utf8');
@@ -77,9 +105,15 @@ function isFollowUpSession() {
 
 // ─── DB Query Functions ─────────────────────────────────────────────────────
 
+// Returns { rows, mode } where mode is 'AND' (initial pass), 'OR' (fallback
+// after AND returned 0), or null (no FTS query / sanitize rejected). Callers
+// use `mode` to apply OR-specific gates — see OR_TOP_BM25_FLOOR rationale.
+// Each row includes `bm25_raw` (pre-multiplier bm25 magnitude) alongside the
+// composite `relevance`, so callers can distinguish raw-match strength from
+// importance/type/decay inflation.
 function searchByFts(db, queryText, project, limit, typeFilter) {
   const ftsQuery = sanitizeFtsQuery(queryText);
-  if (!ftsQuery) return [];
+  if (!ftsQuery) return { rows: [], mode: null };
 
   const cutoff = Date.now() - LOOKBACK_MS;
 
@@ -92,6 +126,7 @@ function searchByFts(db, queryText, project, limit, typeFilter) {
   // docs/p0-injection-noise-baseline.txt.
   const sql = `
     SELECT o.id, o.type, o.title, o.lesson_learned,
+           ${OBS_BM25} as bm25_raw,
            ${OBS_BM25}
              * (1.0 + EXP(-0.693 * (? - o.created_at_epoch) / ${TYPE_DECAY_CASE}))
              * ${TYPE_QUALITY_CASE}
@@ -115,6 +150,7 @@ function searchByFts(db, queryText, project, limit, typeFilter) {
   params.push(limit);
 
   let rows = db.prepare(sql).all(...params);
+  let mode = 'AND';
 
   // OR fallback if AND query returned nothing
   if (rows.length === 0) {
@@ -122,10 +158,11 @@ function searchByFts(db, queryText, project, limit, typeFilter) {
     if (orQuery) {
       params[1] = orQuery;
       rows = db.prepare(sql).all(...params);
+      mode = 'OR';
     }
   }
 
-  return rows;
+  return { rows, mode };
 }
 
 function searchByFile(db, files, project, limit) {
@@ -256,7 +293,7 @@ const QUIET_HOOKS = process.env.MEM_QUIET_HOOKS === '1';
 function formatResults(rows) {
   if (!rows || rows.length === 0) return null;
 
-  const lines = ['[mem] Related memories:'];
+  const lines = ['[mem] FYI — Related memories (continue your task):'];
   for (const r of rows) {
     const icon = typeIcon(r.type);
     const title = truncate(r.title || '', 70);
@@ -272,7 +309,7 @@ function formatResults(rows) {
 // chars (slightly longer than obs titles because prompts carry more context).
 function formatPromptResults(rows) {
   if (!rows || rows.length === 0) return null;
-  const lines = ['[mem] Past similar questions:'];
+  const lines = ['[mem] FYI — Past similar questions (continue your task):'];
   for (const r of rows) {
     const text = truncate((r.prompt_text || '').replace(/\s+/g, ' '), 80);
     lines.push(`P#${r.id} 💬 ${text}`);
@@ -375,7 +412,7 @@ async function main() {
     // take priority slots in the merged output.
     const errSig = extractErrorSignature(promptText);
     const sigRows = errSig
-      ? searchByFts(db, errSig.signature, project, 2, 'bugfix').filter(r =>
+      ? searchByFts(db, errSig.signature, project, 2, 'bugfix').rows.filter(r =>
           typeof r.relevance === 'number' && Math.abs(r.relevance) >= bm25Floor
         )
       : [];
@@ -386,11 +423,13 @@ async function main() {
     } else {
       // FTS search: use the prompt as query, optionally type-filtered
       const files = extractFiles(promptText);
-      let ftsRows = searchByFts(db, promptText, project, intent?.limit || MAX_RESULTS, intent?.type || null);
+      let ftsResult = searchByFts(db, promptText, project, intent?.limit || MAX_RESULTS, intent?.type || null);
       // Fallback: if typed search returned nothing, retry without type filter
-      if (ftsRows.length === 0 && intent?.type) {
-        ftsRows = searchByFts(db, promptText, project, intent.limit || MAX_RESULTS, null);
+      if (ftsResult.rows.length === 0 && intent?.type) {
+        ftsResult = searchByFts(db, promptText, project, intent.limit || MAX_RESULTS, null);
       }
+      let ftsRows = ftsResult.rows;
+      const ftsMode = ftsResult.mode;
       const fileRows = files.length > 0 ? searchByFile(db, files, project, 2) : [];
 
       // T3 (v2.31): BM25 magnitude threshold — drop FTS hits whose relevance
@@ -403,6 +442,19 @@ async function main() {
         typeof r.relevance === 'number' && Math.abs(r.relevance) >= bm25Floor
       );
 
+      // v2.43.x: OR-mode raw-BM25 floor. In OR-fallback mode the composite
+      // TOP_REL_FLOOR below is inflated by importance × type_quality × decay
+      // multipliers — a weak single-stem hit on an importance=3 bugfix obs
+      // can reach composite rel=66 while raw |bm25|=19. Gate on raw bm25
+      // magnitude for OR mode only; AND mode's all-stems-match constraint
+      // is a precision signal and routinely produces legitimate AND hits
+      // below raw |bm25|=20 that we do not want to drop (see GOOD-narrow
+      // probe). Skip gate when OR_TOP_BM25_FLOOR is set to 0 (test hook).
+      if (ftsMode === 'OR' && OR_TOP_BM25_FLOOR > 0 && ftsRows.length > 0) {
+        const topBm25 = Math.abs(ftsRows[0].bm25_raw || 0);
+        if (topBm25 < OR_TOP_BM25_FLOOR) ftsRows = [];
+      }
+
       // v2.34.3: top-|rel| sanity gate. Per-row filtering above leaves noise
       // prompts intact when many rows share a weak stem (all in 25..48 range).
       // If the best remaining FTS match is below the top floor, drop the

package/server.mjs

@@ -27,7 +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, parseIdToken } from './lib/id-routing.mjs';
+import { probeOtherSources as probeIdSources, parseIdToken, bucketIdTokens } from './lib/id-routing.mjs';
 import { getVocabulary, rebuildVocabulary, _resetVocabCache, computeVector, vectorSearch, rrfMerge } from './tfidf.mjs';
 import { createRequire } from 'module';
 
@@ -768,7 +768,10 @@ server.registerTool(
     // from mem_search results expect the same routing as CLI `timeline --anchor`.
     // Prompt/session anchors resolve to the nearest-in-time observation so
     // before/after semantics still apply to the observations timeline.
-    if (typeof anchorId === 'string') {
+    // Also covers bare numeric anchors so compressed-obs routing applies uniformly —
+    // without this, `anchor: 7826` (int) would bypass the compressed check and
+    // silently straddle a dead record.
+    if (typeof anchorId === 'string' || typeof anchorId === 'number') {
       const parsed = parseIdToken(anchorId);
       if (!parsed) {
         return { content: [{ type: 'text', text: `Invalid anchor "${args.anchor}". Expected N, #N, P#N, or S#N.` }] };
@@ -789,9 +792,20 @@ server.registerTool(
         anchorNote = `(anchored to #${nearest.id}, closest obs to ${srcPrefix}${parsed.id})`;
       } else {
         // Bare "#N" or "N" — resolve to obs, falling back to prompt/session like CLI bare-int path.
-        const obsExists = db.prepare('SELECT 1 FROM observations WHERE id = ?').get(parsed.id);
-        if (obsExists) {
-          anchorId = parsed.id;
+        // Route compressed obs to its parent so the before/after window (which filters compressed)
+        // isn't shown around a dead anchor. Negative sentinels (-1 dropped, -2 pending purge) surface
+        // an explicit error — they have no canonical parent.
+        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) {
+            anchorId = ci;
+            anchorNote = `(anchored to #${ci}, #${parsed.id} was compressed into it)`;
+          } else if (ci && ci < 0) {
+            return { content: [{ type: 'text', text: `Observation #${parsed.id} was compressed and pruned; no canonical anchor available.` }] };
+          } 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);
@@ -915,84 +929,123 @@ server.registerTool(
     inputSchema: memGetSchema,
   },
   safeHandler(async (args) => {
-    const source = args.source || 'obs';
-    const placeholders = args.ids.map(() => '?').join(',');
+    // Bucket by per-token prefix (or force all to `args.source` when explicit).
+    // coerceMixedIdTokens has already stringified + regex-validated each token.
+    const { bySrc, invalid } = bucketIdTokens(args.ids, { explicit: args.source || null, defaultSource: 'obs' });
+    if (invalid.length > 0) {
+      // Should not happen — schema regex already rejected bad tokens — but guard defensively.
+      return { content: [{ type: 'text', text: `Invalid ID token(s): ${invalid.join(', ')}. Expected N, #N, P#N, or S#N.` }] };
+    }
+    const totalRequested = bySrc.obs.length + bySrc.session.length + bySrc.prompt.length;
+    if (totalRequested === 0) {
+      return { content: [{ type: 'text', text: 'No valid IDs provided.' }] };
+    }
 
-    let rows, allFields, prefix, sourceLabel;
-    if (source === 'session') {
-      rows = db.prepare(`SELECT * FROM session_summaries WHERE id IN (${placeholders}) ORDER BY created_at_epoch ASC`).all(...args.ids);
-      allFields = ['id', 'request', 'investigated', 'learned', 'completed', 'next_steps', 'files_read', 'files_edited', 'notes', 'project', 'created_at', 'memory_session_id', 'prompt_number'];
-      prefix = 'S#';
-      sourceLabel = 'sessions';
-    } else if (source === 'prompt') {
-      rows = db.prepare(`SELECT * FROM user_prompts WHERE id IN (${placeholders}) ORDER BY created_at_epoch ASC`).all(...args.ids);
-      allFields = ['id', 'prompt_text', 'content_session_id', 'prompt_number', 'created_at'];
-      prefix = 'P#';
-      sourceLabel = 'prompts';
-    } else {
-      // Increment access_count for retrieved observations (batch UPDATE)
+    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'];
+
+    // `fields` filter only makes sense for obs rows; session/prompt ignore it.
+    // Validate when obs is queried — throw on all-invalid, note on partial-invalid.
+    let fieldsNote = '';
+    let obsFieldFilter = null;
+    if (args.fields?.length && bySrc.obs.length > 0) {
+      const invalidFields = args.fields.filter(f => !OBS_FIELDS.includes(f));
+      const validFields = args.fields.filter(f => OBS_FIELDS.includes(f));
+      if (validFields.length === 0) {
+        throw new Error(`No valid fields. Unknown field(s): ${invalidFields.join(', ')}. Valid: ${OBS_FIELDS.join(', ')}`);
+      }
+      if (invalidFields.length > 0) {
+        fieldsNote = `Note: unknown field(s) dropped: ${invalidFields.join(', ')}. Valid: ${OBS_FIELDS.join(', ')}`;
+      }
+      obsFieldFilter = validFields;
+    }
+
+    // Per-source fetchers — each returns { rows, foundIds:Set, prefix }.
+    const sections = [];
+    const foundBySource = { obs: new Set(), session: new Set(), prompt: new Set() };
+
+    if (bySrc.obs.length > 0) {
+      const ph = bySrc.obs.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(), ...args.ids);
-        autoBoostIfNeeded(db, args.ids);
+        db.prepare(`UPDATE observations SET access_count = COALESCE(access_count, 0) + 1, last_accessed_at = ? WHERE id IN (${ph})`).run(Date.now(), ...bySrc.obs);
+        autoBoostIfNeeded(db, bySrc.obs);
       } catch { /* non-critical: FTS5 trigger may fail on corrupted index */ }
-      rows = db.prepare(`SELECT * FROM observations WHERE id IN (${placeholders}) ORDER BY created_at_epoch ASC`).all(...args.ids);
-      allFields = ['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'];
-      prefix = '#';
-      sourceLabel = 'observations';
+      const rows = db.prepare(`SELECT * FROM observations WHERE id IN (${ph}) ORDER BY created_at_epoch ASC`).all(...bySrc.obs);
+      const renderFields = obsFieldFilter || OBS_FIELDS;
+      for (const row of rows) {
+        foundBySource.obs.add(row.id);
+        const lines = [`── #${row.id} ──`];
+        for (const f of renderFields) {
+          const val = row[f];
+          if (val === null || val === undefined || val === '') continue;
+          if (f === 'text' && row.narrative && typeof val === 'string' && val.startsWith(row.narrative)) continue;
+          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}`);
+        }
+        sections.push(lines.join('\n'));
+      }
     }
 
-    // P1-3: validate requested fields — throw on all-invalid so callers don't silently get an
-    // empty record (header only). Partial-invalid is tolerated but surfaced as a note.
-    let fieldsNote = '';
-    if (args.fields?.length) {
-      const invalid = args.fields.filter(f => !allFields.includes(f));
-      const valid = args.fields.filter(f => allFields.includes(f));
-      if (valid.length === 0) {
-        throw new Error(`No valid fields. Unknown field(s): ${invalid.join(', ')}. Valid: ${allFields.join(', ')}`);
+    if (bySrc.session.length > 0) {
+      const ph = bySrc.session.map(() => '?').join(',');
+      const rows = db.prepare(`SELECT * FROM session_summaries WHERE id IN (${ph}) ORDER BY created_at_epoch ASC`).all(...bySrc.session);
+      const sessFields = ['id', 'request', 'investigated', 'learned', 'completed', 'next_steps', 'files_read', 'files_edited', 'notes', 'project', 'created_at', 'memory_session_id', 'prompt_number'];
+      for (const row of rows) {
+        foundBySource.session.add(row.id);
+        const lines = [`── S#${row.id} ──`];
+        for (const f of sessFields) {
+          const val = row[f];
+          if (val === null || val === undefined || val === '') continue;
+          const maxLen = 500;
+          lines.push(`${f}: ${typeof val === 'string' && val.length > maxLen ? val.slice(0, maxLen) + '…' : val}`);
+        }
+        sections.push(lines.join('\n'));
       }
-      if (invalid.length > 0) {
-        fieldsNote = `Note: unknown field(s) dropped: ${invalid.join(', ')}. Valid: ${allFields.join(', ')}`;
+    }
+
+    if (bySrc.prompt.length > 0) {
+      const ph = bySrc.prompt.map(() => '?').join(',');
+      const rows = db.prepare(`SELECT * FROM user_prompts WHERE id IN (${ph}) ORDER BY created_at_epoch ASC`).all(...bySrc.prompt);
+      for (const row of rows) {
+        foundBySource.prompt.add(row.id);
+        const lines = [`── P#${row.id} ──`];
+        if (row.prompt_text) lines.push(`prompt_text: ${row.prompt_text.length > 500 ? row.prompt_text.slice(0, 500) + '…' : row.prompt_text}`);
+        if (row.content_session_id) lines.push(`content_session_id: ${row.content_session_id}`);
+        if (row.prompt_number !== null && row.prompt_number !== undefined) lines.push(`prompt_number: ${row.prompt_number}`);
+        if (row.created_at) lines.push(`created_at: ${row.created_at}`);
+        sections.push(lines.join('\n'));
       }
     }
 
-    if (rows.length === 0) {
-      // 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 totalFound = foundBySource.obs.size + foundBySource.session.size + foundBySource.prompt.size;
+
+    if (totalFound === 0) {
+      // Probe other sources so callers can retry with the right prefix/source override.
+      const queried = new Set(Object.entries(bySrc).filter(([, v]) => v.length > 0).map(([k]) => k));
+      const allNumericIds = [...bySrc.obs, ...bySrc.session, ...bySrc.prompt];
+      const probe = probeIdSources(db, allNumericIds, queried);
       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')`);
+      if (probe.obs.length > 0)     hints.push(`#${probe.obs.join(', #')} (obs — use source='obs' or bare #N)`);
+      if (probe.session.length > 0) hints.push(`S#${probe.session.join(', S#')} (session — use source='session' or S#N)`);
+      if (probe.prompt.length > 0)  hints.push(`P#${probe.prompt.join(', P#')} (prompt — use source='prompt' or P#N)`);
       const hint = hints.length > 0 ? ` Try: ${hints.join('; ')}.` : '';
-      const msg = `No ${sourceLabel} found for given IDs.${hint}`;
+      const queriedList = [...queried].join(', ');
+      const msg = `No records found in source(s) [${queriedList}] for the given ID(s).${hint}`;
       return { content: [{ type: 'text', text: fieldsNote ? `${msg}\n\n${fieldsNote}` : msg }] };
     }
 
-    const fields = args.fields?.length ? args.fields.filter(f => allFields.includes(f)) : allFields;
+    // Missing-ID note per bucket (mirrors mem_delete). Show missing IDs with their bucket prefix
+    // so callers can tell which source returned nothing.
+    const missingHints = [];
+    const miss = (arr, found, prefix) => arr.filter(id => !found.has(id)).map(id => `${prefix}${id}`);
+    missingHints.push(...miss(bySrc.obs, foundBySource.obs, '#'));
+    missingHints.push(...miss(bySrc.session, foundBySource.session, 'S#'));
+    missingHints.push(...miss(bySrc.prompt, foundBySource.prompt, 'P#'));
 
     const parts = [];
     if (fieldsNote) parts.push(fieldsNote);
-    for (const row of rows) {
-      const lines = [`── ${prefix}${row.id} ──`];
-      for (const f of fields) {
-        const val = row[f];
-        if (val === null || val === undefined || val === '') continue;
-        // Skip 'text' field when it duplicates narrative (text = narrative + optional CJK bigrams)
-        if (f === 'text' && row.narrative && typeof val === 'string' && val.startsWith(row.narrative)) continue;
-        // Field-aware truncation: narrative and lesson need more space than metadata
-        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}`);
-      }
-      parts.push(lines.join('\n'));
-    }
-
-    // P1-4: surface IDs that weren't found (mirrors mem_delete's missing-ID note).
-    const foundIds = new Set(rows.map(r => r.id));
-    const missing = args.ids.filter(id => !foundIds.has(id));
-    if (missing.length > 0) {
-      parts.push(`Note: ID(s) ${missing.join(', ')} not found.`);
+    parts.push(...sections);
+    if (missingHints.length > 0) {
+      parts.push(`Note: ID(s) ${missingHints.join(', ')} not found.`);
     }
 
     return { content: [{ type: 'text', text: parts.join('\n\n') }] };
@@ -2123,15 +2176,18 @@ server.registerTool(
   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);

package/tool-schemas.mjs

@@ -28,6 +28,55 @@ const coerceIntArray = z.preprocess(
   z.array(z.number().int())
 );
 
+// Coerce string arrays: accept array, comma-separated string, JSON-array string, or bare string.
+// MCP bridges sometimes JSON-stringify complex args — bare `z.array(z.string())` rejects those
+// with "expected array, received string" and the caller loses the field silently. Parity with
+// coerceIntArray: tolerate the same shapes so files/fields survive client serialization quirks.
+const coerceStringArray = z.preprocess(
+  (v) => {
+    if (Array.isArray(v)) return v.map(x => typeof x === 'string' ? x : String(x));
+    if (typeof v === 'string') {
+      const s = v.trim();
+      if (s.startsWith('[') && s.endsWith(']')) {
+        try {
+          const parsed = JSON.parse(s);
+          if (Array.isArray(parsed)) return parsed.map(x => typeof x === 'string' ? x : String(x));
+        } catch { /* fall through to comma-split */ }
+      }
+      return s.split(',').map(x => x.trim()).filter(x => x.length > 0);
+    }
+    return v;
+  },
+  z.array(z.string())
+);
+
+// Coerce mixed ID tokens (#N / P#N / S#N / bare N) for mem_get. Accepts:
+//   - native arrays: [1, "P#2", "#3"]
+//   - single number: 1
+//   - single/comma string: "1,P#2,S#3"
+//   - JSON-array string: '[1,"P#2"]' (MCP bridges that stringify complex args)
+// Piped to a regex-validated string[] so each token stays parseable by lib/id-routing.parseIdToken
+// at the handler. Closes the CLI↔MCP gap noted in #8127.
+const coerceMixedIdTokens = z.preprocess(
+  (v) => {
+    const norm = (x) => typeof x === 'string' ? x.trim() : String(x);
+    if (Array.isArray(v)) return v.map(norm).filter(s => s.length > 0);
+    if (typeof v === 'number') return [String(v)];
+    if (typeof v === 'string') {
+      const s = v.trim();
+      if (s.startsWith('[') && s.endsWith(']')) {
+        try {
+          const parsed = JSON.parse(s);
+          if (Array.isArray(parsed)) return parsed.map(norm).filter(x => x.length > 0);
+        } catch { /* fall through to comma-split */ }
+      }
+      return s.split(',').map(x => x.trim()).filter(Boolean);
+    }
+    return v;
+  },
+  z.array(z.string().regex(/^[PpSs]?#?\d+$/, 'Expected N, #N, P#N, or S#N')).min(1).max(20)
+);
+
 export const memSearchSchema = {
   query: z.string().optional().describe('Search query (FTS5 syntax supported)'),
   type: z.enum(['observations', 'sessions', 'prompts']).optional().describe('Limit to one table'),
@@ -78,12 +127,12 @@ export const memTimelineSchema = {
 };
 
 export const memGetSchema = {
-  // TODO(#8126): accept P#/S#/# prefix strings for paste-from-search parity with
-  // CLI cmdGet bucketed routing (~40 LOC handler refactor). mem_timeline already
-  // accepts prefixes via coerceAnchor; this is the matched-pair gap.
-  ids: coerceIntArray.pipe(z.array(z.number().int()).min(1).max(20)).describe('Observation IDs to retrieve'),
-  source: z.enum(['obs', 'session', 'prompt']).optional().describe('Record type: obs (default), session (S# from search), prompt (P# from search)'),
-  fields: z.array(z.string()).optional().describe('Specific fields to return (default: all)'),
+  // Accepts mixed tokens so pasted search results work verbatim: [1], [1, "P#2"], "1,P#2,S#3",
+  // or the JSON-stringified form ["1","P#2"]. Each token's prefix routes to its source bucket
+  // in server.mjs via lib/id-routing.bucketIdTokens. An explicit `source` override still wins.
+  ids: coerceMixedIdTokens.describe('Mixed observation/prompt/session IDs — accepts N, #N, P#N, S#N; comma-strings and JSON arrays also coerced'),
+  source: z.enum(['obs', 'session', 'prompt']).optional().describe('Force all IDs to this source (overrides per-token prefixes). Omit to let P#/S#/# prefixes route individually.'),
+  fields: coerceStringArray.optional().describe('Specific fields to return (default: all; validated against obs schema — session/prompt sources ignore this filter)'),
 };
 
 export const memDeleteSchema = {
@@ -97,7 +146,7 @@ export const memSaveSchema = {
   type: OBS_TYPE_ENUM.optional().describe('Observation type (default: discovery)'),
   project: z.string().optional().describe('Project name (default: inferred from CWD)'),
   importance: coerceInt.pipe(z.number().int().min(1).max(3)).optional().describe('Importance level: 1=routine, 2=notable, 3=critical (default: 2 for explicit saves)'),
-  files: z.array(z.string()).optional().describe('File paths associated with this observation'),
+  files: coerceStringArray.optional().describe('File paths associated with this observation'),
   lesson_learned: z.string().max(500).optional().describe('Key lesson or takeaway (for bugfix: root cause & fix; for decision: rationale)'),
 };
 
@@ -162,6 +211,7 @@ export const memExportSchema = {
 export const memRecallSchema = {
   file: z.string().min(1).describe('File path or filename to recall observations for'),
   limit: coerceInt.pipe(z.number().int().min(1).max(50)).optional().describe('Max results (default 10)'),
+  include_noise: z.boolean().optional().describe('Include hook-llm fallback titles ("Modified X", "Worked on X", raw error logs) — hidden by default for parity with mem_search'),
 };
 
 export const memFtsCheckSchema = {