claude-mem-lite 3.47.0 → 3.48.0

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "3.47.0",
+      "version": "3.48.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.47.0",
+  "version": "3.48.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-context.mjs

@@ -8,8 +8,9 @@ import {
   debugLog, debugCatch, neutralizeContextDelimiters,
   DECAY_HALF_LIFE_BY_TYPE, DEFAULT_DECAY_HALF_LIFE_MS, notLowSignalTitleClause,
 } from './utils.mjs';
-import { STALE_SESSION_MS, FALLBACK_OBS_WINDOW_MS, RUNTIME_DIR, effectiveQuiet } from './hook-shared.mjs';
+import { STALE_SESSION_MS, FALLBACK_OBS_WINDOW_MS, RUNTIME_DIR, effectiveQuiet, isQuietHooks } from './hook-shared.mjs';
 import { extractUnfinishedSummary } from './hook-handoff.mjs';
+import { recentInjectableEvents, renderInjectableEvent } from './lib/events-injection.mjs';
 
 /**
  * Infer the project directory from environment variables or cwd.
@@ -390,6 +391,24 @@ export function buildSessionContextLines(db, project, now = new Date(), currentC
     }
   }
 
+  // HIGH-1 (full audit 2026-07-16): surface recent high-importance events — the
+  // canonical store for promoted bugfix/decision/lesson memories that
+  // persistHaikuSummary upgrade-deletes out of observations. Without this section
+  // SessionStart never shows them. E# prefix keeps citation extractors (bare-`#`
+  // anchored) from reading an event id as an observation id. Gated on isQuietHooks()
+  // ONLY (explicit low-noise opt-out), NOT effectiveQuiet: unlike Key Context, events
+  // never appear in the obs-only Recent table and are absent from the MEMORY.md
+  // sentinel, so an adopted project (the default) would otherwise have zero
+  // SessionStart surface for them. Never throws (recentInjectableEvents catches).
+  if (!isQuietHooks()) {
+    const keyEvents = recentInjectableEvents(db, { project, limit: 5 });
+    if (keyEvents.length > 0) {
+      summaryLines.push('### Key Events');
+      for (const e of keyEvents) summaryLines.push(`- ${renderInjectableEvent(e)}`);
+      summaryLines.push('');
+    }
+  }
+
   // 5. Working state from latest /clear handoff.
   // Session scoping: when currentCcSessionId is provided, restrict to this session's
   // own clear handoff so parallel sessions don't see each other's Working State block.

package/hook.mjs

@@ -61,6 +61,7 @@ import {
 import { resolveEdgeAttribution, readPreRecallFileEdges } from './lib/edge-attribution.mjs';
 import { extractTailAssistantText, extractStructuredSummary } from './lib/summary-extractor.mjs';
 import { searchRelevantMemories, formatMemoryLine, selectImperativeLesson } from './hook-memory.mjs';
+import { searchInjectableEvents, renderInjectableEvent } from './lib/events-injection.mjs';
 import { formatTaskImperative } from './lib/task-imperative.mjs';
 import { recordSkillAdoption, gcOldShadowShards } from './registry-recommend.mjs';
 import { gcOldMetricShards } from './lib/metrics.mjs';
@@ -87,7 +88,7 @@ import { getVocabulary } from './tfidf.mjs';
 // Prevent recursive hooks from background claude -p calls
 // Background workers (llm-episode, llm-summary) are exempt — they're ours
 const event = process.argv[2];
-const BG_EVENTS = new Set(['llm-episode', 'llm-summary', 'auto-compress', 'llm-optimize']);
+const BG_EVENTS = new Set(['llm-episode', 'llm-summary', 'auto-compress', 'llm-optimize', 'auto-maintain']);
 
 // Respect Claude Code plugin disable state even when legacy settings.json hooks remain.
 // install.mjs writes direct hooks into ~/.claude/settings.json, so disabling the plugin
@@ -420,7 +421,18 @@ function triggerErrorRecall(db, toolInput, response) {
     `).all(ftsQuery, project, nowR);
 
     const out = formatErrorRecallHints(rows);
-    if (out) process.stdout.write(out);
+    if (out) {
+      // MED-3 (full audit 2026-07-16): emit via the JSON envelope (trailing '\n'),
+      // NOT raw stdout. A raw multi-line write corrupts a co-emitted episode-flush
+      // receipt (both write to PostToolUse stdout in the same call → `<text>{json}`)
+      // and is silently dropped on CC variants that ignore plain-text PostToolUse
+      // stdout. This is the same suppressOutput+additionalContext channel
+      // flushEpisode uses; two separate JSON lines each parse independently.
+      process.stdout.write(JSON.stringify({
+        suppressOutput: true,
+        hookSpecificOutput: { hookEventName: 'PostToolUse', additionalContext: out },
+      }) + '\n');
+    }
   } catch (e) { debugCatch(e, 'triggerErrorRecall'); }
 }
 
@@ -975,6 +987,29 @@ function runSessionStartAutoMaintain(db) {
   }
 }
 
+// SessionStart boot path (MED-4): cheap 24h gate pre-check only. When maintenance is
+// due, the heavy pass (VACUUM-INTO snapshot + purge/cleanup/decay/dedup) is handed to
+// a detached `auto-maintain` worker via spawnBackground so it never blocks interactive
+// session start. The worker re-checks the same gate (idempotent) before doing the work.
+function scheduleSessionStartAutoMaintain() {
+  const maintainFile = join(RUNTIME_DIR, 'last-auto-maintain.json');
+  try {
+    const last = JSON.parse(readFileSync(maintainFile, 'utf8'));
+    if (Date.now() - last.epoch < 24 * 3600000) return; // not due — no spawn
+  } catch { /* no gate file → due */ }
+  if (!process.env.CLAUDE_MEM_SKIP_MAINTAIN) spawnBackground('auto-maintain');
+}
+
+// Detached `auto-maintain` worker entry: opens its own DB and runs the maintenance
+// pass off the interactive boot path. runSessionStartAutoMaintain still owns the 24h
+// gate + the compress/optimize spawns at its tail.
+function handleAutoMaintain() {
+  const db = openDb();
+  if (!db) return;
+  try { runSessionStartAutoMaintain(db); }
+  finally { try { db.close(); } catch { /* ignore */ } }
+}
+
 function saveHandoffAndFastSummary(db, { prevSessionId, prevProject, project, ccSessionId, episodeSnapshot, now }) {
   // Shared clear handoff reference — queried once, used by fast summary + working state
   let prevClearHandoff = null;
@@ -1285,7 +1320,7 @@ async function handleSessionStart() {
 
     runSessionStartDbMutations(db, { sessionId, project, prevSessionId, now });
 
-    runSessionStartAutoMaintain(db);
+    scheduleSessionStartAutoMaintain();
 
     // ── Non-transactional operations (side effects, background work) ──
 
@@ -1520,6 +1555,21 @@ async function handleUserPrompt() {
         lines.push('</memory-context>');
         process.stdout.write(lines.join('\n') + '\n');
       }
+      // HIGH-1 (full audit 2026-07-16): surface FTS-matched events — the canonical
+      // store for promoted bugfix/decision/lesson memories that persistHaikuSummary
+      // upgrade-deletes out of observations. Without this leg they are unreachable at
+      // prompt time. Separate E#-tagged block so it doesn't perturb observation
+      // ranking and citation extractors (bare-`#` anchored) never read an event id as
+      // an obs id. Nested try so an events failure can't suppress the imperative pick.
+      try {
+        const events = searchInjectableEvents(db, { prompt: promptText, project });
+        if (events.length > 0) {
+          const elines = ['<memory-context relevance="events">'];
+          for (const e of events) elines.push(`- ${renderInjectableEvent(e)}`);
+          elines.push('</memory-context>');
+          process.stdout.write(elines.join('\n') + '\n');
+        }
+      } catch (e) { debugCatch(e, 'handleUserPrompt-events'); }
       if (imperativePick) {
         // Guard the write on a non-empty return — formatTaskImperative yields '' for a
         // lesson that strips to empty (e.g. "."), which would otherwise emit a bare line.
@@ -1639,6 +1689,7 @@ try {
     case 'llm-episode':      await handleLLMEpisode(); break;
     case 'llm-summary':      await handleLLMSummary(); break;
     case 'auto-compress':    handleAutoCompress(); break;
+    case 'auto-maintain':    handleAutoMaintain(); break;
     case 'llm-optimize':   await handleLLMOptimize(); break;
     // Detached update refresh spawned by handleSessionStart (audit P3d) — does the
     // GitHub fetch + (non-plugin) install off the SessionStart critical path,

package/lib/citation-tracker.mjs

@@ -707,7 +707,13 @@ export function applyCitationDecay(db, project, injectedIds, citedIds, sessionId
       }
     }
   });
-  try { txn(); } catch (e) { debugCatch(e, 'applyCitationDecay-txn'); return empty; }
+  // IMMEDIATE (not the default DEFERRED): this txn reads each obs then writes it.
+  // Under concurrent same-project Stop hooks a DEFERRED txn pins a read snapshot
+  // first, and the second session's write then hits SQLITE_BUSY_SNAPSHOT — a
+  // snapshot-upgrade conflict busy_timeout cannot resolve — silently dropping the
+  // whole decay pass (promotes/demotes/streak + the paired funnel deltas). Taking
+  // the write lock up front lets busy_timeout actually serialize the two sessions.
+  try { txn.immediate(); } catch (e) { debugCatch(e, 'applyCitationDecay-txn'); return empty; }
   return { promoted, demoted, touched };
 }
 

package/lib/delete-core.mjs

@@ -0,0 +1,72 @@
+// lib/delete-core.mjs — shared hard-delete orchestration for the CLI `delete`
+// command (mem-cli.mjs cmdDelete) and the MCP `mem_delete` tool (server.mjs).
+// Both surfaces previously inlined a byte-for-byte-equivalent copy of this logic,
+// kept in sync by "aligned with MCP mem_delete" / "matching the CLI delete" parity
+// comments — the project's documented #1 drift risk. Consolidated here so there is
+// one implementation: pre-delete snapshot, stale related_ids cleanup,
+// merged/compressed-child recovery, and the delete transaction.
+import { snapshotDb } from './db-backup.mjs';
+import { recoverChildrenOf } from './maintain-core.mjs';
+import { debugCatch } from '../utils.mjs';
+
+/**
+ * Hard-delete the given observation ids with full orchestration. The CALLER owns
+ * the confirm/preview gating and fetches whatever rows it needs to render (existence
+ * check, preview list, missing-id note); this performs only the irreversible mutation
+ * once the caller has decided to proceed.
+ *
+ * Order (preserved from the pre-extraction inline paths):
+ *   1. snapshotDb OUTSIDE any transaction (VACUUM INTO cannot run inside one). Best-
+ *      effort: no-op on :memory:, never throws.
+ *   2. In ONE transaction: strip the deleted ids out of other rows' related_ids
+ *      (coarse LIKE pre-filter → JSON-parse precise filter), recover children
+ *      merged/compressed INTO the doomed rows (compressed_into has no FK), then DELETE.
+ *
+ * @param {import('better-sqlite3').Database} db
+ * @param {number[]} ids  observation ids to delete
+ * @param {{ snapshotTag?: string }} [opts]
+ * @returns {{ deleted: number, recoveredChildren: number, snapshotPath: string|null }}
+ */
+export function deleteObservations(db, ids, { snapshotTag = 'pre-delete' } = {}) {
+  const placeholders = ids.map(() => '?').join(',');
+
+  // Snapshot before the irreversible hard-delete so a wrong-id delete has a pre-image,
+  // matching the maintain purge/cleanup hard-delete paths (audit MED-2). Best-effort
+  // (never throws, skips :memory:). Must run OUTSIDE the transaction below (VACUUM INTO).
+  const snapshotPath = snapshotDb(db, { tag: snapshotTag });
+
+  const deletedIds = new Set(ids);
+  const deleteTx = db.transaction(() => {
+    // Clean up stale references in other observations' related_ids.
+    // LIKE %id% is a coarse pre-filter (false positives: %1% matches [10], [21]) — it only
+    // narrows which rows to fetch; the JSON parse + Set.has below is the precise filter.
+    // Acceptable because observation count per user is typically <10K.
+    const likeConditions = ids.map(() => `related_ids LIKE ?`).join(' OR ');
+    const likeParams = ids.map(id => `%${id}%`);
+    const referencing = db.prepare(`
+      SELECT id, related_ids FROM observations
+      WHERE related_ids IS NOT NULL AND related_ids != '[]' AND (${likeConditions})
+    `).all(...likeParams);
+    for (const r of referencing) {
+      let refIds;
+      try { refIds = JSON.parse(r.related_ids); } catch (e) { debugCatch(e, 'deleteRelatedIds'); continue; }
+      // Only rewrite a well-formed integer array; a malformed related_ids value is left
+      // untouched rather than reshaped by the filter (the stricter of the two originals).
+      if (!Array.isArray(refIds) || !refIds.every(id => Number.isInteger(id))) continue;
+      const filtered = refIds.filter(id => !deletedIds.has(id));
+      if (filtered.length !== refIds.length) {
+        db.prepare('UPDATE observations SET related_ids = ? WHERE id = ?').run(JSON.stringify(filtered), r.id);
+      }
+    }
+    // Resurface rows merged/compressed INTO the doomed keepers before deleting, else they
+    // dangle behind a now-missing parent (compressed_into has no FK) — invisible to every
+    // COALESCE(compressed_into,0)=0 view and unrecoverable. Same guard the maintain
+    // hard-delete paths use (recoverChildrenOf).
+    const recovered = recoverChildrenOf(db, ids);
+    // Execute deletion (FTS5 cleanup handled by the observations_ad trigger).
+    const deleted = db.prepare(`DELETE FROM observations WHERE id IN (${placeholders})`).run(...ids);
+    return { changes: deleted.changes, recovered };
+  });
+  const result = deleteTx();
+  return { deleted: result.changes, recoveredChildren: result.recovered, snapshotPath };
+}

package/lib/events-injection.mjs

@@ -0,0 +1,91 @@
+// lib/events-injection.mjs — surface `events` into the passive injection surfaces.
+//
+// HIGH-1 (full audit 2026-07-16): persistHaikuSummary upgrade-deletes every
+// 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.
+//
+// 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
+// citation-tracker injected-id extractors all anchor on a BARE `#`
+// (FYI `/^#\d/`, memory-context `/\(#\d/`, error-recall row-anchored), so an `E#`
+// row is never mis-attributed to an observation id (which would let citation decay
+// mutate an unrelated observation sharing that id). Events carry no citation columns,
+// so they inject as reference-only — reachability, not decay bookkeeping.
+
+import { searchEventsFts } from './search-core.mjs';
+import { neutralizeContextDelimiters } from '../format-utils.mjs';
+import { sanitizeFtsQuery } from '../utils.mjs';
+
+const DEFAULT_LIMIT = 3;
+const DEFAULT_MIN_IMPORTANCE = 2;
+const TITLE_MAX = 80;
+const LESSON_MAX = 160;
+
+function normalizeRow(r) {
+  return {
+    id: r.id,
+    type: r.event_type || r.type || 'event',
+    title: r.title || '',
+    lesson_learned: (r.body ?? r.lesson_learned) || null,
+    importance: r.importance,
+    created_at_epoch: r.created_at_epoch,
+  };
+}
+
+/**
+ * FTS-matched events for a prompt (UserPromptSubmit surfaces). Superseded events are
+ * excluded by searchEventsFts; importance floor drops low-value rows. Never throws.
+ * @returns {Array<{id,type,title,lesson_learned,importance,created_at_epoch}>}
+ */
+export function searchInjectableEvents(db, { prompt, ftsQuery, project, limit = DEFAULT_LIMIT, minImportance = DEFAULT_MIN_IMPORTANCE } = {}) {
+  if (!db || !project) return [];
+  const q = ftsQuery || (prompt ? sanitizeFtsQuery(prompt) : null);
+  if (!q) return [];
+  try {
+    const rows = searchEventsFts(db, {
+      ftsQuery: q, project, projectBoost: project,
+      importance: minImportance, perSourceLimit: limit,
+    });
+    return rows.map(normalizeRow);
+  } catch { return []; }
+}
+
+/**
+ * Recency + importance events (SessionStart context — no FTS query available).
+ * Excludes superseded events. Never throws.
+ * @returns {Array<{id,type,title,lesson_learned,importance,created_at_epoch}>}
+ */
+export function recentInjectableEvents(db, { project, limit = DEFAULT_LIMIT, minImportance = DEFAULT_MIN_IMPORTANCE } = {}) {
+  if (!db || !project) return [];
+  try {
+    const rows = db.prepare(`
+      SELECT id, event_type, title, body, importance, created_at_epoch
+      FROM events
+      WHERE project = ?
+        AND superseded_at_epoch IS NULL
+        AND COALESCE(importance, 1) >= ?
+      ORDER BY created_at_epoch DESC
+      LIMIT ?
+    `).all(project, minImportance, limit);
+    return rows.map(normalizeRow);
+  } catch { return []; }
+}
+
+/**
+ * Render one injectable event as a defanged `E#<id> [<type>] <title> — <lesson>` line.
+ * The E# prefix keeps citation-tracker extractors (which anchor on a bare `#`) from
+ * mis-reading the event id as an observation id.
+ */
+export function renderInjectableEvent(row) {
+  const title = neutralizeContextDelimiters((row.title || '').slice(0, TITLE_MAX));
+  const head = `E#${row.id} [${row.type}] ${title}`;
+  if (row.lesson_learned) {
+    const lesson = neutralizeContextDelimiters(row.lesson_learned.trim().slice(0, LESSON_MAX));
+    if (lesson) return `${head} — ${lesson}`;
+  }
+  return head;
+}

package/lib/search-core.mjs

@@ -245,17 +245,33 @@ 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;
+
 /**
  * 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. Sources with a
- * single scored row are skipped — normalizing would inflate a weak match to
- * -1.0. Mutates `results` in place; callers re-sort afterwards.
+ * 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.
  */
 export function normalizeCrossSourceScores(results, sourceKey) {
   for (const src of ['obs', 'session', 'prompt', 'event']) {
     const srcResults = results.filter((r) => r[sourceKey] === src && r.score !== null && r.score !== undefined);
-    if (srcResults.length < 2) continue;
+    if (srcResults.length === 0) continue;
+    if (srcResults.length === 1) {
+      srcResults[0].score = NEUTRAL_SINGLE_MATCH_SCORE;
+      continue;
+    }
     const maxAbs = Math.max(...srcResults.map((r) => Math.abs(r.score)));
     if (maxAbs > 0) {
       for (const r of srcResults) r.score = r.score / maxAbs;

package/mem-cli.mjs

@@ -20,10 +20,11 @@ import {
   cleanupBroken, decayAndMarkIdle, boostAccessed, demotePinned, mergeDuplicates,
   recoverOrphanedChildren, recoverBuriedLessons, sweepDeferredWorkOrphans,
   purgeStale, purgeStalePreview, findDuplicates, maintenanceStats, rebuildVectors, vacuum,
-  recoverChildrenOf, hardDeleteCandidateCount,
+  hardDeleteCandidateCount,
   OP_CAP, STALE_AGE_MS, PINNED_INJ_THRESHOLD,
 } from './lib/maintain-core.mjs';
 import { snapshotDb } from './lib/db-backup.mjs';
+import { deleteObservations } from './lib/delete-core.mjs';
 import { optimizePreview, optimizeRun } from './hook-optimize.mjs';
 import { buildSessionContextLines } from './hook-context.mjs';
 import { cmdAdopt, cmdUnadopt } from './adopt-cli.mjs';
@@ -1508,43 +1509,13 @@ function cmdDelete(db, args) {
     return;
   }
 
-  // Snapshot before the irreversible hard-delete so a wrong-id delete has a pre-image,
-  // matching the maintain purge/cleanup hard-delete paths (audit MED-2). Best-effort
-  // (never throws, skips :memory:); rows here are confirmed + non-empty, so the delete
-  // always removes something worth backing up. Must run OUTSIDE the transaction (VACUUM).
-  snapshotDb(db, { tag: 'pre-delete' });
-
-  // Transaction: clean up related_ids references + delete (aligned with MCP mem_delete)
-  const deletedIds = new Set(ids);
-  const deleteTx = db.transaction(() => {
-    const likeConditions = ids.map(() => `related_ids LIKE ?`).join(' OR ');
-    const likeParams = ids.map(id => `%${id}%`);
-    const referencing = db.prepare(`
-      SELECT id, related_ids FROM observations
-      WHERE related_ids IS NOT NULL AND related_ids != '[]' AND (${likeConditions})
-    `).all(...likeParams);
-    for (const r of referencing) {
-      let refIds;
-      try { refIds = JSON.parse(r.related_ids); } catch { continue; }
-      if (!Array.isArray(refIds)) continue;
-      const filtered = refIds.filter(id => !deletedIds.has(id));
-      if (filtered.length !== refIds.length) {
-        db.prepare('UPDATE observations SET related_ids = ? WHERE id = ?').run(JSON.stringify(filtered), r.id);
-      }
-    }
-    // Resurface any rows merged/compressed INTO the doomed keepers before deleting,
-    // else they dangle behind a missing parent (compressed_into has no FK) — invisible
-    // to every COALESCE(compressed_into,0)=0 view and unrecoverable. Same guard the
-    // maintain hard-delete paths use (recoverChildrenOf); the interactive delete path
-    // was missing it. Returned in the result so the user sees the recovery count.
-    const recovered = recoverChildrenOf(db, ids);
-    const deleted = db.prepare(`DELETE FROM observations WHERE id IN (${placeholders})`).run(...ids);
-    return { changes: deleted.changes, recovered };
-  });
-  const result = deleteTx();
+  // Full delete orchestration (snapshot + related_ids cleanup + child recovery + delete
+  // transaction) lives in lib/delete-core.mjs — single source of truth shared with the MCP
+  // mem_delete path (was inlined here + kept in sync by parity comments, the #1 drift risk).
+  const result = deleteObservations(db, ids);
   const missing = ids.filter(id => !rows.some(r => r.id === id));
-  const recoveredNote = result.recovered > 0 ? ` Recovered ${result.recovered} merged/compressed child observation(s) to live.` : '';
-  out(`[mem] Deleted ${result.changes} observation(s).${recoveredNote}${missing.length > 0 ? ` Note: ID(s) ${missing.join(', ')} not found.` : ''}`);
+  const recoveredNote = result.recoveredChildren > 0 ? ` Recovered ${result.recoveredChildren} merged/compressed child observation(s) to live.` : '';
+  out(`[mem] Deleted ${result.deleted} observation(s).${recoveredNote}${missing.length > 0 ? ` Note: ID(s) ${missing.join(', ')} not found.` : ''}`);
 }
 
 // ─── Update ──────────────────────────────────────────────────────────────────

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "3.47.0",
+  "version": "3.48.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",
@@ -90,6 +90,8 @@
     "lib/rrf.mjs",
     "lib/compress-core.mjs",
     "lib/db-backup.mjs",
+    "lib/delete-core.mjs",
+    "lib/events-injection.mjs",
     "lib/maintain-core.mjs",
     "lib/dedup-constants.mjs",
     "lib/deferred-work.mjs",

package/scripts/pre-tool-recall.js

@@ -15,6 +15,7 @@ import { fileIntelFor } from '../lib/file-intel.mjs';
 import { shouldWarnReread, buildRereadWarning, readFileMeta } from '../lib/reread-guard.mjs';
 import { recordMetric } from '../lib/metrics.mjs';
 import { presentIdents } from '../lib/lesson-idents.mjs';
+import { neutralizeContextDelimiters } from '../format-utils.mjs';
 
 // CLAUDE_MEM_DIR matches schema.mjs / main CLI — one env var sandboxes the
 // whole system. CLAUDE_MEM_DB_PATH / CLAUDE_MEM_RUNTIME_DIR remain as
@@ -519,7 +520,14 @@ try {
       // when the model misreads passive lesson context as a closing note.
       lines.push(`[mem] PreToolUse recall — system-injected context, continue your planned action:`);
     }
-    if (fileIntelLine) lines.push(fileIntelLine);
+    // MED-1 (full audit 2026-07-16): defang the injection-block delimiters in
+    // all DB/file-derived text before it enters additionalContext (which CC wraps
+    // in <system-reminder>). Stored text is raw — a lesson/title/summary carrying
+    // a literal </system-reminder> or forged <invoke ...> would break the wrapper
+    // and inject a privileged instruction. Mirrors formatErrorRecallHints, which
+    // already applies the same guard on the parallel error-recall surface. The
+    // `#id [type]` prefix is agent-generated (numeric id + type enum) — no defang.
+    if (fileIntelLine) lines.push(neutralizeContextDelimiters(fileIntelLine));
     if (hasLessons) {
       lines.push(`[mem] Lessons for ${fname}:`);
       for (const r of allRows) {
@@ -527,12 +535,12 @@ try {
           const lesson = r.lesson_learned.length > LESSON_MAX
             ? r.lesson_learned.slice(0, LESSON_MAX - 3) + '...'
             : r.lesson_learned;
-          lines.push(`  #${r.id} [${r.type}] ${lesson}`);
+          lines.push(`  #${r.id} [${r.type}] ${neutralizeContextDelimiters(lesson)}`);
         } else {
           const title = (r.title || '').length > LESSON_MAX
             ? r.title.slice(0, LESSON_MAX - 3) + '...'
             : (r.title || '');
-          lines.push(`  #${r.id} [${r.type}] ${title}`);
+          lines.push(`  #${r.id} [${r.type}] ${neutralizeContextDelimiters(title)}`);
         }
       }
       // v2.98 salience: Edit/Write is the action point — close the block with an
@@ -544,7 +552,7 @@ try {
         const changeText = [toolInput?.old_string, toolInput?.new_string, toolInput?.content]
           .filter(Boolean).join('\n');
         const bridged = await bridgeTopLesson(allRows, changeText);
-        if (bridged) lines.push(`[mem] ⚠ #${bridged.id} → this edit must: ${bridged.check}. Confirm your new code satisfies it.`);
+        if (bridged) lines.push(`[mem] ⚠ #${bridged.id} → this edit must: ${neutralizeContextDelimiters(bridged.check)}. Confirm your new code satisfies it.`);
         else lines.push(`[mem] ⚠ Before this edit: ${ACTIVE_DIRECTIVE}`);
       }
     } else if (!isRead && process.env.CLAUDE_MEM_PRETOOL_NUDGE === '1') {

package/server.mjs

@@ -19,10 +19,11 @@ import {
   cleanupBroken, decayAndMarkIdle, boostAccessed, demotePinned, mergeDuplicates,
   recoverOrphanedChildren, recoverBuriedLessons, sweepDeferredWorkOrphans,
   purgeStale, purgeStalePreview, findDuplicates, maintenanceStats, rebuildVectors, vacuum,
-  recoverChildrenOf, hardDeleteCandidateCount,
+  hardDeleteCandidateCount,
   OP_CAP, STALE_AGE_MS,
 } from './lib/maintain-core.mjs';
 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 { formatObsFieldValue } from './cli/common.mjs';
@@ -680,49 +681,14 @@ server.registerTool(
       return { content: [{ type: 'text', text: lines.join('\n') }] };
     }
 
-    // Snapshot before the irreversible hard-delete so a wrong-id delete has a pre-image,
-    // matching the CLI delete + maintain purge/cleanup paths (audit MED-2). Best-effort
-    // (never throws, skips :memory:). Must run OUTSIDE the transaction below (VACUUM).
-    snapshotDb(db, { tag: 'pre-delete' });
-
-    // Wrap cleanup + deletion in a transaction for consistency
-    const deletedIds = new Set(args.ids);
-    const deleteTx = db.transaction(() => {
-      // Clean up stale references in other observations' related_ids
-      // Use LIKE filter to avoid O(N) full-table scan — only fetch rows that may reference deleted IDs.
-      // NOTE: LIKE %id% has false positives (e.g. %1% matches [10], [21]). This is intentional —
-      // the LIKE is a coarse pre-filter; the JSON parse + Set.has below is the precise filter.
-      // Acceptable because observation count per user is typically <10K.
-      const likeConditions = args.ids.map(() => `related_ids LIKE ?`).join(' OR ');
-      const likeParams = args.ids.map(id => `%${id}%`);
-      const referencing = db.prepare(`
-        SELECT id, related_ids FROM observations
-        WHERE related_ids IS NOT NULL AND related_ids != '[]'
-          AND (${likeConditions})
-      `).all(...likeParams);
-      for (const r of referencing) {
-        let ids;
-        try { ids = JSON.parse(r.related_ids); } catch (e) { debugCatch(e, 'deleteRelatedIds'); continue; }
-        if (!Array.isArray(ids) || !ids.every(id => Number.isInteger(id))) continue;
-        const filtered = ids.filter(id => !deletedIds.has(id));
-        if (filtered.length !== ids.length) {
-          db.prepare('UPDATE observations SET related_ids = ? WHERE id = ?').run(JSON.stringify(filtered), r.id);
-        }
-      }
-      // Resurface rows merged/compressed INTO the doomed keepers before deleting, else
-      // they dangle behind a now-missing parent (compressed_into has no FK) — invisible
-      // to every COALESCE(compressed_into,0)=0 view and unrecoverable. Mirrors the CLI
-      // delete path + the maintain hard-delete guard (recoverChildrenOf).
-      const recovered = recoverChildrenOf(db, args.ids);
-      // Execute deletion (FTS5 cleanup handled by observations_ad trigger)
-      const deleted = db.prepare(`DELETE FROM observations WHERE id IN (${placeholders})`).run(...args.ids);
-      return { changes: deleted.changes, recovered };
-    });
-    const result = deleteTx();
+    // Full delete orchestration (snapshot + related_ids cleanup + child recovery +
+    // delete transaction) lives in lib/delete-core.mjs — single source of truth shared
+    // with the CLI `delete` path (was inlined + kept in sync by parity comments).
+    const result = deleteObservations(db, args.ids);
 
     const missing = args.ids.filter(id => !rows.some(r => r.id === id));
-    const msg = [`Deleted ${result.changes} observation(s).`];
-    if (result.recovered > 0) msg.push(`Recovered ${result.recovered} merged/compressed child observation(s) to live.`);
+    const msg = [`Deleted ${result.deleted} observation(s).`];
+    if (result.recoveredChildren > 0) msg.push(`Recovered ${result.recoveredChildren} merged/compressed child observation(s) to live.`);
     if (missing.length > 0) msg.push(`Note: ID(s) ${missing.join(', ')} not found.`);
     return { content: [{ type: 'text', text: msg.join(' ') }] };
   })

package/source-files.mjs

@@ -152,6 +152,16 @@ export const SOURCE_FILES = [
   // server.mjs, and hook.mjs before their destructive purge/cleanup — missing it
   // would crash maintain on auto-update with an unresolved import.
   'lib/db-backup.mjs',
+  // HIGH-1 events-injection: surfaces the `events` canonical store into the passive
+  // injection surfaces. Statically imported by hook.mjs (UserPromptSubmit) and
+  // hook-context.mjs (SessionStart) — missing it from the manifest would break both
+  // hooks on auto-update.
+  'lib/events-injection.mjs',
+  // Shared delete orchestration (snapshot + related_ids cleanup + child recovery
+  // + delete txn). Statically imported by server.mjs (mem_delete) and mem-cli.mjs
+  // (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',
   // 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;