claude-mem-lite 3.48.0 → 3.49.0

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "3.48.0",
+      "version": "3.49.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.49.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,28 @@ 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.
+            // 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/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/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,
+  };
+}

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,6 +24,9 @@ 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';
@@ -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';
@@ -72,7 +73,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;
@@ -369,7 +370,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;
@@ -803,7 +804,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 +913,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) ──────────────────────────────
@@ -1112,98 +1113,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 +1126,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 +1474,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 +1558,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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "3.48.0",
+  "version": "3.49.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/user-prompt-search.js

@@ -787,8 +787,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);
         }

package/server.mjs

@@ -12,7 +12,6 @@ import { reRankWithContext, autoBoostIfNeeded, runIdleCleanup, buildServerInstru
 import { searchObservationsHybrid } from './search-engine.mjs';
 import { deepSearch, resolveDeepMode, shouldEscalateToDeep, autoDeepLlmReady } from './deep-search.mjs';
 import { selectCompressionCandidates, groupByProjectWeek, compressGroup } from './lib/compress-core.mjs';
-import { buildNotLowSignalSql } from './lib/low-signal-patterns.mjs';
 import { resolveAnchorToken, formatAnchorError, resolveQueryAnchor, fetchRecentTimeline, fetchTimelineWindow } from './lib/timeline-core.mjs';
 import { buildSearchFtsQuery, parseDateBounds, parseDuration, coreRunSearchPipeline } from './lib/search-core.mjs';
 import {
@@ -26,6 +25,8 @@ import { snapshotDb } from './lib/db-backup.mjs';
 import { deleteObservations } from './lib/delete-core.mjs';
 import { effectiveQuiet, RUNTIME_DIR } from './hook-shared.mjs';
 import { TIER_CASE_SQL, tierSqlParams } from './tier.mjs';
+import { computeStatsFeed } from './lib/stats-core.mjs';
+import { buildLessonNudge } from './lib/save-nudge.mjs';
 import { formatObsFieldValue } from './cli/common.mjs';
 import { memSearchSchema, memRecentSchema, memTimelineSchema, memGetSchema, memDeleteSchema, memSaveSchema, memStatsSchema, memCompressSchema, memMaintainSchema, memOptimizeSchema, memUpdateSchema, memExportSchema, memRecallSchema, memFtsCheckSchema, memRegistrySchema, memBrowseSchema, memUseSchema, memDeferSchema, memDeferListSchema, memDeferDropSchema, tools as TOOL_DEFS } from './tool-schemas.mjs';
 
@@ -46,7 +47,6 @@ import { probeOtherSources as probeIdSources, bucketIdTokens } from './lib/id-ro
 import { saveObservation } from './lib/save-observation.mjs';
 import { rebuildObservationDerived } 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 { AUTO_MERGE_THRESHOLD } from './lib/dedup-constants.mjs';
 import {
@@ -750,7 +750,8 @@ server.registerTool(
     const supersededNote = result.supersededIds && result.supersededIds.length > 0
       ? ` Superseded: ${result.supersededIds.map(i => `#${i}`).join(', ')}.`
       : '';
-    return { content: [{ type: 'text', text: `Saved as observation #${result.id} [${result.type}] in project "${project}".${lessonNote}${closedNote}${supersededNote}` }] };
+    const nudge = buildLessonNudge({ type: result.type, id: result.id, lessonCaptured: result.lessonCaptured, surface: 'mcp' });
+    return { content: [{ type: 'text', text: `Saved as observation #${result.id} [${result.type}] in project "${project}".${lessonNote}${closedNote}${supersededNote}${nudge}` }] };
   })
 );
 
@@ -848,97 +849,11 @@ server.registerTool(
       return { content: [{ type: 'text', text: formatQualityReport(data) }] };
     }
 
-    const cutoff = Date.now() - days * 86400000;
-    const projectFilter = args.project ? 'AND project = ?' : '';
-    const baseParams = args.project ? [args.project] : [];
-
-    // Total counts
-    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 = args.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(args.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);
-
-    // Projects (global view — skipped when filtering by single project)
-    const projects = args.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(Date.now() - 7 * 86400000, ...baseParams);
-
-    // Health metrics
-    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 = Date.now() - 30 * 86400000;
-    // v3.23 noise-gauge de-blinding (mirrors mem-cli cmdStats): `<= 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. See 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: Date.now(), currentProject: args.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]));
+    const {
+      obsTotal, sessTotal, promptTotal, obsRecent, sessRecent,
+      types, projects, daily, tokenEst, avgImp, lowVal, lowSignalTitle,
+      noiseRatio, lowSignalRatio, compressedCount, supersededOnlyCount, tierMap,
+    } = computeStatsFeed(db, { project: args.project || null, days });
 
     const lines = [
       `Memory Statistics${args.project ? ` (project: ${args.project})` : ''}:`,

package/source-files.mjs

@@ -162,6 +162,19 @@ export const SOURCE_FILES = [
   // (cmdDelete) — extracted to kill the byte-duplicated twin. Missing it from the
   // manifest would leave both delete surfaces unsigned/broken on auto-update.
   'lib/delete-core.mjs',
+  // Shared primary stats feed (audit 2026-07-17 MED-4) — statically imported by
+  // server.mjs (mem_stats) and mem-cli.mjs (cmdStats); killed the ~80-line
+  // byte-duplicated twin. Missing it breaks both stats surfaces on auto-update.
+  'lib/stats-core.mjs',
+  // Observation `type` vocabulary single source (audit 2026-07-17 MED-3) —
+  // statically imported by tool-schemas.mjs, mem-cli.mjs, hook-llm.mjs,
+  // hook-optimize.mjs, lib/activity.mjs. Missing it breaks every save/validate
+  // path on auto-update.
+  'lib/obs-types.mjs',
+  // Save-time lesson nudge (audit 2026-07-17 P4) — statically imported by server.mjs
+  // (mem_save) and mem-cli.mjs (cmdSave). Missing it breaks both save surfaces on
+  // auto-update.
+  'lib/save-nudge.mjs',
   // P10 dedup/merge threshold constants — single source of truth for the Jaccard
   // dedup/merge cutoffs. Statically imported by hook.mjs, hook-llm.mjs,
   // hook-optimize.mjs, mem-cli.mjs, server.mjs, and the save/maintain cores;

package/tool-schemas.mjs

@@ -3,8 +3,9 @@
 
 import { z } from 'zod';
 import { CLI_INVOKE } from './cli-path.mjs';
+import { OBS_TYPES } from './lib/obs-types.mjs';
 
-export const OBS_TYPE_ENUM = z.enum(['decision', 'bugfix', 'feature', 'refactor', 'discovery', 'change']);
+export const OBS_TYPE_ENUM = z.enum([...OBS_TYPES]);
 
 // LLM-friendly coercion: accept string numbers and normalize to proper types
 const coerceInt = z.preprocess(