claude-mem-lite 3.74.1 → 3.75.1

package/hook.mjs

@@ -23,17 +23,17 @@ import { join } from 'path';
 import { readFileSync, writeFileSync, unlinkSync, readdirSync, renameSync, statSync, existsSync } from 'fs';
 import { homedir } from 'os';
 import {
-  truncate, inferProject, detectBashSignificance,
+  inferProject, detectBashSignificance,
   planErrorRecall, extractFilePaths, isRelatedToEpisode,
   makeEntryDesc, scrubSecrets, stripPrivate, EDIT_TOOLS, debugCatch, debugLog,
-  COMPRESSED_AUTO, OBS_BM25, notLowSignalTitleClause, formatErrorRecallHints,
+  OBS_BM25, notLowSignalTitleClause, formatErrorRecallHints,
   MAX_HOOK_STDIN_BYTES,
 } from './utils.mjs';
 import {
   readEpisodeRaw, episodeFile,
   acquireLock, releaseLock, readEpisode, writeEpisode,
   createEpisode, addFileToEpisode, planEpisodeFlush,
-  writePendingEntry, mergePendingEntries, episodeHasSignificantContent,
+  writePendingEntry, mergePendingEntries, episodeHasSignificantContent, explainSignificance,
 } from './hook-episode.mjs';
 import { cleanupClaudeMdLegacyBlock, buildSessionContextLines } from './hook-context.mjs';
 import { entry as preCompactEntry } from './hook-precompact.mjs';
@@ -44,13 +44,13 @@ import {
   sessionFile, getSessionId, createSessionId, openDb,
   spawnBackground, sweepOrphanEpisodeFiles, sweepStaleProjectMarkers,
 } from './hook-shared.mjs';
-import { handleLLMEpisode, handleLLMSummary, saveObservation, buildImmediateObservation, saveEpisodeImmediate } from './hook-llm.mjs';
-import { scrubRecord } from './lib/scrub-record.mjs';
+import { handleLLMEpisode, handleLLMSummary, saveEpisodeImmediate } from './hook-llm.mjs';
+import { readFastSummarySource, insertFastSummary, FAST_SUMMARY_LIMITS } from './lib/fast-summary.mjs';
 import { formatHookError } from './lib/native-binding-hint.mjs';
 import { recordHookError } from './lib/hook-telemetry.mjs';
 import { queueHookContext, queueHookSystemMessage, flushHookStdout } from './lib/hook-stdout.mjs';
 import { selectCompressionCandidates, groupByProjectWeek, compressGroup } from './lib/compress-core.mjs';
-import { cleanupBroken, decayAndMarkIdle, boostAccessed, selectFuzzyDedupeIds, hardDeleteCandidateCount, purgeStale, recoverOrphanedChildren, recoverBuriedLessons, sweepDeferredWorkOrphans } from './lib/maintain-core.mjs';
+import { cleanupBroken, decayAndMarkIdle, boostAccessed, markAutoCompressible, selectFuzzyDedupeIds, stampDedupSuperseded, hardDeleteCandidateCount, purgeStale, recoverOrphanedChildren, recoverBuriedLessons, sweepDeferredWorkOrphans } from './lib/maintain-core.mjs';
 import { snapshotDb } from './lib/db-backup.mjs';
 import {
   extractCitationsFromTranscript,
@@ -294,18 +294,30 @@ function flushEpisodeWithDb(db, episode, hookEventName) {
 // suppresses the detached enrichment spawn (test determinism; sibling of
 // CLAUDE_MEM_SKIP_COMPRESS / _OPTIMIZE) — the synchronous immediate obs still lands.
 function flushEpisodeGroup(ep, db) {
-  const isSignificant = episodeHasSignificantContent(ep);
+  const verdict = explainSignificance(ep);
+  const isSignificant = verdict.significant;
+  // Audit P2-14 instrument: moving Grep into the bash prefilter would save 85ms per Grep
+  // (91.2ms handoff vs 6.1ms for the already-skipped Read), but nothing records how many
+  // episodes are kept ONLY because of their Greps — and demoting what the product
+  // remembers on a deduction is how work disappears silently. This is that counter.
+  // Off unless CLAUDE_MEM_METRICS=1, like every other row in this sink.
+  recordMetric(join(RUNTIME_DIR, '..'), {
+    event: 'episode_significance',
+    rule: verdict.rule,
+    significant: isSignificant,
+    readCount: verdict.readCount,
+    grepCount: verdict.grepCount,
+    grepDecisive: verdict.grepDecisive,
+  });
 
   // Immediate save: rule-based observation for instant visibility; the LLM
-  // background worker upgrades title/narrative/importance later.
+  // background worker upgrades title/narrative/importance later. `db` is
+  // flushEpisode's handle — passed in so the caller owns open/close and the whole
+  // flush is gated on one availability check (B1). saveEpisodeImmediate re-checks
+  // significance itself, so the guard here is about the flush-file decision below.
   if (isSignificant) {
-    try {
-      const obs = buildImmediateObservation(ep);
-      // `db` is flushEpisode's handle — passed in so the caller owns open/close and the
-      // whole flush is gated on one availability check (B1).
-      const id = saveObservation(obs, ep.project, ep.sessionId, db);
-      if (id) ep.savedId = id;
-    } catch (e) { debugCatch(e, 'flushEpisode-immediateSave'); }
+    const id = saveEpisodeImmediate(ep, db, 'flushEpisode-immediateSave');
+    if (id) ep.savedId = id;
   }
 
   const flushFile = join(RUNTIME_DIR, `ep-flush-${Date.now()}-${randomUUID().slice(0, 8)}.json`);
@@ -596,21 +608,18 @@ async function handleStop() {
           // 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.
+          // One body for both paths (audit 2026-08-22 P2-9). This loop used to be a
+          // hand-copy of flushEpisodeGroup carrying three comments asserting parity with
+          // it, and it was not in parity: it ignored CLAUDE_MEM_SKIP_EPISODE_LLM, so a
+          // lock-contended Stop under test spawned a real background worker; and a failed
+          // flush-file write threw out of the whole loop into the outer catch, whose
+          // `finally` then deleted the claim file — abandoning the subs that had not been
+          // written yet. flushEpisodeGroup returns 'writefail' and the caller skips only
+          // that sub. Per-sub significance gating lives inside it too.
           for (const sub of planEpisodeFlush(episode)) {
             if (!sub.sessionId) sub.sessionId = sessionId;
             if (!sub.project) sub.project = project;
-            // Per-sub significance gate — parity with flushEpisodeGroup. The whole-episode check
-            // above can pass while an interleaved concurrent-session sub is pure noise (e.g. a lone
-            // Read); without this the fallback persists that noise sub AND spawns an LLM worker for it.
-            if (!episodeHasSignificantContent(sub)) continue;
-            try {
-              const obs = buildImmediateObservation(sub);
-              const id = saveObservation(obs, sub.project, sub.sessionId, claimDb);
-              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), { mode: 0o600 }); // captured paths + scrubbed activity — owner-only (sec P3-2)
-            spawnBackground('llm-episode', flushFile);
+            flushEpisodeGroup(sub, claimDb);
           }
         }
       } finally {
@@ -651,21 +660,7 @@ async function handleStop() {
           'SELECT 1 FROM session_summaries WHERE memory_session_id = ? LIMIT 1'
         ).get(sessionId);
         if (!existingSummary) {
-          const firstPrompt = db.prepare(`
-            SELECT prompt_text FROM user_prompts
-            WHERE content_session_id = ?
-            ORDER BY prompt_number ASC LIMIT 1
-          `).get(sessionId);
-          const recentObs = db.prepare(`
-            SELECT title FROM observations
-            WHERE memory_session_id = ? AND COALESCE(compressed_into, 0) = 0
-            ORDER BY created_at_epoch DESC LIMIT 5
-          `).all(sessionId);
-          // Raw values flow into scrubRecord below; truncation at .run() site
-          // so secrets straddling the boundary still match scrubSecrets's
-          // length floors.
-          const fastRequestRaw = firstPrompt?.prompt_text || '';
-          const obsCompleted = recentObs.map(o => o.title).filter(Boolean).join('; ');
+          const { request: fastRequestRaw, completed: obsCompleted } = readFastSummarySource(db, sessionId);
 
           // Structural extraction from the assistant's tail message.
           // CLAUDE.md §10 mandates Done/Not done/Failed/Uncertain markers, so the
@@ -693,24 +688,11 @@ async function handleStop() {
           const finalNotes = structuredNotes || 'fast';
 
           if (fastRequestRaw || finalCompleted || finalRemaining) {
-            const now = new Date();
-            const safe = scrubRecord('session_summaries', {
-              request: fastRequestRaw,
-              completed: finalCompleted,
-              remaining_items: finalRemaining,
-              notes: finalNotes,
+            insertFastSummary(db, {
+              sessionId, project, now: new Date(),
+              values: { request: fastRequestRaw, completed: finalCompleted, remaining: finalRemaining, notes: finalNotes },
+              limits: FAST_SUMMARY_LIMITS.stop,
             });
-            db.prepare(`
-              INSERT INTO session_summaries
-              (memory_session_id, project, request, investigated, learned, completed, next_steps, remaining_items, files_read, files_edited, notes, created_at, created_at_epoch)
-              VALUES (?, ?, ?, '', '', ?, '', ?, '[]', '[]', ?, ?, ?)
-            `).run(
-              sessionId, project, truncate(safe.request, 200),
-              truncate(safe.completed, 600),
-              truncate(safe.remaining_items, 600),
-              truncate(safe.notes, 400),
-              now.toISOString(), now.getTime()
-            );
           }
         }
       } catch (e) { debugCatch(e, 'handleStop-fast-summary'); }
@@ -841,10 +823,13 @@ async function handleStop() {
           } catch (e) { debugCatch(e, 'handleStop-citation-decay'); }
 
           // Persist cite-recall ratio for the next SessionStart to surface as
-          // feedback. We deliberately scan the transcript a second time here
-          // (cheap; the file is already in OS cache) rather than threading the
-          // count through `extractCitationsFromTranscript` so the bump path stays
-          // unchanged.
+          // feedback. This block re-scans the transcript rather than threading the
+          // count through `extractCitationsFromTranscript`, so the bump path stays
+          // unchanged — and since P2-8 every scanner in it shares ONE parse via
+          // lib/transcript-scan.mjs, so "scan again" costs an array iteration, not a
+          // re-read. (The old wording, "cheap; the file is already in OS cache", was
+          // arguing the pre-memo case: the OS cache saved the read, never the parse,
+          // which was ~all of the cost.)
           try {
             const stats = computeCiteRecall(transcriptPath);
             // B2 (v2.83.1): also persist the bugfix-shape nudge/save delta so
@@ -942,7 +927,6 @@ function gcStalePreRecallCooldowns() {
 function runSessionStartDbMutations(db, { sessionId, project, prevSessionId, now }) {
   // ── DB mutations in a transaction (crash-safe consistency) ──
   const staleSessionCutoff = Date.now() - STALE_SESSION_MS;
-  const autoCompressAge = Date.now() - 30 * DAY_MS; // 30 days (accelerated from 90)
 
   db.transaction(() => {
     // Ensure session exists in DB (INSERT OR IGNORE avoids race condition)
@@ -965,59 +949,55 @@ function runSessionStartDbMutations(db, { sessionId, project, prevSessionId, now
       WHERE status = 'active' AND started_at_epoch < ?
     `).run(staleSessionCutoff);
 
-    // Auto-compress: mark old low-importance observations as compressed (30+ days, importance<=1)
-    // Lightweight: only marks rows, doesn't create summaries (full compression via mem_compress)
-    // v2.56.0 #4: protect injection_count > 0 obs (proven contextually relevant
-    // via hook-memory injection, even if user never explicitly fetched). Same
-    // protection applied symmetrically in auto-maintain decay/mark-idle below.
-    // `<= 1` (was `= 1`): citation-decay floors importance at 0 (added v2.73.2, after this
-    // predicate was written) and the LLM low-signal filter saves at imp=0 — those rows are
-    // STRICTLY lower value than imp=1 yet escaped GC, accumulating to ~40% of a mature DB
-    // (immortal: hidden from injection by the imp>=1 floor, but visible as explicit-search noise).
-    const compressed = db.prepare(`
-      UPDATE observations SET compressed_into = ${COMPRESSED_AUTO}
-      WHERE COALESCE(compressed_into, 0) = 0
-        AND COALESCE(importance, 1) <= 1
-        AND COALESCE(injection_count, 0) = 0
-        -- v3.23: never auto-hide a row that carries a real lesson. compression folds
-        -- sources into a title-only summary (lesson lost), and COMPRESSED_AUTO hides the
-        -- row from search entirely. A low-importance obs whose lesson_learned is the
-        -- distilled value must stay findable (audit: 62 lessons buried this way). The 7d
-        -- noise block below already excludes lessons; this 30d block had drifted.
-        AND (lesson_learned IS NULL OR lesson_learned = '' OR lesson_learned = 'none')
-        AND created_at_epoch < ?
-        AND project = ?
-    `).run(autoCompressAge, project);
-    if (compressed.changes > 0) {
-      debugLog('DEBUG', 'session-start', `auto-compressed ${compressed.changes} old observations`);
-    }
-
-    // v2.47 P0-3: accelerated compress for LOW_SIGNAL + no-signal noise.
-    // 7-day window instead of 30. The write-side capNoiseImportance forces
-    // imp=1 on these already; this just shrinks the GC latency so the
-    // projected 32.5% corpus reduction materializes within a week on live
-    // DBs instead of bleeding into the 30-day tier.
-    const noiseCompressAge = Date.now() - 7 * DAY_MS;
-    const noiseCompressed = db.prepare(`
-      UPDATE observations SET compressed_into = ${COMPRESSED_AUTO}
-      WHERE COALESCE(compressed_into, 0) = 0
-        AND COALESCE(importance, 1) <= 1
-        AND (lesson_learned IS NULL OR lesson_learned = '' OR lesson_learned = 'none')
-        AND (facts IS NULL OR facts = '' OR facts = '[]')
-        AND (
-          title LIKE 'Modified %' OR title LIKE 'Worked on %'
-          OR title LIKE 'Reviewed %' OR title LIKE 'Error%'
-        )
-        AND created_at_epoch < ?
-        AND project = ?
-    `).run(noiseCompressAge, project);
-    if (noiseCompressed.changes > 0) {
-      debugLog('DEBUG', 'session-start', `auto-compressed ${noiseCompressed.changes} LOW_SIGNAL noise (7d window)`);
-    }
+    // The two auto-compress marking passes that used to run here moved to the 24h
+    // auto-maintain worker (audit 2026-08-22, P2-11): they are maintenance, and every
+    // boot paid two full-table conditional UPDATEs for them. markAutoCompressible in
+    // lib/maintain-core.mjs holds the (unchanged) predicates.
   })();
 }
 
-function runSessionStartAutoMaintain(db) {
+// Per-project 24h gate for the auto-compressible marking. Separate from the global
+// maintain gate on purpose: the marking is project-scoped work that every project needs
+// daily, while the pass it used to ride on (VACUUM snapshot + purge + decay + dedup) is
+// whole-DB work that should happen once a day in total.
+function markCompressibleGateFile(project) {
+  // Project names arrive already mangled by inferProject (`projects--mem`), but this is
+  // a filename, so do not trust that — one stray separator writes outside RUNTIME_DIR.
+  return join(RUNTIME_DIR, `last-mark-compressible-${String(project).replace(/[^A-Za-z0-9._-]/g, '-')}.json`);
+}
+
+function markAutoCompressibleIfDue(db, project) {
+  if (!project) {
+    // Every production spawn passes it (spawnBackground('auto-maintain', project)); a
+    // hand-run `hook.mjs auto-maintain` does not. Say so rather than skipping in
+    // silence — work vanishing without a word is this codebase's recurring shape.
+    debugLog('DEBUG', 'auto-maintain', 'no project argument — skipping auto-compress marking');
+    return;
+  }
+  const gate = markCompressibleGateFile(project);
+  try {
+    const last = JSON.parse(readFileSync(gate, 'utf8'));
+    if (Date.now() - last.epoch < 24 * 3600000) return;
+  } catch { /* no gate file → due */ }
+  try {
+    const marked = markAutoCompressible(db, project);
+    if (marked.aged > 0) debugLog('DEBUG', 'auto-maintain', `auto-compressed ${marked.aged} old observations`);
+    if (marked.noise > 0) debugLog('DEBUG', 'auto-maintain', `auto-compressed ${marked.noise} LOW_SIGNAL noise (7d window)`);
+    writeFileSync(gate, JSON.stringify({ epoch: Date.now() }));
+  } catch (e) { debugCatch(e, 'auto-maintain-mark-compressible'); }
+}
+
+function runSessionStartAutoMaintain(db, project) {
+  // The auto-compressible marking runs on its OWN per-project gate, before the global
+  // one below. v3.75.0 moved this work off SessionStart onto this worker (P2-11) and,
+  // by putting it inside the global `shouldMaintain` block, cut its coverage from
+  // "every project, every boot" to "one project per 24h" — RUNTIME_DIR is a single
+  // global directory, so whichever project wins the gate is the only one marked, and
+  // with N projects in rotation N-1 never get the 7-day noise pass. The move was right;
+  // the shared gate was not. Heavy work (VACUUM snapshot, purge, decay, dedup) stays on
+  // the global gate — that genuinely should run once a day, not once per project.
+  markAutoCompressibleIfDue(db, project);
+
   // Auto-maintain: cleanup + decay + boost + purge, gated to once per 24h
   const maintainFile = join(RUNTIME_DIR, 'last-auto-maintain.json');
   let shouldMaintain = true;
@@ -1047,6 +1027,11 @@ function runSessionStartAutoMaintain(db) {
       // children (compressed_into dangling at a deleted id). purgeStale recovers them
       // first and caps at opCap. Schema has no marked_at_epoch, so retention anchors on
       // created_at_epoch: 30d marking gate + 7d grace = 37d.
+      // The marking itself already ran at the top of this function, on its own
+      // per-project gate — it must not be conditioned on the global one (see
+      // markAutoCompressibleIfDue). It still happens BEFORE the purge/decay ops below,
+      // preserving the order the SessionStart transaction had relative to them.
+
       const purged = purgeStale(db, mctx, Date.now() - 37 * DAY_MS);
       if (purged > 0) debugLog('DEBUG', 'auto-maintain', `purged ${purged} stale observations`);
 
@@ -1099,8 +1084,7 @@ function runSessionStartAutoMaintain(db) {
       `).all();
       if (dupPairs.length > 0) {
         const removeIds = dupPairs.map(p => p.remove_id);
-        const ph = removeIds.map(() => '?').join(',');
-        db.prepare(`UPDATE observations SET superseded_at = ?, superseded_by = 'auto-dedup' WHERE id IN (${ph}) AND superseded_at IS NULL`).run(Date.now(), ...removeIds);
+        stampDedupSuperseded(db, removeIds, 'auto-dedup');
         debugLog('DEBUG', 'auto-maintain', `auto-deduped ${dupPairs.length} near-identical observations`);
       }
 
@@ -1132,9 +1116,7 @@ function runSessionStartAutoMaintain(db) {
           }));
           const fuzzyRemoveIds = selectFuzzyDedupeIds(rows, { maxMerges: FUZZY_MAX_MERGES });
           if (fuzzyRemoveIds.length > 0) {
-            const ph = fuzzyRemoveIds.map(() => '?').join(',');
-            db.prepare(`UPDATE observations SET superseded_at = ?, superseded_by = 'auto-dedup-fuzzy' WHERE id IN (${ph})`)
-              .run(Date.now(), ...fuzzyRemoveIds);
+            stampDedupSuperseded(db, fuzzyRemoveIds, 'auto-dedup-fuzzy');
             debugLog('DEBUG', 'auto-maintain', `fuzzy auto-deduped ${fuzzyRemoveIds.length} near-identical observations`);
           }
         }
@@ -1178,22 +1160,30 @@ function runSessionStartAutoMaintain(db) {
 // 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');
+function scheduleSessionStartAutoMaintain(project) {
+  // TWO gates, either of which is enough to spawn. Checking only the global one is what
+  // made the marking single-project in v3.75.0: in a multi-project rotation the global
+  // stamp is already fresh by the time the second project boots, so its worker never
+  // ran and its rows were never marked.
+  const due = (file) => {
+    try {
+      const last = JSON.parse(readFileSync(file, 'utf8'));
+      return Date.now() - last.epoch >= 24 * 3600000;
+    } catch { return true; }   // no gate file → due
+  };
+  const maintainDue = due(join(RUNTIME_DIR, 'last-auto-maintain.json'));
+  const markingDue = Boolean(project) && due(markCompressibleGateFile(project));
+  if (!maintainDue && !markingDue) return;
+  if (!process.env.CLAUDE_MEM_SKIP_MAINTAIN) spawnBackground('auto-maintain', project);
 }
 
 // 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() {
+function handleAutoMaintain(project) {
   const db = openDb();
   if (!db) return;
-  try { runSessionStartAutoMaintain(db); }
+  try { runSessionStartAutoMaintain(db, project); }
   finally { try { db.close(); } catch { /* ignore */ } }
 }
 
@@ -1226,23 +1216,7 @@ function saveHandoffAndFastSummary(db, { prevSessionId, prevProject, project, cc
     // Background llm-summary will produce a richer Haiku version later;
     // context injection query (ORDER BY created_at_epoch DESC) auto-prefers latest.
     try {
-      const firstPrompt = db.prepare(`
-        SELECT prompt_text FROM user_prompts
-        WHERE content_session_id = ?
-        ORDER BY prompt_number ASC LIMIT 1
-      `).get(prevSessionId);
-
-      const prevObs = db.prepare(`
-        SELECT title FROM observations
-        WHERE memory_session_id = ? AND COALESCE(compressed_into, 0) = 0
-        ORDER BY created_at_epoch DESC LIMIT 5
-      `).all(prevSessionId);
-
-      // Raw values flow into scrubRecord; truncation deferred to .run() so
-      // secrets straddling the truncation boundary still match scrubSecrets
-      // regex length floors.
-      const fastRequestRaw = firstPrompt?.prompt_text || '';
-      const fastCompletedRaw = prevObs.map(o => o.title).filter(Boolean).join('; ');
+      const { request: fastRequestRaw, completed: fastCompletedRaw } = readFastSummarySource(db, prevSessionId);
 
       // Infer remaining_items from handoff unfinished (already built above at line 476)
       let fastRemainingRaw = '';
@@ -1256,16 +1230,11 @@ function saveHandoffAndFastSummary(db, { prevSessionId, prevProject, project, cc
       }
 
       if (fastRequestRaw || fastCompletedRaw) {
-        const safe = scrubRecord('session_summaries', {
-          request: fastRequestRaw,
-          completed: fastCompletedRaw,
-          remaining_items: fastRemainingRaw,
+        insertFastSummary(db, {
+          sessionId: prevSessionId, project: prevProject || project, now,
+          values: { request: fastRequestRaw, completed: fastCompletedRaw, remaining: fastRemainingRaw },
+          limits: FAST_SUMMARY_LIMITS.sessionStart,
         });
-        db.prepare(`
-          INSERT INTO session_summaries
-          (memory_session_id, project, request, investigated, learned, completed, next_steps, remaining_items, files_read, files_edited, notes, created_at, created_at_epoch)
-          VALUES (?, ?, ?, '', '', ?, '', ?, '[]', '[]', 'fast', ?, ?)
-        `).run(prevSessionId, prevProject || project, truncate(safe.request, 200), truncate(safe.completed, 300), truncate(safe.remaining_items, 200), now.toISOString(), now.getTime());
       }
     } catch (e) { debugCatch(e, 'session-start-fast-summary'); }
   }
@@ -1316,30 +1285,15 @@ function buildFallbackFastSummary(db, { project, now, prevSessionId }) {
         `).get(recentSession.content_session_id);
 
         if (!hasSummary) {
-          const fp = db.prepare(`
-            SELECT prompt_text FROM user_prompts
-            WHERE content_session_id = ? ORDER BY prompt_number ASC LIMIT 1
-          `).get(recentSession.content_session_id);
-          const po = db.prepare(`
-            SELECT title FROM observations
-            WHERE memory_session_id = ? AND COALESCE(compressed_into, 0) = 0
-            ORDER BY created_at_epoch DESC LIMIT 5
-          `).all(recentSession.content_session_id);
-
-          // Raw values into scrubRecord; truncation at .run() preserves
-          // straddling-secret detection (per privacy review).
-          const frRaw = fp?.prompt_text || '';
-          const fcRaw = po.map(o => o.title).filter(Boolean).join('; ');
+          const { request: frRaw, completed: fcRaw } = readFastSummarySource(db, recentSession.content_session_id);
           if (frRaw || fcRaw) {
-            const safe = scrubRecord('session_summaries', {
-              request: frRaw,
-              completed: fcRaw,
+            // No remaining_items on this path: an /exit restart has no handoff and no
+            // episode snapshot to infer one from. It was a bare '' in the SQL before.
+            insertFastSummary(db, {
+              sessionId: recentSession.content_session_id, project, now,
+              values: { request: frRaw, completed: fcRaw },
+              limits: FAST_SUMMARY_LIMITS.exitRestart,
             });
-            db.prepare(`
-              INSERT INTO session_summaries
-              (memory_session_id, project, request, investigated, learned, completed, next_steps, remaining_items, files_read, files_edited, notes, created_at, created_at_epoch)
-              VALUES (?, ?, ?, '', '', ?, '', '', '[]', '[]', 'fast', ?, ?)
-            `).run(recentSession.content_session_id, project, truncate(safe.request, 200), truncate(safe.completed, 300), now.toISOString(), now.getTime());
           }
         }
       }
@@ -1509,7 +1463,7 @@ async function handleSessionStart() {
 
     runSessionStartDbMutations(db, { sessionId, project, prevSessionId, now });
 
-    scheduleSessionStartAutoMaintain();
+    scheduleSessionStartAutoMaintain(project);
 
     // ── Non-transactional operations (side effects, background work) ──
 
@@ -1992,7 +1946,7 @@ try {
     case 'llm-summary':      await handleLLMSummary(); break;
     case 'auto-compress':    handleAutoCompress(); break;
     case 'enrich-save':      await handleEnrichSave(process.argv[3]); break;
-    case 'auto-maintain':    handleAutoMaintain(); break;
+    case 'auto-maintain':    handleAutoMaintain(process.argv[3]); break;
     case 'llm-optimize':   await handleLLMOptimize(); break;
     // Detached update refresh spawned by handleSessionStart (audit P3d) — does the
     // GitHub fetch off the SessionStart critical path, writing update-state.json so

package/hooks/hooks.json

@@ -56,7 +56,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/hook-launcher.mjs\" scripts/pre-agent-inject.js",
+            "command": "bash \"${CLAUDE_PLUGIN_ROOT}/scripts/pre-agent-inject.sh\"",
             "timeout": 5
           }
         ]

package/install.mjs

@@ -682,6 +682,9 @@ settings.hooks = settings.hooks || {};
 
 const SCRIPTS_PATH = join(INSTALL_DIR, 'scripts');
 const PREFILTER_PATH = join(SCRIPTS_PATH, 'post-tool-use.sh');
+// Second bash prefilter, same idea one event over: skip the Node start for a
+// default-off feature (audit 2026-08-22 P2-5, see the script's header).
+const AGENT_PREFILTER_PATH = join(SCRIPTS_PATH, 'pre-agent-inject.sh');
 // v2.84: every Node hook invocation routes through hook-launcher.mjs so an
 // ERR_MODULE_NOT_FOUND from a partial-install drift auto-heals via
 // install.mjs repair instead of permanently bricking the hook chain.
@@ -792,12 +795,16 @@ const memPreSkillBridge = {
 // P0 subagent dispatch-time injection (default off — CLAUDE_MEM_SUBAGENT_INJECT).
 // Fires on the Agent/Task dispatch so a subagent (otherwise memory-blind — #8848)
 // can receive one relevant lesson via updatedInput. Parity with hooks/hooks.json.
+// Behind the bash prefilter since 2026-08-22 (audit P2-5): the flag is off by
+// default, and a disabled feature was starting a Node interpreter on every single
+// Agent dispatch (22.6ms → 2.4ms; see scripts/pre-agent-inject.sh). The prefilter
+// execs the same launcher when the flag is on.
 const memPreAgentInject = {
   matcher: 'Agent|Task',
   hooks: [
     {
       type: 'command',
-      command: nodeHook('scripts/pre-agent-inject.js'),
+      command: `bash "${AGENT_PREFILTER_PATH}"`,
       timeout: 5
     }
   ]
@@ -1957,6 +1964,26 @@ async function doctor() {
     }
   }
 
+  // Env flags that are ACCEPTED but do nothing. A flag a user set and believes is
+  // in effect is a silent lie the rest of doctor cannot see: every other check here
+  // asks whether the install is healthy, and this install is perfectly healthy while
+  // behaving as though the flag were unset (audit 2026-08-22 P2-5).
+  // Dynamically imported, and the mode table is read from the module that owns it:
+  // a static import would drag the registry retriever's dependency chain into a tool
+  // whose whole job is to run when the tree is broken, and a local copy of the list
+  // is the drift shape this repo keeps paying for.
+  try {
+    const { getRequestedRecommendMode, RECOMMEND_MODE_UNIMPLEMENTED } = await import('./registry-recommend.mjs');
+    const requested = getRequestedRecommendMode();
+    if (RECOMMEND_MODE_UNIMPLEMENTED.has(requested)) {
+      dwarn(`CLAUDE_MEM_RECOMMEND_MODE=${requested}: accepted but NOT implemented — `
+        + 'live skill-recommendation injection is Phase 2 and does not exist. The engine '
+        + 'is running in shadow (logs only, injects nothing). Set shadow or off.');
+    }
+  } catch (e) {
+    dwarn('Env flags: check failed — ' + e.message);
+  }
+
   // Plugin cache versions
   const pluginCacheBase = join(homedir(), '.claude', 'plugins', 'cache', MARKETPLACE_KEY, 'claude-mem-lite');
   if (existsSync(pluginCacheBase)) {
@@ -2005,7 +2032,13 @@ export function isMemHook(cfg) {
     const cmd = h.command || '';
     return cmd.includes('claude-mem-lite') ||
       cmd.includes('hook-launcher.mjs') ||
-      cmd.includes('scripts/post-tool-use.sh');
+      cmd.includes('scripts/post-tool-use.sh') ||
+      // Same reason post-tool-use.sh is named here: a bash prefilter routes through
+      // NO launcher, and the product-name clause only fires when the install dir
+      // happens to contain it — which CLAUDE_MEM_DIR can relocate. Without this line
+      // an Agent|Task hook in a relocated install survives uninstall and duplicates
+      // on reinstall (audit 2026-08-22 P2-5 added the second prefilter).
+      cmd.includes('scripts/pre-agent-inject.sh');
   });
 }