claude-mem-lite 3.35.1 → 3.36.0

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "3.35.1",
+      "version": "3.36.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.35.1",
+  "version": "3.36.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/bash-utils.mjs

@@ -53,7 +53,13 @@ function isExcludedPath(p) {
  * @returns {{isError: boolean, isTest: boolean, isBuild: boolean, isGit: boolean, isDeploy: boolean, isSignificant: boolean}}
  */
 export function detectBashSignificance(input, response) {
-  const cmd = (input.command || '').toLowerCase();
+  // Coerce command to a string at the source. A malformed PostToolUse payload can
+  // hand us a non-string `command` (object/number); `(input.command||'').toLowerCase()`
+  // then threw, and this is called UNGUARDED in the hottest hook path (hook.mjs:309) —
+  // the throw propagated to main()'s exit(0), dropping the ENTIRE tool event (no episode
+  // entry, not even a pending file). A non-string command has nothing to analyze, so
+  // degrading to '' (no significance) is the correct, event-preserving fallback.
+  const cmd = (typeof input?.command === 'string' ? input.command : '').toLowerCase();
   // Skip error keyword matching only when the PRIMARY command is a read/search op (its
   // output naturally contains "error"-like keywords that aren't failures). Anchored on the
   // primary command — NOT "search verb appears anywhere" — so `npm run build 2>&1 | tail`

package/deep-search.mjs

@@ -454,12 +454,19 @@ export async function deepSearch(db, params, { llm, searchFn = defaultSearchFn,
     // it does on the single-query baseline path, so "never worse than baseline"
     // holds in the error dimension too — a DB failure must not be silently
     // swallowed into an empty result (F5). Only rewrite variants are best-effort.
-    if (i === 0) return searchFn(db, v, params) || [];
-    try {
-      return searchFn(db, v, params) || [];
-    } catch {
-      return [];
-    }
+    let list;
+    if (i === 0) list = searchFn(db, v, params) || [];
+    else { try { list = searchFn(db, v, params) || []; } catch { list = []; } }
+    // rrfFuseN fuses by array index as rank, so each list MUST already be in
+    // composite-score order. searchObservationsHybrid appends downweighted
+    // concept(×0.7)/PRF(×0.6) expansion rows to the TAIL unsorted and, on the
+    // vectors-disabled path, returns BEFORE the sort its vector arm applies
+    // (search-engine.mjs:430) — so a sparse variant (common in deep search, the
+    // vocabulary-mismatch path) would hand a tail-ranked expansion row to RRF at a
+    // worse rank than its score earns. Sort so index == composite rank, mirroring
+    // the in-engine sort that already guards the vector-RRF merge.
+    list.sort((a, b) => (a.score ?? 0) - (b.score ?? 0));
+    return list;
   });
 
   const fused = rrfFuseN(lists, rrfK);

package/format-utils.mjs

@@ -74,10 +74,14 @@ export function neutralizeContextDelimiters(s) {
 export function formatErrorRecallHints(rows) {
   if (!rows || rows.length === 0) return '';
   const lines = rows.map((r, i) => {
-    const head = `  #${r.id} [${r.type}] ${truncate(r.title, 60)}`;
+    // Defang title + lesson: this block is written to PostToolUse stdout \u2192 model context,
+    // and observations are stored raw (defense is at the injection boundary, not at save),
+    // so a poisoned lesson carrying a forged <system-reminder>/tool tag would inject here
+    // un-neutralized. Same guard the handoff render applies to its replayed fields.
+    const head = `  #${r.id} [${r.type}] ${neutralizeContextDelimiters(truncate(r.title, 60))}`;
     // Inline the lesson body for the single most-relevant hit only (bounded payload).
     if (i === 0 && typeof r.lesson_learned === 'string' && r.lesson_learned.trim()) {
-      return `${head} \u2014 ${truncate(r.lesson_learned.trim(), 200)}`;
+      return `${head} \u2014 ${neutralizeContextDelimiters(truncate(r.lesson_learned.trim(), 200))}`;
     }
     return head;
   });

package/hook-context.mjs

@@ -79,6 +79,11 @@ export function selectWithTokenBudget(db, project, budget = 2000) {
     SELECT id, type, title, narrative, importance, created_at_epoch, files_modified, lesson_learned
     FROM observations
     WHERE project = ? AND COALESCE(compressed_into, 0) = 0
+      -- superseded invisibility: auto-dedup (hook.mjs) sets superseded_at but leaves
+      -- compressed_into=0, so the compressed filter alone lets the hidden near-duplicate
+      -- resurface in the most-visible surface (injected every SessionStart). Sibling
+      -- keyObs already filters this; obsPool + fallbackObs must match.
+      AND superseded_at IS NULL
       AND ${notLowSignalTitleClause('')}
       AND (
         (created_at_epoch > ? AND importance >= 1)
@@ -116,7 +121,12 @@ export function selectWithTokenBudget(db, project, budget = 2000) {
     const impBoost = 0.5 + 0.5 * (o.importance || 1);
     const lessonBoost = o.lesson_learned ? 1.3 : 1.0;
     const value = recency * typeQuality * impBoost * lessonBoost;
-    const cost = estimateTokens((o.title || '') + (o.narrative || ''));
+    // Cost = ONLY what is injected. The Recent table renders title-only (narrative is neither
+    // pushed nor emitted), so charging title+narrative made the budget measure ~5x the real
+    // injected size — it filled to ~44% of capacity and, worse, the √cost density term penalized
+    // long-narrative rows that cost nothing to inject. Title-only cost fills the budget with the
+    // rows actually shown and makes valueDensity = value per injected token.
+    const cost = estimateTokens(o.title || '');
     return { ...o, value, cost, valueDensity: cost > 0 ? value / Math.sqrt(cost) : 0 };
   });
 
@@ -294,6 +304,7 @@ export function buildSessionContextLines(db, project, now = new Date(), currentC
       SELECT id, type, title, project, created_at
       FROM observations
       WHERE COALESCE(compressed_into, 0) = 0
+        AND superseded_at IS NULL
         AND (
           (created_at_epoch > ? AND importance >= 1)
           OR (created_at_epoch > ? AND importance >= 2)

package/hook-episode.mjs

@@ -136,6 +136,39 @@ export function createEpisode(sessionId, project) {
   };
 }
 
+/**
+ * Split an episode's entries by originating CC session so each concurrent
+ * session flushes as its own observation. Common path (single session, or all
+ * untagged/legacy entries) returns [episode] BY REFERENCE — behavior identical
+ * to pre-grouping. When >=2 sessions interleaved in one buffer, returns one
+ * sub-episode per session with its own entries + recomputed file union;
+ * filesRead (untagged bash reads-file) is inherited by every sub. Each sub
+ * resets savedId so it receives its own from its immediate-save (savedId is
+ * load-bearing: llm-episode upgrades the pre-saved obs by it).
+ * @param {object} episode
+ * @returns {object[]}
+ */
+export function planEpisodeFlush(episode) {
+  const groups = new Map();
+  for (const e of episode.entries) {
+    const key = e.ccSession ?? '__none__';
+    if (!groups.has(key)) groups.set(key, []);
+    groups.get(key).push(e);
+  }
+  if (groups.size <= 1) return [episode];
+  const subs = [];
+  for (const [, entries] of groups) {
+    subs.push({
+      ...episode,
+      entries,
+      files: [...new Set(entries.flatMap(e => e.files || []))],
+      filesRead: episode.filesRead,
+      savedId: undefined,
+    });
+  }
+  return subs;
+}
+
 /**
  * Add file paths to an episode's file tracking set (deduped).
  * @param {object} episode The episode to update

package/hook-handoff.mjs

@@ -136,10 +136,13 @@ export function buildAndSaveHandoff(db, sessionId, project, type, episodeSnapsho
     try {
       const tasks = taskReaderModule.readProjectTasks({ projectPath: process.cwd() });
       if (tasks.length > 0) {
+        // Join with the ENTRY separator ('; '), NOT '\n': extractUnfinishedSummary
+        // and renderHandoffFromRow split pending work on UNFINISHED_ENTRY_SEP, so a
+        // '\n'-join collapsed the whole task list into one unreadable multi-line bullet.
         unfinished = tasks
           .slice(0, 5)
           .map(t => `[${t.status}] ${t.title}`)
-          .join('\n');
+          .join(UNFINISHED_ENTRY_SEP);
       }
     } catch { /* task reader is best-effort; never block handoff */ }
   }
@@ -227,7 +230,7 @@ export function buildAndSaveHandoff(db, sessionId, project, type, episodeSnapsho
     project, type, storedSessionId,
     truncate(safe.working_on, 1000),
     safe.completed,
-    safe.unfinished.length > 3000 ? safe.unfinished.slice(0, 2999) + '…' : safe.unfinished,
+    safe.unfinished.length > 3000 ? Array.from(safe.unfinished).slice(0, 2999).join('') + '…' : safe.unfinished,
     safeKeyFiles,
     safe.key_decisions,
     safe.match_keywords,
@@ -441,7 +444,10 @@ function renderHandoffFromRow(handoff, db, project) {
   if (handoff.key_files) {
     try {
       const files = JSON.parse(handoff.key_files);
-      if (files.length > 0) lines.push('## Key Files', files.map(f => basename(f)).join(', '), '');
+      // Defang basenames too: a filename on disk can contain a literal authority tag
+      // (Linux allows almost any char but '/'), and this is the one field in this block
+      // that was rendered raw while working_on/unfinished/key_decisions all neutralize.
+      if (files.length > 0) lines.push('## Key Files', neutralizeContextDelimiters(files.map(f => basename(f)).join(', ')), '');
     } catch {}
   }
   if (handoff.key_decisions) {

package/hook-memory.mjs

@@ -118,7 +118,12 @@ const STALE_OBS_THRESHOLD_MS = 30 * 86400000;
  * @returns {string} `- [type] title[ | Lesson: X] (#id)[ [verify-before-use]]`
  */
 export function formatMemoryLine(obs) {
-  const lessonTag = obs.lesson_learned ? ` | Lesson: ${obs.lesson_learned}` : '';
+  // truncate (not raw): caps the per-hit token cost (an unbounded lesson bloated every
+  // memory-context line) AND collapses newlines — a multi-line lesson pushed the trailing
+  // "(#NN)" onto a later physical line that failed the "- [" prefix gate in
+  // citation-tracker's UserPromptSubmit extractor, so the obs never entered the
+  // citation-decay denominator (its promote/demote loop was silently dead).
+  const lessonTag = obs.lesson_learned ? ` | Lesson: ${truncate(obs.lesson_learned, 200)}` : '';
   let staleHint = '';
   if (typeof obs.created_at_epoch === 'number'
     && Date.now() - obs.created_at_epoch > STALE_OBS_THRESHOLD_MS
@@ -310,7 +315,7 @@ export function searchRelevantMemories(db, userPrompt, project, excludeIds = [])
     // Adaptive threshold: scales with corpus size to filter noise.
     // Each result must individually exceed the threshold (not just the top one).
     const obsCount = db.prepare(
-      'SELECT COUNT(*) as c FROM observations WHERE project = ? AND COALESCE(compressed_into, 0) = 0',
+      'SELECT COUNT(*) as c FROM observations WHERE project = ? AND COALESCE(compressed_into, 0) = 0 AND superseded_at IS NULL',
     ).get(project)?.c || 0;
     const { TINY, SMALL, MEDIUM, LARGE } = BM25_THRESHOLD;
     const threshold = obsCount < 5 ? TINY : obsCount < 100 ? SMALL : obsCount < 500 ? MEDIUM : LARGE;
@@ -422,6 +427,7 @@ export function selectImperativeLesson(db, userPrompt, project, excludeIds = [])
       FROM observations
       WHERE project = ?
         AND COALESCE(compressed_into, 0) = 0
+        AND superseded_at IS NULL
         AND COALESCE(importance, 1) >= 2
         AND lesson_learned IS NOT NULL
         AND TRIM(lesson_learned) != ''

package/hook-optimize.mjs

@@ -539,6 +539,14 @@ export function findSmartCompressCandidates(db, ageDays = 30, { project } = {})
     WHERE COALESCE(compressed_into, 0) = 0
       AND COALESCE(importance, 1) = 1
       AND COALESCE(access_count, 0) = 0
+      -- Never auto-compress a lesson-bearing row. Smart-compress sets compressed_into
+      -- on the originals (line ~693), which hides them from every injection/search
+      -- surface AND puts them out of recoverBuriedLessons' reach (it only lifts
+      -- compressed_into=0). A lesson demoted to imp=1 by citation-decay would be
+      -- silently buried by the unattended 24h llm-optimize run. Exact parity with the
+      -- canonical compress sibling selectCompressionCandidates (compress-core.mjs) —
+      -- "lessons never auto-GC" (also enforced in decayAndMarkIdle, maintain-core.mjs).
+      AND (lesson_learned IS NULL OR lesson_learned = '' OR lesson_learned = 'none')
       AND created_at_epoch < ?
       ${projectClause}
     ORDER BY project, created_at_epoch

package/hook-shared.mjs

@@ -75,22 +75,35 @@ export const CONTINUE_KEYWORDS = /继续|接着|上次|之前的|前面的|刚
 // caller will ever pick up, so sweeping them on SessionStart is safe.
 export const ORPHAN_EPISODE_AGE_MS = 60 * 60 * 1000;
 
-// Sweep stale `ep-flush-*` and `pending-*` files in `runtimeDir` whose mtime
-// is older than `ageMs` (default 1h). Returns the number of files removed.
-// fs-only — no DB / no network. Used by handleSessionStart auto-maintain to
-// prevent the doctor "Stale temp files" warning from accumulating across
-// crashes; equivalent to the manual path in `node install.mjs cleanup` but
-// age-gated so concurrent in-flight workers are never raced.
-export function sweepOrphanEpisodeFiles(runtimeDir, { ageMs = ORPHAN_EPISODE_AGE_MS, now = Date.now() } = {}) {
+// `reads-<project>.txt` (bash fast-path Read tracker) is consumed by flushEpisode's
+// rename-collect on the next edit-flush, NOT by a background worker — so a project
+// that reads but never triggers an edit-flush leaves it uncollected and unswept, and
+// it grows without bound (the 1h episode threshold is far too eager: a long read-only
+// investigation legitimately appends to it for hours). A dedicated 24h floor sweeps
+// only genuinely-abandoned trackers (no append AND no flush in a day → its paths are
+// stale to any current episode) while leaving every active session's file untouched.
+export const ORPHAN_READS_AGE_MS = 24 * 60 * 60 * 1000;
+
+// Sweep stale `ep-flush-*` / `pending-*` (older than `ageMs`, default 1h) and
+// `reads-*.txt` (older than `readsAgeMs`, default 24h) files in `runtimeDir` by
+// mtime. Returns the number of files removed. fs-only — no DB / no network. Used by
+// handleSessionStart auto-maintain to prevent the doctor "Stale temp files" warning
+// from accumulating across crashes; equivalent to the manual path in
+// `node install.mjs cleanup` but age-gated so concurrent in-flight workers / active
+// read sessions are never raced.
+export function sweepOrphanEpisodeFiles(runtimeDir, { ageMs = ORPHAN_EPISODE_AGE_MS, readsAgeMs = ORPHAN_READS_AGE_MS, now = Date.now() } = {}) {
   let entries;
   try { entries = readdirSync(runtimeDir); } catch { return 0; }
   const cutoff = now - ageMs;
+  const readsCutoff = now - readsAgeMs;
   let count = 0;
   for (const f of entries) {
-    if (!(f.startsWith('ep-flush-') || f.startsWith('pending-'))) continue;
+    const isEpisode = f.startsWith('ep-flush-') || f.startsWith('pending-');
+    const isReads = f.startsWith('reads-') && f.endsWith('.txt');
+    if (!isEpisode && !isReads) continue;
     const full = join(runtimeDir, f);
     try {
-      if (statSync(full).mtimeMs < cutoff) {
+      if (statSync(full).mtimeMs < (isReads ? readsCutoff : cutoff)) {
         unlinkSync(full);
         count++;
       }

package/hook-update.mjs

@@ -187,7 +187,7 @@ function shouldCheck(state) {
 
 // ── GitHub API ─────────────────────────────────────────────
 // Try releases/latest first, fallback to tags (some repos only use tags)
-async function fetchLatestRelease() {
+export async function fetchLatestRelease() {
   const headers = {
     'Accept': 'application/vnd.github+json',
     'User-Agent': 'claude-mem-lite-updater/1.0',
@@ -235,7 +235,10 @@ async function fetchWithTimeout(url, headers) {
   const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
   try {
     const res = await fetch(url, { signal: controller.signal, headers });
-    if (res.status === 403) {
+    if (res.status === 403 || res.status === 429) {
+      // 429 = GitHub secondary rate limit (403 = primary). Both must route to the 6h
+      // rate-limit backoff, not the 24h transient-failure path — else a 429 defers the
+      // next check a full day instead of retrying on the shorter rate-limit cadence.
       const state = readState();
       saveState({ ...state, rateLimited: true });
       debugLog('DEBUG', 'hook-update', 'GitHub API rate limited; will retry on the 6h rate-limit cadence');

package/hook.mjs

@@ -31,7 +31,7 @@ import {
 import {
   readEpisodeRaw, episodeFile,
   acquireLock, releaseLock, readEpisode, writeEpisode,
-  createEpisode, addFileToEpisode,
+  createEpisode, addFileToEpisode, planEpisodeFlush,
   writePendingEntry, mergePendingEntries, episodeHasSignificantContent,
 } from './hook-episode.mjs';
 import { cleanupClaudeMdLegacyBlock, buildSessionContextLines } from './hook-context.mjs';
@@ -118,12 +118,13 @@ for (const sig of ['SIGTERM', 'SIGINT']) {
       try {
         const ep = readEpisodeRaw();
         if (ep && ep.entries && ep.entries.length > 0) {
-          // Persist a rule-based observation synchronously BEFORE writing the flush
-          // file — that file has no consumer, so this is the only thing that prevents
-          // the in-flight episode being lost on abnormal termination (audit #6).
+          // Persist a rule-based observation synchronously — the ONLY thing that
+          // salvages the in-flight episode on abnormal termination (audit #6). A
+          // detached llm-episode child can't be spawned from a dying process, so no
+          // ep-flush-* file is written here: it would have NO consumer AND would make
+          // every later handleLLMSummary poll the full CLAUDE_MEM_FLUSH_TIMEOUT (~15s)
+          // waiting for a file that only the 24h orphan-sweep ever removes.
           saveEpisodeImmediate(ep);
-          const flushFile = join(RUNTIME_DIR, `ep-flush-${Date.now()}-${randomUUID().slice(0, 8)}.json`);
-          writeFileSync(flushFile, JSON.stringify(ep));
           try { unlinkSync(join(RUNTIME_DIR, `ep-${inferProject()}.json`)); } catch {}
         }
       } catch {}
@@ -162,77 +163,104 @@ function flushEpisode(episode, hookEventName = 'PostToolUse') {
     episode.filesRead = episode.filesRead || [];
   }
 
-  const isSignificant = episodeHasSignificantContent(episode);
+  // Split by CC session so concurrent same-project sessions flush as separate
+  // observations. planEpisodeFlush returns [episode] BY REFERENCE for the common
+  // single-session (or all-legacy) case → flushEpisodeGroup(episode) is identical
+  // to pre-grouping. Two+ interleaved sessions each get their own sub-episode.
+  const subs = planEpisodeFlush(episode);
+  let anySignificant = false;
+  for (const sub of subs) {
+    const r = flushEpisodeGroup(sub);
+    if (r === 'writefail') {
+      // Single-group: preserve the original early return — buffer left un-unlinked
+      // for a later retry, no receipt. Multi-group: skip only the failed group and
+      // keep the rest. The asymmetry is safe: each group's immediate obs is persisted
+      // BEFORE its flush-file write, so re-flushing the whole buffer would re-emit
+      // already-saved groups as duplicate observations.
+      if (subs.length === 1) return;
+      continue;
+    }
+    if (r === 'significant') anySignificant = true;
+  }
+
+  // Aggregate receipt over the whole episode, gated exactly as before
+  // (isSignificant → anySignificant). v2.33.4: Stop rejects hookSpecificOutput.
+  if (anySignificant && RECEIPT_EVENTS.has(hookEventName)) {
+    try {
+      const entries = episode.entries || [];
+      const toolCounts = {};
+      for (const e of entries) toolCounts[e.tool] = (toolCounts[e.tool] || 0) + 1;
+      const toolSummary = Object.entries(toolCounts)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 3)
+        .map(([t, n]) => `${t}×${n}`)
+        .join(', ');
+      const lines = [`[mem] episode flushed: ${entries.length} entries (${toolSummary})`];
+      // v2.83: error→fix nudge lifted to lib/cite-back-hint.mjs::buildUnsavedBugfixHint
+      // so the wording (count + "Save now" verb) stays in sync with cite-back.
+      const bugfixHint = buildUnsavedBugfixHint(episode);
+      if (bugfixHint) lines.push(bugfixHint);
+      // v2.81: cite-back hint — fires when this episode edits a file that
+      // PreToolUse:Read/Edit nudged earlier in the same session. Precision
+      // signal (we know the file was warned about); orthogonal to the
+      // bugfix-shape nudge above and may co-fire.
+      const citeBack = loadCiteBackForEpisode(episode, RUNTIME_DIR);
+      if (citeBack) lines.push(citeBack);
+      // Trailing newline is REQUIRED: when this receipt flushes at SessionStart
+      // (leftover episode after /clear or /compact), the startup dashboard writes a
+      // second hookSpecificOutput object right after. Without the '\n' the two land
+      // back-to-back as `}{` on one line and Claude Code's line-based JSON parser
+      // drops both — losing the episode-flush / cite-back context exactly at the
+      // session boundary. Every other hookSpecificOutput write appends '\n'; this
+      // was the lone exception.
+      process.stdout.write(JSON.stringify({
+        suppressOutput: true,
+        hookSpecificOutput: {
+          hookEventName,
+          additionalContext: lines.join('\n'),
+        },
+      }) + '\n');
+    } catch { /* never block on receipt */ }
+  }
 
-  // Immediate save: create rule-based observation for instant visibility.
-  // LLM background worker will upgrade title/narrative/importance later.
+  // Remove episode buffer AFTER spawning background workers to prevent concurrent overwrites
+  try { unlinkSync(episodeFile()); } catch {}
+}
+
+// Save one episode-shaped object: immediate rule-based observation (if
+// significant) + flush file + llm-episode enrichment spawn. Extracted from
+// flushEpisode so each CC-session slice (from planEpisodeFlush) flushes
+// independently and carries its OWN savedId into its OWN flush file — the
+// llm-episode worker upgrades the pre-saved obs by that id. Returns
+// 'significant' | 'insignificant' | 'writefail'. CLAUDE_MEM_SKIP_EPISODE_LLM
+// suppresses the detached enrichment spawn (test determinism; sibling of
+// CLAUDE_MEM_SKIP_COMPRESS / _OPTIMIZE) — the synchronous immediate obs still lands.
+function flushEpisodeGroup(ep) {
+  const isSignificant = episodeHasSignificantContent(ep);
+
+  // Immediate save: rule-based observation for instant visibility; the LLM
+  // background worker upgrades title/narrative/importance later.
   if (isSignificant) {
     try {
-      const obs = buildImmediateObservation(episode);
-      const id = saveObservation(obs, episode.project, episode.sessionId);
-      if (id) episode.savedId = id;
+      const obs = buildImmediateObservation(ep);
+      const id = saveObservation(obs, ep.project, ep.sessionId);
+      if (id) ep.savedId = id;
     } catch (e) { debugCatch(e, 'flushEpisode-immediateSave'); }
   }
 
-  // Write episode to flush file, then remove buffer AFTER spawn to prevent race
   const flushFile = join(RUNTIME_DIR, `ep-flush-${Date.now()}-${randomUUID().slice(0, 8)}.json`);
   try {
-    writeFileSync(flushFile, JSON.stringify(episode));
+    writeFileSync(flushFile, JSON.stringify(ep));
   } catch {
-    return;
+    return 'writefail';
   }
 
-  if (isSignificant) {
+  if (isSignificant && !process.env.CLAUDE_MEM_SKIP_EPISODE_LLM) {
     spawnBackground('llm-episode', flushFile);
-
-    // v2.33.1: structured flush receipt so Claude sees what mem just captured
-    // and the legacy error→fix nudge consolidates here. PostToolUse JSON with
-    // hookSpecificOutput.additionalContext reliably renders across CC variants;
-    // the old plain-text stdout write was invisible on some variants.
-    // v2.33.4: Stop event rejects hookSpecificOutput entirely — skip receipt.
-    if (RECEIPT_EVENTS.has(hookEventName)) {
-      try {
-        const entries = episode.entries || [];
-        const toolCounts = {};
-        for (const e of entries) toolCounts[e.tool] = (toolCounts[e.tool] || 0) + 1;
-        const toolSummary = Object.entries(toolCounts)
-          .sort((a, b) => b[1] - a[1])
-          .slice(0, 3)
-          .map(([t, n]) => `${t}×${n}`)
-          .join(', ');
-        const lines = [`[mem] episode flushed: ${entries.length} entries (${toolSummary})`];
-        // v2.83: error→fix nudge lifted to lib/cite-back-hint.mjs::buildUnsavedBugfixHint
-        // so the wording (count + "Save now" verb) stays in sync with cite-back.
-        const bugfixHint = buildUnsavedBugfixHint(episode);
-        if (bugfixHint) lines.push(bugfixHint);
-        // v2.81: cite-back hint — fires when this episode edits a file that
-        // PreToolUse:Read/Edit nudged earlier in the same session. Precision
-        // signal (we know the file was warned about); orthogonal to the
-        // bugfix-shape nudge above and may co-fire.
-        const citeBack = loadCiteBackForEpisode(episode, RUNTIME_DIR);
-        if (citeBack) lines.push(citeBack);
-        // Trailing newline is REQUIRED: when this receipt flushes at SessionStart
-        // (leftover episode after /clear or /compact), the startup dashboard writes a
-        // second hookSpecificOutput object right after. Without the '\n' the two land
-        // back-to-back as `}{` on one line and Claude Code's line-based JSON parser
-        // drops both — losing the episode-flush / cite-back context exactly at the
-        // session boundary. Every other hookSpecificOutput write appends '\n'; this
-        // was the lone exception.
-        process.stdout.write(JSON.stringify({
-          suppressOutput: true,
-          hookSpecificOutput: {
-            hookEventName,
-            additionalContext: lines.join('\n'),
-          },
-        }) + '\n');
-      } catch { /* never block on receipt */ }
-    }
   } else {
     try { unlinkSync(flushFile); } catch {}
   }
-
-  // Remove episode buffer AFTER spawning background worker to prevent concurrent overwrites
-  try { unlinkSync(episodeFile()); } catch {}
+  return isSignificant ? 'significant' : 'insignificant';
 }
 
 // ─── PostToolUse Handler ────────────────────────────────────────────────────
@@ -294,6 +322,10 @@ async function handlePostToolUse() {
     isSignificant: EDIT_TOOLS.has(tool_name) ||
                    bashSig?.isSignificant || false,
     bashSig: bashSig || null,
+    // CC UUID from hook stdin — lets flushEpisode split a buffer shared by
+    // concurrent same-project sessions into per-session observations. Null for
+    // legacy/stdin-less invocations (→ single __none__ group = old behavior).
+    ccSession: hookData.session_id || null,
   };
 
   // Episode buffer management (locked to prevent TOCTOU race)
@@ -437,16 +469,24 @@ async function handleStop() {
         if (episode && episode.entries && episode.entries.length > 0 && episodeHasSignificantContent(episode)) {
           if (!episode.sessionId) episode.sessionId = sessionId;
           if (!episode.project) episode.project = project;
-          // Immediate save: persist rule-based observation to DB before spawning background worker.
-          // Without this, data is lost if the background worker fails.
-          try {
-            const obs = buildImmediateObservation(episode);
-            const id = saveObservation(obs, episode.project, episode.sessionId);
-            if (id) episode.savedId = id;
-          } catch (e) { debugCatch(e, 'handleStop-fallback-immediateSave'); }
-          const flushFile = join(RUNTIME_DIR, `ep-flush-${Date.now()}-${randomUUID().slice(0, 8)}.json`);
-          writeFileSync(flushFile, JSON.stringify(episode));
-          spawnBackground('llm-episode', flushFile);
+          // Split by CC session before saving — parity with flushEpisode's non-contended path
+          // (v3.35.2). Without this, the lock-contended fallback re-merged exactly the interleaved
+          // concurrent-session buffers v3.35.2 split apart, co-attributing two sessions' work into
+          // one garbled observation. planEpisodeFlush returns [episode] by reference for the common
+          // single-session case, so this is a no-op there. Immediate-save each group BEFORE its
+          // flush-file write (same ordering as flushEpisodeGroup) so a worker crash can't lose it.
+          for (const sub of planEpisodeFlush(episode)) {
+            if (!sub.sessionId) sub.sessionId = sessionId;
+            if (!sub.project) sub.project = project;
+            try {
+              const obs = buildImmediateObservation(sub);
+              const id = saveObservation(obs, sub.project, sub.sessionId);
+              if (id) sub.savedId = id;
+            } catch (e) { debugCatch(e, 'handleStop-fallback-immediateSave'); }
+            const flushFile = join(RUNTIME_DIR, `ep-flush-${Date.now()}-${randomUUID().slice(0, 8)}.json`);
+            writeFileSync(flushFile, JSON.stringify(sub));
+            spawnBackground('llm-episode', flushFile);
+          }
         }
       } finally {
         try { unlinkSync(claimFile); } catch {}

package/install.mjs

@@ -1979,30 +1979,52 @@ async function manualUpdate() {
 // latest code even when local install.mjs / hook-update.mjs are themselves
 // buggy on disk.
 async function repair() {
-  console.log('\nclaude-mem-lite repair — re-syncing from latest GitHub release\n');
+  console.log('\nclaude-mem-lite repair — re-syncing from the latest SIGNED GitHub release\n');
   const stagingDir = mkdtempSync(join(tmpdir(), 'claude-mem-lite-repair-'));
   try {
-    const tarballUrl = 'https://api.github.com/repos/sdsrss/claude-mem-lite/tarball';
+    // Resolve the latest RELEASE (tag) and cryptographically VERIFY it before running any
+    // downloaded code — parity with the auto-update path (hook-update.downloadAndInstall).
+    // The old code fetched `/tarball` (default-branch main HEAD, unreleased WIP) and ran its
+    // install.mjs UNVERIFIED, and this path is auto-triggered by hook-launcher on any
+    // ERR_MODULE_NOT_FOUND — so a drifted install silently self-healed onto main, and a
+    // repo/TLS-MITM compromise achieved RCE, bypassing the Ed25519 signed-release control that
+    // the manual `update` path enforces. Lazy import so a missing/broken hook-update dependency
+    // degrades to the manual fallback (fail-closed) rather than to unverified auto-install.
+    let fetchLatestRelease, verifyReleaseAuthenticity;
+    try {
+      ({ fetchLatestRelease, verifyReleaseAuthenticity } = await import('./hook-update.mjs'));
+    } catch (e) {
+      throw new Error(`cannot load the verified-update path (${e.message}) — refusing to auto-install unverified code`, { cause: e });
+    }
+    const rel = await fetchLatestRelease();
+    if (!rel || !rel.tarballUrl) throw new Error('could not resolve the latest release (network / rate-limit)');
+    // URL allow-list mirrors hook-update.downloadAndInstall — only github.com tarball URLs.
+    if (!/^https:\/\/(?:api\.)?github\.com\/[a-zA-Z0-9./_-]+$/.test(rel.tarballUrl)) {
+      throw new Error(`refusing suspicious tarball URL: ${rel.tarballUrl}`);
+    }
     const tarballPath = join(stagingDir, 'release.tgz');
-    log('Downloading latest release tarball...');
-    execFileSync('curl', ['-sL', '-f', '-H', 'Accept: application/vnd.github+json', tarballUrl, '-o', tarballPath],
+    log(`Downloading release v${rel.version}...`);
+    execFileSync('curl', ['-sL', '-f', '-H', 'Accept: application/vnd.github+json', rel.tarballUrl, '-o', tarballPath],
       { timeout: 60000, stdio: ['ignore', 'pipe', 'inherit'] });
     log('Extracting...');
     execFileSync('tar', ['xzf', tarballPath, '-C', stagingDir, '--strip-components=1'],
       { timeout: 30000, stdio: ['ignore', 'pipe', 'inherit'] });
+    // Verify the Ed25519 signature BEFORE running the downloaded install.mjs. Fail-closed:
+    // any tampering / missing-signature / fetch-failure aborts to the manual fallback.
+    log('Verifying release signature...');
+    const authentic = await verifyReleaseAuthenticity(stagingDir, rel.assets);
+    if (!authentic.ok) throw new Error(`release signature check failed (${authentic.action})`);
     const tarballInstaller = join(stagingDir, 'install.mjs');
-    if (!existsSync(tarballInstaller)) {
-      fail('Tarball missing install.mjs — repair aborted');
-      process.exit(1);
-    }
-    log('Re-running install from freshly-downloaded sources...');
+    if (!existsSync(tarballInstaller)) throw new Error('verified tarball missing install.mjs');
+    log('Re-running install from the verified release sources...');
     execFileSync(process.execPath, [tarballInstaller, 'install'],
       { stdio: 'inherit', timeout: 300000 });
-    ok('Repair complete — broken install resynced from latest release');
+    ok(`Repair complete — resynced from verified release v${rel.version}`);
   } catch (e) {
     fail(`Repair failed: ${e.message}`);
     console.log('');
-    console.log('  Manual fallback — run this in any shell:');
+    console.log('  Automatic repair fails closed rather than run unverified code.');
+    console.log('  Manual fallback — run this in any shell (you are choosing to trust it):');
     console.log('');
     console.log('  T=$(mktemp -d) && curl -sL https://api.github.com/repos/sdsrss/claude-mem-lite/tarball | tar xz -C "$T" --strip-components=1 && node "$T/install.mjs" install');
     console.log('');