claude-mem-lite 6.6.0 → 6.7.0

package/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "6.6.0",
+      "version": "6.7.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.6.0",
+  "version": "6.7.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

@@ -549,7 +549,8 @@ node install.mjs install              # Install and configure
 node install.mjs uninstall            # Remove (keep data)
 node install.mjs uninstall --purge    # Remove and delete all data
 node install.mjs status               # Show current status
-node install.mjs doctor               # Diagnose issues
+node cli.mjs doctor                   # Diagnose issues  (cli.mjs, not install.mjs — see note)
+node cli.mjs repair                   # Recover a broken install from the latest signed release
 node install.mjs cleanup-hooks        # Remove only stale claude-mem-lite hooks from settings.json
 node install.mjs update               # Force-check for updates and install them (direct install / npx mode)
 
@@ -559,6 +560,13 @@ npx claude-mem-lite uninstall         # Remove (keep data)
 npx claude-mem-lite doctor            # Diagnose issues
 ```
 
+> `doctor` and `repair` are spelled `cli.mjs`, not `install.mjs`, on purpose. Those two are
+> the commands you reach for when the install is already broken, and `install.mjs` resolves
+> around a dozen static imports before its first line runs — one missing file and it exits
+> with a Node stack instead of telling you which file. `cli.mjs` has no static local imports
+> and catches that, naming the file and a repair command. Everything else in the list is
+> unaffected either way.
+
 Notes:
 - Plugin mode only reports available updates; it does not self-update plugin files.
   To upgrade an installed plugin to the latest published version, run **inside Claude Code**:
@@ -594,7 +602,7 @@ git fetch --tags && git checkout v3.62.0
 # 4. To leave the pin later: git checkout main, then the normal update flow.
 ```
 
-Your data directory (`~/.claude-mem-lite/`) is untouched by install/rollback; schema migrations are forward-only, so after rolling back more than one minor version check `node install.mjs doctor` before trusting search results.
+Your data directory (`~/.claude-mem-lite/`) is untouched by install/rollback; schema migrations are forward-only, so after rolling back more than one minor version check `node cli.mjs doctor` before trusting search results.
 
 ### doctor
 

package/README.zh-CN.md

@@ -461,7 +461,8 @@ node install.mjs install              # 安装并配置
 node install.mjs uninstall            # 移除（保留数据）
 node install.mjs uninstall --purge    # 移除并删除所有数据
 node install.mjs status               # 显示当前状态
-node install.mjs doctor               # 诊断问题
+node cli.mjs doctor                   # 诊断问题（用 cli.mjs 而非 install.mjs，见下方说明）
+node cli.mjs repair                   # 从最新签名发布恢复损坏的安装
 node install.mjs cleanup-hooks        # 只清理 settings.json 中残留的 claude-mem-lite hooks
 node install.mjs update               # 强制检查并安装更新（direct install / npx 模式）
 
@@ -472,6 +473,11 @@ npx claude-mem-lite doctor            # 诊断问题
 ```
 
 说明：
+- `doctor` 与 `repair` 写成 `cli.mjs` 而不是 `install.mjs`，是有意的。这两条恰恰是安装
+  已经坏掉时才会用到的命令，而 `install.mjs` 在执行第一行代码之前要解析十几个静态
+  import——少一个文件就直接吐一段 Node 栈，而不是告诉你少了哪个文件。`cli.mjs` 没有
+  任何本地静态 import，会捕获这种失败并说出缺失的文件和修复命令。列表中其余命令两种
+  写法都一样。
 - 插件模式只提示可用更新，不会自更新插件文件。
 - direct install / npx 模式保留自动更新，并使用 staged replacement；若依赖安装失败会回滚。
 - 如果你禁用了插件，但 `~/.claude/settings.json` 里还有旧的 mem hooks，可运行 `node install.mjs cleanup-hooks`。

package/cli.mjs

@@ -30,6 +30,77 @@ const CLI_COMMANDS = new Set([
 // Kept as a named set so a stale script or muscle-memory invocation gets the reason rather
 // than a bare "Unknown command" plus a misleading edit-distance suggestion.
 const REMOVED_COMMANDS = new Set(['registry', 'import', 'enrich']);
+
+// D#26 / R12 P1-1, second half. `doctor` and `repair` exist to tell a user which
+// file their install is missing. Until now, on exactly that install, they did not
+// run: install.mjs's ~13 static imports resolve BEFORE its first line executes, so
+// one absent module killed the command with a bare ERR_MODULE_NOT_FOUND and zero
+// bytes of stdout. A half-finished update, a trimmed tarball (this repo has
+// shipped three) or a hand-deleted file all land there — CLAUDE.md's "a recovery
+// path must not import the thing it recovers", on the startup edge.
+//
+// A static import cannot be caught inside the module that declares it, so the
+// catch lives one entry up. THIS file is the host because it is the published
+// `bin` and because its own static closure is one file — itself; every route
+// below is an `await import()`. Whatever this prints must therefore rely on
+// nothing but the language, the same charter scripts/hook-launcher.mjs follows:
+// no local import may appear here, or the fallback shares the fate it reports on.
+//
+// The remedy is deliberately NOT `install.mjs repair` — that is the file that
+// would not load. It has to come from outside the broken tree.
+// THREE shapes, not one. The first cut caught only ERR_MODULE_NOT_FOUND, and pre-ship
+// review pointed out that an interrupted write leaves a file PRESENT and truncated far
+// more often than it leaves it absent: that arrives as a SyntaxError, and a truncated
+// install.mjs arrives as neither — the module loads and simply has no `main`, which
+// died at the call site with "main is not a function". All three are the same fact
+// about the world (this install's files are not intact) and get the same answer.
+// Anything else is rethrown: this is a classifier, not a swallow.
+function explainBrokenInstall(what) {
+  const w = (s) => process.stderr.write(`[claude-mem-lite] ${s}\n`);
+  w(`This install is incomplete — ${what}`);
+  w('That is why this command cannot run: these files load before any of their code executes.');
+  w('Repair: npm install -g claude-mem-lite@latest --force');
+  w('Or, in Claude Code: /plugin uninstall claude-mem-lite && /plugin install claude-mem-lite@sdsrss');
+  process.exit(1);
+}
+
+/**
+ * Absolute path out of an error that carries one, or null.
+ *
+ * ERR_MODULE_NOT_FOUND carries `url`. An ESM SyntaxError carries NOTHING —
+ * measured on Node 26: `url` and `code` both undefined, message a bare
+ * "Unexpected end of input", every stack frame a node-internal loader. So the
+ * caller must be able to say its piece without a filename rather than printing
+ * "undefined", and naming the damaged file would take a `node --check` scan of
+ * the install, which is a bigger thing than this line.
+ */
+function fileFromError(e) {
+  const m = String(e?.url || e?.stack || e?.message || '').match(/file:\/\/(\/[^\s:)'"]+)/);
+  if (m) return m[1];
+  const quoted = String(e?.message || '').match(/'([^']+\.mjs)'/);
+  return quoted ? quoted[1] : null;
+}
+
+async function loadInstaller() {
+  let mod;
+  try {
+    mod = await import('./install.mjs');
+  } catch (e) {
+    if (e?.code === 'ERR_MODULE_NOT_FOUND') {
+      explainBrokenInstall(`it is missing: ${fileFromError(e) || 'a module'}`);
+    }
+    // Never reprint the parser's own output: the stack is what this exists to replace.
+    if (e instanceof SyntaxError) {
+      const at = fileFromError(e);
+      explainBrokenInstall(`this file is damaged or truncated: ${at || 'one of its modules'}`);
+    }
+    throw e;
+  }
+  if (typeof mod?.main !== 'function') {
+    explainBrokenInstall('install.mjs loaded but exports no `main` — it is truncated');
+  }
+  return mod;
+}
 const INSTALL_COMMANDS = new Set([
   'install',
   'uninstall',
@@ -90,11 +161,11 @@ if (cmd === '--version' || cmd === '-v' || cmd === '-V' || cmd === 'version') {
     const { run } = await import('./mem-cli.mjs');
     await run(['help']);
   } else {
-    const { main } = await import('./install.mjs');
+    const { main } = await loadInstaller();
     await main([]);
   }
 } else if (INSTALL_COMMANDS.has(cmd)) {
-  const { main } = await import('./install.mjs');
+  const { main } = await loadInstaller();
   await main(process.argv.slice(2));
 } else if (REMOVED_COMMANDS.has(cmd)) {
   // Released-artifact discoverability signal for the skill-registry removal. Deliberately

package/install.mjs

@@ -1799,6 +1799,17 @@ async function doctor() {
   // another tree's schema.mjs would poison the process that must report the answer. It is
   // also why this check is USEFUL TODAY rather than only after the next upgrade — doctor
   // runs from whichever tree the user invoked, so new code here can diagnose an old cache.
+  // Hoisted out of the branch below because two LATER checks have to honour it. The
+  // verdict is "this install cannot safely touch that file"; a verdict nothing
+  // downstream reads is a sentence, not a gate (R12 audit, partition C P2-5).
+  //
+  // Two variables, because the two consumers ask different questions. `dbWriteBlocked`
+  // is about SAFETY — may this process open the file read-write — and carries its own
+  // reason so the line it gates is true. `dbUnusableHere` is about HONESTY — may this
+  // screen put a ✓ on a store this install cannot use. A read that succeeds on a
+  // too-new file is still a real number; a checkmark on it is not.
+  let dbWriteBlocked = null;
+  let dbUnusableHere = false;
   if (!existsSync(DB_PATH)) {
     ok('DB schema: no database yet — nothing to compare');
   } else if (rootProbes.length === 0) {
@@ -1810,6 +1821,31 @@ async function doctor() {
     const compat = probeSchemaCompat(shape.runtimeRoots, DB_PATH);
     const behind = compat.filter((c) => c.status === 'skew');
     const unknown = compat.filter((c) => c.status === 'unknown');
+    // Ask about the tree THIS process runs from, not about the machine.
+    // probeSchemaCompat probes every code home on purpose — its docblock says so:
+    // "so a report can NAME the one that is behind instead of asserting something
+    // global about 'the install'". The first cut of this gate read `behind.length > 0`
+    // and then printed "this install", which is the assertion that docblock exists to
+    // prevent. On the shape this whole check was built for — a current npm-global CLI
+    // beside a stale plugin cache, reached routinely per the rationale above — the
+    // running process can read and write the store perfectly well, and gating on any
+    // home withheld checkFTSIntegrity + rebuildFTS, doctor's ONLY non-destructive DB
+    // repair, from the machine most likely to need it. Found in pre-ship review.
+    //
+    // `unknown` blocks the write too, and says so in its own words: the probe could
+    // not get both numbers, and "I could not tell" is not "safe to write". The three
+    // outcomes stay three, the way the schema check above already keeps them.
+    const self = compat.find((c) => c.root === PROJECT_DIR);
+    if (!self) {
+      dbWriteBlocked = 'could not identify the install this command is running from';
+    } else if (self.status === 'skew') {
+      dbWriteBlocked =
+        `this database (v${self.dbVersion}) is newer than the install you are running, ` +
+        `which supports up to v${self.supported}`;
+      dbUnusableHere = true;
+    } else if (self.status === 'unknown') {
+      dbWriteBlocked = 'could not determine whether the install you are running can read this database';
+    }
     if (behind.length === 0 && unknown.length === 0) {
       ok(`DB schema: v${compat[0]?.dbVersion} — readable by all ${compat.length} install(s)`);
     }
@@ -1900,8 +1936,12 @@ async function doctor() {
     } catch {
       /* unreadable marker → bare warning */
     }
+    // cli.mjs, matching hook-launcher.mjs's CLI_REPAIR and the two remedies further
+    // down: this check FIRES because something about the install is already
+    // misbehaving, which is the worst moment to hand out the one entry that cannot
+    // survive a missing module. Pre-ship review of v6.7.0 caught this one left behind.
     dwarn(
-      `Hook self-heal: a recent hook fire degraded to exit-0${detail} — run \`node ${join(PROJECT_DIR, 'install.mjs')} repair\``,
+      `Hook self-heal: a recent hook fire degraded to exit-0${detail} — run \`node ${join(PROJECT_DIR, 'cli.mjs')} repair\``,
     );
   } else {
     ok('Hook self-heal: no recent silent hook breakage');
@@ -2113,30 +2153,44 @@ async function doctor() {
       if (fts) {
         ok('FTS5 index: present');
         // FTS5 integrity check (requires read-write access for INSERT INTO fts VALUES('integrity-check'))
-        try {
-          const { checkFTSIntegrity, rebuildFTS } = await import('./schema.mjs');
-          const rwDb = new Database(DB_PATH);
-          rwDb.pragma('busy_timeout = 3000');
+        if (dbWriteBlocked) {
+          // Everything past this point wants a WRITE handle on a file this install
+          // has just been told it is too old to write — which is the exact way a
+          // store gets locked out for good. The rebuild below is gated by sitting
+          // inside this else, not by a second condition that could drift from it.
+          //
+          // dwarn rather than silence, and the REASON is interpolated rather than
+          // assumed: "I could not look" and "I looked and it is fine" have to stay
+          // distinguishable, and so does "I did not look, and here is which of the
+          // three reasons applies" — a line that names the wrong reason ends the
+          // reader's search just as a false green does.
+          dwarn(`FTS5 integrity: not checked — ${dbWriteBlocked}`);
+        } else {
           try {
-            const { healthy, details } = checkFTSIntegrity(rwDb);
-            if (healthy) {
-              ok('FTS5 integrity: all indexes healthy');
-            } else {
-              dwarn('FTS5 integrity issues detected:');
-              for (const d of details) log(`    ${d}`);
-              log('  Attempting FTS5 rebuild...');
-              const { rebuilt, errors } = rebuildFTS(rwDb);
-              if (rebuilt.length > 0) ok(`FTS5 rebuilt: ${rebuilt.join(', ')}`);
-              if (errors.length > 0) {
-                fail(`FTS5 rebuild errors: ${errors.join(', ')}`);
-                issues++;
+            const { checkFTSIntegrity, rebuildFTS } = await import('./schema.mjs');
+            const rwDb = new Database(DB_PATH);
+            rwDb.pragma('busy_timeout = 3000');
+            try {
+              const { healthy, details } = checkFTSIntegrity(rwDb);
+              if (healthy) {
+                ok('FTS5 integrity: all indexes healthy');
+              } else {
+                dwarn('FTS5 integrity issues detected:');
+                for (const d of details) log(`    ${d}`);
+                log('  Attempting FTS5 rebuild...');
+                const { rebuilt, errors } = rebuildFTS(rwDb);
+                if (rebuilt.length > 0) ok(`FTS5 rebuilt: ${rebuilt.join(', ')}`);
+                if (errors.length > 0) {
+                  fail(`FTS5 rebuild errors: ${errors.join(', ')}`);
+                  issues++;
+                }
               }
+            } finally {
+              rwDb.close();
             }
-          } finally {
-            rwDb.close();
+          } catch (e) {
+            dwarn('FTS5 integrity check failed: ' + e.message);
           }
-        } catch (e) {
-          dwarn('FTS5 integrity check failed: ' + e.message);
         }
       } else {
         dwarn('FTS5 index: missing (will be created on server start)');
@@ -2340,7 +2394,7 @@ async function doctor() {
       warn(
         `Managed files: ${r.missingCount} missing (${parts.join('; ')}) — a copy install resolves ` +
           `imports against the install dir, so these throw at hook time. Fix: claude-mem-lite self-update ` +
-          `(or: node ${join(INSTALL_DIR, 'install.mjs')} repair)`,
+          `(or: node ${join(INSTALL_DIR, 'cli.mjs')} repair)`,
       );
       issues++;
     }
@@ -2361,7 +2415,11 @@ async function doctor() {
     const skipScripts = !shape.managed && !!shape.activePluginVersion;
     const { checkHookScriptDrift, HOOK_SCRIPT_ENTRY_POINTS } = await import('./lib/doctor-drift.mjs');
     const h = skipScripts ? null : checkHookScriptDrift(INSTALL_DIR, HOOK_SCRIPT_FILES);
-    const scriptRemedy = `claude-mem-lite self-update (or: node ${join(INSTALL_DIR, 'install.mjs')} repair)`;
+    // cli.mjs, not install.mjs: the reader of this line has an install that is
+    // missing files, and install.mjs is the one entry that cannot survive that —
+    // its static imports resolve before its first statement. cli.mjs has no static
+    // local imports and catches the failure (D#26). Same route, same command.
+    const scriptRemedy = `claude-mem-lite self-update (or: node ${join(INSTALL_DIR, 'cli.mjs')} repair)`;
     if (skipScripts) {
       ok('Hook scripts: n/a (plugin-only install — hooks run from the plugin cache)');
     } else if (!h.present) {
@@ -2499,7 +2557,15 @@ async function doctor() {
       // Align with stats / MCP mem_stats: session_summaries, not sdk_sessions
       const sessCount = db.prepare('SELECT COUNT(*) as cnt FROM session_summaries').get()?.cnt || 0;
       db.close();
-      ok(`DB stats: ${sizeMB}MB, ${obsCount} observations, ${sessCount} sessions`);
+      const stats = `DB stats: ${sizeMB}MB, ${obsCount} observations, ${sessCount} sessions`;
+      // The read succeeds on a too-new file — the tables are still there — so this
+      // line printed a ✓ about a store the screen had already called unusable two
+      // checks up. The numbers are real and worth showing; the checkmark is not.
+      // Keyed on dbUnusableHere, not on dbWriteBlocked: "I could not confirm this
+      // install can read the DB" is not grounds to tell the user it cannot.
+      if (dbUnusableHere)
+        dwarn(`${stats} — but the install you are running cannot use this database (see DB schema above)`);
+      else ok(stats);
     } catch (e) {
       dwarn('DB stats: ' + e.message);
     }

package/lib/file-edge-match.mjs

@@ -44,6 +44,10 @@
 // so the split is inlined below rather than imported. utils.mjs used to export the
 // same two lines as `basenameAnySep`; that copy was deleted in the same round once
 // its only consumer went, so this file is now the sole home.
+//
+// The one import below does not cost that: project-utils.mjs is a leaf over
+// `node:path`, and pre-tool-recall.js already imports it for inferProject.
+import { likeLiteral } from '../project-utils.mjs';
 
 /**
  * SQL boolean expression for the four-arm match. Placeholder order matches
@@ -72,10 +76,39 @@ export function basenameAnySep(p) {
   return s.slice(Math.max(s.lastIndexOf('/'), s.lastIndexOf('\\')) + 1);
 }
 
+/**
+ * This module had its own `likeLiteral` for one commit, and the comment justifying
+ * the duplication was wrong twice running — first "THE only copy in the repo" (it
+ * was not; project-utils.mjs has had one since R10 P2-3), then "project-utils.mjs
+ * pulls a DB handle's worth of graph behind it" (it does not: it imports
+ * `node:path` and nothing else, its own header calls it a leaf, and
+ * scripts/pre-tool-recall.js — the cold-start script the excuse was built around —
+ * already imports it). Both were caught in review rather than by measuring first.
+ *
+ * So it is imported, per this file's own rule about basenameAnySep one docblock up:
+ * a second copy is exactly what produced R12 B-1.
+ */
+
+/**
+ * LIKE needle for one element of a JSON-array TEXT column (`events.file_paths`),
+ * to be wrapped as `%"<needle>"%` and run under `ESCAPE '\'`.
+ *
+ * TWO escapes compose here and the order is not interchangeable. The column holds
+ * `JSON.stringify(paths)`, so a win32 separator is already TWO characters on disk
+ * (`C:\\proj`); the LIKE escape then has to double each of those again to mean two
+ * literal backslashes. Skipping the JSON step is the trap: it looks fixed, because
+ * on POSIX `JSON.stringify` of a path is the identity, so every non-Windows test
+ * stays green either way. Measured on `:memory:` against a real stored row —
+ * shipped = 0 rows, LIKE-escape alone = 0 rows, JSON-then-LIKE = 1 row.
+ */
+export function jsonArrayLikeNeedle(s) {
+  return likeLiteral(JSON.stringify(String(s ?? '')).slice(1, -1));
+}
+
 /** Bind values for fileMatchClause, in placeholder order. */
 export function fileMatchParams(filePath) {
   const fname = basenameAnySep(filePath);
-  const escaped = fname.replace(/%/g, '\\%').replace(/_/g, '\\_');
+  const escaped = likeLiteral(fname);
   // `%\\` before the basename: under ESCAPE '\', a literal backslash is
   // written '\\' — so the JS string carries two backslash characters.
   return [filePath, fname, `%/${escaped}`, `%\\\\${escaped}`];

package/lib/hook-stdin.mjs

@@ -67,7 +67,11 @@ export function salvageTruncatedHookEvent(prefix) {
   // one, which still exits 0 but writes a `pre-recall:top` telemetry row: the same
   // hook-error noise the caller split `pre-recall:json` away from. 4096 is far above any
   // real path (PATH_MAX is 4096 on Linux, 1024 on macOS), so no reachable payload is lost.
-  const fp = prefix.match(/"file_path"\s*:\s*"((?:[^"\\]|\\.){0,4096})"/);
+  // Both spellings, because the caller accepts both: NotebookEdit carries
+  // `notebook_path` and never `file_path`, so a truncated notebook payload would
+  // otherwise salvage nothing while the untruncated one recalls fine — the same
+  // half-covered shape as R12 B-2, one path over.
+  const fp = prefix.match(/"(?:file_path|notebook_path)"\s*:\s*"((?:[^"\\]|\\.){0,4096})"/);
   if (!fp) return null;
   let filePath;
   // The captured group is still JSON-escaped (Windows paths arrive as `C:\\x`).

package/npm-shrinkwrap.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "6.6.0",
+  "version": "6.7.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",

package/project-utils.mjs

@@ -72,11 +72,20 @@ export function projectNameFromDir(p) {
   return raw.replace(/[^a-zA-Z0-9_.-]/g, '-').slice(0, 100);
 }
 
-/** Escape LIKE metacharacters so a caller-supplied name is matched literally.
+/** Escape LIKE metacharacters so a caller-supplied value is matched literally.
  *  R10 P2-3: unescaped, `--project '%'` matched every project and ORDER BY COUNT(*)
- *  returned the biggest one; `_` matched any single character the same way. */
-function likeLiteral(s) {
-  return s.replace(/[\\%_]/g, '\\$&');
+ *  returned the biggest one; `_` matched any single character the same way.
+ *
+ *  THE only copy in the repo, and it lives here because this module is a leaf over
+ *  `node:path` alone — the ~30 ms cold-start hook scripts already import it, so the
+ *  shared home costs them nothing. `lib/file-edge-match.mjs` imports it rather than
+ *  keeping the second copy it had: that second copy escaped `%` and `_` and not the
+ *  escape character, which is the whole of R12 B-1. Backslash first is not optional —
+ *  under `ESCAPE '\'` SQLite reads `\` + any character as that character taken
+ *  literally, so an un-doubled backslash is consumed and the pattern silently stops
+ *  matching the string it was built from. */
+export function likeLiteral(s) {
+  return String(s ?? '').replace(/[\\%_]/g, '\\$&');
 }
 
 /**

package/scripts/post-tool-recall.js

@@ -54,7 +54,12 @@ async function main() {
   let filePath, sessionId;
   try {
     const e = JSON.parse(input);
-    filePath = e.tool_input?.file_path;
+    // Both spellings — this file's PostToolUse matcher includes NotebookEdit, whose
+    // schema has `notebook_path` and no `file_path`. The PreToolUse twin got this in
+    // v6.7.0 and this leg did not, which is the repo's most repeated failure shape:
+    // a fix that closes ONE of the inputs reaching the same line. Caught in pre-ship
+    // review of that very round.
+    filePath = e.tool_input?.file_path ?? e.tool_input?.notebook_path;
     sessionId = e.session_id || null;
   } catch {
     return;

package/scripts/pre-tool-recall.js

@@ -20,7 +20,12 @@ import { buildNotLowSignalSql } from '../lib/low-signal-patterns.mjs';
 import { recordHookError } from '../lib/hook-telemetry.mjs';
 import { cooldownPathFor as sharedCooldownPathFor } from '../lib/cooldown-path.mjs';
 import { citeFactorClause } from '../scoring-sql.mjs';
-import { fileMatchClause, fileMatchParams, basenameAnySep } from '../lib/file-edge-match.mjs';
+import {
+  fileMatchClause,
+  fileMatchParams,
+  basenameAnySep,
+  jsonArrayLikeNeedle,
+} from '../lib/file-edge-match.mjs';
 import { fileIntelFor } from '../lib/file-intel.mjs';
 import { shouldWarnReread, buildRereadWarning, readFileMeta } from '../lib/reread-guard.mjs';
 import { recordMetric } from '../lib/metrics.mjs';
@@ -96,6 +101,23 @@ import { DEDUP_STALE_MS as CROSS_HOOK_DEDUP_MS } from './prompt-search-utils.mjs
 // failure ALGO-4 exists to fix. The cap is right (an unbounded LIMIT is worse), the
 // reassurance was wrong.
 const CROSS_HOOK_DEDUP_SLACK_MAX = 5;
+// The tools this script claims to handle. FOUR surfaces carry this list — the
+// comment said three until review counted again, which is the second time in one
+// round that an enumeration here was written from memory:
+//   1. hooks/hooks.json's PreToolUse matcher for this script
+//   2. its settings.json twin at install.mjs:1064
+//   3. this constant
+//   4. benchmark/efficacy-harness.mjs, which builds its own settings.json
+// (install.mjs:975 looks like a fifth and is not — different matcher, for
+// post-tool-recall.js.)
+//
+// Drift between any two is invisible at runtime. Two guards chain to cover 1-3:
+// tests/hooks-pretool-whitelist-sync.test.mjs pins hooks.json against this
+// constant, and tests/audit-silent-20260814.test.mjs diffs hooks.json against the
+// install.mjs twin — hooks.json is the hub and neither spoke can drift alone.
+// Surface 4 is covered by NEITHER: it is a benchmark harness, so drift there
+// silently changes what the benchmark measures rather than what users get.
+const HANDLED_TOOLS = ['Edit', 'Write', 'NotebookEdit', 'Read'];
 // v2.33.1: cooldown path is session-scoped so same-file-twice within one
 // session never re-injects (was: global file, 5-min window). Cross-session:
 // fresh file, fresh nudges — this is intended. No session_id → fall back to
@@ -379,7 +401,12 @@ try {
   try {
     const event = JSON.parse(input);
     toolInput = event.tool_input;
-    filePath = event.tool_input?.file_path;
+    // NotebookEdit is in our matcher but has no `file_path`: its schema is
+    // { notebook_path, cell_id, cell_type, edit_mode, new_source } with
+    // additionalProperties:false. Reading only `file_path` made this hook a
+    // no-op on every .ipynb edit (R12 audit, partition B-2). utils.mjs's
+    // `case 'NotebookEdit'` already knew the shape differs; this leg did not.
+    filePath = event.tool_input?.file_path ?? event.tool_input?.notebook_path;
     sessionId = event.session_id || null;
     toolName = event.tool_name || null;
     const off = event.tool_input?.offset;
@@ -400,17 +427,31 @@ try {
   }
 
   // Upstream-shape probe: hook ran but neither field nor input shape matches the
-  // contract we encode (event.tool_input.file_path, event.tool_name in
-  // Edit|Write|NotebookEdit|Read). Distinguishes "Claude Code renamed the field"
-  // from "event genuinely has no file_path" — without this trace, a CC upstream
-  // rename silently zeroes injection like code-graph's matcher bug.
+  // contract we encode (a path field on event.tool_input, event.tool_name in
+  // HANDLED_TOOLS). Distinguishes "Claude Code renamed the field" from "event
+  // genuinely has no path" — without this trace, a CC upstream rename silently
+  // zeroes injection like code-graph's matcher bug.
+  //
+  // The whitelist used to double as a SILENCE list, and that inverted the probe:
+  // a rename can only ever show up on a tool we handle, so the one population
+  // carrying the signal was the one population it declined to record. That is how
+  // NotebookEdit ran 100% dead and unobservable (R12 audit, partition B-2) — the
+  // probe written to catch exactly this had the tool in its whitelist. Each
+  // outcome now gets its own scope so the populations stay separable in the log.
   if (!filePath) {
-    if (toolName && !['Edit', 'Write', 'NotebookEdit', 'Read'].includes(toolName)) {
+    if (!toolName) {
+      recordHookError('pre-recall:no-toolname', new Error('event missing tool_name'), RUNTIME_DIR);
+    } else if (HANDLED_TOOLS.includes(toolName)) {
+      recordHookError(
+        'pre-recall:no-path-field',
+        new Error(`tool_name=${toolName} carried no known path field`),
+        RUNTIME_DIR,
+        { toolName, inputKeys: Object.keys(toolInput || {}).slice(0, 12) },
+      );
+    } else {
       recordHookError('pre-recall:unknown-tool', new Error(`tool_name=${toolName}`), RUNTIME_DIR, {
         toolName,
       });
-    } else if (!toolName) {
-      recordHookError('pre-recall:no-toolname', new Error('event missing tool_name'), RUNTIME_DIR);
     }
     process.exit(0);
   }
@@ -497,8 +538,10 @@ try {
     // Windows-shaped payload. Fixing the observations leg alone would have left this
     // hook recalling lessons but no events.
     const fname = basenameAnySep(filePath);
-    // Escape LIKE wildcards (still needed below for the events file_paths arms)
-    const escaped = fname.replace(/%/g, '\\%').replace(/_/g, '\\_');
+    // Needle for the events leg's JSON-array column — see jsonArrayLikeNeedle for
+    // why the JSON escape has to run before the LIKE one. The observations leg
+    // below matches a plain column and gets its params from fileMatchParams.
+    const basenameNeedle = jsonArrayLikeNeedle(fname);
     // P0 (D#78): path-boundary match — editing utils.mjs must NOT pull lessons
     // stored under bash-utils.mjs (the old '%<basename>' suffix LIKE did).
     // Clause + params come from lib/file-edge-match.mjs, byte-shared with the
@@ -608,7 +651,7 @@ try {
     // patterns match both basename and full-path entries. JSON quoting
     // (`"<name>"`) prevents partial-match false positives like "foo.mjs"
     // matching "myfoo.mjs".
-    const filePathEscaped = filePath.replace(/%/g, '\\%').replace(/_/g, '\\_');
+    const fullPathNeedle = jsonArrayLikeNeedle(filePath);
     // v2.34.6: Read also tightens the events query — only rows with a non-empty
     // body (= lesson equivalent). Edit path keeps a wider net, but P0 (D#78)
     // closes the parallel-path drift vs the observations query: a bodyless row
@@ -643,7 +686,7 @@ try {
         LIMIT ${eventsLimit}
       `,
         )
-        .all(project, cutoff, `%"${escaped}"%`, `%"${filePathEscaped}"%`);
+        .all(project, cutoff, `%"${basenameNeedle}"%`, `%"${fullPathNeedle}"%`);
     } catch {
       /* events table may not exist on pre-v2.31 DBs — silent */
     }

package/scripts/user-prompt-search.js

@@ -596,14 +596,15 @@ function searchRecent(db, project, limit) {
 // 256 KB full-payload tier hook.mjs uses — both tiers live in utils.mjs (G19) — because the
 // payload here is a user PROMPT, not a tool response. `rejectOnTimeout` matches the previous
 // behaviour: the caller treats a timeout as "skip the injection".
-// Returns a bare string, as this script's callers expect.
+// Returns readHookStdin's `{ text, truncated }` whole: the caller records `truncated`
+// in its telemetry, and that flag is the difference between "the user sent malformed
+// JSON" and "we cut their prompt in half" (R12 B-3). It used to return a bare string.
 async function readStdin() {
-  const { text } = await readHookStdin({
+  return readHookStdin({
     timeoutMs: 2000,
     maxBytes: MAX_UPS_PROMPT_BYTES,
     rejectOnTimeout: true,
   });
-  return text;
 }
 
 // ─── Format Output ──────────────────────────────────────────────────────────
@@ -653,17 +654,34 @@ async function main() {
   // Prevent recursion from background claude -p calls
   if (process.env.CLAUDE_MEM_HOOK_RUNNING) return;
 
+  // Both swallows below record first. They were this file's only silent ones, and
+  // they sit on the *entry* of the face: past MAX_UPS_PROMPT_BYTES the read hands
+  // back a truncated prefix, JSON.parse throws, the face goes dark, and every
+  // health surface — `stats`, `doctor` — reads zero errors. Measured three arms
+  // back-to-back at 318 B / 61 760 B / 72 000 B: only the third one vanished, so
+  // what is lost is the prompt that pasted a large log, which is exactly the
+  // prompt an error-signature recall is most useful on (R12 audit, partition B-3).
   let raw;
+  // No initializer: the parse catch below is reachable only after the destructure
+  // above succeeded, so every read of this is an assigned one.
+  let truncated;
   try {
-    raw = await readStdin();
-  } catch {
+    ({ text: raw, truncated } = await readStdin());
+  } catch (e) {
+    recordHookError('ups:stdin', e, RUNTIME_DIR, { stage: 'read' });
     return;
   }
 
   let hookData;
   try {
     hookData = JSON.parse(raw);
-  } catch {
+  } catch (e) {
+    recordHookError('ups:stdin', e, RUNTIME_DIR, {
+      stage: 'parse',
+      inputLen: raw?.length ?? 0,
+      truncated,
+      capBytes: MAX_UPS_PROMPT_BYTES,
+    });
     return;
   }
   // JSON.parse('null'/'42'/'"x"') succeeds with a non-object; dereferencing .prompt on