claude-mem-lite 6.15.0 → 6.16.0

package/.claude-plugin/marketplace.json

@@ -9,10 +9,10 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "6.15.0",
+      "version": "6.16.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.16.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

@@ -237,6 +237,22 @@ rm -rf ~/claude-mem-lite/   # pre-v0.5 unhidden (if not auto-moved)
     repos/               # Shallow-cloned source repos
 ```
 
+## 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
@@ -1055,6 +1071,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_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

@@ -199,6 +199,20 @@ rm -rf ~/claude-mem-lite/   # v0.5 前的非隐藏目录（如未自动迁移）
     repos/               # 浅克隆的源代码仓库
 ```
 
+## 升级到 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 变更、不需要迁移，全部回退只需固定

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-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 } from './lib/hook-text-cap.mjs';
 
 /**
  * Build + emit the memory context block on stdout. Writes the Key Context ids
@@ -27,7 +28,7 @@ export function handlePreCompact({ db, project, sessionId, runtimeDir = RUNTIME_
     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`);
+      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

package/hook.mjs

@@ -99,6 +99,7 @@ import {
 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 { shouldRecallOnFailure } from './lib/tool-refusal.mjs';
 import {
   entryInputTags,
@@ -3040,7 +3041,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 +3252,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 +3273,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 +3282,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 +3313,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';
 /**
@@ -743,8 +744,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 +863,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/hook-stdout.mjs

@@ -89,6 +89,8 @@
 // about ONE channel. Before believing it for an event, find which field that event's
 // runner actually reads.
 
+import { capHookText } from './hook-text-cap.mjs';
+
 let parts = [];
 let queuedEvent = null;
 let systemParts = [];
@@ -226,14 +228,15 @@ export function flushHookStdout(deps = {}) {
   if (!hasContext && !hasInput && !hasSystem) return false;
   const write = deps.write || ((s) => process.stdout.write(s));
   const envelope = { suppressOutput: true };
-  if (hasSystem) envelope.systemMessage = systemParts.join('\n');
+  // Each field is capped on its own — the host measures them separately (hook-text-cap.mjs).
+  if (hasSystem) envelope.systemMessage = capHookText(systemParts.join('\n'));
   // Omitted entirely when there is nothing addressed to the host's per-event block:
   // Stop's schema REJECTS a hookSpecificOutput block, and an envelope carrying only a
   // user notice must not invent an event name to hang one on.
   if (hasContext || hasInput) {
     envelope.hookSpecificOutput = { hookEventName: queuedEvent };
     if (hasInput) envelope.hookSpecificOutput.updatedInput = queuedInput;
-    if (hasContext) envelope.hookSpecificOutput.additionalContext = parts.join('\n\n');
+    if (hasContext) envelope.hookSpecificOutput.additionalContext = capHookText(parts.join('\n\n'));
   }
   parts = [];
   queuedEvent = null;

package/lib/hook-text-cap.mjs

@@ -0,0 +1,191 @@
+// lib/hook-text-cap.mjs — keep every string the host injects under its 10,000-character cap.
+//
+// Claude Code's hooks reference (code.claude.com/docs/en/hooks, fetched 2026-09-27):
+//
+//   "A hook's `additionalContext`, `systemMessage`, and `initialUserMessage` strings, and its
+//    plain stdout, are capped at 10,000 characters … For JSON output, each field is measured
+//    separately; plain stdout is measured whole. Over the limit: Claude Code saves the output
+//    to a file in the session directory and replaces it with the file path and a preview of
+//    up to the first 2,000 characters … Claude Code doesn't ask Claude to read the file."
+//
+// So an over-long injection is not cut at 10,000 — it collapses to a 2,000-character preview
+// and the model is never told to fetch the rest. Trimming here, by whole lines, keeps ~9,500
+// characters in context instead of 2,000, and says which ids were dropped.
+//
+// Two entry points, one per delivery channel:
+//   • capHookText(text)        — a single string (an envelope field, PreCompact's one write);
+//   • writePlainHookText(text) — plain stdout written in several chunks by one process
+//                                (UserPromptSubmit), measured whole by the host, so the
+//                                budget is per HANDLER, not per call.
+
+/** The host's documented per-field / whole-plain-stdout cap. */
+export const HOOK_TEXT_CAP = 10_000;
+
+// Content stops RESERVE characters short of the cap so the omission footer and any closing
+// tags re-appended for blocks cut open fit. Sized, not proven: MAX_FOOTER_IDS bounds the id
+// COUNT, not their length, and nothing bounds the tag nesting. For what the surfaces emit
+// (ids of a few digits, one or two nested blocks) the tail is under ~250 characters; a longer
+// one is still held under the cap by the final safeSlice, at the cost of the re-closed tags.
+const RESERVE = 500;
+const MAX_FOOTER_IDS = 12;
+
+// Ids as every injection surface renders them: `#12`, `E#34`, `D#5`, `P#820`.
+const ID_RE = /(?<![\w#])((?:[A-Z])?#\d+)\b/g;
+const OPEN_TAG_RE = /^<([a-z][\w-]*)(?:\s[^>]*)?>$/;
+const CLOSE_TAG_RE = /^<\/([a-z][\w-]*)>$/;
+
+function idsIn(lines) {
+  const seen = new Set();
+  for (const line of lines) for (const m of line.matchAll(ID_RE)) seen.add(m[1]);
+  return [...seen];
+}
+
+/**
+ * @param {string[]} droppedLines whole lines not shown
+ * @param {string} [cutRest] the tail of a line that was cut short, when one was
+ */
+function omissionFooter(droppedLines, cutRest = '') {
+  const ids = idsIn(cutRest ? [cutRest, ...droppedLines] : droppedLines);
+  const shown = ids.slice(0, MAX_FOOTER_IDS).join(', ');
+  const more = ids.length > MAX_FOOTER_IDS ? ` +${ids.length - MAX_FOOTER_IDS} more` : '';
+  const idPart = ids.length ? ` (ids: ${shown}${more})` : '';
+  const what = [
+    cutRest ? 'a line was cut short' : '',
+    droppedLines.length ? `${droppedLines.length} more line(s) not shown` : '',
+  ]
+    .filter(Boolean)
+    .join(', ');
+  return `[claude-mem-lite] ${what} — hook output limit${idPart}`;
+}
+
+/** `s` cut to at most `n` UTF-16 units without leaving half of a surrogate pair. */
+function safeSlice(s, n) {
+  if (n <= 0) return '';
+  if (s.length <= n) return s;
+  const c = s.charCodeAt(n - 1);
+  return s.slice(0, c >= 0xd800 && c <= 0xdbff ? n - 1 : n);
+}
+
+/**
+ * Trim `text` to at most `cap` characters by dropping whole lines from the end.
+ *
+ * Lines are kept from the top (every surface renders its highest-ranked rows first), a
+ * footer names what was dropped, and any `<tag>` block whose closing line was dropped is
+ * closed again so the kept text still parses as the block it claims to be. A text already
+ * within `cap` is returned unchanged.
+ *
+ * @param {string} text
+ * @param {number} [cap] Hard ceiling for the returned string.
+ * @returns {string}
+ */
+export function capHookText(text, cap = HOOK_TEXT_CAP) {
+  const s = String(text ?? '');
+  if (s.length <= cap) return s;
+  const budget = Math.max(0, cap - RESERVE);
+  const lines = s.split('\n');
+  const kept = [];
+  const open = [];
+  let used = 0;
+  let i = 0;
+  for (; i < lines.length; i++) {
+    const add = lines[i].length + (kept.length ? 1 : 0);
+    if (used + add > budget) break;
+    kept.push(lines[i]);
+    used += add;
+    const o = lines[i].match(OPEN_TAG_RE);
+    const c = lines[i].match(CLOSE_TAG_RE);
+    if (o) open.push(o[1]);
+    else if (c && open[open.length - 1] === c[1]) open.pop();
+  }
+  // A first line longer than the whole budget would otherwise leave nothing at all. It is cut
+  // with a visible ellipsis and the footer says so: a lesson or an instruction cut mid-sentence
+  // with no marker reads as complete (pre-ship review P3-1).
+  let cutRest = '';
+  if (kept.length === 0 && lines.length > 0) {
+    let head = safeSlice(lines[0], budget - 1);
+    // Back off to a word boundary when the cut lands inside a token, so an id is never shown
+    // half (`#424…`) and the footer, which reads ids from the cut part, gets it whole.
+    if (/[\w#]$/.test(head) && /^[\w#]/.test(lines[0].slice(head.length))) {
+      const sp = head.search(/\s\S*$/);
+      if (sp > 0) head = head.slice(0, sp + 1);
+    }
+    kept.push(`${head}…`);
+    cutRest = lines[0].slice(head.length);
+    i = 1;
+  }
+  // A closing line re-appended below is not "not shown"; count it out of the footer.
+  const reclosed = new Map();
+  for (const t of open) reclosed.set(t, (reclosed.get(t) || 0) + 1);
+  const dropped = lines.slice(i).filter((l) => {
+    if (l.trim() === '') return false;
+    const c = l.match(CLOSE_TAG_RE);
+    if (c && reclosed.get(c[1]) > 0) {
+      reclosed.set(c[1], reclosed.get(c[1]) - 1);
+      return false;
+    }
+    return true;
+  });
+  const tail = [];
+  if (dropped.length || cutRest) tail.push(omissionFooter(dropped, cutRest));
+  for (let k = open.length - 1; k >= 0; k--) tail.push(`</${open[k]}>`);
+  const out = [...kept, ...tail].join('\n');
+  // "Never over cap" holds regardless; the slice fires only for a tail RESERVE did not cover
+  // (see RESERVE) or a caller passing a cap smaller than RESERVE.
+  return out.length <= cap ? out : safeSlice(out, cap);
+}
+
+/**
+ * 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}
+ */
+export function writeCappedHookText(text, deps = {}) {
+  const write = deps.write || ((s) => process.stdout.write(s));
+  write(`${capHookText(text, HOOK_TEXT_CAP - 1)}\n`);
+}
+
+// ── plain stdout, several chunks per handler ─────────────────────────────────────────
+
+let plainUsed = 0;
+
+/**
+ * Write a chunk of plain hook stdout, keeping the HANDLER's total under the cap.
+ *
+ * The host measures plain stdout whole, so two blocks that each fit can still overflow
+ * together. A chunk that no longer fits is trimmed by capHookText to what is left; once the
+ * budget is spent, later chunks are reduced to a one-line omission note while room for one
+ * remains, and dropped after that.
+ *
+ * @param {string} text Chunk to write; a trailing newline is added.
+ * @param {{write?: (s: string) => void, cap?: number}} [deps]
+ * @returns {void}
+ */
+export function writePlainHookText(text, deps = {}) {
+  const write = deps.write || ((s) => process.stdout.write(s));
+  const cap = deps.cap ?? HOOK_TEXT_CAP;
+  const body = String(text ?? '');
+  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 note = `${omissionFooter(body.split('\n').filter((l) => l.trim() !== ''))}\n`;
+  if (note.length <= remaining) {
+    write(note);
+    plainUsed += note.length;
+  }
+}
+
+/**
+ * Start a new plain-stdout budget. Called at the top of each handler that writes through
+ * writePlainHookText: one handler invocation is one hook output, and in-process callers
+ * (tests, the dispatcher) may run several.
+ */
+export function resetPlainHookText() {
+  plainUsed = 0;
+}

package/lib/recall-framing.mjs

@@ -0,0 +1,86 @@
+// lib/recall-framing.mjs — the first line of a PreToolUse / PostToolUse recall block, in two arms.
+//
+// The legacy line announces itself as "system-injected context, continue your planned
+// action". It was added in v2.40.0, modelled on the #7758 fix (a handoff injection misread
+// as a user message): without a "this is context, not a new request" signal the model
+// sometimes ended its turn after an Edit + reminder. Claude Code's hooks reference
+// (code.claude.com/docs/en/hooks, fetched 2026-09-27) now warns against exactly this shape:
+//
+//   "Write the text as factual statements rather than imperative system instructions …
+//    Text framed as out-of-band system commands can trigger Claude's prompt-injection
+//    defenses, which causes Claude to surface the text to you instead of treating it as
+//    context."
+//
+// PreToolUse is the best-cited face on record (56.2% over 7 days, 2026-09-27), so the wording
+// is not swapped on the documentation's say-so. The factual arm keeps that line's point as a
+// statement ("the tool call proceeds as planned") and the two arms run side by side, assigned
+// per SESSION, so one walk over one corpus compares them (doctrine rule 2: never diff two runs
+// taken at different times). benchmark/citation-live-replay.mjs `--by-framing` reads the arm
+// back from the injected text itself, which stays correct across the deploy boundary.
+//
+// CLAUDE_MEM_RECALL_FRAMING = ab (default) | legacy | factual.
+
+const LEGACY_TAIL = 'system-injected context, continue your planned action:';
+// The substring classifyRecallFraming keys on. Part of the factual line only.
+const FACTUAL_MARK = 'notes recorded by claude-mem-lite';
+// The shape both arms' first line shares: `[mem] PreToolUse recall — …` / `[mem] PostToolUse recall — …`.
+const FRAMING_LINE_RE = /^\[mem\] (?:PreToolUse|PostToolUse) recall — /;
+
+/**
+ * Which arm this session gets.
+ *
+ * `ab` splits on a stable hash of the session id, so every recall block of one session uses
+ * one wording (a per-call coin would mix both into every session and leave nothing to
+ * compare). No session id → legacy: the arm must be attributable, and a block with no
+ * session cannot be.
+ *
+ * @param {string|null|undefined} sessionId
+ * @param {Record<string, string|undefined>} [env]
+ * @returns {'legacy'|'factual'}
+ */
+export function recallFramingArm(sessionId, env = process.env) {
+  const mode = String(env.CLAUDE_MEM_RECALL_FRAMING || 'ab')
+    .trim()
+    .toLowerCase();
+  if (mode === 'legacy' || mode === 'factual') return mode;
+  if (!sessionId) return 'legacy';
+  // FNV-1a, 32-bit: stable across processes and Node versions, unlike anything keyed on
+  // object identity or Math.random.
+  let h = 0x811c9dc5;
+  for (const ch of String(sessionId)) {
+    h ^= ch.codePointAt(0);
+    h = Math.imul(h, 0x01000193) >>> 0;
+  }
+  return h % 2 === 0 ? 'legacy' : 'factual';
+}
+
+/**
+ * The framing line for one recall block.
+ *
+ * @param {'PreToolUse'|'PostToolUse'} face
+ * @param {{sessionId?: string|null, fname?: string, env?: Record<string, string|undefined>}} [opts]
+ * @returns {string}
+ */
+export function recallFramingLine(face, { sessionId = null, fname = '', env = process.env } = {}) {
+  if (recallFramingArm(sessionId, env) === 'legacy') return `[mem] ${face} recall — ${LEGACY_TAIL}`;
+  const subject = fname ? ` about ${fname}` : '';
+  return `[mem] ${face} recall — ${FACTUAL_MARK}${subject}; the tool call proceeds as planned:`;
+}
+
+/**
+ * Read the arm back from injected text (the A/B ruler's side).
+ *
+ * @param {string} text One hook attachment's text.
+ * @returns {'legacy'|'factual'|null} null when the text carries neither framing line.
+ */
+export function classifyRecallFraming(text) {
+  // Only the framing line itself counts. The block also carries lesson bodies, and a lesson
+  // that quotes either wording (one about this very A/B, say) must not relabel the session
+  // (pre-ship review P3-8).
+  for (const line of String(text ?? '').split('\n')) {
+    if (!FRAMING_LINE_RE.test(line)) continue;
+    if (line.endsWith(LEGACY_TAIL)) return 'legacy';
+    if (line.includes(FACTUAL_MARK)) return 'factual';
+  }
+  return null;
+}

package/lib/time-constants.mjs

@@ -36,3 +36,12 @@ export const DAY_MS = 24 * HOUR_MS;
  * printing "✓ Removed" — and `doctor` recommends running `cleanup`.
  */
 export const ORPHAN_EPISODE_AGE_MS = HOUR_MS;
+
+/**
+ * PreToolUse recall's hard age cut: observations and events created longer ago than this
+ * are never surfaced by file, whatever their later use. Set without a measurement, and it
+ * first bites on 2026-11-04 on the maintainer DB (oldest live row 2026-09-05). Shared with
+ * benchmark/cutoff-reach-probe.mjs, which counts the rows it removes, so the probe reads the
+ * shipped window rather than a copy of it.
+ */
+export const PRETOOL_LOOKBACK_MS = 60 * DAY_MS;

package/mem-cli.mjs

@@ -1825,7 +1825,14 @@ function cmdContext(db, args) {
     // produce (the CLI twin of why <skill-loaded> is excluded from CONTEXT_DELIMITER_RE).
     // The untrusted half is already neutralized one layer up: buildSessionContextLines
     // defangs every row it renders, so only the trusted wrapper is written raw here.
-    outVerbatim(`<claude-mem-context>\n${block}\n</claude-mem-context>`);
+    const wrapped = `<claude-mem-context>\n${block}\n</claude-mem-context>`;
+    outVerbatim(wrapped);
+    if (flags.chars) {
+      // stderr, so stdout stays byte-for-byte the block. This is the <claude-mem-context>
+      // part only: SessionStart also prepends the startup dashboard to the same field, and
+      // lib/hook-text-cap.mjs trims the whole field at the cap.
+      process.stderr.write(`[mem] context: ${wrapped.length} characters (hook cap ${HOOK_TEXT_CAP})\n`);
+    }
   }
 }
 
@@ -3273,7 +3280,7 @@ Commands:
                           daily_activity,data_health,tier_distribution})
                         or quality shape when --quality --json combined
 
-  context               Show current CLAUDE.md context block
+  context               Show the SessionStart context block (--chars: its size vs the hook cap, on stderr)
     --json              Output as structured JSON
 
   browse                Tier-grouped memory dashboard
@@ -3623,6 +3630,7 @@ import { cmdActivity } from './cli/activity.mjs';
 import { cmdVerifyApply } from './cli/verify-apply.mjs';
 
 import { DAY_MS } from './lib/time-constants.mjs';
+import { HOOK_TEXT_CAP } from './lib/hook-text-cap.mjs';
 // ─── Main Entry Point ────────────────────────────────────────────────────────
 
 /**

package/npm-shrinkwrap.json

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

package/package.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.16.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).",
   "type": "module",
   "packageManager": "npm@10.9.2",
   "engines": {
@@ -116,6 +116,8 @@
     "lib/hook-stdin.mjs",
     "lib/plugin-key.mjs",
     "lib/hook-stdout.mjs",
+    "lib/hook-text-cap.mjs",
+    "lib/recall-framing.mjs",
     "lib/proc-lock.mjs",
     "lib/atomic-write.mjs",
     "lib/platform-gate.mjs",

package/scripts/post-tool-recall.js

@@ -31,6 +31,7 @@ import { queueHookContext, flushHookStdout } from '../lib/hook-stdout.mjs';
 import { readHookStdin, TOOL_INPUT_FILE_MAX_BYTES } from '../lib/hook-stdin.mjs';
 import { cooldownPathFor as sharedCooldownPathFor } from '../lib/cooldown-path.mjs';
 import { toolEditPath } from '../lib/file-edge-match.mjs';
+import { recallFramingLine } from '../lib/recall-framing.mjs';
 
 const SALIENCE_BIND = process.env.CLAUDE_MEM_SALIENCE === 'bind';
 
@@ -95,7 +96,7 @@ async function main() {
   }
   if (!dropped.length) return;
 
-  const lines = ['[mem] PostToolUse recall — system-injected context, continue your planned action:'];
+  const lines = [recallFramingLine('PostToolUse', { sessionId, fname: basename(filePath) })];
   for (const d of dropped.slice(0, 3)) {
     lines.push(
       `[mem] ⚠ your edit to ${basename(filePath)} dropped \`${d.token}\` flagged by #${d.obsId} — if intentional say so, else re-check before moving on.`,

package/scripts/pre-tool-recall.js

@@ -34,6 +34,7 @@ import { shouldWarnReread, buildRereadWarning, readFileMeta } from '../lib/rerea
 import { recordMetric } from '../lib/metrics.mjs';
 import { presentIdents } from '../lib/lesson-idents.mjs';
 import { neutralizeContextDelimiters } from '../format-utils.mjs';
+import { recallFramingLine } from '../lib/recall-framing.mjs';
 // D#154: the one stdout writer. This script has THREE emit sites (Read→Edit ack,
 // repeated-read guard, lesson block) and they stay one document because each branch
 // process.exit()s before reaching the next.
@@ -66,7 +67,7 @@ import { readHookStdin, TOOL_INPUT_FILE_MAX_BYTES, salvageTruncatedHookEvent } f
 // only — cheaper than several imports this script already carries.
 import { inferProject, inferProjectDir } from '../project-utils.mjs';
 
-import { DAY_MS } from '../lib/time-constants.mjs';
+import { PRETOOL_LOOKBACK_MS } from '../lib/time-constants.mjs';
 // CLAUDE_MEM_DIR matches schema.mjs / main CLI — one env var sandboxes the
 // whole system. CLAUDE_MEM_DB_PATH / CLAUDE_MEM_RUNTIME_DIR remain as
 // per-component overrides for tests that mix isolated + real paths.
@@ -525,7 +526,7 @@ try {
         queueHookContext(
           'PreToolUse',
           [
-            '[mem] PreToolUse recall — system-injected context, continue your planned action:',
+            recallFramingLine('PreToolUse', { sessionId, fname: basename(filePath) }),
             `[mem] ⚠ Lessons ${idList} were shown when you Read ${basename(filePath)} — ${ACTIVE_DIRECTIVE}`,
           ].join('\n'),
         );
@@ -540,7 +541,7 @@ try {
           queueHookContext(
             'PreToolUse',
             [
-              '[mem] PreToolUse recall — system-injected context, continue your planned action:',
+              recallFramingLine('PreToolUse', { sessionId, fname: basename(filePath) }),
               buildRereadWarning(basename(filePath), entry.reread.tokens),
             ].join('\n'),
           );
@@ -613,8 +614,9 @@ try {
     // Stop-side edge attribution so trigger and resolver can never drift.
     const fileMatch = fileMatchClause('of2');
     const fileParams = fileMatchParams(filePath);
-    // 60-day lookback to avoid surfacing ancient observations
-    const cutoff = Date.now() - 60 * DAY_MS;
+    // 60-day lookback to avoid surfacing ancient observations (PRETOOL_LOOKBACK_MS;
+    // benchmark/cutoff-reach-probe.mjs counts what it removes)
+    const cutoff = Date.now() - PRETOOL_LOOKBACK_MS;
 
     // Surface actionable lessons first, then high-importance bugfix/decision observations.
     // Priority: 1) observations with lesson_learned (most actionable for preventing repeat bugs)
@@ -829,9 +831,10 @@ try {
       hasLessons || Boolean(fileIntelLine) || (!isRead && process.env.CLAUDE_MEM_PRETOOL_NUDGE === '1');
     if (showFraming) {
       // Framing line mirrors #7758 handoff-injection fix: without an explicit
-      // "system-injected, continue" disclaimer, observed turn-end after Edit+reminder
-      // when the model misreads passive lesson context as a closing note.
-      lines.push(`[mem] PreToolUse recall — system-injected context, continue your planned action:`);
+      // "this is context, the call continues" line, observed turn-end after Edit+reminder
+      // when the model misreads passive lesson context as a closing note. Two wordings
+      // run side by side per session — lib/recall-framing.mjs.
+      lines.push(recallFramingLine('PreToolUse', { sessionId, fname }));
     }
     // MED-1 (full audit 2026-07-16): defang the injection-block delimiters in
     // all DB/file-derived text before it enters additionalContext (which CC wraps

package/scripts/user-prompt-search.js

@@ -48,6 +48,7 @@ import { isSchemaSkewError, schemaSkewFromError, shouldRecordSkew } from '../lib
 
 import { DAY_MS } from '../lib/time-constants.mjs';
 import { envNumber } from '../lib/env-number.mjs';
+import { writePlainHookText, resetPlainHookText } from '../lib/hook-text-cap.mjs';
 // ─── Constants ──────────────────────────────────────────────────────────────
 
 // Telemetry sink (lib/hook-telemetry.mjs contract): env override for tests, else
@@ -697,6 +698,7 @@ function formatPromptResults(rows) {
 // ─── Main ───────────────────────────────────────────────────────────────────
 
 async function main() {
+  resetPlainHookText();
   // Prevent recursion from background claude -p calls
   if (process.env.CLAUDE_MEM_HOOK_RUNNING) return;
 
@@ -786,7 +788,7 @@ async function main() {
             for (const dl of neutralizeContextDelimiters(r.detail).split('\n')) lines.push(`  ${dl}`);
           }
         }
-        process.stdout.write(lines.join('\n') + '\n');
+        writePlainHookText(lines.join('\n'));
         // Merge into the dedup file so a re-referencing prompt within the stale
         // window skips re-injection. A later FTS-path write replaces ids wholesale
         // (accepted: worst case is one cheap re-injection after an obs-emitting
@@ -1078,7 +1080,7 @@ async function main() {
         : formatPromptResults(promptRows)
       : null;
     if (output) {
-      process.stdout.write(output + '\n');
+      writePlainHookText(output);
       // Write injected IDs for dedup with hook.mjs handleUserPrompt + self-dedup
       // replace, NOT union: this leg writes the prompt's own result set wholesale, and it
       // is the ONE writer that puts raw observation numbers (mixed with `P<id>` strings)

package/source-files.mjs

@@ -150,6 +150,8 @@ export const SOURCE_FILES = [
   'lib/hook-stdin.mjs',
   'lib/plugin-key.mjs',
   'lib/hook-stdout.mjs',
+  'lib/hook-text-cap.mjs',
+  'lib/recall-framing.mjs',
   // audit P0/P1: inter-process install lock + atomic config writes — imported by
   // install.mjs (settings.json + install lock) and hook-update.mjs (.claude.json
   // + auto-update lock). Must ship or a partial install/update skips them.