claude-mem-lite 3.48.0 → 3.50.0

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "3.48.0",
+      "version": "3.50.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.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).",
   "author": {
     "name": "sdsrss"

package/hook-llm.mjs

@@ -21,6 +21,7 @@ import {
 import { EVENT_TYPES, saveEvent } from './lib/activity.mjs';
 import { isNoiseObservation, capNoiseImportance, isLowYieldChangeObs } from './lib/low-signal-patterns.mjs';
 import { episodeHasSignificantContent } from './hook-episode.mjs';
+import { OBS_TYPE_SET } from './lib/obs-types.mjs';
 
 // T9: memdir-incompatible types live in the `events` table, not `observations`.
 // Set lookup is O(1) — authoritative source is lib/activity.mjs::EVENT_TYPES.
@@ -771,7 +772,7 @@ ${actionList}`;
   const ruleImportance = computeRuleImportance(episode);
 
   let obs;
-  const validTypes = new Set(['decision', 'bugfix', 'feature', 'refactor', 'discovery', 'change']);
+  const validTypes = OBS_TYPE_SET;
 
   const gotSlot = await acquireLLMSlot();
   if (gotSlot) {

package/hook-optimize.mjs

@@ -15,6 +15,7 @@ import { scrubRecord } from './lib/scrub-record.mjs';
 import { getVocabulary, computeVector, cosineSimilarity, vecTextForRow } from './tfidf.mjs';
 import { MERGE_JACCARD_LOW, AUTO_MERGE_THRESHOLD } from './lib/dedup-constants.mjs';
 import { DB_DIR } from './schema.mjs';
+import { OBS_TYPE_SET } from './lib/obs-types.mjs';
 
 const RUNTIME_DIR = join(DB_DIR, 'runtime');
 
@@ -150,7 +151,7 @@ export async function executeReenrich(db, limit = 10, { scope = 'narrow', projec
   if (candidates.length === 0) return { processed: 0, skipped: 0 };
 
   let processed = 0, skipped = 0;
-  const validTypes = new Set(['decision', 'bugfix', 'feature', 'refactor', 'discovery', 'change']);
+  const validTypes = OBS_TYPE_SET;
 
   for (const cand of candidates) {
     const gotSlot = await acquireLLMSlot();
@@ -929,19 +930,32 @@ export async function optimizeRun(db, { tasks, maxItems = 15, force = false, ree
     try {
       switch (task) {
         case 're-enrich':
-          if (reenrichScope === 'narrow') {
-            // P1-2: the default maintenance pass covers BOTH narrow (fill lesson/concepts on
-            // fully-degraded rows) AND aliases (backfill search_aliases on lesson-bearing
-            // manual saves that narrow+wide both skip — mem_save writes no aliases, so without
-            // this they stay paraphrase-unfindable). Split the budget so neither starves.
-            // An explicit --scope wide|aliases still runs exactly that one scope (below).
-            const aliasBudget = Math.max(1, Math.floor(budget.reenrich / 2));
-            const narrowRes = await executeReenrich(db, budget.reenrich - aliasBudget, { scope: 'narrow', project });
-            const aliasRes = await executeReenrich(db, aliasBudget, { scope: 'aliases', project });
+          if (reenrichScope === 'narrow' || reenrichScope === 'wide') {
+            // P1-2 (v3.43) + audit 2026-07-17 P4: the maintenance pass covers BOTH the main
+            // scope (narrow = fill lesson/concepts on fully-degraded rows; wide = lesson
+            // backfill on substantive event-typed rows) AND aliases (backfill search_aliases
+            // on lesson-bearing manual saves that narrow+wide both skip — mem_save writes no
+            // aliases, so without this they stay paraphrase-unfindable). v3.43 hung the split
+            // only on the DEFAULT 'narrow' branch, but the DAILY auto path (handleLLMOptimize
+            // 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. 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);
+            const mainRes = await executeReenrich(db, budget.reenrich - aliasBudget, { scope: reenrichScope, project });
+            const aliasRes = aliasBudget > 0
+              ? await executeReenrich(db, aliasBudget, { scope: 'aliases', project })
+              : { processed: 0, skipped: 0 };
             results.reenrich = {
-              processed: (narrowRes.processed || 0) + (aliasRes.processed || 0),
-              skipped: (narrowRes.skipped || 0) + (aliasRes.skipped || 0),
-              byScope: { narrow: narrowRes, aliases: aliasRes },
+              processed: (mainRes.processed || 0) + (aliasRes.processed || 0),
+              skipped: (mainRes.skipped || 0) + (aliasRes.skipped || 0),
+              byScope: { [reenrichScope]: mainRes, aliases: aliasRes },
             };
           } else {
             results.reenrich = await executeReenrich(db, budget.reenrich, { scope: reenrichScope, project });

package/lib/activity.mjs

@@ -8,10 +8,11 @@ import { sanitizeFtsQuery } from '../utils.mjs';
 import { scrubRecord } from './scrub-record.mjs';
 import { saveObservation } from './save-observation.mjs';
 import { notLowSignalTitleClause } from '../scoring-sql.mjs';
+import { OBS_TYPE_SET } from './obs-types.mjs';
 
 // Observation types (mirrors the observations.type enum) — events carry a wider
 // set, so promotion maps the extras (lesson/bug/observation) onto valid obs types.
-const OBS_TYPES = new Set(['decision', 'bugfix', 'feature', 'refactor', 'discovery', 'change']);
+const OBS_TYPES = OBS_TYPE_SET;
 const EVENT_TO_OBS_TYPE = { bug: 'bugfix', lesson: 'discovery', observation: 'discovery' };
 
 /**

package/lib/deferred-work.mjs

@@ -74,6 +74,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/events-injection.mjs

@@ -4,9 +4,14 @@
 // event-typed memory (bugfix/decision/lesson/discovery/…) out of `observations`
 // and into the `events` table, so after Haiku enrichment the high-value history
 // lives ONLY in events. v3.44 wired events into mem_search + PreToolUse recall,
-// but the three PASSIVE injection surfaces (SessionStart context, UserPromptSubmit
-// path A = user-prompt-search.js, path B = hook.mjs memory-context) still read only
-// observations — so the promoted memories were unreachable at prompt/session time.
+// but the passive injection surfaces still read only observations — so the promoted
+// memories were unreachable at prompt/session time.
+//
+// Wiring (v3.48.0): SessionStart context (hook-context.mjs, recency) + UserPromptSubmit
+// path B (hook.mjs memory-context, FTS). Path A (user-prompt-search.js) is INTENTIONALLY
+// not wired: both UserPromptSubmit hooks fire on every prompt and there is no cross-hook
+// events dedup, so wiring path A too would double-inject the same event. Do NOT "complete"
+// the wiring by adding events here to path A.
 //
 // id-space discipline: events share the numeric id space with observations but are a
 // separate table, so injected events are rendered with an `E#` prefix. The
@@ -82,6 +87,10 @@ export function recentInjectableEvents(db, { project, limit = DEFAULT_LIMIT, min
  */
 export function renderInjectableEvent(row) {
   const title = neutralizeContextDelimiters((row.title || '').slice(0, TITLE_MAX));
+  // row.type is a frozen event_type enum (saveEvent is reached only via
+  // hook-llm.mjs behind `if (EVENT_TYPE_SET.has(summary.type))`), so it carries no
+  // injection markers and is intentionally NOT defanged — mirrors the un-defanged
+  // `[type]` for observations. If an unvalidated event writer is ever added, defang it.
   const head = `E#${row.id} [${row.type}] ${title}`;
   if (row.lesson_learned) {
     const lesson = neutralizeContextDelimiters(row.lesson_learned.trim().slice(0, LESSON_MAX));

package/lib/export-columns.mjs

@@ -14,7 +14,10 @@
 // + branch + timing. `id` + `memory_session_id` are informational (restore remaps id and
 // buckets under a synthetic restore session). Session-idempotency keys (last_decided/
 // last_cited_session_id, demoted_at, optimized_at) are intentionally NOT exported — they are
-// meaningless after a row is re-bucketed under a restore session.
+// meaningless after a row is re-bucketed under a restore session. Also intentionally NOT
+// exported: `related_ids` (holds observation ids, stale/dangling after restore remaps ids)
+// and `discovery_tokens` (a derived retrieval metric, rebuilt by the live system; exporting
+// it would freeze a stale value into backups).
 export const EXPORT_COLUMNS = [
   'id', 'memory_session_id', 'project', 'type', 'title', 'subtitle', 'narrative', 'text',
   'concepts', 'facts', 'files_read', 'files_modified', 'lesson_learned', 'search_aliases',

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/lib/obs-types.mjs

@@ -0,0 +1,12 @@
+// Single source of truth for the observation `type` vocabulary.
+//
+// Audit 2026-07-17 MED-3: this list was hardcoded verbatim in 10 JS sites + the SQL
+// CHECK constraint (schema.mjs observations DDL) — the project's #1 bug class
+// (fix-lands-on-one-surface) sitting latent on the core type vocabulary. Every
+// validator now imports from here; the SQL CHECK stays a literal (SQLite DDL cannot
+// interpolate at migration time) and is locked to this list by
+// tests/obs-types-invariant.test.mjs, which also fails if a new hardcoded copy of
+// the list appears anywhere else in the runtime source.
+export const OBS_TYPES = Object.freeze(['decision', 'bugfix', 'feature', 'refactor', 'discovery', 'change']);
+
+export const OBS_TYPE_SET = new Set(OBS_TYPES);

package/lib/save-nudge.mjs

@@ -0,0 +1,22 @@
+// Save-time lesson nudge (audit 2026-07-17 P4): bugfix/decision are the types whose
+// value lives in the lesson (root cause + fix / constraint + tradeoff), yet they are
+// exactly where lessonless writes concentrate (14d live data: bugfix 18.8% / decision
+// 28.7% lessonless, worsening). The nudge fires in the SAVE RESPONSE — the one moment
+// the model still has the context to write the lesson — and names the exact follow-up
+// call, so acting on it costs one tool call. Zero LLM cost; the async backfill arm
+// (optimizeRun wide/aliases re-enrich) stays the safety net for saves that ignore it.
+//
+// Shared by server.mjs (mem_save) and mem-cli.mjs (cmdSave) — one gate, two phrasings,
+// no twin drift.
+const NUDGE_TYPES = new Set(['bugfix', 'decision']);
+
+/**
+ * @param {{ type: string, id: number, lessonCaptured: boolean, surface: 'mcp'|'cli' }} p
+ * @returns {string} nudge text to append ('' when no nudge applies)
+ */
+export function buildLessonNudge({ type, id, lessonCaptured, surface }) {
+  if (lessonCaptured || !NUDGE_TYPES.has(type)) return '';
+  return surface === 'cli'
+    ? `\n[mem] ⚠ ${type} #${id} saved without a lesson — capture the root cause + fix while it's fresh: claude-mem-lite update ${id} --lesson "<root cause + fix>"`
+    : ` ⚠ Saved without lesson_learned — a ${type} is worth keeping only with its lesson. Capture it now: mem_update(id=${id}, lesson_learned="<root cause + fix>").`;
+}

package/lib/search-core.mjs

@@ -245,31 +245,57 @@ export function searchEventsFts(db, { ftsQuery, project = null, projectBoost = n
   `).all(...params);
 }
 
-// A lone match has no within-source spread to normalize against. Clamp it to
-// the neutral middle of the [-1, 0] band (MED-5): leaving its raw BM25 magnitude
-// (a title hit can reach -8..-40) let one incidental single-source match — and
-// `event` is now a common low-cardinality source — outrank an entire page of
-// strongly-matched, normalized rows from another source. -0.5 is magnitude-
-// independent, so it fixes both the dominating strong lone match and does not
-// inflate a weak one to -1.0 (the reason single-row sources were previously
-// skipped). Global-max normalization would NOT fix a lone match that IS the
-// global max, so a fixed neutral value is used instead.
-const NEUTRAL_SINGLE_MATCH_SCORE = -0.5;
+// A lone match has no within-source spread to normalize against (MED-5, v3.48.0).
+// A magnitude-blind constant (-0.5) fixed the dominating direction — an incidental
+// lone hit no longer outranks a strongly-matched page — but buried the opposite,
+// equally common shape (audit 2026-07-17 MED-1): events are the CANONICAL store for
+// promoted bugfix/decision memories AND a low-cardinality source, so "the best
+// answer is one strong event" is routine, and within-source max-normalization pins
+// every multi-hit source's best to -1 regardless of absolute strength.
+//
+// Fix: band the lone hit by its raw magnitude RELATIVE to the global raw max across
+// all scored rows — the cross-source signal the per-source normalization destroys.
+// obs/event/session BM25 live on comparable scales (weighted bm25 × decay ×
+// project-boost), so the ratio is meaningful there; small-scale sources (prompts,
+// bm25 ≈ -1) can only be penalized by this comparison, never inflated — the safe
+// direction. Bands (ratio = |lone| / globalMaxAbs, first match wins):
+//   ratio ≥ 1   → -1.05  the lone hit IS the strongest raw match anywhere: rank it
+//                        strictly ahead of every normalized -1 (ties in raw
+//                        strength resolve toward the lone hit — the [-1, 0] band
+//                        convention is deliberately exceeded here)
+//   ratio ≥ 0.5 → -0.75  comparable to the best: above neutral, below the leaders
+//   ratio ≥ 0.1 → -0.5   the MED-5 neutral mid
+//   ratio < 0.1 → -0.25  grazing match: sink it
+// score === 0 rows (the prompts CJK LIKE fallback — zero confidence) are excluded
+// from normalization entirely and keep their 0, sorting last in the ascending
+// merge (audit L3: the old clamp promoted a lone 0-score row to the neutral mid).
+const SINGLE_MATCH_BANDS = [
+  [1.0, -1.05],
+  [0.5, -0.75],
+  [0.1, -0.5],
+  [0, -0.25],
+];
 
 /**
  * Normalize each source's BM25 scores to [-1, 0] before cross-source merge.
  * Prevents observations (BM25 can reach -40) from systematically outranking
  * sessions (-6) and prompts (-1) regardless of relevance. A source with a single
- * scored row is clamped to the neutral mid (see NEUTRAL_SINGLE_MATCH_SCORE) —
- * it has no within-source spread to normalize against. Mutates `results` in
- * place; callers re-sort afterwards.
+ * scored row is banded by its magnitude relative to the global raw max (see
+ * SINGLE_MATCH_BANDS) — it has no within-source spread to normalize against.
+ * Mutates `results` in place; callers re-sort afterwards.
  */
 export function normalizeCrossSourceScores(results, sourceKey) {
+  const scored = results.filter((r) => r.score !== null && r.score !== undefined && r.score !== 0);
+  const globalMaxAbs = scored.length ? Math.max(...scored.map((r) => Math.abs(r.score))) : 0;
   for (const src of ['obs', 'session', 'prompt', 'event']) {
-    const srcResults = results.filter((r) => r[sourceKey] === src && r.score !== null && r.score !== undefined);
+    // score === 0 stays out: for multi-row sources 0/maxAbs would be 0 anyway, and a
+    // lone 0-score row must not be banded upward (it only occurs as the prompts LIKE
+    // fallback, which never coexists with real prompt FTS hits).
+    const srcResults = results.filter((r) => r[sourceKey] === src && r.score !== null && r.score !== undefined && r.score !== 0);
     if (srcResults.length === 0) continue;
     if (srcResults.length === 1) {
-      srcResults[0].score = NEUTRAL_SINGLE_MATCH_SCORE;
+      const ratio = globalMaxAbs > 0 ? Math.abs(srcResults[0].score) / globalMaxAbs : 0;
+      srcResults[0].score = SINGLE_MATCH_BANDS.find(([floor]) => ratio >= floor)[1];
       continue;
     }
     const maxAbs = Math.max(...srcResults.map((r) => Math.abs(r.score)));

package/lib/stats-core.mjs

@@ -0,0 +1,113 @@
+// lib/stats-core.mjs — shared primary stats feed for CLI `stats` and MCP `mem_stats`.
+//
+// Audit 2026-07-17 MED-4: these ~15 COUNT/GROUP-BY queries were hand-copied
+// byte-equivalent between server.mjs (mem_stats) and mem-cli.mjs (cmdStats) — the
+// same twin-drift class the `--quality` sub-report already closed via
+// lib/stats-quality.mjs, and delete orchestration via lib/delete-core.mjs. One
+// computation, two renderers: callers keep their own formatting (MCP text block /
+// CLI console+JSON) plus any surface-only extras (CLI hookErrors24h).
+import { inferProject } from '../utils.mjs';
+import { buildNotLowSignalSql } from './low-signal-patterns.mjs';
+import { TIER_CASE_SQL, tierSqlParams } from '../tier.mjs';
+import { computeNoiseGauge } from './stats-quality.mjs';
+
+/**
+ * Compute the primary stats feed. Row shapes are returned exactly as the twin
+ * blocks produced them ({c}/{t}/{v} single-row objects, arrays for distributions)
+ * so both call sites render with minimal diff.
+ */
+export function computeStatsFeed(db, { project = null, days = 30, now = Date.now() } = {}) {
+  const cutoff = now - days * 86400000;
+  const projectFilter = project ? 'AND project = ?' : '';
+  const baseParams = project ? [project] : [];
+
+  // Total counts (session_summaries, not sdk_sessions — CLI↔MCP aligned)
+  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)
+  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)
+  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
+  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: `<= 1` makes the imp=0 dormant population visible
+  // (decay floor + LLM low-signal filter push ~half the live corpus to 0);
+  // injection_count=0 mirrors decay's NEVER-INJECTED guard so injected-but-decayed
+  // pinned noise isn't 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 the read-side filter
+  // already excludes). The imp≤1 "Low-value" metric can't see these, so the gauge
+  // under-reports real noise without it. Same source as 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.
+  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);
+
+  // Tier distribution
+  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]));
+
+  return {
+    obsTotal, sessTotal, promptTotal, obsRecent, sessRecent,
+    types, projects, daily,
+    tokenEst, avgImp, lowVal, lowSignalTitle, liveTotal,
+    noiseRatio, lowSignalRatio, compressedCount, supersededOnlyCount,
+    tierMap,
+  };
+}