claude-mem-lite 6.15.0 → 6.17.0

package/.claude-plugin/marketplace.json

@@ -9,10 +9,10 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "6.15.0",
+      "version": "6.17.0",
       "source": "./",
       "homepage": "https://github.com/sdsrss/claude-mem-lite",
-      "description": "Persistent long-term memory for Claude Code via MCP — captures coding decisions, bugfixes, and context across sessions. Hybrid FTS5 + TF-IDF search with episode batching. Single SQLite DB, no external services. A lighter, lower-cost alternative to claude-mem (episode batching + a smaller model; cost savings are an internal estimate, not a measured benchmark)."
+      "description": "Persistent long-term memory for Claude Code via MCP — captures coding decisions, bugfixes, and context across sessions. FTS5 BM25 keyword 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,7 +1,7 @@
 {
   "name": "claude-mem-lite",
-  "version": "6.15.0",
-  "description": "Persistent long-term memory for Claude Code via MCP — captures coding decisions, bugfixes, and context across sessions. Hybrid FTS5 + TF-IDF search with episode batching. Single SQLite DB, no external services. A lighter, lower-cost alternative to claude-mem (episode batching + a smaller model; cost savings are an internal estimate, not a measured benchmark).",
+  "version": "6.17.0",
+  "description": "Persistent long-term memory for Claude Code via MCP — captures coding decisions, bugfixes, and context across sessions. FTS5 BM25 keyword 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

@@ -81,7 +81,7 @@ How claude-mem-lite differs from the major neighbors in the LLM-memory space (ve
 - **Episode batching** -- Groups related file operations into coherent episodes before LLM encoding
 - **Error-triggered recall** -- Automatically searches memory when Bash errors occur, surfacing relevant past fixes
 - **Proactive file history** -- When editing a file, automatically shows relevant past observations for that file
-- **Session summaries** -- LLM-generated summaries at session end (via background workers using `claude -p`)
+- **Session summaries** -- written at every Stop (the assistant's final report when it has Done / Not done sections, else the first prompt and recent observation titles), then upgraded by a background model summary when the session has observations
 - **Project-scoped context** -- Injects recent memory into `CLAUDE.md` and session startup for immediate context
 - **Observation types** -- Categorized as `decision`, `bugfix`, `feature`, `refactor`, `discovery`, or `change`
 - **Importance grading** -- LLM assigns 1-3 importance levels (routine / notable / critical) to each observation
@@ -237,6 +237,35 @@ rm -rf ~/claude-mem-lite/   # pre-v0.5 unhidden (if not auto-moved)
     repos/               # Shallow-cloned source repos
 ```
 
+## Upgrading to 6.17.0
+
+**Two defaults change; one has a switch.** No schema change and no migration, so reverting
+everything is pinning `claude-mem-lite@6.16.0`.
+
+- **The pre-edit lesson line asks for a lesson's `#NN` only where it changed the edit.** It no
+  longer asks for an applied / not-applicable verdict on every lesson in your next reply, which
+  put lesson-id lists into replies. Old directive: `CLAUDE_MEM_SALIENCE=verdict`. Adopted
+  projects get the matching CLAUDE.md managed row and detail doc on the next SessionStart;
+  `CLAUDE_MEM_NO_TEMPLATE_REFRESH=1` keeps the old text.
+- **SessionStart's "Deferred Work" list ends with "+N more open"** when more than its 5 rows
+  are open. No switch; pin 6.16.0 to revert.
+
+## Upgrading to 6.16.0
+
+**Three defaults change; one has an off switch.** No schema change and no migration, so
+reverting everything is pinning `claude-mem-lite@6.15.0`.
+
+- **Each session gets one of two first lines on a file-recall block.** Half of sessions keep
+  "system-injected context, continue your planned action"; the other half get a plain
+  statement of where the notes come from, as Claude Code's hooks guide recommends. The two
+  are compared by cite-rate before one becomes the default. Off (old line everywhere):
+  `CLAUDE_MEM_RECALL_FRAMING=legacy`.
+- **Memory text longer than the host's 10,000-character hook limit is trimmed by whole
+  lines**, with a closing line naming the ids left out, instead of the host replacing it with
+  a 2,000-character preview. No switch; pin 6.15.0 to revert.
+- **Lessons shown after a failed Bash command now count in citation decay**, like every other
+  surface: ones never cited are ranked down over time. No switch; pin 6.15.0 to revert.
+
 ## Upgrading to 6.15.0
 
 **Two defaults change; one has an off switch.** No schema change and no migration, so
@@ -559,7 +588,7 @@ lesson_learned, minhash_sig, access_count, compressed_into, search_aliases,
 branch, superseded_at, superseded_by, last_accessed_at
 ```
 
-**session_summaries** -- LLM-generated session summaries
+**session_summaries** -- per-session summaries (written at Stop, upgraded by the background model summary)
 ```
 id, memory_session_id, project, request, investigated,
 learned, completed, next_steps, files_read, files_edited, notes,
@@ -628,6 +657,7 @@ Stop
   -> Flush final episode buffer
   -> Save handoff snapshot (type 'exit')
   -> Mark session completed
+  -> Write the session summary row (sync, no model call)
   -> Spawn LLM summary worker (poll-based wait)
   -> Keep the session file  <- Stop fires per TURN; deleting it here re-minted a mem
      session every turn and left the SessionStart /clear branch unreachable (v5.4.0)
@@ -1055,7 +1085,8 @@ and names can change between releases.
 |----------|-------------|---------|
 | `CLAUDE_MEM_TASK_IMPERATIVE` | `on`/`1` injects the single most relevant lesson at prompt position under an imperative template. | _(off)_ |
 | `CLAUDE_MEM_SUBAGENT_INJECT` | Dispatch-time memory injection for subagents. | _(off)_ |
-| `CLAUDE_MEM_SALIENCE` | Selects a comprehension-bridge arm (`bridge`, `bind`); unset = current default behavior. | _(unset)_ |
+| `CLAUDE_MEM_RECALL_FRAMING` | First line of a PreToolUse / PostToolUse recall block. `ab` gives each session one of two wordings, the older "system-injected context, continue your planned action" or a plain statement of source, so their cite-rates can be compared in one run (`benchmark/citation-live-replay.mjs --by-framing`); `legacy` / `factual` pin one. | `ab` |
+| `CLAUDE_MEM_SALIENCE` | Selects how the pre-edit lesson line asks for a response: unset = name a lesson's `#NN` only where it changed the edit; `verdict` = the pre-6.17 per-lesson `applied` / `n/a` verdict (the directive only: the adoption row in CLAUDE.md and the detail doc keep the new wording); `bind` / `bridge` = comprehension-bridge arms (`bridge` keeps the pre-6.17 verdict wording as its fallback); `legacy` = no directive. | _(unset)_ |
 | `CLAUDE_MEM_EDGE_DECAY` | Enables decay of file↔observation edges. | _(off)_ |
 | `CLAUDE_MEM_EDGE_DECAY_K` | Edge-decay threshold when the flag above is on (clamped to ≥1). | `3` |
 

package/README.zh-CN.md

@@ -60,7 +60,7 @@
 - **Episode 批处理** -- 将相关文件操作分组为连贯的 episode，再进行 LLM 编码
 - **错误触发回忆** -- Bash 出错时自动搜索记忆，浮现相关的历史修复方案
 - **主动文件历史** -- 编辑文件时，自动显示该文件相关的历史观察记录
-- **会话摘要** -- 会话结束时通过后台 worker（使用 `claude -p`）生成 LLM 摘要
+- **会话摘要** -- 每次 Stop 时写入（助手最终回复带 Done / Not done 段落时取其内容，否则取首条提示和最近的 observation 标题），会话有 observation 时再由后台模型摘要升级
 - **项目作用域上下文** -- 将最近的记忆注入 `CLAUDE.md` 和会话启动上下文
 - **观察类型** -- 分类为 `decision`、`bugfix`、`feature`、`refactor`、`discovery` 或 `change`
 - **重要度分级** -- LLM 为每条观察分配 1-3 级重要度（日常/关注/关键）
@@ -199,6 +199,32 @@ rm -rf ~/claude-mem-lite/   # v0.5 前的非隐藏目录（如未自动迁移）
     repos/               # 浅克隆的源代码仓库
 ```
 
+## 升级到 6.17.0
+
+**两处默认行为改变，其中一处有开关。** 没有 schema 变更、不需要迁移，全部回退只需固定
+`claude-mem-lite@6.16.0`。
+
+- **编辑前的 lesson 提示只在某条 lesson 改变了这次改动时，才请模型提一次它的 `#NN`。** 不再要求在
+  下一条回复里对每条 lesson 逐一表态“采纳 / 不适用”——那会让回复里出现成串的 lesson 编号。恢复旧提示：
+  `CLAUDE_MEM_SALIENCE=verdict`。已接入的项目会在下次 SessionStart 时把 CLAUDE.md 托管行和详细文档
+  换成对应的新写法；想保留旧文本设 `CLAUDE_MEM_NO_TEMPLATE_REFRESH=1`。
+- **SessionStart 的 "Deferred Work" 列表（5 行）在还有更多未完成事项时，末尾加一行 "+N more open"。**
+  没有开关，回退请固定 6.16.0。
+
+## 升级到 6.16.0
+
+**三处默认行为改变，其中一处有开关。** 没有 schema 变更、不需要迁移，全部回退只需固定
+`claude-mem-lite@6.15.0`。
+
+- **文件召回块的第一行，每个会话分到两种写法之一。** 一半会话保留原来的 "system-injected context,
+  continue your planned action"，另一半改成说明这些笔记来自哪里的事实陈述（Claude Code 的 hooks
+  指南建议这样写）。两种写法先比较引用率，再决定默认用哪个。关闭（全部用旧写法）：
+  `CLAUDE_MEM_RECALL_FRAMING=legacy`。
+- **超过宿主 1 万字符 hook 上限的记忆文本会按整行裁剪**，末尾一行列出被略去的 id；以前宿主会把它换成
+  2,000 字符的预览。没有开关，回退请固定 6.15.0。
+- **Bash 命令失败后展示的教训，现在也计入引用衰减**，和其他注入面一致：一直没被引用的会逐渐排到后面。
+  没有开关，回退请固定 6.15.0。
+
 ## 升级到 6.15.0
 
 **两处默认行为改变，其中一处有开关。** 没有 schema 变更、不需要迁移，全部回退只需固定
@@ -456,7 +482,7 @@ text, narrative, concepts, facts, files_read, files_modified,
 importance, related_ids, created_at, created_at_epoch
 ```
 
-**session_summaries** -- LLM 生成的会话摘要
+**session_summaries** -- 每个会话的摘要（Stop 时写入，后台模型摘要升级）
 ```
 id, memory_session_id, project, request, investigated,
 learned, completed, next_steps, files_read, files_edited, notes
@@ -515,6 +541,7 @@ Stop
   -> 刷新最终 episode 缓冲区
   -> 保存交接快照（/exit 时）
   -> 标记会话为已完成
+  -> 写入会话摘要行（同步，不调模型）
   -> 启动 LLM 摘要 worker（轮询等待）
 ```
 

package/adopt-content.mjs

@@ -50,7 +50,7 @@ PreToolUse hooks already run \`mem_recall\` for past lessons before Read/Edit/Wr
 
 | When | Call |
 |------|------|
-| Before Edit/Write | hook already recalled; if a \`#NN\` lesson was injected, cite \`#NN\` next time you produce user-visible text (citing = adopting the feedback; uncited lessons decay) |
+| Before Edit/Write | hook already recalled; if an injected \`#NN\` lesson changed what you did, name \`#NN\` once where you say so (citing = adopting; uncited lessons decay; skip ones that did not apply) |
 | After fixing a non-trivial bug | \`mem_save(type="bugfix", lesson_learned="<root cause + fix>", importance=2)\` |
 | After a non-obvious architecture decision | \`mem_save(type="decision", lesson_learned="<constraint + tradeoff>")\` |
 | Deferring to a future session | \`mem_defer({title, priority:1|2|3, detail})\`; when fixed, add \`closes_deferred=[N]\` to \`mem_save\` |
@@ -87,11 +87,12 @@ PreToolUse hook 在你 Read / Edit / Write 文件前已自动 \`mem_recall\` 该
 - **Edit / Write** 路径：decision-support——最多 3 条、240 字符、高重要度 bugfix/decision 即使无
   lesson 也注入。
 - Read→Edit 同文件共享 cooldown（不重复注入正文），但 Read 注入后的首个 Edit 会把 lesson **ID**
-  以一行 ack 指令重新浮出。看到 \`#NN [bugfix] …\` 这类行时：**下次产出用户可见文字时引用 \`#NN\`**
-  （\`'#NN applied'\` 或 \`'#NN n/a — <理由>'\`）。纯工具回合不算；把 ID 记在工作记忆里，写回时引用。
+  以一行 ack 指令重新浮出。看到 \`#NN [bugfix] …\` 这类行时：**某条 lesson 改变了你的做法，就在描述
+  那处改动时顺带提一次 \`#NN\`**；没用上的 lesson 不必提，也不要逐条列出。纯工具回合不算；
+  把 ID 记在工作记忆里，写回时引用。
 - 系统按会话追踪引用：被引用的 lesson 在召回排序里上浮，被注入却未引用的下沉（有界的排序乘数）；
   反复注入却从未被引用的，后台维护会把它的 importance 降到 2（无 lesson 的降到 1）。
-  \`'#NN n/a'\` 算作已回应，但不算采纳：排序上与未引用相同，同样下沉。
+  写成 \`#NN n/a\` 的驳回不算采纳：排序上与未引用相同，同样下沉——所以不必写。
   引用是给系统的反馈，不是合规仪式——注入池据此自调。
 
 ## 何时主动调用 MCP 工具

package/cli/common.mjs

@@ -326,6 +326,7 @@ export const KNOWN_CLI_FLAGS = new Set([
   'benchmark',
   'body',
   'branch',
+  'chars',
   'closes-deferred',
   'concepts',
   'confirm',
@@ -427,6 +428,7 @@ export const KNOWN_CLI_FLAGS = new Set([
  */
 export const COMMAND_SCOPED_FLAGS = new Map([
   ['apply', 'verify-apply'],
+  ['chars', 'context'],
   ['digest', 'verify-apply'],
   ['print-project', 'verify-apply'],
   ['undo', 'verify-apply'],

package/hook-context.mjs

@@ -580,7 +580,12 @@ export function buildSessionContextLines(
   currentCcSessionId = null,
   collector = null,
 ) {
-  if (collector) collector.keyContextIds = [];
+  if (collector) {
+    collector.keyContextIds = [];
+    // The same rows as {id, text: rendered line}, so a caller can book only the ones the
+    // hook-output cap keeps (D#108; lib/hook-text-cap.mjs idsShownWhole).
+    collector.keyContextLines = [];
+  }
   // 1. Token-budgeted observation selection
   const selected = selectWithTokenBudget(db, project, 2000);
   const observations = selected.observations;
@@ -711,14 +716,20 @@ export function buildSessionContextLines(
       summaryLines.push('### File Lessons');
       summaryLines.push(...shown.map((e) => e.line));
       summaryLines.push('');
-      if (collector) collector.keyContextIds.push(...shown.map((e) => e.id));
+      if (collector) {
+        collector.keyContextIds.push(...shown.map((e) => e.id));
+        collector.keyContextLines.push(...shown.map((e) => ({ id: e.id, text: e.line })));
+      }
     }
     if (keyContext.length > 0 && !quiet) {
       const shown = keyContext.slice(0, keyContextQuota);
       summaryLines.push('### Key Context');
       summaryLines.push(...shown.map((e) => e.line));
       summaryLines.push('');
-      if (collector) collector.keyContextIds.push(...shown.map((e) => e.id));
+      if (collector) {
+        collector.keyContextIds.push(...shown.map((e) => e.id));
+        collector.keyContextLines.push(...shown.map((e) => ({ id: e.id, text: e.line })));
+      }
     }
   } else if (!latestSummary && !effectiveQuiet()) {
     // Fallback: no summary AND no key observations — show recent activity.
@@ -851,7 +862,8 @@ export function buildSessionContextLines(
     SELECT id, title, priority,
            ROW_NUMBER() OVER (
              ORDER BY priority DESC, created_at_epoch ASC, id ASC
-           ) AS ordinal
+           ) AS ordinal,
+           COUNT(*) OVER () AS open_total
     FROM deferred_work
     WHERE project = ? AND status = 'open'
     ORDER BY priority DESC, created_at_epoch ASC, id ASC
@@ -867,6 +879,14 @@ export function buildSessionContextLines(
       const pTag = d.priority === 3 ? '🔴' : d.priority === 1 ? '⚪' : '🟡';
       deferredLines.push(`${d.ordinal}. ${pTag} [P${d.priority}] ${truncate(d.title, 120)} (D#${d.id})`);
     }
+    // The list is capped at 5 and used to stop there silently, so 10 open items read as a
+    // 5-item backlog. The total is the same statement's COUNT(*) OVER (), taken before LIMIT.
+    const hidden = Number(deferredItems[0].open_total) - deferredItems.length;
+    // Both listing surfaces page at 10, so the line names the knob rather than promising "all".
+    if (hidden > 0)
+      deferredLines.push(
+        `+${hidden} more open — mem_defer_list / \`defer list\` with a larger limit lists them`,
+      );
     deferredLines.push('');
   }
 

package/hook-handoff.mjs

@@ -33,6 +33,7 @@ import * as taskReaderModule from './lib/task-reader.mjs';
 // so a named import could not be spied on in tests.
 import * as pausedReaderModule from './lib/paused-reader.mjs';
 import { liveObsFilterSql } from './lib/inject-search-core.mjs';
+import { summarySourceLabel } from './lib/fast-summary.mjs';
 
 /**
  * Build and save a handoff snapshot to session_handoffs table.
@@ -1035,7 +1036,7 @@ function renderHandoffFromRow(handoff, db, project) {
     let summary = db
       .prepare(
         `
-      SELECT completed, next_steps, remaining_items FROM session_summaries
+      SELECT completed, next_steps, remaining_items, notes FROM session_summaries
       WHERE memory_session_id = ? AND project = ?
       ORDER BY created_at_epoch DESC, id DESC LIMIT 1
     `,
@@ -1049,7 +1050,7 @@ function renderHandoffFromRow(handoff, db, project) {
       summary = db
         .prepare(
           `
-        SELECT completed, next_steps, remaining_items FROM session_summaries
+        SELECT completed, next_steps, remaining_items, notes FROM session_summaries
         WHERE project = ?
         ORDER BY ABS(created_at_epoch - ?) ASC, id DESC LIMIT 1
       `,
@@ -1058,7 +1059,9 @@ function renderHandoffFromRow(handoff, db, project) {
     }
     if (summary && (summary.completed || summary.next_steps || summary.remaining_items)) {
       lines.push('');
-      lines.push('<session-summary source="haiku">');
+      // Provenance of the Done text from the row's own tag, not a constant: it read "haiku" on
+      // every row, including rows whose Done came from the Stop report or observation titles.
+      lines.push(`<session-summary source="${summarySourceLabel(summary.notes)}">`);
       // Defang: these come from session_summaries, populated by Haiku OR by
       // extractStructuredSummary over the assistant transcript tail — replayed text that can
       // carry tool-XML / forged authority tags, same class as working_on above (audit MED-4).

package/hook-precompact.mjs

@@ -9,6 +9,7 @@ import { buildSessionContextLines } from './hook-context.mjs';
 import { inferProject, debugCatch, debugLog } from './utils.mjs';
 import { RUNTIME_DIR } from './hook-shared.mjs';
 import { recordKeyContextInjection } from './lib/keyctx-marker.mjs';
+import { writeCappedHookText, idsShownWhole } from './lib/hook-text-cap.mjs';
 
 /**
  * Build + emit the memory context block on stdout. Writes the Key Context ids
@@ -26,9 +27,9 @@ export function handlePreCompact({ db, project, sessionId, runtimeDir = RUNTIME_
     const collector = {};
     const body = buildSessionContextLines(db, project, new Date(), sessionId || null, collector);
     const rendered = body && String(body).trim() !== '';
-    if (rendered) {
-      process.stdout.write(`<claude-mem-context>\n${body}\n</claude-mem-context>\n`);
-    }
+    // What the cap kept, not what was rendered: a Key Context row the cap cut is not in
+    // context, so booking it would exclude it from <memory-context> too (D#108).
+    const shown = rendered ? writeCappedHookText(`<claude-mem-context>\n${body}\n</claude-mem-context>`) : '';
     // Recorded even when NOTHING was re-rendered, matching handleSessionStart — the two
     // callers must describe the same set (keyctx-marker.mjs header), and the marker is an
     // exclude-set for what is actually in context. The old empty-body early return left the
@@ -39,7 +40,7 @@ export function handlePreCompact({ db, project, sessionId, runtimeDir = RUNTIME_
       runtimeDir,
       project,
       sessionId: sessionId || null,
-      ids: rendered ? collector.keyContextIds || [] : [],
+      ids: idsShownWhole(shown, collector.keyContextLines),
     });
   } catch (e) {
     debugCatch(e, 'handlePreCompact');

package/hook-update.mjs

@@ -76,11 +76,12 @@ export async function checkForUpdate(options = {}) {
     const state = readState();
     if (!force && !shouldCheck(state)) {
       // Return cached update info if previously detected
-      if (state.updateAvailable && state.latestVersion) {
+      const running = pendingCachedUpdate(state);
+      if (running) {
         return {
           updateAvailable: true,
           updated: false,
-          from: state.installedVersion,
+          from: running,
           to: state.latestVersion,
           installDeferred: pluginMode || !allowInstall,
           pluginMode,
@@ -160,13 +161,14 @@ export function getCachedUpdateBanner() {
   try {
     if (isDevMode() || process.env.CLAUDE_MEM_SKIP_UPDATE) return null;
     const state = readState();
-    if (state.updateAvailable && state.latestVersion) {
+    const running = pendingCachedUpdate(state);
+    if (running) {
       // Cached "available" state only persists for deferred installs (plugin mode
       // / allowInstall=false); a successful auto-install clears updateAvailable.
       const hint = isPluginMode()
         ? ' — plugin mode only checks for updates; reinstall/update the plugin to apply it'
         : '';
-      return `\n📦 claude-mem-lite: v${state.latestVersion} available (current: v${state.installedVersion})${hint}\n`;
+      return `\n📦 claude-mem-lite: v${state.latestVersion} available (current: v${running})${hint}\n`;
     }
     return null;
   } catch {
@@ -174,6 +176,18 @@ export function getCachedUpdateBanner() {
   }
 }
 
+// Issue #35. A cached `updateAvailable` is a claim about the version that was
+// running when the check ran, and in plugin mode the update itself is applied by
+// Claude Code — downloadAndInstall never runs, so nothing clears the flag. Judge
+// the cache against the version running NOW: returns that version when the cached
+// latest is still ahead of it, else null. Both cached faces (the SessionStart
+// banner and the throttled checkForUpdate) ask this, so neither can nag alone.
+function pendingCachedUpdate(state) {
+  if (!state.updateAvailable || !state.latestVersion) return null;
+  const running = getCurrentVersion();
+  return compareVersions(state.latestVersion, running) > 0 ? running : null;
+}
+
 // True when a network refresh is due (24h throttle) and updates aren't disabled.
 // Caller spawns the refresh in the background so this session doesn't wait.
 export function isUpdateCheckDue() {

package/hook.mjs

@@ -98,7 +98,13 @@ import {
 } from './lib/fast-summary.mjs';
 import { formatHookError } from './lib/native-binding-hint.mjs';
 import { recordHookError } from './lib/hook-telemetry.mjs';
-import { queueHookContext, queueHookSystemMessage, flushHookStdout } from './lib/hook-stdout.mjs';
+import {
+  queueHookContext,
+  queueHookSystemMessage,
+  flushHookStdout,
+  previewHookContext,
+} from './lib/hook-stdout.mjs';
+import { writePlainHookText, resetPlainHookText, idsShownWhole } from './lib/hook-text-cap.mjs';
 import { shouldRecallOnFailure } from './lib/tool-refusal.mjs';
 import {
   entryInputTags,
@@ -1564,9 +1570,12 @@ function trackCitationsAtStop(db, { sessionId, project, ccSessionId, transcriptP
         let gate = { gateInjected: null, gateRecalled: null, gateRatio: null };
         try {
           const gateInjectedIds = unionSurfaces(extractInjectedBySurface(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.
+          // The nudge asks whether the agent ANSWERED what the hooks showed it, so a
+          // `#NN n/a — <reason>` still counts. Since D#98 the default directive asks for no
+          // reply on a lesson that did not apply, so that silence now reads as a miss here and
+          // the gate fires more (projected 78/95 → up to 87/95 qualifying sessions,
+          // docs/audits/20260927-d98-dismissal-baseline.md). Left as is: the gate already fired
+          // on most sessions and self-silences after 3; D#111's readout re-measures it.
           const gateCited = extractCitationsFromTranscript(transcriptPath, {
             mainOnly: true,
             includeDismissed: true,
@@ -1744,6 +1753,12 @@ async function handleStop() {
   // waits on, then recreates the sandbox tree behind the test's cleanup. Any
   // grace period for that is a race, not a barrier — the post-tag review timed a
   // recreate at 432ms and watched a 300ms grace lose.
+  //
+  // D#95 made this opt-in in 34a65cd and was reverted before release: its premise ("Last
+  // Session already comes from the Stop report") holds only when the assistant's final reply
+  // carries Done / Not done sections (lib/summary-extractor.mjs). Without them the Stop row is
+  // the first prompt + recent observation titles, and this worker's model summary is the only
+  // prose summary such a user gets.
   if (!process.env.CLAUDE_MEM_SKIP_SUMMARY)
     spawnBackground('llm-summary', sessionId, project, String(stopEpoch));
 
@@ -2860,7 +2875,9 @@ async function handleSessionStart() {
       runtimeDir: RUNTIME_DIR,
       project,
       sessionId: ccSessionId,
-      ids: contextCollector.keyContextIds || [],
+      // Only the rows the cap keeps: flushHookStdout caps additionalContext at the
+      // dispatcher's exit, and nothing is queued for the model after this point (D#108).
+      ids: idsShownWhole(previewHookContext(), contextCollector.keyContextLines),
     });
 
     // One-time migration: remove any stale <claude-mem-context> block left in
@@ -3040,7 +3057,7 @@ function injectHandoffIfEarly(db, { project, promptText, promptNumber, ccSession
         const picked = pickHandoffToInject(db, project, ccSessionId);
         if (picked) {
           const injection = renderHandoffInjection(db, project, ccSessionId);
-          if (injection) process.stdout.write(injection + '\n');
+          if (injection) writePlainHookText(injection);
           // Consume ONLY the row we just injected — leave other projects' exit
           // handoffs intact so future sessions can still resume from them.
           // Pre-v2.46 wiped every exit handoff for the project on any continuation
@@ -3251,7 +3268,7 @@ async function injectSemanticMemory(db, { project, promptText, ccSessionId }) {
         const lines = ['<memory-context relevance="high">'];
         for (const m of memories) lines.push(formatMemoryLine(m));
         lines.push('</memory-context>');
-        process.stdout.write(lines.join('\n') + '\n');
+        writePlainHookText(lines.join('\n'));
       }
       // HIGH-1 (full audit 2026-07-16): surface FTS-matched events — the canonical
       // store for promoted bugfix/decision/lesson memories that persistHaikuSummary
@@ -3272,7 +3289,7 @@ async function injectSemanticMemory(db, { project, promptText, ccSessionId }) {
           const elines = ['<memory-context relevance="events">'];
           for (const e of events) elines.push(`- ${renderInjectableEvent(e)}`);
           elines.push('</memory-context>');
-          process.stdout.write(elines.join('\n') + '\n');
+          writePlainHookText(elines.join('\n'));
         }
       } catch (e) {
         debugCatch(e, 'handleUserPrompt-events');
@@ -3281,7 +3298,7 @@ async function injectSemanticMemory(db, { project, promptText, ccSessionId }) {
         // Guard the write on a non-empty return — formatTaskImperative yields '' for a
         // lesson that strips to empty (e.g. "."), which would otherwise emit a bare line.
         const imperativeLine = formatTaskImperative(imperativePick.lesson_learned, imperativePick.id);
-        if (imperativeLine) process.stdout.write(imperativeLine + '\n');
+        if (imperativeLine) writePlainHookText(imperativeLine);
       }
 
       // D#214's ruler, second half: arm B was computed above, before anything was
@@ -3312,6 +3329,7 @@ async function injectSemanticMemory(db, { project, promptText, ccSessionId }) {
 }
 
 async function handleUserPrompt() {
+  resetPlainHookText();
   const input = await readUserPromptInput();
   if (!input) return;
   const { promptText, hookData } = input;

package/lib/citation-tracker.mjs

@@ -18,6 +18,7 @@ import { readTranscriptEntries } from './transcript-scan.mjs';
 // The emitter's own prefix — see SURFACE_MATCHERS.task_imperative. Importing it rather
 // than re-typing the framing is what keeps emit and extract from becoming two lists.
 import { TASK_IMPERATIVE_PREFIX } from './task-imperative.mjs';
+import { classifyRecallFraming } from './recall-framing.mjs';
 
 import { DAY_MS } from './time-constants.mjs';
 /**
@@ -102,8 +103,9 @@ export function unanchoredInjectedIdRe() {
 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
+// The adoption doc asked the agent (until D#98; still under CLAUDE_MEM_SALIENCE=verdict) to
+// answer every surfaced lesson with `'#NN applied'` or `'#NN n/a — <reason>'`, and agents
+// still write the second form unprompted. It 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
@@ -743,8 +745,13 @@ const SURFACE_MATCHERS = {
     // post-tool-use.sh. High-volume surface that NO extractor matched before
     // v3.47 — error-recall'd obs accrued injection_count but never reached
     // applyCitationDecay, so they could neither promote nor demote.
+    // TWO deliveries: post-tool-use.sh (PostToolUse) and `hook.mjs post-tool-failure`
+    // (PostToolUseFailure — where a host-flagged failure goes, not PostToolUse). Keyed on
+    // the first alone until 2026-09-27, which kept every failure-path recall out of decay
+    // and every cite-rate ruler (C1 denominator count: 158 attachments carrying 389 ids).
     accepts: ({ command, text }) =>
-      command.includes('post-tool-use') && text.includes('Related memories found for this error'),
+      (command.includes('post-tool-use') || command.includes('post-tool-failure')) &&
+      text.includes('Related memories found for this error'),
     collect: (text, add) => {
       // Per-line anchored: match only a row that STARTS with `#NN [type]` (after its
       // indent), NOT every such token in the block. The inlined lesson body (v3.16.x)
@@ -857,6 +864,32 @@ export function countInjectedBySurface(transcriptPath, opts = {}) {
   return out;
 }
 
+/**
+ * Which recall framing arm(s) this transcript's PreToolUse blocks carried (A1 A/B).
+ *
+ * Read from the injected text, not recomputed from the session id: a session that ran
+ * before the A/B shipped saw the legacy line whatever its id hashes to, and only the text
+ * knows. Same walk and same `pretool` matcher as every other face.
+ *
+ * @param {string|null|undefined} transcriptPath
+ * @param {{mainOnly?: boolean}} [opts]
+ * @returns {'legacy'|'factual'|'mixed'|null} null when no PreToolUse block carried a framing line.
+ */
+export function pretoolFramingOf(transcriptPath, opts = {}) {
+  const seen = new Set();
+  eachHookAttachment(
+    transcriptPath,
+    (ctx) => {
+      if (!SURFACE_MATCHERS.pretool.accepts(ctx)) return;
+      const arm = classifyRecallFraming(ctx.text);
+      if (arm) seen.add(arm);
+    },
+    opts,
+  );
+  if (seen.size === 0) return null;
+  return seen.size > 1 ? 'mixed' : [...seen][0];
+}
+
 // Per-face extractors: thin wrappers over the shared table, kept as named
 // exports because callers and tests address individual faces.
 function extractOneSurface(face, transcriptPath, opts) {

package/lib/deferred-work.mjs

@@ -67,14 +67,16 @@ export function insertDeferred(db, args) {
  * @param {Database} db
  * @param {string} project
  * @param {number} [limit=10]
- * @returns {Array<{id, project, title, detail, priority, status, created_at_epoch, ordinal}>}
+ * @returns {Array<{id, project, title, detail, priority, status, created_at_epoch, ordinal, open_total}>}
+ *   `open_total` is every open row in the project, counted by the same statement before LIMIT.
  */
 export function listOpenWithOrdinal(db, project, limit = 10) {
   return db
     .prepare(
       `
     SELECT id, project, title, detail, priority, status, created_at_epoch,
-           ROW_NUMBER() OVER (ORDER BY priority DESC, created_at_epoch ASC, id ASC) AS ordinal
+           ROW_NUMBER() OVER (ORDER BY priority DESC, created_at_epoch ASC, id ASC) AS ordinal,
+           COUNT(*) OVER () AS open_total
     FROM deferred_work
     WHERE project = ? AND status = 'open'
     ORDER BY priority DESC, created_at_epoch ASC, id ASC
@@ -84,6 +86,22 @@ export function listOpenWithOrdinal(db, project, limit = 10) {
     .all(project, limit);
 }
 
+/**
+ * How many open rows `defer list` / `mem_defer_list` left off their page, as a line to
+ * print — '' when the page held them all. Without it a page one short of the open set
+ * (11 open, default page 10) reads as the whole list. Shared by both surfaces; `raise`
+ * names the knob in each surface's own spelling. The total comes from the page's own
+ * statement (`open_total`), so a concurrent `defer add` cannot make the two disagree.
+ * @param {Array<{open_total?: number}>} page rows from listOpenWithOrdinal
+ * @param {string} raise e.g. `raise --limit (max 100)`
+ * @returns {string}
+ */
+export function formatDeferMoreHint(page, raise) {
+  const hidden = page.length > 0 ? Number(page[0].open_total) - page.length : 0;
+  if (!(hidden > 0)) return '';
+  return `${hidden} more open item${hidden === 1 ? '' : 's'} not shown — ${raise}`;
+}
+
 // ─── G11: list age + stale refresh hint (roadmap 2026-07-18) ─────────────────
 
 // Internal const (was exported at v3.51.0 birth with zero external importers —

package/lib/fast-summary.mjs

@@ -151,6 +151,18 @@ export function parseSummaryNotes(notes) {
   return { done: 'titles', left: 'other', lines: text };
 }
 
+/**
+ * The `source` attribute the /clear handoff puts on `<session-summary>`: who wrote the row's
+ * Done text — `haiku` (the model worker), `report` (the assistant's own final report,
+ * extracted at Stop) or `titles` (observation titles, the fast fallback).
+ * @param {string|null|undefined} notes session_summaries.notes
+ * @returns {'haiku'|'report'|'titles'}
+ */
+export function summarySourceLabel(notes) {
+  const { done } = parseSummaryNotes(notes);
+  return done === 'model' ? 'haiku' : done;
+}
+
 /** Inverse of parseSummaryNotes. `lines` must already be scrubbed. */
 export function formatSummaryNotes({ done, left, lines }, max) {
   const head = `done${done} left${left}`;