claude-mem-lite 6.16.0 → 6.17.1

package/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "6.16.0",
+      "version": "6.17.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. 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,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "6.16.0",
+  "version": "6.17.1",
   "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,20 @@ 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` (since 6.17.1
+  it also says it overrides the managed row and detail doc, which keep the new wording). 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
@@ -575,7 +589,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,
@@ -644,6 +658,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)
@@ -1072,7 +1087,7 @@ 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_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 a comprehension-bridge arm (`bridge`, `bind`); unset = current default behavior. | _(unset)_ |
+| `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 adoption row in CLAUDE.md and the detail doc keep the new wording, and since 6.17.1 the directive says it overrides them); `bind` / `bridge` = comprehension-bridge arms (`bridge` keeps the pre-6.17 verdict wording as its fallback; neither says it overrides the adopted text, so their measured wording stays fixed); `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,18 @@ 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`（6.17.1 起它会注明自己优先于托管行和详细文档，那两处保持新写法）。
+  已接入的项目会在下次 SessionStart 时把 CLAUDE.md 托管行和详细文档换成对应的新写法；想保留旧文本设 `CLAUDE_MEM_NO_TEMPLATE_REFRESH=1`。
+- **SessionStart 的 "Deferred Work" 列表（5 行）在还有更多未完成事项时，末尾加一行 "+N more open"。**
+  没有开关，回退请固定 6.16.0。
+
 ## 升级到 6.16.0
 
 **三处默认行为改变，其中一处有开关。** 没有 schema 变更、不需要迁移，全部回退只需固定
@@ -470,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
@@ -529,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/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;
@@ -705,20 +710,36 @@ export function buildSessionContextLines(
     // asserted in tests/hook-context.test.mjs rather than left as a claim, because "it
     // only adds" is exactly the kind of sentence this repo keeps finding to be false.
     const { fileLessonQuota, keyContextQuota } = sectionQuotas(fileLessons.length, keyContext.length);
+    // The collector records the line as the caller will SEE it: this function's return runs
+    // neutralizeContextDelimiters over the whole body, and idsShownWhole matches exact lines,
+    // so a row carrying a delimiter tag was shown yet never booked (D#115 P3-1). Matches the
+    // block-level pass for any tag closed on its own line. Two cases still differ, and leave a
+    // shown row unbooked as before this fix: an UNclosed tag whose attribute tail
+    // (CONTEXT_DELIMITER_RE's `[^>]*` does not stop at a newline) runs to a later row's `>` —
+    // the rows at the two ends of that span; and the block pass failing closed (32+ nested
+    // forged tags, defangToFixpoint strips every `<` / `>`) — any shown row holding `<` or
+    // `>`. 0 of 178 live importance>=2 rows carry a tag (2026-09-27).
+    const bookedLine = (e) => ({ id: e.id, text: neutralizeContextDelimiters(e.line) });
 
     if (fileLessons.length > 0 && !quiet) {
       const shown = fileLessons.slice(0, fileLessonQuota);
       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(bookedLine));
+      }
     }
     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(bookedLine));
+      }
     }
   } else if (!latestSummary && !effectiveQuiet()) {
     // Fallback: no summary AND no key observations — show recent activity.
@@ -851,7 +872,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 +889,19 @@ 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 openTotal = Number(deferredItems[0].open_total);
+    const hidden = openTotal - deferredItems.length;
+    // Both listing surfaces page at 10, so the line names the knob rather than promising "all".
+    // Their maxima differ (mem_defer_list 50, `defer list` 100): past 50 only the CLI can list
+    // them, past 100 nothing lists them all (v6.17.1 pre-tag review).
+    if (hidden > 0)
+      deferredLines.push(
+        openTotal <= 50
+          ? `+${hidden} more open — mem_defer_list / \`defer list\` with a larger limit lists them`
+          : `+${hidden} more open — \`defer list --limit 100\` lists ${openTotal <= 100 ? 'them' : 'the first 100'}`,
+      );
     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,7 +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 } from './lib/hook-text-cap.mjs';
+import { writeCappedHookText, idsShownWhole } from './lib/hook-text-cap.mjs';
 
 /**
  * Build + emit the memory context block on stdout. Writes the Key Context ids
@@ -27,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) {
-      writeCappedHookText(`<claude-mem-context>\n${body}\n</claude-mem-context>`);
-    }
+    // 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
@@ -40,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. Every cached face (the SessionStart
+// banner, the throttled checkForUpdate and install.mjs `doctor`) asks this, so none can nag alone.
+export 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,8 +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 { writePlainHookText, resetPlainHookText } from './lib/hook-text-cap.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,
@@ -1565,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,
@@ -1745,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));
 
@@ -2861,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

package/install.mjs

@@ -2369,7 +2369,19 @@ async function doctor() {
       if (state.lastCheck) parts.push(`last check: ${state.lastCheck}`);
       if (state.latestVersion) parts.push(`latest: v${state.latestVersion}`);
       if (state.lastUpdate) parts.push(`last update: ${state.lastUpdate}`);
-      if (state.updateAvailable) parts.push('update pending');
+      // Judged against the version running now, like the banner (#35): in plugin mode
+      // nothing clears the cached flag once Claude Code has applied the update. Dynamic, as
+      // elsewhere in doctor, so a hook-update that cannot load costs only this judgement.
+      if (state.updateAvailable) {
+        let pending = true;
+        try {
+          const { pendingCachedUpdate } = await import('./hook-update.mjs');
+          pending = pendingCachedUpdate(state) !== null;
+        } catch {
+          /* cannot judge — report the cached flag as it stands */
+        }
+        if (pending) parts.push('update pending');
+      }
       if (state.rateLimited) parts.push('rate-limited');
       if (state.lastError) parts.push(`last error: ${state.lastError}`);
       ok(`Update state: ${parts.join(', ') || 'empty'}`);

package/lib/citation-tracker.mjs

@@ -103,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

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,29 @@ 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.
+ * A page already at the surface's maximum gets no `raise` advice: the reader cannot act on
+ * it (D#115 P3-7), so the line says which rows are missing instead.
+ * @param {Array<{open_total?: number}>} page rows from listOpenWithOrdinal
+ * @param {string} raise e.g. `raise --limit (max 100)`
+ * @param {number} [max] the surface's largest page
+ * @returns {string}
+ */
+export function formatDeferMoreHint(page, raise, max = Infinity) {
+  const hidden = page.length > 0 ? Number(page[0].open_total) - page.length : 0;
+  if (!(hidden > 0)) return '';
+  const head = `${hidden} more open item${hidden === 1 ? '' : 's'} not shown`;
+  if (page.length >= max) {
+    return `${head} — this is already the largest page (${max}); the rest sort last (lowest priority, then newest)`;
+  }
+  return `${head} — ${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}`;

package/lib/hook-stdout.mjs

@@ -236,7 +236,7 @@ export function flushHookStdout(deps = {}) {
   if (hasContext || hasInput) {
     envelope.hookSpecificOutput = { hookEventName: queuedEvent };
     if (hasInput) envelope.hookSpecificOutput.updatedInput = queuedInput;
-    if (hasContext) envelope.hookSpecificOutput.additionalContext = capHookText(parts.join('\n\n'));
+    if (hasContext) envelope.hookSpecificOutput.additionalContext = renderContext();
   }
   parts = [];
   queuedEvent = null;
@@ -246,6 +246,23 @@ export function flushHookStdout(deps = {}) {
   return true;
 }
 
+/** The additionalContext string the flush writes — one expression, shared with the preview. */
+function renderContext() {
+  return capHookText(parts.join('\n\n'));
+}
+
+/**
+ * The additionalContext the next flush will write, as it will be written — capped. A
+ * handler that books rendered rows (SessionStart's Key Context marker) reads this after its
+ * last queueHookContext, so it books only what the cap keeps (D#108). '' when nothing is
+ * queued for the model.
+ *
+ * @returns {string}
+ */
+export function previewHookContext() {
+  return queuedEvent && parts.length > 0 ? renderContext() : '';
+}
+
 /** Test seam: forget anything queued but not yet written. */
 export function resetHookStdout() {
   parts = [];

package/lib/hook-text-cap.mjs

@@ -134,16 +134,42 @@ export function capHookText(text, cap = HOOK_TEXT_CAP) {
   return out.length <= cap ? out : safeSlice(out, cap);
 }
 
+/**
+ * Which of `entries` reached the model WHOLE in `shown` (D#108).
+ *
+ * Every surface books what it injected — the dedup marker, `injection_count`, the Key
+ * Context marker — and must book only what the cap kept: a row booked but cut is
+ * suppressed for the dedup window as if it had been seen. An entry counts when all of its
+ * text survives as whole lines; a row cut short (`…`) or a multi-line item whose tail was
+ * dropped does not. Each surface's rows carry their own id, so one row's text cannot stand
+ * in for another's.
+ *
+ * @template T
+ * @param {string} shown What the writer actually emitted (the writers below return it).
+ * @param {Iterable<{id: T, text: string}>} entries Rendered items, in any order.
+ * @returns {T[]} ids of the entries shown whole, in `entries` order.
+ */
+export function idsShownWhole(shown, entries) {
+  const hay = `\n${String(shown ?? '')}\n`;
+  const out = [];
+  for (const e of entries || []) {
+    if (e && typeof e.text === 'string' && e.text !== '' && hay.includes(`\n${e.text}\n`)) out.push(e.id);
+  }
+  return out;
+}
+
 /**
  * Write ONE capped string as a hook's whole plain stdout (PreCompact's single block).
  *
  * @param {string} text
  * @param {{write?: (s: string) => void}} [deps]
- * @returns {void}
+ * @returns {string} What was written, without the trailing newline — feed it to idsShownWhole.
  */
 export function writeCappedHookText(text, deps = {}) {
   const write = deps.write || ((s) => process.stdout.write(s));
-  write(`${capHookText(text, HOOK_TEXT_CAP - 1)}\n`);
+  const out = capHookText(text, HOOK_TEXT_CAP - 1);
+  write(`${out}\n`);
+  return out;
 }
 
 // ── plain stdout, several chunks per handler ─────────────────────────────────────────
@@ -160,7 +186,8 @@ let plainUsed = 0;
  *
  * @param {string} text Chunk to write; a trailing newline is added.
  * @param {{write?: (s: string) => void, cap?: number}} [deps]
- * @returns {void}
+ * @returns {string} What was written, without the trailing newline ('' when nothing was) —
+ *   feed it to idsShownWhole before booking any row as delivered.
  */
 export function writePlainHookText(text, deps = {}) {
   const write = deps.write || ((s) => process.stdout.write(s));
@@ -169,16 +196,18 @@ export function writePlainHookText(text, deps = {}) {
   const remaining = cap - plainUsed;
   if (remaining > RESERVE) {
     // capHookText returns `body` unchanged when it fits, so this is also the common path.
-    const out = `${capHookText(body, remaining - 1)}\n`;
-    write(out);
-    plainUsed += out.length;
-    return;
+    const out = capHookText(body, remaining - 1);
+    write(`${out}\n`);
+    plainUsed += out.length + 1;
+    return out;
   }
-  const note = `${omissionFooter(body.split('\n').filter((l) => l.trim() !== ''))}\n`;
-  if (note.length <= remaining) {
-    write(note);
-    plainUsed += note.length;
+  const note = omissionFooter(body.split('\n').filter((l) => l.trim() !== ''));
+  if (note.length + 1 <= remaining) {
+    write(`${note}\n`);
+    plainUsed += note.length + 1;
+    return note;
   }
+  return '';
 }
 
 /**