claude-mem-lite 6.10.3 → 6.11.0

package/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "6.10.3",
+      "version": "6.11.0",
       "source": "./",
       "homepage": "https://github.com/sdsrss/claude-mem-lite",
       "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": "6.10.3",
+  "version": "6.11.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/README.md

@@ -237,6 +237,25 @@ rm -rf ~/claude-mem-lite/   # pre-v0.5 unhidden (if not auto-moved)
     repos/               # Shallow-cloned source repos
 ```
 
+## Upgrading to 6.11.0
+
+**One default changes: re-enrich stops leaving part of its budget idle.** It reserves half of
+each run's budget for two backfill passes and gives its main scope the rest. When the main
+scope had fewer rows to enrich than its share, the remainder went unspent; it now goes to the
+backfills. The daily unattended pass runs once per machine per day, over all projects
+together, so with an empty main pool it now makes up to 6 of these LLM calls a day where it
+made 3. The ceiling of 6 is unchanged — it was always the declared budget — and a separately
+budgeted scope-classification pass, also unchanged, can add up to 6 more short calls. A manual
+`claude-mem-lite optimize --run` or `mem_optimize` behaves the same way. No schema change and
+no migration: an older build still opens the database, so reverting is pinning
+`claude-mem-lite@6.10.3`.
+
+**One security fix does not reach data you already have.** In some combinations of two
+labelled credentials on one line — `token: <v> secret: <v>` is one, when the first value ends
+in a letter — earlier versions redacted the first and stored the second as typed. Values on
+separate lines were never affected. This release fixes the write path; nothing already in
+your database is rewritten.
+
 <!-- normalize-per-project-note:start -->
 ## Upgrading to 6.8.0
 

package/README.zh-CN.md

@@ -199,6 +199,20 @@ rm -rf ~/claude-mem-lite/   # v0.5 前的非隐藏目录（如未自动迁移）
     repos/               # 浅克隆的源代码仓库
 ```
 
+## 升级到 6.11.0
+
+**只有一个默认行为变化：re-enrich 不再让一部分预算空着。** 它为两个回填任务预留每次运行一半的
+预算，其余给主范围。以前主范围待处理的行数少于它那一份时，剩下的额度就空着不用；现在转给回填
+任务。每日后台任务是**每台机器每天一次、对所有项目合并运行**，所以主池为空时，它现在每天最多
+做 6 次这类 LLM 调用，而以前是 3 次。上限 6 没变——这一直是声明的预算；另有一个单独计预算的
+「范围分类」任务，本版未改动，最多还会再加 6 次简短调用。手动运行 `claude-mem-lite optimize --run`
+或 `mem_optimize` 行为相同。没有 schema 变更、没有迁移：旧版本仍能打开数据库，回退就是固定到
+`claude-mem-lite@6.10.3`。
+
+**有一个安全修复不会作用于你已有的数据。** 同一行里两个带标签的凭据，在某些组合下——例如
+`token: <v> secret: <v>`，且第一个值以字母结尾——以前的版本会脱敏第一个、把第二个按原样存下来。
+分行写的值从未受影响。本版本修的是写入路径；数据库里已有的内容不会被改写。
+
 <!-- normalize-per-project-note:start -->
 ## 升级到 6.8.0
 

package/hook-optimize.mjs

@@ -1739,14 +1739,55 @@ export async function optimizeRun(
             // Both pools drain (each is idempotent via the column it fills), so the
             // ordering decides which drains first, not which gets served at all.
             const half = Math.max(1, Math.floor(budget.reenrich / 2));
+            // D#51: `half` is the fill passes' CAP, not their entitlement — and the main
+            // scope's remainder used to evaporate whenever main's own pool held fewer rows
+            // than its share. The comment above states the symmetric case ("a
+            // zero-candidate aliases pass costs nothing and the main scope keeps its full
+            // budget") and neither stated nor implemented the reverse.
+            //
+            // The unit is ONE RUN, not one project. The daily path (handleLLMOptimize)
+            // calls this once per machine per day with no `project`, so every pool here is
+            // a union over all projects; only normalize fans out per project. Measured
+            // read-only on the live DB 2026-09-22: the union read wide 0 / aliases 0 against
+            // a concepts backlog of 74 (78 on a re-read later that day — every session adds
+            // rows), so the daily run idled 3 of its 6 slots and the backlog drained at 3 a
+            // day; it now drains at 6. (A first draft of this comment summed eight
+            // per-project shares into "26 slots a day" — arithmetic about eight runs that
+            // never happen. The ledger's original union reading was the right one.)
+            //
+            // Main is MEASURED first and still RUNS first. That distinction is the whole
+            // safety argument: this is a SELECT, and the execution order below — which is
+            // load-bearing for a reason the next comment gives — is untouched.
+            //
+            // Nor can this reopen the starvation the ordering comment forbids. The fill
+            // passes take at most `fillCap`, so mainBudget >= budget.reenrich - fillCap =
+            // min(budget.reenrich - half, mainPool): when main's pool is at or below its old
+            // floor it now receives ALL of it, and when the pool is larger the arithmetic is
+            // byte-for-byte what it was. So THIS CHANGE introduces no input on which a fill
+            // pass takes a slot the main scope could have spent — which is the comparative
+            // claim, and the only one that holds. An earlier draft said it absolutely ("there
+            // is no input..."), and pre-ship review brute-forced 129,654 inputs and found
+            // 98,713 counter-examples to the absolute: at R=6 with mainPool=4, half=3 and
+            // fillCap=3, main could have spent 4 and gets 3. That is PRE-EXISTING — the old
+            // arithmetic gives 3 there too — so the comparative reading is sound and the
+            // unqualified one was never true of this code. Pinned by "does not take the main
+            // scope below what its own pool can use" and by "measures the main pool with the
+            // scope it is about to RUN".
+            const mainPool = findReenrichCandidates(db, budget.reenrich, {
+              scope: reenrichScope,
+              project,
+            }).length;
+            const fillCap = Math.max(half, budget.reenrich - mainPool);
             const aliasBudget = Math.min(
-              half,
-              findReenrichCandidates(db, half, { scope: 'aliases', project }).length,
+              fillCap,
+              findReenrichCandidates(db, fillCap, { scope: 'aliases', project }).length,
             );
             const conceptsBudget = Math.min(
-              half - aliasBudget,
-              findReenrichCandidates(db, Math.max(0, half - aliasBudget), { scope: 'concepts', project })
-                .length,
+              fillCap - aliasBudget,
+              findReenrichCandidates(db, Math.max(0, fillCap - aliasBudget), {
+                scope: 'concepts',
+                project,
+              }).length,
             );
             const scopesBudget = Math.min(
               budget.reenrich,

package/install.mjs

@@ -65,6 +65,17 @@ const HOOK_PATH = join(INSTALL_DIR, 'hook.mjs');
 // imports — this pair used to be typed out in each.
 import { MARKETPLACE_KEY, PLUGIN_KEY, PLUGIN_NAME, isPluginExplicitlyDisabled } from './lib/plugin-key.mjs';
 import { doctorDbModeHint } from './lib/doctor-modes.mjs';
+// Static, matching doctor-modes above. Safe here where it would not be for a heavier
+// module: this one is a leaf over node:fs + node:child_process, so it adds no load graph
+// to the entry point that has to survive a broken install.
+import { checkHookInterpreter } from './lib/doctor-hook-interpreter.mjs';
+import {
+  classifyEpisodeFile,
+  EPISODE_AGE_LABEL,
+  isEpisodeResidue,
+  isUpdateResidue,
+  scanStaleTempFiles,
+} from './lib/doctor-stale-temp.mjs';
 const NPM_INSTALL_CMD = 'npm install --omit=dev --no-audit --no-fund';
 
 import {
@@ -84,7 +95,6 @@ import { detectInstallShape, probeRuntimeRoots, hasAnyManagedCode } from './lib/
 import { probeSchemaCompat, schemaSkewRemedy } from './lib/schema-skew.mjs';
 import { clearNativeBindingBreakage, readNativeBindingBreakage } from './lib/native-binding-hint.mjs';
 import { sweepStaleTestFixtures } from './lib/tmp-fixture-sweep.mjs';
-import { ORPHAN_EPISODE_AGE_MS } from './lib/time-constants.mjs';
 import { acquireLock } from './lib/proc-lock.mjs';
 import { atomicWriteFileSync } from './lib/atomic-write.mjs';
 import { isMemHook, launcherEntryPath } from './lib/hook-prune.mjs';
@@ -279,59 +289,6 @@ export function buildDoctorSummary(issues, warnings) {
   return `${issues} issue(s) found.${warnSuffix}`;
 }
 
-/**
- * How many LIVE hook commands invoke `bash`, and which scripts they are.
- *
- * There are two hook registrations and only one is live per install shape, which is what
- * the first cut of doctor's interpreter check got wrong (pre-ship review P1-1). The plugin
- * shape reads `hooks/hooks.json` out of the plugin cache. The npm / npx / `git clone` shape
- * has no such file — `hooks/hooks.json` is in RELEASE_SIGNED_FILES but NOT in SOURCE_FILES,
- * so nothing deploys it to ~/.claude-mem-lite/ — and registers its hooks in settings.json
- * instead. Reading only the manifest therefore answered "zero bash hooks" on the one shape
- * where two of them are live.
- *
- * Returns THREE outcomes, never two. `count: null` means no registration could be read, and
- * that is deliberately distinct from a count of zero: zero is an answer, null is the absence
- * of one, and a diagnostic that reports them identically tells the reader to stop looking.
- *
- * @param {{manifestPath: string, settingsCommands?: string[], installDir: string}} opts
- * @returns {{count: number|null, source: 'manifest'|'settings'|null, scripts: string[]}}
- */
-export function resolveBashHookCount({ manifestPath, settingsCommands = [], installDir }) {
-  const basenames = (commands) =>
-    commands
-      .map((c) => {
-        const m = c.match(/([^/"\s]+\.sh)/);
-        return m ? m[1] : c;
-      })
-      .sort();
-
-  if (existsSync(manifestPath)) {
-    try {
-      const parsed = JSON.parse(readFileSync(manifestPath, 'utf8'));
-      const commands = [];
-      for (const matchers of Object.values(parsed?.hooks || {})) {
-        for (const m of matchers || []) {
-          for (const h of m?.hooks || []) commands.push(String(h?.command || ''));
-        }
-      }
-      const bash = commands.filter((c) => c.startsWith('bash '));
-      return { count: bash.length, source: 'manifest', scripts: basenames(bash) };
-    } catch {
-      // A torn manifest is not evidence of zero bash hooks. Fall through to settings.json,
-      // and if that says nothing about us either, the caller gets null.
-    }
-  }
-  // Only OUR entries: settings.json is shared with every other tool the user installs, so a
-  // foreign `bash "…"` line is not ours to report on, and — the discriminating half — a
-  // settings.json that names nothing of ours is not evidence that no hook needs bash. It is
-  // evidence we are reading the wrong registration.
-  const ours = settingsCommands.filter((c) => c.includes(installDir));
-  if (ours.length === 0) return { count: null, source: null, scripts: [] };
-  const bash = ours.filter((c) => c.startsWith('bash '));
-  return { count: bash.length, source: 'settings', scripts: basenames(bash) };
-}
-
 // Dev installs symlink server.mjs → the project's source file. Used to suppress
 // misleading "first run" messages since hook-update.mjs skips state-writes in
 // this mode (see hook-update.mjs isDevMode).
@@ -2586,95 +2543,50 @@ async function doctor() {
     dwarn('Hook scripts: check failed — ' + e.message);
   }
 
-  // Hook interpreter. Some hook commands are `bash "<script>"` (the PostToolUse and
-  // Agent prefilters, plus setup.sh in the plugin manifest) — the rest are `node`. If bash
-  // cannot run, those commands fail and nothing says so; the check above grades whether the
-  // FILES are present, which they are.
-  //
-  // Keyed on whether bash runs, not on process.platform === 'win32'. A Windows user with
-  // Git for Windows on PATH — the normal case, since Claude Code shells out to bash for its
-  // own Bash tool — has a working configuration and must not be warned; a stripped
-  // container with no bash has a broken one and must be, whatever its platform. This is
-  // also what issue #28's P3-19 intent asked for: `os: [darwin, linux]` was added so a
-  // Windows user "should be told rather than handed a string of silent catch blocks", and
-  // blocking the install told them nothing. This is the telling.
-  try {
-    const {
-      count: bashCommands,
-      source: countSource,
-      scripts: bashScripts,
-    } = resolveBashHookCount({
+  // Hook interpreter — see lib/doctor-hook-interpreter.mjs for what it grades and why it
+  // keys on whether bash RUNS rather than on process.platform. The two registration paths
+  // are passed in rather than recomputed there, because they appear verbatim in the
+  // "could not read either registration" message and that text is asserted on.
+  checkHookInterpreter(
+    { ok, dwarn },
+    {
       manifestPath: join(PROJECT_DIR, 'hooks', 'hooks.json'),
+      settingsPath: join(homedir(), '.claude', 'settings.json'),
       settingsCommands: settingsHookCommands(homedir()),
       installDir: INSTALL_DIR,
-    });
-    if (bashCommands === null) {
-      // NOT `ok`. Pre-ship review (P1-1) found the first cut printing "no hook command needs
-      // bash" here, on a shape where two of them are registered — a green line that ends the
-      // reader's search is worse than the silence this check exists to remove.
-      dwarn(
-        'Hook interpreter: could not read either hook registration — neither ' +
-          `${join(PROJECT_DIR, 'hooks', 'hooks.json')} nor a claude-mem-lite entry in ` +
-          `${join(homedir(), '.claude', 'settings.json')} — so whether any hook needs bash is unknown.`,
-      );
-    } else if (bashCommands === 0) {
-      ok(`Hook interpreter: no hook command needs bash (per the ${countSource})`);
-    } else {
-      let bashOk = false;
-      try {
-        execFileSync('bash', ['-c', 'exit 0'], { stdio: 'ignore', timeout: 5000 });
-        bashOk = true;
-      } catch {
-        /* not resolvable, or not runnable — either way the hooks that need it cannot fire */
-      }
-      if (bashOk) {
-        ok(`Hook interpreter: bash present (${bashCommands} hook command(s) need it)`);
-      } else {
-        // dwarn, not an issue: everything else works. Saying "broken" about an install
-        // whose MCP server and node hooks are fine would be the mirror of the defect that
-        // sent this round's reporter looking at their disk and their network.
-        // The scripts are NAMED from the live registration rather than described from
-        // memory — the first cut wrote "(episode Read-tracking and the subagent prefilter)",
-        // a two-item gloss on a count of three (P3-1).
-        dwarn(
-          `Hook interpreter: bash not found on PATH — the ${bashCommands} hook command(s) that ` +
-            `invoke it cannot fire (${bashScripts.join(', ')}). The MCP server and the node ` +
-            'hooks are unaffected. On Windows, install Git for Windows or use WSL; elsewhere ' +
-            'this means a stripped PATH.',
-        );
-      }
-    }
-  } catch (e) {
-    dwarn('Hook interpreter: check failed — ' + e.message);
-  }
+    },
+  );
 
-  // Stale temp files
+  // Stale temp files. The rules live in lib/doctor-stale-temp.mjs because this scanner and
+  // cleanup's deleter are the same question asked twice and had drifted twice — see that
+  // file. Counting is all that differs here; the classification is shared, so "what doctor
+  // calls stale" and "what cleanup removes" agree on the age gate, which is the axis they
+  // last diverged on. Not on every axis: cleanup skips update residue entirely while
+  // install.lock is held and the scanner has no such gate, so mid-self-update doctor still
+  // counts a file cleanup will decline. That one is milder than D#53 — cleanup SAYS it is
+  // skipping rather than answering "No stale files found" — and it predates this change.
   try {
-    // hook-update + the episode workers write runtime/ + staging under DB_DIR
-    // (= MEM_DATA_DIR, env-aware), NOT the homedir code dir — scan there so doctor
-    // sees the real residue under relocation. MEM_RUNTIME_DIR rather than
-    // join(MEM_DATA_DIR,'runtime'): `pending-*` / `ep-flush-*` are written through
-    // hook-shared.mjs's override-aware RUNTIME_DIR, and `cleanup()` below deletes them from
-    // MEM_RUNTIME_DIR — v3.93.0 moved the deleter and left this scanner behind, so under the
-    // override doctor reported "none" while the cleanup it recommends removed files.
-    const runtimeDir = MEM_RUNTIME_DIR;
-    let staleCount = 0;
-    const stalePatterns = ['.update-staging-', '.update-backup-'];
-    if (existsSync(MEM_DATA_DIR)) {
-      for (const f of readdirSync(MEM_DATA_DIR)) {
-        if (stalePatterns.some((p) => f.startsWith(p))) staleCount++;
-      }
-    }
-    if (existsSync(runtimeDir)) {
-      for (const f of readdirSync(runtimeDir)) {
-        if (f.startsWith('pending-') || f.startsWith('ep-flush-')) staleCount++;
-      }
-    }
-    if (staleCount > 0) {
-      dwarn(`Stale temp files: ${staleCount} found (run: node install.mjs cleanup)`);
+    const { stale, inFlight } = scanStaleTempFiles({
+      dataDir: MEM_DATA_DIR,
+      runtimeDir: MEM_RUNTIME_DIR,
+    });
+    if (stale > 0) {
+      dwarn(`Stale temp files: ${stale} found (run: node install.mjs cleanup)`);
     } else {
       ok('Stale temp files: none');
     }
+    // D#53: reported as a DETAIL, not a warning. An episode file younger than the gate is
+    // work in progress — after a Stop that hands an episode to the summarizer it exists for
+    // up to ~60s, the worst-case round trip — so warning about it
+    // put a permanent ⚠ on healthy machines and sent them to a command that answers "No
+    // stale files found." Still said out loud rather than hidden, because a bare "none"
+    // next to a runtime dir that visibly holds files is the kind of green line that ends
+    // the reader's search. Mirrors cleanup's own "Kept N …" line.
+    if (inFlight > 0) {
+      log(
+        `  ${inFlight} episode file(s) newer than ${EPISODE_AGE_LABEL} are in flight, not stale — cleanup keeps these.`,
+      );
+    }
   } catch {
     dwarn('Stale temp files: check failed');
   }
@@ -3070,13 +2982,12 @@ function cleanup() {
   // and the window is long — it spans the source-compile fallback, up to five minutes —
   // while doctor is actively telling the user to run cleanup. Non-blocking: if an installer
   // holds the lock we skip only these two patterns, not the rest of cleanup.
-  const stalePatterns = ['.update-staging-', '.update-backup-'];
   const updateLock = acquireLock(join(MEM_DATA_DIR, 'runtime', 'install.lock')); // runtime-dir:stays-put — install lock serialises real installers
   if (!updateLock) {
     warn('Update residue skipped: install in progress (install.lock held)');
   } else if (existsSync(MEM_DATA_DIR)) {
     for (const f of readdirSync(MEM_DATA_DIR)) {
-      if (stalePatterns.some((p) => f.startsWith(p))) {
+      if (isUpdateResidue(f)) {
         if (dryRun) {
           ok(`Would remove: ${f}`);
           removed++;
@@ -3108,20 +3019,13 @@ function cleanup() {
   // the conservative one.
   const runtimeDir = MEM_RUNTIME_DIR;
   if (existsSync(runtimeDir)) {
-    const epCutoff = Date.now() - ORPHAN_EPISODE_AGE_MS;
+    const now = Date.now();
     let inFlight = 0;
     for (const f of readdirSync(runtimeDir)) {
-      if (f.startsWith('pending-') || f.startsWith('ep-flush-')) {
-        // Unreadable mtime → treat as in-flight and skip. Failing safe here costs one
-        // stale file until the next sweep; failing open costs an episode.
-        let mtimeMs;
-        try {
-          mtimeMs = statSync(join(runtimeDir, f)).mtimeMs;
-        } catch {
-          inFlight++;
-          continue;
-        }
-        if (mtimeMs > epCutoff) {
+      if (isEpisodeResidue(f)) {
+        // The gate itself lives in lib/doctor-stale-temp.mjs, so doctor's count and this
+        // deletion cannot disagree about which files are in flight (D#53).
+        if (classifyEpisodeFile(runtimeDir, f, { now }) === 'in-flight') {
           inFlight++;
           continue;
         }
@@ -3141,7 +3045,7 @@ function cleanup() {
     }
     if (inFlight > 0) {
       log(
-        `  Kept ${inFlight} episode file(s) newer than 1h — possibly in flight, they sweep automatically once stale.`,
+        `  Kept ${inFlight} episode file(s) newer than ${EPISODE_AGE_LABEL} — possibly in flight, they sweep automatically once stale.`,
       );
     }
   }

package/lib/doctor-hook-interpreter.mjs

@@ -0,0 +1,175 @@
+/**
+ * doctor's hook-interpreter check, extracted from install.mjs.
+ *
+ * Why it moved, since "it was long" is not one of this repo's `lib/` criteria: the
+ * second criterion is a unit carved out of an entry file so COVERAGE reaches it.
+ * `install.mjs` is excluded from the coverage population by name (vitest.config.mjs's
+ * coverage `exclude`; the population is a denylist, so staying out costs a named entry),
+ * so code living in it has no coverage reading at all — not a low one, NONE — while
+ * `doctor()` alone is 1025 of
+ * its ~3595 lines and holds the criteria a user is shown when their install is broken.
+ * Those criteria were graded almost entirely by subprocess E2E, and the 2026-09 audit
+ * found two P1s among them.
+ *
+ * (`vitest.config.mjs` records a spot reading of 11.67% statements from a run that
+ * temporarily added the file to the population. That is a STAMP, not a current number:
+ * it is dated 2026-09-03 and predates all three caliber breaks CLAUDE.md names — the
+ * 2026-09-05 reformat, the vitest 5.0.0 coverage recalibration, and the 2026-09-07
+ * `include` inversion. An earlier draft of this docblock quoted it as if it were
+ * current, which is the carried-cell shape this repo files as a defect.)
+ *
+ * What is measured on THIS tree, and is the argument that actually carries: the
+ * dispatch below reads 88.88% statements with its own cases, where in `install.mjs` it
+ * had no reading to improve on. Joining lib/doctor-modes.mjs, lib/doctor-drift.mjs and
+ * lib/doctor-benchmark.mjs, which started this split.
+ *
+ * A LEAF on purpose — `node:fs` and `node:child_process`, nothing from this project.
+ * Doctor is the surface a BROKEN install is diagnosed from, and this repo has already
+ * paid for the alternative: one import edge, taken for two path constants, put the
+ * signature-verified repair out of reach on exactly the installs it existed to repair.
+ * Everything else arrives as an argument.
+ */
+
+import { existsSync, readFileSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
+
+/**
+ * How many LIVE hook commands invoke `bash`, and which scripts they are.
+ *
+ * There are two hook registrations and only one is live per install shape, which is what
+ * the first cut of doctor's interpreter check got wrong (pre-ship review P1-1). The plugin
+ * shape reads `hooks/hooks.json` out of the plugin cache. The npm / npx / `git clone` shape
+ * has no such file — `hooks/hooks.json` is in RELEASE_SIGNED_FILES but NOT in SOURCE_FILES,
+ * so nothing deploys it to ~/.claude-mem-lite/ — and registers its hooks in settings.json
+ * instead. Reading only the manifest therefore answered "zero bash hooks" on the one shape
+ * where two of them are live.
+ *
+ * Returns THREE outcomes, never two. `count: null` means no registration could be read, and
+ * that is deliberately distinct from a count of zero: zero is an answer, null is the absence
+ * of one, and a diagnostic that reports them identically tells the reader to stop looking.
+ *
+ * @param {{manifestPath: string, settingsCommands?: string[], installDir: string}} opts
+ * @returns {{count: number|null, source: 'manifest'|'settings'|null, scripts: string[]}}
+ */
+export function resolveBashHookCount({ manifestPath, settingsCommands = [], installDir }) {
+  const basenames = (commands) =>
+    commands
+      .map((c) => {
+        const m = c.match(/([^/"\s]+\.sh)/);
+        return m ? m[1] : c;
+      })
+      .sort();
+
+  if (existsSync(manifestPath)) {
+    try {
+      const parsed = JSON.parse(readFileSync(manifestPath, 'utf8'));
+      const commands = [];
+      for (const matchers of Object.values(parsed?.hooks || {})) {
+        for (const m of matchers || []) {
+          for (const h of m?.hooks || []) commands.push(String(h?.command || ''));
+        }
+      }
+      const bash = commands.filter((c) => c.startsWith('bash '));
+      return { count: bash.length, source: 'manifest', scripts: basenames(bash) };
+    } catch {
+      // A torn manifest is not evidence of zero bash hooks. Fall through to settings.json,
+      // and if that says nothing about us either, the caller gets null.
+    }
+  }
+  // Only OUR entries: settings.json is shared with every other tool the user installs, so a
+  // foreign `bash "…"` line is not ours to report on, and — the discriminating half — a
+  // settings.json that names nothing of ours is not evidence that no hook needs bash. It is
+  // evidence we are reading the wrong registration.
+  const ours = settingsCommands.filter((c) => c.includes(installDir));
+  if (ours.length === 0) return { count: null, source: null, scripts: [] };
+  const bash = ours.filter((c) => c.startsWith('bash '));
+  return { count: bash.length, source: 'settings', scripts: basenames(bash) };
+}
+
+/**
+ * Can bash actually be run? Separated from the dispatch below, and injectable there,
+ * because shelling out is the entire reason that dispatch had no unit coverage: one of
+ * its four outcomes needs a machine where bash is absent, which no in-process test can
+ * arrange without rewriting PATH for the whole worker. The dispatch's outer catch is
+ * unreachable through THIS function — it catches everything and returns false — so the
+ * real probe never drives it. Other things in that try block can: a non-string entry in
+ * `settingsCommands`, or a reporter (`ok` / `dwarn`) that throws. The shipped caller
+ * passes only strings, and the tests drive the catch with an injected throwing probe.
+ *
+ * @returns {boolean}
+ */
+function probeBash() {
+  try {
+    execFileSync('bash', ['-c', 'exit 0'], { stdio: 'ignore', timeout: 5000 });
+    return true;
+  } catch {
+    /* not resolvable, or not runnable — either way the hooks that need it cannot fire */
+    return false;
+  }
+}
+
+/**
+ * Grade the hook interpreter, reporting through doctor's own helpers.
+ *
+ * Some hook commands are `bash "<script>"` (the PostToolUse and Agent prefilters, plus
+ * setup.sh in the plugin manifest) — the rest are `node`. If bash cannot run, those
+ * commands fail and nothing says so; the file-presence check grades whether the FILES are
+ * there, which they are.
+ *
+ * Keyed on whether bash RUNS, not on `process.platform === 'win32'`. A Windows user with
+ * Git for Windows on PATH — the normal case, since Claude Code shells out to bash for its
+ * own Bash tool — has a working configuration and must not be warned; a stripped container
+ * with no bash has a broken one and must be, whatever its platform. This is also what issue
+ * #28's P3-19 intent asked for: `os: [darwin, linux]` was added so a Windows user "should be
+ * told rather than handed a string of silent catch blocks", and blocking the install told
+ * them nothing. This is the telling.
+ *
+ * @param {{ok: (m: string) => void, dwarn: (m: string) => void}} report doctor's helpers
+ * @param {object} ctx
+ * @param {string} ctx.manifestPath    plugin-shape registration (hooks/hooks.json)
+ * @param {string} ctx.settingsPath    npm-shape registration, named in the unknown message
+ * @param {string[]} ctx.settingsCommands
+ * @param {string} ctx.installDir
+ * @param {() => boolean} [ctx.bashPresent]
+ */
+export function checkHookInterpreter(
+  { ok, dwarn },
+  { manifestPath, settingsPath, settingsCommands = [], installDir, bashPresent = probeBash },
+) {
+  try {
+    const {
+      count: bashCommands,
+      source: countSource,
+      scripts: bashScripts,
+    } = resolveBashHookCount({ manifestPath, settingsCommands, installDir });
+    if (bashCommands === null) {
+      // NOT `ok`. Pre-ship review (P1-1) found the first cut printing "no hook command needs
+      // bash" here, on a shape where two of them are registered — a green line that ends the
+      // reader's search is worse than the silence this check exists to remove.
+      dwarn(
+        'Hook interpreter: could not read either hook registration — neither ' +
+          `${manifestPath} nor a claude-mem-lite entry in ` +
+          `${settingsPath} — so whether any hook needs bash is unknown.`,
+      );
+    } else if (bashCommands === 0) {
+      ok(`Hook interpreter: no hook command needs bash (per the ${countSource})`);
+    } else if (bashPresent()) {
+      ok(`Hook interpreter: bash present (${bashCommands} hook command(s) need it)`);
+    } else {
+      // dwarn, not an issue: everything else works. Saying "broken" about an install
+      // whose MCP server and node hooks are fine would be the mirror of the defect that
+      // sent this round's reporter looking at their disk and their network.
+      // The scripts are NAMED from the live registration rather than described from
+      // memory — the first cut wrote "(episode Read-tracking and the subagent prefilter)",
+      // a two-item gloss on a count of three (P3-1).
+      dwarn(
+        `Hook interpreter: bash not found on PATH — the ${bashCommands} hook command(s) that ` +
+          `invoke it cannot fire (${bashScripts.join(', ')}). The MCP server and the node ` +
+          'hooks are unaffected. On Windows, install Git for Windows or use WSL; elsewhere ' +
+          'this means a stripped PATH.',
+      );
+    }
+  } catch (e) {
+    dwarn('Hook interpreter: check failed — ' + e.message);
+  }
+}

package/lib/doctor-stale-temp.mjs

@@ -0,0 +1,111 @@
+/**
+ * What counts as stale temp residue, and — the half that kept drifting — what does NOT.
+ *
+ * Extracted from install.mjs because the scanner (`doctor`) and the deleter (`cleanup`)
+ * were two hand-kept copies of the same rules, and they have now diverged twice:
+ *
+ *   • v3.93.0 moved the deleter to MEM_RUNTIME_DIR and left the scanner on
+ *     join(MEM_DATA_DIR,'runtime'), so under a runtime override doctor reported "none"
+ *     while the cleanup it recommends removed files. Fixed by moving the scanner.
+ *   • D#53 (measured 2026-09-22): the deleter age-gates `pending-*` / `ep-flush-*` at
+ *     ORPHAN_EPISODE_AGE_MS and the scanner did not, so with three in-flight episode
+ *     files doctor printed "Stale temp files: 3 found (run: node install.mjs cleanup)"
+ *     and cleanup answered "Kept 3 episode file(s) newer than 1h" then "No stale files
+ *     found." Two faces of one install contradicting each other, verbatim.
+ *
+ * Both were the same defect class on different axes — first the directory, then the age
+ * gate — which is why this module exports the CLASSIFIER and not just the prefixes.
+ * Sharing the prefixes alone would leave the age gate implemented twice, which is the
+ * shape that produced D#53 in the first place.
+ *
+ * A leaf: node:fs, node:path, and one constants module that imports nothing.
+ */
+
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { ORPHAN_EPISODE_AGE_MS } from './time-constants.mjs';
+
+/** Residue from an interrupted self-update, written under the data dir by hook-update. */
+const UPDATE_RESIDUE_PREFIXES = ['.update-staging-', '.update-backup-'];
+
+/** Episode hand-off files under the runtime dir. Age-gated: see classifyEpisodeFile. */
+const EPISODE_RESIDUE_PREFIXES = ['pending-', 'ep-flush-'];
+
+export const isUpdateResidue = (name) => UPDATE_RESIDUE_PREFIXES.some((p) => name.startsWith(p));
+
+export const isEpisodeResidue = (name) => EPISODE_RESIDUE_PREFIXES.some((p) => name.startsWith(p));
+
+/**
+ * How the age gate is SPOKEN, derived from the gate itself rather than hand-written.
+ *
+ * Both faces print this window to the user. Before it existed, cleanup printed a literal
+ * "1h" while the rule lived in ORPHAN_EPISODE_AGE_MS, and this change's own first draft
+ * added a second literal to doctor's new in-flight line — a hand-kept twin of the gate, in
+ * the change whose headline was that the rule has one home. Pre-ship review counted it.
+ *
+ * Whole hours only: a 20-minute gate would print "0h". The gate is HOUR_MS today, and
+ * tests/doctor-stale-temp-agreement.test.mjs parses this label back and requires it to
+ * equal the gate, so a gate that is not a whole number of hours fails there rather than
+ * printing a wrong window to the user.
+ */
+export const EPISODE_AGE_LABEL = `${Math.round(ORPHAN_EPISODE_AGE_MS / 3600000)}h`;
+
+/**
+ * Is this episode file residue, or is it work in progress?
+ *
+ * The single definition of the age gate that doctor and cleanup share. (The automatic
+ * sweep in hook-shared.mjs and the summarizer's wait in hook-llm.mjs apply the same
+ * constant in their own code.) `ep-flush-<ts>-<id>.json` is the episode handed to the
+ * summarizer, not leftovers: the round-trip is up to ~60s, and deleting one mid-flight
+ * discards that episode's observations silently. An unreadable mtime counts as in-flight,
+ * because failing safe costs one stale file until the next sweep and failing open costs
+ * an episode.
+ *
+ * @returns {'stale'|'in-flight'}
+ */
+export function classifyEpisodeFile(
+  runtimeDir,
+  name,
+  { now = Date.now(), episodeAgeMs = ORPHAN_EPISODE_AGE_MS } = {},
+) {
+  let mtimeMs;
+  try {
+    mtimeMs = statSync(join(runtimeDir, name)).mtimeMs;
+  } catch {
+    return 'in-flight';
+  }
+  // `>=`, so a file aged exactly the gate is KEPT — the side hook-shared.mjs's sweep
+  // (deletes only `< cutoff`) and hook-llm.mjs (`>= cutoff` is live) already chose. `>`
+  // put the tie on cleanup's delete side, making the manual command the aggressive one.
+  return mtimeMs >= now - episodeAgeMs ? 'in-flight' : 'stale';
+}
+
+/**
+ * Count what `cleanup` would actually remove, split from what it would deliberately keep.
+ *
+ * `stale` is the number doctor may recommend cleanup for; `inFlight` is reported as a
+ * detail rather than a warning, because a file that is supposed to exist right now is not
+ * a fault. Note the asymmetry, which is deliberate and is NOT the age gate being applied
+ * inconsistently: update residue is guarded by install.lock in cleanup, not by age, so
+ * there is no age gate here for it to mirror.
+ *
+ * @returns {{stale: number, inFlight: number}}
+ */
+export function scanStaleTempFiles({ dataDir, runtimeDir, now = Date.now(), episodeAgeMs }) {
+  let stale = 0;
+  let inFlight = 0;
+
+  if (existsSync(dataDir)) {
+    for (const f of readdirSync(dataDir)) if (isUpdateResidue(f)) stale++;
+  }
+
+  if (existsSync(runtimeDir)) {
+    for (const f of readdirSync(runtimeDir)) {
+      if (!isEpisodeResidue(f)) continue;
+      if (classifyEpisodeFile(runtimeDir, f, { now, episodeAgeMs }) === 'in-flight') inFlight++;
+      else stale++;
+    }
+  }
+
+  return { stale, inFlight };
+}

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "claude-mem-lite",
-  "version": "6.10.3",
+  "version": "6.11.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "claude-mem-lite",
-      "version": "6.10.3",
+      "version": "6.11.0",
       "os": [
         "darwin",
         "linux",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "6.10.3",
+  "version": "6.11.0",
   "description": "Persistent long-term memory for Claude Code via MCP — captures coding decisions, bugfixes, and context across sessions. Hybrid FTS5 + TF-IDF search with episode batching. Single SQLite DB, no external services. A lighter, lower-cost alternative to claude-mem (episode batching + a smaller model; cost savings are an internal estimate, not a measured benchmark).",
   "type": "module",
   "packageManager": "npm@10.9.2",
@@ -74,6 +74,8 @@
     "lib/startup-dashboard.mjs",
     "lib/doctor-benchmark.mjs",
     "lib/doctor-drift.mjs",
+    "lib/doctor-hook-interpreter.mjs",
+    "lib/doctor-stale-temp.mjs",
     "lib/cli-project.mjs",
     "lib/stats-quality.mjs",
     "lib/low-signal-patterns.mjs",

package/secret-scrub.mjs

@@ -78,7 +78,7 @@ export const SECRET_PATTERNS = [
     /((?:\b|_)(?:password|passwd|passphrase)\s*:\s*)(?!process\.env\.)(?!new\s)(?!\w+\()(?!(?:null|undefined|true|false|None|nil|empty|""|''|0)\b)(?![A-Za-z]{1,15}(?=[\s,;'"}\]]|$))[^\s,;'"}\]]{6,}/gi,
     '$1***',
   ],
-  //   1c. `:` separator, prose-ambiguous nouns → keep the lookbehind ("the token: alice"):
+  //   1c. `:` separator, prose-ambiguous nouns → keep the lookbehind ("the token: alicebob"):
   [
     /((?<![A-Za-z][ \t])(?:\b|_)(?:token|bearer|secret)\s*:\s*)(?!process\.env\.)(?!new\s)(?!\w+\()(?!(?:null|undefined|true|false|None|nil|empty|""|''|0)\b)[^\s,;'"}\]]{6,}/gi,
     '$1***',
@@ -277,11 +277,71 @@ export const SECRET_PATTERNS = [
  * @param {string} text Input text potentially containing secrets
  * @returns {string} Text with secrets replaced by '***'
  */
+// ── D#52 / D#46: one sweep is not a fixed point ─────────────────────────────
+// Three patterns carry the prose lookbehind `(?<![A-Za-z][ \t])` — "preceded by
+// letter + horizontal space means English prose, leave it alone". That guard is
+// load-bearing (#8283 / round-4 / R5): `the token: alicebob` stays readable only
+// because of it, while `token: alicebob` is scrubbed. (Not `alice` — five characters
+// is under the value class's minimum of six, so that phrase is never scrubbed at all
+// and cannot show the guard doing anything.)
+// But a /g match CONSUMES its value, so the NEXT labelled keyword on the same
+// line is preceded by that value's last character plus a space. The lookbehind
+// cannot tell that from a word, so it skipped it: `token: <v> secret: <v>` left
+// the SECOND secret in plaintext. Replacing the first one rewrites that left
+// context to `*** `, and `*` is not [A-Za-z], which is why a second sweep caught
+// what the first missed — the same fact D#46 reported as non-idempotence.
+// The leak and the drift are one defect, and a fixed point closes both; the
+// idempotence is what cmdRestore's re-scrub of five EXPORT_COLUMNS needed.
+//
+// Cost is unchanged on real content: the loop's FIRST iteration is the sweep
+// that used to be the whole function, and text the scrubber does not modify
+// exits on the `===` right after it. Measured 2026-09-22 on the live corpus:
+// of the 287 NON-EMPTY values across text/subtitle/concepts/facts/search_aliases,
+// 0 are modified at all, so the common path pays one string comparison. (A first
+// draft of this line said "0 of 452"; 452 was the NOT-NULL count, ~39% of which
+// are empty strings that nothing could modify — the zero was true and the
+// denominator was not the population.)
+//
+// TERMINATION IS THE CAP, and saying anything stronger would be a guess. A first
+// draft of this comment argued it structurally — "`***` is 3 characters and every
+// value class requires at least 6, so a replacement can never become a new match".
+// Pre-ship review measured that and it is FALSE of six patterns whose value class
+// is `+` or `*`; two of them (the PEM block and the `postgres://` DSN) demonstrably
+// re-match their own `***` output. Convergence is fast in practice — 7 sweeps was
+// the maximum over 40 000 fuzzed inputs — but the only thing that BOUNDS this loop
+// is MAX_SCRUB_PASSES, so that is what the comment is allowed to claim.
+//
+// Convergence rate, stated with the shape it is a property of: N space-adjacent
+// secrets take N+1 sweeps only when each value ends in an ASCII LETTER, because
+// that is what re-arms the prose lookbehind for the next keyword. A value ending
+// in a digit does not re-arm it, so those converge in 2 regardless of N.
+//
+// Hitting the cap leaves labelled secrets unscrubbed past the 32nd, and that is
+// the deliberate choice. The earlier draft instead re-ran the three prose-guarded
+// patterns with the guard STRIPPED — which clears the remainder, and also applies
+// to the whole string rather than the un-converged region, so prose elsewhere in
+// the same input is redacted irreversibly on the write path. Pre-ship review
+// reproduced it: a 33-deep chain turned `Reset the password: instructions are in
+// the onboarding doc` into `Reset the password: *** are in…`, which is verbatim
+// the v3.61.0 regression lines 44-50 of this file record as already undone once.
+// Past the cap the function is also no longer idempotent — the property cmdRestore's
+// re-scrub relies on holds only below it — and a second call scrubs further, which
+// is the safe direction.
+// Reaching the cap needs a deliberately constructed ~447-byte adjacent chain;
+// corrupting prose needs only to be in the same string as one. Between a partial
+// scrub of a crafted credential dump and irreversible damage to a user's text,
+// this repo has twice decided the text matters more.
+const MAX_SCRUB_PASSES = 32;
+
 export function scrubSecrets(text) {
   if (!text || typeof text !== 'string') return text || '';
   let result = stripPrivate(text);
-  for (const [pattern, replacement] of SECRET_PATTERNS) {
-    result = result.replace(pattern, replacement);
+  for (let pass = 1; ; pass++) {
+    const before = result;
+    for (const [pattern, replacement] of SECRET_PATTERNS) {
+      result = result.replace(pattern, replacement);
+    }
+    if (result === before || pass >= MAX_SCRUB_PASSES) break;
   }
   return result;
 }

package/source-files.mjs

@@ -72,6 +72,8 @@ export const SOURCE_FILES = [
   'lib/startup-dashboard.mjs',
   'lib/doctor-benchmark.mjs',
   'lib/doctor-drift.mjs',
+  'lib/doctor-hook-interpreter.mjs',
+  'lib/doctor-stale-temp.mjs',
   // DB-aware project pick for terminal-invoked CLI commands. Statically imported by
   // mem-cli.mjs, cli/activity.mjs and cli/doctor.mjs — ship it or every CLI command
   // throws ERR_MODULE_NOT_FOUND in installed/tarball runtimes.