claude-mem-lite 6.12.2 → 6.13.1

package/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "6.12.2",
+      "version": "6.13.1",
       "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.1",
   "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,20 @@ 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. 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 +914,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` 各注入面的引用率从此偏低。不要拿 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']);
@@ -57,20 +75,114 @@ 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',
+]);
+
+/** 'read' | 'neutral' | 'other' for one simple command (one element of a pipeline). */
+function classifySimpleCommand(text) {
+  const toks = text.trim().split(/\s+/).filter(Boolean);
   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 'read';
+  return first === 'git' && GIT_READ_SUBCMDS.has(toks[i + 1]) ? 'read' : 'other';
+}
+
+/**
+ * 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.
+ */
+function splitStatements(cmd) {
+  const statements = [];
+  let pipeline = [];
+  let cur = '';
+  let quote = null;
+  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];
+    if (quote) {
+      if (ch === quote) quote = null;
+      else if (ch === '\\' && quote === '"') cur += cmd[k++];
+      cur += ch;
+      continue;
+    }
+    if (ch === '\\') {
+      if (cmd[k + 1] !== '\n') cur += ch + (cmd[k + 1] ?? '');
+      k++;
+      continue;
+    }
+    if (ch === "'" || ch === '"') {
+      quote = ch;
+      cur += ch;
+      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;
+}
+
+// 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.
+function isReadOnlyCommand(cmd) {
+  const statements = splitStatements(cmd);
+  if (!statements) return classifySimpleCommand(cmd.split('|')[0]) === 'read';
+  let sawRead = false;
+  for (const pipeline of statements) {
+    for (const element of pipeline) {
+      const kind = classifySimpleCommand(element);
+      if (kind === 'other') return false;
+      if (kind === 'read') sawRead = true;
+    }
+  }
+  return sawRead;
 }
 
 // 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.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,77 @@ 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".
+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;
+
+/**
+ * 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 +189,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 +201,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
@@ -1254,7 +1316,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 +1528,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/npm-shrinkwrap.json

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

package/package.json

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