claude-mem-lite 3.49.0 → 3.51.0

package/.claude-plugin/marketplace.json

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

package/.claude-plugin/plugin.json

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

package/hook-optimize.mjs

@@ -940,7 +940,11 @@ export async function optimizeRun(db, { tasks, maxItems = 15, force = false, ree
             // via auto-maintain) passes 'wide' explicitly — so aliases never had a cadence and
             // live coverage crawled at ~15%. The split is ADAPTIVE: aliases takes at most half
             // the budget and only what its candidate pool actually holds, so a zero-candidate
-            // aliases pass costs nothing and the main scope keeps its full budget.
+            // aliases pass costs nothing and the main scope keeps its full budget. Boundary:
+            // at budget.reenrich === 1, `half` floors to 1 (the whole budget), so with ≥1
+            // alias candidate the main scope gets 0 that cycle — pre-existing v3.43 semantics
+            // (reachable only via manual `optimize --max ≤4`; the daily path runs reenrich=6),
+            // and the starved scope self-corrects next cycle.
             // An explicit --scope aliases still runs exactly that one scope (below).
             const half = Math.max(1, Math.floor(budget.reenrich / 2));
             const aliasBudget = Math.min(half, findReenrichCandidates(db, half, { scope: 'aliases', project }).length);

package/hook.mjs

@@ -344,8 +344,13 @@ async function handlePostToolUse() {
   let db = null;
   const getDb = () => { if (!db) db = openDb(); return db; };
 
-  // Tier 2 G: Error-triggered recall
-  if (bashSig?.isError) {
+  // Tier 2 G: Error-triggered recall. Gated on isHardError (genuine failure
+  // fingerprint), NOT isError — the loose gate fired "Related memories found for
+  // this error" on exit-0 commands whose output merely contained the word "error"
+  // (G8, roadmap 2026-07-18), and was self-recursive: the hint string itself
+  // contains 'error', so a later command echoing it re-triggered recall.
+  // entry.isError above keeps the loose semantics on purpose (episode narrative).
+  if (bashSig?.isHardError) {
     const d = getDb();
     if (d) triggerErrorRecall(d, toolInput, resp);
   }

package/lib/deferred-work.mjs

@@ -58,6 +58,49 @@ export function listOpenWithOrdinal(db, project, limit = 10) {
   `).all(project, limit);
 }
 
+// ─── G11: list age + stale refresh hint (roadmap 2026-07-18) ─────────────────
+
+const DAY_MS = 86_400_000;
+export const DEFER_STALE_DAYS = 30;
+
+/**
+ * Render one `defer list` row (shared by CLI cmdDeferList and MCP
+ * mem_defer_list — no hand-synced twins). Age rides inside the id tag:
+ * `1. 🟡 [P2] title (D#5, 12d)`.
+ * @param {{ordinal, priority, title, id, created_at_epoch}} r
+ * @param {number} [now]
+ */
+export function formatDeferListRow(r, now = Date.now()) {
+  const pTag = r.priority === 3 ? '🔴' : r.priority === 1 ? '⚪' : '🟡';
+  const days = Math.max(0, Math.floor((now - r.created_at_epoch) / DAY_MS));
+  return `${r.ordinal}. ${pTag} [P${r.priority}] ${r.title} (D#${r.id}, ${days}d)`;
+}
+
+/**
+ * Count ALL open rows older than DEFER_STALE_DAYS in the project — deliberately
+ * not derived from the displayed list: (priority DESC, created_at ASC) ordering
+ * sinks old P1 rows past the LIMIT, and those are exactly the ones the hint
+ * exists for.
+ */
+export function countStaleOpen(db, project, now = Date.now()) {
+  return db.prepare(`
+    SELECT COUNT(*) AS n FROM deferred_work
+    WHERE project = ? AND status = 'open' AND created_at_epoch < ?
+  `).get(project, now - DEFER_STALE_DAYS * DAY_MS).n;
+}
+
+/**
+ * Tail hint for stale open items. Null when none — callers print nothing.
+ * Nudge-only by design: no auto-demote / auto-drop (defer is a commitment
+ * surface; silent cleanup would break it).
+ * @param {number} staleCount
+ * @returns {string|null}
+ */
+export function formatDeferStaleHint(staleCount) {
+  if (!staleCount || staleCount <= 0) return null;
+  return `⚠ ${staleCount} item(s) open >${DEFER_STALE_DAYS} days — refresh (still relevant?) or drop with a reason.`;
+}
+
 /**
  * Set status='dropped' with a non-empty reason. No-op when status is not 'open'.
  * @returns {{changed: number}} 1 if updated, 0 if not found or not open.
@@ -74,6 +117,143 @@ export function dropDeferred(db, id, reason) {
   return { changed: r.changes };
 }
 
+/**
+ * Fetch full deferred_work rows by raw id — ANY status, input order preserved,
+ * missing ids omitted. This is the read half of the D# surface: `defer list`
+ * stays title-only by design (dashboard noise budget), so `get D#N` is where
+ * the detail field becomes readable at all.
+ * @param {Database} db
+ * @param {number[]} ids Raw deferred_work ids
+ * @returns {Array<object>} Full rows
+ */
+export function getDeferredByIds(db, ids) {
+  if (!Array.isArray(ids) || ids.length === 0) return [];
+  const stmt = db.prepare(`SELECT * FROM deferred_work WHERE id = ?`);
+  const rows = [];
+  for (const id of ids) {
+    if (!Number.isInteger(id) || id <= 0) continue;
+    const r = stmt.get(id);
+    if (r) rows.push(r);
+  }
+  return rows;
+}
+
+/**
+ * Render one deferred_work row with FULL detail (never truncated) — shared by
+ * CLI cmdGet and MCP mem_get so the two surfaces cannot drift.
+ * @param {object} row Full deferred_work row (from getDeferredByIds)
+ * @returns {string}
+ */
+export function formatDeferredDetail(row) {
+  const pTag = row.priority === 3 ? '🔴' : row.priority === 1 ? '⚪' : '🟡';
+  const lines = [`── D#${row.id} ── deferred (${row.status}) ${pTag} [P${row.priority}]`];
+  lines.push(`project: ${row.project}`);
+  lines.push(`title: ${row.title}`);
+  if (row.detail) lines.push(`detail: ${row.detail}`);
+  if (row.files) {
+    try {
+      const f = JSON.parse(row.files);
+      if (Array.isArray(f) && f.length > 0) lines.push(`files: ${f.join(', ')}`);
+    } catch { /* legacy non-JSON files value — skip rather than render garbage */ }
+  }
+  if (row.created_at_epoch) lines.push(`created: ${new Date(row.created_at_epoch).toISOString()}`);
+  if (row.status === 'dropped' && row.drop_reason) lines.push(`drop_reason: ${row.drop_reason}`);
+  if (row.status === 'done' && row.closed_by_obs_id) lines.push(`closed_by: #${row.closed_by_obs_id}`);
+  return lines.join('\n');
+}
+
+/**
+ * P2 search leg: make deferred items reachable from mem_search / CLI search.
+ *
+ * Two channels, merged direct-first and deduped:
+ *   1. Explicit "D#N" refs in the query → direct id lookup, ANY status
+ *      (an explicit reference deserves the row even if closed), project-scoped.
+ *   2. Keyword match over OPEN items' title+detail — JS substring matching
+ *      (never SQL LIKE, so %/_ are literals and wildcard injection is
+ *      structurally impossible; corpus is ≤50 open rows per project).
+ *      Multi-token queries need ceil(n/2) token hits so one generic token
+ *      ("test", "lesson") can't drag the trailer into every search.
+ *
+ * Date bounds are deliberately NOT applied — open items are few, current by
+ * definition, and the trailer is labeled as deferred work, not search results.
+ *
+ * @param {Database} db
+ * @param {string} query Raw user query
+ * @param {string} project Project scope (required — trailer is project-local)
+ * @param {{limit?: number}} [opts]
+ * @returns {Array<object>} Full rows, direct refs first, capped at limit
+ */
+export function searchDeferredWork(db, query, project, { limit = 3 } = {}) {
+  if (!query || typeof query !== 'string' || !project) return [];
+
+  const refIds = [];
+  const refRe = /\bD#(\d+)\b/gi;
+  let m;
+  while ((m = refRe.exec(query)) !== null) {
+    const id = parseInt(m[1], 10);
+    if (id > 0 && !refIds.includes(id)) refIds.push(id);
+  }
+  const direct = refIds.length > 0
+    ? getDeferredByIds(db, refIds).filter(r => r.project === project)
+    : [];
+
+  const tokens = query
+    .replace(/\bD#\d+\b/gi, ' ')
+    .toLowerCase()
+    .split(/\s+/)
+    .filter(t => t.length >= 2)
+    .slice(0, 8);
+
+  let keyword = [];
+  if (tokens.length > 0) {
+    const open = db.prepare(`
+      SELECT * FROM deferred_work
+      WHERE project = ? AND status = 'open'
+      ORDER BY priority DESC, created_at_epoch ASC
+      LIMIT 50
+    `).all(project);
+    const need = Math.max(1, Math.ceil(tokens.length / 2));
+    keyword = open
+      .map(r => {
+        const hay = `${r.title || ''} ${r.detail || ''}`.toLowerCase();
+        return { r, matched: tokens.filter(t => hay.includes(t)).length };
+      })
+      .filter(x => x.matched >= need)
+      .sort((a, b) => b.matched - a.matched)
+      .map(x => x.r);
+  }
+
+  const seen = new Set();
+  const out = [];
+  for (const r of [...direct, ...keyword]) {
+    if (seen.has(r.id)) continue;
+    seen.add(r.id);
+    out.push(r);
+    if (out.length >= limit) break;
+  }
+  return out;
+}
+
+/**
+ * Render the deferred search trailer — appended AFTER (and never counted in)
+ * the main result set. Title-only lines; `invokeHint` names the surface's
+ * full-detail reader (CLI `get D#N` / MCP mem_get).
+ * @param {Array<object>} rows From searchDeferredWork
+ * @param {string} invokeHint e.g. 'claude-mem-lite get D#<id>'
+ * @returns {string[]} Lines (empty array when rows is empty)
+ */
+export function formatDeferredSearchTrailer(rows, invokeHint) {
+  if (!Array.isArray(rows) || rows.length === 0) return [];
+  const lines = [`[mem] Deferred work matches — full detail: ${invokeHint}`];
+  for (const r of rows) {
+    const pTag = r.priority === 3 ? '🔴' : r.priority === 1 ? '⚪' : '🟡';
+    const statusTag = r.status === 'open' ? '' : ` [${r.status}]`;
+    const title = (r.title || '(untitled)').length > 80 ? `${r.title.slice(0, 80)}…` : (r.title || '(untitled)');
+    lines.push(`  D#${r.id} ${pTag} [P${r.priority}]${statusTag} ${title}`);
+  }
+  return lines;
+}
+
 /**
  * Resolve mixed ordinal (int) + raw-id ("D#<n>") tokens to real deferred_work
  * ids, validated against caller project + status='open'.

package/lib/id-routing.mjs

@@ -55,6 +55,32 @@ export function bucketIdTokens(tokens, { explicit = null, defaultSource = 'obs'
   return { bySrc, invalid };
 }
 
+/**
+ * Peel D#N deferred-work tokens off a mixed get-token list BEFORE bucketing.
+ * D# is a get-only read surface: deferred rows live outside the observation
+ * timeline, so they never enter bucketIdTokens' obs/session/prompt/event
+ * buckets, are exempt from `source` forcing, and stay rejected by the
+ * delete/timeline schemas. Requires the `#` (bare "D92" is prose, not a token).
+ *
+ * @param {Array<string|number>} tokens Mixed input
+ * @returns {{deferredIds: number[], rest: Array<string|number>}} deferredIds
+ *   deduped in input order; rest preserved for bucketIdTokens.
+ */
+export function splitDeferredTokens(tokens) {
+  const deferredIds = [];
+  const rest = [];
+  for (const raw of tokens) {
+    const m = typeof raw === 'string' ? /^[Dd]#(\d+)$/.exec(raw.trim()) : null;
+    if (m) {
+      const id = parseInt(m[1], 10);
+      if (id > 0 && !deferredIds.includes(id)) deferredIds.push(id);
+    } else {
+      rest.push(raw);
+    }
+  }
+  return { deferredIds, rest };
+}
+
 /**
  * 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

@@ -33,7 +33,7 @@ import { cmdAdopt, cmdUnadopt } from './adopt-cli.mjs';
 import { parseIntFlag, isNumericToken } from './lib/cli-flags.mjs';
 import { auditMemdir, memdirPath } from './memdir.mjs';
 import { aggregateProjectCiteRecall } from './lib/citation-tracker.mjs';
-import { probeOtherSources as probeIdSources, bucketIdTokens } from './lib/id-routing.mjs';
+import { probeOtherSources as probeIdSources, bucketIdTokens, splitDeferredTokens } from './lib/id-routing.mjs';
 import { join, sep, dirname } from 'path';
 import { readFileSync, existsSync, readdirSync } from 'fs';
 
@@ -54,6 +54,9 @@ import { aggregateMetrics } from './lib/metrics.mjs';
 import {
   insertDeferred, listOpenWithOrdinal, dropDeferred,
   resolveDeferredIds, closeDeferredItems,
+  getDeferredByIds, formatDeferredDetail,
+  searchDeferredWork, formatDeferredSearchTrailer,
+  formatDeferListRow, countStaleOpen, formatDeferStaleHint,
 } from './lib/deferred-work.mjs';
 
 // ─── Commands ────────────────────────────────────────────────────────────────
@@ -142,6 +145,20 @@ async function cmdSearch(db, args, { llm } = {}) {
     return;
   }
 
+  // P2: deferred trailer — open deferred items matching the query, appended
+  // after (and never counted in) the main results. Unfiltered first-page text
+  // searches only; --json keeps its documented shape (deliberate asymmetry,
+  // locked by tests). Defined before the sanitize-empty early-return so a pure
+  // "D#92" query (which sanitizes to no FTS terms) still reaches the item.
+  const wantDeferredTrailer = !jsonOutput && !source && !type && !branch && !tier && !minImportance && offset === 0;
+  const emitDeferredTrailer = () => {
+    if (!wantDeferredTrailer) return;
+    try {
+      const rows = searchDeferredWork(db, query, project || inferProject());
+      for (const line of formatDeferredSearchTrailer(rows, 'claude-mem-lite get D#<id>')) out(line);
+    } catch { /* trailer is best-effort; never break search */ }
+  };
+
   const ftsQuery = buildSearchFtsQuery(query, { or: useOr });
   // --deep proceeds even when the literal query sanitizes to nothing — its LLM
   // rewrite may still produce searchable variants (F3, parity with server.mjs).
@@ -153,6 +170,7 @@ async function cmdSearch(db, args, { llm } = {}) {
     if (jsonOutput) {
       out(JSON.stringify({ query, total: 0, returned: 0, offset, limit, deep: false, results: [] }));
     } else {
+      emitDeferredTrailer();
       fail(`[mem] No valid search terms in "${query}"`);
     }
     return;
@@ -246,6 +264,9 @@ async function cmdSearch(db, args, { llm } = {}) {
       out(JSON.stringify({ query, total: 0, returned: 0, offset, limit, deep: isDeep, variants: isDeep ? deepVariants : undefined, results: [] }));
     } else {
       out(`[mem] No results for "${query}"`);
+      // The zero-result path is where the trailer earns its keep — the D#92
+      // failure chain was exactly "searched, found nothing, item was deferred".
+      emitDeferredTrailer();
     }
     return;
   }
@@ -334,6 +355,7 @@ async function cmdSearch(db, args, { llm } = {}) {
       }
     }
   }
+  emitDeferredTrailer();
 }
 
 function cmdRecent(db, args) {
@@ -573,7 +595,7 @@ function cmdGet(db, args) {
   const idStr = positional.join(',');
   if (!idStr) {
     fail('[mem] Usage: claude-mem-lite get <id1,id2,...> [--source obs|session|prompt|event] [--fields f1,f2,...]\n' +
-         '        IDs accept prefix from search output: #123 (obs), P#123 (prompt), S#123 (session), E#123 (event).');
+         '        IDs accept prefix from search output: #123 (obs), P#123 (prompt), S#123 (session), E#123 (event), D#123 (deferred item, full detail).');
     return;
   }
 
@@ -587,12 +609,16 @@ function cmdGet(db, args) {
     return;
   }
 
+  // D#N deferred tokens are peeled off BEFORE bucketing/source-forcing — they
+  // always read deferred_work (get-only surface; delete/timeline keep rejecting).
+  const { deferredIds, rest } = splitDeferredTokens(tokens);
+
   // Shared bucketing with MCP mem_get — single source of truth for P#/S#/E#/# routing (#8050).
-  const { bySrc, invalid: unparseable } = bucketIdTokens(tokens, { explicit, defaultSource: 'obs' });
+  const { bySrc, invalid: unparseable } = bucketIdTokens(rest, { 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 + bySrc.event.length === 0) {
+  if (bySrc.obs.length + bySrc.session.length + bySrc.prompt.length + bySrc.event.length + deferredIds.length === 0) {
     fail('[mem] No valid IDs provided');
     return;
   }
@@ -615,6 +641,21 @@ function cmdGet(db, args) {
 
   const sections = [];
   let totalFound = 0;
+  // Deferred sections render first: explicit D# requests are rare and the
+  // FULL detail (never truncated) is the whole point of this surface.
+  let deferredMissing = [];
+  if (deferredIds.length > 0) {
+    const dRows = getDeferredByIds(db, deferredIds);
+    const found = new Set(dRows.map(r => r.id));
+    deferredMissing = deferredIds.filter(id => !found.has(id));
+    if (dRows.length > 0) {
+      sections.push(dRows.map(formatDeferredDetail).join('\n\n'));
+      totalFound += dRows.length;
+    }
+    if (deferredMissing.length > 0) {
+      process.stderr.write(`[mem] Deferred item(s) not found: ${deferredMissing.map(i => `D#${i}`).join(', ')}\n`);
+    }
+  }
   if (bySrc.obs.length > 0) {
     const s = renderObsRows(db, bySrc.obs, requestedFields);
     if (s) { sections.push(s.text); totalFound += s.count; }
@@ -633,6 +674,12 @@ function cmdGet(db, args) {
   }
 
   if (totalFound === 0) {
+    // Deferred-only request that found nothing — the source-probe below is
+    // about obs/session/prompt/event and would print an empty source list.
+    if (deferredMissing.length > 0 && bySrc.obs.length + bySrc.session.length + bySrc.prompt.length + bySrc.event.length === 0) {
+      fail(`[mem] Deferred item(s) not found: ${deferredMissing.map(i => `D#${i}`).join(', ')}. List open items: claude-mem-lite defer list`);
+      return;
+    }
     // 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 = [...bySrc.obs, ...bySrc.session, ...bySrc.prompt, ...bySrc.event];
@@ -991,9 +1038,13 @@ function cmdDeferList(db, args) {
   }
   out(`[mem] Open deferred items (project "${project}"):`);
   for (const r of list) {
-    const pTag = r.priority === 3 ? '🔴' : r.priority === 1 ? '⚪' : '🟡';
-    out(`  ${r.ordinal}. ${pTag} [P${r.priority}] ${r.title} (D#${r.id})`);
+    out(`  ${formatDeferListRow(r)}`);
   }
+  const staleHint = formatDeferStaleHint(countStaleOpen(db, project));
+  if (staleHint) out(`  ${staleHint}`);
+  // Affordance for the detail field — list stays title-only by design (it is
+  // mirrored into the SessionStart dashboard, where detail would be noise).
+  out(`  Full detail: claude-mem-lite get D#<id>`);
 }
 
 function cmdDeferDrop(db, args) {
@@ -1163,6 +1214,9 @@ async function cmdStats(db, args) {
   }
 
   out(`[mem] Stats${project ? ` (${project})` : ''}:`);
+  // Env-aware data dir (CLAUDE_MEM_DIR || ~/.claude-mem-lite) — stated so any
+  // raw-db fallback can't guess a co-located-with-the-CLI path (D#92 chain).
+  out(`Data dir: ${DB_DIR}`);
   out(`Total: ${obsTotal.c.toLocaleString()} observations | ${sessTotal.c} sessions | ${promptTotal.c} prompts`);
   out(`Last ${days}d: ${obsRecent.c} observations | ${sessRecent.c} sessions`);
   out('');
@@ -2550,9 +2604,11 @@ Commands:
     --json              Output as JSON: {file,limit,include_noise,total,results:[…]}
 
   get <id1,id2,...>     Get full details by ID
-    IDs accept search-output prefixes: #123 (obs), P#123 (prompt), S#123 (session).
+    IDs accept search-output prefixes: #123 (obs), P#123 (prompt), S#123 (session),
+    D#123 (deferred item — FULL detail; defer list is title-only).
     Bare N defaults to obs. Mixed prefixes in one call route each token correctly.
-    --source S          Force record type (obs|session|prompt); overrides prefixes.
+    --source S          Force record type (obs|session|prompt); overrides prefixes
+                        (D# tokens exempt — they always read deferred_work).
     --fields f1,f2,...  Select specific fields to return (observations only).
 
   timeline              Show observations around an anchor (shows recent if no anchor)
@@ -2584,7 +2640,7 @@ Commands:
       --detail T        Constraint + why deferred
       --files f1,f2     Comma-separated file paths
       --project P       Project name
-    list                List open deferred items
+    list                List open deferred items (title-only; full detail via get D#N)
       --limit N         Max results (default 10)
       --project P       Filter by project
     drop <D#N|ordinal>[,...]  Drop one or more deferred items (no fix needed)

package/package.json

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

package/scripts/prompt-search-utils.mjs

@@ -218,3 +218,30 @@ export function extractFiles(text) {
     !/^\d+\.\d+$/.test(m)  // Exclude pure version numbers like "3.14" (not paths like "1.0/config.json")
   );
 }
+
+// ─── Deferred-work references (D#N) ──────────────────────────────────────────
+
+// Cap injected deferred items per prompt — a batch approval ("D#1 D#2 D#3 全部
+// 批准") gets the first three; more would blow the injection noise budget.
+export const MAX_DEFERRED_REFS = 3;
+
+/**
+ * Extract deferred_work ids the prompt explicitly references as D#N (case-
+ * insensitive). Requires the `#` — bare "D92" is prose (chip names, model
+ * numbers), not a token. Deduped, input order, capped at MAX_DEFERRED_REFS.
+ * @param {string} text
+ * @returns {number[]}
+ */
+export function extractDeferredRefs(text) {
+  const out = [];
+  const re = /\bD#(\d+)\b/gi;
+  let m;
+  while ((m = re.exec(String(text || ''))) !== null) {
+    const id = parseInt(m[1], 10);
+    if (id > 0 && !out.includes(id)) {
+      out.push(id);
+      if (out.length >= MAX_DEFERRED_REFS) break;
+    }
+  }
+  return out;
+}

package/scripts/user-prompt-search.js

@@ -11,7 +11,8 @@ import { writeFileSync, readFileSync, existsSync, renameSync } from 'fs';
 import { join, sep } from 'path';
 import { pathToFileURL } from 'url';
 import Database from 'better-sqlite3';
-import { shouldSkip, computeEffectiveLen, detectIntent, shouldSkipByDedup, extractFiles, extractErrorSignature, DEDUP_STALE_MS, matchRegistrySkillName, detectMemOverride } from './prompt-search-utils.mjs';
+import { shouldSkip, computeEffectiveLen, detectIntent, shouldSkipByDedup, extractFiles, extractErrorSignature, extractDeferredRefs, DEDUP_STALE_MS, matchRegistrySkillName, detectMemOverride } from './prompt-search-utils.mjs';
+import { getDeferredByIds } from '../lib/deferred-work.mjs';
 import { recommendSkill } from '../registry-recommend.mjs';
 
 // ─── Constants ──────────────────────────────────────────────────────────────
@@ -580,15 +581,68 @@ async function main() {
   // into the FTS MATCH query terms. Mirrors hook.mjs handleUserPrompt.
   const promptText = stripPrivate(rawPrompt);
 
-  // Skip short/confirmation/slash-command/simple-op prompts
-  if (shouldSkip(promptText)) return;
-
   // P0: User-explicit "ignore memory" override (mirrors CC built-in
-  // memoryTypes.ts:215). When the prompt directly tells Claude to skip
-  // memory recall, we short-circuit before FTS — no FTS budget burn,
-  // no .claude-mem-injected-* state churn, no surface emission.
+  // memoryTypes.ts:215). Moved ABOVE the deterministic D# path so it
+  // short-circuits ALL injection surfaces (previously ran after shouldSkip —
+  // same outcome there, both return without output).
   if (detectMemOverride(promptText)) return;
 
+  // ─── Deterministic D#N deferred-detail injection (v3.50) ──────────────────
+  // A prompt naming D#N ("D#92 批准，进 writing-plans") is the highest-precision
+  // trigger this hook has: the user is resuming a deferred item whose FULL
+  // detail no list surface renders (defer list / dashboard are title-only —
+  // the 2026-07-18 D#92 post-/clear failure chain). Runs BEFORE shouldSkip /
+  // length gates: short approval prompts are the common case here, and the
+  // trigger is exact-reference, not relevance-scored.
+  let db = null;
+  try {
+    const deferredRefs = extractDeferredRefs(promptText);
+    if (deferredRefs.length > 0) {
+      db = ensureDb();
+      const project = inferProject();
+      const openRows = getDeferredByIds(db, deferredRefs)
+        .filter(r => r.status === 'open' && r.project === project);
+      // Namespace dedup ids as "D<id>" (parity with the "P<id>" prompt-corpus
+      // convention) so obs ids can't collide in the shared injected-ids file.
+      const dedupIds = openRows.map(r => `D${r.id}`);
+      if (openRows.length > 0 && !shouldSkipByDedup(dedupIds, INJECTED_IDS_FILE)) {
+        const lines = ['[mem] Deferred work referenced in prompt (open items, full detail):'];
+        for (const r of openRows) {
+          const pTag = r.priority === 3 ? '🔴' : r.priority === 1 ? '⚪' : '🟡';
+          lines.push(`D#${r.id} ${pTag} [P${r.priority}] ${neutralizeContextDelimiters(r.title || '')}`);
+          if (r.detail) {
+            // Full detail, defanged, never truncated — the point of this surface.
+            for (const dl of neutralizeContextDelimiters(r.detail).split('\n')) lines.push(`  ${dl}`);
+          }
+        }
+        process.stdout.write(lines.join('\n') + '\n');
+        // Merge into the dedup file so a re-referencing prompt within the stale
+        // window skips re-injection. A later FTS-path write replaces ids wholesale
+        // (accepted: worst case is one cheap re-injection after an obs-emitting
+        // prompt inside the same 5-min window).
+        try {
+          let prevIds = [];
+          let prevCount = 0;
+          try {
+            const prev = JSON.parse(readFileSync(INJECTED_IDS_FILE, 'utf8'));
+            if (prev.ts && Date.now() - prev.ts < DEDUP_STALE_MS) {
+              prevIds = Array.isArray(prev.ids) ? prev.ids : [];
+              prevCount = prev.count || 0;
+            }
+          } catch {}
+          writeFileSync(INJECTED_IDS_FILE, JSON.stringify({
+            ids: [...new Set([...prevIds.map(String), ...dedupIds])],
+            ts: Date.now(),
+            count: prevCount + 1,
+          }));
+        } catch {}
+      }
+    }
+  } catch { /* deterministic path must never block the main flow */ }
+
+  // Skip short/confirmation/slash-command/simple-op prompts
+  if (shouldSkip(promptText)) { try { db?.close(); } catch {} return; }
+
   // T3 (v2.31): additional raw-length gate on top of shouldSkip's CJK-weighted
   // effective-length check. Suppresses medium-short Latin prompts ("run tests",
   // "fix bug now") that carry too few content tokens for a meaningful FTS lookup.
@@ -596,13 +650,15 @@ async function main() {
   // short continuations ("前面那个?", "does it work?") depend on prior context.
   const followUp = isFollowUpSession();
   const promptMinLen = followUp ? FOLLOWUP_PROMPT_MIN_LENGTH : PROMPT_MIN_LENGTH;
-  if (computeEffectiveLen(promptText.trim()) < promptMinLen) return;
+  if (computeEffectiveLen(promptText.trim()) < promptMinLen) { try { db?.close(); } catch {} return; }
   const bm25Floor = followUp ? FOLLOWUP_BM25_MIN_SCORE : BM25_MIN_SCORE;
 
-  let db;
-  try {
-    db = ensureDb();
-  } catch { return; }
+  // db may already be open from the deterministic D# path above.
+  if (!db) {
+    try {
+      db = ensureDb();
+    } catch { return; }
+  }
 
   try {
     const project = inferProject();

package/server.mjs

@@ -43,7 +43,7 @@ import { join, sep } from 'path';
 import { homedir } from 'os';
 import { ensureRegistryDb, upsertResource } from './registry.mjs';
 import { searchResources } from './registry-retriever.mjs';
-import { probeOtherSources as probeIdSources, bucketIdTokens } from './lib/id-routing.mjs';
+import { probeOtherSources as probeIdSources, bucketIdTokens, splitDeferredTokens } from './lib/id-routing.mjs';
 import { saveObservation } from './lib/save-observation.mjs';
 import { rebuildObservationDerived } from './lib/observation-write.mjs';
 import { EXPORT_COLUMNS_SQL } from './lib/export-columns.mjs';
@@ -52,6 +52,9 @@ import { AUTO_MERGE_THRESHOLD } from './lib/dedup-constants.mjs';
 import {
   insertDeferred, listOpenWithOrdinal, dropDeferred,
   resolveDeferredIds, closeDeferredItems,
+  getDeferredByIds, formatDeferredDetail,
+  searchDeferredWork, formatDeferredSearchTrailer,
+  formatDeferListRow, countStaleOpen, formatDeferStaleHint,
 } from './lib/deferred-work.mjs';
 import { _resetVocabCache } from './tfidf.mjs';
 import { createRequire } from 'module';
@@ -283,11 +286,30 @@ async function runSearchPipeline(db, args, { llm, rerankLlm } = {}) {
   const deepMode = resolveDeepMode(args.deep, { surface: 'mcp' });
   const rerank = args.rerank === true && deepMode === 'deep';
 
+  // P2: deferred trailer — open deferred items matching the query, appended to
+  // the text blob AFTER (and never counted in) the main results/total. Parity
+  // with CLI cmdSearch's emitDeferredTrailer; unfiltered first-page searches
+  // only. Structured fields (results/total) stay untouched — the trailer is a
+  // text affordance, not a result source.
+  const wantDeferredTrailer = !args.type && !args.obs_type && !args.branch && !args.tier && !args.importance && offset === 0;
+  const appendDeferredTrailer = (result) => {
+    if (!wantDeferredTrailer) return result;
+    try {
+      const rows = searchDeferredWork(db, args.query || '', args.project || currentProject);
+      const lines = formatDeferredSearchTrailer(rows, 'mem_get ids=["D#<id>"]');
+      if (lines.length > 0 && result.content?.[0]?.type === 'text') {
+        result.content[0].text += `\n\n${lines.join('\n')}`;
+      }
+    } catch { /* trailer is best-effort; never break search */ }
+    return result;
+  };
+
   // Early return when query was provided but sanitized to nothing (all FTS5
   // keywords/special chars). Skipped for deep/auto (the LLM rewrite may still
   // produce variants) and for filter-only listings (date/obs_type/importance).
+  // A pure "D#92" query lands here — the trailer still reaches the item.
   if (args.query && !ftsQuery && !epochFrom && !epochTo && !args.obs_type && !args.importance && deepMode === 'normal') {
-    return { ...formatSearchOutput([], args, ftsQuery, 0), escalated: false, results: [], total: 0, variants: null };
+    return { ...appendDeferredTrailer(formatSearchOutput([], args, ftsQuery, 0)), escalated: false, results: [], total: 0, variants: null };
   }
 
   // Source scoping. deep is observations-only (deepSearch fuses hybrid-obs lists). branch/tier are
@@ -349,6 +371,7 @@ async function runSearchPipeline(db, args, { llm, rerankLlm } = {}) {
   if (r.reranked && output.content?.[0]?.type === 'text') {
     output.content[0].text += '\n\n[deep search: LLM-reranked the top candidates by relevance]';
   }
+  appendDeferredTrailer(output);
 
   // Expose structured fields for tests + the MCP content blob.
   return { ...output, results: r.page, total: r.total, escalated: r.escalated, variants: r.variants, reranked: r.reranked };
@@ -505,14 +528,18 @@ server.registerTool(
     inputSchema: memGetSchema,
   },
   safeHandler(async (args) => {
+    // D#N deferred tokens are peeled off BEFORE bucketing/source-forcing —
+    // get-only read surface into deferred_work (parity with CLI cmdGet; the
+    // fetch+render live in lib/deferred-work.mjs so the twins cannot drift).
+    const { deferredIds, rest } = splitDeferredTokens(args.ids);
     // 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' });
+    const { bySrc, invalid } = bucketIdTokens(rest, { 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, S#N, or E#N.` }] };
+      return { content: [{ type: 'text', text: `Invalid ID token(s): ${invalid.join(', ')}. Expected N, #N, P#N, S#N, E#N, or D#N.` }] };
     }
-    const totalRequested = bySrc.obs.length + bySrc.session.length + bySrc.prompt.length + bySrc.event.length;
+    const totalRequested = bySrc.obs.length + bySrc.session.length + bySrc.prompt.length + bySrc.event.length + deferredIds.length;
     if (totalRequested === 0) {
       return { content: [{ type: 'text', text: 'No valid IDs provided.' }] };
     }
@@ -615,7 +642,26 @@ server.registerTool(
       }
     }
 
-    const totalFound = foundBySource.obs.size + foundBySource.session.size + foundBySource.prompt.size + foundBySource.event.size;
+    // Deferred sections — prepended below (explicit D# requests are rare; the
+    // FULL untruncated detail is the point of this surface).
+    let deferredSections = [];
+    let deferredFound = 0;
+    let deferredMissing = [];
+    if (deferredIds.length > 0) {
+      const dRows = getDeferredByIds(db, deferredIds);
+      const found = new Set(dRows.map(r => r.id));
+      deferredMissing = deferredIds.filter(id => !found.has(id));
+      deferredSections = dRows.map(formatDeferredDetail);
+      deferredFound = dRows.length;
+    }
+
+    const totalFound = foundBySource.obs.size + foundBySource.session.size + foundBySource.prompt.size + foundBySource.event.size + deferredFound;
+
+    if (totalFound === 0 && deferredIds.length > 0 && bySrc.obs.length + bySrc.session.length + bySrc.prompt.length + bySrc.event.length === 0) {
+      // Deferred-only request, nothing found — the source-probe below is about
+      // obs/session/prompt/event and would render an empty source list.
+      return { content: [{ type: 'text', text: `Deferred item(s) not found: ${deferredMissing.map(i => `D#${i}`).join(', ')}. List open items: mem_defer_list.` }] };
+    }
 
     if (totalFound === 0) {
       // Probe other sources so callers can retry with the right prefix/source override.
@@ -629,7 +675,8 @@ server.registerTool(
       if (probe.event.length > 0)   hints.push(`E#${probe.event.join(', E#')} (event — use source='event' or E#N)`);
       const hint = hints.length > 0 ? ` Try: ${hints.join('; ')}.` : '';
       const queriedList = [...queried].join(', ');
-      const msg = `No records found in source(s) [${queriedList}] for the given ID(s).${hint}`;
+      const deferredNote = deferredMissing.length > 0 ? ` Deferred item(s) not found: ${deferredMissing.map(i => `D#${i}`).join(', ')}.` : '';
+      const msg = `No records found in source(s) [${queriedList}] for the given ID(s).${deferredNote}${hint}`;
       return { content: [{ type: 'text', text: fieldsNote ? `${msg}\n\n${fieldsNote}` : msg }] };
     }
 
@@ -641,10 +688,11 @@ server.registerTool(
     missingHints.push(...miss(bySrc.session, foundBySource.session, 'S#'));
     missingHints.push(...miss(bySrc.prompt, foundBySource.prompt, 'P#'));
     missingHints.push(...miss(bySrc.event, foundBySource.event, 'E#'));
+    missingHints.push(...deferredMissing.map(id => `D#${id}`));
 
     const parts = [];
     if (fieldsNote) parts.push(fieldsNote);
-    parts.push(...sections);
+    parts.push(...deferredSections, ...sections);
     if (missingHints.length > 0) {
       parts.push(`Note: ID(s) ${missingHints.join(', ')} not found.`);
     }
@@ -799,9 +847,12 @@ server.registerTool(
     }
     const lines = [`Open deferred items (project "${project}"):`];
     for (const r of list) {
-      const pTag = r.priority === 3 ? '🔴' : r.priority === 1 ? '⚪' : '🟡';
-      lines.push(`${r.ordinal}. ${pTag} [P${r.priority}] ${r.title} (D#${r.id})`);
+      lines.push(formatDeferListRow(r));
     }
+    const staleHint = formatDeferStaleHint(countStaleOpen(db, project));
+    if (staleHint) lines.push(staleHint);
+    // Affordance for the detail field — list stays title-only by design.
+    lines.push(`Full detail: mem_get ids=["D#<id>"]`);
     return { content: [{ type: 'text', text: lines.join('\n') }] };
   })
 );
@@ -858,6 +909,8 @@ server.registerTool(
     const lines = [
       `Memory Statistics${args.project ? ` (project: ${args.project})` : ''}:`,
       '',
+      // Env-aware data dir — parity with CLI cmdStats (D#92 wrong-path chain).
+      `Data dir: ${DB_DIR}`,
       `Total: ${obsTotal.c} observations | ${sessTotal.c} sessions | ${promptTotal.c} prompts`,
       `Last ${days}d: ${obsRecent.c} observations | ${sessRecent.c} sessions`,
       '',

package/tool-schemas.mjs

@@ -52,7 +52,7 @@ const coerceStringArray = z.preprocess(
   z.array(z.string())
 );
 
-// Coerce mixed ID tokens (#N / P#N / S#N / bare N) for mem_get. Accepts:
+// Coerce mixed ID tokens (#N / P#N / S#N / D#N / bare N) for mem_get. Accepts:
 //   - native arrays: [1, "P#2", "#3"]
 //   - single number: 1
 //   - single/comma string: "1,P#2,S#3"
@@ -76,7 +76,10 @@ const coerceMixedIdTokens = z.preprocess(
     }
     return v;
   },
-  z.array(z.string().regex(/^[EePpSs]?#?\d+$/, 'Expected N, #N, P#N, S#N, or E#N')).min(1).max(20)
+  // D#N (deferred_work) requires the `#` — bare "D92" is prose, not a token.
+  // Round-trip rule: `defer list` renders "(D#92)", so mem_get must accept it
+  // back (tests/schema-roundtrip.test.mjs). Delete/timeline keep rejecting D#.
+  z.array(z.string().regex(/^(?:[Dd]#|[EePpSs]?#?)\d+$/, 'Expected N, #N, P#N, S#N, E#N, or D#N')).min(1).max(20)
 );
 
 export const memSearchSchema = {
@@ -137,8 +140,8 @@ export const memGetSchema = {
   // 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/event IDs — accepts N, #N, P#N, S#N, E#N; comma-strings and JSON arrays also coerced'),
-  source: z.enum(['obs', 'session', 'prompt', 'event']).optional().describe('Force all IDs to this source (overrides per-token prefixes). Omit to let P#/S#/E#/# prefixes route individually.'),
+  ids: coerceMixedIdTokens.describe('Mixed observation/prompt/session/event/deferred IDs — accepts N, #N, P#N, S#N, E#N, D#N; comma-strings and JSON arrays also coerced. D#N reads a deferred_work item with FULL detail (defer list is title-only)'),
+  source: z.enum(['obs', 'session', 'prompt', 'event']).optional().describe('Force all IDs to this source (overrides per-token prefixes). Omit to let P#/S#/E#/# prefixes route individually. D#N tokens are exempt — they always read deferred_work.'),
   fields: coerceStringArray.optional().describe('Specific fields to return (default: all; validated against obs schema — session/prompt sources ignore this filter)'),
 };