claude-mem-lite 6.12.2 → 6.13.2

package/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "6.12.2",
+      "version": "6.13.2",
       "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.12.2",
+  "version": "6.13.2",
   "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,21 @@ rm -rf ~/claude-mem-lite/   # pre-v0.5 unhidden (if not auto-moved)
     repos/               # Shallow-cloned source repos
 ```
 
+## Upgrading to 6.13.0
+
+**One default changes: SessionStart no longer injects `### Key Events`.** That section listed
+the five newest importance ≥ 2 rows of the `events` table — activity the background summarizer
+records — at the top of every session, chosen by recency rather than by what you were doing. A
+check of 30 of them against git history and transcripts found 2 accurate and 16 wrong. Events are still stored, searchable with `mem_search`, and
+injected when your prompt or the file being edited matches them. To restore the section, set
+`CLAUDE_MEM_SESSION_EVENTS=1`. No schema change and no migration: an older build still opens
+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 (`--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
 
 **One default changes: re-enrich stops leaving part of its budget idle.** It reserves half of
@@ -900,6 +915,7 @@ claude-mem-lite.
 | `OPENROUTER_MODEL` | Overrides the OpenRouter model slug for **all** background calls (e.g. `openai/gpt-4o-mini`, `qwen/qwen-2.5-72b-instruct`). When unset, the `CLAUDE_MEM_MODEL` tier maps to `anthropic/claude-haiku-4.5` (haiku) or `anthropic/claude-sonnet-4.5` (sonnet). | _(tier default)_ |
 | `CLAUDE_MEM_DEBUG` | Enable debug logging (`1` to enable). | _(disabled)_ |
 | `MEM_QUIET_HOOKS` | Low-noise hooks. `1` drops the `File Lessons` / `Key Context` sections from SessionStart injection, the lesson suffix from `[mem] Related memories`, and the `WHEN TO USE` / `Decision rules` blocks from MCP server instructions. IDs and the `Recent` table still surface so `mem_get(ids=[…])` remains reachable. Intended for users running the invited-memory adopt path or who otherwise want minimal auto-injection. **Since v2.82.0 this env no longer gates auto-adopt — use `MEM_NO_AUTO_ADOPT=1` for that.** | _(disabled)_ |
+| `CLAUDE_MEM_SESSION_EVENTS` | `1`/`on` restores the SessionStart `### Key Events` section (recent high-importance rows from the `events` table). **Off by default since v6.13.0**: an audit of 30 events read 2 accurate and 16 wrong. The UserPromptSubmit events block and PreToolUse recall are query-matched and stay on; `mem_search` still reaches every event. | _(off)_ |
 | `MEM_NO_AUTO_ADOPT` | Global opt-out for auto-adopt (v2.82.0+). `1` prevents the per-SessionStart auto-write of the `CLAUDE.md` managed block across **all** projects. For per-project opt-out use `claude-mem-lite adopt --disable` instead (writes a durable `<memdir>/.mem-no-auto-adopt` sentinel that survives marker deletion). | _(disabled)_ |
 | `MEM_NO_ADOPT_HINT` | Silences the one-line "Invited-memory 未启用：`claude-mem-lite adopt`…" hint that SessionStart appends when the current project hasn't been adopted. Since v2.82.1 auto-adopt runs on every SessionStart for any install path, so this hint typically surfaces only when you've explicitly opted out (`MEM_NO_AUTO_ADOPT=1` or `claude-mem-lite adopt --disable`). | _(disabled)_ |
 

package/README.zh-CN.md

@@ -199,6 +199,17 @@ rm -rf ~/claude-mem-lite/   # v0.5 前的非隐藏目录（如未自动迁移）
     repos/               # 浅克隆的源代码仓库
 ```
 
+## 升级到 6.13.0
+
+**只有一个默认行为变化：SessionStart 不再注入 `### Key Events`。** 这一节在每个会话开头列出
+`events` 表里最新的 5 条 importance ≥ 2 的记录（后台摘要器记下的活动），按时间挑选，与你当前在做
+什么无关。对照 git 历史和会话记录核验其中 30 条：2 条属实、16 条错误。event 仍然会存储、可以用 `mem_search` 检索，当你的提问或正在编辑的文件与之匹配时
+仍会注入。想恢复这一节，设置 `CLAUDE_MEM_SESSION_EVENTS=1`。没有 schema 变更、没有迁移：旧版本
+仍能打开数据库，回退就是固定到 `claude-mem-lite@6.12.2`。
+
+**引用率读数会从这个版本起下降，这是口径变化。** agent 用 `#NN n/a` 回应的 lesson 不再计为引用，
+所以 `citation-stats` 各注入面的引用率从此偏低（`--sidechain` 除外：它把 `n/a` 算作已回应）。不要拿 6.13.0 之前和之后的读数直接比较。
+
 ## 升级到 6.11.0
 
 **只有一个默认行为变化：re-enrich 不再让一部分预算空着。** 它为两个回填任务预留每次运行一半的
@@ -690,6 +701,7 @@ npm run benchmark:gate    # CI 门控：指标回退超过 5% 容差时失败
 | `OPENROUTER_MODEL` | 覆盖**所有**后台调用的 OpenRouter 模型 slug（如 `openai/gpt-4o-mini`、`qwen/qwen-2.5-72b-instruct`）。未设时按 `CLAUDE_MEM_MODEL` 分层映射到 `anthropic/claude-haiku-4.5`（haiku）或 `anthropic/claude-sonnet-4.5`（sonnet）。 | _(分层默认)_ |
 | `CLAUDE_MEM_DEBUG` | 启用调试日志（设为 `1` 启用）。 | _(禁用)_ |
 | `MEM_QUIET_HOOKS` | 低噪声 hook。设为 `1` 时，SessionStart 注入去掉 `File Lessons` / `Key Context` 两节，`[mem] Related memories` 去掉 lesson 后缀，MCP server instructions 去掉 `WHEN TO USE` / `Decision rules` 两段。ID 与 `Recent` 表仍保留，`mem_get(ids=[…])` 可继续展开细节。适用于启用了 invited-memory adopt 流程或偏好最小化自动注入的用户。**v2.82.0 起此 env 不再阻挡 auto-adopt——如需关闭 auto-adopt 用 `MEM_NO_AUTO_ADOPT=1`。** | _(禁用)_ |
+| `CLAUDE_MEM_SESSION_EVENTS` | 设为 `1`/`on` 时恢复 SessionStart 的 `### Key Events` 一节（`events` 表中最近的高重要度条目）。**v6.13.0 起默认关闭**：对 30 条 event 的核验只有 2 条属实、16 条错误。UserPromptSubmit 的 events 块与 PreToolUse 召回按查询匹配，保持开启；`mem_search` 仍可检索全部 event。 | _(关闭)_ |
 | `MEM_NO_AUTO_ADOPT` | auto-adopt 全局关闭开关（v2.82.0+）。设为 `1` 阻止每次 SessionStart 在**所有**项目自动写入 `CLAUDE.md` 托管块。项目级关闭走 `claude-mem-lite adopt --disable`（写 `<memdir>/.mem-no-auto-adopt` 哨兵，存活于 marker 删除）。 | _(禁用)_ |
 | `MEM_NO_ADOPT_HINT` | 静音当前项目未 adopt 时 SessionStart 追加的那一行 "Invited-memory 未启用…" 提示。v2.82.1 起任何安装路径每次 SessionStart 都自动 adopt，所以该提示一般只在你显式 opt out（`MEM_NO_AUTO_ADOPT=1` 或 `claude-mem-lite adopt --disable`）的项目才会出现。 | _(禁用)_ |
 

package/adopt-content.mjs

@@ -89,7 +89,9 @@ PreToolUse hook 在你 Read / Edit / Write 文件前已自动 \`mem_recall\` 该
 - Read→Edit 同文件共享 cooldown（不重复注入正文），但 Read 注入后的首个 Edit 会把 lesson **ID**
   以一行 ack 指令重新浮出。看到 \`#NN [bugfix] …\` 这类行时：**下次产出用户可见文字时引用 \`#NN\`**
   （\`'#NN applied'\` 或 \`'#NN n/a — <理由>'\`）。纯工具回合不算；把 ID 记在工作记忆里，写回时引用。
-- 系统按会话追踪引用：未引用的 lesson 连续 3 个会话后 importance −1（地板 0），被引用的 +1（封顶 3）。
+- 系统按会话追踪引用：被引用的 lesson 在召回排序里上浮，被注入却未引用的下沉（有界的排序乘数）；
+  反复注入却从未被引用的，后台维护会把它的 importance 降到 2（无 lesson 的降到 1）。
+  \`'#NN n/a'\` 算作已回应，但不算采纳：排序上与未引用相同，同样下沉。
   引用是给系统的反馈，不是合规仪式——注入池据此自调。
 
 ## 何时主动调用 MCP 工具

package/bash-utils.mjs

@@ -28,6 +28,24 @@ const SEARCH_VERBS = new Set([
   'file',
   'which',
   'type',
+  // Print-a-file-or-listing verbs agents use to READ source (`sed -n 40,80p f`) — their
+  // output is file content, so an `Error:` in it is quoted text, not a failure.
+  'sed',
+  'awk',
+  'ls',
+  'jq',
+  'nl',
+  'stat',
+  'diff',
+  'code-graph-mcp',
+  // Pure filters, so `grep x f | sort | uniq -c` stays a read.
+  'sort',
+  'uniq',
+  'cut',
+  'tr',
+  'column',
+  'paste',
+  'strings',
 ]);
 // Command prefixes that wrap the real command (env-assignments handled separately).
 const CMD_WRAPPERS = new Set(['sudo', 'doas', 'env', 'time', 'command', 'nice', 'nohup', 'stdbuf', 'xargs']);
@@ -44,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,
@@ -57,20 +76,450 @@ const GIT_READ_SUBCMDS = new Set([
 const HARD_ERROR_RE =
   /\bERR!|\bpanic\b|traceback|segfault|core dumped|\benoent\b|command not found|assertion\s?error|\n\s+at\s+\S|(?:type|reference|range|syntax|eval|uri)error:/i;
 
-// True when the command's PRIMARY operation (left of the first pipe, past any
-// env-assignments / wrapper like `sudo`/`env`/`time`) is a read/search — including
-// `git grep`/`git log`. Anchoring on the primary command (not "search verb appears
-// anywhere") is what lets `npm run build 2>&1 | tail` stay an error while `sudo grep`,
-// `git grep`, `cat f | head` are correctly exempt.
-function isReadOnlyCommand(cmd) {
-  const primary = cmd.split('|')[0];
-  const toks = primary.trim().split(/\s+/).filter(Boolean);
+// Commands that only set the shell up for the next one. They neither make a command
+// read-only nor stop it being one: `cd repo && grep …` is a grep. This matters because
+// the host resets the cwd between Bash calls, so agents prefix `cd <repo> &&` to over
+// half of their commands (5009 of 9096 in this repo's transcripts, 2026-09-25) — and
+// while `cd` counted as the primary verb, every such grep/sed of source that mentions
+// `TypeError:` fired error-recall on a command that had not failed.
+const NEUTRAL_VERBS = new Set([
+  'cd',
+  'pushd',
+  'popd',
+  'echo',
+  'printf',
+  'true',
+  ':',
+  '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 = 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) return false;
-  if (SEARCH_VERBS.has(first)) return true;
-  return first === 'git' && GIT_READ_SUBCMDS.has(toks[i + 1]);
+  if (!first || NEUTRAL_VERBS.has(first)) return 'neutral';
+  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. 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 = '';
+  };
+  const endStatement = () => {
+    endElement();
+    statements.push(pipeline);
+    pipeline = [];
+  };
+  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;
+      cur += ch;
+      continue;
+    }
+    if (ch === '\\') {
+      if (cmd[k + 1] !== '\n') cur += ch + (cmd[k + 1] ?? '');
+      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();
+      if (next === '&') k++;
+      continue;
+    }
+    const isRedirectAmp = ch === '&' && (cmd[k - 1] === '>' || cmd[k - 1] === '<' || next === '>');
+    if (ch === ';' || ch === '\n' || (ch === '&' && !isRedirectAmp) || (ch === '|' && next === '|')) {
+      endStatement();
+      if ((ch === '&' && next === '&') || ch === '|') k++;
+      continue;
+    }
+    cur += ch;
+  }
+  if (quote) return null;
+  endStatement();
+  return { statements, subs };
+}
+
+// True when the command only READS: every element of every pipeline is a read/search
+// (including `git grep`/`git log`) or a neutral set-up like `cd`/`echo`, and at least one
+// is a read. Anchoring on the verbs actually executed (not "search verb appears
+// anywhere") is what lets `npm run build 2>&1 | tail` stay an error while `sudo grep`,
+// `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) {
+  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 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 'other';
+      if (kind === 'read') sawRead = true;
+    }
+  }
+  return sawRead ? 'read' : 'neutral';
 }
 
 // Paths excluded from observation capture (ephemeral / virtual filesystems) — applied

package/hook-context.mjs

@@ -32,7 +32,11 @@ import {
   UNCONSUMED_HANDOFF_SQL,
 } from './hook-shared.mjs';
 import { extractUnfinishedSummary } from './hook-handoff.mjs';
-import { recentInjectableEvents, renderInjectableEvent } from './lib/events-injection.mjs';
+import {
+  recentInjectableEvents,
+  renderInjectableEvent,
+  sessionStartEventsEnabled,
+} from './lib/events-injection.mjs';
 import { liveObsFilterSql } from './lib/inject-search-core.mjs';
 // The canonical one (v3.84.0): this file carried a byte-identical private copy, which is
 // the same one-home rule this release enforced for the cooldown path and the dashboard.
@@ -738,12 +742,15 @@ export function buildSessionContextLines(
   // canonical store for promoted bugfix/decision/lesson memories that
   // persistHaikuSummary upgrade-deletes out of observations. Without this section
   // SessionStart never shows them. E# prefix keeps citation extractors (bare-`#`
-  // anchored) from reading an event id as an observation id. Gated on isQuietHooks()
-  // ONLY (explicit low-noise opt-out), NOT effectiveQuiet: unlike Key Context, events
+  // anchored) from reading an event id as an observation id. Of the quiet switches it
+  // honours isQuietHooks() (explicit low-noise opt-out), NOT effectiveQuiet: unlike Key Context, events
   // never appear in the obs-only Recent table and are absent from the MEMORY.md
   // sentinel, so an adopted project (the default) would otherwise have zero
   // SessionStart surface for them. Never throws (recentInjectableEvents catches).
-  if (!isQuietHooks()) {
+  //
+  // Since v6.13.0 the section is also opt-in (sessionStartEventsEnabled): audited at
+  // 2/30 accurate. The rationale lives on the predicate.
+  if (!isQuietHooks() && sessionStartEventsEnabled()) {
     const keyEvents = recentInjectableEvents(db, { project, limit: 5 });
     if (keyEvents.length > 0) {
       summaryLines.push('### Key Events');

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).

package/hook.mjs

@@ -1427,7 +1427,13 @@ function trackCitationsAtStop(db, { sessionId, project, ccSessionId, transcriptP
         let gate = { gateInjected: null, gateRecalled: null, gateRatio: null };
         try {
           const gateInjectedIds = unionSurfaces(extractInjectedBySurface(transcriptPath, { mainOnly: true }));
-          const gateCited = extractCitationsFromTranscript(transcriptPath, { mainOnly: true });
+          // The nudge asks whether the agent ANSWERED what the hooks showed it, and
+          // `#NN n/a — <reason>` is a complete answer: counting it as silence would nag
+          // an agent for following the convention to the letter.
+          const gateCited = extractCitationsFromTranscript(transcriptPath, {
+            mainOnly: true,
+            includeDismissed: true,
+          });
           let hit = 0;
           for (const id of gateInjectedIds) if (gateCited.has(id)) hit++;
           gate = {

package/lib/citation-tracker.mjs

@@ -101,17 +101,88 @@ export function unanchoredInjectedIdRe() {
 // `#123` / `#45678` at a word boundary — matches the CLAUDE.md cite pattern.
 const CITATION_RE = citationIdRe();
 
+// ─── Dismissals ──────────────────────────────────────────────────────────────
+// The adoption doc asks the agent to answer every surfaced lesson with `'#NN applied'`
+// or `'#NN n/a — <reason>'`. The second form is the agent saying the lesson did NOT
+// apply, yet `#NN` alone was the whole citation test, so a dismissal promoted the row
+// exactly like an application: cited_count + 1, uncited_streak reset, demoted_at
+// cleared, access_count bumped towards boostAccessed. Measured 2026-09-25T21:40Z over every
+// top-level transcript on the authoring machine with this rule: 328 of ~1,880 `#NN` mentions (1,881–1,884 by method; the corpus grows)
+// in assistant text are dismissals, and the most-"cited" row of this repo (#54, 9x) was
+// among them. This is the discriminator D#179 said no signal supplied — the product's
+// own convention supplies it for the case the agent states.
+//
+// Deliberately NARROW. A missed dismissal leaves the pre-fix behaviour (credited), while
+// 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 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.
+ * @param {string} text
+ * @param {number} end index just past the matched `#NN`
+ * @returns {boolean}
+ */
+export function isDismissalAt(text, end) {
+  let rest = text.slice(end, end + 240);
+  rest = rest.slice(rest.match(DISMISSAL_LIST_TAIL)[0].length);
+  if (markerNotRetracted(rest)) return true;
+  const gloss = rest.match(DISMISSAL_GLOSS);
+  return !!gloss && markerNotRetracted(rest.slice(gloss[0].length));
+}
+
+// The marker opens the clause; an application stated later in the SAME clause
+// ("#12 n/a for a.mjs; applied to b.mjs", "#12 does not apply to tests but I applied it
+// to lib") means the lesson WAS used, and a miss here keeps the old crediting, which is
+// the cheap direction (pre-ship defect review P3-6). The clause ends at a newline, a
+// sentence stop, or the next id, so "#1 n/a; #2 applied" still dismisses #1.
+const DISMISSAL_CLAUSE_END = /[\n。]|\.\s|[A-Z]?#\d/;
+// Completed, un-negated application only: a present-tense "applies" is how a dismissal
+// explains itself ("n/a — it applies to the server path, not this file"), and "does not
+// apply" / 不采纳 negate (delta review P3-2).
+const APPLIED_IN_CLAUSE =
+  /(?<!\b(?:not|never|n't)\s)\b(?:applied|adopted)\b|已采纳|采纳了|已按|按它修|已应用|用上了/i;
+function markerNotRetracted(s) {
+  const m = s.match(DISMISSAL_MARKER);
+  if (!m) return false;
+  const clause = s.slice(m[0].length).split(DISMISSAL_CLAUSE_END)[0];
+  return !APPLIED_IN_CLAUSE.test(clause);
+}
+
 /**
  * Parse a Claude Code transcript .jsonl and extract unique observation IDs
  * cited inside assistant text blocks.
  *
+ * An id every one of whose mentions is a dismissal (`#NN n/a — …`, see isDismissalAt)
+ * is NOT a citation by default: the callers that credit a row (decay promotion, the
+ * access bump, the funnel and per-face cite rates) must not reward "this did not
+ * apply". One non-dismissing mention anywhere in the session is enough to cite it.
+ * Pass `includeDismissed: true` where the question is COMPLIANCE — "did the agent
+ * answer the lesson it was shown" — for which a dismissal is a complete answer.
+ *
  * @param {string} transcriptPath Path to transcript file (.jsonl)
  * @param {object} [opts] Options
  * @param {boolean} [opts.mainOnly=false] If true, skip transcript records where isSidechain === true
+ * @param {boolean} [opts.includeDismissed=false] If true, count `#NN n/a` mentions too
  * @returns {Set<number>} unique IDs referenced as `#NN` in assistant text
  */
 export function extractCitationsFromTranscript(transcriptPath, opts = {}) {
-  const { mainOnly = false } = opts;
+  const { mainOnly = false, includeDismissed = false } = opts;
   const ids = new Set();
   for (const entry of readTranscriptEntries(transcriptPath)) {
     // Claude Code transcript: one JSON per line with type='assistant' | 'user' | ...
@@ -129,7 +200,8 @@ export function extractCitationsFromTranscript(transcriptPath, opts = {}) {
       let m;
       while ((m = CITATION_RE.exec(block.text))) {
         const id = Number(m[1]);
-        if (Number.isInteger(id) && id > 0 && id < 1e7) ids.add(id);
+        if (!(Number.isInteger(id) && id > 0 && id < 1e7)) continue;
+        if (includeDismissed || !isDismissalAt(block.text, m.index + m[0].length)) ids.add(id);
       }
     }
   }
@@ -140,7 +212,8 @@ export function extractCitationsFromTranscript(transcriptPath, opts = {}) {
  * D#179 prerequisite measurement: split each cited id into the responses that
  * ACTED while naming it and the responses that only TALKED about it.
  *
- * `applyCitationDecay` promotes on any `#NN` in assistant text, so writing a release
+ * `applyCitationDecay` promotes on any `#NN` in assistant text that is not a stated
+ * dismissal (`#NN n/a`, see isDismissalAt), so writing a release
  * note, an audit, or a review that discusses a memory promotes that memory — including,
  * self-referentially, a note observing that the memory is about to be evicted. Nothing
  * downstream distinguishes "changed the code this lesson describes" from "mentioned the
@@ -199,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;
@@ -1254,7 +1330,8 @@ export function computeThreadCiteRecall(transcriptPath) {
   // the PROMPT (updatedInput). Fold that in so sidechain recall isn't a false 0. On a
   // main transcript this marker is absent → no-op.
   for (const id of extractInjectedFromSubagentPrompt(transcriptPath)) injected.add(id);
-  const cited = extractCitationsFromTranscript(transcriptPath);
+  // A compliance ratio — "did the thread answer what it was handed" — so `#NN n/a` counts.
+  const cited = extractCitationsFromTranscript(transcriptPath, { includeDismissed: true });
   let recalled = 0;
   for (const id of injected) if (cited.has(id)) recalled++;
   return {
@@ -1465,7 +1542,9 @@ export function redirectSupersededIds(db, project, ids) {
  * this lesson" from "wrote about this lesson" (D#179; a release-note session
  * promotes exactly the rows it discusses, and the mention/application split
  * measured on the live corpus is not a bound in either direction), a bounded rank
- * shift is the right cost for a mis-read citation. An eviction is not.
+ * shift is the right cost for a mis-read citation. An eviction is not. (One case now
+ * has a signal: the agent's own `#NN n/a` — see isDismissalAt — is no longer read as
+ * a citation. A mention that merely discusses a lesson still is.)
  *
  * NOT covered by this change, and stated so nobody reads it as "citations can no
  * longer move importance": `bumpCitationAccess` credits `access_count`, and the

package/lib/cite-back-hint.mjs

@@ -26,6 +26,7 @@ import { citeRecallPathFor } from './cite-recall-path.mjs';
 // One caliber for `#NN`. citation-tracker.mjs does NOT import this module, so the edge
 // is acyclic.
 import { citationIdRe } from './citation-tracker.mjs';
+import { lessonIdTokens } from './injected-ids.mjs';
 import { envNumber } from './env-number.mjs';
 
 const MAX_FILES = 2;
@@ -51,7 +52,7 @@ export function buildCiteBackHint(episode, cooldown) {
       const ids = Array.isArray(entry.lessonIds) ? entry.lessonIds : null;
       if (!ids || ids.length === 0) continue;
       seen.add(file);
-      matches.push({ file, ids });
+      matches.push({ file, ids, obsIds: entry.obsIds });
       if (matches.length >= MAX_FILES) break;
     }
     if (matches.length >= MAX_FILES) break;
@@ -70,7 +71,8 @@ export function buildCiteBackHint(episode, cooldown) {
   ];
   for (const m of matches) {
     const fname = neutralizeContextDelimiters(basename(m.file));
-    const idList = m.ids.map((id) => `#${id}`).join(', ');
+    // lessonIds mixes obs and event ids; lessonIdTokens keeps the E# namespace.
+    const idList = lessonIdTokens(m.ids, m.obsIds).join(', ');
     lines.push(`  • ${fname} ← ${idList} — /lesson --file ${fname} "<root cause + fix>"`);
   }
   return lines.join('\n');

package/lib/events-injection.mjs

@@ -85,6 +85,31 @@ export function searchInjectableEvents(
   }
 }
 
+/**
+ * Whether SessionStart renders `### Key Events`. OFF unless `CLAUDE_MEM_SESSION_EVENTS`
+ * is `1`/`on`.
+ *
+ * The section is recency-selected, not query-conditioned, and nothing checks an event
+ * against the work it describes. A 30-row audit of this repo's own events (2026-09-25,
+ * docs/audits/20260925-200912-session-history-analysis.md §4.4.1) read 2 ACCURATE /
+ * 11 PARTLY / 16 WRONG / 1 GENERIC; the two most frequent failures (6 each) are the
+ * summarizer reading mutation-probe vocabulary as product bugs and lessons generalised past
+ * their evidence. The section had been injected 50 times (250 rows; the analysis session
+ * itself excluded) into this project's
+ * main sessions. Lines that are wrong half the time, stated with the authority of
+ * "Key Events", are a net cost at the top of every session. (`events.accessed_count` is
+ * NOT evidence either way: only `activity show` (getEvent) bumps it, while `mem_get` / `get E#N` go
+ * through fetchEventDetail, which does not.)
+ *
+ * Only this face is paused. The UserPromptSubmit leg (`searchInjectableEvents`) and the
+ * PreToolUse rows are matched against the prompt or the file being touched, and
+ * mem_search still reaches every event.
+ */
+export function sessionStartEventsEnabled(env = process.env) {
+  const v = env.CLAUDE_MEM_SESSION_EVENTS;
+  return v === '1' || v === 'on';
+}
+
 /**
  * Recency + importance events (SessionStart context — no FTS query available).
  * Excludes superseded events. Never throws.

package/lib/injected-ids.mjs

@@ -268,6 +268,39 @@ export function injectedIdKey(id, src = 'obs') {
  */
 export const EVENT_ID_PREFIX = 'E#';
 
+/**
+ * Render a pre-tool-recall cooldown entry's ids as citable tokens: `#N` for an
+ * observation, `E#N` for an event.
+ *
+ * `lessonIds` is the mixed list (obs + events, in injection order) and `obsIds` the
+ * observation subset (recorded since D#78). Two re-renderers — the Read→Edit ack line
+ * and the cite-back hint — printed every lessonId as a bare `#N`, so an injected
+ * `E#116` came back as "cite #116", which is a DIFFERENT memory: a bare `#` is the
+ * observation namespace (citationIdRe). Same shape as D#202, one layer later.
+ *
+ * `obsIds` is a multiset match, because one obs and one event may share a number in the
+ * same entry. An entry without `obsIds` (written before D#78) cannot be split and keeps
+ * the old bare rendering.
+ *
+ * @param {Array<number|string>} lessonIds
+ * @param {Array<number|string>|undefined} obsIds
+ * @returns {string[]}
+ */
+export function lessonIdTokens(lessonIds, obsIds) {
+  if (!Array.isArray(lessonIds)) return [];
+  if (!Array.isArray(obsIds)) return lessonIds.map((id) => `#${id}`);
+  const obsLeft = new Map();
+  for (const id of obsIds) obsLeft.set(String(id), (obsLeft.get(String(id)) || 0) + 1);
+  return lessonIds.map((id) => {
+    const n = obsLeft.get(String(id)) || 0;
+    if (n > 0) {
+      obsLeft.set(String(id), n - 1);
+      return `#${id}`;
+    }
+    return `${EVENT_ID_PREFIX}${id}`;
+  });
+}
+
 /**
  * Runtime-dir FILE NAME for the SessionStart Key Context marker: the obs ids
  * ACTUALLY rendered into the <claude-mem-context> File Lessons / Key Context

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.12.2",
+  "version": "6.13.2",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "claude-mem-lite",
-      "version": "6.12.2",
+      "version": "6.13.2",
       "os": [
         "darwin",
         "linux",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "6.12.2",
+  "version": "6.13.2",
   "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/schema.mjs

@@ -58,8 +58,10 @@ export { DB_DIR, DB_PATH, CODE_DIR };
 // closed_by_obs_id FK with ON DELETE SET NULL (audit trail preserved).
 // v32 (v2.73.2): citation-decay columns on observations — uncited_streak,
 // cited_count, last_decided_session_id. Stop hook resolves injected obs as
-// cited|uncited; 3 consecutive uncited → importance -1 (floor 0); 1 cited → +1
-// (cap 3). last_decided_session_id makes Stop idempotent across multi-fire.
+// cited|uncited; they feed citeFactorClause's bounded rank multiplier. (As shipped,
+// 3 consecutive uncited → importance -1 and 1 cited → +1; D#179/D#198 removed both
+// importance writes — the 3-session rollover now only resets the streak and stamps
+// demoted_at.) last_decided_session_id makes Stop idempotent across multi-fire.
 // v35 (v2.87.0): no DDL — version bumped only to force one full migration pass on
 // existing DBs, which runs the one-shot observation_files orphan cleanup (and
 // re-runs the v28 observation_vectors cleanup) to clear the backlog leaked while
@@ -363,8 +365,9 @@ const MIGRATIONS = [
   'ALTER TABLE observations ADD COLUMN last_injected_at INTEGER DEFAULT NULL',
   // v32 (citation-decay): per-obs feedback loop for pre-tool-recall injection
   // pool. Stop hook resolves each session's injected IDs as cited|uncited.
-  // 3 consecutive uncited sessions → importance -1 (floor 0). 1 cited session →
-  // importance +1 (cap 3). last_decided_session_id makes Stop idempotent across
+  // cited_count / uncited_streak feed citeFactorClause (a bounded rank multiplier);
+  // since D#179/D#198 the loop never writes importance (see applyCitationDecay).
+  // last_decided_session_id makes Stop idempotent across
   // multi-fire scenarios (Claude may fire Stop more than once per session).
   'ALTER TABLE observations ADD COLUMN uncited_streak INTEGER NOT NULL DEFAULT 0',
   'ALTER TABLE observations ADD COLUMN cited_count INTEGER NOT NULL DEFAULT 0',

package/scoring-sql.mjs

@@ -248,7 +248,7 @@ export function notLowSignalTitleClause(alias = 'o') {
 //   cited≥10, streak=0 → 3.0  (capped — one viral obs can't dominate)
 //   cited=0, streak=2  → 0.5
 //   cited=0, streak=3+ → 0.4  (floored; citation-decay resets streak at 3
-//                              after demoting importance, so steady-state
+//                              and stamps demoted_at, so steady-state
 //                              streak is bounded by [0,2])
 //
 // Disjoint from noisePenaltyClause: noise penalty uses

package/scripts/pre-tool-recall.js

@@ -12,6 +12,7 @@ import {
   injectedIdsFileName,
   injectedIdKey,
   EVENT_ID_PREFIX,
+  lessonIdTokens,
   readInjectedMarker,
   mergeInjectedMarker,
 } from '../lib/injected-ids.mjs';
@@ -485,7 +486,8 @@ try {
       const seenIds = typeof entry === 'object' && Array.isArray(entry.lessonIds) ? entry.lessonIds : [];
       const wasReadMode = typeof entry === 'object' && entry.mode === 'read';
       if (!isRead && wasReadMode && seenIds.length > 0 && !SALIENCE_LEGACY) {
-        const idList = seenIds.map((id) => `#${id}`).join(', ');
+        // Namespaced per table: a bare `#N` for an event id names a different memory.
+        const idList = lessonIdTokens(seenIds, entry.obsIds).join(', ');
         queueHookContext(
           'PreToolUse',
           [

package/scripts/user-prompt-search.js

@@ -429,7 +429,8 @@ export function searchByFts(
   // docs/p0-injection-noise-baseline.txt.
   // A1 (v2.83): cite_factor closes the citation-decay → ranking loop. Obs the
   // assistant cited in past sessions (cited_count > 0) get boosted; obs with
-  // accumulating uncited_streak get dampened upstream of importance-decay.
+  // accumulating uncited_streak get dampened (citation-decay no longer writes importance,
+  // D#179/D#198, so this multiplier is the loop's only ranking effect).
   // Disjoint signal from noise_penalty (which uses injection_count vs
   // access_count) — see scoring-sql.mjs::citeFactorClause for the math.
   const sql = `