claude-mem-lite 3.33.1 → 3.35.0

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "3.33.1",
+      "version": "3.35.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.33.1",
+  "version": "3.35.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/cli/common.mjs

@@ -89,6 +89,72 @@ export function rejectBareStringFlags(flags, keys) {
   return false;
 }
 
+// ─── Unknown-flag typo guard ─────────────────────────────────────────────────
+
+/**
+ * Union of every flag name any CLI command reads (parseArgs silently drops the rest).
+ * Over-inclusive BY DESIGN: a flag listed here that a given command ignores just means
+ * "no typo warning for it" — harmless. The only real risk is OMITTING a valid flag, and
+ * the edit-distance gate in suggestUnknownFlags() makes even that non-fatal (a distinct
+ * real flag rarely lands within distance 2 of another). Add new flags here when adding
+ * them to a command — same maintenance contract as JSON_SUPPORTED_CMDS in mem-cli.
+ */
+export const KNOWN_CLI_FLAGS = new Set([
+  'after', 'age-days', 'all', 'anchor', 'batch', 'before', 'benchmark', 'body', 'branch',
+  'capability-summary', 'category', 'closes-deferred', 'concepts', 'confirm', 'days', 'deep',
+  'detail', 'domain-tags', 'dry-run', 'enrich', 'execute', 'fields', 'file', 'files', 'floors',
+  'force', 'format', 'from', 'has', 'help', 'importance', 'include-compressed', 'include-noise',
+  'intent-tags', 'invocation-name', 'json', 'key', 'keywords', 'lesson', 'lesson-learned', 'limit',
+  'local-path', 'margins', 'max', 'memdir', 'merge-ids', 'metrics', 'name', 'narrative', 'no-deep',
+  'offset', 'ops', 'or', 'out', 'priority', 'project', 'quality', 'query', 'reason', 'repo-url',
+  'rerank', 'resource-type', 'retain-days', 'retry', 'run', 'run-all', 'scope', 'session-audit',
+  'sidechain', 'since', 'sort', 'source', 'status', 'sweep', 'task', 'tech-stack', 'tier', 'title',
+  'to', 'trigger-patterns', 'type', 'use-cases', 'verbose',
+]);
+
+/** Levenshtein distance, early-exit past `max` (cheap enough for a handful of flags). */
+function editDistance(a, b, max = 2) {
+  const m = a.length, n = b.length;
+  if (Math.abs(m - n) > max) return max + 1;
+  let prev = Array.from({ length: n + 1 }, (_, j) => j);
+  for (let i = 1; i <= m; i++) {
+    const cur = [i];
+    let rowMin = i;
+    for (let j = 1; j <= n; j++) {
+      const d = Math.min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + (a[i - 1] !== b[j - 1] ? 1 : 0));
+      cur[j] = d;
+      if (d < rowMin) rowMin = d;
+    }
+    if (rowMin > max) return max + 1; // whole row already past budget → give up
+    prev = cur;
+  }
+  return prev[n];
+}
+
+/**
+ * Detect likely-typo flags: names NOT in KNOWN_CLI_FLAGS but within edit distance 2 of
+ * a known flag. parseArgs silently drops unknown flags, so `save --improtance 3` used to
+ * persist the DEFAULT importance and `recent --projcte X` silently queried the inferred
+ * project — a typo produced a wrong result with zero signal. Returns [{flag, suggestion}].
+ * Unknown flags with NO close match are omitted: they may be a valid flag we didn't
+ * catalog, so silence beats a false alarm. Warning-only by contract — never fails.
+ * @param {object} flags Parsed flags from parseArgs.
+ * @returns {Array<{flag: string, suggestion: string}>}
+ */
+export function suggestUnknownFlags(flags) {
+  const result = [];
+  for (const key of Object.keys(flags)) {
+    if (!key || KNOWN_CLI_FLAGS.has(key)) continue;
+    let best = null, bestDist = 3;
+    for (const known of KNOWN_CLI_FLAGS) {
+      const d = editDistance(key, known);
+      if (d < bestDist) { bestDist = d; best = known; }
+    }
+    if (best && bestDist <= 2) result.push({ flag: key, suggestion: best });
+  }
+  return result;
+}
+
 // ─── Time Formatting ─────────────────────────────────────────────────────────
 
 /** "just now" / "5m ago" / "3h ago" / "2d ago" relative to now. */

package/format-utils.mjs

@@ -37,12 +37,16 @@ export function truncate(str, max = 80) {
 //      block would smuggle a privileged-channel instruction / fake tool-call narrative
 //      into the model's context. It can't escape its wrapper (class 1 closers are
 //      defanged), but a nested forged authority/tool tag is still an indirect-prompt-
-//      injection vector; strip the brackets so it reads as inert text. Other tags
-//      (<other-tag>) \u2014 and the attribute-bearing <invoke \u2026>/<parameter \u2026> forms \u2014 are
-//      deliberately left intact.
+//      injection vector; strip the brackets so it reads as inert text. Tool-call tags
+//      (<invoke \u2026>/<parameter \u2026>, bare + antml:-namespaced) are included: a prior turn's
+//      malformed tool-XML replayed through a handoff corrupted the continuation surface
+//      (mid-token truncation + model confusion), so replayed tool-XML must defang too.
+//      These carry attributes, so the match allows an optional attribute tail before the
+//      closing `>` \u2014 which also catches an attribute-bearing forgery of an authority tag
+//      (<system-reminder foo="\u2026">). Unrelated tags (<other-tag>) are left intact.
 // Reachable by editing files that contain these tokens \u2014 e.g. developing claude-mem-lite
 // itself, where source/observations carry the delimiter names.
-const CONTEXT_DELIMITER_RE = /<\/?(?:claude-mem-context|memory-context|session-handoff|system-reminder|task-notification|(?:antml:)?function_calls|(?:antml:)?function_results)>/gi;
+const CONTEXT_DELIMITER_RE = /<\/?(?:claude-mem-context|memory-context|session-handoff|system-reminder|task-notification|(?:antml:)?function_calls|(?:antml:)?function_results|(?:antml:)?invoke|(?:antml:)?parameter)(?:\s[^>]*)?>/gi;
 
 /**
  * Defang the literal context-block delimiter tags in user-derived text. Strips just the

package/hook-handoff.mjs

@@ -478,9 +478,12 @@ function renderHandoffFromRow(handoff, db, project) {
     if (summary && (summary.completed || summary.next_steps || summary.remaining_items)) {
       lines.push('');
       lines.push('<session-summary source="haiku">');
-      if (summary.completed) lines.push(summary.completed);
-      if (summary.remaining_items) lines.push(`Remaining: ${summary.remaining_items}`);
-      if (summary.next_steps) lines.push(`Next steps: ${summary.next_steps}`);
+      // Defang: these come from session_summaries, populated by Haiku OR by
+      // extractStructuredSummary over the assistant transcript tail — replayed text that can
+      // carry tool-XML / forged authority tags, same class as working_on above (audit MED-4).
+      if (summary.completed) lines.push(neutralizeContextDelimiters(summary.completed));
+      if (summary.remaining_items) lines.push(`Remaining: ${neutralizeContextDelimiters(summary.remaining_items)}`);
+      if (summary.next_steps) lines.push(`Next steps: ${neutralizeContextDelimiters(summary.next_steps)}`);
       lines.push('</session-summary>');
     }
   } catch {}

package/hook-llm.mjs

@@ -146,6 +146,22 @@ export function saveObservation(obs, projectOverride, sessionIdOverride, externa
       return null;
     }
 
+    // Paired-gate DROP at the auto-capture choke-point (v3.35). isLowYieldChangeObs
+    // (type=change + imp<2 + no real lesson — the substantive-title band isNoiseObservation
+    // misses) previously ran ONLY on the LLM-success path (handleLLMEpisode). The pre-save
+    // write here and the LLM-failure fallback (which keeps the pre-saved row) both bypassed
+    // it, so template change-rows survived on LLM failure. Gate covers all three write paths.
+    // Runs BEFORE capNoiseImportance: the pre-assigned importance IS the rule signal for a
+    // provisional pre-save — an imp>=2 rule-triggered episode (config/error change) must land
+    // so it stays visible immediately, survives a total LLM failure (the keep-pre-saved
+    // branch), and keeps its original created_at for the later in-place upgrade. (A dropped
+    // pre-save is not lost on LLM success — that path clean-inserts a fresh row — but it loses
+    // those three.) capNoiseImportance then caps any title-noise survivor to imp=1 as before.
+    if (isLowYieldChangeObs(obs)) {
+      debugLog('saveObservation', `dropped low-yield change: ${truncate(obs.title || '', 60)}`);
+      return null;
+    }
+
     // v2.47 P0-3: importance cap for LOW_SIGNAL titles that kept the drop gate
     // open via importance>=2 but carry no lesson/facts signal. 341 rows in live
     // DB had imp=3 under these conditions (99.4% noise). Cap to 1 so they

package/hook.mjs

@@ -47,7 +47,7 @@ import { handleLLMEpisode, handleLLMSummary, saveObservation, buildImmediateObse
 import { scrubRecord } from './lib/scrub-record.mjs';
 import { formatHookError } from './lib/native-binding-hint.mjs';
 import { selectCompressionCandidates, groupByProjectWeek, compressGroup } from './lib/compress-core.mjs';
-import { cleanupBroken, decayAndMarkIdle, boostAccessed, selectFuzzyDedupeIds, hardDeleteCandidateCount, purgeStale, recoverOrphanedChildren } from './lib/maintain-core.mjs';
+import { cleanupBroken, decayAndMarkIdle, boostAccessed, selectFuzzyDedupeIds, hardDeleteCandidateCount, purgeStale, recoverOrphanedChildren, recoverBuriedLessons } from './lib/maintain-core.mjs';
 import { snapshotDb } from './lib/db-backup.mjs';
 import {
   extractCitationsFromTranscript,
@@ -62,6 +62,7 @@ import { extractTailAssistantText, extractStructuredSummary } from './lib/summar
 import { searchRelevantMemories, formatMemoryLine, selectImperativeLesson } from './hook-memory.mjs';
 import { formatTaskImperative } from './lib/task-imperative.mjs';
 import { recordSkillAdoption, gcOldShadowShards } from './registry-recommend.mjs';
+import { gcOldMetricShards } from './lib/metrics.mjs';
 import { detectMemOverride } from './lib/mem-override.mjs';
 import { buildAndSaveHandoff, detectContinuationIntent, renderHandoffInjection, pickHandoffToInject, extractUnfinishedSummary } from './hook-handoff.mjs';
 import { checkForUpdate, getCachedUpdateBanner, isUpdateCheckDue } from './hook-update.mjs';
@@ -795,6 +796,11 @@ function runSessionStartAutoMaintain(db) {
       const orphansRecovered = recoverOrphanedChildren(db, mctx);
       if (orphansRecovered > 0) debugLog('DEBUG', 'auto-maintain', `recovered ${orphansRecovered} orphaned compression children`);
 
+      // Heal lesson rows citation-decay buried at importance 0 under the old floor=0.
+      // Non-destructive (0→1 on lesson-bearing rows only); idempotent no-op once none remain.
+      const lessonsHealed = recoverBuriedLessons(db, mctx);
+      if (lessonsHealed > 0) debugLog('DEBUG', 'auto-maintain', `healed ${lessonsHealed} lesson rows buried at importance 0`);
+
       const { decayed, idleMarked } = decayAndMarkIdle(db, mctx);
       if (decayed > 0) debugLog('DEBUG', 'auto-maintain', `decayed ${decayed} stale observations`);
       if (idleMarked > 0) debugLog('DEBUG', 'auto-maintain', `marked ${idleMarked} idle as pending-purge`);
@@ -1098,6 +1104,9 @@ async function handleSessionStart() {
   gcStalePreRecallCooldowns();
   // Bound the shadow-recommendation log (daily JSONL shards, no GC at write time).
   try { gcOldShadowShards(); } catch { /* best-effort, never blocks SessionStart */ }
+  // Same for the opt-in metrics sink (RUNTIME_DIR's parent is DB_DIR). Runs even when
+  // metrics are disabled, so shards left by a since-toggled-off run still get pruned.
+  try { gcOldMetricShards(join(RUNTIME_DIR, '..')); } catch { /* best-effort */ }
 
   // Plugin cache self-heal: Claude Code auto-updates the marketplace plugin can
   // re-populate cache/<ver>/hooks/hooks.json, reintroducing duplicate hook

package/lib/citation-tracker.mjs

@@ -472,7 +472,16 @@ export function hasMainThreadAssistantText(transcriptPath) {
 }
 
 const IMPORTANCE_CAP = 3;
-const IMPORTANCE_FLOOR = 0;
+// Demote floor = 1, NOT 0. Both passive injection surfaces exclude importance 0
+// (pre-tool-recall.js requires >=2, user-prompt-search.js requires >=1), so a row
+// demoted to 0 can never be re-injected → never re-cited → never recovers: a one-way
+// burial that silently hides lesson-bearing rows the "lessons never auto-GC" guards
+// (maintain decayAndMarkIdle + compress-core) protect on every other path. Floor 1
+// keeps a decayed row on the >=1 surface with a citation-recovery path. Genuine noise
+// still sinks via maintain's PENDING_PURGE pipeline, which keys on compressed_into
+// (not importance) over injection_count=0 rows — a disjoint population from these
+// injected-but-uncited rows — so noise GC is unaffected.
+const IMPORTANCE_FLOOR = 1;
 const UNCITED_STREAK_THRESHOLD = 3;
 
 // Adoption-rate gate (P5 ②). A project's cite-rate is SUM(cited_count) /

package/lib/maintain-core.mjs

@@ -117,6 +117,29 @@ export function recoverOrphanedChildren(db, { projectFilter = '', baseParams = [
   `).run(...baseParams).changes;
 }
 
+// Heal lesson-bearing rows that citation-decay buried at importance 0 under the old
+// IMPORTANCE_FLOOR=0 (fixed in citation-tracker.mjs → floor 1). All passive injection
+// surfaces exclude importance 0 (pre-tool-recall >=2, user-prompt-search >=1, memory-context
+// >=1), so a lesson demoted there is invisible AND — being injection_count>0 by construction
+// — sits in no GC queue either (decayAndMarkIdle only marks injection_count=0 rows): stranded
+// out of reach with its distilled lesson. Lifting to 1 restores >=1-surface visibility + a
+// citation-recovery path. NON-DESTRUCTIVE (only 0→1 on lesson-bearing rows, never
+// deletes/hides), idempotent (a no-op once no imp-0 lesson rows remain), so safe to run
+// unconditionally alongside recoverOrphanedChildren. `superseded_at IS NULL` mirrors the
+// injection surfaces' own filter (pre-tool-recall:368, memory-context:217) — a de-dup loser
+// (auto-dedup sets superseded_at but leaves compressed_into=0) must NOT be lifted back into
+// injectability. Non-lesson imp-0 rows are left buried (low-value, not worth resurfacing).
+export function recoverBuriedLessons(db, { projectFilter = '', baseParams = [] } = {}) {
+  return db.prepare(`
+    UPDATE observations SET importance = 1
+    WHERE COALESCE(compressed_into, 0) = 0
+      AND COALESCE(importance, 1) = 0
+      AND superseded_at IS NULL
+      AND lesson_learned IS NOT NULL AND lesson_learned <> '' AND lower(lesson_learned) <> 'none'
+      ${projectFilter}
+  `).run(...baseParams).changes;
+}
+
 export function cleanupBroken(db, { projectFilter, baseParams, opCap = OP_CAP }) {
   const doomed = db.prepare(`
     SELECT id FROM observations

package/lib/metrics.mjs

@@ -16,7 +16,7 @@
 // skip malformed lines silently. The module imports nothing heavy so hook
 // cold-start pays near-zero when metrics are disabled.
 
-import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync } from 'fs';
+import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, unlinkSync } from 'fs';
 import { join } from 'path';
 
 const DAY_MS = 86400000;
@@ -68,6 +68,33 @@ export function timed(dbDir, event, fn, extra = {}) {
   }
 }
 
+/**
+ * Prune metric daily shards older than `retainDays`. recordMetric writes one
+ * YYYY-MM-DD.jsonl per day with no GC, so a long-lived CLAUDE_MEM_METRICS=1 install
+ * grows the dir unbounded. 90d keeps a full quarter for aggregate windows while
+ * bounding the dir. Runs regardless of the enable flag so a user who toggles metrics
+ * OFF still gets old shards cleaned. Shard date read from the filename (ISO dates sort
+ * lexicographically = chronologically). Best-effort, never throws — called from the
+ * SessionStart GC sweep (mirrors registry-recommend.gcOldShadowShards).
+ * @returns {number} shards removed
+ */
+export function gcOldMetricShards(dbDir, retainDays = 90) {
+  try {
+    if (!dbDir) return 0;
+    const dir = join(dbDir, 'metrics');
+    if (!existsSync(dir)) return 0;
+    const cutoff = new Date(Date.now() - retainDays * DAY_MS).toISOString().slice(0, 10);
+    let removed = 0;
+    for (const name of readdirSync(dir)) {
+      const m = /^(\d{4}-\d{2}-\d{2})\.jsonl$/.exec(name);
+      if (m && m[1] < cutoff) {
+        try { unlinkSync(join(dir, name)); removed++; } catch { /* per-entry, silent */ }
+      }
+    }
+    return removed;
+  } catch { return 0; }
+}
+
 /** Count of days to aggregate by default in readMetrics / aggregate. */
 export const DEFAULT_WINDOW_DAYS = 7;
 

package/lib/startup-dashboard.mjs

@@ -8,7 +8,7 @@
 import { readGitState } from './git-state.mjs';
 import { readProjectTasks } from './task-reader.mjs';
 import { recentPlans } from './plan-reader.mjs';
-import { isAdoptedHere } from '../hook-shared.mjs';
+import { isAdoptedHere, HANDOFF_EXPIRY_EXIT } from '../hook-shared.mjs';
 
 function ageStr(ms) {
   const diff = Date.now() - ms;
@@ -22,11 +22,16 @@ function ageStr(ms) {
 
 function readRecentHandoff(db, project) {
   try {
+    // Only surface a handoff the UserPromptSubmit injection could actually deliver: apply
+    // the SAME expiry the injection's pickHandoffToInject enforces (HANDOFF_EXPIRY_EXIT).
+    // Without this the dashboard promised "context injects on your next message" for an
+    // exit handoff >7d old that pickHandoffToInject filters as expired → the promise could
+    // never be kept (batch2-reviewer Finding 1).
     return db.prepare(`
       SELECT created_at_epoch, working_on FROM session_handoffs
-      WHERE project = ? AND type = 'exit'
+      WHERE project = ? AND type = 'exit' AND created_at_epoch > ?
       ORDER BY created_at_epoch DESC LIMIT 1
-    `).get(project);
+    `).get(project, Date.now() - HANDOFF_EXPIRY_EXIT);
   } catch { return null; }
 }
 
@@ -82,10 +87,16 @@ export function buildDashboard({ db, project, projectPath = process.cwd(), stubs
   }
 
   if (handoff) {
-    parts.push(`🔄 Continuation (/exit ${ageStr(handoff.created_at_epoch)}):`);
-    if (handoff.working_on) {
-      parts.push(`  - Working on: ${handoff.working_on.slice(0, 160)}`);
-    }
+    // Continuation POINTER only. The working_on CONTENT is delivered once — by the
+    // UserPromptSubmit <session-handoff> block on a continuation-intent prompt
+    // (renderHandoffInjection). Emitting the teaser here too double-injected working_on
+    // into the model's context on every resume (post-defang: redundant, not unsafe).
+    // Wording is CONDITIONAL ("resume it to restore"), not a promise of automatic
+    // injection: the injection is gated on continuation-intent, so on a genuinely new
+    // first task the gate stays silent (stale working_on correctly not injected) and the
+    // pointer must not claim otherwise. readRecentHandoff already drops handoffs older than
+    // the injection's own expiry, so a shown pointer is always deliverable on resume.
+    parts.push(`🔄 Continuation available (/exit ${ageStr(handoff.created_at_epoch)}) — resume it to restore the full context.`);
   }
 
   if (eventCount > 0) {

package/mem-cli.mjs

@@ -18,7 +18,7 @@ import { selectCompressionCandidates, groupByProjectWeek, compressGroup } from '
 import { buildNotLowSignalSql } from './lib/low-signal-patterns.mjs';
 import {
   cleanupBroken, decayAndMarkIdle, boostAccessed, demotePinned, mergeDuplicates,
-  recoverOrphanedChildren,
+  recoverOrphanedChildren, recoverBuriedLessons,
   purgeStale, purgeStalePreview, findDuplicates, maintenanceStats, rebuildVectors, vacuum,
   recoverChildrenOf, hardDeleteCandidateCount,
   OP_CAP, STALE_AGE_MS, PINNED_INJ_THRESHOLD,
@@ -37,7 +37,7 @@ import { readFileSync, existsSync, readdirSync } from 'fs';
 // v2.41: shared CLI helpers extracted to cli/common.mjs. Keep this file as the
 // router + remaining-command bodies during the incremental split. Future work:
 // move each cmdXxx into its own cli/<cmd>.mjs; mem-cli.mjs becomes pure dispatch.
-import { parseArgs, out, fail, relativeTime, fmtDateShort, parseIdToken, formatProbeHints, rejectBareStringFlags, OBS_TIME_FIELDS, formatObsFieldValue } from './cli/common.mjs';
+import { parseArgs, out, fail, relativeTime, fmtDateShort, parseIdToken, formatProbeHints, rejectBareStringFlags, suggestUnknownFlags, OBS_TIME_FIELDS, formatObsFieldValue } from './cli/common.mjs';
 import { saveObservation } from './lib/save-observation.mjs';
 import { rebuildObservationDerived } from './lib/observation-write.mjs';
 import { recallByFile } from './lib/recall-core.mjs';
@@ -1972,6 +1972,10 @@ function cmdMaintain(db, args) {
       // unreachable children. Non-destructive — un-hide only, no delete.
       const orphans = recoverOrphanedChildren(db, mctx);
       if (orphans > 0) results.push(`Recovered ${orphans} orphaned compression children`);
+      // Heal lesson rows citation-decay buried at importance 0 (pre floor=1). 0→1 on
+      // lesson-bearing rows only; idempotent no-op once none remain.
+      const lessonsHealed = recoverBuriedLessons(db, mctx);
+      if (lessonsHealed > 0) results.push(`Healed ${lessonsHealed} lesson rows buried at importance 0`);
     }
 
     if (ops.includes('decay')) {
@@ -3007,6 +3011,15 @@ export async function run(argv) {
     return;
   }
 
+  // Typo guard: parseArgs silently DROPS unknown flags, so `save --improtance 3` used to
+  // persist the DEFAULT importance and `recent --projcte X` silently queried the inferred
+  // project — a misspelled flag changed results with zero signal. Warn (stderr, non-fatal)
+  // when a flag looks like a misspelling of a real one; stdout + exit code stay untouched,
+  // so JSON/text consumers are unaffected. Mirrors the unknown-COMMAND suggester in cli.mjs.
+  for (const { flag, suggestion } of suggestUnknownFlags(parseArgs(cmdArgs).flags)) {
+    process.stderr.write(`[mem] Unknown flag --${flag}; did you mean --${suggestion}?\n`);
+  }
+
   // adopt / unadopt do pure filesystem work on ~/.claude/projects/<encoded>/memory/ —
   // no DB needed. Route them before ensureDb() so an unbootable DB doesn't block.
   if (cmd === 'adopt') { cmdAdopt(cmdArgs); return; }

package/package.json

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

package/project-utils.mjs

@@ -32,6 +32,17 @@ export function resolveProject(db, name) {
   ).get(`%--${name}`);
   if (suffixed) { _cache.set(name, suffixed.project); return suffixed.project; }
 
+  // 1.5) Exact-name match: a project literally named "p" (e.g. inferProject() at a
+  // filesystem-root cwd yields no "--", or a manually-saved bare name). MUST beat the
+  // fuzzy prefix/substring fallbacks below — otherwise `%p%` matches every "projects--*"
+  // row and ORDER BY COUNT(*) returns the biggest UNRELATED project, making the exact
+  // project permanently unreachable via --project. Ranks below step 1 only, preserving
+  // the documented "prefer canonical parent--name over a stray short name" intent.
+  const exact = db.prepare(
+    'SELECT project FROM observations WHERE project = ? LIMIT 1'
+  ).get(name);
+  if (exact) { _cache.set(name, exact.project); return exact.project; }
+
   // 2) Prefix-in-suffix match: "code-graph" → "projects--code-graph-mcp"
   const prefixed = db.prepare(
     'SELECT project FROM observations WHERE project LIKE ? GROUP BY project ORDER BY COUNT(*) DESC LIMIT 1'

package/scripts/post-tool-recall.js

@@ -68,4 +68,13 @@ async function main() {
   }));
 }
 
-main().catch(() => {}).finally(() => process.exit(0));
+// No forced process.exit(0): main() consumes stdin to EOF (or early-returns without
+// touching it) and holds no open handles (no DB, no timers), so the event loop drains
+// and the process exits 0 on its own — which FLUSHES the stdout nudge above. A forced
+// exit could drop that pending async write on a piped stdout (the v3.33.1 gotcha the
+// payload-bearing sibling hooks avoid). catch() keeps the exit code 0.
+// Swallow EPIPE: if Claude Code closes the read end before the async write drains, the
+// stream emits 'error' — without the (now-removed) forced exit, an unhandled one would
+// surface as a non-zero exit + stack. A hook must never fail loud on a dropped pipe.
+process.stdout.on('error', () => {});
+main().catch(() => {});

package/scripts/user-prompt-search.js

@@ -4,7 +4,7 @@
 // Lightweight: only imports schema.mjs and utils.mjs, no MCP SDK
 
 import { ensureDb, DB_DIR, REGISTRY_DB_PATH } from '../schema.mjs';
-import { sanitizeFtsQuery, relaxFtsQueryToOr, truncate, typeIcon, inferProject, OBS_BM25, TYPE_DECAY_CASE, TYPE_QUALITY_CASE, notLowSignalTitleClause, noisePenaltyClause, stripPrivate } from '../utils.mjs';
+import { sanitizeFtsQuery, relaxFtsQueryToOr, truncate, typeIcon, inferProject, OBS_BM25, TYPE_DECAY_CASE, TYPE_QUALITY_CASE, notLowSignalTitleClause, noisePenaltyClause, stripPrivate, neutralizeContextDelimiters } from '../utils.mjs';
 import { citeFactorClause } from '../scoring-sql.mjs';
 import { cjkPrecisionOk } from '../nlp.mjs';
 import { writeFileSync, readFileSync, existsSync, renameSync } from 'fs';
@@ -265,7 +265,7 @@ export function rowMatchesIdentifier(row, idsLower) {
 // Each row includes `bm25_raw` (pre-multiplier bm25 magnitude) alongside the
 // composite `relevance`, so callers can distinguish raw-match strength from
 // importance/type/decay inflation.
-function searchByFts(db, queryText, project, limit, typeFilter) {
+export function searchByFts(db, queryText, project, limit, typeFilter) {
   const ftsQuery = sanitizeFtsQuery(queryText);
   if (!ftsQuery) return { rows: [], mode: null };
 
@@ -299,6 +299,7 @@ function searchByFts(db, queryText, project, limit, typeFilter) {
       AND o.importance >= 1
       AND o.created_at_epoch > ?
       AND COALESCE(o.compressed_into, 0) = 0
+      AND o.superseded_at IS NULL
       AND ${notLowSignalTitleClause('o')}
       ${typeClause}
     ORDER BY relevance
@@ -345,6 +346,7 @@ function searchByFile(db, files, project, limit) {
       WHERE o.project = ?
         AND o.importance >= 1
         AND COALESCE(o.compressed_into, 0) = 0
+        AND o.superseded_at IS NULL
         AND o.created_at_epoch > ?
         AND (of2.filename = ? OR of2.filename LIKE ? ESCAPE '\\')
         AND ${notLowSignalTitleClause('o')}
@@ -420,6 +422,7 @@ function searchRecent(db, project, limit) {
     WHERE project = ?
       AND importance >= 1
       AND COALESCE(compressed_into, 0) = 0
+      AND superseded_at IS NULL
       AND created_at_epoch > ?
       AND ${notLowSignalTitleClause('')}
     ORDER BY created_at_epoch DESC
@@ -464,8 +467,10 @@ function formatResults(rows) {
   const lines = ['[mem] FYI — Related memories (continue your task):'];
   for (const r of rows) {
     const icon = typeIcon(r.type);
-    const title = truncate(r.title || '', 70);
-    const lesson = !QUIET_HOOKS && r.lesson_learned ? ` — ${truncate(r.lesson_learned, 50)}` : '';
+    // Defang replayed obs text before truncation: a poisoned title/lesson carrying tool-XML
+    // or a forged authority tag must not render as a live delimiter in this injected block.
+    const title = truncate(neutralizeContextDelimiters(r.title || ''), 70);
+    const lesson = !QUIET_HOOKS && r.lesson_learned ? ` — ${truncate(neutralizeContextDelimiters(r.lesson_learned), 50)}` : '';
     lines.push(`#${r.id} ${icon} ${title}${lesson}`);
   }
   return lines.join('\n');
@@ -479,7 +484,10 @@ function formatPromptResults(rows) {
   if (!rows || rows.length === 0) return null;
   const lines = ['[mem] FYI — Past similar questions (continue your task):'];
   for (const r of rows) {
-    const text = truncate((r.prompt_text || '').replace(/\s+/g, ' '), 80);
+    // prompt_text is a raw prior USER prompt — the highest-risk replayed class (this is
+    // exactly the column that carried malformed tool-XML into the handoff bug). Defang the
+    // delimiters, then collapse whitespace + truncate.
+    const text = truncate(neutralizeContextDelimiters(r.prompt_text || '').replace(/\s+/g, ' '), 80);
     lines.push(`P#${r.id} 💬 ${text}`);
   }
   return lines.join('\n');

package/server.mjs

@@ -17,7 +17,7 @@ import { resolveAnchorToken, formatAnchorError, resolveQueryAnchor, fetchRecentT
 import { buildSearchFtsQuery, parseDateBounds, parseDuration, coreRunSearchPipeline } from './lib/search-core.mjs';
 import {
   cleanupBroken, decayAndMarkIdle, boostAccessed, demotePinned, mergeDuplicates,
-  recoverOrphanedChildren,
+  recoverOrphanedChildren, recoverBuriedLessons,
   purgeStale, purgeStalePreview, findDuplicates, maintenanceStats, rebuildVectors, vacuum,
   recoverChildrenOf, hardDeleteCandidateCount,
   OP_CAP, STALE_AGE_MS,
@@ -1139,6 +1139,10 @@ server.registerTool(
           // resurface unreachable children. Non-destructive — un-hide only, no delete.
           const orphans = recoverOrphanedChildren(db, mctx);
           if (orphans > 0) results.push(`Recovered ${orphans} orphaned compression children`);
+          // Heal lesson rows citation-decay buried at importance 0 (pre floor=1). 0→1 on
+          // lesson-bearing rows only; idempotent no-op once none remain.
+          const lessonsHealed = recoverBuriedLessons(db, mctx);
+          if (lessonsHealed > 0) results.push(`Healed ${lessonsHealed} lesson rows buried at importance 0`);
         }
 
         if (ops.includes('decay')) {