claude-mem-lite 3.48.0 → 3.50.0

package/mem-cli.mjs

@@ -15,7 +15,6 @@ import { ensureRegistryDb, upsertResource } from './registry.mjs';
 import { searchResources } from './registry-retriever.mjs';
 import { computeFunnel, formatFunnel, computeSweep, formatSweep, DEFAULT_SWEEP_FLOORS, DEFAULT_SWEEP_MARGINS } from './registry-recommend.mjs';
 import { selectCompressionCandidates, groupByProjectWeek, compressGroup } from './lib/compress-core.mjs';
-import { buildNotLowSignalSql } from './lib/low-signal-patterns.mjs';
 import {
   cleanupBroken, decayAndMarkIdle, boostAccessed, demotePinned, mergeDuplicates,
   recoverOrphanedChildren, recoverBuriedLessons, sweepDeferredWorkOrphans,
@@ -25,13 +24,16 @@ import {
 } from './lib/maintain-core.mjs';
 import { snapshotDb } from './lib/db-backup.mjs';
 import { deleteObservations } from './lib/delete-core.mjs';
+import { OBS_TYPE_SET } from './lib/obs-types.mjs';
+import { computeStatsFeed } from './lib/stats-core.mjs';
+import { buildLessonNudge } from './lib/save-nudge.mjs';
 import { optimizePreview, optimizeRun } from './hook-optimize.mjs';
 import { buildSessionContextLines } from './hook-context.mjs';
 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';
 
@@ -42,7 +44,6 @@ import { parseArgs, out, fail, relativeTime, fmtDateShort, parseIdToken, formatP
 import { saveObservation } from './lib/save-observation.mjs';
 import { rebuildObservationDerived, normalizeScope } from './lib/observation-write.mjs';
 import { EXPORT_COLUMNS_SQL } from './lib/export-columns.mjs';
-import { computeNoiseGauge } from './lib/stats-quality.mjs';
 import { recallByFile } from './lib/recall-core.mjs';
 import { resolveAnchorToken, formatAnchorError, resolveQueryAnchor, fetchRecentTimeline, fetchTimelineWindow } from './lib/timeline-core.mjs';
 import { buildSearchFtsQuery, parseDateBounds, parseDuration, coreRunSearchPipeline } from './lib/search-core.mjs';
@@ -53,6 +54,8 @@ import { aggregateMetrics } from './lib/metrics.mjs';
 import {
   insertDeferred, listOpenWithOrdinal, dropDeferred,
   resolveDeferredIds, closeDeferredItems,
+  getDeferredByIds, formatDeferredDetail,
+  searchDeferredWork, formatDeferredSearchTrailer,
 } from './lib/deferred-work.mjs';
 
 // ─── Commands ────────────────────────────────────────────────────────────────
@@ -72,7 +75,7 @@ async function cmdSearch(db, args, { llm } = {}) {
 
   const limit = parseIntFlag(flags.limit, { name: '--limit', defaultValue: 20, max: 1000 });
   const type = flags.type || null;
-  const validObsTypes = new Set(['decision', 'bugfix', 'feature', 'refactor', 'discovery', 'change']);
+  const validObsTypes = OBS_TYPE_SET;
   if (type && !validObsTypes.has(type)) {
     fail(`[mem] Invalid --type "${type}". Valid: ${[...validObsTypes].join(', ')}`);
     return;
@@ -141,6 +144,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).
@@ -152,6 +169,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;
@@ -245,6 +263,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;
   }
@@ -333,6 +354,7 @@ async function cmdSearch(db, args, { llm } = {}) {
       }
     }
   }
+  emitDeferredTrailer();
 }
 
 function cmdRecent(db, args) {
@@ -369,7 +391,7 @@ function cmdRecent(db, args) {
   // try this for "show recent bugfixes". Mirror cmdSearch's enum validation.
   const type = flags.type || null;
   if (type) {
-    const validObsTypes = new Set(['decision', 'bugfix', 'feature', 'refactor', 'discovery', 'change']);
+    const validObsTypes = OBS_TYPE_SET;
     if (!validObsTypes.has(type)) {
       fail(`[mem] Invalid --type "${type}". Valid: ${[...validObsTypes].join(', ')}`);
       return;
@@ -572,7 +594,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;
   }
 
@@ -586,12 +608,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;
   }
@@ -614,6 +640,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; }
@@ -632,6 +673,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];
@@ -803,7 +850,7 @@ function cmdSave(db, args) {
   if (rejectBareStringFlags(flags, ['title', 'files', 'lesson', 'lesson-learned', 'project', 'type'])) return;
 
   const type = flags.type || 'discovery';
-  const validTypes = new Set(['decision', 'bugfix', 'feature', 'refactor', 'discovery', 'change']);
+  const validTypes = OBS_TYPE_SET;
   if (!validTypes.has(type)) {
     fail(`[mem] Invalid type "${type}". Valid: ${[...validTypes].join(', ')}`);
     return;
@@ -912,7 +959,7 @@ function cmdSave(db, args) {
   const supersededNote = result.supersededIds && result.supersededIds.length > 0
     ? ` Superseded: ${result.supersededIds.map(i => `#${i}`).join(', ')}.`
     : '';
-  out(`[mem] Saved #${result.id} [${result.type}] "${truncate(result.title, 80)}" (project: ${result.project})${lessonNote}${closedNote}${supersededNote}`);
+  out(`[mem] Saved #${result.id} [${result.type}] "${truncate(result.title, 80)}" (project: ${result.project})${lessonNote}${closedNote}${supersededNote}${buildLessonNudge({ type: result.type, id: result.id, lessonCaptured: result.lessonCaptured, surface: 'cli' })}`);
 }
 
 // ─── cmdDefer (sub-dispatch: add | list | drop) ──────────────────────────────
@@ -993,6 +1040,9 @@ function cmdDeferList(db, args) {
     const pTag = r.priority === 3 ? '🔴' : r.priority === 1 ? '⚪' : '🟡';
     out(`  ${r.ordinal}. ${pTag} [P${r.priority}] ${r.title} (D#${r.id})`);
   }
+  // 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) {
@@ -1112,98 +1162,12 @@ async function cmdStats(db, args) {
     return;
   }
 
-  const projectFilter = project ? 'AND project = ?' : '';
-  const baseParams = project ? [project] : [];
-
   const now = Date.now();
-  const cutoff = now - days * 86400000;
-
-  // Total counts (aligned with MCP mem_stats: use session_summaries, not sdk_sessions)
-  const obsTotal = db.prepare(
-    `SELECT COUNT(*) as c FROM observations WHERE 1=1 ${projectFilter}`
-  ).get(...baseParams);
-  const sessTotal = db.prepare(
-    `SELECT COUNT(*) as c FROM session_summaries WHERE 1=1 ${projectFilter}`
-  ).get(...baseParams);
-  const promptTotal = project
-    ? db.prepare('SELECT COUNT(*) as c FROM user_prompts p JOIN sdk_sessions s ON p.content_session_id = s.content_session_id WHERE s.project = ?').get(project)
-    : db.prepare('SELECT COUNT(*) as c FROM user_prompts').get();
-
-  // Recent counts
-  const obsRecent = db.prepare(
-    `SELECT COUNT(*) as c FROM observations WHERE created_at_epoch >= ? ${projectFilter}`
-  ).get(cutoff, ...baseParams);
-  const sessRecent = db.prepare(
-    `SELECT COUNT(*) as c FROM session_summaries WHERE created_at_epoch >= ? ${projectFilter}`
-  ).get(cutoff, ...baseParams);
-
-  // Type distribution (recent)
-  const types = db.prepare(`
-    SELECT type, COUNT(*) as c FROM observations
-    WHERE created_at_epoch >= ? ${projectFilter}
-    GROUP BY type ORDER BY c DESC
-  `).all(cutoff, ...baseParams);
-
-  // Top projects (global view — skipped when filtering by single project; aligned with MCP)
-  const projects = project ? [] : db.prepare(`
-    SELECT project, COUNT(*) as c FROM observations
-    GROUP BY project ORDER BY c DESC LIMIT 20
-  `).all();
-
-  // Daily activity (last 7 days; aligned with MCP mem_stats)
-  const daily = db.prepare(`
-    SELECT date(created_at) as day, COUNT(*) as c FROM observations
-    WHERE created_at_epoch >= ? ${projectFilter}
-    GROUP BY day ORDER BY day DESC LIMIT 7
-  `).all(now - 7 * 86400000, ...baseParams);
-
-  // Data health (aligned with MCP mem_stats)
-  const tokenEst = db.prepare(`
-    SELECT SUM(LENGTH(COALESCE(title,'')) + LENGTH(COALESCE(narrative,'')) + LENGTH(COALESCE(text,''))) / 4 as t
-    FROM observations WHERE 1=1 ${projectFilter}
-  `).get(...baseParams);
-  const avgImp = db.prepare(
-    `SELECT AVG(COALESCE(importance,1)) as v FROM observations WHERE 1=1 ${projectFilter}`
-  ).get(...baseParams);
-  const thirtyDaysAgo = now - 30 * 86400000;
-  // v3.23 noise-gauge de-blinding: the prior `importance = 1` predicate was
-  // structurally blind to imp=0 — decay's floor + the LLM low-signal filter push
-  // dormant rows to 0, which on a real store is ~half the live corpus. The gauge
-  // therefore reported "0.0% noise" while the store was dormant-heavy. `<= 1` makes
-  // imp=0 visible; injection_count=0 mirrors decay's NEVER-INJECTED guard so an
-  // injected-but-decayed row (pinned noise, tracked separately) is not miscounted
-  // as "never used".
-  const lowVal = db.prepare(`
-    SELECT COUNT(*) as c FROM observations
-    WHERE COALESCE(importance,1) <= 1 AND COALESCE(access_count,0) = 0
-      AND COALESCE(injection_count,0) = 0
-      AND COALESCE(compressed_into, 0) = 0
-      AND created_at_epoch < ? ${projectFilter}
-  `).get(thirtyDaysAgo, ...baseParams);
-  // Low-signal-title population: template / tool-log titles (Modified, Worked on,
-  // Error while working, Error:, node/npm/npx …) that the retrieval layer already
-  // filters out by default. The imp=1 "Low-value" metric above structurally can't
-  // see these — they often carry inflated importance and recent access — so the
-  // health gauge under-reports real noise without this line. Same LOW_SIGNAL
-  // pattern source as the read-side filter (lib/low-signal-patterns.mjs).
-  const lowSignalTitle = db.prepare(`
-    SELECT COUNT(*) as c FROM observations
-    WHERE NOT ${buildNotLowSignalSql()}
-      AND COALESCE(compressed_into, 0) = 0 ${projectFilter}
-  `).get(...baseParams);
-  // F7: both noise numerators exclude compressed rows → divide by the LIVE count, not
-  // obsTotal (all rows), so a compress-heavy store isn't reported cleaner than it is.
-  // Shared with the MCP mem_stats gauge via computeNoiseGauge (lib/stats-quality.mjs).
-  const liveTotal = db.prepare(
-    `SELECT COUNT(*) as c FROM observations WHERE COALESCE(compressed_into, 0) = 0 ${projectFilter}`
-  ).get(...baseParams);
-  const { noiseRatio, lowSignalRatio } = computeNoiseGauge({ liveTotal: liveTotal.c, lowValCount: lowVal.c, lowSignalCount: lowSignalTitle.c });
-  const compressedCount = db.prepare(
-    `SELECT COUNT(*) as c FROM observations WHERE compressed_into IS NOT NULL ${projectFilter}`
-  ).get(...baseParams);
-  const supersededOnlyCount = db.prepare(
-    `SELECT COUNT(*) as c FROM observations WHERE superseded_at IS NOT NULL AND compressed_into IS NULL ${projectFilter}`
-  ).get(...baseParams);
+  const {
+    obsTotal, sessTotal, promptTotal, obsRecent, sessRecent,
+    types, projects, daily, tokenEst, avgImp, lowVal, lowSignalTitle,
+    noiseRatio, lowSignalRatio, compressedCount, supersededOnlyCount, tierMap,
+  } = computeStatsFeed(db, { project, days, now });
 
   // Hook self-observation: count PreToolUse / Skill-bridge script failures
   // recorded in the last 24h. Surfaces silent breakage (DB corruption,
@@ -1211,17 +1175,6 @@ async function cmdStats(db, args) {
   // failure mode that left code-graph's matcher bug undetected for 10 sessions.
   const hookErrors24h = countRecentHookErrors(join(DB_DIR, 'runtime'), now - 86400000);
 
-  // Tier distribution (aligned with MCP mem_stats)
-  const tierCtx = { now, currentProject: project || inferProject(), currentSessionId: '' };
-  const tdParams = tierSqlParams(tierCtx);
-  const tierDist = db.prepare(`
-    SELECT tier, COUNT(*) as c FROM (
-      SELECT ${TIER_CASE_SQL} as tier FROM observations
-      WHERE COALESCE(compressed_into, 0) = 0 AND superseded_at IS NULL ${projectFilter}
-    ) GROUP BY tier ORDER BY tier
-  `).all(...tdParams, ...baseParams);
-  const tierMap = Object.fromEntries(tierDist.map(r => [r.tier, r.c]));
-
   if (jsonOutput) {
     out(JSON.stringify({
       project,
@@ -1570,7 +1523,7 @@ function cmdUpdate(db, args) {
     updates.push('narrative = ?'); params.push(scrubSecrets(flags.narrative));
   }
   if (flags.type) {
-    const validTypes = new Set(['decision', 'bugfix', 'feature', 'refactor', 'discovery', 'change']);
+    const validTypes = OBS_TYPE_SET;
     if (!validTypes.has(flags.type)) {
       fail(`[mem] Invalid type "${flags.type}". Valid: ${[...validTypes].join(', ')}`);
       return;
@@ -1654,7 +1607,7 @@ function cmdExport(db, args) {
   if (flags.type) {
     // Reject unknown types — silently returning [] for `--type bogus` looked like a
     // legitimate empty filter result, hiding the typo. Mirrors cmdSearch / cmdSave / cmdUpdate.
-    const validObsTypes = new Set(['decision', 'bugfix', 'feature', 'refactor', 'discovery', 'change']);
+    const validObsTypes = OBS_TYPE_SET;
     if (!validObsTypes.has(flags.type)) {
       fail(`[mem] Invalid --type "${flags.type}". Valid: ${[...validObsTypes].join(', ')}`);
       return;
@@ -2646,9 +2599,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)
@@ -2680,7 +2635,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.48.0",
+  "version": "3.50.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",
@@ -92,6 +92,9 @@
     "lib/db-backup.mjs",
     "lib/delete-core.mjs",
     "lib/events-injection.mjs",
+    "lib/stats-core.mjs",
+    "lib/obs-types.mjs",
+    "lib/save-nudge.mjs",
     "lib/maintain-core.mjs",
     "lib/dedup-constants.mjs",
     "lib/deferred-work.mjs",

package/registry.mjs

@@ -376,7 +376,7 @@ const UPSERT_SQL = `
     repo_url=CASE WHEN excluded.repo_url != '' THEN excluded.repo_url ELSE repo_url END,
     repo_stars=CASE WHEN excluded.repo_stars > 0 THEN excluded.repo_stars ELSE repo_stars END,
     local_path=CASE WHEN excluded.local_path != '' THEN excluded.local_path ELSE local_path END,
-    file_hash=excluded.file_hash,
+    file_hash=CASE WHEN excluded.file_hash IS NOT NULL AND excluded.file_hash != '' THEN excluded.file_hash ELSE file_hash END,
     invocation_name=CASE WHEN excluded.invocation_name != '' THEN excluded.invocation_name ELSE invocation_name END,
     -- Preserve-on-empty (mirror repo_stars/invocation_name above): a PARTIAL re-upsert --
     -- e.g. "registry import --name X --capability-summary ...", where mem-cli defaults every

package/schema.mjs

@@ -176,7 +176,7 @@ const CORE_SCHEMA = `
     memory_session_id TEXT NOT NULL,
     project TEXT NOT NULL,
     text TEXT,
-    type TEXT NOT NULL CHECK(type IN ('decision', 'bugfix', 'feature', 'refactor', 'discovery', 'change')),
+    type TEXT NOT NULL CHECK(type IN ('decision', 'bugfix', 'feature', 'refactor', 'discovery', 'change')), -- keep in sync with lib/obs-types.mjs OBS_TYPES (locked by tests/obs-types-invariant.test.mjs)
     title TEXT,
     subtitle TEXT,
     facts TEXT,

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();
@@ -787,8 +843,11 @@ async function main() {
       if (matched) {
         const cooldown = getSkillCooldown();
         if (!cooldown[matched]) {
+          // Registry skill names come from third-party repos (tools/adopt import) — an
+          // untrusted boundary like every other DB-derived string on this surface.
+          const safeName = neutralizeContextDelimiters(matched);
           process.stdout.write(
-            `\n[mem] Skill "${matched}" may apply — invoke via SkillTool or run: claude-mem-lite registry show ${matched}\n`
+            `\n[mem] Skill "${safeName}" may apply — invoke via SkillTool or run: claude-mem-lite registry show ${safeName}\n`
           );
           setSkillCooldown(matched);
         }