claude-mem-lite 2.41.0 → 2.43.0

package/.claude-plugin/marketplace.json

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

package/cli/common.mjs

@@ -1,10 +1,11 @@
 // cli/common.mjs — shared helpers used by every per-command file under cli/.
 // Extracted from mem-cli.mjs (v2.41) as first step in the god-module split.
 //
-// Scope: pure utilities only. No DB, no imports from other cli/ files. This
-// module is the single source of truth for stdout/stderr framing, arg parsing,
-// ID-token parsing, and relative-time formatting — every command imports from
-// here so the CLI stays consistent.
+// Scope: pure utilities only. No DB, no imports from other cli/ files; only
+// `lib/` leaf utilities may be re-exported through here (currently:
+// parseIdToken). This module is the single source of truth for stdout/stderr
+// framing, arg parsing, ID-token parsing, and relative-time formatting —
+// every command imports from here so the CLI stays consistent.
 
 // ─── Argument Parsing ────────────────────────────────────────────────────────
 
@@ -75,22 +76,10 @@ export function fmtDateShort(iso) {
 }
 
 // ─── ID Token Parsing ────────────────────────────────────────────────────────
-
-/**
- * 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 } | null}
- *   source===null means no explicit prefix — caller picks default (typically 'obs').
- */
-export 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 };
-}
+// 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
+// 5 CLI call sites that already import parseIdToken from cli/common.mjs.
+export { parseIdToken } from '../lib/id-routing.mjs';
 
 /**
  * Format the shared `probeIdSources` output as CLI hint strings.

package/lib/id-routing.mjs

@@ -1,10 +1,58 @@
-// 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.
+// Shared probe for "ID-not-found-in-requested-source" hints + shared token
+// parser. Used by CLI (mem-cli.mjs, cli/common.mjs re-export) and MCP
+// (server.mjs) so both paths stay aligned — parity per #8050.
 //
 // The formatter stays per-call-site because CLI and MCP surface format
-// differently (stderr vs response text); only the SQL layer is shared.
+// differently (stderr vs response text); only the SQL + token-parse layers
+// are shared.
+
+// ─── ID Token Parsing ────────────────────────────────────────────────────────
+
+/**
+ * Parse an ID token as it appears in search output or CLI positional args.
+ * Accepts: `123`, `#123`, `P#123` / `p123` (prompt), `S#123` / `s123` (session).
+ * @param {unknown} raw
+ * @returns {{ source: 'obs'|'session'|'prompt'|null, id: number } | null}
+ *   source===null means no explicit prefix — caller picks default (typically 'obs').
+ */
+export 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 };
+}
+
+/**
+ * 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

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';
 
@@ -476,7 +476,7 @@ function cmdRecent(db, args) {
   for (const r of rows) {
     const time = relativeTime(r.created_at_epoch);
     const title = truncate(r.title || r.subtitle || '(untitled)', 80);
-    out(`#${String(r.id).padStart(5)} ${typeIcon(r.type)} ${time.padEnd(8)} ${title}`);
+    out(`${('#' + r.id).padEnd(6)} ${typeIcon(r.type)} ${time.padEnd(8)} ${title}`);
   }
 }
 
@@ -597,20 +597,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 +606,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 +649,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 +706,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);
@@ -787,7 +789,7 @@ function cmdTimeline(db, args) {
     for (const r of rows.reverse()) {
       const time = relativeTime(r.created_at_epoch);
       const title = truncate(r.title || r.subtitle || '(untitled)', 80);
-      out(`#${String(r.id).padStart(5)} ${typeIcon(r.type)} ${time.padEnd(8)} ${title}`);
+      out(`${('#' + r.id).padEnd(6)} ${typeIcon(r.type)} ${time.padEnd(8)} ${title}`);
     }
     return;
   }
@@ -840,7 +842,7 @@ function cmdTimeline(db, args) {
     const marker = r.id === anchorId ? ' <--' : '';
     const time = relativeTime(r.created_at_epoch);
     const title = truncate(r.title || r.subtitle || '(untitled)', 80);
-    out(`#${String(r.id).padStart(5)} ${typeIcon(r.type)} ${time.padEnd(8)} ${title}${marker}`);
+    out(`${('#' + r.id).padEnd(6)} ${typeIcon(r.type)} ${time.padEnd(8)} ${title}${marker}`);
   }
 }
 

package/package.json

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

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 } 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';
 
@@ -762,6 +762,71 @@ server.registerTool(
     const before = args.before ?? 5;
     const after = args.after ?? 5;
     let anchorId = args.anchor;
+    let anchorNote = null;
+
+    // Resolve prefixed-token anchor (e.g. "P#3462" / "S#53" / "#8121") — users pasting
+    // 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.
+    // 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.` }] };
+      }
+      if (parsed.source === 'prompt' || parsed.source === 'session') {
+        const srcTable = parsed.source === 'prompt' ? 'user_prompts' : 'session_summaries';
+        const srcPrefix = parsed.source === 'prompt' ? 'P#' : 'S#';
+        const row = db.prepare(`SELECT created_at_epoch FROM ${srcTable} WHERE id = ?`).get(parsed.id);
+        if (!row) return { content: [{ type: 'text', text: `${parsed.source === 'prompt' ? 'Prompt' : 'Session'} ${srcPrefix}${parsed.id} not found.` }] };
+        const projArg = args.project;
+        const nearest = db.prepare(`
+          SELECT id FROM observations
+          WHERE COALESCE(compressed_into, 0) = 0 ${projArg ? 'AND project = ?' : ''}
+          ORDER BY ABS(created_at_epoch - ?) ASC LIMIT 1
+        `).get(...(projArg ? [projArg, row.created_at_epoch] : [row.created_at_epoch]));
+        if (!nearest) return { content: [{ type: 'text', text: `No observations near ${srcPrefix}${parsed.id}.` }] };
+        anchorId = nearest.id;
+        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.
+        // 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);
+          const hit = promptRow ? { row: promptRow, prefix: 'P#', name: 'prompt' }
+                    : sessionRow ? { row: sessionRow, prefix: 'S#', name: 'session' }
+                    : null;
+          if (!hit) {
+            return { content: [{ type: 'text', text: `Observation, prompt, or session with id ${parsed.id} not found.` }] };
+          }
+          const projArg = args.project;
+          const nearest = db.prepare(`
+            SELECT id FROM observations
+            WHERE COALESCE(compressed_into, 0) = 0 ${projArg ? 'AND project = ?' : ''}
+            ORDER BY ABS(created_at_epoch - ?) ASC LIMIT 1
+          `).get(...(projArg ? [projArg, hit.row.created_at_epoch] : [hit.row.created_at_epoch]));
+          if (!nearest) return { content: [{ type: 'text', text: `No observations near ${hit.prefix}${parsed.id} (${hit.name}).` }] };
+          anchorId = nearest.id;
+          anchorNote = `(anchored to #${nearest.id}, closest obs to ${hit.prefix}${parsed.id})`;
+        }
+      }
+    }
 
     // Auto-find anchor via FTS (with recency decay)
     if (!anchorId && args.query) {
@@ -845,7 +910,7 @@ server.registerTool(
     const anchor = db.prepare('SELECT id, type, title, subtitle, project, created_at FROM observations WHERE id = ?').get(anchorId);
 
     const all = [...beforeRows.reverse(), anchor, ...afterRows];
-    const lines = [`Timeline around #${anchorId}:\n`];
+    const lines = [`Timeline around #${anchorId}${anchorNote ? ' ' + anchorNote : ''}:\n`];
     for (const r of all) {
       const marker = r.id === anchorId ? ' ◀' : '';
       lines.push(`#${r.id} ${typeIcon(r.type)} [${r.type}] ${truncate(r.title || r.subtitle || '(untitled)')} | ${r.project} | ${fmtDate(r.created_at)}${marker}`);
@@ -864,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') }] };

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'),
@@ -50,8 +99,27 @@ export const memRecentSchema = {
   project: z.string().optional().describe('Filter by project (default: inferred from CWD)'),
 };
 
+// Anchor accepts plain int, "123" string-int, or prefixed token from search output:
+// "#123" / "P#123" (prompt) / "S#123" (session). Prompt/session anchors resolve to
+// the nearest-in-time observation so timeline semantics still apply. CLI --anchor
+// parity per #8050 (CLI has supported prefixed tokens since v2.39.0).
+const coerceAnchor = z.preprocess(
+  (v) => {
+    if (typeof v === 'string') {
+      const s = v.trim();
+      if (/^-?\d+$/.test(s)) return parseInt(s, 10);
+      return s;
+    }
+    return v;
+  },
+  z.union([
+    z.number().int(),
+    z.string().regex(/^[PpSs]?#?\d+$/, 'Expected N, #N, P#N, or S#N'),
+  ])
+);
+
 export const memTimelineSchema = {
-  anchor: coerceInt.pipe(z.number().int()).optional().describe('Observation ID as center point. Takes precedence over query when both are provided.'),
+  anchor: coerceAnchor.optional().describe('Anchor as observation ID (int) or prefixed token string: "#123", "P#123" (prompt → nearest obs), "S#123" (session → nearest obs). Takes precedence over query.'),
   query: z.string().optional().describe('FTS5 query to auto-find anchor. Ignored when anchor is also given; use one or the other.'),
   before: coerceInt.pipe(z.number().int().min(0).max(50)).optional().describe('Items before anchor (default 5)'),
   after: coerceInt.pipe(z.number().int().min(0).max(50)).optional().describe('Items after anchor (default 5)'),
@@ -59,9 +127,12 @@ export const memTimelineSchema = {
 };
 
 export const memGetSchema = {
-  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 = {
@@ -75,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)'),
 };