claude-mem-lite 3.74.1 → 3.75.0

package/hook.mjs

@@ -23,10 +23,10 @@ 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 {
@@ -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,
@@ -297,15 +297,13 @@ function flushEpisodeGroup(ep, db) {
   const isSignificant = episodeHasSignificantContent(ep);
 
   // 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 +594,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 +646,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 +674,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'); }
@@ -942,7 +910,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 +932,14 @@ 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) {
+function runSessionStartAutoMaintain(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 +969,20 @@ 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.
+      // Mark auto-compressible rows BEFORE the purge/decay ops below, preserving the
+      // order the SessionStart transaction had relative to them (marking ran first, at
+      // boot). Project-scoped exactly as before — P2-11 moved the cadence, not the scope.
+      if (project) {
+        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)`);
+      } else {
+        // 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');
+      }
+
       const purged = purgeStale(db, mctx, Date.now() - 37 * DAY_MS);
       if (purged > 0) debugLog('DEBUG', 'auto-maintain', `purged ${purged} stale observations`);
 
@@ -1099,8 +1035,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 +1067,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 +1111,22 @@ 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() {
+function scheduleSessionStartAutoMaintain(project) {
   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');
+  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 +1159,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 +1173,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 +1228,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 +1406,7 @@ async function handleSessionStart() {
 
     runSessionStartDbMutations(db, { sessionId, project, prevSessionId, now });
 
-    scheduleSessionStartAutoMaintain();
+    scheduleSessionStartAutoMaintain(project);
 
     // ── Non-transactional operations (side effects, background work) ──
 
@@ -1992,7 +1889,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');
   });
 }
 

package/lib/citation-tracker.mjs

@@ -10,10 +10,11 @@
 // column UPDATE including access_count. Per-row UPDATEs wrapped in try-catch
 // to prevent SQLITE_CORRUPT_VTAB cascades from stopping the whole scan.
 
-import { readFileSync, existsSync, readdirSync, statSync } from 'fs';
+import { readFileSync, readdirSync, statSync } from 'fs';
 import { join } from 'path';
 import { debugCatch } from '../utils.mjs';
 import { keyContextIdsFileName } from './injected-ids.mjs';
+import { readTranscriptEntries } from './transcript-scan.mjs';
 
 import { DAY_MS } from './time-constants.mjs';
 // `#123` / `#45678` at a word boundary — matches the CLAUDE.md cite pattern.
@@ -32,13 +33,7 @@ const CITATION_RE = /#(\d{1,7})\b/g;
 export function extractCitationsFromTranscript(transcriptPath, opts = {}) {
   const { mainOnly = false } = opts;
   const ids = new Set();
-  if (!transcriptPath || !existsSync(transcriptPath)) return ids;
-  let raw;
-  try { raw = readFileSync(transcriptPath, 'utf8'); } catch { return ids; }
-  for (const line of raw.split('\n')) {
-    if (!line.trim()) continue;
-    let entry;
-    try { entry = JSON.parse(line); } catch { continue; }
+  for (const entry of readTranscriptEntries(transcriptPath)) {
     // Claude Code transcript: one JSON per line with type='assistant' | 'user' | ...
     if (entry.type !== 'assistant' || !entry.message) continue;
     // Citation-decay loop scopes citation signal to main-thread text only —
@@ -77,18 +72,10 @@ export function extractCitationsFromTranscript(transcriptPath, opts = {}) {
  *   Returns zeros if transcript is missing or empty.
  */
 export function computeCiteRecall(transcriptPath) {
-  const empty = { injected: 0, cited: 0, recalled: 0, ratio: 0 };
-  if (!transcriptPath || !existsSync(transcriptPath)) return empty;
-  let raw;
-  try { raw = readFileSync(transcriptPath, 'utf8'); } catch { return empty; }
-
   const injected = new Set();
   const cited = new Set();
 
-  for (const line of raw.split('\n')) {
-    if (!line.trim()) continue;
-    let entry;
-    try { entry = JSON.parse(line); } catch { continue; }
+  for (const entry of readTranscriptEntries(transcriptPath)) {
     const target = entry.type === 'assistant' ? cited : injected;
     // Walk every text-bearing surface the transcript carries: top-level content,
     // nested message content (assistant/user blocks), and tool_result-style
@@ -199,13 +186,7 @@ function normalizeHookCommand(command) {
  */
 function eachHookAttachment(transcriptPath, fn, opts = {}) {
   const { mainOnly = false } = opts;
-  if (!transcriptPath || !existsSync(transcriptPath)) return;
-  let raw;
-  try { raw = readFileSync(transcriptPath, 'utf8'); } catch { return; }
-  for (const line of raw.split('\n')) {
-    if (!line.trim()) continue;
-    let entry;
-    try { entry = JSON.parse(line); } catch { continue; }
+  for (const entry of readTranscriptEntries(transcriptPath)) {
     if (entry.type !== 'attachment') continue;
     if (mainOnly && entry.isSidechain === true) continue;
     const att = entry.attachment;
@@ -523,12 +504,7 @@ const SUBAGENT_INJECT_ID_RE = /^\s{0,4}#(\d{1,7})\s+—/;
  */
 export function extractInjectedFromSubagentPrompt(transcriptPath) {
   const ids = new Set();
-  let raw;
-  try { raw = readFileSync(transcriptPath, 'utf8'); } catch { return ids; }
-  for (const line of raw.split('\n')) {
-    if (!line) continue;
-    let entry;
-    try { entry = JSON.parse(line); } catch { continue; }
+  for (const entry of readTranscriptEntries(transcriptPath)) {
     const c = entry.message?.content;
     const text = typeof c === 'string'
       ? c
@@ -612,22 +588,15 @@ export function aggregateProjectCiteRecall(txDir, { cutoff = 0 } = {}) {
  * @returns {boolean}
  */
 export function hasMainThreadAssistantText(transcriptPath) {
-  if (!transcriptPath || !existsSync(transcriptPath)) return false;
-  let raw;
-  try { raw = readFileSync(transcriptPath, 'utf8'); } catch { return false; }
-  // Reverse-iterate so a turn that just produced text returns true on the
-  // FIRST line examined instead of walking the entire transcript. Common case
-  // (model wrote a paragraph → Stop fires) short-circuits in O(1) line parses;
-  // pathological case (no text anywhere) still walks all entries but that's
-  // the degenerate state we want false for anyway. v2.80 perf polish — the
-  // pre-v2.80 forward scan held the full transcript in memory and walked
-  // every line on the common case too.
-  const lines = raw.split('\n');
-  for (let i = lines.length - 1; i >= 0; i--) {
-    const line = lines[i];
-    if (!line || !line.trim()) continue;
-    let entry;
-    try { entry = JSON.parse(line); } catch { continue; }
+  // Reverse-iterate so a turn that just produced text returns true on the FIRST entry
+  // examined instead of walking the whole transcript; the pathological case (no text
+  // anywhere) still walks everything, which is the degenerate state we want false for.
+  // v2.80 polish. The short-circuit is now over an already-parsed array rather than over
+  // JSON.parse calls, so it saves iteration rather than parsing — the parse is shared
+  // with the other seven scanners of the same file (audit P2-8).
+  const entries = readTranscriptEntries(transcriptPath);
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const entry = entries[i];
     if (entry.type !== 'assistant' || !entry.message) continue;
     if (entry.isSidechain === true) continue;
     const content = entry.message.content;

package/lib/cite-back-hint.mjs

@@ -12,7 +12,8 @@
 // Legacy schema   (pre-v2.81):  { "<path>": <number> } — tolerated, never emits.
 
 import { basename, join } from 'path';
-import { readFileSync, existsSync } from 'fs';
+import { readFileSync } from 'fs';
+import { readTranscriptEntries } from './transcript-scan.mjs';
 import { EDIT_TOOLS } from '../utils.mjs';
 
 const MAX_FILES = 2;
@@ -140,19 +141,10 @@ const MEM_SAVE_TOOL_NAMES = new Set([
 ]);
 
 export function countUnsavedBugfixShape(transcriptPath) {
-  const empty = { nudged: 0, saved: 0, unsaved: 0 };
-  if (!transcriptPath || !existsSync(transcriptPath)) return empty;
-  let raw;
-  try { raw = readFileSync(transcriptPath, 'utf8'); } catch { return empty; }
-
   let nudged = 0;
   let saved = 0;
 
-  for (const line of raw.split('\n')) {
-    if (!line.trim()) continue;
-    let entry;
-    try { entry = JSON.parse(line); } catch { continue; }
-
+  for (const entry of readTranscriptEntries(transcriptPath)) {
     // Bugfix-shape hint emissions live in PostToolUse attachment.stdout.
     if (entry.type === 'attachment') {
       const stdout = entry.attachment?.stdout || '';
@@ -281,13 +273,7 @@ const CITE_BACK_ID_RE = /#(\d{1,7})\b/g;
 
 export function extractCiteBackSignals(transcriptPath) {
   const ids = new Set();
-  if (!transcriptPath || !existsSync(transcriptPath)) return ids;
-  let raw;
-  try { raw = readFileSync(transcriptPath, 'utf8'); } catch { return ids; }
-  for (const line of raw.split('\n')) {
-    if (!line.trim()) continue;
-    let entry;
-    try { entry = JSON.parse(line); } catch { continue; }
+  for (const entry of readTranscriptEntries(transcriptPath)) {
     if (entry.type !== 'attachment') continue;
     const stdout = entry.attachment?.stdout || '';
     if (!stdout.includes(CITE_BACK_HINT_LEADER)) continue;

package/lib/doctor-drift.mjs

@@ -82,9 +82,16 @@ export function checkDevDrift(installDir, sourceFiles) {
 // stale in silence: tests/doctor-hook-script-manifest.test.mjs re-derives it from the
 // `command` strings in hooks/hooks.json and asserts equality, so registering a new hook
 // script without classifying it here goes red.
+//
+// `pre-agent-inject.js` moved OUT of this set on 2026-08-22 (audit P2-5): no command line
+// names it any more — `pre-agent-inject.sh` does, and execs the .js only when the feature
+// is switched on. It is still shipped and still executed, so `checkHookScriptDrift` keeps
+// grading it; it now reports as the module class, whose message ("ERR_MODULE_NOT_FOUND at
+// hook time") is the truer description of what its absence does. Same severity either way,
+// which is why this set is documented as driving the MESSAGE, not the grade.
 export const HOOK_SCRIPT_ENTRY_POINTS = new Set([
   'post-tool-use.sh', 'user-prompt-search.js', 'pre-tool-recall.js',
-  'post-tool-recall.js', 'pre-skill-bridge.js', 'pre-agent-inject.js',
+  'post-tool-recall.js', 'pre-skill-bridge.js', 'pre-agent-inject.sh',
   'hook-launcher.mjs',
 ]);