claude-mem-lite 6.13.1 → 6.13.3

package/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "6.13.1",
+      "version": "6.13.3",
       "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.13.1",
+  "version": "6.13.3",
   "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

@@ -249,7 +249,8 @@ the database, so reverting is pinning `claude-mem-lite@6.12.2`.
 
 **Citation readings drop at this version, and that is a measurement change.** A lesson the
 agent answers with `#NN n/a` is no longer counted as cited, so `citation-stats` per-face rates
-read lower from here on. Do not compare a reading taken before 6.13.0 with one taken after.
+read lower from here on (`--sidechain` excepted: it counts an `n/a` as an answer). Do not compare
+a reading taken before 6.13.0 with one taken after.
 
 ## Upgrading to 6.11.0
 

package/README.zh-CN.md

@@ -208,7 +208,7 @@ rm -rf ~/claude-mem-lite/   # v0.5 前的非隐藏目录（如未自动迁移）
 仍能打开数据库，回退就是固定到 `claude-mem-lite@6.12.2`。
 
 **引用率读数会从这个版本起下降，这是口径变化。** agent 用 `#NN n/a` 回应的 lesson 不再计为引用，
-所以 `citation-stats` 各注入面的引用率从此偏低。不要拿 6.13.0 之前和之后的读数直接比较。
+所以 `citation-stats` 各注入面的引用率从此偏低（`--sidechain` 除外：它把 `n/a` 算作已回应）。不要拿 6.13.0 之前和之后的读数直接比较。
 
 ## 升级到 6.11.0
 

package/bash-utils.mjs

@@ -62,6 +62,7 @@ const GIT_READ_SUBCMDS = new Set([
   'shortlog',
   'reflog',
   'status',
+  'rev-parse',
 ]);
 
 // Hard failure fingerprints — a real crash / thrown exception / non-zero-exit marker,
@@ -92,32 +93,320 @@ const NEUTRAL_VERBS = new Set([
   'export',
   'set',
   'exit',
+  // Print a path or a date; used inside `$(…)` to build a read's arguments.
+  'pwd',
+  'date',
+  'basename',
+  'dirname',
+  'realpath',
+  'readlink',
 ]);
 
+// code-graph-mcp subcommands that only query the index (plus `snapshot inspect`, handled in
+// WRITES_OR_RUNS). The rest (serve, the index rebuilds, doctor's repairs, benchmark,
+// adopt / unadopt / uninstall, snapshot create) run work whose failures error-recall should see.
+const CODE_GRAPH_READ_SUBCMDS = new Set([
+  'grep',
+  'search',
+  'ast-search',
+  'callgraph',
+  'impact',
+  'affected',
+  'show',
+  'map',
+  'tour',
+  'overview',
+  'deps',
+  'trace',
+  'similar',
+  'refs',
+  'dead-code',
+  'centrality',
+  'cycles',
+  'surprising',
+  'report',
+  'health-check',
+  'stats',
+  'outcome',
+  'help',
+  '--help',
+  '--version',
+]);
+
+// Forms of a SEARCH_VERBS verb that write a file or run a program, so their output is not
+// file content (v6.13.0 defect review P3-5). Args are the whitespace tokens after the verb;
+// quotes are not stripped, which only matters for a flag written inside quotes.
+const WRITES_OR_RUNS = {
+  sed: (args) => args.some((a) => /^-[A-Za-z]*i/.test(a) || a.startsWith('--in-place')),
+  sort: (args) => args.some((a) => /^-[A-Za-z]*o/.test(a) || a.startsWith('--output')),
+  // `-f` reads the program from a file (or a heredoc on stdin) this check cannot see.
+  awk: (args, text) =>
+    args.some((a) => /^-f/.test(a) || a.startsWith('--file')) ||
+    /\bsystem\s*\(|\|\s*(?:getline\b|")|\|&/.test(text),
+  find: (args) => args.some((a) => /^-(?:exec|execdir|ok|okdir|delete|fprint0?|fprintf|fls)$/.test(a)),
+  'code-graph-mcp': (args) =>
+    !CODE_GRAPH_READ_SUBCMDS.has(args[0]) && !(args[0] === 'snapshot' && args[1] === 'inspect'),
+};
+
 /** 'read' | 'neutral' | 'other' for one simple command (one element of a pipeline). */
 function classifySimpleCommand(text) {
-  const toks = text.trim().split(/\s+/).filter(Boolean);
+  const toks = shellWords(text);
   let i = 0;
   while (i < toks.length && (/^\w+=/.test(toks[i]) || CMD_WRAPPERS.has(toks[i]))) i++;
   const first = toks[i];
   if (!first || NEUTRAL_VERBS.has(first)) return 'neutral';
-  if (SEARCH_VERBS.has(first)) return 'read';
+  if (SEARCH_VERBS.has(first)) return WRITES_OR_RUNS[first]?.(toks.slice(i + 1), text) ? 'other' : 'read';
   return first === 'git' && GIT_READ_SUBCMDS.has(toks[i + 1]) ? 'read' : 'other';
 }
 
+/**
+ * Split one simple command into words on whitespace OUTSIDE quotes, so `x="a b" grep …`
+ * stays an assignment followed by grep (v6.13.2 delta review FALSE-2). Quotes are kept in
+ * the words; only the split point is quote-aware.
+ */
+function shellWords(text) {
+  const words = [];
+  let cur = '';
+  let inWord = false;
+  let quote = null;
+  for (let k = 0; k < text.length; k++) {
+    const ch = text[k];
+    if (quote) {
+      if (ch === '\\' && quote !== "'") {
+        cur += ch + (text[k + 1] ?? '');
+        k++;
+        continue;
+      }
+      if (ch === quote[quote.length - 1]) quote = null;
+      cur += ch;
+      continue;
+    }
+    if (/\s/.test(ch)) {
+      if (inWord) words.push(cur);
+      cur = '';
+      inWord = false;
+      continue;
+    }
+    inWord = true;
+    if (ch === '\\') {
+      cur += ch + (text[k + 1] ?? '');
+      k++;
+      continue;
+    }
+    if (ch === '$' && text[k + 1] === "'") {
+      quote = ANSI_QUOTE;
+      cur += "$'";
+      k++;
+      continue;
+    }
+    if (ch === "'" || ch === '"') quote = ch;
+    cur += ch;
+  }
+  if (inWord) words.push(cur);
+  return words;
+}
+
+// `$'…'` (ANSI-C quoting): a backslash escapes the next character, including `'`.
+const ANSI_QUOTE = "$'";
+// Stands in for a cut-out substitution. No surrounding spaces: `f=$(…)` must stay one
+// assignment word, or the placeholder becomes the verb.
+const SUBST = '__SUBST__';
+const MAX_SUBST_DEPTH = 32;
+
+/**
+ * Remove what the shell does not run as a command: heredoc bodies (they are stdin) and
+ * `#` comments. Quote-aware. An apostrophe in either used to unbalance the quotes and send
+ * the whole line to a first-word fallback (v6.13.0 defect review P3-4).
+ *
+ * An UNQUOTED delimiter (`<<EOF`) is the exception: bash expands `$(…)` and backticks in
+ * that body, so each body line is kept as `: "<line>"`, a no-op whose substitutions
+ * splitStatements still cuts out and judges. `$((…))` and `((…))` are copied whole so a
+ * `<<` shift inside them is not read as a heredoc (v6.13.2 pre-ship defect review).
+ */
+function stripNonCommands(cmd) {
+  let out = '';
+  let quote = null;
+  // Set once a `((` never closes: every later attempt would rescan to the end of the input,
+  // which made unclosed parentheses quadratic (v6.13.2 delta review P3-1).
+  let arithUnclosed = false;
+  const pending = []; // heredoc delimiters opened on the current line: { word, dash, expand }
+  for (let k = 0; k < cmd.length; k++) {
+    const ch = cmd[k];
+    if (quote === ANSI_QUOTE) {
+      if (ch === '\\') {
+        out += ch + (cmd[k + 1] ?? '');
+        k++;
+        continue;
+      }
+      if (ch === "'") quote = null;
+      out += ch;
+      continue;
+    }
+    if (quote) {
+      // Keep the backslash AND the character it escapes (the old `out += cmd[k++]; out += ch`
+      // wrote the backslash twice and dropped the escaped character).
+      if (ch === '\\' && quote === '"') {
+        out += ch + (cmd[k + 1] ?? '');
+        k++;
+        continue;
+      }
+      if (ch === quote) quote = null;
+      out += ch;
+      continue;
+    }
+    if (ch === '\\') {
+      out += ch + (cmd[k + 1] ?? '');
+      k++;
+      continue;
+    }
+    if (ch === '$' && cmd[k + 1] === "'") {
+      quote = ANSI_QUOTE;
+      out += "$'";
+      k++;
+      continue;
+    }
+    if (ch === "'" || ch === '"') {
+      quote = ch;
+      out += ch;
+      continue;
+    }
+    const opensArith =
+      (ch === '$' && cmd[k + 1] === '(' && cmd[k + 2] === '(') ||
+      (ch === '(' && cmd[k + 1] === '(' && cmd[k - 1] !== '$');
+    if (opensArith && !arithUnclosed) {
+      const end = arithmeticEnd(cmd, ch === '$' ? k + 1 : k);
+      if (end >= 0) {
+        out += cmd.slice(k, end);
+        k = end - 1;
+        continue;
+      }
+      if (end === ARITH_UNCLOSED) arithUnclosed = true;
+    }
+    if (ch === '#' && (k === 0 || /[\s;&|()]/.test(cmd[k - 1]))) {
+      while (k + 1 < cmd.length && cmd[k + 1] !== '\n') k++;
+      continue;
+    }
+    if (ch === '<' && cmd[k + 1] === '<' && cmd[k + 2] !== '<' && cmd[k - 1] !== '<') {
+      const m = /^<<(-?)[ \t]*((?:'[^'\n]*'|"[^"\n]*"|\\.|[^\s;&|<>()'"\\])+)/.exec(cmd.slice(k));
+      if (m) {
+        pending.push({
+          word: m[2].replace(/\\(.)/g, '$1').replace(/['"]/g, ''),
+          dash: m[1] === '-',
+          expand: !/['"\\]/.test(m[2]),
+        });
+        out += m[0];
+        k += m[0].length - 1;
+        continue;
+      }
+    }
+    if (ch === '\n' && pending.length > 0) {
+      out += ch;
+      // Consume each body in order, up to and including its delimiter line.
+      let pos = k + 1;
+      for (const { word, dash, expand } of pending.splice(0)) {
+        while (pos < cmd.length) {
+          let end = cmd.indexOf('\n', pos);
+          if (end === -1) end = cmd.length;
+          const line = cmd.slice(pos, end);
+          pos = end + 1;
+          if ((dash ? line.replace(/^\t+/, '') : line) === word) break;
+          if (expand) {
+            const esc = line.replace(/\\(?=")/g, '\\\\').replace(/"/g, '\\"');
+            // A trailing backslash would escape the wrapper's closing quote.
+            const odd = /\\*$/.exec(esc)[0].length % 2 === 1;
+            out += `: "${esc}${odd ? '\\' : ''}"\n`;
+          }
+        }
+      }
+      k = pos - 1;
+      continue;
+    }
+    out += ch;
+  }
+  return out;
+}
+
+const ARITH_UNCLOSED = -2;
+
+/**
+ * For `((` whose first `(` is at `open` (after the `$` of `$((`, or a bare `((`): the index
+ * just past the closing `))` when bash reads it as arithmetic, -1 when it is a command form
+ * instead, ARITH_UNCLOSED when the inner `(` never closes. bash tries arithmetic first and
+ * falls back when the inner `(` does not close on `))`, so `$((npm test) | head)` is a
+ * command substitution holding a subshell (v6.13.2 delta review P3-3).
+ */
+function arithmeticEnd(cmd, open) {
+  const inner = closingParen(cmd, open + 2);
+  if (inner === -1) return ARITH_UNCLOSED;
+  return cmd[inner] === ')' ? inner + 1 : -1;
+}
+
+/**
+ * Index just past the `)` that closes a substitution whose body starts at `start`, or -1
+ * when it never closes. Quote-aware; nested parentheses count.
+ */
+function closingParen(cmd, start) {
+  let depth = 1;
+  let quote = null;
+  for (let k = start; k < cmd.length; k++) {
+    const ch = cmd[k];
+    if (quote) {
+      if (ch === '\\' && quote !== "'") k++;
+      else if (ch === quote[quote.length - 1]) quote = null;
+      continue;
+    }
+    if (ch === '\\') k++;
+    else if (ch === '$' && cmd[k + 1] === "'") {
+      quote = ANSI_QUOTE;
+      k++;
+    } else if (ch === "'" || ch === '"') quote = ch;
+    else if (ch === '(') depth++;
+    else if (ch === ')' && --depth === 0) return k + 1;
+  }
+  return -1;
+}
+
 /**
  * Split a command line into statements (on `;`, newline, `&&`, `||`, `&`), each a list
  * of its pipeline elements (on `|` and `|&`). Quote-aware, so the `;` in
  * `grep -E "a;b"` separates nothing, and the `&` of a redirection (`2>&1`, `&>f`) is not
- * a statement break. A backslash-newline continues the line. Returns null when the
- * quotes do not balance (a heredoc body with an apostrophe, say) — the caller then falls
- * back to the one-verb rule rather than guess.
+ * a statement break. A backslash-newline continues the line. The bodies of `$(…)`,
+ * backticks, `<(…)` and `>(…)` — outside quotes or inside double quotes, where they run
+ * all the same — are cut out into `subs` for the caller to judge on their own. Returns
+ * null when the quotes or a substitution do not close.
  */
 function splitStatements(cmd) {
   const statements = [];
+  const subs = [];
   let pipeline = [];
   let cur = '';
   let quote = null;
+  // Cut a substitution body out at `k` (the index of `$`, `<`, `>` or the backtick);
+  // returns the index of its last character, or -1 when it never closes.
+  const takeSub = (k) => {
+    if (cmd[k] === '`') {
+      const end = cmd.indexOf('`', k + 1);
+      if (end === -1) return -1;
+      subs.push(cmd.slice(k + 1, end));
+      cur += SUBST;
+      return end;
+    }
+    if (cmd[k] === '$' && cmd[k + 2] === '(') {
+      const arithEnd = arithmeticEnd(cmd, k + 1);
+      if (arithEnd >= 0) {
+        // An arithmetic body is not a command, but a substitution inside it still runs.
+        const body = cmd.slice(k + 3, arithEnd - 2);
+        if (/\$\(|`/.test(body)) subs.push(`: ${body}`);
+        cur += SUBST;
+        return arithEnd - 1;
+      }
+    }
+    const end = closingParen(cmd, k + 2);
+    if (end === -1) return -1;
+    subs.push(cmd.slice(k + 2, end - 1));
+    cur += SUBST;
+    return end - 1;
+  };
   const endElement = () => {
     pipeline.push(cur);
     cur = '';
@@ -129,9 +418,29 @@ function splitStatements(cmd) {
   };
   for (let k = 0; k < cmd.length; k++) {
     const ch = cmd[k];
+    const opensSub = ch === '`' || ((ch === '$' || ch === '<' || ch === '>') && cmd[k + 1] === '(');
+    if (quote === ANSI_QUOTE) {
+      if (ch === '\\') {
+        cur += ch + (cmd[k + 1] ?? '');
+        k++;
+        continue;
+      }
+      if (ch === "'") quote = null;
+      cur += ch;
+      continue;
+    }
     if (quote) {
+      if (quote === '"' && (ch === '`' || (ch === '$' && cmd[k + 1] === '('))) {
+        k = takeSub(k);
+        if (k === -1) return null;
+        continue;
+      }
+      if (ch === '\\' && quote === '"') {
+        cur += ch + (cmd[k + 1] ?? '');
+        k++;
+        continue;
+      }
       if (ch === quote) quote = null;
-      else if (ch === '\\' && quote === '"') cur += cmd[k++];
       cur += ch;
       continue;
     }
@@ -140,11 +449,22 @@ function splitStatements(cmd) {
       k++;
       continue;
     }
+    if (ch === '$' && cmd[k + 1] === "'") {
+      quote = ANSI_QUOTE;
+      cur += "$'";
+      k++;
+      continue;
+    }
     if (ch === "'" || ch === '"') {
       quote = ch;
       cur += ch;
       continue;
     }
+    if (opensSub) {
+      k = takeSub(k);
+      if (k === -1) return null;
+      continue;
+    }
     const next = cmd[k + 1];
     if (ch === '|' && next !== '|') {
       endElement();
@@ -161,7 +481,7 @@ function splitStatements(cmd) {
   }
   if (quote) return null;
   endStatement();
-  return statements;
+  return { statements, subs };
 }
 
 // True when the command only READS: every element of every pipeline is a read/search
@@ -171,18 +491,35 @@ function splitStatements(cmd) {
 // `git grep`, `cat f | head` and `cd repo && sed -n 1,9p f` are exempt. Every statement
 // and every pipe consumer is checked, so `grep x f; npm test | tail` and
 // `printf '…' | node server.mjs` are not exempted on the strength of their first word.
+// Substitution bodies are judged the same way, so `grep x $(npm test)` runs a program.
+// A line that still does not parse once heredoc bodies and comments are gone is 'other':
+// the old fallback judged it by its first word and silenced exactly the heredoc-then-run
+// shape (v6.13.0 defect review P3-4).
 function isReadOnlyCommand(cmd) {
-  const statements = splitStatements(cmd);
-  if (!statements) return classifySimpleCommand(cmd.split('|')[0]) === 'read';
+  return commandKind(stripNonCommands(cmd)) === 'read';
+}
+
+/** 'read' | 'neutral' | 'other' for a whole command line (see isReadOnlyCommand). */
+function commandKind(cmd, depth = 0) {
+  // Each level rescans its body; past this depth the line is judged 'other' rather than
+  // recursing into a RangeError on the hot path of every Bash event.
+  if (depth > MAX_SUBST_DEPTH) return 'other';
+  const parsed = splitStatements(cmd);
+  if (!parsed) return 'other';
   let sawRead = false;
-  for (const pipeline of statements) {
+  for (const body of parsed.subs) {
+    const kind = commandKind(body, depth + 1);
+    if (kind === 'other') return 'other';
+    if (kind === 'read') sawRead = true;
+  }
+  for (const pipeline of parsed.statements) {
     for (const element of pipeline) {
       const kind = classifySimpleCommand(element);
-      if (kind === 'other') return false;
+      if (kind === 'other') return 'other';
       if (kind === 'read') sawRead = true;
     }
   }
-  return sawRead;
+  return sawRead ? 'read' : 'neutral';
 }
 
 // Paths excluded from observation capture (ephemeral / virtual filesystems) — applied

package/hook-handoff.mjs

@@ -165,7 +165,7 @@ export function buildAndSaveHandoff(db, sessionId, project, type, episodeSnapsho
       WHERE project = ? AND ${liveObsFilterSql('')}
         AND COALESCE(importance, 1) >= 3
         AND ${notLowSignalTitleClause('')}
-      ORDER BY created_at_epoch DESC LIMIT 1
+      ORDER BY created_at_epoch DESC, id DESC LIMIT 1
     `,
       )
       .get(project);
@@ -248,7 +248,7 @@ export function buildAndSaveHandoff(db, sessionId, project, type, episodeSnapsho
       `
     SELECT title, type, narrative FROM observations
     WHERE (memory_session_id = ? OR project = ?) AND COALESCE(compressed_into, 0) = 0 ${obsWindowClause}
-    ORDER BY created_at_epoch DESC LIMIT 15
+    ORDER BY created_at_epoch DESC, id DESC LIMIT 15
   `,
     )
     .all(sessionId, project, ...obsWindowParams);
@@ -348,21 +348,36 @@ export function buildAndSaveHandoff(db, sessionId, project, type, episodeSnapsho
   if (episodeSnapshot?.files) episodeSnapshot.files.filter(isValidFile).forEach((f) => fileSet.add(f));
   // Same namespace widening as `completed` above — see the reasoning there. Measured
   // 2026-09-21: 8 of the 17 live handoff rows stored key_files as the empty array.
-  const obsFiles = db
+  //
+  // The cap counts rows that CONTRIBUTE a new file (D#67, the D#40 shape). This read was
+  // `LIMIT 10` → isValidFile, so rows the filter empties ('[]', directories, /tmp paths)
+  // could use up the window. A latent defect: the v6.13.2 pre-ship claims review replayed
+  // the live DB 2026-09-26 with this read's own WHERE and window, and 0 of 45 stored
+  // handoffs and 0 of 310 sessions lost a file (the largest window held 11 rows).
+  // Streaming keeps the filter exactly as it was.
+  let contributing = 0;
+  for (const row of db
     .prepare(
       `
     SELECT files_modified FROM observations
     WHERE (memory_session_id = ? OR project = ?) AND files_modified IS NOT NULL ${obsWindowClause}
-    ORDER BY created_at_epoch DESC LIMIT 10
+    ORDER BY created_at_epoch DESC, id DESC
   `,
     )
-    .all(sessionId, project, ...obsWindowParams);
-  for (const row of obsFiles) {
+    .iterate(sessionId, project, ...obsWindowParams)) {
+    let files;
     try {
-      JSON.parse(row.files_modified)
-        .filter(isValidFile)
-        .forEach((f) => fileSet.add(f));
-    } catch {}
+      files = JSON.parse(row.files_modified);
+    } catch {
+      continue;
+    }
+    const valid = Array.isArray(files) ? files.filter(isValidFile) : [];
+    const before = fileSet.size;
+    valid.forEach((f) => fileSet.add(f));
+    // A row that only repeats a listed file (the common case: one file edited again and
+    // again) contributes nothing either (v6.13.2 pre-ship defect review P3-7).
+    if (fileSet.size === before) continue;
+    if (++contributing === 10) break;
   }
 
   // 5. Key decisions — high importance observations (skip low-signal degraded titles).
@@ -784,6 +799,11 @@ export function pickHandoffToInject(db, project, currentCcSessionId = null) {
   const now = Date.now();
   // Fetch recent handoffs and find the most recent non-expired one.
   // A newer but expired 'clear' handoff must not shadow a still-valid 'exit' handoff.
+  // No id tiebreaker on this or the Stage -1/0/2 reads above, on purpose: session_handoffs has
+  // no id column, and its rowid is not recency because the writer is an UPSERT that keeps the
+  // row's original rowid. On a tie `rowid DESC` would therefore pick the older write exactly
+  // when the lower-rowid row was written last, a shape only a rewrite produces. A correct
+  // tiebreak needs a column; see findings.md, the created_at_epoch tie bullet.
   const handoffs = currentCcSessionId
     ? db
         .prepare(
@@ -1017,7 +1037,7 @@ function renderHandoffFromRow(handoff, db, project) {
         `
       SELECT completed, next_steps, remaining_items FROM session_summaries
       WHERE memory_session_id = ? AND project = ?
-      ORDER BY created_at_epoch DESC LIMIT 1
+      ORDER BY created_at_epoch DESC, id DESC LIMIT 1
     `,
       )
       .get(handoff.session_id, project);
@@ -1031,7 +1051,7 @@ function renderHandoffFromRow(handoff, db, project) {
           `
         SELECT completed, next_steps, remaining_items FROM session_summaries
         WHERE project = ?
-        ORDER BY ABS(created_at_epoch - ?) ASC LIMIT 1
+        ORDER BY ABS(created_at_epoch - ?) ASC, id DESC LIMIT 1
       `,
         )
         .get(project, handoff.created_at_epoch ?? 0);

package/lib/citation-tracker.mjs

@@ -116,10 +116,21 @@ const CITATION_RE = citationIdRe();
 // a false one withholds credit from a lesson that was used, so the marker must follow
 // the id directly: past the rest of an id list (`#137 / #260 / #54 n/a`, `#1758、E#3520
 // 与本次无关`) and at most one short parenthetical gloss, never "somewhere nearby".
+// The English adjectives must not be followed by a noun: "#12 irrelevant rows are now
+// filtered" describes the change (defect review P3-6). Only a word from ADJ_VERDICT_NEXT may
+// follow them. Over 1,900 `#NN` mentions (citationIdRe) in 218 top-level transcripts across
+// every project (2026-09-26T06:46Z) this changed exactly one verdict, the review's own
+// example quoted back.
 const DISMISSAL_LIST_TAIL = /^(?:\*\*|`|\s|[,，、/]|and\b|和|[A-Z]?#\d{1,7}\b)*/;
 const DISMISSAL_GLOSS = /^\s*(?:（[^（）\n]{1,80}）|\([^()\n]{1,80}\))/;
-const DISMISSAL_MARKER =
-  /^[\s*`:：\-—–(（[]*(?:(?:本轮|本次|这次|此次|此处)\s*)?(?:n\/a\b|not applicable|does(?:n't| not) apply|did(?:n't| not) apply|irrelevant|not relevant|unrelated|不适用|不相关|无关(?!紧要)|与(?:本|这|此)[^。\n；;]{0,16}无关)/i;
+const ADJ_VERDICT_NEXT =
+  'here|to|for|in|on|now|this|since|because|as|so|and|but|at|with|anyway|anymore|either|too|though|today';
+const DISMISSAL_MARKER = new RegExp(
+  "^[\\s*`:：\\-—–(（[]*(?:(?:本轮|本次|这次|此次|此处)\\s*)?(?:n\\/a\\b|not applicable|does(?:n't| not) apply|did(?:n't| not) apply|" +
+    `(?:irrelevant|not relevant|unrelated)(?![ \\t]+(?!(?:${ADJ_VERDICT_NEXT})\\b)[A-Za-z])|` +
+    '不适用|不相关|无关(?!紧要)|与(?:本|这|此)[^。\\n；;]{0,16}无关)',
+  'i',
+);
 
 /**
  * True when the `#NN` that ENDS at `end` in `text` is answered as not applying.
@@ -261,8 +272,11 @@ export function classifyCitationContext(transcriptPath, opts = {}) {
         continue;
       }
       // Only `text` blocks count as citing. `thinking` is deliberately excluded:
-      // extractCitationsFromTranscript scores text only, and the whole point is to
-      // classify the same numerator the decay loop acts on, not a wider one.
+      // extractCitationsFromTranscript scores text only. The numerator is still WIDER than
+      // the decay loop's by one class: a `#NN n/a` dismissal counts here, and the decay loop
+      // (extractCitationsFromTranscript's default) does not. Left as is because
+      // benchmark/citation-live-replay.mjs reads this split, and changing it would move
+      // that ruler's caliber (v6.13.0 defect review P3-7).
       if (block.type !== 'text' || typeof block.text !== 'string') continue;
       CITATION_RE.lastIndex = 0;
       let m;

package/mem-cli.mjs

@@ -2794,7 +2794,10 @@ function cmdMemdirAudit(args) {
 // main decay loop excludes (it runs mainOnly). aggregateProjectCiteRecall scans THIS
 // project's transcripts: top-level <session>.jsonl = main, and
 // <session>/subagents/agent-*.jsonl = sidechain (descends ONE level into the literal
-// subagents/ dir only, no unbounded recursion). Same methodology, so comparable.
+// subagents/ dir only, no unbounded recursion). Main and sidechain use the same
+// methodology here, so they compare with each other. It is a compliance ratio that counts
+// a `#NN n/a` dismissal as an answer, so it does NOT compare with the per-face rates,
+// including the `subagent` face, which exclude dismissals since v6.13.0.
 function _reportSidechainCiteRecall({ days, json }) {
   const cutoff = Date.now() - days * 86400 * 1000;
   // memdir = ~/.claude/projects/<encoded>/memory; transcripts are its siblings.

package/npm-shrinkwrap.json

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

package/package.json

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